Wie schreibt man eine serverlose Funktion

Serverlose Funktionen sollten gut funktionieren und nur auf Anfrage von einem inaktiven Zustand aus verfügbar sein. Wir geben Ihnen eine Anleitung, wie Sie eine serverlose Anwendung erstellen – und was Sie sonst noch rund um dieses Thema wissen sollten.

Serverlose Architektur ermöglicht es, Backend-Webdienste nach Bedarf zu implementieren. Anstatt Ihre eigene Serverkonfiguration zu pflegen, können Sie Ihre Software für serverlose Anbieter konzipieren, um den damit verbundenen Overhead zu minimieren. Serverlose Anwendungen werden in der Regel aus einem Git-Repository in eine Umgebung bereitgestellt, die je nach Bedarf skaliert werden kann.

Dies bedeutet, dass serverlose Funktionen effektiv "auf null" skaliert werden können - eine Funktion oder ein Endpunkt sollte keine Ressourcen verbrauchen, solange er nicht aufgerufen wird. Dies bedeutet jedoch auch, dass serverlose Funktionen gut verhalten müssen und nur aus einem Ruhezustand heraus verfügbar sein sollten, um individuelle Antworten auf Eingabeaufforderungen bereitzustellen. Diese Antworten können so rechenintensiv sein, wie es erforderlich ist, müssen jedoch in einer vorhersehbaren Weise aufgerufen und beendet werden.

Voraussetzungen

• Eine lokale Shell-Umgebung mit einem installierten serverlosen Bereitstellungstool.
• Das Versionskontrollwerkzeug Git in Ihrer Entwicklungsumgebung verfügbar.

Schritt 1 - Erstellung eines Serverless-App-Repositorys

Eine vollständige serverlose Anwendung kann sich auf nur zwei Dateien beschränken: die Konfigurationsdatei, die normalerweise in .yml-Syntax vorliegt und die erforderlichen Metadaten für Ihre Anwendung beim serverlosen Anbieter deklariert, und eine Datei, die den Code selbst enthält, z. B. my_app.py, my_app.js oder my_app.go. Wenn Ihre Anwendung Sprachabhängigkeiten hat, werden sie in der Regel ebenfalls unter Verwendung von Standard-Sprachkonventionen deklariert, z. B. eine package.json-Datei für Node.js.

Um eine serverlose Anwendung zu initialisieren, können Sie doctl sandbox init mit dem Namen eines neuen Verzeichnisses verwenden:

ctctl sandbox init myServerlessProject

Standardmäßig wird dies ein Projekt mit folgender Verzeichnisstruktur erstellen:

myServerlessProject/
    +-- packages
    ¦   +-- sample
    ¦       +-- hello
    ¦           +-- hello.js
    +-- project.yml

Die project.yml-Datei befindet sich im obersten Verzeichnis. Sie deklariert Metadaten für hello.js, das eine einzige Funktion enthält. Alle serverlosen Anwendungen folgen dieser essentiellen Struktur. Weitere Beispiele mit anderen serverlosen Frameworks finden Sie im offiziellen Serverless Framework GitHub-Repository. Sie können auch diese Verzeichnisstrukturen von Grund auf neu erstellen, ohne auf eine Initialisierungsfunktion angewiesen zu sein, beachten Sie jedoch, dass die Anforderungen jedes serverlosen Anbieters geringfügig variieren werden.

Schritt 2 - Architektur einer serverlosen Anwendung

Eine serverlose Anwendung kann aus einer einzelnen Funktion bestehen, die in einer Sprache geschrieben ist, die von Ihrem serverlosen Computing-Anbieter interpretiert wird (in der Regel Go, Python und JavaScript), solange sie eine Ausgabe zurückgeben kann. Ihre Funktion kann andere Funktionen aufrufen oder andere Sprachbibliotheken laden, aber es sollte immer eine einzige Hauptfunktion in Ihrer Projekt-Konfigurationsdatei definiert sein, die mit dem Endpunkt selbst kommuniziert.

Das Ausführen von doctl sandbox init im letzten Schritt hat automatisch ein Beispielprojekt für Ihre serverlose Anwendung generiert, einschließlich einer Datei namens hello.js. Sie können diese Datei mit nano oder Ihrem bevorzugten Texteditor öffnen:

