🥇Külastame enda serverlessi Fn baasil

Ehitus oma serverless'i põhjal Fn

Serverivabad arvutused — on üks silmapaistvamaid suundi pilvandmetöötluses. Peamine tööpõhimõte on see, et infrastruktuuri haldamine ei kuulu DevOps'ide, vaid teenusepakkujate ülesanne. Ressursside skaleerimine kohandub automaatselt koormuse järgi ja omab suurt muutmiskiirus.

Teine ühine joon on tendents koodi minimeerimiseks ja fokusseerimiseks, mistõttu nimetatakse serverivabu arvutusi mõnikord "funktsioon kui teenus" (FaaS).

Ajalooliselt oli esimene pilveteenuste pakkuja, kes pakkus FaaS-i AWS Lambda kaudu, Amazon, kust see nimi pärineb. Ka teised pilveteenuste pakkujad pakuvad analooge:

Google'i Cloud Functions
Microsofti Azure Functions

Kõik need ettevõtted pakuvad serverivabu arvutusi, automaatset skaleerimist ja tasu ainult tegelikult kasutatud ressursside eest, kuid nad seovad kliente oma patenteeritud toote juurde. Siiski on olemas tasuta avatud lähtekoodiga alternatiive serverivabade arvutuste korraldamiseks. Tasub märkida:

Platvormi Apache OpenWhisk, mida arendab IBM-i inkubaator,
Spring Cloud Functions, mis on osa piisavalt rikkalikust Spring Frameworki ökosüsteemist, mida saab kasutada ka AWS Lambda, Azure Functions ja OpenWhiski fasadina,
Fn projekt, mida toetab Oracle.

Kõik need on täielikult sõltumatud pilvedest, st need on installitavad igas pilves, sealhulgas teie enda, avalikus või erapilves, ja muidugi ka Exoscale'is.

Kuidas Fn projekt on üles ehitatud

Fn põhineb täielikult Docker'il, koosnedes kahest põhikomponendist:

CLI programmist, mis on mõeldud Fn infrastruktuuri kõigi aspektide haldamiseks ja koostööks Fn serveriga,
Ise Fn server, tavaline rakendus, mis on pakitud Docker konteinerisse.

Fn'is juurutatud funktsioonid töötavad samuti eraldi konteinerites, mis võimaldab toetada väga mitmeid programmeerimiskeeli, näiteks… Clojure!

Funktsioonide argumendid edastatakse standardse sisendi (STDIN) kaudu, tulemused kirjutatakse standardsele väljundile (STDOUT). Kui argumendid või tagastatavad väärtused ei ole lihtsad väärtused (näiteks JSON objekt), saavad need olla muudetud abistava kihi kaudu, mille Fn pakub funktsioonide arendamise komplektina (FDK).

Kasutamiseks on saadaval sisseehitatud mallide komplektid, mis lihtsustavad FaaSi juurutamist erinevatel keeltes ja nende versioonides (Go, erinevad Java versioonid, Python jne).

FaaSi loomine on lihtne, järgides seda skeemi:

Jurutame funktsiooni CLI Fn abil: loodakse rakenduse konfigureerimisfail Fn jaoks, mis põhineb valitud mallil.
Väljastame oma funktsiooni, taas CLI Fn abil: konteineripilt paigutatakse mingisse registrisse, pärast mida serverit teavitakse selle pildi olemasolust ja asukohast.

Ehitus oma serverless'i põhjal Fn
Funktsioonide kohaletoimetamise põhimõte Fn-s

Kohalik installatsioon ja serverivaba funktsioonide testimine

Alustame Fn-i installimist kohalikus masinas. Esiteks installitakse Docker, nagu Fn nõuab. Eeldame, et oleme Debian/Ubuntu süsteemil:

$ sudo apt-get update
$ sudo apt-get install docker.io

Või kasutage oma süsteemi jaoks pakihaldurit/ Dockerit. Seejärel saame otse jätkata Fn CLI installimisega. Näiteks curl abil:

$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh

Kui töötate OSX-il koos Homebrew'ga, võib minna teist teed:

$ brew install fn

