is een van de meest opvallende trends op het gebied van cloud computing. Het basisprincipe is dat infrastructuur niet de zorg is van DevOps, maar van de serviceprovider. Het schalen van resources wordt automatisch aangepast aan de belasting en kent een hoge mate van verandering.
Een ander gemeenschappelijk kenmerk is de neiging om code te minimaliseren en te focussen. Daarom wordt serverloos computergebruik ook wel Function as a Service (FaaS) genoemd.
Historisch gezien was Amazon de eerste cloudprovider die FaaS met AWS Lambda aanbood, vandaar de naam. Andere cloudserviceproviders bieden ook soortgelijke diensten aan:
- Cloudfuncties van Google
- Azure-functies van Microsoft
Al deze bedrijven bieden serverloos computergebruik, automatische schaling en betalen alleen voor wat u daadwerkelijk gebruikt, maar ze sluiten klanten op aan hun eigen product. Er zijn echter gratis en open source-alternatieven voor serverloos computergebruik. Het is niks waard:
- Platform , ontwikkeld in een incubator door IBM,
- , als onderdeel van een redelijk rijk Spring Framework-ecosysteem, dat ook kan worden gebruikt als gevel voor AWS Lambda, Azure Functions en OpenWhisk,
- , ondersteund door Oracle.
Ze zijn allemaal volledig onafhankelijk van de cloud, dat wil zeggen dat ze in elke cloud kunnen worden geïnstalleerd, inclusief die van jou, openbaar of privé, en natuurlijk in Exoscale.
Hoe het Fn-project werkt
Fn is volledig gebaseerd op Docker en bestaat uit twee hoofdcomponenten:
- CLI-programma ontworpen om alle aspecten van de Fn-infrastructuur te beheren en communiceert met de Fn-server,
- De Fn-server zelf is een reguliere applicatie verpakt in een Docker-container.
De functies die in Fn worden ingezet, worden ook in aparte containers uitgevoerd, waardoor je veel programmeertalen kunt ondersteunen, bijvoorbeeld... Clojure!
Functieargumenten worden doorgegeven aan standaardinvoer (STDIN), resultaten worden geschreven naar standaarduitvoer (STDOUT). Als de argumenten of retourwaarden geen eenvoudige waarden zijn (zoals een JSON-object), kunnen ze worden geconverteerd met behulp van een door Fn zelf aangeleverde abstractielaag in de vorm van een Function Development Kit (FDK).
Voor het gemak worden ingebouwde sets met sjablonen aangeboden om de implementatie van FaaS te vergemakkelijken in een uitgebreide lijst met verschillende talen en hun versies (Go, verschillende versies van Java, Python, enz.).
Het maken van een FaaS is eenvoudig door dit diagram te volgen:
- Implementatie van de functie met behulp van de Fn CLI: er wordt een applicatieconfiguratiebestand voor Fn gemaakt op basis van de geselecteerde sjabloon.
- We rollen een eigen functie uit, wederom met behulp van CLI Fn: de containerimage wordt in een bepaalde repository geplaatst, waarna de server op de hoogte wordt gesteld van het bestaan en de plaatsing van deze image.
Het principe van het leveren van functies aan Fn
Lokale installatie en testen van serverloze functies
Laten we beginnen met het installeren van Fn op de lokale machine. Eerst wordt Docker geïnstalleerd, zoals vereist door Fn. Ervan uitgaande dat we Debian/Ubuntu gebruiken:
$ sudo apt-get update
$ sudo apt-get install docker.ioOf gebruik een pakketbeheerder/Docker-build volgens uw systeem. Vervolgens kunt u direct doorgaan met het installeren van de Fn CLI. Als u bijvoorbeeld krul gebruikt:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shAls u OSX gebruikt en Homebrew is geïnstalleerd, kunt u de andere kant op gaan:
$ 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.7MBWe zijn nu klaar om onze functie in eerste instantie te implementeren met behulp van de CLI. Voor de eenvoud zullen we een ingebouwde opstartomgeving gebruiken, zoals Node:
$ fn init --runtime node --trigger http hellonode
Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.Er wordt een nieuwe map aangemaakt hellonode om onze Fn-functie verder te ontwikkelen met enkele basisconfiguratiebestanden. In de nieuw aangemaakte directory kunt u uw applicatie maken volgens de standaarden van de door u gekozen taal of 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.javaFn creëert de initiële projectstructuur, creëert een bestand func.yaml, met de benodigde instellingen voor Fn, en stelt de sjabloon in voor de code in de door u gekozen taal.
In het geval van de Node-runtime betekent dit:
$ 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 gaan we onze functie snel lokaal testen om te zien hoe alles werkt.
Eerst starten we de Fn-server. Zoals eerder vermeld, is de Fn-server een Docker-container en daarom zal deze na het opstarten de afbeelding uit het Docker-register halen.
$ 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
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Om onze functie te kunnen uitvoeren, moet deze worden “uitgerold”. Dit vereist имя приложения: In Fn moeten alle toepassingen worden opgegeven als naamruimten voor gerelateerde functies.
Fn CLI zoekt naar het bestand func.yaml in de huidige map die zal worden gebruikt om de functie te configureren. Dus eerst moet je naar onze directory gaan 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-triggerZoals je kunt zien aan de hand van de opdrachtuitvoer, wordt er een nieuwe Docker-containerimage gemaakt met daarin onze functie. De functie is klaar om te worden aangeroepen en we hebben twee manieren om dit te doen:
- met behulp van de Fn-opdracht
invoke - direct bellen via
http
telefoontje invoke via Fn emuleert het eenvoudigweg werk via HTTP voor tests, wat handig is voor snel testen:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}Om een functie rechtstreeks aan te roepen, moet u de volledige URL kennen:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}De Fn-server stelt zijn functies beschikbaar op poort 8080 en de functie-URL lijkt overeen te komen met het patroon t/app/function, maar niet volledig. Via HTTP wordt een functie niet rechtstreeks aangeroepen, maar via een zogenaamde trigger, die, zoals de naam zegt, de functieaanroep ‘start’. Triggers worden gedefinieerd in `func.yml project:
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 триггераWe kunnen de triggernaam wijzigen zodat deze overeenkomt met de functienaam, dit zal alles vereenvoudigen:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииVervolgens voeren we de functielevering opnieuw uit en roepen deze aan vanaf een nieuwe trigger:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Alles werkt! Het is tijd om verder te gaan met grootschalige experimenten en onze FaaS op de server te publiceren!
Serverloze functieservices installeren op uw eigen infrastructuur
Laten we snel een virtuele machine installeren met behulp van de Exoscale CLI. Als je het nog niet hebt ingesteld, kun je het gebruiken . Dit is een coole tool die uw productiviteit nog meer zal verhogen. Vergeet niet dat u een regel moet configureren om poort 8080 in de beveiligingsgroep te openen! De volgende opdrachten starten een schone virtuele machine, klaar om onze functies te hosten:
$ 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-securitygroupVervolgens kunt u een ssh-verbinding maken met de virtuele machine en de externe Fn-server installeren:
$ 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)Installeer vervolgens Docker en de Fn-server op dezelfde manier als al op de lokale machine gebeurde, start de 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 is klaar om functies te ontvangen! Voor gerichte overdracht van functies naar een externe server gebruiken we het commando deploy van de lokale computer door de vlag weg te laten --local.
Bovendien vereist Fn dat u de locatie van de Fn-server en het Docker-register opgeeft. Deze opties kunnen worden ingesteld via omgevingsvariabelen FN_API_URL и FN_REGISTRY respectievelijk, maar biedt ook een handiger manier om eenvoudig het maken en beheren van configuraties voor implementatie te beheren.
In Fn-termen wordt de configuratie voor implementatie aangeroepen context. Met het volgende commando wordt de context gemaakt:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelU kunt de beschikbare contexten als volgt bekijken:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
En schakel over naar de context die zojuist als volgt is gemaakt:
$ fn use context exoscale
Now using context: exoscaleVanaf nu downloadt de levering van de Fn-functie Docker-images met behulp van het geselecteerde DockerHub-account (in mijn geval - nfrankel) en breng vervolgens de externe server op de hoogte (in dit voorbeeld - http://185.19.30.175:8080) over de locatie en versie van de nieuwste afbeelding met uw functie.
$ 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 .Eindelijk:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Functielevenscyclus in Fn-gebaseerd serverloos computergebruik
Voordelen van serverless computing op eigen capaciteit
Serverloos computergebruik is een handige oplossing voor het snel implementeren van onafhankelijke delen van een applicatie die communiceren met complexere applicaties of microservices.
Dit komt vaak door de verborgen kosten van het binden aan de gekozen leverancier, wat, afhankelijk van de specifieke gebruikssituatie en het specifieke volume, in de toekomst kan leiden tot hogere kosten en verminderde flexibiliteit.
Multi-cloud- en hybride cloud-architecturen hebben in dit geval ook te lijden, omdat u gemakkelijk in een situatie terecht kunt komen waarin u serverloos computergebruik zou willen gebruiken, maar vanwege bedrijfsbeleid misschien niet mogelijk is.
Fn is vrij eenvoudig te gebruiken en kan vrijwel dezelfde FaaS-interface bieden, met weinig overhead. Het elimineert elke leverancier-lock-in en kan lokaal of bij elke handige aanbieder van cloudoplossingen naar keuze worden geïnstalleerd. Er is ook vrijheid bij het kiezen van een programmeertaal.
Dit artikel behandelt alleen de basisprincipes van Fn, maar het maken van je eigen runtime is vrij eenvoudig, en de algehele architectuur kan breder worden ingezet met behulp van een Fn-load balancer, of door Fn ter bescherming achter een proxy te plaatsen.
Bron: www.habr.com