nano myServerlessProject/packages/sample/hello/hello.js

Diese Datei enthält eine einzige Funktion namens main(), die eine Menge von Argumenten akzeptieren kann. Dies ist die Standardmethode, mit der serverlose Architekturen die Eingabe verarbeiten. Serverlose Funktionen müssen nicht unbedingt JSON oder HTTP-Header direkt analysieren, um die Eingabe zu verarbeiten. Auf den meisten Plattformen der Anbieter erhalten serverlose Funktionen Eingaben von HTTP-Anfragen als Liste von Argumenten, die mithilfe von Standard-Sprachfunktionen ausgepackt werden können.

Die erste Zeile der Funktion verwendet den JavaScript ||-Operator, um ein name-Argument zu parsen, wenn es vorhanden ist, oder den String "stranger" zu verwenden, wenn die Funktion ohne Argumente aufgerufen wird. Dies ist wichtig, falls der Endpunkt Ihrer Funktion falsch abgefragt oder mit fehlenden Daten aufgerufen wird. Serverlose Funktionen sollten immer einen Codepfad haben, der es Ihnen ermöglicht, schnell null zurückzugeben oder das Äquivalent von null in einer gut geformten HTTP-Antwort zurückzugeben, mit minimalem zusätzlichem Verarbeitungsaufwand. Die nächste Zeile, let greeting =, führt einige zusätzliche Zeichenmanipulationen durch.

Je nach Ihrem serverlosen Anbieter haben Sie möglicherweise keine Dateisystem- oder Betriebssystemfunktionen für Ihre Funktion zur Verfügung. Serverlose Anwendungen sind nicht unbedingt zustandslos. Funktionen, die serverlosen Anwendungen erlauben, ihren Zustand zwischen den Ausführungen aufzuzeichnen oder beizubehalten, sind jedoch in der Regel eigentümlich für jeden Anbieter. Die häufigste Ausnahme davon ist die Möglichkeit, Ausgaben Ihrer Funktionen zu protokollieren und zu behalten. Die Beispiel-App hello.js enthält eine console.log() -Funktion, die eine integrierte Funktion von JavaScript verwendet, um einige zusätzliche Daten auf die Konsole eines Browsers oder auf die Standardausgabe eines lokalen Terminals auszugeben, ohne sie an den Benutzer zurückzugeben. Die meisten serverlosen Anbieter ermöglichen Ihnen auf diese Weise, Protokollausgaben zu behalten und zu überprüfen.

Die letzte Zeile der Funktion wird verwendet, um Ausgaben aus Ihrer Funktion zurückzugeben. Da die meisten serverlosen Funktionen als HTTP-Endpunkte bereitgestellt werden, möchten Sie normalerweise eine HTTP-Antwort zurückgeben. Ihre serverlose Umgebung kann diese Antwort automatisch für Sie erstellen. In diesem Fall ist es nur notwendig, einen Anforderungskörper innerhalb eines Arrays zurückzugeben, und die Endpunkt-Konfiguration kümmert sich um den Rest.

Diese Funktion könnte viele weitere Schritte durchführen, solange sie die gleichen Grundanforderungen an Eingabe und Ausgabe erfüllt. Alternativ könnte Ihre Anwendung mehrere serverlose Funktionen in einer Sequenz ausführen, und sie könnten bei Bedarf ausgetauscht werden. Serverlose Funktionen können als ähnlich wie microservice-getriebene Architekturen angesehen werden: Beide ermöglichen es Ihnen, eine Anwendung aus mehreren lose gekoppelten Diensten zusammenzustellen, die nicht unbedingt voneinander abhängig sind und über etablierte Protokolle wie HTTP kommunizieren. Nicht alle Microservice-Architekturen sind serverlos, aber die meisten serverlosen Architekturen implementieren Microservices.

Schritt 3 - Bereitstellung einer serverlosen Funktion

