— einer der auffälligsten Trends im Cloud Computing. Das grundlegende Prinzip ist, dass die Infrastruktur nicht die Sorge der DevOps, sondern des Dienstanbieters ist. Die Skalierung der Ressourcen passt sich automatisch an die Last an und bietet eine hohe Änderungsrate.
Ein weiteres gemeinsames Merkmal ist der Trend zur Minimierung und Fokussierung des Codes, weshalb Serverless Computing manchmal als „Function as a Service“ (FaaS) bezeichnet wird.
Historisch war Amazon der erste Cloud-Dienstleister, der FaaS mit AWS Lambda anbot, weshalb der Begriff seinen Ursprung dort hat. Auch andere Cloud-Dienstleister bieten ähnliche Lösungen an:
- Cloud Functions von Google
- Azure Functions von Microsoft
All diese Unternehmen bieten Serverless Computing, automatische Skalierung und die Abrechnung nur für tatsächlich genutzte Ressourcen an, binden die Kunden jedoch an ihr proprietäres Produkt. Dennoch gibt es kostenlose Open-Source-Alternativen für die Implementierung von Serverless Computing. Es ist erwähnenswert:
- Die Plattform , entwickelt im Inkubator von IBM,
- , als Teil eines umfangreichen Ökosystems des Spring Frameworks, das auch als Fassade für AWS Lambda, Azure Functions und OpenWhisk verwendet werden kann,
- , unterstützt von Oracle.
Alle sind vollständig cloudunabhängig, das heißt, sie können in jede Cloud installiert werden, einschließlich Ihrer eigenen, öffentlicher oder privater sowie natürlich in Exoscale.
Wie das Fn-Projekt funktioniert
Fn basiert vollständig auf Docker und besteht aus zwei Hauptkomponenten:
- CLI-Programme, die dazu dienen, alle Aspekte der Fn-Infrastruktur zu verwalten und mit dem Fn-Server zu interagieren,
- Der eigentliche Fn-Server, eine gewöhnliche Anwendung, die in einem Docker-Container verpackt ist.
Funktionen, die in Fn bereitgestellt werden, laufen ebenfalls in eigenen Containern, was die Unterstützung vieler Programmiersprachen ermöglicht, zum Beispiel... Clojure!
Die Argumente der Funktionen werden über die Standardeingabe (STDIN) übergeben, die Ergebnisse werden auf die Standardausgabe (STDOUT) geschrieben. Wenn die Argumente oder Rückgabewerte keine einfachen Werte sind (z. B. JSON-Objekte) – können sie mithilfe der Abstraktionsschicht umgewandelt werden, die von Fn in Form eines Function Development Kits (FDK) bereitgestellt wird.
Zur Vereinfachung stehen integrierte Vorlagensets zur Verfügung, die das Deployen von FaaS in einer Vielzahl von Programmiersprachen und deren Versionen (Go, verschiedene Java-Versionen, Python usw.) erleichtern.
Die Erstellung von FaaS ist einfach und folgt diesem Schema:
- Wir deployen die Funktion über die Fn-CLI: Eine Anwendungs-Konfigurationsdatei für Fn basierend auf der gewählten Vorlage wird erstellt.
- Wir rollen unsere eigene Funktion ebenfalls über die Fn-CLI aus: Das Container-Image wird in ein Repository hochgeladen, und der Server wird über die Existenz und den Standort dieses Images informiert.
Das Prinzip der Bereitstellung von Funktionen in Fn
Lokale Installation und Testen von serverlosen Funktionen
Lassen Sie uns mit der Installation von Fn auf der lokalen Maschine beginnen. Zunächst wird Docker installiert, wie von Fn gefordert. Wir gehen davon aus, dass wir Debian/Ubuntu verwenden:
$ sudo apt-get update
$ sudo apt-get install docker.ioOder verwenden Sie den Paketmanager/Bau von Docker entsprechend Ihrem System. Danach können wir direkt zur Installation der Fn-CLI übergehen. Zum Beispiel mit curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shWenn Sie auf OSX mit installiertem Homebrew arbeiten, können Sie einen anderen Weg wählen:
$ brew install fn
==> Herunterladen https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Herunterladen von https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Entpacken fn-0.5.8.high_sierra.bottle.tar.gz
/usr/local/Cellar/fn/0.5.8: 5 Dateien, 16.7MBJetzt ist alles bereit für das erste Deployment unserer Funktion über die CLI. Zur Vereinfachung verwenden wir die integrierte Laufzeitumgebung, zum Beispiel Node:
$ fn init --runtime node --trigger http hellonode
Funktion wird erstellt unter: /hellonode
Funktionsvordruck erstellt.
func.yaml erstellt.Ein neues Verzeichnis wird erstellt hellonode für die weitere Entwicklung unserer Fn-Funktion mit einigen grundlegenden Konfigurationsdateien. Im neu erstellten Verzeichnis können Sie Ihre Anwendung erstellen, die den Standards der von Ihnen gewählten Sprache oder Laufzeit entspricht:
# Каталог с 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 erstellt die Grundstruktur des Projekts, erstellt die Datei func.yaml, die notwendige Konfigurationen für Fn enthält, und legt eine Vorlage für den Code in der von Ihnen gewählten Sprache fest.
Im Fall der Laufzeit Node bedeutet das:
$ cat hellonode/func.js
const fdk=require('@fnproject/fdk');
fdk.handle(function(input){
let name = 'World';
if (input.name) {
name = input.name;
}
return {'message': 'Hallo ' + name}
})Jetzt prüfen wir schnell unsere Funktion lokal, um zu sehen, wie alles funktioniert.
Zu Beginn starten wir den Fn-Server. Wie bereits erwähnt, ist der Fn-Server ein Docker-Container, der nach dem Start das Image aus dem Docker-Registry abruft.
$ fn start -d # starten Sie den lokalen Server im Hintergrund
Image 'fnproject/fnserver:latest' lokal nicht gefunden
latest: Herunterladen von fnproject/fnserver
ff3a5c916c92: Download vollständig
1a649ea86bca: Download vollständig
ce35f4d5f86a: Download vollständig
...
Status: Neuere Version des Images für fnproject/fnserver:latest heruntergeladen
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Um unsere Funktion zu starten, muss sie "bereitgestellt" werden. Dazu benötigen wir den Namen der Anwendung: In Fn müssen alle Anwendungen als Namensräume für verwandte Funktionen definiert werden.
Das Fn CLI sucht nach einer Datei func.yaml im aktuellen Verzeichnis, die zur Konfiguration der Funktion verwendet werden soll. Daher sollten wir zuerst in unser Verzeichnis wechseln. hellonode.
$ cd hellonode
$ fn deploy --app fnexo --local # Wir rollen die Funktion lokal aus, der Name der Anwendung ist fnexo.
# Der Parameter local lädt das Image nicht in das entfernte Registry,
# sondern führt es direkt aus
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-triggerWie aus der Ausgabe des Befehls zu sehen ist, wird ein neues Container-Image für Docker erstellt, das unsere Funktion enthält. Die Funktion ist bereit, aufgerufen zu werden, und wir haben zwei Möglichkeiten, dies zu tun:
- unter Verwendung des Befehls Fn
invoke - direkt über
http
Aufruf invoke über Fn wird der HTTP-Betrieb nur für Tests emuliert, was nützlich für eine schnelle Überprüfung ist:
$ fn invoke fnexo hellonode # Wir rufen die Funktion hellonode der Anwendung fnexo auf
{"message":"Hello World"}Um die Funktion direkt aufzurufen, muss die vollständige URL bekannt sein:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Der Fn-Server stellt seine Funktionen über den Port 8080 bereit, und offenbar entspricht die URL der Funktion dem Schema t/app/function, aber nicht vollständig. Über HTTP wird die Funktion nicht direkt aufgerufen, sondern über einen sogenannten Trigger, der gemäß seines Namens die Funktion „startet“. Trigger werden in `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 des TriggersWir können den Namen des Triggers ändern, damit er dem Namen der Funktion entspricht, das vereinfacht alles:
triggers:
- name: hellonode-trigger
type: http
source: \/hellonode # entspricht dem Namen der FunktionDann starten wir die Bereitstellung der Funktion erneut und rufen sie über den neuen Trigger auf:
$ fn deploy --app fnexo hellonode --local
$ curl http:\/\/localhost:8080\/t\/fnexo\/hellonode
{"message":"Hello World"}Alles funktioniert! Es ist an der Zeit, zu realen Experimenten überzugehen und unseren FaaS auf dem Server zu veröffentlichen!
Installation von Serverless-Funktionen auf eigener Infrastruktur
Lassen Sie uns schnell eine virtuelle Maschine mit der Exoscale CLI einrichten. Wenn Sie sie noch nicht konfiguriert haben, können Sie . Es ist ein großartiges Werkzeug, das Ihre Produktivität weiter steigern wird. Vergessen Sie nicht, eine Regel zum Öffnen des Ports 8080 in der Sicherheitsgruppe einzurichten! Die folgenden Befehle starten eine saubere virtuelle Maschine, die bereit ist, unsere Funktionen zu 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-securitygroupDann kann man sich per SSH mit der virtuellen Maschine verbinden und den Fn-Server installieren:
$ exo ssh fn-server
Die Authentizität des Hosts '185.19.30.175 (185.19.30.175)' kann nicht bestätigt werden.
Der ECDSA-Schlüsselfingerabdruck ist SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Sind Sie sich sicher, dass Sie die Verbindung fortsetzen möchten (ja/nein)? ja
Warnung: '185.19.30.175' (ECDSA) wurde dauerhaft zur Liste der bekannten Hosts hinzugefügt.
Willkommen bei Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)Anschließend installieren wir Docker und den Fn-Server ganz genauso, wie es bereits auf der lokalen Maschine gemacht wurde, und starten den 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 ist bereit, Funktionen entgegenzunehmen! Um Funktionen auf den Remote-Server zu übertragen, verwenden wir den Befehl deploy vom lokalen Computer aus und lassen das Flag --local.
Darüber hinaus erfordert Fn die Angabe des Plazierung von Fn-Server und Docker-Registry. Diese Parameter können über Umgebungsvariablen festgelegt werden: FN_API_URL und FN_REGISTRY Entsprechend wird jedoch eine benutzerfreundlichere Methode angeboten, um die Erstellung und Verwaltung von Konfigurationen für die Bereitstellung zu erleichtern.
In Bezug auf Fn wird eine Konfiguration für die Bereitstellung genannt context. Der folgende Befehl erstellt einen Kontext:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelSie können die verfügbaren Kontexte folgendermaßen anzeigen:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
Und um zu dem gerade erstellten Kontext zu wechseln, so:
$ fn use context exoscale
Now using context: exoscaleAb diesem Punkt wird die Bereitstellung von Fn-Funktionen Docker-Images laden, wobei das ausgewählte DockerHub-Konto verwendet wird (in meinem Fall — nfrankel), woraufhin der Remote-Server (in diesem Beispiel — http://185.19.30.175:8080) über den Standort und die Version des letzten Images, das Ihre Funktion enthält, informiert wird.
$ fn deploy --app fnexo . # wird auf dem lokalen Rechner aus dem Verzeichnis hellonode ausgeführt
Deploying function at: /.
Deploying hellonode to app: fnexo
Bumped to version 0.0.5
Building image nfrankel/hellonode:0.0.5 .Schließlich:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Der Lebenszyklus einer Funktion in serverlosen Berechnungen basierend auf Fn
Die Vorteile von serverlosen Berechnungen auf eigener Hardware
Serverlose Berechnungen sind eine praktische Lösung für die schnelle Implementierung unabhängiger Teile einer Anwendung, die mit komplexeren Anwendungen oder Mikrodiensten interagieren.
Dies ist oft mit versteckten Kosten verbunden, die an den gewählten Anbieter gebunden sind, was je nach spezifischem Anwendungsfall und Umfang zu höheren Kosten und geringerer Flexibilität in der Zukunft führen kann.
Multicloud- und hybride Cloud-Architekturen leiden ebenfalls darunter, da man schnell in eine Situation gelangen kann, in der man serverlose Berechnungen nutzen möchte, dies aber aufgrund der Unternehmensrichtlinien möglicherweise nicht möglich ist.
Fn ist einfach zu bedienen, kann fast die gleiche FaaS-Schnittstelle bieten, jedoch mit geringen Kosten. Es befreit von jeglichen Anbieterbindungen, da man es lokal oder bei einem beliebigen durch den Nutzer bevorzugten Cloud-Anbieter installieren kann. Zudem gibt es Freiheit bei der Wahl der Programmiersprache.
Der Artikel behandelt nur die Grundlagen von Fn, doch die Erstellung einer eigenen Ausführungsumgebung ist recht einfach. Die gesamte Architektur kann erweitert werden, indem man den Fn-Load-Balancer verwendet oder Fn hinter einem Proxy platziert, um ihn zu schützen.
Quelle: habr.com
