Tutorial

Ausführen serverloser Funktionen mit OpenFaaS auf DigitalOcean Kubernetes

KubernetesDigitalOcean Managed Kubernetes

Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

Einführung

Üblicherweise erfordert das Hosting einer Softwareanwendung im Internet Infrastrukturmanagement, Planung und Überwachung für ein monolithisches System. Im Gegensatz zu diesem traditionellen Ansatz gliedert die serverless Architektur (auch bekannt als Function as a Service oder FaaS) Ihre Anwendung in Funktionen auf. Bei diesen Funktionen handelt es sich um zustandslose, in sich geschlossene, ereignisausgelöste, funktional vollständige Entitäten, die über von Ihnen verwaltete APIs kommunizieren, statt über die zugrunde liegende Hardware und die explizite Bereitstellung der Infrastruktur. Die Funktionen sind vom Design her skalierbar, übertragbar, schneller einzurichten und einfacher zu testen als gewöhnliche Anwendungen. Damit die serverlose Architektur im Prinzip funktionieren kann, ist eine plattformunabhängige Art der Paketierung und Orchestrierung von Funktionen erforderlich.

OpenFaaS ist ein Open-Source-Framework zur Implementierung der serverlosen Architektur auf Kubernetes, wobei Docker-Container zur Speicherung und Ausführung von Funktionen verwendet werden. Es ermöglicht die Paketierung eines beliebigen Programms als Container und die Verwaltung einer Funktion über die Befehlszeile oder die integrierte Web-Benutzeroberfläche. OpenFaaS verfügt über eine ausgezeichnete Unterstützung für Metriken und bietet eine automatische Skalierung der Funktionen bei steigender Nachfrage.

In diesem Tutorial werden Sie OpenFaaS auf Ihrem DigitalOcean Kubernetes-Cluster in Ihrer Domäne einsetzen und es mit kostenlosen Let’s Encrypt TLS-Zertifikaten sichern. Sie werden auch die Web-Benutzeroberfläche erkunden und bestehende und neue Funktionen mithilfe von faas-cli, dem offiziellen Befehlszeilen-Tool, implementieren. Am Ende verfügen Sie über ein flexibles System für die Bereitstellung serverloser Funktionen.

Voraussetzungen

  • Ein DigitalOcean Kubernetes-Cluster, bei dem Ihre Verbindung standardmäßig als kubectl konfiguriert ist. Der Cluster muss über mindestens 8 GB RAM und 4 für OpenFaaS verfügbare CPU-Cores verfügen (bei stärkerer Nutzung sind mehr erforderlich). Eine Anleitung zur Konfiguration von kubectl finden Sie unter dem Schritt Verbinden mit Ihrem Cluster, wenn Sie Ihren Cluster erstellen. Um einen Kubernetes-Cluster in DigitalOcean zu erstellen, lesen Sie unser Dokument Kubernetes Schnellstart.
  • Auf Ihrem lokalen Rechner installiertes Docker. Folgen Sie den Schritten 1 und 2 für Ihre Distribution in Installieren von Docker.
  • Einen Account bei Docker Hub zur Speicherung von Docker-Images, die Sie in diesem Tutorial erstellen werden.
  • Auf Ihrem lokalen Rechner installiertes faas-cli, das offizielle CLI-Tool zur Verwaltung von OpenFaaS. Anweisungen für mehrere Plattformen finden Sie in den offiziellen Dokumentationen.
  • Auf Ihrem lokalen Rechner installierten Helm-Paketmanager. Schließen Sie dazu Schritt 1 ab und fügen Sie das Repository stable von Schritt 2 des Tutorials Installieren von Software auf Kubernetes-Clustern mit dem Helm 3-Paketmanager hinzu.
  • In Ihrem Cluster mit Helm installierten Nginx Ingress Controller und Cert Manager, um OpenFaaS mit Ingress-Ressourcen freizugeben. Folgen Sie dazu den Anweisungen unter Einrichten eines Nginx Ingress unter DigitalOcean Kubernetes mit Helm.
  • Ein vollständig registrierter Domänenname zum Hosten von OpenFaaS, der auf den vom Nginx Ingress verwendeten Load Balancer verweist. Dieses Tutorial verwendet durchgehend openfaas.your_domain. Sie können einen Domänennamen unter Namecheap günstig erwerben oder einen kostenlosen von Freenom herunterladen oder einfach die Domänenregistrierungsstelle Ihrer Wahl verwenden.

