TOC

So installieren und sichern Sie OpenFaaS mit Docker Swarm unter Ubuntu 16.04

Der Autor hat Diversity in Tech Fund ausgewählt, um eine Spende als Teil des Write for DOnations zu erhalten Programm.

Einführung

Die serverlose Architektur verbirgt Serverinstanzen vor dem Entwickler und stellt normalerweise eine API bereit, mit der Entwickler ihre Anwendungen in der Cloud ausführen können. Mit diesem Ansatz können Entwickler Anwendungen schnell bereitstellen, da sie die Bereitstellung und Wartung von Instanzen den entsprechenden DevOps-Teams überlassen können. Es senkt auch die Infrastrukturkosten, da Sie mit den entsprechenden Tools Ihre Instanzen nach Bedarf skalieren können.

Anwendungen, die auf serverlosen Plattformen ausgeführt werden, werden als serverlose Funktionen bezeichnet. Eine Funktion ist ein containerisierter, ausführbarer Code, mit dem bestimmte Vorgänge ausgeführt werden. Durch das Containerisieren von Anwendungen wird sichergestellt, dass Sie auf vielen Computern eine konsistente Umgebung reproduzieren können, sodass Aktualisierungen und Skalierungen möglich sind.

OpenFaaS ist ein kostenloses Open-Source-Framework zum Erstellen und Hosten von Funktionen ohne Server. Mit offiziellem Support für Docker Swarm und Kubernetes können Sie Ihre Anwendungen über die leistungsstarke API (Befehlszeile) bereitstellen Schnittstelle oder Web-Benutzeroberfläche. Es wird mit integrierten Metriken geliefert, die von https://prometheus.io [Prometheus] bereitgestellt werden, und unterstützt die automatische Skalierung bei Bedarf sowie die Skalierung von Null.

In diesem Tutorial richten Sie OpenFaaS mit Docker Swarm unter Ubuntu 16.04 ein und verwenden es. Sichern Sie die Web-Benutzeroberfläche und API, indem Sie Traefik mit https://letsencrypt.org/ einrichten. [Lassen Sie uns verschlüsseln]. Dies gewährleistet eine sichere Kommunikation zwischen den Knoten im Cluster sowie zwischen OpenFaaS und seinen Betreibern.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

  • Ubuntu 16.04 läuft auf Ihrem lokalen Rechner. Sie können andere Distributionen und Betriebssysteme verwenden, stellen Sie jedoch sicher, dass Sie die entsprechenden OpenFaaS-Skripts für Ihr Betriebssystem verwenden, und installieren Sie alle in diesen Voraussetzungen aufgeführten Abhängigkeiten.

  • + git,` + curl` und + jq sind auf Ihrem lokalen Computer installiert. Sie verwenden "+ git ", um das OpenFaaS-Repository zu klonen, " curl ", um die API zu testen, und " jq ", um unformatiertes https://www.digitalocean.com/community/tutorials/an-introduction-to zu transformieren -json [JSON] -Antworten von der API auf lesbares JSON. Verwenden Sie die folgenden Befehle, um die erforderlichen Abhängigkeiten für dieses Setup zu installieren: ` sudo apt-get update && sudo apt-get install git curl jq +`

  • Docker wird installiert. Führen Sie dazu die Schritte 1 und 2 unter https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-16-04 aus Ubuntu 16.04].

  • Ein https://hub.docker.com [Docker Hub] Konto. Um Funktionen für OpenFaaS bereitzustellen, müssen sie in einer öffentlichen Containerregistrierung veröffentlicht werden. Wir werden Docker Hub für dieses Tutorial verwenden, da es kostenlos und weit verbreitet ist. Stellen Sie sicher, dass Sie sich mit Docker auf Ihrem lokalen Computer authentifizieren, indem Sie den Befehl + docker login verwenden.

  • Docker Machine installiert, gefolgt von https://www.digitalocean.com/community/tutorials/how-to-provision-and-manage-remote-docker-hosts-with -docker-machine-on-ubuntu-16-04 [Bereitstellen und Verwalten von Remote-Docker-Hosts mit Docker Machine unter Ubuntu 16.04].

  • Ein persönliches DigitalOcean-Zugriffstoken. Befolgen Sie zum Erstellen eines Tokens diese Anweisungen.

  • Ein Docker Swarm-Cluster mit 3 Knoten, bereitgestellt unter https://www.digitalocean.com/community/tutorials/how-to-create-a-cluster-of-docker-containers-with-docker-swarm-and-digitalocean -on-ubuntu-16-04 [Erstellen eines Clusters von Docker-Containern mit Docker Swarm und DigitalOcean unter Ubuntu 16.04].

  • Ein vollständig registrierter Domänenname mit einem A-Eintrag, der auf eine der Instanzen im Docker-Schwarm verweist. Im gesamten Lernprogramm wird * example.com * als Beispieldomäne angezeigt. Sie sollten dies durch Ihre eigene Domain ersetzen, die Sie entweder unter Namecheap oder kostenlos unter Freenom erwerben können. . Sie können auch einen anderen Domain-Registrar Ihrer Wahl verwenden.

Schritt 1 - Herunterladen von OpenFaaS und Installieren der OpenFaaS-CLI

Um OpenFaaS auf Ihrem Docker-Schwarm bereitzustellen, müssen Sie die Bereitstellungsmanifeste und -skripte herunterladen. Am einfachsten erhalten Sie sie, indem Sie das offizielle OpenFaas-Repository klonen und das entsprechende Tag überprüfen, das eine OpenFaaS-Version darstellt.

Zusätzlich zum Klonen des Repositorys installieren Sie auch die FaaS-CLI, ein leistungsstarkes Befehlszeilenprogramm, mit dem Sie neue Funktionen von Ihrem Terminal aus verwalten und bereitstellen können. Es bietet Vorlagen zum Erstellen eigener Funktionen in den meisten wichtigen Programmiersprachen. Unter https://www.digitalocean.com/community/tutorials/installationsanleitung-und-sicheres-öffnen-mit-dockerwarm-auf-ubuntu-16-04#step-7-%E2%80% Wenn Sie [Schritt 7] verwenden, um eine Python -Funktion zu erstellen und auf OpenFaaS bereitzustellen .

In diesem Lernprogramm stellen Sie OpenFaaS v bereit. Die Schritte zum Bereitstellen anderer Versionen sollten ähnlich sein. Lesen Sie jedoch project changelog, um sicherzustellen, dass keine aktuellen Änderungen vorgenommen werden.

Navigieren Sie zunächst zu Ihrem Ausgangsverzeichnis und führen Sie den folgenden Befehl aus, um das Repository in das Verzeichnis "+ ~ / faas +" zu klonen:

cd ~
git clone https://github.com/openfaas/faas.git

Navigieren Sie zum neu erstellten Verzeichnis "+ ~ / faas +":

cd ~/faas

Wenn Sie das Repository klonen, erhalten Sie Dateien aus dem Hauptzweig, die die neuesten Änderungen enthalten. Da wichtige Änderungen in den Master-Zweig gelangen können, wird die Verwendung in der Produktion nicht empfohlen. Schauen wir uns stattdessen das "++" - Tag an:

git checkout

Die Ausgabe enthält eine Nachricht über das erfolgreiche Auschecken und eine Warnung über das Übernehmen von Änderungen an diesem Zweig:

OutputNote: checking out ''.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

 git checkout -b <new-branch-name>

HEAD is now at 8f0d2d1 Expose scale-function endpoint

Wenn Fehler auftreten, beheben Sie diese, indem Sie den Anweisungen auf dem Bildschirm folgen, bevor Sie fortfahren.

Nachdem Sie das OpenFaaS-Repository heruntergeladen haben, fahren Sie mit der Installation der FaaS-CLI fort. Geben Sie die erforderlichen Manifestdateien ein.

Der einfachste Weg, die FaaS-CLI zu installieren, ist die Verwendung des offiziellen Skripts. Navigieren Sie in Ihrem Terminal zu Ihrem Ausgangsverzeichnis und laden Sie das Skript mit dem folgenden Befehl herunter:

cd ~
curl -sSL -o faas-cli.sh https://cli.openfaas.com

Dadurch wird das Skript + faas-cli.sh + in Ihr Ausgangsverzeichnis heruntergeladen. Bevor Sie das Skript ausführen, sollten Sie den Inhalt überprüfen:

less faas-cli.sh

Sie können die Vorschau durch Drücken von + q + verlassen. Nachdem Sie den Inhalt des Skripts überprüft haben, können Sie mit der Installation fortfahren, indem Sie dem Skript ausführbare Berechtigungen erteilen und es ausführen. Führen Sie das Skript als root aus, damit es automatisch in Ihren + PATH kopiert wird:

chmod +x faas-cli.sh
sudo ./faas-cli.sh

Die Ausgabe enthält Informationen zum Installationsfortschritt und zur installierten CLI-Version:

Outputx86_64
Downloading package https://github.com/openfaas/faas-cli/releases/download//faas-cli as /tmp/faas-cli
Download complete.

Running as root - Attempting to move faas-cli to /usr/local/bin
New version of faas-cli installed to /usr/local/bin
Creating alias 'faas' for 'faas-cli'.
 ___                   _____           ____
/ _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
\___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
     |_|

CLI:
commit:
version:

Wenn ein Fehler angezeigt wird, beheben Sie ihn, indem Sie den Anweisungen auf dem Bildschirm folgen, bevor Sie mit dem Lernprogramm fortfahren.

Zu diesem Zeitpunkt ist die FaaS-CLI installiert. Um mehr über Befehle zu erfahren, die Sie verwenden können, führen Sie die CLI ohne Argumente aus:

faas-cli

Die Ausgabe zeigt die verfügbaren Befehle und Flags:

Output  ___                   _____           ____
/ _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
\___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
     |_|


Manage your OpenFaaS functions from the command line

Usage:
 faas-cli [flags]
 faas-cli [command]

Available Commands:
 build          Builds OpenFaaS function containers
 cloud          OpenFaaS Cloud commands
 deploy         Deploy OpenFaaS functions
 help           Help about any command
 invoke         Invoke an OpenFaaS function
 list           List OpenFaaS functions
 login          Log in to OpenFaaS gateway
 logout         Log out from OpenFaaS gateway
 new            Create a new template in the current folder with the name given as name
 push           Push OpenFaaS functions to remote registry (Docker Hub)
 remove         Remove deployed OpenFaaS functions
 store          OpenFaaS store commands
 template       Downloads templates from the specified github repo
 version        Display the clients version information

Flags:
     --filter string   Wildcard to match with function names in YAML file
 -h, --help            help for faas-cli
     --regex string    Regex to match with function names in YAML file
 -f, --yaml string     Path to YAML file describing function(s)

Use "faas-cli [command] --help" for more information about a command.

Sie haben jetzt die OpenFaaS-Manifeste erfolgreich abgerufen und die FaaS-CLI installiert, mit der Sie Ihre OpenFaaS-Instanz von Ihrem Terminal aus verwalten können.

Das Verzeichnis + ~ / faas + enthält Dateien aus der Version ++, sodass Sie OpenFaaS jetzt auf Ihrem Docker Swarm bereitstellen können. Bevor Sie dies tun, müssen Sie die Bereitstellungsmanifestdatei so ändern, dass sie Traefik enthält, wodurch Ihr OpenFaaS-Setup durch Einrichten von Let’s Encrypt gesichert wird.

Schritt 2 - Traefik konfigurieren

Traefik ist ein Docker-fähiger Reverse-Proxy mit SSL-Unterstützung von Let’s Encrypt. Das SSL-Protokoll stellt sicher, dass Sie sicher mit dem Swarm-Cluster kommunizieren, indem Sie die Daten verschlüsseln, die Sie zwischen den Knoten senden und empfangen.

Um Traefik mit OpenFaaS zu verwenden, müssen Sie das OpenFaaS-Bereitstellungsmanifest so ändern, dass es Traefik enthält, und OpenFaaS anweisen, Traefik zu verwenden, anstatt seine Dienste direkt dem Internet auszusetzen.

Navigieren Sie zurück zum Verzeichnis "+ ~ / faas +" und öffnen Sie das OpenFaaS-Bereitstellungsmanifest in einem Texteditor:

cd ~/faas
nano ~/faas/docker-compose.yml

Die OpenFaaS-Bereitstellung besteht aus mehreren Diensten, die unter der Direktive "+ services +" definiert sind und die Abhängigkeiten bereitstellen, die zum Ausführen von OpenFaaS, der OpenFaaS-API und der Web-Benutzeroberfläche sowie von Prometheus und AlertManager (für die Verarbeitung von Metriken) erforderlich sind.

Fügen Sie am Anfang des Abschnitts "+ services" einen neuen Service mit dem Namen "+ traefik" hinzu, der das Image "+ traefik: v1.6 +" für die Bereitstellung verwendet:

~ / faas / docker-compose.yml

version: "3.3"
services:


   gateway:
        ...

Das Traefik-Image stammt aus dem Traefik Docker Hub-Repository, wo Sie eine Liste aller verfügbaren Images finden.

Weisen Sie Docker als Nächstes an, Traefik mit dem Befehl "+" auszuführen. Dadurch wird Traefik ausgeführt, für die Zusammenarbeit mit Docker Swarm konfiguriert und SSL mithilfe von Let’s Encrypt bereitgestellt. Die folgenden Flags konfigurieren Traefik:

  • + - Docker. * +: Diese Flags weisen Traefik an, Docker zu verwenden und anzugeben, dass es in einem Docker-Schwarm-Cluster ausgeführt wird.

  • + - web = true +: Dieses Flag aktiviert die Traefik Web-Benutzeroberfläche.

  • + - defaultEntryPoints + und + - entryPoints +: Diese Flags definieren die zu verwendenden Einstiegspunkte und Protokolle. In unserem Fall beinhaltet dies HTTP an Port + 80 + und HTTPS an Port + 443 +.

  • + - acme. * +: Diese Flags weisen Traefik an, ACME zum Generieren von Let’s Encrypt-Zertifikaten zu verwenden, um Ihren OpenFaaS-Cluster mit SSL zu sichern.

