je eden najvidnejših trendov v računalništvu v oblaku. Osnovno načelo delovanja je, da infrastruktura ni skrb DevOps, temveč ponudnika storitev. Skaliranje virov se samodejno prilagaja obremenitvi in ima visoko stopnjo sprememb.
Druga skupna značilnost je težnja po minimiziranju in osredotočanju kode, zaradi česar se brezstrežniško računalništvo včasih imenuje funkcija kot storitev (FaaS).
Zgodovinsko gledano je bil prvi ponudnik oblakov, ki je ponudil FaaS z AWS Lambda, Amazon, od tod tudi ime. Podobne ponujajo tudi drugi ponudniki storitev v oblaku:
- Googlove funkcije v oblaku
- Microsoftove funkcije Azure
Vsa ta podjetja zagotavljajo brezstrežniško računalništvo, samodejno skaliranje in plačajo samo tisto, kar dejansko uporabljate, vendar stranke zaklenejo v svoj lastniški izdelek. Vendar pa obstajajo brezplačne in odprtokodne alternative za brezstrežniško računalništvo. Omeniti velja:
- Platforma , ki ga je v inkubatorju razvil IBM,
- , kot del dokaj bogatega ekosistema Spring Framework, ki se lahko uporablja tudi kot fasada za AWS Lambda, Azure Functions in OpenWhisk,
- , ki ga podpira Oracle.
Vsi so popolnoma neodvisni od oblakov, torej jih je mogoče namestiti v poljuben oblak, tudi svojega, javnega ali zasebnega, in seveda v Exoscale.
Kako deluje projekt Fn
Fn v celoti temelji na Dockerju in je sestavljen iz dveh glavnih komponent:
- Program CLI, zasnovan za upravljanje vseh vidikov infrastrukture Fn in interakcijo s strežnikom Fn,
- Sam strežnik Fn je običajna aplikacija, pakirana v vsebniku Docker.
Funkcije, nameščene v Fn, se prav tako izvajajo v ločenih vsebnikih, kar vam omogoča podporo številnih programskih jezikov, na primer ... Clojure!
Funkcijski argumenti se posredujejo v standardni vhod (STDIN), rezultati se zapišejo v standardni izhod (STDOUT). Če argumenti ali vrnjene vrednosti niso enostavne vrednosti (kot je objekt JSON), jih je mogoče pretvoriti z uporabo abstraktne plasti, ki jo zagotovi sam Fn v obliki kompleta za razvoj funkcij (FDK).
Za udobje so na voljo vgrajeni nabori predlog, ki olajšajo uvajanje FaaS v obsežnem seznamu različnih jezikov in njihovih različic (Go, različne različice Jave, Python itd.).
Ustvarjanje FaaS je preprosto z upoštevanjem tega diagrama:
- Razmestitev funkcije z uporabo Fn CLI: konfiguracijska datoteka aplikacije za Fn se ustvari na podlagi izbrane predloge.
- Razvijemo lastno funkcijo, spet z uporabo CLI Fn: slika vsebnika se postavi v določeno skladišče, nato pa je strežnik obveščen o obstoju in postavitvi te slike.
Načelo dostave funkcij Fn
Lokalna namestitev in testiranje brezstrežniških funkcij
Začnimo nameščati Fn na lokalni računalnik. Najprej je nameščen Docker, kot zahteva Fn. Ob predpostavki, da uporabljamo Debian/Ubuntu:
$ sudo apt-get update
$ sudo apt-get install docker.ioAli pa uporabite gradnjo upravitelja paketov/Docker v skladu z vašim sistemom. Nato lahko nadaljujete neposredno z namestitvijo Fn CLI. Na primer z uporabo curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shČe uporabljate OS X z nameščenim Homebrew, lahko greste drugače:
$ brew install fn
==> Downloading https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Downloading from https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Pouring fn-0.5.8.high_sierra.bottle.tar.gz
/usr/local/Cellar/fn/0.5.8: 5 files, 16.7MBZdaj smo pripravljeni na prvotno uvedbo naše funkcije z uporabo CLI. Zaradi enostavnosti bomo uporabili vgrajeno okolje za zagon, kot je Node:
$ fn init --runtime node --trigger http hellonode
Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.Ustvaril se bo nov imenik hellonode za nadaljnji razvoj naše funkcije Fn z nekaj osnovnimi konfiguracijskimi datotekami. Znotraj novo ustvarjenega imenika lahko ustvarite svojo aplikacijo po standardih izbranega jezika ali izvajalnega okolja:
# Каталог с node выглядит так:
hellonode
├── func.js
├── func.yaml
└── package.json
# Свежеустановленное окружение Java11 такое:
hellojava11
├── func.yaml
├── pom.xml
└── src
├── main
│ └── java
│ └── com
│ └── example
│ └── fn
│ └── HelloFunction.java
└── test
└── java
└── com
└── example
└── fn
└── HelloFunctionTest.javaFn ustvari začetno strukturo projekta, ustvari datoteko func.yaml, ki vsebuje potrebne nastavitve za Fn, in nastavi predlogo za kodo v jeziku, ki ste ga izbrali.
V primeru izvajalnega okolja Node to pomeni:
$ cat hellonode/func.js
const fdk=require('@fnproject/fdk');
fdk.handle(function(input){
let name = 'World';
if (input.name) {
name = input.name;
}
return {'message': 'Hello ' + name}
})Zdaj bomo našo funkcijo hitro preizkusili lokalno, da vidimo, kako vse deluje.
Najprej bomo zagnali strežnik Fn. Kot že omenjeno, je strežnik Fn vsebnik Docker, zato bo po zagonu šel in vzel sliko iz registra Docker.
$ fn start -d # запускаем локальный сервер в фоне
Unable to find image 'fnproject/fnserver:latest' locally
latest: Pulling from fnproject/fnserver
ff3a5c916c92: Pull complete
1a649ea86bca: Pull complete
ce35f4d5f86a: Pull complete
...
Status: Downloaded newer image for fnproject/fnserver:latest
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Če želite zagnati našo funkcijo, jo morate "razviti". To zahteva имя приложения: V Fn morajo biti vse aplikacije navedene kot imenski prostori za povezane funkcije.
Fn CLI bo poiskal datoteko func.yaml v trenutnem imeniku, ki bo uporabljen za konfiguracijo funkcije. Torej, najprej morate iti v naš imenik hellonode.
$ cd hellonode
$ fn deploy --app fnexo --local # выкатываем функцию локально, имя приложения - fnexo.
# параметр local не заливает образ в удаленный реестр,
# запуская его напрямую
Deploying hellonode to app: fnexo
Bumped to version 0.0.2
Building image nfrankel/hellonode:0.0.3 .
Updating function hellonode using image nfrankel/hellonode:0.0.3...
Successfully created app: fnexo
Successfully created function: hellonode with nfrankel/hellonode:0.0.3
Successfully created trigger: hellonode-triggerKot lahko vidite iz izhoda ukaza, je ustvarjena nova slika vsebnika Docker, ki vsebuje našo funkcijo. Funkcija je pripravljena za klic in imamo dva načina za to:
- z uporabo ukaza Fn
invoke - kliče neposredno prek
http
Izziv invoke prek Fn preprosto emulira delo prek HTTP za teste, kar je priročno za hitro testiranje:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}Če želite neposredno poklicati funkcijo, morate poznati celoten URL:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Strežnik Fn izpostavi svoje funkcije na vratih 8080 in zdi se, da URL funkcije ustreza vzorcu t/app/function, vendar ne v celoti. Preko HTTP-ja se funkcija ne kliče neposredno, temveč preko tako imenovanega sprožilca, ki v skladu z imenom “začne” klic funkcije. Sprožilci so definirani v `func.yml projekt:
schema_version: 20180708
name: hellonode
version: 0.0.3
runtime: node
entrypoint: node func.js
format: json
triggers:
- name: hellonode-trigger
type: http
source: /hellonode-trigger # URL триггераIme sprožilca lahko spremenimo tako, da se ujema z imenom funkcije, kar bo vse poenostavilo:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииNato znova zaženemo dostavo funkcije in jo pokličemo iz novega sprožilca:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Vse deluje! Čas je, da nadaljujemo s poskusi v polnem obsegu in objavimo naš FaaS na strežniku!
Namestitev brezstrežniških funkcijskih storitev na lastno infrastrukturo
Hitro namestimo virtualni stroj z uporabo Exoscale CLI. Če ga še niste nastavili, lahko uporabite . To je kul orodje, ki bo še povečalo vašo produktivnost. Ne pozabite, da morate konfigurirati pravilo za odpiranje vrat 8080 v varnostni skupini! Naslednji ukazi bodo zagnali čisti virtualni stroj, pripravljen za gostovanje naših funkcij:
$ exo firewall create fn-securitygroup
$ exo firewall add fn-securitygroup ssh --my-ip
$ exo firewall add fn-securitygroup -p tcp -P 8080-8080 -c 0.0.0.0/0
$ exo vm create fn-server -s fn-securitygroupNato lahko ssh v virtualni stroj in namestite oddaljeni strežnik Fn:
$ exo ssh fn-server
The authenticity of host '185.19.30.175 (185.19.30.175)' can't be established.
ECDSA key fingerprint is SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '185.19.30.175' (ECDSA) to the list of known hosts.
Welcome to Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)Nato namestite Docker in strežnik Fn na enak način, kot ste že naredili na lokalnem računalniku, zaženite strežnik:
$ sudo apt-get update
$ sudo apt-get install docker.io
$ sudo systemctl start docker
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
$ sudo fn start
...
______
/ ____/___
/ /_ / __
/ __/ / / / /
/_/ /_/ /_/
v0.3.643Fn je pripravljen na sprejemanje funkcij! Za ciljni prenos funkcij na oddaljeni strežnik bomo uporabili ukaz deploy iz lokalnega računalnika tako, da izpustite zastavico --local.
Poleg tega Fn zahteva, da določite lokacijo strežnika Fn in registra Docker. Te možnosti je mogoče nastaviti prek spremenljivk okolja FN_API_URL и FN_REGISTRY ponuja pa tudi bolj priročen način za preprosto upravljanje ustvarjanja in upravljanja konfiguracij za uvajanje.
V izrazih Fn se imenuje konfiguracija za uvajanje context. Naslednji ukaz bo ustvaril kontekst:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelRazpoložljive kontekste si lahko ogledate takole:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
In preklopite na kontekst, ki je bil pravkar ustvarjen takole:
$ fn use context exoscale
Now using context: exoscaleOd tu naprej bo dostava funkcije Fn prenesla slike Docker z uporabo izbranega računa DockerHub (v mojem primeru - nfrankel) in nato obvestite oddaljeni strežnik (v tem primeru - http://185.19.30.175:8080) o lokaciji in različici najnovejše slike, ki vsebuje vašo funkcijo.
$ fn deploy --app fnexo . # выполняется на локальной машине из каталога hellonode
Deploying function at: /.
Deploying hellonode to app: fnexo
Bumped to version 0.0.5
Building image nfrankel/hellonode:0.0.5 .Končno:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Življenjski cikel funkcije v brezstrežniškem računalništvu na osnovi Fn
Prednosti brezstrežniškega računalništva z lastnimi zmogljivostmi
Brezstrežniško računalništvo je priročna rešitev za hitro implementacijo neodvisnih delov aplikacije, ki komunicirajo s kompleksnejšimi aplikacijami ali mikrostoritvami.
To je pogosto posledica skritih stroškov vezave na izbranega prodajalca, kar lahko, odvisno od posebnega primera uporabe in obsega, povzroči višje stroške in zmanjšano prilagodljivost v prihodnosti.
V tem primeru trpijo tudi večoblačne in hibridne oblačne arhitekture, saj se zlahka znajdete v situaciji, ko bi radi uporabljali brezstrežniško računalništvo, vendar zaradi korporativnih politik to morda ne bo mogoče.
Fn je zelo enostaven za uporabo in lahko zagotovi skoraj enak vmesnik FaaS, z malo dodatnih stroškov. Odpravlja kakršno koli zaklepanje prodajalca in ga je mogoče namestiti lokalno ali pri katerem koli priročnem ponudniku rešitev v oblaku po vaši izbiri. Obstaja tudi svoboda pri izbiri programskega jezika.
Ta članek pokriva samo osnove Fn, vendar je ustvarjanje lastnega izvajalnega okolja precej preprosto, celotno arhitekturo pa je mogoče uporabiti širše z uporabo izravnalnika obremenitve Fn ali tako, da Fn postavite za proxy za zaščito.
Vir: www.habr.com