Anmerkung: Der von Ihnen in diesem Tutorial verwendete Domänenname muss sich von dem Domänennamen unterscheiden, der in dem vorbereitenden Tutorial Einrichten eines Nginx Ingress auf DigitalOcean Kubernetes verwendet wird.

Schritt 1 – Installieren von OpenFaaS mit Helm

In diesem Schritt installieren Sie OpenFaaS mit Helm auf Ihrem Kubernetes-Cluster und stellen es in Ihrer Domäne zur Verfügung.

Als Teil der Voraussetzung des Nginx Ingress Controllers haben Sie Beispieldienste und einen Ingress erstellt. Sie werden sie in diesem Tutorial nicht benötigen, sodass Sie diese durch Ausführen der folgenden Befehle löschen können:

  • kubectl delete -f hello-kubernetes-first.yaml
  • kubectl delete -f hello-kubernetes-second.yaml
  • kubectl delete -f hello-kubernetes-ingress.yaml

Da Sie Funktionen als Kubernetes-Objekte bereitstellen werden, ist es hilfreich, sie und OpenFaaS selbst in getrennten Namespaces in Ihrem Cluster zu speichern. Der Namespace von OpenFaaS wird als openfaas bezeichnet und der Namespace der Funktionen ist openfaas-fn. Erstellen Sie diese in Ihrem Cluster, indem Sie den folgenden Befehl ausführen:

  • kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml

Sie sehen die folgende Ausgabe:

Output
namespace/openfaas created namespace/openfaas-fn created

Als Nächstes müssen Sie das OpenFaaS Helm-Repository hinzufügen, das das OpenFaaS-Chart hostet. Führen Sie dazu folgenden Befehl aus:

  • helm repo add openfaas https://openfaas.github.io/faas-netes/

Helm wird die folgende Ausgabe anzeigen:

Output
"openfaas" has been added to your repositories

Aktualisieren Sie den Chart-Cache von Helm:

  • helm repo update

Sie sehen die folgende Ausgabe:

Output
Hang tight while we grab the latest from your chart repositories... ...Successfully got an update from the "openfaas" chart repository ...Successfully got an update from the "jetstack" chart repository ...Successfully got an update from the "stable" chart repository Update Complete. ⎈ Happy Helming!⎈

Bevor Sie OpenFaaS installieren, müssen Sie Chart-Parameter anpassen. Sie werden diese auf Ihrem lokalen Rechner in einer Datei namens values.yaml speichern. Erstellen und öffnen Sie die Datei mit Ihrem Texteditor:

  • nano values.yaml

Fügen Sie die folgenden Zeilen hinzu:

values.yaml
functionNamespace: openfaas-fn
generateBasicAuth: true

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: "nginx"
  hosts:
    - host: openfaas.your_domain
      serviceName: gateway
      servicePort: 8080
      path: /

Zuerst geben Sie den Namespace an, in dem Funktionen gespeichert werden, indem Sie openfaas-fn der Variablen functionNamespace zuweisen. Indem Sie generateBasicAuth auf true setzen, weisen Sie Helm an, eine obligatorische Authentifizierung beim Zugriff auf die OpenFaaS Web-Benutzeroberfläche einzurichten und eine Kombination von Admin-Benutzername und Passwort für Sie zu erzeugen.

Dann aktivieren Sie die Ingress-Erstellung und konfigurieren sie weiter, um den Nginx Ingress-Controller zur Bereitstellung des OpenFaaS-Dienstes gateway in Ihrer Domäne zu verwenden.

