🥇 Loome oma serverless'i Fn-i põhjal

We are building our own serverless based on Fn

Serveriteta arvutus — üks kõige silmatorkavamaid suundi pilveteenustes. Peamine põhimõte on see, et infrastruktuuri eest hoolitseb mitte DevOps, vaid teenusepakkuja. Ressursside automaatne skaleerimine kohandub koormusega ja omab kõrgendatud muutmiskiirus.

Teine levinud tunnusjoon on kalduvus vähendada ja fokuseerida koodi, mistõttu nimetatakse serveriteta arvutust mõnikord ka kui "funktsioonina teenus" (FaaS).

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

Google'i Cloud Functions
Microsofti Azure Functions

Kõik need ettevõtted pakuvad serveriteta arvutust, automaatset skaleerimist ja tasu ainult tegelikult kasutatud ressursside eest, kuid nad seovad kliente oma omandiõigusega tootele. Siiski on olemas tasuta avatud lähtekoodiga alternatiive serveriteta arvutuse korraldamiseks. Tasub märkida:

Platvorm Apache OpenWhisk, mida arendab IBM-i inkubaator,
Spring Cloud Functions, osana varsin rikkaasta Spring Framework -ekosysteemistä, jota voidaan käyttää myös AWS Lambdan, Azure Functionsin ja OpenWhiskin julkisivuna,
Fn-projekti, jota tukee Oracle.

Kaikki ne ovat täysin riippumattomia pilvistä, ts. ne voidaan asentaa mihin tahansa pilveen, mukaan lukien oma, julkinen tai yksityinen, ja tietenkin Exoscaleen.

Miten Fn-projekti toimii

Fn perustuu täysin Dockeriin ja koostuu kahdesta pääkomponentista:

CLI-ohjelmasta, joka on tarkoitettu hallitsemaan kaikkia Fn-infrastruktuurin näkökohtia ja vuorovaikutusta Fn-palvelimen kanssa,
Itse Fn-palvelin, tavallinen sovellus, joka on pakattu Docker-konttiin.

Fn:ssä käyttöön otetut funktiot suoritetaan myös erillisissä konteissa, mikä mahdollistaa useiden ohjelmointikielten käytön, esimerkiksi… Clojure!

Funktioiden argumentit välitetään standardiin syötteeseen (STDIN), ja tulokset kirjoitetaan standardiin ulostuloon (STDOUT). Jos argumentit tai palautusarvot eivät ole yksinkertaisia arvoja (esim. JSON-objekti) — ne voidaan muuttaa Fn:n tarjoaman funktioiden kehityspaketin (FDK) avulla.

Mugavuse huvides pakuvad sisseehitatud šabloonide komplekti, mis lihtsustavad FaaS-i käivitamist mitmesugustes keeltes ja nende versioonides (Go, erinevad Java versioonid, Python jne).

FaaS-i loomine on lihtne, järgides seda skeemi:

Käivitame funktsiooni CLI Fn abil: luuakse rakenduse konfigureerimisfail Fn jaoks, mis põhineb valitud šabloonil.
Tõukame oma funktsiooni, samuti CLI Fn abil: konteineripilt paigutatakse mõnda registrisse, pärast mida teavitatakse serverit selle olemasolust ja asukohast.

We are building our own serverless based on Fn
Fn-s funktsioonide kohaletoimetamise põhimõte

Kohalik installatsioon ja serverivabade funktsioonide testimine

Alustame Fn-i paigaldamist kohalikule masinale. Esiteks installime Dockerit, nagu nõuab Fn. Eeldatakse, et kasutame Debian/Ubuntu:

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

Või kasutage pakihaldurit/ Dockerit vastavalt oma süsteemile. seejärel saab minna otse Fn CLI installatsiooni juurde. Näiteks, kasutades curl-i:

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

Kui töötate OSX-is, kus on installitud Homebrew, saate minna teise 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 faili, 16.7MB

Nüüd on kõik valmis meie funktsiooni esialgseks seadistamiseks CLI abil. Lihtsuse huvides kasutame sissehitatud keskkonda, näiteks Node:

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

Funktsiooni loomine aadressil: /hellonode
Funktsiooni mall genereeritud.
func.yaml loodud.

Loodud on uus kataloog hellonode meie Fn funktsiooni edasise arenduse jaoks koos mõningate põhikonfiguratsioonifailidega. Uues loodud kataloogis saate luua oma rakenduse, järgides valitud keele või keskkonna 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, genereerib faili func.yaml, mis sisaldab Fn-i jaoks vajalikke seadistusi ja seab üles koodimalli, kasutades valitud keelt.

Node'i keskkonna korral 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.

Esiteks käivitame Fn serveri. Nagu juba mainitud, on Fn server Docker konteiner, seega pärast käivitamist tõmbab ta pildi Docker registrist.

$ fn start -d                    # käivita kohalik server taustal

Kohalikult ei leitud pilti 'fnproject/fnserver:latest'
latest: Tõmbamine fnproject/fnserver'ist
ff3a5c916c92: Tõmbamine lõpetatud
1a649ea86bca: Tõmbamine lõpetatud
ce35f4d5f86a: Tõmbamine lõpetatud

...

Olekuraport: Uuem pilt on tõmmatud fnproject/fnserver:latest
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5

