Budování našeho vlastního serveru bez serveru založeného na Fn

Bezserverové výpočty je jedním z nejvýznamnějších trendů v oblasti cloud computingu. Základním principem fungování je, že infrastruktura není záležitostí DevOps, ale poskytovatele služeb. Měřítko zdrojů se automaticky přizpůsobuje zatížení a má vysokou rychlost změn.

Dalším společným rysem je tendence minimalizovat a soustředit se na kód, což je důvod, proč se bezserverové výpočty někdy nazývají funkce jako služba (FaaS).

Historicky prvním cloudovým poskytovatelem, který nabídl FaaS s AWS Lambda, byl Amazon, odtud název. Další poskytovatelé cloudových služeb také nabízejí podobné:

• Cloudové funkce od společnosti Google
• Azure Functions od Microsoftu

Všechny tyto společnosti poskytují bezserverové výpočty, automatické škálování a platí pouze za to, co skutečně používáte, ale zamknou zákazníky do svého proprietárního produktu. Existují však bezplatné a open source alternativy pro bezserverové výpočty. Za zmínku stojí:

• Plošina Apache OpenWhisk, vyvinuté v inkubátoru IBM,
• Jarní cloudové funkce, jako součást poměrně bohatého ekosystému Spring Framework, který lze také použít jako fasádu pro AWS Lambda, Azure Functions a OpenWhisk,
• Projekt Fn, podporované společností Oracle.

Všechny jsou zcela nezávislé na cloudech, to znamená, že je lze nainstalovat do jakéhokoli cloudu, včetně vašeho vlastního, veřejného nebo soukromého, a samozřejmě do Exoscale.

Jak funguje projekt Fn

Fn je zcela založen na Dockeru a skládá se ze dvou hlavních komponent:

• Program CLI určený ke správě všech aspektů infrastruktury Fn a spolupracuje se serverem Fn,
• Samotný Fn server je běžná aplikace zabalená v kontejneru Docker.

Funkce nasazené ve Fn jsou také vykonávány v samostatných kontejnerech, což vám umožňuje například podporovat spoustu programovacích jazyků... Clojure!

Argumenty funkce jsou předávány na standardní vstup (STDIN), výsledky jsou zapisovány na standardní výstup (STDOUT). Pokud argumenty nebo návratové hodnoty nejsou jednoduchými hodnotami (jako je objekt JSON), lze je převést pomocí abstraktní vrstvy poskytované samotným Fn ve formě sady Function Development Kit (FDK).

Pro pohodlí jsou nabízeny vestavěné sady šablon pro usnadnění nasazení FaaS v rozsáhlém seznamu různých jazyků a jejich verzí (Go, různé verze Java, Python atd.).

Vytvoření FaaS je snadné podle tohoto schématu:

• Nasazení funkce pomocí Fn CLI: Na základě vybrané šablony se vytvoří konfigurační soubor aplikace pro Fn.
• Zavádíme vlastní funkci, opět pomocí CLI Fn: obraz kontejneru je umístěn do určitého úložiště, načež je server informován o existenci a umístění tohoto obrazu.

Princip doručování funkcí do Fn

Lokální instalace a testování bezserverových funkcí

Začněme instalovat Fn na místní počítač. Nejprve se nainstaluje Docker, jak vyžaduje Fn. Za předpokladu, že jsme na Debian/Ubuntu:

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

Nebo použijte správce balíčků/docker sestavení podle vašeho systému. Poté můžete přejít přímo k instalaci Fn CLI. Například pomocí curl:

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

Pokud používáte OSX s nainstalovaným Homebrew, můžete jít jiným způsobem:

$ 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

Nyní jsme připraveni na první nasazení naší funkce pomocí CLI. Pro jednoduchost použijeme vestavěné spouštěcí prostředí, jako je Node:

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

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

Bude vytvořen nový adresář hellonode k dalšímu rozvoji naší funkce Fn pomocí některých základních konfiguračních souborů. V nově vytvořeném adresáři můžete vytvořit aplikaci podle standardů vámi zvoleného jazyka nebo runtime:

# Каталог с 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 vytvoří počáteční strukturu projektu, vytvoří soubor func.yaml, obsahující nezbytná nastavení pro Fn, a nastaví šablonu pro kód ve vámi zvoleném jazyce.

V případě běhového prostředí Node to znamená:

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

Nyní rychle otestujeme naši funkci lokálně, abychom viděli, jak vše funguje.

Nejprve spustíme Fn server. Jak již bylo zmíněno, Fn server je kontejner Docker, proto po spuštění přejde a vezme obraz z registru Docker.

$ 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

Aby naše funkce fungovala, musí být „vypuštěna“. To vyžaduje имя приложения: V Fn musí být všechny aplikace specifikovány jako jmenné prostory pro související funkce.