Denken Sie daran, openfaas.your_domain durch Ihre gewünschte Domäne aus den Voraussetzungen zu ersetzen. Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Installieren Sie zum Schluss OpenFaaS in den Namespace openfaas mit den angepassten Werten:

  • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

Sie sehen die folgende Ausgabe:

Output
Release "openfaas" does not exist. Installing it now. NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

Die Ausgabe zeigt, dass die Installation erfolgreich war. Führen Sie den folgenden Befehl aus, um das Passwort für den Account admin zu ermitteln:

  • echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode) | tee openfaas-password.txt

Das entschlüsselte Passwort wird in die Ausgabe und gleichzeitig mit tee in eine Datei namens openfaas-password.txt geschrieben. Notieren Sie sich die Ausgabe, bei der es sich um Ihr OpenFaaS-Passwort für das Konto admin handelt.

Durch Ausführen des folgenden Befehls können Sie beobachten, wie OpenFaaS-Container verfügbar werden:

  • kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"

Wenn alle aufgelisteten Bereitstellungen ready sind, geben Sie zum Beenden STRG + C ein.

Sie können nun in Ihrem Webbrowser zu der angegebenen Domäne navigieren. Geben Sie bei Aufforderung admin als Benutzername und das zugehörige Passwort ein. Sie sehen dann die Web-Benutzeroberfläche von OpenFaaS:

OpenFaaS – Leeres Bedienfeld

Sie haben OpenFaaS erfolgreich installiert und das Bedienfeld in Ihrer Domäne verfügbar gemacht. Als Nächstes sichern Sie es mit kostenlosen TLS-Zertifikaten von Let’s Encrypt.

Schritt 2 – Aktivieren von TLS für Ihre Domäne

In diesem Schritt sichern Sie Ihre ungeschützte Domäne mit Let’s Encrypt-Zertifikaten, die vom Zertifikatsmanager bereitgestellt werden.

Dazu müssen Sie die Ingress-Konfiguration in values.yaml bearbeiten. Öffnen Sie sie zum Bearbeiten:

  • nano values.yaml

Fügen Sie die hervorgehobenen Zeilen hinzu:

values.yaml
generateBasicAuth: true

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: "nginx"
    cert-manager.io/cluster-issuer: letsencrypt-prod
  tls:
    - hosts:
        - openfaas.your_domain
      secretName: openfaas-crt
  hosts:
    - host: openfaas.your_domain
      serviceName: gateway
      servicePort: 8080
      path: /

Der Block tls definiert, in welchem Secret die Zertifikate für ihre (unter hosts aufgelisteten) Seiten ihre Zertifikate speichern, die der ClusterIssuer letsencrypt-prod ausstellt. In der Regel muss das angegebene Secret für jeden Ingress in Ihrem Cluster unterschiedlich sein.

Vergessen Sie nicht, openfaas.your_domain​​​ durch Ihre gewünschte Domäne zu ersetzen. Speichern und schließen Sie danach die Datei.

Wenden Sie die Änderungen in Ihrem Cluster an, indem Sie folgenden Befehl ausführen:

  • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

Sie sehen die folgende Ausgabe:

Output
Release "openfaas" has been upgraded. Happy Helming! NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 2 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

Sie müssen einige Minuten warten, bis die Server von Let’s Encrypt ein Zertifikat für Ihre Domäne ausstellen. In der Zwischenzeit können Sie den Fortschritt verfolgen, indem Sie sich die Ausgabe des folgenden Befehls ansehen:

  • kubectl describe certificate openfaas-crt -n openfaas

Das Ende der Ausgabe wird ähnlich wie dieses aussehen:

Output
Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal GeneratedKey 24m cert-manager Generated a new private key Normal Requested 16m cert-manager Created new CertificateRequest resource "openfaas-crt-1017759607" Normal Issued 16m cert-manager Certificate issued successfully

Wenn die letzte Ausgabezeile Certificate issued successfully lautet, können Sie die Ausgabe durch Drücken von STRG + C beenden. Sie sehen das Vorhängeschloss links neben der Adressleiste in Ihrem Browser, das anzeigt, dass Ihre Verbindung sicher ist.

