Veidojam savu serverless risinājumu, balstoties uz Fn

Serverless skaitļošana — viena no izteiktākajām tendencēm mākoņskaitļošanā. Pamata darbības princips ir tāds, ka infrastruktūra ir pakalpojumu sniedzēju rūpe, nevis DevOps speciālistu. Resursu mērogošana automātiski pielāgojas slodzei un ir ar augstu izmaiņu ātrumu.

Vēl viena kopīga iezīme ir tendence minimizēt un koncentrēt kodu, tāpēc serverless skaitļošanu reizēm sauc par "funkcija kā pakalpojumu" (FaaS).

Vēsturiskā ziņā pirmais mākoņpakalpojumu sniedzējs, kurš piedāvāja FaaS ar AWS Lambda, bija Amazon, no kurienes arī radies šis nosaukums. Citi mākoņpakalpojumu sniedzēji piedāvā līdzīgas alternatīvas:

• Google Cloud Functions
• Microsoft Azure Functions

Visas šīs kompānijas piedāvā serverless skaitļošanu, automātisku mērogošanu un maksāšanu tikai par faktiski izmantotajiem resursiem, bet tajā pašā laikā piesaista klientus savam patentētajam produktam. Tomēr pastāv bezmaksas alternatīvas ar atvērtā koda risinājumiem serverless skaitļošanai. Vērts pieminēt:

• Platformu Apache OpenWhisk, kuru izstrādā IBM inkubators,
• Spring Cloud Functions, kā daļu no diezgan bagātīgas Spring Framework ekosistēmas, kuru var izmantot arī kā AWS Lambda, Azure Functions un OpenWhisk saskarni,
• Projektu Fn, kuru atbalsta Oracle.

Visi tie ir pilnīgi neatkarīgi no mākoņiem, t.i., tos var uzstādīt jebkurā mākoņos, tostarp jūsu pašu, publiskajā vai privātajā, un protams, Exoscale.

Kā ir izveidots projekts Fn

Fn pilnībā balstās uz Docker, sastāv no diviem galvenajiem komponentiem:

• CLI programma, kas paredzēta, lai pārvaldītu visus Fn infrastruktūras aspektus, un mijiedarbojas ar Fn serveri,
• Pats Fn servers, parasts lietojums, iepakots Docker konteinerā.

Funkcijas, kas izvietotas Fn, tiek izpildītas arī atsevišķos konteineros, kas ļauj atbalstīt daudzus programmēšanas valodas, piemēram… Clojure!

Funkciju argumenti tiek nodoti standarta ievadā (STDIN), rezultāti tiek rakstīti standarta izvadā (STDOUT). Ja argumenti vai atgriezamās vērtības nav vienkārši vērtības (piemēram, JSON objekts) — tās var tikt pārveidotas, izmantojot abstrahēšanas slāni, ko nodrošina Fn kā funkciju izstrādes komplektu (FDK).

Lai atvieglotu darbu, tiek piedāvāti iebūvēti veidņu komplekti, kas atvieglo FaaS izvēršanu plašā dažādu valodu un to versiju sarakstā (Go, dažādas Java versijas, Python u.c.).

FaaS izveide ir vienkārša, sekojot šai shēmai:

• Izvietot funkciju, izmantojot CLI Fn: tiek izveidots lietojumprogrammas konfigurācijas fails Fn, pamatojoties uz izvēlēto veidni.
• Izdojam savu funkciju, atkal izmantojot CLI Fn: konteineru attēls tiek ievietots kādā krātuvē, pēc tam serveris tiek informēts par attēla esamību un izvietojumu.

Funkciju piegādes princips Fn

Lokālā uzstādīšana un bezserveru funkciju testēšana

Sāksim ar Fn uzstādīšanu vietējā datorā. Vispirms ir jāinstalē Docker, kā to prasa Fn. Pieņemam, ka esam Debian/Ubuntu:

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

Vai nu izmantojiet pakotņu pārvaldnieku / Docker būvniecību atbilstoši jūsu sistēmai. Pēc tam varat tieši pāriet uz Fn CLI uzstādīšanu. Piemēram, izmantojot curl:

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

Ja strādājat ar OSX, kur ir uzstādīts Homebrew, varat doties citu ceļu:

$ brew install fn

==> Lejupielādē https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Lejupielādē no https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Tiek ielejots fn-0.5.8.high_sierra.bottle.tar.gz
  /usr/local/Cellar/fn/0.5.8: 5 faili, 16.7MB

Tagad viss ir gatavs, lai sākotnēji izvērstu mūsu funkciju, izmantojot CLI. Lai atvieglotu, mēs izmantosim iebūvēto vidi palaišanai, piemēram, Node:

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

