— en av de mest märkbara trenderna inom molntjänster. Grundprincipen för driften är att infrastrukturen inte är DevOps ansvar, utan tjänsteleverantörens. Resursskalning anpassar sig automatiskt till belastningen och har en hög förändringstakt.
Ett annat vanligt drag är tendensen att minimera och fokusera kod, vilket är anledningen till att serverlös databehandling ibland kallas "funktion som en tjänst" (FaaS).
Historiskt sett var Amazon den första molntjänstleverantören som erbjöd FaaS med AWS Lambda, därav namnet. Andra molntjänstleverantörer erbjuder också liknande erbjudanden:
- Molnfunktioner från Google
- Azure Functions av Microsoft
Alla dessa företag erbjuder serverlös databehandling, automatisk skalning och prissättning baserat på användning, men de låser kunderna till sin egenutvecklade produkt. Det finns dock gratis alternativ med öppen källkod för serverlös databehandling. Det är värt att notera:
- Plattform , utvecklad i en inkubator av IBM,
- , som en del av det omfattande Spring Framework-ekosystemet, som också kan användas som en fasad för AWS Lambda, Azure Functions och OpenWhisk,
- , som stöds av Oracle.
Alla är helt moln-agnostiska, vilket innebär att de kan installeras i vilket moln som helst, inklusive ditt eget, publikt eller privat, och naturligtvis i Exoscale.
Hur Fn-projektet fungerar
Fn är helt baserat på Docker och består av två huvudkomponenter:
- CLI-program utformat för att hantera alla aspekter av Fn-infrastrukturen och interagera med Fn-servern,
- Själva Fn-servern är en vanlig applikation paketerad i en Docker-container.
Funktioner som distribueras i Fn exekveras också i separata containrar, vilket gör att vi kan stödja en hel del programmeringsspråk, som till exempel… Clojure!
Funktionsargument skickas till standardingången (STDIN) och resultaten skrivs till standardutgången (STDOUT). Om argumenten eller returvärdena inte är enkla värden (t.ex. ett JSON-objekt) kan de transformeras med hjälp av ett abstraktionslager som tillhandahålls av Fn självt i form av ett Function Development Kit (FDK).
För enkelhetens skull erbjuds inbyggda malluppsättningar för att underlätta FaaS-distribution i en mängd olika språk och deras versioner (Go, olika versioner av Java, Python, etc.).
Det är enkelt att skapa en FaaS, följ det här diagrammet:
- Distribuera funktionen med Fn CLI: Detta skapar en programkonfigurationsfil för Fn baserat på den valda mallen.
- Vi rullar ut vår egen funktion, återigen med hjälp av CLI Fn: containeravbildningen placeras i ett visst repository, varefter servern meddelas om existensen och platsen för denna avbildning.
Principen för att tillhandahålla funktioner i Fn
Installera och testa serverlösa funktioner lokalt
Låt oss börja med att installera Fn på den lokala maskinen. Först installerar vi Docker, vilket krävs av Fn. Detta förutsätter att vi är på Debian/Ubuntu:
$ sudo apt-get update
$ sudo apt-get install docker.ioEller använd pakethanteraren/Docker-versionen enligt ditt system. Sedan kan du gå direkt till installationen av Fn CLI. Till exempel, med curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shOm du kör OSX med Homebrew installerat kan du ta en annan väg:
$ 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.7MBNu är vi redo att driftsätta vår funktion initialt med hjälp av CLI. För enkelhetens skull kommer vi att använda en inbyggd runtime, till exempel Node:
$ fn init --runtime node --trigger http hellonode
Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.En ny katalog kommer att skapas. hellonode för att vidareutveckla vår Fn-funktion med några grundläggande konfigurationsfiler. Inuti den nyskapade katalogen kan du skapa din applikation enligt standarderna för ditt valda språk eller körningstid:
# Каталог с 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 skapar den initiala projektstrukturen, skapar en fil func.yaml, som innehåller de nödvändiga inställningarna för Fn, och ställer in mallen för koden på det språk du har valt.
När det gäller Node-körtiden betyder detta:
$ 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}
})Nu ska vi snabbt testa vår funktion lokalt för att se hur allt fungerar.
Först startar vi Fn-servern. Som nämnts är Fn-servern en Docker-container, så efter uppstarten kommer den att hämta en avbildning från Docker-registret.
$ 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
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5För att lansera vår funktion behöver vi "rulla ut den". Detta kräver имя приложенияI Fn måste alla applikationer anges som namnrymder för relaterade funktioner.
Fn CLI kommer att söka efter filen func.yaml i den aktuella katalogen, som kommer att användas för att konfigurera funktionen. Så först måste vi gå till vår katalog 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-triggerSom du kan se från kommandots utdata skapas en ny Docker-containeravbildning som innehåller vår funktion. Funktionen är redo att anropas, och vi har två sätt att göra detta:
- med hjälp av Fn-kommandot
invoke - ringer direkt via
http
samtal invoke via Fn emulerar helt enkelt arbete över HTTP för tester, vilket är bekvämt för snabb kontroll:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}För att anropa funktionen direkt behöver du veta hela URL:en:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Fn-servern exponerar sina funktioner på port 8080, och funktionens URL verkar matcha schemat. t/app/function, men inte helt. Via HTTP anropas inte funktionen direkt, utan via den så kallade triggern, som, som namnet antyder, "startar" funktionsanropet. Triggers definieras i `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 триггераVi kan ändra triggernamnet så att det matchar funktionsnamnet, detta kommer att göra saker enklare:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииSedan kör vi funktionsleveransen igen och anropar den från den nya triggern:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Allt fungerar! Det är dags att gå vidare till verkliga experiment och publicera vår FaaS på servern!
Installera serverlösa funktionstjänster på din egen infrastruktur
Låt oss snabbt konfigurera en virtuell maskin med Exoscale CLI. Om du inte har konfigurerat den än kan du använda Detta är ett coolt verktyg som ytterligare kommer att öka din produktivitet. Glöm inte att ställa in en regel för att öppna port 8080 i säkerhetsgruppen! Följande kommandon startar en ren virtuell maskin som är redo att vara värd för våra funktioner:
$ 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-securitygroupSedan kan du logga in via ssh på den virtuella maskinen och installera den fjärranslutna Fn-servern:
$ 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)Sedan installerar vi Docker och Fn-servern på samma sätt som vi gjorde på den lokala maskinen och startar servern:
$ 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 är redo att ta emot funktioner! För riktad överföring av funktioner till fjärrservern använder vi kommandot deploy från den lokala datorn, utan flaggan --local.
Dessutom kräver Fn att du anger platsen för Fn-servern och Docker-registret. Dessa parametrar kan ställas in via miljövariabler. FN_API_URL и FN_REGISTRY respektive, men erbjuder också ett mer bekvämt sätt att enkelt hantera skapandet och hanteringen av distributionskonfigurationer.
I Fn-termer kallas distributionskonfigurationen contextFöljande kommando skapar en kontext:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelDu kan se tillgängliga sammanhang så här:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
Och byt till det sammanhang som just skapades så här:
$ fn use context exoscale
Now using context: exoscaleFrån och med nu kommer Fn-funktionsleveransen att ladda ner Docker-avbildningar med det valda kontot på DockerHub (i mitt fall, nfrankel), och meddela sedan fjärrservern (i det här exemplet, http://185.19.30.175:8080) om platsen och versionen av den senaste bilden som innehåller din funktion.
$ 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 .Till sist:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Funktionslivscykel i serverlös databehandling baserad på Fn
Fördelar med lokal serverlös databehandling
Serverlös databehandling är en bekväm lösning för att snabbt implementera oberoende delar av en applikation som interagerar med mer komplexa applikationer eller mikrotjänster.
Detta beror ofta på den dolda kostnaden för att binda en vald leverantör, vilket, beroende på det specifika användningsfallet och volymen, kan resultera i högre kostnader och mindre flexibilitet i framtiden.
Multimoln- och hybridmolnarkitekturer lider också i detta fall, eftersom man lätt kan hamna i en situation där man skulle vilja använda serverlös databehandling, men på grund av företagets policyer kanske det inte är möjligt.
Fn är ganska lätt att arbeta med och kan erbjuda nästan samma gränssnitt som FaaS, med låg omkostnad. Det eliminerar all leverantörslåsning, du kan installera det lokalt eller hos vilken bekväm molnleverantör som helst. Det finns också frihet att välja programmeringsspråk.
Den här artikeln täcker bara grunderna i Fn, men att skapa din egen runtime är ganska enkelt, och den övergripande arkitekturen kan skalas upp ytterligare genom att använda en Fn-belastningsutjämnare eller genom att placera Fn bakom en proxy för skydd.
Källa: will.com