Sie haben Ihre OpenFaaS-Domäne mit kostenlosen TLS-Zertifikaten von Let’s Encrypt gesichert. Jetzt werden Sie die Web-Benutzeroberfläche verwenden und Funktionen von dort aus verwalten.

Schritt 3 – Bereitstellen von Funktionen über die Web-Benutzeroberfläche

In diesem Abschnitt werden Sie die Web-Benutzeroberfäche von OpenFaaS erkunden und dann Funktionen von dort bereitstellen, verwalten und aufrufen.

Die Web-Benutzeroberfläche von OpenFaaS verfügt über zwei Hauptteile: Auf der linken Seite eine Spalte, in der die bereitgestellten Funktionen aufgelistet werden, und das zentrale Bedienfeld, in dem Sie detaillierte Informationen über eine ausgewählte Funktion sehen und mit dieser interagieren können.

Um eine neue Funktion bereitzustellen, klicken Sie oben links unter dem OpenFaaS-Logo auf die Schaltfläche Deploy New Function. Es wird ein Dialogfeld angezeigt, in dem Sie aufgefordert werden, eine Funktion auszuwählen:

OpenFaaS – Dialogfeld Bereitstellen einer neuen Funktion

Die Registerkarte FROM STORE listet vorgefertigte Funktionen aus dem offiziellen OpenFaaS Function Store auf, die Sie sofort bereitstellen können. Jede Funktion wird mit einer kurzen Beschreibung angezeigt und Sie können das Link-Symbol rechts neben einer Funktion auswählen, um einen Blick auf ihren Quellcode zu werfen. Um eine Store-Funktion aus der Liste bereitzustellen, wählen Sie diese aus und klicken Sie dann auf die Schaltfläche DEPLOY.

Sie können auch Ihre eigene Funktion bereitstellen, indem Sie zu der Registerkarte CUSTOM wechseln:

OpenFaaS – Bereitstellen einer benutzerdefinierten Funktion

Hier müssen Sie ein Docker-Image Ihrer Funktion angeben, das speziell für OpenFaaS konfiguriert und in einer Docker-Registrierung (wie z. B. Docker Hub) verfügbar ist. In diesem Schritt stellen Sie eine vorgefertigte Funktion aus dem OpenFaaS Store bereit. Im nächsten Schritt erstellen Sie benutzerdefinierte Funktionen und stellen diese im Docker Hub bereit.

Sie stellen die Funktion NodeInfo bereit, die Informationen über den Rechner zurückgibt, auf dem sie bereitgestellt wird, wie CPU-Architektur, Anzahl der Cores, gesamt verfügbarer RAM-Speicher und Betriebszeit (in Sekunden).

Wählen Sie aus der Liste der Store-Funktionen NodeInfo und klicken Sie auf DEPLOY. Es wird bald in der Liste der bereitgestellten Funktionen angezeigt.

OpenFaaS – NodeInfo bereitgestellt

Wählen Sie sie aus. Im mittleren Teil des Bildschirms sehen sie grundlegende Informationen über die bereitgestellte Funktion.

OpenFaaS – Info über bereitgestellte Funktion

Der Status der Funktion wird in Echtzeit aktualisiert und sollte schnell zu Ready wechseln. Wenn über längere Zeit Not Ready angezeigt wird, ist es sehr wahrscheinlich, dass Ihrem Cluster die Ressourcen fehlen, um einen neuen Pod zu akzeptieren. Im Abschnitt Größenänderung von Droplets finden Sie Informationen darüber, wie Sie dies beheben können.

Sobald Ready erscheint, ist die bereitgestellte Funktion unter der angegebenen URL zugänglich. Um sie zu testen, können Sie in Ihrem Browser zu der URL navigieren oder sie über das Feld Invoke function aufrufen, das sich unter der Funktionsinfo befindet.

OpenFaaS – Bereitgestellte Funktion aufrufen