Stellen Sie sicher, dass die Platzhalter für "+" -Domänen in den Flags " - acme.domains " und " - acme.email +" durch die Domain ersetzt werden, die Sie für den Zugriff auf OpenFaaS verwenden möchten. Sie können mehrere Domänen angeben, indem Sie sie durch Kommas und Leerzeichen trennen. Die E-Mail-Adresse ist für SSL-Benachrichtigungen und Benachrichtigungen, einschließlich Benachrichtigungen zum Ablauf des Zertifikats. In diesem Fall behandelt Traefik die Erneuerung von Zertifikaten automatisch, sodass Sie Ablaufbenachrichtigungen ignorieren können.

Fügen Sie den folgenden Codeblock unter der Direktive "+ image of" und über "+ gateway" ein:

~ / faas / docker-compose.yml

...
   traefik:
       image: traefik:v1.6
       command: -c --docker=true
           --docker.swarmmode=true
           --docker.domain=traefik
           --docker.watch=true
           --web=true
           --defaultEntryPoints='http,https'
           --entryPoints='Name:https Address::443 TLS'
           --entryPoints='Name:http Address::80'
           --acme=true
           --acme.entrypoint='https'
           --acme.httpchallenge=true
           --acme.httpchallenge.entrypoint='http'
           --acme.domains=', '
           --acme.email=''
           --acme.ondemand=true
           --acme.onhostrule=true
           --acme.storage=/etc/traefik/acme/acme.json
...

Mit der Anweisung "+ command " teilen wir Traefik mit, welche Ports für das Internet verfügbar gemacht werden sollen. Traefik verwendet für seine Operationen den Port " 8080 ", während OpenFaaS den Port " 80 " für nicht sichere Kommunikation und den Port " 443 +" für sichere Kommunikation verwendet.

Fügen Sie die folgende Anweisung + ports + unter der Anweisung + command + hinzu. Die +: + Notation stellt sicher, dass der Port auf der linken Seite von Traefik für das Internet zugänglich ist und dem Port des Containers auf der rechten Seite zugeordnet ist:

~ / faas / docker-compose.yml

       ...
       command:
           ...

           -
           -
           -
       ...

Als nächstes mounten Sie die Docker-Socket-Datei mit der Direktive + volume + vom Host, auf dem Docker ausgeführt wird, an Traefik. Die Docker-Socket-Datei kommuniziert mit der Docker-API, um Ihre Container zu verwalten und Details zu diesen abzurufen, z. B. die Anzahl der Container und deren IP-Adressen. Sie mounten auch das Volume "+ acme +", das wir später in diesem Schritt definieren werden.

Die Direktive "+ networks" weist Traefik an, die "+" -Funktionen von "network" zu verwenden, die zusammen mit OpenFaaS bereitgestellt werden. Dieses Netzwerk stellt sicher, dass Funktionen mit anderen Teilen des Systems, einschließlich der API, kommunizieren können.

Die Direktive "+ deploy +" weist Docker an, Traefik nur auf dem Docker Swarm Manager-Knoten auszuführen.

Fügen Sie die folgenden Direktiven unter der Direktive "+ ports +" hinzu:

~ / faas / docker-compose.yml

       ...
       volumes:
           - "/var/run/docker.sock:/var/run/docker.sock"
           - "acme:/etc/traefik/acme"
       networks:
           - functions
       deploy:
           placement:
               constraints: [node.role == manager]

Zu diesem Zeitpunkt sollte der Service-Block "+ traefik +" folgendermaßen aussehen:

~ / faas / docker-compose.yml

version: "3.3"
services:
   traefik:
       image: traefik:v1.6
       command: -c --docker=true
           --docker.swarmmode=true
           --docker.domain=traefik
           --docker.watch=true
           --web=true
           --defaultEntryPoints='http,https'
           --entryPoints='Name:https Address::443 TLS'
           --entryPoints='Name:http Address::80'
           --acme=true
           --acme.entrypoint='https'
           --acme.httpchallenge=true
           --acme.httpchallenge.entrypoint='http'
           --acme.domains=', '
           --acme.email=''
           --acme.ondemand=true
           --acme.onhostrule=true
           --acme.storage=/etc/traefik/acme/acme.json
       ports:
           - 80:80
           - 8080:8080
           - 443:443
       volumes:
           - "/var/run/docker.sock:/var/run/docker.sock"
           - "acme:/etc/traefik/acme"
       networks:
         - functions
       deploy:
         placement:
           constraints: [node.role == manager]

   gateway:
       ...

Während diese Konfiguration sicherstellt, dass Traefik mit OpenFaaS bereitgestellt wird, müssen Sie OpenFaaS auch für die Arbeit mit Traefik konfigurieren. Standardmäßig ist der Dienst "+ gateway " so konfiguriert, dass er auf dem Port " 8080 +" ausgeführt wird, der sich mit Traefik überschneidet.

Der Dienst + gateway + bietet das API-Gateway, mit dem Sie Ihre Funktionen bereitstellen, ausführen und verwalten können. Es verwaltet Metriken (über Prometheus) und die automatische Skalierung und hostet die Web-Benutzeroberfläche.

Unser Ziel ist es, den "+ gateway +" - Dienst mit Traefik verfügbar zu machen, anstatt ihn direkt dem Internet zugänglich zu machen.

Suchen Sie den Dienst "+ gateway +", der folgendermaßen aussehen sollte:

~ / faas / docker-compose.yml

...
   gateway:
       ports:
           - 8080:8080
       image: openfaas/gateway:0.8.7
       networks:
           - functions
       environment:
           functions_provider_url: "http://faas-swarm:8080/"
           read_timeout:  "300s"        # Maximum time to read HTTP request
           write_timeout: "300s"        # Maximum time to write HTTP response
           upstream_timeout: "300s"     # Maximum duration of upstream function call - should be more than read_timeout and write_timeout
           dnsrr: "true"               # Temporarily use dnsrr in place of VIP while issue persists on PWD
           faas_nats_address: "nats"
           faas_nats_port: 4222
           direct_functions: "true"    # Functions are invoked directly over the overlay network
           direct_functions_suffix: ""
           basic_auth: "${BASIC_AUTH:-true}"
           secret_mount_path: "/run/secrets/"
           scale_from_zero: "false"
       deploy:
           resources:
               # limits:   # Enable if you want to limit memory usage
               #     memory: 200M
               reservations:
                   memory: 100M
           restart_policy:
               condition: on-failure
               delay: 5s
               max_attempts: 20
               window: 380s
           placement:
               constraints:
                   - 'node.platform.os == linux'
       secrets:
           - basic-auth-user
           - basic-auth-password
...

Entfernen Sie die Direktive "+ ports " aus dem Dienst, um zu vermeiden, dass der Dienst " gateway +" direkt verfügbar gemacht wird.

Fügen Sie als Nächstes die folgende Anweisung + lables + zum Abschnitt + deploy + des Dienstes + gateway + hinzu. Diese Direktive macht die Endpunkte "+ / ui", "+ / system" und "+ / functions" auf Port "+ 8080 +" über Traefik verfügbar:

