— one of the most notable trends in cloud computing. The main principle of operation is that the infrastructure is the responsibility of the service provider, not the DevOps. Resource scaling automatically adjusts to the load and has a high speed of change.
Another common feature is the trend towards minimizing and focusing code, which is why serverless computing is sometimes called 'function as a service' (FaaS).
Historically, the first cloud service provider to offer FaaS with AWS Lambda was Amazon, which is where this name originated. Other cloud service providers also offer similar solutions:
- Cloud Functions from Google
- Azure Functions from Microsoft
All these companies provide serverless computing, automatic scaling, and payment only for resources actually used, but they tie clients to their proprietary product. However, there are free open-source alternatives for organizing serverless computing. It is worth noting:
- The platform , developed in the incubator by IBM,
- , as part of a fairly rich ecosystem of Spring Framework, which can also be used as a facade for AWS Lambda, Azure Functions, and OpenWhisk,
- , supported by Oracle.
All of them are completely cloud-independent, meaning they can be installed in any cloud, including your own, public, or private, and of course in Exoscale.
How the Fn project is structured
Fn is entirely based on Docker and consists of two main components:
- A CLI tool designed to manage all aspects of the Fn infrastructure, and interacting with the Fn server,
- The actual Fn server, a regular application packed in a Docker container.
Functions deployed in Fn also run in separate containers, allowing support for many programming languages, such as… Clojure!
Function arguments are passed to standard input (STDIN), and results are written to standard output (STDOUT). If the arguments or returned values are not simple values (such as a JSON object) — they can be converted using the abstraction layer provided by Fn in the form of a Function Development Kit (FDK).
Pro pohodlí jsou nabízeny vestavěné šablony, které usnadňují nasazení FaaS na široké řadě různých jazyků a jejich verzí (Go, různé verze Java, Python atd.).
Vytvoření FaaS je snadné podle této schémy:
- Nasazení funkce pomocí CLI Fn: je vytvořen konfigurační soubor aplikace pro Fn na základě zvolené šablony.
- Nasazení vlastní funkce opět pomocí CLI Fn: obraz kontejneru je umístěn do nějakého depozitáře, poté je server informován o existenci a umístění tohoto obrazu.
Princip dodávání funkcí do Fn
Lokální instalace a testování serverless funkcí
Přejdeme k instalaci Fn na místním stroji. Nejprve se nainstaluje Docker, jak vyžaduje Fn. Předpokládáme, že pracujeme na Debianu/Ubuntu:
$ sudo apt-get update
$ sudo apt-get install docker.ioNebo použijte správce balíčků/instrumentaci Docker podle vašeho systému. Poté můžeme přímo přejít k instalaci Fn CLI. Například pomocí curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shPokud pracujete na OSX s nainstalovaným Homebrew, můžete jít jinou cestou:
$ brew install fn
==> Stahování https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Stahování z https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Příprava fn-0.5.8.high_sierra.bottle.tar.gz
/usr/local/Cellar/fn/0.5.8: 5 souborů, 16.7MBNyní je vše připraveno pro první nasazení naší funkce pomocí CLI. Pro jednoduchost budeme používat vestavěné prostředí pro spuštění, například Node:
$ fn init --runtime node --trigger http hellonode
Vytváření funkce v: /hellonode
Funkční základní šablona vygenerována.
func.yaml vytvořen.Bude vytvořen nový adresář hellonode pro další vývoj naší funkce Fn s některými základními konfiguračními soubory. Uvnitř nově vytvořeného adresáře můžete vytvořit vaši aplikaci, která odpovídá standardům zvoleného jazyka nebo prostředí:
# Каталог с 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.javaFn vytváří počáteční strukturu projektu, vytváří soubor func.yaml, který obsahuje nezbytná nastavení pro Fn, a nastavuje šablonu pro kód v jazyce, který jste zvolili.
V případě 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 zkontrolujeme naši funkci lokálně, abychom viděli, jak vše funguje.
Nejprve spustíme server Fn. Jak již bylo řečeno, server Fn je Docker kontejner, takže po spuštění vezme obraz z Docker registry.
$ fn start -d # spustíme lokální server na pozadí
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
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Abychom mohli spustit naši funkci, musíme ji „vydat“. K tomu potřebujeme název aplikace: ve Fn musí být všechny aplikace definovány jako názvové prostory pro související funkce.
Fn CLI hledá soubor func.yaml v aktuálním adresáři, který se použije pro konfiguraci funkce. Takže se nejprve musíme přesunout do našeho adresáře hellonode.
$ cd hellonode
$ fn deploy --app fnexo --local # vydáváme funkci lokálně, název aplikace - fnexo.
# parametr local nevytlačuje obraz do vzdáleného registru,
# spouští ho přímo
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-triggerJak vidíte z výstupu příkazu, vytváří se nový obraz kontejneru pro Docker, který obsahuje 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ím přímo přes
http
Zavolání invoke přes Fn emuluje práci přes HTTP pro testování, což je vhodné pro rychlé ověření:
$ fn invoke fnexo hellonode # voláme funkci hellonode aplikace fnexo
{"message":"Hello World"}Abychom mohli funkci volat přímo, musíme znát kompletní URL:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Server Fn poskytuje své funkce přes port 8080, a jak se zdá, URL funkce odpovídá schématu t/app/function, ale ne zcela. Skrze HTTP je funkce volána nepřímo, ale skrze takzvaný trigger, který podle svého jména „spouští“ volání funkce. Triggery jsou definovány v `func.yml projektu:
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 triggeruMůžeme změnit jméno triggeru, aby odpovídalo názvu funkce, což vše zjednoduší:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # odpovídá názvu funkcePak znovu spustíme dodání funkce a zavoláme ji z nového triggeru:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Ahoj světe"}Všechno funguje! Je čas přejít k reálným experimentům a publikovat náš FaaS na serveru!
Instalace serverless funkcí na vlastní infrastruktuře
Rychle nainstalujme virtuální stroj pomocí CLI Exoscale. Pokud jej ještě nemáte nastavený — můžete použít . To je skvělý nástroj, který ještě více zvýší vaši produktivitu. Nezapomeňte nastavit pravidlo pro otevření portu 8080 ve skupině zabezpečení! Následující příkazy spustí čistý virtuální stroj, připravený pro nasazení našich funkcí:
$ 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-securitygroupPak se můžete přihlásit na virtuální stroj přes ssh a nainstalovat vzdálený server Fn:
$ exo ssh fn-server
Autenticita hostitele '185.19.30.175 (185.19.30.175)' nemůže být ověřena.
ECDSA klíčový otisk je SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Opravdu chcete pokračovat v připojení (ano/ne)? ano
Varování: Trvale přidáno '185.19.30.175' (ECDSA) do seznamu známých hostitelů.
Vítejte na Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)Nyní nainstalujeme Docker a server Fn stejně, jak to již bylo provedeno na lokálním stroji, a spustíme 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.643Fn je připraven k přijímání funkcí! Pro cílové nasazení funkcí na vzdálený server použijeme příkaz deploy z lokálního počítače s vynecháním přepínače --local.
Kromě toho Fn vyžaduje nastavit adresu serveru Fn a registru Docker. Tyto parametry mohou být nastaveny prostřednictvím proměnných prostředí FN_API_URL a FN_REGISTRY příslušně, ale je zde i pohodlnější způsob pro snadnou správu vytváření a správy konfigurací pro nasazení.
V termínech Fn se konfigurace pro nasazení nazývá context. Následující příkaz vytvoří kontext:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelMůžete si prohlédnout dostupné kontexty 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řepnout na kontext, který byl právě vytvořen, takto:
$ fn use context exoscale
Nyní používáte kontext: exoscaleOd tohoto místa bude dodání funkcí Fn načítat obrazy Docker pomocí vybraného účtu na DockerHub (v mém případě — nfrankel), po kterém informuje vzdálený server (v tomto příkladu — http://185.19.30.175:8080) o umístění a verzi posledního obrazu, který obsahuje vaši funkci.
$ fn deploy --app fnexo . # provádí se na lokálním stroji z adresáře hellonode
Nasazení funkce na:
Nasazení hellonode do aplikace: fnexo
Zvýšeno na verzi 0.0.5
Vytváření obrazu nfrankel/hellonode:0.0.5 .Nakonec:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Životní cyklus funkce v bezserverových výpočtech založených na Fn
Výhody bezserverových výpočtů na vlastních prostředcích
Bezserverové výpočty jsou pohodlným řešením pro rychlé nasazení nezávislých částí aplikace, které interagují s komplexnějšími aplikacemi nebo microservices.
Často to souvisí se skrytou cenou vázání na vybraného poskytovatele, což může v závislosti na konkrétním scénáři použití a objemu vést k vyšším nákladům a snížení flexibility do budoucna.
Vícecloudové a hybridní cloudové architektury také trpí v takovém případě, protože se můžete snadno ocitnout v situaci, kdy byste chtěli používat bezserverové výpočty, ale kvůli firemní politice to může být nemožné.
Fn je dostatečně jednoduchý na používání, může poskytnout téměř stejný FaaS rozhraní s minimálními náklady. Odstraní jakékoli vazby na poskytovatele, může být nainstalován lokálně nebo u jakéhokoliv vhodného poskytovatele cloudových řešení podle vašeho výběru. Také máte volnost ve výběru programovacího jazyka.
V článku jsou uvedeny pouze základy Fn, ale vytvoření vlastního prostředí pro provádění je dost jednoduché a celkovou architekturu lze rozšířit použitím vyvažovače zatížení Fn, nebo umístěním Fn za proxy pro ochranu.
Zdroj: habr.com