Sie können zwischen Text, JSON und Download wählen, um die Art der Antwort anzugeben, die Sie erwarten. Wenn Sie möchten, dass die Abfrage ein POST anstelle von GET ist, können Sie im Feld Request body Abfragedaten bereitstellen.

Um die Funktion nodeinfo aufzurufen, klicken Sie auf die Schaltfläche INVOKE. OpenFaaS erstellt und führt eine HTTP-Abfrage gemäß den gewählten Optionen aus und füllt die Antwortfelder mit den empfangenen Daten aus.

OpenFaaS – Antwort der Funktion nodeinfo

Der Antwortstatus ist HTTP 200 OK. Das bedeutet, dass die Abfrage erfolgreich ausgeführt wurde. Response body enthält Systeminformationen, die die Funktion NodeInfo sammelt, d. h. sie ist zugänglich und funktioniert korrekt.

Um eine Funktion zu löschen, wählen Sie sie aus der Liste aus und klicken Sie auf das Mülleimer-Symbol in der rechten oberen Ecke der Seite. Wenn Sie dazu aufgefordert werden, klicken Sie zur Bestätigung auf OK. Der Status der Funktion wechselt zu Not Ready (was bedeutet, dass sie aus dem Cluster entfernt wird) und die Funktion wird bald nicht mehr auf der Benutzeroberfläche vorhanden sein.

In diesem Schritt haben Sie die Web-Benutzeroberfläche von OpenFaaS verwendet sowie Funktionen von dort bereitgestellt und verwaltet. Sie werden nun sehen, wie Sie OpenFaaS-Funktionen über die Befehlszeile bereitstellen und verwalten können.

Schritt 4 – Verwalten von Funktionen mit faas-cli

In diesem Abschnitt konfigurieren Sie die faas-cli für die Arbeit mit Ihrem Cluster. Anschließend werden Sie Ihre vorhandenen Funktionen über die Befehlszeile bereitstellen und verwalten.

Um zu vermeiden, dass Sie Ihre OpenFaaS-Domäne bei jeder Ausführung der faas-cli angeben müssen, speichern Sie sie in einer Umgebungsvariable namens OPENFAAS_URL, deren Wert die faas-cli automatisch abholt und während der Ausführung verwendet.

Öffnen Sie .bash_profile in Ihrem Stammverzeichnis zur Bearbeitung:

  • nano ~/.bash_profile

Fügen Sie die folgende Zeile hinzu:

~/.bash_profile
. . .
export OPENFAAS_URL=https://openfaas.your_domain

Denken Sie daran, openfaas.your_domain​​​ durch Ihre gewünschte Domäne zu ersetzen. Speichern und schließen Sie danach die Datei.

Um sich nicht erneut anmelden zu müssen, werten Sie die Datei manuell aus:

  • . ~/.bash_profile

Stellen Sie nun sicher, dass Sie faas-cli auf Ihrem lokalen Rechner installiert haben. Falls Sie es noch nicht installiert haben, folgen Sie den Anleitungen in den offiziellen Dokumentationen.

Richten Sie dann Ihre Anmeldedaten ein, indem Sie den folgenden Befehl ausführen:

  • cat ~/openfaas-password.txt | faas-cli login --username admin --password-stdin

Die Ausgabe sieht ungefähr so aus:

Output
Calling the OpenFaaS server to validate the credentials... credentials saved for admin https://openfaas.your_domain

Um eine Funktion aus dem Store bereitzustellen, führen Sie den folgenden Befehl aus:

  • faas store deploy function_name

Sie können die Bereitstellung von nodeinfo versuchen, indem Sie Folgendes ausführen:

  • faas store deploy nodeinfo

Sie sehen eine Ausgabe wie die folgende:

Output
Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/nodeinfo

Um bereitgestellte Funktionen auflisten zu können, führen Sie faas list aus:

  • faas list

Ihre vorhandenen Funktionen werden angezeigt:

Output
Function Invocations Replicas nodeinfo 0 1

Um detaillierte Informationen über eine bereitgestellte Funktion zu erhalten, verwenden Sie faas describe:

  • faas describe nodeinfo

