Saját szerver nélküli építésünk Fn alapján

Szerver nélküli számítástechnika a felhőalapú számítástechnika egyik legjelentősebb trendje. Az alapvető működési elv, hogy az infrastruktúra nem a DevOps, hanem a szolgáltató feladata. Az erőforrás-skálázás automatikusan alkalmazkodik a terheléshez, és nagy a változási aránya.

Egy másik közös jellemző a kód minimalizálására és fókuszálására való hajlam, ezért a kiszolgáló nélküli számítástechnikát néha szolgáltatásként funkciónak (FaaS) nevezik.

Történelmileg az Amazon volt az első felhőszolgáltató, amely FaaS-t kínált az AWS Lambdával, innen ered a név. Más felhőszolgáltatók is kínálnak hasonlókat:

• Felhőfunkciók a Google-tól
• Azure Functions a Microsofttól

Mindezek a cégek kiszolgáló nélküli számítástechnikát, automatikus skálázást biztosítanak, és csak azért fizetnek, amit Ön ténylegesen használ, de bezárják az ügyfeleket a saját termékükbe. Vannak azonban ingyenes és nyílt forráskódú alternatívák a kiszolgáló nélküli számítástechnikához. Nem ér semmit:

• Felület Apache OpenWhisk, amelyet az IBM inkubátorban fejlesztett ki,
• Tavaszi felhőfunkciók, egy meglehetősen gazdag Spring Framework ökoszisztéma részeként, amely az AWS Lambda, az Azure Functions és az OpenWhisk homlokzataként is használható,
• Project Fn, amelyet az Oracle támogat.

Mindegyik teljesen független a felhőktől, azaz bármilyen felhőbe telepíthető, beleértve a saját, nyilvános vagy privát felhőt, és természetesen az Exoscale-ben is.

Hogyan működik az Fn projekt

Az Fn teljesen a Dockeren alapul, és két fő összetevőből áll:

• CLI program, amely az Fn infrastruktúra minden aspektusának kezelésére szolgál, és együttműködik az Fn szerverrel,
• Maga az Fn-kiszolgáló egy Docker-tárolóba csomagolt szokásos alkalmazás.

Az Fn-ben telepített funkciók külön konténerekben is végrehajtásra kerülnek, ami sok programozási nyelv támogatását teszi lehetővé, például... Clojure!

A függvény argumentumait a szabványos bemenetre (STDIN), az eredményeket a szabványos kimenetre (STDOUT) írják. Ha az argumentumok vagy a visszatérési értékek nem egyszerű értékek (például JSON-objektum), akkor konvertálhatók egy absztrakciós réteg segítségével, amelyet maga az Fn biztosít egy függvényfejlesztő készlet (FDK) formájában.

A kényelem kedvéért beépített sablonkészleteket kínálnak, amelyek megkönnyítik a FaaS telepítését a különböző nyelvek és verzióik kiterjedt listáján (Go, a Java különböző verziói, Python stb.).

A FaaS létrehozása egyszerű az alábbi diagram követésével:

• A funkció üzembe helyezése az Fn parancssori felület használatával: a kiválasztott sablon alapján létrejön egy alkalmazás konfigurációs fájl az Fn számára.
• Bemutatjuk a saját funkciónkat, ismét a CLI Fn használatával: a konténer kép egy bizonyos tárolóba kerül, majd a szerver értesítést kap ennek a képnek a létezéséről és elhelyezéséről.

A függvények Fn-be való eljuttatásának elve

Szerver nélküli funkciók helyi telepítése és tesztelése

Kezdjük el telepíteni az Fn-t a helyi gépre. Először a Docker telepítésre kerül, ahogy azt az Fn megköveteli. Feltételezve, hogy Debian/Ubuntu-n vagyunk:

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

Vagy használjon csomagkezelőt/Docker buildet a rendszerének megfelelően. Ezután közvetlenül folytathatja az Fn CLI telepítését. Például a curl használatával:

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

Ha OSX-et használ, és telepítve van a Homebrew, akkor a másik utat választja:

$ 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

Most már készen állunk arra, hogy a funkciót a CLI használatával először üzembe helyezzük. Az egyszerűség kedvéért beépített indítókörnyezetet fogunk használni, mint például a Node:

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

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

Egy új könyvtár jön létre hellonode hogy tovább fejleszthessük Fn funkciónkat néhány alapvető konfigurációs fájllal. Az újonnan létrehozott könyvtárban létrehozhatja az alkalmazást a választott nyelv vagy futási környezet szabványai szerint:

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

Az Fn létrehozza a kezdeti projektstruktúrát, létrehoz egy fájlt func.yaml, amely tartalmazza az Fn szükséges beállításait, és beállítja a kód sablonját a választott nyelven.

A Node futtatókörnyezet esetében ez a következőket jelenti:

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

Most gyorsan teszteljük a funkciónkat helyben, hogy megnézzük, hogyan működik minden.

Először elindítjuk az Fn szervert. Mint már említettük, az Fn-kiszolgáló egy Docker-tároló, ezért az indítás után elmegy, és átveszi a képet a Docker-nyilvántartásból.

$ 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

Funkciónk futtatásához „ki kell gurítani”. Ez megköveteli имя приложения: Az Fn nyelvben minden alkalmazást névtérként kell megadni a kapcsolódó függvényekhez.