Fn CLI vyhledá soubor func.yaml v aktuálním adresáři, který bude použit ke konfiguraci funkce. Nejprve tedy musíte jít do našeho adresáře 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

Jak můžete vidět z výstupu příkazu, je vytvořen nový obrázek kontejneru Docker obsahující naši funkci. Funkce je připravena k volání a máme dva způsoby, jak to udělat:

• pomocí příkazu Fn invoke
• volání přímo přes http

Výzva invoke přes Fn jednoduše emuluje práci přes HTTP pro testy, což je vhodné pro rychlé testování:

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

{"message":"Hello World"}

Abyste mohli funkci volat přímo, potřebujete znát úplnou adresu URL:

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

{"message":"Hello World"}

Fn server zpřístupňuje své funkce na portu 8080 a adresa URL funkce se zdá odpovídat vzoru t/app/function, ale ne úplně. Přes HTTP se funkce nevolá přímo, ale přes tzv. trigger, který podle svého názvu „spustí“ volání funkce. Spouštěče jsou definovány v `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 триггера

Můžeme změnit název spouštěče tak, aby odpovídal názvu funkce, tím se vše zjednoduší:

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

Poté začneme znovu dodávat funkci a voláme ji z nového spouštěče:

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

{"message":"Hello World"}

Všechno funguje! Je čas přejít k experimentům v plném rozsahu a publikovat naše FaaS na serveru!

Instalace služeb funkcí bez serveru na vlastní infrastrukturu

Pojďme rychle nainstalovat virtuální stroj pomocí Exoscale CLI. Pokud jste to ještě nenastavili, můžete použít náš průvodce rychlým startem. Jedná se o skvělý nástroj, který ještě více zvýší vaši produktivitu. Nezapomeňte, že musíte nakonfigurovat pravidlo pro otevření portu 8080 ve skupině zabezpečení! Následující příkazy spustí čistý virtuální stroj připravený hostit naše funkce:

$ 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

Poté můžete ssh do virtuálního počítače a nainstalovat vzdálený Fn server:

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

Poté nainstalujte Docker a Fn server stejným způsobem, jaký jste již provedli na místním počítači, spusťte server:

$ 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 je připraven přijímat funkce! Pro cílený přenos funkcí na vzdálený server použijeme příkaz deploy z místního počítače vynecháním příznaku --local.

Kromě toho Fn vyžaduje, abyste zadali umístění Fn serveru a registru Docker. Tyto možnosti lze nastavit pomocí proměnných prostředí FN_API_URL и FN_REGISTRY respektive, ale také nabízí pohodlnější způsob, jak snadno spravovat vytváření a správu konfigurací pro nasazení.

Z hlediska Fn se nazývá konfigurace pro nasazení context. Následující příkaz vytvoří kontext:

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

Dostupné kontexty můžete zobrazit takto:

$ fn list contexts

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

A přepněte do kontextu, který byl právě vytvořen takto:

 $ fn use context exoscale

 Now using context: exoscale

Od této chvíle bude dodávka funkce Fn stahovat obrázky Docker pomocí vybraného účtu DockerHub (v mém případě - nfrankel) a poté upozorněte vzdálený server (v tomto příkladu - http://185.19.30.175:8080) o umístění a verzi nejnovějšího obrázku obsahujícího vaši funkci.

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

Konečně:

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

{"message":"Hello World"}

Životní cyklus funkcí ve Fn-Based Serverless Computing

Výhody bezserverového počítání při vlastní kapacitě

Bezserverové výpočty jsou pohodlné řešení pro rychlou implementaci nezávislých částí aplikace, které interagují se složitějšími aplikacemi nebo mikroslužbami.

To je často způsobeno skrytými náklady na uzamčení vybraného dodavatele, což v závislosti na konkrétním případu použití a objemu může v budoucnu vést k vyšším nákladům a snížené flexibilitě.

Multicloudové a hybridní cloudové architektury v tomto případě také trpí, protože se snadno můžete dostat do situace, kdy byste rádi používali bezserverové výpočty, ale kvůli firemním politikám to nemusí být možné.

Fn se poměrně snadno používá a může poskytnout téměř stejné rozhraní FaaS s malou režií. Eliminuje jakékoli uzamčení dodavatele a lze jej nainstalovat lokálně nebo v libovolném vhodném poskytovateli cloudových řešení podle vašeho výběru. Svoboda je také ve výběru programovacího jazyka.

Tento článek pokrývá pouze základy Fn, ale vytvoření vlastního běhového prostředí je poměrně jednoduché a celkovou architekturu lze nasadit šířeji pomocí nástroje pro vyrovnávání zatížení Fn nebo umístěním Fn za proxy pro ochranu.

Zdroj: www.habr.com