Kuna tahame oma funktsiooni „välja panna”, on vaja teha järgmised toimingud. rakenduse nimi: Fn-s peavad kõik rakendused olema määratud nimede ruumide kaudu seotud funktsioonide jaoks.

Fn CLI otsib faili func.yaml praeguses kataloogis, mida rakendatakse funktsiooni seadistamiseks. Seega peame esmalt minema oma katalooge. hellonode.

$ cd hellonode
$ fn deploy --app fnexo --local  # juurutame funktsiooni kohaliku nimega fnexo.
                                 # kohalik valik ei lae pilti kaugregistrisse,
                                 # käivitab selle otse

Juurutamine hellonode rakendusele: fnexo
Tõstetud versiooniks 0.0.2
Kuvatakse pilt nfrankel/hellonode:0.0.3 .
Kasutades hellonode funktsiooni pilti nfrankel/hellonode:0.0.3...
Rakendus fnexo on edukalt loodud
Funktsioon hellonode koos nfrankel/hellonode:0.0.3 on edukalt loodud
Käivitatud on hellonode-trigger käivitus

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

kasutades käsku Fn invoke
kutsudes otse http

Kutse invoke Fn lihtsalt simuleerib HTTP töötlust testimiseks, mis on kiire kontrolli jaoks mugav:

$ fn invoke fnexo hellonode      # kutsume välja hellonode funktsiooni rakenduses fnexo

{"message":"Hello World"}

Funktsiooni otse kutsumiseks tuleb teada täis-URLi:

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

{"message":"Hello World"}

Fn server pakub oma funktsioone läbi sadama 8080, ja tundub, et funktsiooni URL vastab skeemile t/app/function, kuid mitte täielikult. HTTP kaudu kutsutakse funktsiooni mitte otse, vaid nn triggeriga, mis oma nime kohaselt „käivitab” funktsiooni kutsumise. Triggerid määratletakse `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 nii, 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 uuesti ja kutsume selle välja uuest triggerist:

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

{"message":"Hello World"}

Kõik töötab! On õige aeg liikuda praktiliste katsete juurde ja avaldada meie FaaS serveris!

Serverivabade funktsioonide teenuste paigaldamine oma infrastruktuurile

Korraldame kiiresti virtuaalmasina seadistamise Exoscale CLI abil. Kui te pole seda veel seadistanud — võite kasutada meie kiire käivitamise juhend. See on suurepärane tööriist, mis tõstab veelgi teie tootlikkust. Ärge unustage seadistada reeglit portaali 8080 avamiseks Security Group'is! Järgmised käsud käivitavad puhta virtuaalmasina, 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 virtuaalmasinale siseneda ja installida Fn-i kaugrestori:

$ exo ssh fn-server

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

Seejärel installime Dockeri ja Fn-serveri, nagu on juba tehtud kohalikul masinal, ja 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 suunamiseks kaugrestorisse kasutame käsku deploy kohalikult arvutilt, jättes välja lipu --local.

Lisaks nõuab Fn, et määrata Fn-serveri ja Dockeri registri asukoht. Need parameetrid saab seada keskkonnamuutujate kaudu FN_API_URL ja FN_REGISTRY seega, kuid on pakutud ka mugavamat viisi konfiguratsioonide loomise ja haldamise hõlpsaks juhtimiseks.

Fn-i mõistes nimetatakse implementatsiooni konfiguratsiooni 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 järgmiselt:

$ fn list contexts

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

Ja vahetada just loodud konteksti järgmiselt:

 $ fn use context exoscale

 Now using context: exoscale

Alates sellest kohast hakkab Fn-i funktsioonide pakkumine laadima Docker-pilte, kasutades valitud konto DockerHubis (minu puhul — nfrankel), seejärel teavitab eemalat serverit (selles näites — http://185.19.30.175:8080) teie funktsiooni viimasest pildist ja versioonist asukohast.

$ fn deploy --app fnexo .   # täidetakse lokaalselt kataloogist hellonode

Deploying function at: /.
Deploying hellonode to app: fnexo
Bumped to version 0.0.5
Building image nfrankel/hellonode:0.0.5 .

Lõpuks:

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

{"message":"Hello World"}

We are building our own serverless based on Fn
Fn-põhistes serverivabades arvutustes on funktsiooni elutsükkel

Serverless-arvutuse eelised oma jõudluse alusel

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

Sageli on see seotud varjatud kulude probleemiga, mis on seotud valitud teenusepakkujaga, mis sõltub konkreetsest kasutusjuhust ja mahust, mis võib tulevikus viia kõrgemate kulude ja madalama paindlikkuseni.

Multicloud ja hübriidpilvaarhitektuurid kannatavad samuti, kuna võib tekkida olukord, kus on soov kasutada serverless-arvutusi, kuid ettevõtte poliitika tõttu ei pruugi see olla võimalik.

Fn on piisavalt lihtne kasutada ja võib pakkuda peaaegu sama FaaSi liidest väikeste kuludega. See eemaldab teenusepakkujaga seotud sidemed, kuna saate seda installida kohapealselt või valida endale sobiva pilveteenuse pakkuja. Samuti on olemas vabadus programmeerimiskeele valikul.

Artiklis on tutvustatud ainult Fn põhialuseid, kuid oma täitmisüsteemi loomine on piisavalt lihtne ja üldist arhitektuuri saab laiendada Fn koormuse tasakaalustaja abil või paigutades Fn vahepealseks kaitseks.

Allikas: habr.com