är en av de mest framträdande trenderna inom cloud computing. Den grundläggande operativa principen är att infrastrukturen inte är DevOps, utan tjänsteleverantörens angelägenhet. Resursskalning anpassas automatiskt efter belastning och har en hög förändringshastighet.
Ett annat vanligt drag är tendensen att minimera och fokusera kod, varför serverlös datoranvändning ibland kallas för funktion som en tjänst (FaaS).
Historiskt sett var den första molnleverantören att erbjuda FaaS med AWS Lambda Amazon, därav namnet. Andra molntjänstleverantörer erbjuder också liknande:
- Molnfunktioner från Google
- Azure-funktioner från Microsoft
Alla dessa företag tillhandahåller serverlös datoranvändning, automatisk skalning och betalar bara för det du faktiskt använder, men de låser kunderna till sin egenutvecklade produkt. Det finns dock gratis och öppen källkodsalternativ för serverlös datoranvändning. Det är värt att notera:
- Plattform , utvecklad i en inkubator av IBM,
- , som en del av ett ganska rikt Spring Framework-ekosystem, som också kan användas som fasad för AWS Lambda, Azure Functions och OpenWhisk,
- , med stöd av Oracle.
Alla är helt oberoende av moln, det vill säga de kan installeras i vilket moln som helst, inklusive ditt eget, offentliga eller privata, och naturligtvis i Exoscale.
Hur Fn-projektet fungerar
Fn är helt baserat på Docker, består av två huvudkomponenter:
- CLI-program utformat för att hantera alla aspekter av Fn-infrastrukturen och interagerar med Fn-servern,
- Själva Fn-servern är en vanlig applikation paketerad i en Docker-behållare.
Funktionerna som distribueras i Fn körs också i separata behållare, vilket gör att du kan stödja många programmeringsspråk, till exempel... Clojure!
Funktionsargument skickas till standardingång (STDIN), resultat skrivs till standardutgång (STDOUT). Om argumenten eller returvärdena inte är enkla värden (som ett JSON-objekt) kan de konverteras med hjälp av ett abstraktionslager som tillhandahålls av Fn själv i form av ett Function Development Kit (FDK).
För enkelhetens skull erbjuds inbyggda uppsättningar av mallar för att underlätta distributionen av FaaS i en omfattande lista över olika språk och deras versioner (Go, olika versioner av Java, Python, etc.).
Att skapa en FaaS är lätt genom att följa detta diagram:
- Distribuera funktionen med Fn CLI: en applikationskonfigurationsfil för Fn skapas baserat på den valda mallen.
- Vi rullar ut vår egen funktion, återigen med CLI Fn: containerbilden placeras i ett visst arkiv, varefter servern meddelas om existensen och placeringen av denna bild.
Principen för att leverera funktioner till Fn
Lokal installation och testning av serverlösa funktioner
Låt oss börja installera Fn på den lokala maskinen. Först installeras Docker som krävs av Fn. Förutsatt att vi är på Debian/Ubuntu:
$ sudo apt-get update
$ sudo apt-get install docker.ioEller använd en pakethanterare/Docker-byggd enligt ditt system. Sedan kan du gå direkt till installationen av Fn CLI. Använd till exempel curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shOm du använder OSX med Homebrew installerat kan du gå åt andra hållet:
$ 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.7MBVi är nu redo att initialt distribuera vår funktion med hjälp av CLI. För enkelhetens skull kommer vi att använda en inbyggd lanseringsmiljö, som 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örtid:
# Каталог с 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 ursprungliga 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 valde.
När det gäller nodens körtid 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 redan nämnts är Fn-servern en Docker-behållare, därför kommer den, efter uppstart, att ta bilden 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 köra vår funktion måste den "rullas ut". Detta kräver имя приложения: I Fn måste alla applikationer anges som namnutrymmen 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 du 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 kommandoutgången skapas en ny Docker-containerbild som innehåller vår funktion. Funktionen är redo att anropas och vi har två sätt att göra det:
- med Fn-kommandot
invoke - ringer direkt via
http
samtal invoke via Fn emulerar den helt enkelt arbete via HTTP för tester, vilket är bekvämt för snabbtestning:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}För att kunna anropa en funktion direkt måste du känna till hela URL:en:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Fn-servern exponerar sina funktioner på port 8080 och funktionen URL verkar matcha mönstret t/app/function, men inte helt. Genom HTTP anropas inte en funktion direkt, utan genom en så kallad trigger, som enligt sitt namn ”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 för att matcha funktionsnamnet, detta kommer att förenkla allt:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииSedan börjar vi leverera funktionen igen och anropar den från en ny trigger:
$ 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 fullskaliga experiment och publicera vår FaaS på servern!
Installera serverlösa funktionstjänster på din egen infrastruktur
Låt oss snabbt installera en virtuell maskin med Exoscale CLI. Om du inte har konfigurerat det ännu kan du använda . Detta är ett coolt verktyg som kommer att öka din produktivitet ännu mer. Glöm inte att du måste konfigurera en regel för att öppna port 8080 i säkerhetsgruppen! Följande kommandon kommer att starta en ren virtuell maskin, 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 ssh till 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)Installera sedan Docker och Fn-servern på samma sätt som redan gjordes på den lokala maskinen, starta 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 en fjärrserver kommer vi att använda kommandot deploy från den lokala datorn genom att utelämna flaggan --local.
Dessutom kräver Fn att du anger platsen för Fn-servern och Docker-registret. Dessa alternativ kan ställas in via miljövariabler FN_API_URL и FN_REGISTRY men erbjuder också ett bekvämare sätt att enkelt hantera skapandet och hanteringen av konfigurationer för distribution.
I Fn-termer anropas konfigurationen för distribution context. Följande kommando skapar sammanhanget:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelDu kan se de tillgängliga sammanhangen 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 sammanhanget som just skapades så här:
$ fn use context exoscale
Now using context: exoscaleFrån och med nu kommer leveransen av Fn-funktionen att ladda ner Docker-bilder med det valda DockerHub-kontot (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 Fn-baserad serverlös datoranvändning
Fördelar med serverlös datoranvändning på egen kapacitet
Serverlös datoranvändning ä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 låsa sig till den valda leverantören, vilket beroende på det specifika användningsfallet och volymen kan leda till högre kostnader och minskad flexibilitet i framtiden.
Flermoln och hybridmolnarkitekturer lider också i det här fallet, eftersom du lätt kan hamna i en situation där du skulle vilja använda serverlös datoranvändning, men på grund av företagspolicyer kanske det inte är möjligt.
Fn är ganska lätt att använda och kan ge nästan samma FaaS-gränssnitt, med lite overhead. Det eliminerar alla inlåsningar från leverantörer och kan installeras lokalt eller i valfri bekväm molnlösningsleverantör du väljer. Det finns också frihet i att välja ett programmeringsspråk.
Den här artikeln täcker bara grunderna i Fn, men att skapa din egen körtid är ganska enkelt, och den övergripande arkitekturen kan distribueras mer brett med hjälp av en Fn-lastbalanserare, eller genom att placera Fn bakom en proxy för skydd.
Källa: will.com