Az Fn CLI megkeresi a fájlt func.yaml abban az aktuális könyvtárban, amelyet a funkció konfigurálásához használunk. Tehát először el kell mennie a könyvtárunkba 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

Amint a parancs kimenetéből látható, egy új Docker-tárolókép jön létre, amely tartalmazza a funkciónkat. A függvény készen áll a meghívásra, és ennek két módja van:

• az Fn paranccsal invoke
• keresztül hívja közvetlenül http

hívás invoke Az Fn-n keresztül egyszerűen emulálja a HTTP-n keresztüli munkát a tesztekhez, ami kényelmes a gyors teszteléshez:

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

{"message":"Hello World"}

Egy függvény közvetlen meghívásához ismernie kell a teljes URL-t:

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

{"message":"Hello World"}

Az Fn szerver a 8080-as porton teszi közzé funkcióit, és úgy tűnik, hogy a függvény URL-címe megegyezik a mintával t/app/function, de nem teljesen. A HTTP-n keresztül egy függvényt nem közvetlenül, hanem egy úgynevezett triggeren keresztül hívnak meg, amely a nevének megfelelően „indítja” a függvényhívást. A triggerek a következőben vannak meghatározva `func.yml projekt:

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

Megváltoztathatjuk a trigger nevét, hogy megfeleljen a függvény nevének, ez mindent leegyszerűsít:

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

Ezután újra futtatjuk a függvényszállítást, és egy új triggerből hívjuk meg:

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

{"message":"Hello World"}

Minden működik! Ideje áttérni a teljes körű kísérletekre, és közzétenni a FaaS-t a szerveren!

Szerver nélküli funkciószolgáltatások telepítése saját infrastruktúrájára

Telepítsünk gyorsan egy virtuális gépet az Exoscale CLI segítségével. Ha még nem állította be, használhatja rövid útmutatónkat. Ez egy nagyszerű eszköz, amely még jobban növeli a termelékenységet. Ne felejtse el, hogy be kell állítania egy szabályt a 8080-as port megnyitásához a biztonsági csoportban! A következő parancsok egy tiszta virtuális gépet indítanak el, amely készen áll a funkcióink fogadására:

$ 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

Ezután beállíthatja az ssh-t a virtuális gépbe, és telepítheti a távoli Fn-kiszolgálót:

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

Ezután telepítse a Dockert és az Fn-kiszolgálót ugyanúgy, mint a helyi gépen, indítsa el a kiszolgálót:

$ 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

Az Fn készen áll a funkciók fogadására! A funkciók távoli szerverre történő célzott átviteléhez a parancsot fogjuk használni deploy a helyi számítógépről a jelző elhagyásával --local.

Ezenkívül az Fn megköveteli az Fn-kiszolgáló és a Docker-nyilvántartás helyének megadását. Ezek az opciók környezeti változókon keresztül állíthatók be FN_API_URL и FN_REGISTRY illetve kényelmesebb módot kínál a telepítéshez szükséges konfigurációk létrehozásának és kezelésének egyszerű kezelésére.

Fn kifejezéssel a telepítéshez szükséges konfigurációt hívják context. A következő parancs hozza létre a kontextust:

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

Az elérhető kontextusokat így tekintheti meg:

$ fn list contexts

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

És váltson az imént létrehozott kontextusra, így:

 $ fn use context exoscale

 Now using context: exoscale

Innentől kezdve az Fn funkció kézbesítése a kiválasztott DockerHub-fiók használatával tölti le a Docker-képeket (az én esetemben - nfrankel), majd értesítse a távoli kiszolgálót (ebben a példában - http://185.19.30.175:8080) a funkcióját tartalmazó legújabb kép helyéről és verziójáról.

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

Végül:

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

{"message":"Hello World"}

Funkció életciklusa az Fn-alapú kiszolgáló nélküli számítástechnikában

A kiszolgáló nélküli számítástechnika előnyei saját kapacitással

A kiszolgáló nélküli számítástechnika kényelmes megoldás az alkalmazások olyan független részeinek gyors megvalósítására, amelyek kölcsönhatásba lépnek bonyolultabb alkalmazásokkal vagy mikroszolgáltatásokkal.

Ez gyakran a kiválasztott szállítóhoz való bezárás rejtett költségéből adódik, ami az adott felhasználási esettől és mennyiségtől függően magasabb költségekhez és csökkentett rugalmassághoz vezethet a jövőben.

A többfelhős és hibrid felhőarchitektúrák is szenvednek ebben az esetben, mert könnyen kerülhet olyan helyzetbe, hogy szeretne szerver nélküli számítástechnikát használni, de a vállalati szabályzatok miatt ez nem biztos, hogy lehetséges.

Az Fn használata meglehetősen egyszerű, és szinte ugyanazt a FaaS interfészt tudja biztosítani, kevés többletköltséggel. Kiküszöböli a szállítói bezárkózást, és telepíthető helyben vagy bármely kényelmes felhőmegoldás-szolgáltatóban, amelyet választott. A programozási nyelv kiválasztásában is van szabadság.

Ez a cikk csak az Fn alapjaival foglalkozik, de a saját futtatókörnyezet létrehozása meglehetősen egyszerű, és az általános architektúra szélesebb körben is telepíthető Fn terheléselosztó segítségével, vagy ha az Fn-t egy proxy mögé helyezi védelem céljából.

Forrás: will.com