yra viena ryškiausių debesų kompiuterijos tendencijų. Pagrindinis veikimo principas yra tas, kad infrastruktūra yra ne DevOps, o paslaugos teikėjo rūpestis. Išteklių mastelio keitimas automatiškai prisitaiko prie apkrovos ir turi didelį pokyčių greitį.
Kitas bendras bruožas yra tendencija sumažinti ir sutelkti kodą, todėl kompiuterija be serverio kartais vadinama funkcija kaip paslauga (FaaS).
Istoriškai pirmasis debesų tiekėjas, pasiūlęs FaaS su AWS Lambda, buvo „Amazon“, taigi ir pavadinimas. Kiti debesies paslaugų teikėjai taip pat siūlo panašius:
- „Google“ teikiamos debesies funkcijos
- Azure Functions iš Microsoft
Visos šios įmonės teikia kompiuterius be serverių, automatinį mastelio keitimą ir moka tik už tai, ką iš tikrųjų naudojate, tačiau jos užrakina klientus į savo patentuotą produktą. Tačiau yra nemokamų atvirojo kodo alternatyvų kompiuteriams be serverių. Tai nieko neverta:
- Platforma , sukurtas IBM inkubatoriuje,
- , kaip gana turtingos Spring Framework ekosistemos dalis, kuri taip pat gali būti naudojama kaip AWS Lambda, Azure Functions ir OpenWhisk fasadas,
- , palaikomas „Oracle“.
Visi jie yra visiškai nepriklausomi nuo debesų, tai yra, juos galima įdiegti bet kuriame debesyje, įskaitant savo, viešą ar privatų, ir, žinoma, Exoscale.
Kaip veikia Fn projektas
Fn yra visiškai pagrįstas Docker, susideda iš dviejų pagrindinių komponentų:
- CLI programa, skirta valdyti visus Fn infrastruktūros aspektus ir sąveikauti su Fn serveriu,
- Pats Fn serveris yra įprasta programa, supakuota į Docker konteinerį.
Fn įdiegtos funkcijos taip pat vykdomos atskiruose konteineriuose, o tai leidžia palaikyti daugybę programavimo kalbų, pavyzdžiui... Clojure!
Funkcijų argumentai perduodami į standartinę įvestį (STDIN), rezultatai įrašomi į standartinę išvestį (STDOUT). Jei argumentai arba grąžinimo reikšmės nėra paprastos reikšmės (pvz., JSON objektas), jas galima konvertuoti naudojant abstrakcijos sluoksnį, kurį Fn teikia kaip funkcijų kūrimo rinkinį (FDK).
Patogumui siūlomi integruoti šablonų rinkiniai, palengvinantys FaaS diegimą plačiu įvairių kalbų ir jų versijų sąrašu (Go, skirtingos Java versijos, Python ir kt.).
Sukurti FaaS lengva pagal šią diagramą:
- Funkcijos diegimas naudojant Fn CLI: pagal pasirinktą šabloną sukuriamas Fn programos konfigūracijos failas.
- Mes išleidžiame savo funkciją, vėlgi naudodami CLI Fn: konteinerio vaizdas patalpinamas į tam tikrą saugyklą, po kurio serveriui pranešama apie šio vaizdo buvimą ir vietą.
Funkcijų pateikimo Fn principas
Vietinis be serverio funkcijų diegimas ir testavimas
Pradėkime nuo Fn diegimo vietiniame kompiuteryje. Pirmiausia, kaip reikalauja Fn, įdiegsime Docker. Tai darant prielaidą, kad esame Debian/Ubuntu:
$ sudo apt-get update
$ sudo apt-get install docker.ioArba naudokite paketų tvarkyklę / „Docker“ versiją pagal savo sistemą. Tada galite pereiti tiesiai prie Fn CLI diegimo. Pavyzdžiui, naudojant curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shJei naudojate OSX su įdiegta „Homebrew“, galite eiti kitu būdu:
$ 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.7MBDabar esame pasirengę iš pradžių įdiegti savo funkciją naudodami CLI. Paprastumo dėlei naudosime įmontuotą paleidimo aplinką, tokią kaip Node:
$ fn init --runtime node --trigger http hellonode
Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.Bus sukurtas naujas katalogas hellonode toliau plėtoti Fn funkciją su kai kuriais pagrindiniais konfigūracijos failais. Naujai sukurtame kataloge galite sukurti programą pagal pasirinktos kalbos ar vykdymo laiko standartus:
# Каталог с 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 sukuria pradinę projekto struktūrą, sukuria failą func.yaml, kuriame yra būtini Fn nustatymai, ir nustato kodo šabloną pasirinkta kalba.
Mazgo vykdymo laiko atveju tai reiškia:
$ 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}
})Dabar greitai išbandysime savo funkciją vietoje, kad pamatytume, kaip viskas veikia.
Pirmiausia paleisime Fn serverį. Kaip jau minėta, Fn serveris yra Docker konteineris, todėl po paleidimo jis eis ir paims vaizdą iš Docker registro.
$ 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
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Norint vykdyti mūsų funkciją, ji turi būti „išleista“. Tai reikalauja имя приложения: Fn, visos programos turi būti nurodytos kaip susijusių funkcijų vardų erdvės.
Fn CLI ieškos failo func.yaml dabartiniame kataloge, kuris bus naudojamas funkcijai konfigūruoti. Taigi pirmiausia turite eiti į mūsų katalogą 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-triggerKaip matote iš komandos išvesties, sukuriamas naujas Docker konteinerio vaizdas, kuriame yra mūsų funkcija. Funkcija paruošta iškviesti, ir mes turime du būdus tai padaryti:
- naudojant Fn komandą
invoke - skambinti tiesiogiai per
http
Вызов invoke per Fn jis tiesiog imituoja darbą per HTTP testams, o tai patogu atliekant greitą testavimą:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}Norėdami tiesiogiai iškviesti funkciją, turite žinoti visą URL:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Fn serveris atskleidžia savo funkcijas 8080 prievade ir atrodo, kad funkcijos URL atitinka šabloną t/app/function, bet ne iki galo. Per HTTP funkcija iškviečiama ne tiesiogiai, o per vadinamąjį trigerį, kuris pagal pavadinimą „paleidžia“ funkcijos iškvietimą. Trigeriai yra apibrėžti `func.yml projektas:
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 триггераGalime pakeisti trigerio pavadinimą, kad jis atitiktų funkcijos pavadinimą, tai viską supaprastins:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииTada vėl pradedame teikti funkciją ir iškviečiame ją iš naujo aktyviklio:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Viskas veikia! Atėjo laikas pereiti prie plataus masto eksperimentų ir paskelbti mūsų FaaS serveryje!
Be serverio funkcijų paslaugų įdiegimas savo infrastruktūroje
Greitai įdiegkime virtualią mašiną naudodami Exoscale CLI. Jei dar nenustatėte, galite naudoti . Tai puikus įrankis, kuris dar labiau padidins jūsų produktyvumą. Nepamirškite, kad reikia sukonfigūruoti taisyklę, kad atidarytumėte 8080 prievadą saugos grupėje! Šios komandos paleis švarią virtualią mašiną, paruoštą priglobti mūsų funkcijas:
$ 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-securitygroupTada galite ssh į virtualią mašiną ir įdiegti nuotolinį Fn serverį:
$ 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)Tada įdiekite „Docker“ ir „Fn“ serverį taip pat, kaip jau buvo padaryta vietiniame kompiuteryje, paleiskite serverį:
$ 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 yra pasirengęs priimti funkcijas! Tiksliniam funkcijų perkėlimui į nuotolinį serverį naudosime komandą deploy iš vietinio kompiuterio, praleidžiant vėliavėlę --local.
Be to, Fn reikalauja nurodyti Fn serverio ir Docker registro vietą. Šias parinktis galima nustatyti naudojant aplinkos kintamuosius FN_API_URL и FN_REGISTRY atitinkamai, bet taip pat siūlo patogesnį būdą lengvai valdyti diegimo konfigūracijų kūrimą ir valdymą.
Fn terminais vadinama diegimo konfigūracija context. Ši komanda sukurs kontekstą:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelGalimus kontekstus galite peržiūrėti taip:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
Ir pereikite prie konteksto, kuris ką tik buvo sukurtas taip:
$ fn use context exoscale
Now using context: exoscaleNuo šiol Fn funkcijos pristatymas atsisiųs „Docker“ vaizdus naudojant pasirinktą „DockerHub“ paskyrą (mano atveju - nfrankel), tada praneškite nuotoliniam serveriui (šiame pavyzdyje - http://185.19.30.175:8080) apie naujausio vaizdo, kuriame yra jūsų funkcija, vietą ir versiją.
$ 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 .Pagaliau:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Funkcijos gyvavimo ciklas naudojant Fn pagrįstą kompiuteriją be serverio
Kompiuterių be serverių privalumai jūsų pačių pajėgumais
Kompiuterija be serverio yra patogus sprendimas greitai įdiegti nepriklausomas programos dalis, kurios sąveikauja su sudėtingesnėmis programomis ar mikropaslaugomis.
Taip dažnai nutinka dėl paslėptų sąnaudų, susijusių su pasirinktu pardavėju, o tai, priklausomai nuo konkretaus naudojimo atvejo ir apimties, gali lemti didesnes išlaidas ir sumažinti lankstumą ateityje.
Šiuo atveju nukenčia ir kelių debesų bei hibridinių debesų architektūros, nes galite lengvai atsidurti situacijoje, kai norėtumėte naudoti be serverio kompiuteriją, tačiau dėl įmonės politikos tai gali būti neįmanoma.
„Fn“ yra gana paprasta naudoti ir gali suteikti beveik tą pačią „FaaS“ sąsają su nedideliu kiekiu. Tai pašalina bet kokį pardavėjo blokavimą ir gali būti įdiegta vietoje arba bet kuriame patogiame jūsų pasirinktame debesies sprendimų teikėje. Taip pat yra laisvė pasirenkant programavimo kalbą.
Šiame straipsnyje aptariami tik Fn pagrindai, tačiau sukurti savo vykdymo laiką yra gana paprasta, o bendrą architektūrą galima plačiau pritaikyti naudojant Fn apkrovos balansavimo priemonę arba įdedant Fn už tarpinio serverio apsaugai.
Šaltinis: www.habr.com