Die Ausgabe wird ähnlich dieser sein:

Name:                nodeinfo
Status:              Ready
Replicas:            1
Available replicas:  1
Invocations:         0
Image:               functions/nodeinfo-http:latest
Function process:
URL:                 https://openfaas.your_domain/function/nodeinfo
Async URL:           https://openfaas.your_domain/async-function/nodeinfo
Labels:              faas_function : nodeinfo
                     uid : 514253614
Annotations:         prometheus.io.scrape : false

Sie können eine Funktion mit faas invoke aufrufen:

  • faas invoke nodeinfo

Sie erhalten die folgende Meldung:

Output
Reading from STDIN - hit (Control + D) to stop.

Dann können Sie einen Request Body bereitstellen. Wenn Sie dies tun, ist die Methode POST anstelle von GET. Wenn Sie die Dateneingabe abgeschlossen haben oder die Anforderung GET sein soll, drücken Sie STRG + D. faas-cli führt dann die abgeleitete Abfrage aus und gibt die Antwort aus, ähnlich wie bei der Web-Benutzeroberfläche.

Zum Löschen einer Funktion führen Sie faas remove aus:

  • faas remove nodeinfo

Sie erhalten die folgende Ausgabe:

Output
Deleting: nodeinfo. Removing old function.

Führen Sie faas list erneut aus, um zu sehen, dass nodeinfo entfernt wurde.

Output
Function Invocations Replicas

In diesem Schritt haben Sie Funktionen in Ihrem Cluster von der Befehlszeile aus mit Hilfe von faas-cli bereitgestellt, aufgelistet, aufgerufen und entfernt. im nächsten Schritt erstellen Sie Ihre eigene Funktion und stellen sie in Ihrem Cluster bereit.

Schritt 5 – Erstellen und Bereitstellen einer neuen Funktion

Erstellen Sie nun eine Beispielfunktion von Node.JS unter Verwendung von faas-cli und stellen Sie diese auf Ihrem Cluster bereit.

Die daraus resultierende Funktion wird als Docker-Container gepackt und auf Docker Hub veröffentlicht. Um Container veröffentlichen zu können, müssen Sie sich anmelden, indem Sie den folgenden Befehl ausführen:

  • docker login

Geben Sie Ihren Docker Hub-Benutzernamen und Ihr Passwort ein, wenn Sie zum Beenden des Anmeldevorgangs aufgefordert werden.

Speichern Sie die Beispielfunktion Node.JS in einem Ordner namens sample-js-function. Erstellen Sie diese mit dem folgenden Befehl:

  • mkdir sample-js-function

Navigieren Sie dorthin:

  • cd sample-js-function

Füllen Sie das Verzeichnis mit der Vorlage einer JS-Funktion, indem Sie den folgenden Befehl ausführen:

  • faas new sample-js --lang node

Die Ausgabe sieht in etwa folgendermaßen aus:

Output
2020/03/24 17:06:08 No templates found in current directory. 2020/03/24 17:06:08 Attempting to expand templates from https://github.com/openfaas/templates.git 2020/03/24 17:06:10 Fetched 19 template(s) : [csharp csharp-armhf dockerfile go go-armhf java11 java11-vert -x java8 node node-arm64 node-armhf node12 php7 python python-armhf python3 python3-armhf python3-debian ru by] from https://github.com/openfaas/templates.git Folder: sample-js created. ___ _____ ____ / _ \ _ __ ___ _ __ | ___|_ _ __ _/ ___| | | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \ | |_| | |_) | __/ | | | _| (_| | (_| |___) | \___/| .__/ \___|_| |_|_| \__,_|\__,_|____/ |_| Function created in folder: sample-js Stack file written: sample-js.yml ...

Wie in der Ausgabe geschrieben, befindet sich der Code für die Funktion selbst im Ordner sample-js, während sich die OpenFaaS-Konfiguration für die Funktion in der Datei sample-js.yaml befindet. Unter dem Verzeichnis sample-js (das einem regulären Node.JS-Projekt ähnelt) befinden sich zwei Dateien, handler.js und package.json.