Izveido funkciju: /hellonode
Funkciju paraugs ģenerēts.
func.yaml izveidots.

Tiks izveidots jauns katalogs hellonode turpmākai mūsu Fn funkcijas attīstībai ar dažiem pamatkonfigurācijas failiem. Iekš jaunizveidotā kataloga jūs varat izveidot savu lietojumprogrammu, ievērojot izvēlētā valodas vai izpildes vides standartu:

# Каталог с 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 izveido projekta sākotnējo struktūru, izveidojot failu func.yaml, kas satur nepieciešamās iestatīšanas fn un nosaka veidni kodam valodā, kuru izvēlējāties.

Ja runājam par Node izpildlaiku, tas nozīmē:

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

Tagad mēs ātri pārbaudīsim mūsu funkciju lokāli, lai redzētu, kā viss darbojas.

Vispirms mēs palaidīsim Fn serveri. Kā jau tika teikts, Fn servers ir Docker konteiners, tāpēc pēc palaišanas tas ņems attēlu no Docker reģistra.

$ fn start -d                    # palaidīsim lokālo serveri fonā

Image 'fnproject/fnserver:latest' nav atrasts lokāli
latest: Velk no fnproject/fnserver
ff3a5c916c92: Velk pabeigts
1a649ea86bca: Velk pabeigts
ce35f4d5f86a: Velk pabeigts

...

Status: Lejupielādēts jaunāks attēls kā fnproject/fnserver:latest
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5

Lai palaistu mūsu funkciju, tai jābūt "izlaistai". Tam nepieciešams lietošanas nosaukums: Fn visām lietojumprogrammām jābūt noteiktām kā nosaukumu telpām saistītām funkcijām.

Fn CLI meklēs failu func.yaml pašreizējā katalogā, kas tiks izmantots funkcijas konfigurēšanai. Tāpēc vispirms jāpārslēdzas uz mūsu katalogu hellonode.

$ cd hellonode
$ fn deploy --app fnexo --local  # izlaidīsim funkciju lokāli, lietojumprogrammas nosaukums - fnexo.
                                 # vietējais parametrs neieliek attēlu attālinātajā reģistrā,
                                 # palaidīsim to tieši

Izlaižot hellonode lietojumprogrammā: fnexo
Palielināts līdz versijai 0.0.2
Veido attēlu nfrankel/hellonode:0.0.3 .
Atjaunojam funkciju hellonode, izmantojot attēlu nfrankel/hellonode:0.0.3...
Veiksmīgi izveidota lietojumprogramma:  fnexo
Veiksmīgi izveidota funkcija: hellonode ar nfrankel/hellonode:0.0.3
Veiksmīgi izveidots triggers: hellonode-trigger

Kā var redzēt no komandas izvadē, tiek izveidots jauns Docker konteinera attēls, kas satur mūsu funkciju. Funkcija ir gatava vārdus saukt, un mums ir divi veidi, kā to izdarīt:

• izmantojot Fn komandu invoke
• izsaucot tieši caur http

Izsaukt invoke izmantojot Fn, vienkārši emulē HTTP darbu testiem, kas ir ērti ātrai pārbaudei:

$ fn invoke fnexo hellonode      # izsaucam funkciju hellonode lietojumprogrammā fnexo

{"message":"Hello World"}

Lai izsauktu funkciju tieši, jāzina pilns URL:

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

{"message":"Hello World"}