==> Laadimine https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Laadimine aadressilt 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 failid, 16.7MB

Nüüd on kõik valmis meie funktsiooni esmaseks juurutamiseks CLI abil. Lihtsuse huvides kasutame sisseehitatud keskkonda, näiteks Node'i:

$ fn init --runtime node --trigger http hellonode

Funktsioon luuakse asukohas: /hellonode
Funktsiooni aluskood genereeritud.
func.yaml loodud.

Loodud saab uus kataloog hellonode edasi meie Fn funktsiooni arendamiseks koos mõnede põhikonfigureerimisfailidega. Uues loodud kataloogis saate luua oma rakenduse, järgides teie valitud keele või käituskeskkonna standardeid:

# Каталог с 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.java

Fn loob projekti algstruktuuri ning loob faili func.yaml, mis sisaldab Fn-ile vajalikke seadistusi, ja seab valitud keeles koodimalli.

Node'i käituskeskkonna puhul tähendab see:

$ 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}
})

Nüüd kontrollime kiiresti meie funktsiooni kohalikult, et näha, kuidas kõik töötab.

Kõigepealt käivitame Fn serveri. Nagu juba mainitud, on Fn server Docker konteiner, seega peale käivitamist see läheb ja võtab pildi Docker registrist.

$ fn start -d                    # käivitame kohaliku serveri taustal

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

Käivitamiseks tuleb meie funktsioon "välja viia". Selleks on vajalik rakenduse nimi: Fn-is peavad kõik rakendused olema määratud seotud funktsioonide nimedena.

Fn CLI otsib faili func.yaml praeguses kataloogis, mis rakendub funktsiooni seadistamiseks. Seega peame esmalt minema meie katalooge hellonode.

$ cd hellonode
$ fn deploy --app fnexo --local  # väljastame funktsiooni kohalikult, rakenduse nimi - fnexo.
                                 # parameeter local ei lae pilti kaugregistrisse,
                                 # käivitades selle otse

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-trigger

Nagu näha käsu väljundist, luuakse uus Docker konteineri pilt, mis sisaldab meie funktsiooni. Funktsioon on kutsumiseks valmis ning meil on kaks võimalust selle tegemiseks:

kasutades käsku Fn invoke
kutsudes otse läbi http

Kutsumine invoke Fn emuleerib lihtsalt HTTP tööd testide jaoks, mis on kiire testimise jaoks mugav:

$ fn invoke fnexo hellonode      # kutsume fnexo rakenduse hellonode funktsiooni

{"message":"Hello World"}

Funktsiooni otse kutsumiseks tuleb teada täielikku URL-i:

$ curl http://localhost:8080/t/fnexo/hellonode-trigger

{"message":"Hello World"}

