— is een van de meest opvallende trends in cloud computing. Het belangrijkste principe is dat de infrastructuur de verantwoordelijkheid is van de dienstverleners, en niet van de DevOps-teams. De schaalvergroting van middelen past zich automatisch aan de belasting aan en heeft een hoge respons snelheid.
Een andere gemeenschappelijke eigenschap is de neiging om de code te minimaliseren en te focussen, waardoor serverless computing soms 'functies als een dienst' (FaaS) wordt genoemd.
Historisch gezien was Amazon de eerste cloudprovider die FaaS aanbood met AWS Lambda, waar deze naam vandaan komt. Andere cloudproviders bieden ook vergelijkbare diensten aan:
- Cloud Functions van Google
- Azure Functions van Microsoft
Al deze bedrijven bieden serverless computing, automatische schaalvergroting en alleen betaling voor daadwerkelijk gebruikte middelen, maar ze binden klanten aan hun eigen product. Er zijn echter ook gratis alternatieven met open source voor het organiseren van serverless computing. Het is belangrijk op te merken:
- Het platform , ontwikkeld onder toezicht van IBM in een incubator,
- , als onderdeel van het vrij omvangrijke ecosysteem van Spring Framework, dat ook kan worden gebruikt als facade voor AWS Lambda, Azure Functions en OpenWhisk,
- , ondersteund door Oracle.
Al deze oplossingen zijn volledig onafhankelijk van clouds, wat betekent dat ze in elke cloud kunnen worden geïnstalleerd, inclusief je eigen cloud, publiek of privé, en natuurlijk in Exoscale.
Hoe het Fn-project is opgebouwd
Fn is volledig gebaseerd op Docker en bestaat uit twee hoofdcomponenten:
- Een CLI-programma dat bedoeld is voor het beheer van alle aspecten van de Fn-infrastructuur en interactie met de Fn-server,
- De Fn-server zelf, een gewone applicatie verpakt in een Docker-container.
Functies die in Fn worden uitgerold, draaien ook in aparte containers, wat ondersteuning biedt voor verschillende programmeertalen, bijvoorbeeld… Clojure!
Functies worden via standaardinvoer (STDIN) doorgegeven, terwijl de resultaten op standaarduitvoer (STDOUT) worden geschreven. Als de argumenten of teruggegeven waarden geen eenvoudige waarden zijn (bijvoorbeeld een JSON-object), kunnen ze worden omgezet met behulp van de abstractielaag die Fn zelf biedt in de vorm van een function development kit (FDK).
Voor gemak zijn er ingebouwde sjablonen beschikbaar die het implementeren van FaaS in een uitgebreide lijst van verschillende talen en versies (Go, verschillende versies van Java, Python, enz.) vergemakkelijken.
Het creëren van FaaS is eenvoudig door het volgende schema te volgen:
- We implementeren de functie met behulp van de CLI Fn: er wordt een applicatieconfiguratiebestand voor Fn aangemaakt, gebaseerd op de gekozen sjabloon.
- We rolt onze eigen functie uit, wederom met behulp van de CLI Fn: de container afbeelding wordt in een bepaalde repository geplaatst, waarna de server op de hoogte wordt gebracht van het bestaan en de locatie van deze afbeelding.
Het principe van functielevering in Fn
Lokale installatie en testen van serverless functies
Laten we beginnen met de installatie van Fn op de lokale machine. Eerst installeren we Docker, zoals vereist door Fn. Er wordt aangenomen dat we op Debian/Ubuntu zijn:
$ sudo apt-get update
$ sudo apt-get install docker.ioOf gebruik een pakketbeheerder/monitor om Docker volgens jouw systeem te installeren. Vervolgens kan je direct overgaan tot de installatie van Fn CLI. Bijvoorbeeld, met curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shAls je op OSX werkt met Homebrew geïnstalleerd, kun je een andere weg inslaan:
$ brew install fn
==> Downloaden https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Downloaden van https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Gieten van fn-0.5.8.high_sierra.bottle.tar.gz
/usr/local/Cellar/fn/0.5.8: 5 bestanden, 16.7MBNu is alles klaar voor de eerste implementatie van onze functie met behulp van CLI. Voor de eenvoud gebruiken we de ingebouwde omgeving om uit te voeren, bijvoorbeeld Node:
$ fn init --runtime node --trigger http hellonode
Functie aangemaakt op: /hellonode
Functie sjabloon gegenereerd.
func.yaml aangemaakt.Er wordt een nieuwe map aangemaakt hellonode voor verdere ontwikkeling van onze Fn-functie met enkele basisconfiguratiebestanden. Binnen de nieuw aangemaakte map kun je je applicatie creëren, volgend de normen van de door jou 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 en maakt het bestand aan func.yaml, die de noodzakelijke instellingen voor Fn bevat, en het sjabloon voor de code in de door jou gekozen taal instelt.
In het geval van de Node runtime betekent dit:
$ cat hellonode/func.js
const fdk=require('@fnproject/fdk');
fdk.handle(function(input){
let name = 'Wereld';
if (input.name) {
name = input.name;
}
return {'message': 'Hallo ' + name}
})Laten we nu snel onze functie lokaal testen om te zien hoe alles werkt.
Eerst starten we de Fn-server. Zoals eerder vermeld, is de Fn-server een Docker-container, dus na het starten haalt deze het beeld uit de Docker-registry.
$ fn start -d # start de lokale server op de achtergrond
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 starten, moet deze 'uitgerold' worden. Hiervoor is nodig de naam van de applicatie: in Fn moeten alle applicaties worden gedefinieerd als namespaces voor de bijbehorende functies.
Fn CLI zal zoeken naar het bestand func.yaml in de huidige map, dat zal worden toegepast voor de functie-instelling. Dus laten we eerst naar onze map navigeren hellonode.
$ cd hellonode
$ fn deploy --app fnexo --local # rol de functie lokaal uit, de naam van de applicatie is - fnexo.
# de local parameter uploadt het beeld niet naar de externe registry,
# maar start het direct
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 uit de uitvoer van de opdracht blijkt, wordt er een nieuw Docker-containerbeeld aangemaakt dat onze functie bevat. De functie is klaar voor aanroep, en we hebben twee manieren om dit te doen:
- door de Fn
invoke - direct aan te roepen via
http
Aanroep invoke via Fn simuleert eenvoudigweg het werken via HTTP voor tests, wat handig is voor een snelle controle:
$ fn invoke fnexo hellonode # roep de functie hellonode aan van de applicatie fnexo
{"message":"Hallo Wereld"}Om de functie direct aan te roepen, moet je de volledige URL kennen:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hallo Wereld"}De Fn-server biedt zijn functies aan via poort 8080, en het lijkt erop dat de URL van de functie overeenkomt met het schema t/app/function, maar niet volledig. Via HTTP wordt de functie niet direct aangeroepen, maar via een zogenaamde trigger, die volgens zijn naam de aanroep van de functie "start". Triggers worden gedefinieerd in `func.yml van het 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 van de triggerWe kunnen de naam van de trigger wijzigen, zodat deze overeenkomt met de naam van de functie, dat vereenvoudigt alles:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # komt overeen met de naam van de functieVervolgens starten we de functie opnieuw en roepen deze aan vanuit de nieuwe trigger:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Alles werkt! Het is tijd om echte experimenten uit te voeren en onze FaaS op de server te publiceren!
Installatie van serverless functies op eigen infrastructuur
Laten we snel een virtuele machine opzetten met de Exoscale CLI. Als je deze nog niet hebt ingesteld, kun je gebruikmaken van . Dit is een geweldig hulpmiddel dat je productiviteit verder verhoogt. Vergeet niet een regel in te stellen om poort 8080 te openen in de Security Group! 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 kun je via ssh de virtuele machine benaderen en de Fn-server installeren:
$ exo ssh fn-server
De authenticiteit van de host '185.19.30.175 (185.19.30.175)' kan niet worden vastgesteld.
ECDSA sleutelvingerafdruk is SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Weet je zeker dat je wilt doorgaan met verbinden (ja/nee)? ja
Waarschuwing: '185.19.30.175' (ECDSA) is permanent toegevoegd aan de lijst met bekende hosts.
Welkom bij Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)Vervolgens installeren we Docker en de Fn-server op dezelfde manier als op de lokale machine, en starten 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 de doeltreffende overdracht van functies naar de externe server zullen we de command gebruiken deploy van de lokale computer, waarbij we de vlag --local.
Daarnaast vereist Fn dat je de locatie van de Fn-server en de Docker registry opgeeft. Deze parameters kunnen worden ingesteld via omgevingsvariabelen FN_API_URL en FN_REGISTRY respectievelijk, maar er is ook een handiger manier voor gemakkelijke creatie en beheer van configuraties voor implementatie.
In de termen van Fn wordt de configuratie voor implementatie aangeduid als context. De volgende opdracht zal de context aanmaken:
$ 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
HUIDIGE NAAM PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
En schakelen naar de context die zojuist is aangemaakt, zo:
$ fn use context exoscale
Nu gebruikmakend van context: exoscaleVanaf dit punt zal de levering van Fn-functies Docker-images laden met behulp van het gekozen account op DockerHub (in mijn geval — nfrankel), waarna de externe server (in dit voorbeeld — http://185.19.30.175:8080) zal worden geïnformeerd over de locatie en versie van de laatste afbeelding die uw functie bevat.
$ fn deploy --app fnexo . # uitgevoerd op de lokale machine vanuit de hellonode-structuur
Functioneel aan het implementeren op: /.
Functie hellonode aan app: fnexo implementeren
Verhoogd naar versie 0.0.5
Afbeelding nfrankel/hellonode:0.0.5 bouwen.Eindelijk:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Levenscyclus van een functie in serverloze computing gebaseerd op Fn
Voordelen van serverloze computing op eigen infrastructuur
Serverloze computing is een handige oplossing voor een snelle implementatie van onafhankelijke delen van een applicatie die samenwerken met meer complexe applicaties of microservices.
Dit gaat vaak gepaard met verborgen kosten van het vastzitten aan de gekozen leverancier, wat, afhankelijk van de specifieke use-case en schaal, kan leiden tot hogere kosten en een afname van flexibiliteit in de toekomst.
Multicloud- en hybride cloudarchitecturen lijden ook in zo'n geval, want je kunt gemakkelijk in een situatie belanden waarin je serverloze computing zou willen gebruiken, maar dit om bedrijfsbeleid onmogelijk kan zijn.
Fn is eenvoudig te gebruiken, kan een bijna identieke interface zoals FaaS bieden, met lage overhead. Het voorkomt enige binding aan de leverancier, je kunt het lokaal installeren of bij een cloudprovider naar keuze. Ook is er vrijheid in het kiezen van programmeertaal.
In dit artikel worden slechts de basisprincipes van Fn behandeld, maar het creëren van je eigen runtime-omgeving is vrij eenvoudig, en de algemene architectuur kan verder worden uitgebreid met behulp van een Fn-loadbalancer of door Fn achter een proxy te plaatsen voor beveiliging.
Bron: habr.com