Fn servers piedāvā savas funkcijas caur 8080 portu, un, kā šķiet, funkcijas URL atbilst shēmai t/app/function, bet ne pilnībā. Caur HTTP funkcija netiek izsaukta tieši, bet caur saukto izsistēju, kas, kā norāda nosaukums, "izsauc" funkciju. Izsistēji tiek noteikti `func.yml projekta:

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

Mēs varam mainīt trigeru nosaukumu, lai tas atbilstu funkcijas nosaukumam, tas atvieglos procesu:

triggers:
- name: hellonode-trigger
  type: http
  source: /hellonode    # atbilst funkcijas nosaukumam

Pēc tam mēs vēlreiz palaižam funkcijas piegādi un izsaucam to no jauna trigera:

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

{"message":"Hello World"}

Viss strādā! Tagad ir īstais laiks veikt reālus eksperimentus un publicēt mūsu FaaS serverī!

Serverless funkciju pakalpojumu uzstādīšana uz savas infrastruktūras

Ātri uzstādīsim virtuālo mašīnu, izmantojot Exoscale CLI. Ja jūs to vēl neesat konfigurējis — varat izmantot mūsu ātrā palaišanas rokasgrāmatu. Tas ir lielisks rīks, kas vēl vairāk palielinās jūsu produktivitāti. Neaizmirstiet iestatīt noteikumu, lai atvērtu 8080 portu drošības grupā! Šie komandas palaidīs tīru virtuālo mašīnu, kas gatava mūsu funkciju izvietošanai:

$ 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

Pēc tam varat piekļūt virtuālajai mašīnai, izmantojot ssh, un uzstādīt Fn atālināto serveri:

$ exo ssh fn-server

Hosta '185.19.30.175 (185.19.30.175)' autentiskums nevar tikt noteikts.
ECDSA atslēgas pirksta nospiedums ir SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Vai esat pārliecināts, ka vēlaties turpināt savienojumu (jā/nē)? jā
Brīdinājums: uz visiem laikiem pievienots '185.19.30.175' (ECDSA) zināmo hostu sarakstam.
Laipni lūdzam Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)

Pēc tam uzstādām Docker un Fn serveri tāpat kā tas tika darīts uz vietējās mašīnas, palaižam 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 ir gatavs funkciju saņemšanai! Lai funkcijas mērķtiecīgi nolasītu no attālinātā servera, izmantosim komandu deploy no vietējā datora, izslēdzot eglītes --local.

Turklāt Fn prasa norādīt Fn servera un Docker reģistra atrašanās vietu. Šie parametri var tikt iestatīti, izmantojot vides mainīgos FN_API_URL un FN_REGISTRY atbilstoši, taču tiek piedāvāts arī ērtāks veids, kā viegli pārvaldīt konfigurāciju izveidi un pārvaldību izvietošanai.

Fn terminoloģijā kontekstu izvietošanai sauc par context. Nākamā komanda izveidos kontekstu:

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

Jūs varat apskatīt pieejamos kontekstus šādi:

$ fn list contexts

PAŠREIZĒJAIS NOSAUKUMS  PROVIDER      API URL                      REGISTRY
    default       default       http://localhost:8080/
    exoscale      default       http://185.19.30.175:8080    nfrankel

Un pārslēgties uz tikko izveidoto kontekstu ir šādi:

 $ fn use context exoscale

 Tagad izmantojam kontekstu: exoscale

Sākot no šīs vietas, Fn funkciju piegāde tiks ielādējusi Docker attēlus, izmantojot izvēlēto kontu DockerHub (manā gadījumā — nfrankel), pēc tam paziņojot attālinātajam serverim (šajā piemērā — http://185.19.30.175:8080) par pēdējā attēla, kas satur jūsu funkciju, atrašanās vietu un versiju.

$ fn deploy --app fnexo .   # izpildāms uz lokālās mašīnas no hellonode direktorijas

Piegādā funkciju: /.
Piegāde hellonode uz lietotni: fnexo
Jums piešķirta versija 0.0.5
Būvējot attēlu nfrankel/hellonode:0.0.5 .

Visbeidzot:

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

{"message":"Hello World"}

Funkcijas dzīves cikls bezserveru skaitīšanā, balstoties uz Fn

Bezserveru skaitīšanas priekšrocības uz jūsu iespējām

Bezserveru skaitīšana — ērts risinājums, lai ātri ieviestu neatkarīgas lietojumprogrammas daļas, kas sadarbojas ar sarežģītākām lietojumprogrammām vai mikropakalpojumiem.

Bieži tas saistīts ar slēptām izmaksām, piesaistot izvēlētajam pakalpojumu sniedzējam, kas atkarībā no konkrētā pielietojuma un apjoma var novest pie augstākām izmaksām un samazinātas elastības nākotnē.

Multicloud un hibrīdas mākoņu arhitektūras arī cieš šādā gadījumā, jo var viegli nonākt situācijā, kad vēlētos izmantot bezserveru skaitīšanu, bet korporatīvās politikas dēļ tas varētu būt neiespējami.

Fn ir pietiekami vienkāršs lietošanā, var sniegt gandrīz tādu pašu FaaS interfeisu, ar nelielām izmaksām. Tas atbrīvos no jebkādām piesaistēm pakalpojumu sniedzējiem, to var uzstādīt lokāli vai pie jebkura ērtā mākoņu pakalpojumu sniedzēja pēc jūsu izvēles. Tāpat ir brīvība izvēlēties programmēšanas valodu.

Rakstā ir aplūkotas tikai Fn pamati, taču paša izpildes vides izveide ir diezgan vienkārša, un vispārējo arhitektūru var izplatīt plašāk, izmantojot Fn slodzes balansētāju vai izvietojot Fn aiz proksi aizsardzībai.

Avots: habr.com