Veidojot savu bezserveru, pamatojoties uz Fn

Bezservera skaitļošana ir viena no redzamākajām mākoņdatošanas tendencēm. Darbības pamatprincips ir tāds, ka infrastruktūra nav DevOps, bet pakalpojumu sniedzēja rūpes. Resursu mērogošana automātiski pielāgojas slodzei, un tai ir augsts izmaiņu ātrums.

Vēl viena izplatīta iezīme ir tendence samazināt un fokusēt kodu, tāpēc bezservera skaitļošanu dažreiz sauc par funkciju kā pakalpojumu (FaaS).

Vēsturiski pirmais mākoņa pakalpojumu sniedzējs, kas piedāvāja FaaS ar AWS Lambda, bija Amazon, tāpēc arī nosaukums. Arī citi mākoņpakalpojumu sniedzēji piedāvā līdzīgus pakalpojumus:

• Google mākoņfunkcijas
• Azure Functions no Microsoft

Visi šie uzņēmumi nodrošina skaitļošanu bez serveriem, automātisko mērogošanu un maksā tikai par to, ko jūs faktiski izmantojat, taču tie piesaista klientus viņu patentētajam produktam. Tomēr bezservera skaitļošanai ir bezmaksas un atvērtā pirmkoda alternatīvas. Ir vērts atzīmēt:

• Platforma Apache OpenWhisk, ko inkubatorā izstrādājis IBM,
• Pavasara mākoņu funkcijas, kas ir daļa no diezgan bagātīgas Spring Framework ekosistēmas, ko var izmantot arī kā fasādi AWS Lambda, Azure Functions un OpenWhisk,
• Projekts Fn, ko atbalsta Oracle.

Visi no tiem ir pilnīgi neatkarīgi no mākoņiem, tas ir, tos var instalēt jebkurā mākonī, tostarp jūsu, publiskajā vai privātajā, un, protams, Exoscale.

Kā darbojas Fn projekts

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

• CLI programma, kas izstrādāta, lai pārvaldītu visus Fn infrastruktūras aspektus un mijiedarbojas ar Fn serveri,
• Pats Fn serveris ir parasta lietojumprogramma, kas iepakota Docker konteinerā.

Fn izvietotās funkcijas tiek izpildītas arī atsevišķos konteineros, kas ļauj atbalstīt daudzas programmēšanas valodas, piemēram... Clojure!

Funkciju argumenti tiek nodoti standarta ievadei (STDIN), rezultāti tiek ierakstīti standarta izvadē (STDOUT). Ja argumenti vai atgriešanas vērtības nav vienkāršas vērtības (piemēram, JSON objekts), tos var konvertēt, izmantojot abstrakcijas slāni, ko nodrošina pats Fn funkciju izstrādes komplekta (FDK) veidā.

Ērtības labad tiek piedāvāti iebūvēti veidņu komplekti, kas atvieglo FaaS izvietošanu plašā dažādu valodu un to versiju sarakstā (Go, dažādas Java, Python versijas utt.).

FaaS izveidošana ir vienkārša, sekojot šai diagrammai:

• Funkcijas izvietošana, izmantojot Fn CLI: tiek izveidots lietojumprogrammas konfigurācijas fails Fn, pamatojoties uz atlasīto veidni.
• Mēs izlaižam savu funkciju, atkal izmantojot CLI Fn: konteinera attēls tiek ievietots noteiktā repozitorijā, pēc kura serveris tiek informēts par šī attēla esamību un izvietojumu.

Funkciju piegādes princips Fn

Bezserveru funkciju lokāla uzstādīšana un testēšana

Sāksim Fn instalēšanu vietējā datorā. Pirmkārt, tiek instalēts Docker, kā to pieprasa Fn. Pieņemot, ka mēs izmantojam Debian/Ubuntu:

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

Vai arī izmantojiet pakotņu pārvaldnieku/Docker būvējumu atbilstoši savai sistēmai. Pēc tam varat pāriet tieši uz Fn CLI instalēšanu. Piemēram, izmantojot čokurošanās:

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

Ja izmantojat operētājsistēmu OSX ar instalētu Homebrew, varat izvēlēties citu ceļu:

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

Tagad esam gatavi sākotnēji izvietot savu funkciju, izmantojot CLI. Vienkāršības labad mēs izmantosim iebūvētu palaišanas vidi, piemēram, Node:

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

Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.

Tiks izveidots jauns direktorijs hellonode lai tālāk attīstītu mūsu Fn funkciju ar dažiem pamata konfigurācijas failiem. Jaunizveidotajā direktorijā varat izveidot savu lietojumprogrammu, ievērojot jūsu izvēlētās valodas vai izpildlaika 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.java

Fn izveido sākotnējo projekta struktūru, izveido failu func.yaml, kas satur nepieciešamos Fn iestatījumus, un iestata koda veidni jūsu izvēlētajā valodā.

Node izpildlaika gadījumā 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.

Pirmkārt, mēs sāksim Fn serveri. Kā jau minēts, Fn serveris ir Docker konteiners, tāpēc pēc palaišanas tas aizies un paņems attēlu no Docker reģistra.

$ 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

Lai izpildītu mūsu funkciju, tai ir jābūt “izrullētai”. Tas prasa имя приложения: Fn valodā visas lietojumprogrammas ir jānorāda kā saistīto funkciju nosaukumvietas.