Fn server pakub oma funktsioone porti 8080 kaudu ning näib, et funktsiooni URL vastab skeemile t/app/function, kuid mitte täielikult. HTTP kaudu kutsutakse funktsiooni mitte otse, vaid nn triggeri kaudu, mis oma nime kohaselt "käivitab" funktsiooni kutsumise. Triggerid on määratletud `func.yml projekti:

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    # triggeri URL

Saame muuta triggeri nime, et see vastaks funktsiooni nimele, see lihtsustab kõike:

triggers:
- name: hellonode-trigger
  type: http
  source: /hellonode    # vastab funktsiooni nimele

Seejärel käivitame funktsiooni tarnimise veel kord ja kutsume selle uue triggeri kaudu:

$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode

{"message":"Tere, maailm"}

Kõik töötab! On just õige aeg minna reaalsesse katsetusse ja avaldada meie FaaS serveris!

Serverless funktsioonide teenuste seadistamine oma infrastruktuuris

Alustame kiiresti virtuaalse masina seadistamist Exoscale'i CLI abil. Kui te ei ole seda veel seadistanud — võite kasutada meie kiire käivitamise juhendit. See on suurepärane tööriist, mis tõstab veelgi teie tootlikkust. Ärge unustage seadistada reeglit port 8080 avamiseks Security Group'is! Järgmised käsud käivitavad puhta virtuaalse masina, mis on valmis meie funktsioonide majutamiseks:

$ 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-securitygroup

Seejärel saab SSH kaudu virtuaalsesse masinasse siseneda ja paigaldada kaugserveri Fn:

$ exo ssh fn-server

Hosti '185.19.30.175 (185.19.30.175)' autentsust ei saa kehtestada.
ECDSA võtme sõrmejälg on SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Kas soovite jätkata ühenduse loomist (jah/ei)? jah
Hoiatus: '185.19.30.175' (ECDSA) on püsivalt lisatud tuntud hostide nimekirja.
Tere tulemast Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)

Seejärel paigaldame Docker'i ja Fn serveri samuti nagu seda tehti kohalikul masinal ning käivitame serveri:

$ 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.643

Fn on valmis funktsioonide vastuvõtmiseks! Funktsioonide sihtimise jaoks kaugserverisse kasutame käsku deploy kohalikust arvutist, jättes välja flagi --local.

Lisaks peab Fn näitama Fn serveri ja Docker'i registri asukohta. Need parameetrid võivad olla määratud keskkonnamuutujate kaudu FN_API_URL ja FN_REGISTRY vastavalt, kuid pakutakse ka mugavamat viisi konfiguratsioonide loomise ja haldamise hõlbustamiseks.

Fn kontekst, mida kasutatakse rakenduse juurutamiseks, nimetatakse context. Järgmine käsk loob konteksti:

$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankel

Saate vaadata saadaval olevaid kontekste nii:

$ fn list contexts

CURRENT NAME      PROVIDER      API URL                      REGISTRY
    default       default       http://localhost:8080/
    exoscale      default       http://185.19.30.175:8080    nfrankel

Ja lülituda just loodud konteksti nii:

 $ fn use context exoscale

 Nüüd kasutame konteksti: exoscale

Alates sellest kohast hakkab Fn funktsioonide tarnimine laadima Docker'i pilte, kasutades valitud kontot DockerHub'is (minu puhul — nfrankel), seejärel teavitab see kaugserverit (sel juhul — http://185.19.30.175:8080) viimase pildi asukohast ja versioonist, mis sisaldab teie funktsiooni.

$ fn deploy --app fnexo .   # käivitatakse lokaalselt hellonode kataloogist

Funktsiooni laadimine asukohas: /.
Laadimine hellonode rakendusse: fnexo
Versioon tõstetud 0.0.5-ni
Pildi koostamine nfrankel/hellonode:0.0.5 .

Lõpuks:

$ curl http://185.19.30.175:8080/t/fnexo/hellonode

{"message":"Tere, maailm"}

Ehitus oma serverless'i põhjal Fn
Fn baasil serverless arvutustes funktsiooni elutsükkel

Serverless arvutuste eelised oma infrastruktuuris

Serverless arvutused on mugav lahendus sõltumatute rakenduse osade kiireks juurutamiseks, mis suhtlevad keerukamate rakenduste või mikroteenustega.

Sageli on sellel peidetud kulu seondumine valitud teenusepakkujaga, mis sõltuvalt konkreetsest kasutusjuhtumist ja mahust võib viia kõrgemate kuludeni ja vähenenud paindlikkuseni tulevikus.

Multicloud ja hübriidsete pilvearhitektuuride korral tekivad samuti probleemid, kuna võib lihtsalt sattuda olukorda, kus soovite kasutada serverless arvutusi, kuid ettevõtte poliitika tõttu võib see olla võimatu.

Fn on kasutajasõbralik, see võib pakkuda peaaegu samasugust FaaS liidest, väikeste kuludega. See vabastab teid igasugustest teenusepakkuja sidemetest, seda saab installida lokaalselt või valida sobivas pilveteenuse pakkujas. Samuti on vabade valikute osas programmeerimiskeeles.

Artiklis tutvustatakse vaid Fn põhialuseid, kuid oma täitmisvõimekeskkonna loomine on piisavalt lihtne ning üldist arhitektuuri saab laiendada Fn tasakaalustaja kasutamisega või paigutades Fn proksi taha kaitseks.

Allikas: habr.com