~ / faas / docker-compose.yml

       ...
       deploy:

               -
               -
           resources:
           ...

Der Endpunkt "+ / ui " macht die OpenFaaS-Web-Benutzeroberfläche verfügbar, die in der https://www.digitalocean.com/community/tutorials/how-to-install-and-secure-openfaas-using-docker-swarm- behandelt wird. on-ubuntu-16-04 # step-6-% E2% 80% 94-using-the-openfaas-web-ui [Step 6] dieses Tutorials. Der Endpunkt " / system" ist der API-Endpunkt, der zum Verwalten von OpenFaaS verwendet wird, während der Endpunkt "+ / function s" die API-Endpunkte zum Verwalten und Ausführen von Funktionen bereitstellt. https://www.digitalocean.com/community/tutorials/how-to-install-and-secure-openfaas-using-docker-swarm-on-ubuntu-16-04#step-5-%E2%80%94 -mit-der-openfaas-api [Schritt 5] dieses Tutorials behandelt die OpenFaaS-API im Detail.

Nach Änderungen sollte Ihr "+ gateway +" - Dienst folgendermaßen aussehen:

~ / faas / docker-compose.yml

...
   gateway:
       image: openfaas/gateway:0.8.7
       networks:
           - functions
       environment:
           functions_provider_url: "http://faas-swarm:8080/"
           read_timeout:  "300s"        # Maximum time to read HTTP request
           write_timeout: "300s"        # Maximum time to write HTTP response
           upstream_timeout: "300s"     # Maximum duration of upstream function call - should be more than read_timeout and write_timeout
           dnsrr: "true"               # Temporarily use dnsrr in place of VIP while issue persists on PWD
           faas_nats_address: "nats"
           faas_nats_port: 4222
           direct_functions: "true"    # Functions are invoked directly over the overlay network
           direct_functions_suffix: ""
           basic_auth: "${BASIC_AUTH:-true}"
           secret_mount_path: "/run/secrets/"
           scale_from_zero: "false"
       deploy:
           labels:
               - traefik.port=8080
               - traefik.frontend.rule=PathPrefix:/ui,/system,/function
           resources:
               # limits:   # Enable if you want to limit memory usage
               #     memory: 200M
               reservations:
                   memory: 100M
           restart_policy:
               condition: on-failure
               delay: 5s
               max_attempts: 20
               window: 380s
           placement:
               constraints:
                   - 'node.platform.os == linux'
       secrets:
           - basic-auth-user
           - basic-auth-password
...

Zuletzt definieren wir das "+ acme +" - Volume, das zum Speichern von Let’s Encrypt-Zertifikaten verwendet wird. Wir können ein leeres Volume definieren, dh, Daten bleiben nicht erhalten, wenn Sie den Container zerstören. Wenn Sie den Container zerstören, werden die Zertifikate beim nächsten Start von Traefik neu generiert.

Fügen Sie in die letzte Zeile der Datei die folgende Anweisung + volume + ein:

~ / faas / docker-compose.yml

...
volumes:
   acme:

Speichern Sie die Datei und schließen Sie den Texteditor. Zu diesem Zeitpunkt haben Sie Traefik so konfiguriert, dass es Ihre OpenFaaS-Bereitstellung und Docker Swarm schützt. Jetzt können Sie es zusammen mit OpenFaaS auf Ihrem Swarm-Cluster bereitstellen.

Schritt 3 - Bereitstellen von OpenFaaS

Nachdem Sie das OpenFaaS-Bereitstellungsmanifest vorbereitet haben, können Sie es bereitstellen und OpenFaaS verwenden. Zum Bereitstellen verwenden Sie das Skript "+ deploy_stack.sh +". Dieses Skript ist für Linux- und MacOS-Betriebssysteme vorgesehen. Im OpenFaaS-Verzeichnis finden Sie jedoch auch entsprechende Skripts für Windows und https : //github.com/openfaas/faas/blob/master/deploy_stack.ps1 [ARM-Systeme].

Bevor Sie OpenFaaS bereitstellen, müssen Sie "+ docker-machine +" anweisen, Docker-Befehle über das Skript auf einem der Computer im Swarm auszuführen. Verwenden Sie für dieses Tutorial die https://www.digitalocean.com/community/tutorials/how-to-create-a-cluster-of-docker-containers-with-docker-swarm-and-digitalocean-on-ubuntu -16-04 # step-3-% E2% 80% 94-initializing-the-cluster-manager [Schwarmmanager].

Wenn Sie den Befehl + docker-machine use + konfiguriert haben, können Sie ihn verwenden:

docker-machine use

Wenn nicht, verwenden Sie den folgenden Befehl:

eval $(docker-machine env )

Das Skript + deploy_stack.sh + stellt alle Ressourcen bereit, die für das erwartete Funktionieren von OpenFaaS erforderlich sind, einschließlich Konfigurationsdateien, Netzwerkeinstellungen, Diensten und Anmeldeinformationen für die Autorisierung beim OpenFaaS-Server.

Führen Sie das Skript aus. Die Bereitstellung dauert einige Minuten.

~/faas/deploy_stack.sh

Die Ausgabe enthält eine Liste der Ressourcen, die während des Bereitstellungsprozesses erstellt wurden, sowie die Anmeldeinformationen, die Sie für den Zugriff auf den OpenFaaS-Server und den FaaS-CLI-Befehl verwenden.

Notieren Sie sich diese Anmeldeinformationen, da Sie sie im gesamten Lernprogramm für den Zugriff auf die Web-Benutzeroberfläche und die API benötigen:

OutputAttempting to create credentials for gateway..
roozmk0y1jkn17372a8v9y63g
q1odtpij3pbqrmmf8msy3ampl
[Credentials]
username:
password:
echo -n  | faas-cli login --username= --password-stdin

Enabling basic authentication for gateway..

Deploying OpenFaaS core services
Creating network func_functions
Creating config func_alertmanager_config
Creating config func_prometheus_config
Creating config func_prometheus_rules
Creating service func_alertmanager
Creating service func_traefik
Creating service func_gateway
Creating service func_faas-swarm
Creating service func_nats
Creating service func_queue-worker
Creating service func_prometheus

Wenn Fehler angezeigt werden, befolgen Sie die Anweisungen auf dem Bildschirm, um sie zu beheben, bevor Sie mit dem Lernprogramm fortfahren.

Bevor Sie fortfahren, authentifizieren Sie die FaaS-CLI mit dem OpenFaaS-Server mithilfe des Befehls, der vom Bereitstellungsskript bereitgestellt wird.