handler.js enthält tatsächlichen JS-Code, der eine Antwort zurückgibt, wenn die Funktion aufgerufen wird. Der Inhalt des Handlers sieht wie folgt aus:

sample-js-function/sample-js/handler.js
"use strict"

module.exports = async (context, callback) => {
    return {status: "done"}
}

Er exportiert eine Lambda-Funktion mit zwei Parametern, einem Kontext mit Abfragedaten und einem Callback, mit dem Sie Antwortdaten zurückübergeben können, anstatt sie nur zurückzugeben.

Öffnen Sie diese Datei zur Bearbeitung:

  • nano sample-js/handler.js

Ändern Sie die hervorgehobene Zeile wie folgt:

sample-js-function/sample-js/handler.js
"use strict"

module.exports = async (context, callback) => {
    return {status: "<h1>Hello Sammy!</h1>"}
}

Wenn Sie fertig sind, speichern und schließen Sie die Datei. Diese OpenFaaS-Funktion wird, wenn sie aufgerufen wird, Hello Sammy! in die Antwort schreiben.

Öffnen Sie als Nächstes die Konfigurationsdatei zur Bearbeitung:

  • nano sample-js.yml

Sie wird wie folgt aussehen:

sample-js-function/sample-js.yml
version: 1.0
provider:
  name: openfaas
  gateway: https://openfaas.your_domain
functions:
  sample-js:
    lang: node
    handler: ./sample-js
    image: sample-js:latest

Für den provider gibt sie openfaas und ein Standard-Gateway an. Dann definiert sie die Funktion sample-js, gibt ihre Sprache (node), ihren Handler und den Namen des Docker-Image an, den Sie ändern müssen, um den Benutzernamen Ihres Docker Hub-Accounts einzufügen:

sample-js-function/sample-js.yml
version: 1.0
provider:
  name: openfaas
  gateway: http://127.0.0.1:8080
functions:
  sample-js:
    lang: node
    handler: ./sample-js
    image: your_docker_hub_username/sample-js:latest

Speichern und schließen Sie die Datei.

Erstellen Sie dann das Docker-Image, verschieben Sie es zum Docker-Hub und stellen Sie es in Ihrem Cluster bereit, und zwar gleichzeitig, indem Sie den folgenden Befehl ausführen:

  • faas up -f sample-js.yml

Es wird eine umfangreiche Ausgabe (hauptsächlich von Docker) erfolgen, die so endet:

Output
. . . [0] < Pushing sample-js [your_docker_hub_username/sample-js:latest] done. [0] Worker done. Deploying: sample-js. Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/sample-js

Rufen Sie Ihre neu bereitgestellte Funktion auf, um sicherzustellen, dass sie funktioniert:

  • faas invoke sample-js

Drücken Sie STRG + D. Sie sehen die folgende Ausgabe:

Output
<h1>Hello Sammy!</h1>

Das bedeutet, dass die Funktion gepackt und korrekt bereitgestellt wurde.

Sie können die Funktion entfernen, indem Sie Folgendes ausführen:

  • faas remove sample-js

Sie haben nun erfolgreich eine benutzerdefinierte Node.JS-Funktion auf Ihrer OpenFaaS-Instanz in Ihrem Cluster erstellt und bereitgestellt.

Zusammenfassung

Sie haben OpenFaaS auf Ihrem DigitalOcean Kubernetes-Cluster bereitgestellt und können nun sowohl vorgefertigte als auch benutzerdefinierte Funktionen bereitstellen. Jetzt sind Sie in der Lage, die Function-as-a-Service-Architektur zu implementieren, was die Ressourcennutzung erhöhen und Leistungsverbesserungen für Ihre Anwendungen bewirken kann.

Wenn Sie mehr über erweiterte OpenFaaS-Funktionen erfahren möchten, wie z. B. die automatische Skalierung für Ihre eingesetzten Funktionen und die Überwachung ihrer Leistung, besuchen Sie die offizielle Dokumentation.

0 Comments

Creative Commons License