Fn CLI meklēs failu func.yaml pašreizējā direktorijā, kas tiks izmantota funkcijas konfigurēšanai. Tāpēc vispirms jums jāiet uz mūsu direktoriju 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-trigger

Kā redzat no komandas izvades, tiek izveidots jauns Docker konteinera attēls, kas satur mūsu funkciju. Funkcija ir gatava izsaukšanai, un mums ir divi veidi, kā to izdarīt:

• izmantojot Fn komandu invoke
• zvanot tieši pa http

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

$ fn invoke fnexo hellonode      # вызываем функцию hellonode приложения fnexo

{"message":"Hello World"}

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

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

{"message":"Hello World"}

Fn serveris atklāj savas funkcijas portā 8080, un šķiet, ka funkcijas URL atbilst modelim t/app/function, bet ne pilnībā. Izmantojot HTTP, funkcija netiek izsaukta tieši, bet ar tā saukto trigeri, kas pēc nosaukuma “sāk” funkcijas izsaukumu. Trigeri ir definēti `func.yml projekts:

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 триггера

Mēs varam mainīt sprūda nosaukumu, lai tas atbilstu funkcijas nosaukumam, tas visu vienkāršos:

triggers:
- name: hellonode-trigger
  type: http
  source: /hellonode    # совпадает с именем функции

Pēc tam vēlreiz palaižam funkcijas piegādi un izsaucam to no jauna aktivizētāja:

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

{"message":"Hello World"}

Viss darbojas! Ir pienācis laiks pāriet uz pilna mēroga eksperimentiem un publicēt mūsu FaaS serverī!

Bezserveru funkciju pakalpojumu instalēšana savā infrastruktūrā

Ātri instalēsim virtuālo mašīnu, izmantojot Exoscale CLI. Ja vēl neesat to iestatījis, varat to izmantot mūsu ātrā darba sākšanas rokasgrāmata. Šis ir foršs rīks, kas vēl vairāk palielinās jūsu produktivitāti. Neaizmirstiet, ka jums ir jākonfigurē noteikums, lai drošības grupā atvērtu portu 8080! Šīs komandas palaidīs tīru virtuālo mašīnu, kas ir gatava mitināt mūsu 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-securitygroup

Pēc tam varat ssh virtuālajā mašīnā un instalēt attālo Fn serveri:

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

Pēc tam instalējiet Docker un Fn serveri tādā pašā veidā, kā tas jau tika darīts vietējā mašīnā, startējiet 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 uztvert funkcijas! Mērķtiecīgai funkciju pārsūtīšanai uz attālo serveri mēs izmantosim komandu deploy no vietējā datora, izlaižot karogu --local.

Turklāt Fn ir jānorāda Fn servera un Docker reģistra atrašanās vieta. Šīs opcijas var iestatīt, izmantojot vides mainīgos FN_API_URL и FN_REGISTRY attiecīgi, bet arī piedāvā ērtāku veidu, kā viegli pārvaldīt izvietošanai paredzēto konfigurāciju izveidi un pārvaldību.

Fn izteiksmē tiek izsaukta izvietošanas konfigurācija context. Šī komanda izveidos kontekstu:

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

Varat skatīt pieejamos kontekstus, piemēram:

$ fn list contexts

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

Un pārslēdzieties uz kontekstu, kas tikko tika izveidots šādi:

 $ fn use context exoscale

 Now using context: exoscale

No šī brīža Fn funkcijas piegāde lejupielādēs Docker attēlus, izmantojot atlasīto DockerHub kontu (manā gadījumā - nfrankel), un pēc tam paziņojiet attālajam serverim (šajā piemērā - http://185.19.30.175:8080) par jaunākā attēla, kurā ir jūsu funkcija, atrašanās vietu un versiju.

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

Visbeidzot:

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

{"message":"Hello World"}

Funkcijas dzīves cikls uz Fn balstītā bezservera skaitļošanā

Bez servera skaitļošanas priekšrocības ar jūsu pašu jaudu

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

Tas bieži vien ir saistīts ar slēptajām izmaksām, kas saistītas ar piesaisti izvēlētajam pārdevējam, kas atkarībā no konkrētā lietošanas gadījuma un apjoma var radīt lielākas izmaksas un samazināt elastību nākotnē.

Šajā gadījumā cieš arī vairāku mākoņu un hibrīdmākoņu arhitektūras, jo var viegli nonākt situācijā, kad gribētos izmantot bezserveru skaitļošanu, taču korporatīvo politiku dēļ tas var nebūt iespējams.

Fn ir diezgan viegli lietojams, un tas var nodrošināt gandrīz tādu pašu FaaS interfeisu ar nelielām izmaksām. Tas novērš jebkādu pārdevēja bloķēšanu, un to var instalēt lokāli vai jebkurā ērtā mākoņa risinājumu nodrošinātājā pēc jūsu izvēles. Programmēšanas valodas izvēlē ir arī brīvība.

Šajā rakstā ir apskatīti tikai Fn pamati, taču sava izpildlaika izveide ir diezgan vienkārša, un vispārējo arhitektūru var izvietot plašāk, izmantojot Fn slodzes balansētāju vai novietojot Fn aiz starpniekservera aizsardzībai.

Avots: www.habr.com