Das Skript gab die Flags aus, die Sie für den Befehl bereitstellen müssen. Sie müssen jedoch ein zusätzliches Flag "+ - gateway +" mit der Adresse Ihres OpenFaaS-Servers hinzufügen, da die FaaS-CLI davon ausgeht, dass der Gateway-Server ausgeführt wird + localhost + `:

echo -n  | faas-cli login --username= --password-stdin --gateway

Die Ausgabe enthält eine Nachricht über die erfolgreiche Autorisierung:

OutputCalling the OpenFaaS server to validate the credentials...
credentials saved for admin https://example.com

Zu diesem Zeitpunkt ist auf Ihrem Docker Swarm-Cluster ein voll funktionsfähiger OpenFaaS-Server sowie die FaaS-CLI für die Verwendung Ihres neu bereitgestellten Servers konfiguriert. Bevor Sie die Verwendung von OpenFaaS testen, stellen wir zunächst einige Beispielfunktionen bereit.

Schritt 4 - Bereitstellen von OpenFaaS-Beispielfunktionen

OpenFaaS wird zunächst ohne implementierte Funktionen ausgeliefert. Zum Testen und Verwenden benötigen Sie einige Funktionen.

Das OpenFaaS-Projekt enthält einige Beispielfunktionen, und Sie finden eine Liste der verfügbaren verfügbaren Funktionen zusammen mit ihren Bereitstellungsmanifesten im OpenFaaS-Repository. Einige der Beispielfunktionen umfassen "+ nodeinfo ", um Informationen über den Knoten anzuzeigen, auf dem eine Funktion ausgeführt wird, " wordcount ", um die Anzahl der Wörter in einer übergebenen Anforderung zu zählen, und " markdown +", um übergebene Markdown-Eingaben zu konvertieren zur HTML-Ausgabe.

Das Manifest "+ stack.yml " im Verzeichnis " ~ / faas +" stellt neben den oben genannten Funktionen mehrere Beispielfunktionen bereit. Sie können es mithilfe der FaaS-CLI bereitstellen.

Führen Sie den folgenden Befehl + faas-cli + aus, der den Pfad zum Stapelmanifest und die Adresse Ihres OpenFaaS-Servers enthält:

faas-cli deploy -f ~/faas/stack.yml --gateway https://

Die Ausgabe enthält Statuscodes und Meldungen, die angeben, ob die Bereitstellung erfolgreich war oder nicht:

OutputDeploying: wordcount.

Deployed. 200 OK.
URL: https:///function/wordcount

Deploying: base64.

Deployed. 200 OK.
URL: https:///function/base64

Deploying: markdown.

Deployed. 200 OK.
URL: https:///function/markdown

Deploying: hubstats.

Deployed. 200 OK.
URL: https:///function/hubstats

Deploying: nodeinfo.

Deployed. 200 OK.
URL: https:///function/nodeinfo

Deploying: echoit.

Deployed. 200 OK.
URL: https:///function/echoit

Wenn Sie Fehler sehen, beheben Sie diese, indem Sie den Anweisungen auf dem Bildschirm folgen.

Führen Sie nach Abschluss der Stapelbereitstellung alle Funktionen auf, um sicherzustellen, dass sie bereitgestellt und einsatzbereit sind:

faas-cli list --gateway https://

Die Ausgabe enthält eine Liste von Funktionen mit ihren Replikatnummern und einer Anzahl von Aufrufen:

OutputFunction                        Invocations     Replicas
markdown                        0               1
wordcount                       0               1
base64                          0               1
nodeinfo                        0               1
hubstats                        0               1
echoit                          0               1

Wenn Sie Ihre Funktionen hier nicht sehen, stellen Sie sicher, dass der Befehl "+ faas-cli deploy +" erfolgreich ausgeführt wurde.

Sie können jetzt die OpenFaaS-Beispielfunktionen verwenden, um die Verwendung der API, der Web-Benutzeroberfläche und der CLI zu testen und zu demonstrieren. Im nächsten Schritt verwenden Sie zunächst die OpenFaaS-API, um Funktionen aufzulisten und auszuführen.

Schritt 5 - Verwenden der OpenFaaS-API

OpenFaaS wird mit einer leistungsstarken API geliefert, mit der Sie Ihre serverlosen Funktionen verwalten und ausführen können. Verwenden Sie Swagger, ein Tool zum Entwickeln, Testen und Dokumentieren von APIs, um die API-Dokumentation zu durchsuchen und anschließend die API zum Auflisten und Ausführen von Funktionen zu verwenden.

Mit Swagger können Sie die API-Dokumentation überprüfen, um herauszufinden, welche Endpunkte verfügbar sind und wie Sie sie verwenden können. Im OpenFaaS-Repository finden Sie die Swagger-API-Spezifikation, die mit dem Swagger-Editor zum Konvertieren der Spezifikation verwendet werden kann für Menschen lesbare Form.

Navigieren Sie mit Ihrem Webbrowser zu "+ http: // editor.swagger.io / +". Sie sollten mit dem folgenden Bildschirm begrüßt werden:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/swagger_welcome.png [Begrüßungsseite von Swagger Editor]

Hier finden Sie einen Texteditor mit dem Quellcode für die Swagger-Beispielspezifikation und der lesbaren API-Dokumentation auf der rechten Seite.

Importieren wir die OpenFaaS-Swagger-Spezifikation. Klicken Sie im oberen Menü auf die Schaltfläche * Datei * und dann auf * URL importieren *:

image: https: //assets.digitalocean.com/articles/openfaas_ubuntu_1604/swagger_editor.png [Swagger Editor-Import-URL]

Es wird ein Popup-Fenster angezeigt, in dem Sie die Adresse der Swagger-API-Spezifikation eingeben müssen. Wenn das Popup nicht angezeigt wird, stellen Sie sicher, dass Popups für Ihren Webbrowser aktiviert sind.

Geben Sie in das Feld den Link zur OpenFaaS-API-Spezifikation von Swagger ein: + https: // raw.githubusercontent.com / openfaas / faas / master / api-docs / swagger.yml +

image: https: //assets.digitalocean.com/articles/openfaas_ubuntu_1604/swagger_editor_url.png [Swagger Editor-Eingabe-URL]

Nachdem Sie auf die Schaltfläche * OK * geklickt haben, zeigt der Swagger-Editor die API-Referenz für OpenFaaS an. Diese sollte folgendermaßen aussehen:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/swagger_openfaas.png [Swagger Editor OpenFaaS API-Spezifikation]

Auf der linken Seite sehen Sie die Quelle der API-Referenzdatei, auf der rechten Seite eine Liste der Endpunkte mit kurzen Beschreibungen. Wenn Sie auf einen Endpunkt klicken, werden weitere Details angezeigt, einschließlich der erforderlichen Parameter, der verwendeten Methode und der möglichen Antworten:

image: https: //assets.digitalocean.com/articles/openfaas_ubuntu_1604/swagger_endpoint_details.png [Swagger Editor Endpoint details]

Sobald Sie wissen, welche Endpunkte verfügbar sind und welche Parameter sie erwarten, können Sie sie zum Verwalten Ihrer Funktionen verwenden.

Als Nächstes verwenden Sie den Befehl "+ curl ", um mit der API zu kommunizieren. Navigieren Sie also zurück zu Ihrem Terminal. Mit dem ` -u ` Flag können Sie das in Schritt 3 erhaltene `+` Paar übergeben, während das + -X + Flag die Anforderungsmethode definiert. Sie übergeben auch Ihre Endpunkt-URL "+ https: /// system / functions +":

curl -u : -X  https:///system/functions

Die erforderliche Methode für jeden Endpunkt finden Sie in den API-Dokumenten.

In Schritt 4 haben Sie mehrere Beispielfunktionen implementiert, die in der Ausgabe angezeigt werden sollen:

Output[{"name":"base64","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"base64","availableReplicas":0,"labels":{"com.openfaas.function":"base64","function":"true"}},{"name":"nodeinfo","image":"functions/nodeinfo:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"nodeinfo","function":"true"}},{"name":"hubstats","image":"functions/hubstats:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"hubstats","function":"true"}},{"name":"markdown","image":"functions/markdown-render:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"markdown","function":"true"}},{"name":"echoit","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"cat","availableReplicas":0,"labels":{"com.openfaas.function":"echoit","function":"true"}},{"name":"wordcount","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"wc","availableReplicas":0,"labels":{"com.openfaas.function":"wordcount","function":"true"}}]

Folgen Sie den Anweisungen auf dem Bildschirm, um das Problem zu beheben, bevor Sie mit dem Lernprogramm fortfahren. Stellen Sie sicher, dass Sie die Anforderung mit der empfohlenen Methode und den richtigen Anmeldeinformationen an den richtigen Endpunkt senden. Sie können die Protokolle für den Dienst "+ gateway +" auch mit dem folgenden Befehl überprüfen:

docker service logs func_gateway

Standardmäßig gibt die API-Antwort auf den Aufruf "+ curl " unformatiertes JSON ohne neue Zeilen zurück, das nicht von Menschen gelesen werden kann. Um es zu analysieren, leiten Sie die Antwort von ` curl ` an das Dienstprogramm ` jq +` weiter, das den JSON in eine für Menschen lesbare Form konvertiert:

curl -u : -X  https:///system/functions | jq

Die Ausgabe ist jetzt in lesbarer Form. Sie sehen den Funktionsnamen, mit dem Sie Funktionen mit der API verwalten und aufrufen können, die Anzahl der Aufrufe sowie Informationen wie Beschriftungen und Anzahl der Replikate, die für Docker relevant sind:

Output[
 {
   "name": "base64",
   "image": "functions/alpine:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "base64",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "base64",
     "function": "true"
   }
 },
 {
   "name": "nodeinfo",
   "image": "functions/nodeinfo:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "nodeinfo",
     "function": "true"
   }
 },
 {
   "name": "hubstats",
   "image": "functions/hubstats:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "hubstats",
     "function": "true"
   }
 },
 {
   "name": "markdown",
   "image": "functions/markdown-render:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "markdown",
     "function": "true"
   }
 },
 {
   "name": "echoit",
   "image": "functions/alpine:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "cat",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "echoit",
     "function": "true"
   }
 },
 {
   "name": "wordcount",
   "image": "functions/alpine:latest",
   "invocationCount": 0,
   "replicas": 1,
   "envProcess": "wc",
   "availableReplicas": 0,
   "labels": {
     "com.openfaas.function": "wordcount",
     "function": "true"
   }
 }
]

Nehmen wir eine dieser Funktionen und führen sie mit dem API-Endpunkt "+ / function / " aus. Dieser Endpunkt ist über die POST-Methode verfügbar, bei der Sie mit dem Flag " -d +" Daten an die Funktion senden können.

Führen Sie zum Beispiel den folgenden Befehl "+ curl " aus, um die Funktion " echoit " auszuführen, die mit OpenFaaS ausgeliefert wird und die von Ihnen gesendete Zeichenfolge als Anfrage ausgibt. Sie können die Zeichenfolge "" Sammy The Shark "+" verwenden, um Folgendes zu demonstrieren:

curl -u : -X  https:///function/ -d ""

Die Ausgabe zeigt dir "+ Sammy The Shark":

OutputSammy The Shark

Wenn ein Fehler angezeigt wird, befolgen Sie die Bildschirmprotokolle, um das Problem zu beheben, bevor Sie mit dem Lernprogramm fortfahren. Sie können auch die Protokolle der Gateway-Dienste überprüfen.

Zu diesem Zeitpunkt haben Sie die OpenFaaS-API zum Verwalten und Ausführen Ihrer Funktionen verwendet. Schauen wir uns nun die OpenFaaS-Web-Benutzeroberfläche an.

Schritt 6 - Verwenden der OpenFaaS-Weboberfläche

OpenFaaS wird mit einer Web-Benutzeroberfläche geliefert, mit der Sie neue Funktionen hinzufügen und installierte ausführen können. In diesem Schritt installieren Sie eine Funktion zum Generieren von QR-Codes aus dem FaaS-Store und generieren einen Beispielcode.

Zeigen Sie mit Ihrem Webbrowser zunächst auf "+ https: /// ui / +". Beachten Sie, dass der abschließende Schrägstrich erforderlich ist, um den Fehler "Nicht gefunden" zu vermeiden.

Geben Sie im Dialogfeld HTTP-Authentifizierung den Benutzernamen und das Kennwort ein, die Sie beim Bereitstellen von OpenFaaS in Schritt 3 erhalten haben.

Sobald Sie angemeldet sind, sehen Sie auf der linken Seite des Bildschirms die verfügbaren Funktionen sowie die Schaltfläche * Neue Funktionen bereitstellen *, mit der Sie neue Funktionen installieren können.

Klicken Sie auf * Neue Funktionen bereitstellen *, um eine neue Funktion bereitzustellen. Sie sehen das FaaS-Store-Fenster, das von der Community getestete Funktionen bietet, die Sie mit einem einzigen Klick installieren können:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/openfaas_func_store.png [OpenFaaS-Funktionsspeicher]

Zusätzlich zu diesen Funktionen können Sie Funktionen auch manuell aus einem Docker-Image bereitstellen.

In diesem Tutorial stellen Sie die Funktion * QR Code Generator * aus dem FaaS Store bereit. Suchen Sie den Eintrag * QR Code Generator - Go * in der Liste, klicken Sie darauf und klicken Sie dann auf die Schaltfläche * Deploy * am unteren Rand des Fensters:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/openfaas_qr.png [OpenFaaS QR Code Generator-Funktion]

Nachdem Sie auf "Bereitstellen" geklickt haben, wird das Fenster "Neue Funktion bereitstellen" geschlossen und die Funktion bereitgestellt. In der Liste auf der linken Seite des Fensters sehen Sie eine Auflistung für die Funktion * + qrcode-go + *. Klicken Sie auf diesen Eintrag, um ihn auszuwählen. Das Hauptfunktionsfenster zeigt den Funktionsnamen, die Anzahl der Replikate, die Anzahl der Aufrufe und das Image sowie die Option zum Aufrufen der Funktion an:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/openfaas_qr_code.png [OpenFaaS QR Code Function]

Lassen Sie uns einen QR-Code generieren, der die URL Ihrer Domain enthält. Geben Sie im Feld * Anforderungshauptteil * den Inhalt des QR-Codes ein, den Sie generieren möchten. In unserem Fall ist dies * "example.com" *. Wenn Sie fertig sind, klicken Sie auf die Schaltfläche "Aufrufen".

Wenn Sie die Ausgabeoption * Text * oder * JSON * auswählen, gibt die Funktion den Inhalt der Datei aus, der nicht verwendbar oder für den Menschen lesbar ist:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/qr_generated_code.png [OpenFaaS-generierter QR-Code]

Sie können eine Antwort herunterladen. In unserem Fall handelt es sich um eine PNG-Datei mit dem QR-Code. Wählen Sie dazu die Option * Download * und klicken Sie erneut auf * Invoke *. Kurz darauf sollten Sie den QR-Code herunterladen, den Sie mit dem Bildbetrachter Ihrer Wahl öffnen können:

image: https://assets.digitalocean.com/articles/openfaas_ubuntu_1604/qr_image_two.png [Generierter QR-Code]

Neben der Bereitstellung von Funktionen aus dem FaaS-Store oder von Docker-Images können Sie auch eigene Funktionen erstellen. Im nächsten Schritt erstellen Sie eine Python-Funktion mithilfe der FaaS-Befehlszeilenschnittstelle.

Schritt 7 - Erstellen von Funktionen mit der FaaS-CLI

In den vorherigen Schritten haben Sie die FaaS-CLI für die Verwendung mit Ihrem OpenFaaS-Server konfiguriert. Die FaaS-CLI ist eine Befehlszeilenschnittstelle, mit der Sie OpenFaaS verwalten und Funktionen installieren und ausführen können, genau wie Sie es über die API oder über die Web-Benutzeroberfläche tun würden.

Verglichen mit der Web-Benutzeroberfläche oder der API verfügt die FaaS-CLI über Vorlagen für viele Programmiersprachen, mit denen Sie Ihre eigenen Funktionen erstellen können. Es kann auch Container-Images basierend auf Ihrem Funktionscode erstellen und Images an eine Image-Registrierung wie Docker Hub senden.

In diesem Schritt erstellen Sie eine Funktion, veröffentlichen sie in Docker Hub und führen sie dann auf Ihrem OpenFaaS-Server aus. Diese Funktion ähnelt der Standardfunktion "+ echoit +", die als Anforderung übergebene Eingaben zurückgibt.

Wir werden Python verwenden, um unsere Funktion zu schreiben. Wenn Sie mehr über Python erfahren möchten, besuchen Sie unsere How To Code in Python 3 Tutorial-Reihe und unsere How To Code in Python eBook.

Erstellen Sie vor dem Erstellen der neuen Funktion ein Verzeichnis zum Speichern von FaaS-Funktionen und navigieren Sie dorthin:

mkdir ~/faas-functions
cd ~/faas-functions

Führen Sie den folgenden Befehl aus, um eine neue Python-Funktion mit dem Namen "+ echo-input" zu erstellen. Stellen Sie sicher, dass Sie "++" durch Ihren Docker Hub-Benutzernamen ersetzen, da Sie die Funktion später an Docker Hub senden:

faas-cli new  --lang  --prefix  --gateway

Die Ausgabe enthält eine Bestätigung über die erfolgreiche Funktionserstellung. Wenn Sie keine Vorlagen heruntergeladen haben, lädt die CLI Vorlagen in Ihrem aktuellen Verzeichnis herunter:

Output2018/05/13 12:13:06 No templates found in current directory.
2018/05/13 12:13:06 Attempting to expand templates from https://github.com/openfaas/templates.git
2018/05/13 12:13:11 Fetched 12 template(s) : [csharp dockerfile go go-armhf node node-arm64 node-armhf python python-armhf python3 python3-armhf ruby] from https://github.com/openfaas/templates.git
Folder:  created.
 ___                   _____           ____
/ _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
\___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
     |_|


Function created in folder:
Stack file written: .yml

Das Ergebnis des Befehls "+ faas-cli new " ist ein neu erstelltes Verzeichnis " ~ / faas-functions / echo-input", das den Funktionscode und die Datei "+ echo-input.yml" enthält. Diese Datei enthält Informationen zu Ihrer Funktion: In welcher Sprache, in welchem ​​Namen und auf welchem ​​Server Sie sie bereitstellen.

Navigieren Sie zum Verzeichnis "+ ~ / faas-functions / echo-input":

cd ~/faas-fucntions/echo-input

Führen Sie Folgendes aus, um den Inhalt des Verzeichnisses anzuzeigen:

ls

Das Verzeichnis enthält zwei Dateien: "+ handler.py ", die den Code für Ihre Funktion enthalten, und " requirements.txt +", die die für die Funktion erforderlichen Python-Module enthalten.

Da wir derzeit keine nicht standardmäßigen Python-Module benötigen, ist die Datei "+ requirements.txt " leer. Sie können dies mit dem Befehl ` cat +` überprüfen:

cat requirements.txt

Als nächstes schreiben wir eine Funktion, die eine Anfrage als String zurückgibt.

Die Datei "+ handler.py +" enthält bereits den Beispiel-Handlercode, der eine empfangene Antwort als Zeichenfolge zurückgibt. Werfen wir einen Blick auf den Code:

nano handler.py

Die Standardfunktion heißt "+ handle " und verwendet einen einzelnen Parameter " req +", der eine Anforderung enthält, die beim Aufruf an die Funktion übergeben wird. Die Funktion führt nur eine Sache aus und gibt die übergebene Anforderung als Antwort zurück:

def handle(req):
   """handle a request to the function
   Args:
       req (str): request body
   """

   return req

Ändern wir es so, dass es zusätzlichen Text enthält. Ersetzen wir die Zeichenfolge in der Anweisung "+ return +" wie folgt:

   return "Received message: " + req

Speichern Sie die Datei und schließen Sie den Texteditor.

Als Nächstes erstellen wir ein Docker-Image aus dem Quellcode der Funktion. Navigieren Sie zum Verzeichnis "+ faas-functions", in dem sich die Datei "+ echo-input.yml" befindet:

cd ~/faas-functions

Der folgende Befehl erstellt das Docker-Image für Ihre Funktion:

faas-cli build -f

Die Ausgabe enthält Informationen zum Erstellungsfortschritt:

Output[0] > Building echo-input.
Clearing temporary build folder: ./build/echo-input/
Preparing ./echo-input/ ./build/echo-input/function
Building: sammy/echo-input with python template. Please wait..
Sending build context to Docker daemon  7.168kB
Step 1/16 : FROM python:2.7-alpine
---> 5fdd069daf25
Step 2/16 : RUN apk --no-cache add curl     && echo "Pulling watchdog binary from Github."     && curl -sSL https://github.com/openfaas/faas/releases/download/0.8.0/fwatchdog > /usr/bin/fwatchdog     && chmod +x /usr/bin/fwatchdog     && apk del curl --no-cache
---> Using cache
---> 247d4772623a
Step 3/16 : WORKDIR /root/
---> Using cache
---> 532cc683d67b
Step 4/16 : COPY index.py           .
---> Using cache
---> b4b512152257
Step 5/16 : COPY requirements.txt   .
---> Using cache
---> 3f9cbb311ab4
Step 6/16 : RUN pip install -r requirements.txt
---> Using cache
---> dd7415c792b1
Step 7/16 : RUN mkdir -p function
---> Using cache
---> 96c25051cefc
Step 8/16 : RUN touch ./function/__init__.py
---> Using cache
---> 77a9db274e32
Step 9/16 : WORKDIR /root/function/
---> Using cache
---> 88a876eca9e3
Step 10/16 : COPY function/requirements.txt .
---> Using cache
---> f9ba5effdc5a
Step 11/16 : RUN pip install -r requirements.txt
---> Using cache
---> 394a1dd9e4d7
Step 12/16 : WORKDIR /root/
---> Using cache
---> 5a5893c25b65
Step 13/16 : COPY function           function
---> eeddfa67018d
Step 14/16 : ENV fprocess="python index.py"
---> Running in 8e53df4583f2
Removing intermediate container 8e53df4583f2
---> fb5086bc7f6c
Step 15/16 : HEALTHCHECK --interval=1s CMD [ -e /tmp/.lock ] || exit 1
---> Running in b38681a71378
Removing intermediate container b38681a71378
---> b04c045b0994
Step 16/16 : CMD ["fwatchdog"]
---> Running in c5a11078df3d
Removing intermediate container c5a11078df3d
---> bc5f08157c5a
Successfully built bc5f08157c5a
Successfully tagged sammy/echo-input:latest
Image: /echo-input built.
[0] < Building echo-input done.
[0] worker done.

Wenn Sie eine Fehlermeldung erhalten, stellen Sie sicher, dass Sie diese beheben, indem Sie die Anweisungen auf dem Bildschirm befolgen, bevor Sie die Funktion bereitstellen.

Sie müssen Ihre OpenFaaS-Funktion containerisieren, um sie bereitzustellen. Durch das Containerisieren von Anwendungen wird sichergestellt, dass die für die Ausführung Ihrer Anwendung erforderliche Umgebung problemlos reproduziert und Ihre Anwendung problemlos bereitgestellt, skaliert und aktualisiert werden kann.

In diesem Lernprogramm wird Docker Hub als kostenlose Lösung verwendet. Sie können jedoch jede Containerregistrierung verwenden, einschließlich Ihrer eigenen privaten Registrierung.

Führen Sie den folgenden Befehl aus, um das erstellte Image in Ihr angegebenes Repository in Docker Hub zu verschieben:

faas-cli push -f

Das Pushen dauert je nach Geschwindigkeit Ihrer Internetverbindung einige Minuten. Die Ausgabe enthält den Upload-Fortschritt des Bildes:

Output[0] > Pushing echo-input.
The push refers to repository [docker.io/sammy/echo-input]
320ea573b385: Pushed
9d87e56f5d0c: Pushed
6f79b75e7434: Pushed
23aac2d8ecf2: Pushed
2bec17d09b7e: Pushed
e5a0e5ab3be6: Pushed
e9c8ca932f1b: Pushed
beae1d55b4ce: Pushed
2fcae03ed1f7: Pushed
62103d5daa03: Mounted from library/python
f6ac6def937b: Mounted from library/python
55c108c7613c: Mounted from library/python
e53f74215d12: Mounted from library/python
latest: digest: sha256:794fa942c2f593286370bbab2b6c6b75b9c4dcde84f62f522e59fb0f52ba05c1 size: 3033
[0] < Pushing echo-input done.
[0] worker done.

Wenn Sie Ihr Image auf Docker Hub übertragen, können Sie damit eine Funktion auf Ihrem OpenFaaS-Server bereitstellen.

Führen Sie zum Bereitstellen Ihrer Funktion den Befehl "+ deploy +" aus, der den Pfad zum Manifest enthält, das Ihre Funktion beschreibt, sowie die Adresse Ihres OpenFaaS-Servers:

faas-cli deploy -f  --gateway

Die Ausgabe zeigt den Status der Bereitstellung zusammen mit dem Namen der Funktion, die Sie bereitstellen, und dem Bereitstellungsstatuscode:

OutputDeploying: .

Deployed. 200 OK.
URL:

Wenn die Bereitstellung erfolgreich war, wird ein Statuscode von "+ 200 +" angezeigt. Befolgen Sie im Falle von Fehlern die bereitgestellten Anweisungen, um das Problem zu beheben, bevor Sie fortfahren.

Zu diesem Zeitpunkt ist Ihre Funktion implementiert und kann verwendet werden. Sie können testen, ob es wie erwartet funktioniert, indem Sie es aufrufen.

Um eine Funktion mit der FaaS-CLI aufzurufen, verwenden Sie den Befehl "+ invoke +", indem Sie den Funktionsnamen und die OpenFaaS-Adresse übergeben. Nach dem Ausführen des Befehls werden Sie aufgefordert, die Anforderung einzugeben, die Sie an die Funktion senden möchten.

Führen Sie den folgenden Befehl aus, um die Funktion + echo-input + aufzurufen:

faas-cli invoke echo-input --gateway

Sie werden aufgefordert, die Anfrage einzugeben, die Sie an die Funktion senden möchten:

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

Geben Sie den Text ein, den Sie an die Funktion senden möchten, z. B .:

Sammy The Shark!

Wenn Sie fertig sind, drücken Sie "+ ENTER " und dann " STRG + D ", um die Anfrage zu beenden. Die Tastenkombination " STRG + D +" im Terminal wird zum Registrieren eines Dateiendes (End-of-File, EOF) verwendet. Die OpenFaaS-CLI beendet das Lesen vom Terminal, sobald EOF empfangen wird.

Nach einigen Sekunden gibt der Befehl die Antwort der Funktion aus:

OutputReading from STDIN - hit (Control + D) to stop.
Sammy The Shark!
Received message: Sammy The Shark!

Wenn die Ausgabe nicht angezeigt wird oder eine Fehlermeldung angezeigt wird, führen Sie die vorherigen Schritte erneut aus, um sicherzustellen, dass Sie die Funktion wie beschrieben implementiert haben, und befolgen Sie die Anweisungen auf dem Bildschirm, um das Problem zu beheben.

Zu diesem Zeitpunkt haben Sie mit drei Methoden mit Ihrer Funktion interagiert: der Web-Benutzeroberfläche, der API und der CLI. Wenn Sie Ihre Funktionen mit einer dieser Methoden ausführen können, können Sie flexibel entscheiden, wie Sie Funktionen in Ihre vorhandenen Workflows integrieren möchten.

Fazit

In diesem Lernprogramm haben Sie die serverlose Architektur und OpenFaaS verwendet, um Ihre Anwendungen mithilfe der OpenFaaS-API, der Web-Benutzeroberfläche und der CLI bereitzustellen und zu verwalten. Sie haben auch Ihre Infrastruktur gesichert, indem Sie Traefik für die Bereitstellung von SSL mithilfe von Let’s Encrypt eingesetzt haben.

Wenn Sie mehr über das OpenFaaS-Projekt erfahren möchten, lesen Sie die website und die offizielle Dokumentation des projekts.

Related