Serverloses Computing ist einer der sichtbarsten Trends im Cloud Computing. Das Grundprinzip der Arbeit ist, dass die Infrastruktur nicht das Anliegen von DevOps ist, sondern der Dienstleister. Die Ressourcenskalierung passt sich automatisch der Auslastung an und weist eine hohe Änderungsrate auf.
Ein weiteres gemeinsames Merkmal ist die Tendenz, Code zu minimieren und zu fokussieren. Daher wird serverloses Computing manchmal als "Funktion als Dienst" (FaaS) bezeichnet.
In der Vergangenheit war Amazon der erste Cloud-Dienstleister, der FaaS mit AWS Lambda anbot, von dem der Name stammt. Andere Cloud-Dienstleister bieten auch Analoga an:
- Google Cloud-Funktionen
- Azure-Funktionen von Microsoft
Alle diese Unternehmen bieten serverloses Computing, automatische Skalierung und zahlen nur für tatsächlich genutzte Ressourcen. Gleichzeitig binden sie Kunden an ihr firmeneigenes Produkt. Es gibt jedoch kostenlose Open Source-Alternativen für Serverless Computing. Es ist erwähnenswert:
Alle sind völlig unabhängig von den Clouds, dh, sie werden in jeder Cloud installiert, einschließlich Ihrer eigenen, öffentlichen oder privaten, und natürlich in Exoscale.
Wie das Fn-Projekt funktioniert
Fn basiert vollständig auf Docker und besteht aus zwei Hauptkomponenten:
- CLI-Programm zur Verwaltung aller Aspekte der Fn-Infrastruktur und zur Interaktion mit dem Fn-Server
- Eigentlich ist der Fn-Server die übliche Anwendung, die in einem Container für Docker verpackt ist.
Die in Fn implementierten Funktionen werden auch in separaten Containern ausgeführt, sodass Sie viele Programmiersprachen unterstützen können, zum Beispiel ... Clojure!
Argumente von Funktionen werden an die Standardeingabe (STDIN) übergeben, die Ergebnisse an die Standardausgabe (STDOUT). Wenn die Argumente oder Rückgabewerte keine einfachen Werte sind (z. B. ein JSON-Objekt), können sie mithilfe der von Fn selbst bereitgestellten Abstraktionsschicht als Funktionsentwicklungskit (Function Development Kit, FDK) transformiert werden.
Zur Vereinfachung stehen integrierte Vorlagen zur Verfügung, die die Bereitstellung von FaaS in einer umfangreichen Liste verschiedener Sprachen und ihrer Versionen (Go, verschiedene Versionen von Java, Python usw.) erleichtern.
Das Erstellen von FaaS ist einfach, wenn Sie diesem Muster folgen:
- Wir stellen die Funktion über die CLI Fn bereit: Auf der Grundlage der ausgewählten Vorlage wird eine Anwendungskonfigurationsdatei für Fn erstellt.
- Wir rollen unsere eigene Funktion aus, wieder unter Verwendung der CLI Fn: Das Container-Image wird in einem bestimmten Repository abgelegt, woraufhin der Server über das Vorhandensein und die Platzierung dieses Images informiert wird.
Funktionslieferprinzip in Fn
Lokale Installation und Test von serverlosen Funktionen
Wir fahren mit der Installation von Fn auf dem lokalen Computer fort. Docker wird zuerst installiert, wie von Fn gefordert. Wir sollen auf Debian / Ubuntu sein:
$ sudo apt-get update $ sudo apt-get install docker.io
Nun, oder verwenden Sie den Paketmanager / Docker-Build, der Ihrem System entspricht. Dann können Sie direkt zur Fn CLI-Installation gehen. Zum Beispiel mit curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
Wenn Sie OSX mit installiertem Homebrew ausführen, können Sie auch anders vorgehen:
$ 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.7MB
Jetzt ist alles bereit für die erste Bereitstellung unserer Funktion über die CLI. Der Einfachheit halber verwenden wir die integrierte Umgebung, um beispielsweise Node auszuführen:
$ fn init --runtime node --trigger http hellonode Creating function at: /hellonode Function boilerplate generated. func.yaml created.
Ein neues hellonode Verzeichnis wird erstellt, um unsere Fn-Funktion mit einigen grundlegenden Konfigurationsdateien weiterzuentwickeln. In dem neu erstellten Verzeichnis können Sie eine Anwendung erstellen, die den Standards der ausgewä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.java
Fn erstellt die anfängliche Projektstruktur, erstellt eine func.yaml Datei mit den erforderlichen Einstellungen für Fn und installiert eine Vorlage für den Code in der von Ihnen ausgewählten Sprache.
Im Falle der Node-Laufzeit bedeutet dies:
$ 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} })
Jetzt werden wir unsere Funktion schnell vor Ort überprüfen, um zu sehen, wie alles funktioniert.
Zuerst starten wir den Fn-Server. Wie bereits erwähnt, ist der Fn-Server ein Docker-Container. Nach dem Start wird das Image aus der Docker-Registrierung abgerufen.
$ 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 668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5
Um unsere Funktion auszuführen, müssen Sie sie ausrollen. Dies erfordert einen
Fn CLI sucht im aktuellen Verzeichnis nach der Datei func.yaml , mit der die Funktion konfiguriert wird. Also müssen Sie zuerst in unser hellonode Verzeichnis gehen.
$ 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-trigger
Wie Sie der Ausgabe des Befehls entnehmen können, wird ein neues Container-Image für Docker erstellt, das unsere Funktion enthält. Die Funktion kann jetzt aufgerufen werden, und wir haben zwei Möglichkeiten, dies zu tun:
- Verwenden Sie den Befehl fn
invoke - direkt über
http anrufen
Das Aufrufen von invoke über Fn emuliert einfach die HTTP-Arbeit für Tests, was für eine schnelle Überprüfung praktisch ist:
$ fn invoke fnexo hellonode # hellonode fnexo {"message":"Hello World"}
Um die Funktion direkt aufzurufen, müssen Sie die vollständige URL kennen:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger {"message":"Hello World"}
Der Fn-Server stellt seine Funktionen über Port 8080 bereit, und es scheint, dass die URL der Funktion mit dem Schema t/app/function übereinstimmt, jedoch nicht vollständig. Über HTTP wird die Funktion nicht direkt aufgerufen, sondern über den sogenannten Trigger, der den Funktionsaufruf nach seinem Namen „startet“. Trigger werden im Projekt `func.yml definiert:
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
Wir können den Namen des Triggers so ändern, dass er mit dem Namen der Funktion übereinstimmt. Dies vereinfacht alles:
triggers: - name: hellonode-trigger type: http source: /hellonode #
Dann starten wir die Auslieferung der Funktion erneut und rufen sie vom neuen Trigger aus auf:
$ fn deploy --app fnexo hellonode --local $ curl http://localhost:8080/t/fnexo/hellonode {"message":"Hello World"}
Alles arbeitet! Es ist Zeit, umfassende Experimente zu starten und unser FaaS auf dem Server zu veröffentlichen!
Serverlose Funktionsdienste auf Ihrer eigenen Infrastruktur installieren
Lassen Sie uns schnell eine virtuelle Maschine mithilfe der CLI-Exoskala installieren. Wenn Sie es noch nicht eingerichtet haben, können Sie es mithilfe unseres Leitfadens schnell starten . Dies ist ein cooles Tool, mit dem Sie Ihre Produktivität weiter steigern können. Vergessen Sie nicht, dass Sie eine Regel konfigurieren müssen, um Port 8080 in der Sicherheitsgruppe zu öffnen! 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-securitygroup
Dann können Sie in die virtuelle Maschine ssh und den Remote-Fn-Server installieren:
$ 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)
Installieren Sie dann Docker und den Fn-Server auf dieselbe Weise wie auf dem lokalen Computer. Starten Sie 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.643
Fn ist bereit für Features! Für die gezielte Übertragung von Funktionen auf einen Remote-Server verwenden wir den Befehl deploy vom lokalen Computer, wobei das Flag --local wird.
Außerdem müssen Sie in Fn den Speicherort des Fn-Servers und der Docker-Registrierung angeben. Diese Parameter können über die Umgebungsvariablen FN_API_URL bzw. FN_REGISTRY wird jedoch eine bequemere Möglichkeit zum einfachen Verwalten der Erstellung und Verwaltung von Konfigurationen für die Bereitstellung angeboten.
In Bezug auf Fn wird die Konfiguration für die Bereitstellung als context . Der folgende Befehl erstellt den Kontext:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankel
Sie 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 wechseln Sie zu dem gerade erstellten Kontext:
$ fn use context exoscale Now using context: exoscale
Ab diesem Zeitpunkt werden durch die Bereitstellung von Fn-Funktionen Docker-Bilder unter Verwendung des ausgewählten Kontos auf DockerHub (in meinem Fall nfrankel ) nfrankel und der Remote-Server (in diesem Beispiel http://185.19.30.175:8080 ) über den Speicherort und die Version benachrichtigt Das letzte Bild mit Ihrer 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 .
Endlich:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode {"message":"Hello World"}
Funktionslebenszyklus im Serverless Computing basierend auf Fn
Die Vorteile von Serverless Computing in seinen Einrichtungen
Serverless Computing ist eine praktische Lösung für die schnelle Implementierung unabhängiger Anwendungsteile, die mit komplexeren Anwendungen oder Mikrodiensten interagieren.
Dies liegt häufig an den versteckten Kosten für die Bindung an den ausgewählten Lieferanten, die je nach Anwendungsfall und Volumen zu höheren Kosten und einer geringeren Flexibilität in der Zukunft führen können.
In diesem Fall leiden auch Multi-Cloud- und Hybrid-Cloud-Architekturen, da Sie sich leicht in einer Situation befinden, in der Sie serverloses Computing einsetzen möchten. Aufgrund von Unternehmensrichtlinien ist dies jedoch möglicherweise nicht möglich.
Fn ist recht einfach zu bedienen, es kann fast die gleiche FaaS-Schnittstelle mit geringen Kosten bieten. Der Provider wird nicht mehr gebunden, sondern kann lokal oder in einem geeigneten Cloud-Lösungsanbieter Ihrer Wahl installiert werden. Es besteht auch die Freiheit, eine Programmiersprache zu wählen.
Im Artikel werden nur die Grundlagen von Fn vorgestellt. Das Erstellen einer eigenen Laufzeitumgebung ist jedoch recht einfach. Die allgemeine Architektur kann mithilfe des Fn-Lastenausgleichs oder durch Platzieren von Fn hinter einem Proxy zum Schutz erweitert werden.