Die ctctl-Sandbox-Befehlszeilentools ermöglichen es Ihnen, Ihre Anwendung ohne Beförderung in die Produktion zu bereitstellen und zu testen, und andere serverlose Implementierungen bieten ähnliche Funktionen. In fast allen Bereitstellungs-Workflows für serverlose Funktionen müssen Sie jedoch Ihre Anwendung in ein Quellcode-Repository wie GitHub hochladen und das GitHub-Repository mit Ihrem serverlosen Anbieter verbinden.

Wenn Sie für eine Produktionseinsatz bereit sind, sollten Sie in der Lage sein, die Konsole Ihres serverlosen Anbieters zu besuchen und Ihr Quellcode-Repository als Teil einer Anwendung zu identifizieren. Ihre Anwendung kann auch andere Komponenten haben, wie z. B. eine statische Website, oder sie kann nur den einen Endpunkt bereitstellen.

Für den Moment können Sie direkt in eine Test-Sandbox mit ctctl sandbox bereitstellen:

ctctl sandbox deploy myServerlessProject

Dies gibt Informationen über Ihre Bereitstellung zurück, einschließlich eines weiteren Befehls, den Sie ausführen können, um Ihre Live-Test-URL anzufordern:

Ausgabe
    Bereitgestellt '~/Desktop/myServerlessProject'
     zu Namespace 'f8572f2a-swev6f2t3bs'
     auf Host 'https://faas-nyc1-78edc.ctserverless.io'
    Bereitstellungsstatus in 'myServerlessProject\.nimbella' aufgezeichnet

    Bereitgestellte Funktionen ('doctl sbx fn get  --url' für URL):
     - sample/hello

Das Ausführen dieses Befehls gibt den aktuellen Endpunkt Ihrer serverlosen Funktion zurück:

ctctl sbx fn get sample/hello –url

Die zurückgegebenen Pfade werden automatisch generiert, sollten jedoch mit /sample/hello enden, basierend auf den Funktionsnamen.

Hinweis: Sie können die Funktionalität der ctctl Sandbox-Bereitstellung im Quellrepository überprüfen.

Nachdem Sie in der Test- oder Produktionsumgebung bereitgestellt haben, können Sie cURL verwenden, um HTTP-Anfragen an Ihren Endpunkt zu senden. Für die in diesem Tutorial entwickelte Beispielanwendung sample/hello sollten Sie eine curl-Anfrage an Ihren /sample/hello-Endpunkt senden können:

curl https://faas-nyc1-78edc.ctserverless.io/api/v1/web/f8572f2a-swev6f2t3bs/sample/hello

Die Ausgabe wird als der Body einer Standard-HTTP-Anfrage zurückgegeben:

Ausgabe
    “Hello stranger!”

Sie können auch das name-Argument für Ihre Funktion wie oben beschrieben angeben, indem Sie es als zusätzlichen URL-Parameter codieren:

curl https://faas-nyc1-78edc.ctserverless.io/api/v1/web/f8572f2a-swev6f2t3bs/sample/hello?name=sammy

Die Ausgabe wird sein:

Ausgabe
    “Hello sammy!”

Nachdem Sie getestet und bestätigt haben, dass Ihre Anwendung die erwarteten Antworten zurückgibt, sollten Sie sicherstellen, dass das Senden unerwarteter Ausgaben an Ihren Endpunkt dazu führt, dass er gracefully scheitert. Sie können bewährte Methoden zur Fehlerbehandlung überprüfen, um sicherzustellen, dass die Eingabe korrekt geparst wird, aber am wichtigsten ist, sicherzustellen, dass Ihre Anwendung niemals unerwartet hängen bleibt, da dies Verfügbarkeitsprobleme für serverlose Apps verursachen kann, sowie unerwartete Abrechnung pro Verwendung.

Fazit

In diesem Tutorial haben wir eine Beispielserverlose Funktion schreibt, überprüft und bereitgestellt. Obwohl jede serverlose Computing-Plattform im Wesentlichen proprietär ist, folgen die verschiedenen Anbieter sehr ähnlichen architektonischen Prinzipien, und die Prinzipien in diesem Tutorial sind weitgehend anwendbar. Wie jeder andere Web-Stack können serverlose Architekturen in Bezug auf den Umfang erheblich variieren, aber die Gewährleistung, dass einzelne Komponenten eigenständig sind, hilft dabei, Ihren gesamten Stack wartbarer zu halten.