Erste Schritte mit den serverlosen Funktionen von DigitalOcean

Functions ist eine der neuesten Ergänzungen der DigitalOcean Cloud-Plattform. Es bietet eine erstklassige Methode zur Entwicklung serverloser Funktionen, ohne DigitalOcean zu verlassen. Ihr Code wird nach Bedarf ausgeführt, wenn er aufgerufen wird, wodurch die manuelle Serverbereitstellung und -wartung entfällt.

In diesem Artikel erklären wir, was DigitalOcean Functions unterstützt, und gehen durch eine Demonstration zum Erstellen Ihrer eigenen einfachen Funktion. Functions verfügt über ein kostenloses Kontingent, das 25 GiB-Stunden pro Monat bereitstellt, wobei eine GiB-Sekunde als Arbeitsspeicherverbrauch multipliziert mit der Ausführungszeit jedes Funktionsaufrufs berechnet wird.

Unterstützte Funktionen

Functions wurde im Mai 2022 eingeführt und bietet DigitalOcean-Kunden eine integrierte Option zum Ausführen serverloser Workloads. Jede Funktion erhält ihren eigenen API-Endpunkt, der den von Ihnen erstellten Code ausführt. Sie müssen vor der Bereitstellung keine eigenen Server einrichten oder das Projekt containerisieren. Live-Funktionen werden vom Backend der App-Plattform von DigitalOcean gehostet.

Funktionen können in die verwalteten Datenbanken von DigitalOcean integriert werden, um die dauerhafte Datenspeicherung zu erleichtern. Sie verfügen außerdem über eine umfassende CLI, mit der Sie Ihren Code in Ihrem Terminal bereitstellen und testen können.

Die erste Version der Plattform unterstützt fünf verschiedene Programmierumgebungen:

  • Gehen Sie 1.17
  • Node.js 14
  • Node.js 14 (kompatibel mit AWS Lambda-Funktionen)
  • PHP8
  • Python 3.9

Sie müssen Ihren Code in einer dieser Sprachen schreiben können, um ihn als Funktion bereitzustellen. Weitere Laufzeiten könnten in Zukunft unterstützt werden.

Einrichten

Es ist möglich, neue Funktionen mit dem Web Control Panel von DigitalOcean oder Doctl, seiner entwicklerorientierten CLI, zu starten. Wir konzentrieren uns für die Zwecke dieses Artikels auf den Terminal-basierten Doctl-Ansatz. Dies macht alle Funktionen von Functions verfügbar und ist der beabsichtigte Weg für alle außer den einfachsten Anwendungsfällen. Stellen Sie sicher, dass Sie die neueste Version von Doctl installiert und bei Ihrem DigitalOcean-Konto authentifiziert haben, bevor Sie fortfahren.

Bild von DigitalOcean-Funktionen

Sie müssen einige weitere Einrichtungsschritte ausführen, wenn Sie die DigitalOcean-Funktionen zum ersten Mal verwenden. Beenden Sie zunächst die Installation von Doctl’s serverless Verlängerung. Dies fügt volle Unterstützung für die Entwicklung und Bereitstellung von Funktionen hinzu.

$ doctl serverless install
Downloading...Unpacking...Installing...Cleaning up...
Done

Verbinden Sie als Nächstes die serverlosen Funktionen mit Ihrem DigitalOcean-Konto:

$ doctl serverless connect
Connected to function namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a' on API host 'https://faas-lon1-917a94a7.doserverless.co'

Jetzt sollten Sie bereit sein, mit dem Schreiben von Funktionen zu beginnen. Führen Sie die aus serverless status Befehl, um zu überprüfen, ob alles funktioniert:

$ doctl serverless status
Connected to function namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a' on API host 'https://faas-lon1-917a94a7.doserverless.co'
Sandbox version is 3.1.1-1.2.1

Die oben gezeigte Ausgabe bestätigt, dass die Functions-Unterstützung installiert und einsatzbereit ist.

Lesen Sie auch  Die Verbesserung der naturwissenschaftlichen Grundbildung bedeutet eine Veränderung der naturwissenschaftlichen Bildung

Das serverless Befehl ist ein Alias ​​von sandbox. Zum Zeitpunkt des Schreibens haben die beiden Schlüsselwörter identische Funktionen und werden in der Dokumentation von DigitalOcean austauschbar verwendet. Wir standardisieren auf serverless für diese Anleitung.

Erstellen einer Funktion

Verwenden Sie den folgenden Befehl, um ein neues Functions-Projekt zu erstellen:

$ doctl serverless init --language js demo-project
A local sandbox area 'demo-project' was created for you.
You may deploy it by running the command shown on the next line:
  doctl sandbox deploy demo-project

Dieser Befehl erstellt eine neue JavaScript-Funktion innerhalb demo-project in Ihrem Arbeitsverzeichnis. Überprüfen Sie den Inhalt dieses Verzeichnisses, um zu sehen, was Doctl für Sie erstellt hat:

$ tree demo-project
demo-project
├── packages
│   └── sample
│       └── hello
│           └── hello.js
└── project.yml

3 directories, 2 files

Das project.yml In dieser Datei konfigurieren Sie Ihr Funktionsprojekt und die bereitgestellten Endpunkte.

targetNamespace: ''
parameters: {}
packages:
  - name: sample
    environment: {}
    parameters: {}
    annotations: {}
    actions:
      - name: hello
        binary: false
        main: ''
        runtime: 'nodejs:default'
        web: true
        parameters: {}
        environment: {}
        annotations: {}
        limits: {}

Das Starter-Template konfiguriert ein Paket namens sample. In diesem Paket gibt es eine einzelne Aktion (Endpunkt) mit dem Namen hello das wird mit der Node-Laufzeit ausgeführt. Der Quellcode für diese Aktion ist unter gespeichert packages/sample/hello/hello.js. Schauen wir uns als nächstes diese Datei an:

function main(args) {
    let name = args.name || 'stranger'
    let greeting = 'Hello ' + name + '!'
    console.log(greeting)
    return {"body": greeting}
}

Dies ist normaler JavaScript-Code. Das main() Funktion wird jedes Mal aufgerufen, wenn Ihre Funktion aufgerufen wird. Es empfängt ein Objekt, das Argumente enthält, die als HTTP GET- und POST-Daten in der Benutzeranforderung übermittelt werden. Sie können auch statische Argumente konfigurieren, indem Sie die verwenden parameters Feld für Aktionen, Pakete und das Projekt der obersten Ebene in Ihrem project.yml Datei.

Funktionen müssen ein Objekt zurückgeben, das die HTTP-Antwort auf die Ausgabe beschreibt. Das body Feld wird zu den Daten, die in der Antwort enthalten sind.

Aufrufen und Bereitstellen von Funktionen

Dieses Projekt ist betriebsbereit. Verwenden Sie diesen Befehl, um Ihre Funktion bereitzustellen:

$ doctl serverless deploy .
Deploying '/home/james/@scratch/demo-project'
  to namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a'
  on host 'https://faas-lon1-917a94a7.doserverless.co'
Deployment status recorded in '.nimbella'

Deployed functions ('doctl sbx fn get  --url' for URL):
  - sample/hello

Das serverless deploy Der Befehl benötigt ein Argument, den Pfad zu dem Verzeichnis, das Ihre Funktionen enthält. Verwenden . wenn das Stammverzeichnis Ihres Projekts bereits Ihr Arbeitsverzeichnis ist.

Lesen Sie auch  Die Schwachstelle von Microsoft Teams zeigt die Gefahr von Collaboration-Apps

Jetzt können Sie Ihre Funktion mit der CLI testen:

$ doctl serverless functions invoke sample/hello -p name:howtogeek
{
    "body": "Hello howtogeek!"
}

Das -p Parameter legt ein Argument fest, das an Ihren Code weitergegeben wird. Dieses Beispiel zeigt, wie der Rückgabewert Ihrer Funktion zum HTTP-Antworttext wird.

Versuchen Sie als Nächstes, eine echte API-Anforderung an Ihre Funktion zu stellen. Sie können seine URL mit dem folgenden Befehl ermitteln:

$ URL=$(doctl serverless functions get sample/hello --url)

Verwenden curl oder Ihren eigenen bevorzugten HTTP-Client, um diesen Endpunkt zu erreichen:

$ curl $URL?name=howtogeek
Hello howtogeek!

Das name Der Abfragezeichenfolgenparameter wurde erfolgreich an die Funktion übergeben.

Ändern Ihrer Funktion

Bisher verwenden wir den Beispielcode von DigitalOcean ohne Änderungen. Dies wird Sie auf Ihrer serverlosen Reise nicht weit bringen! Bearbeiten Sie Ihre hello.js Datei, also sieht es so aus:

function main(args) {
    return {
        body: {
            value: (args.value * 2),
            timestamp: Date.now()
        },
        headers: {
            "Content-Type": "application/json"
        }
    };
}

Stellen Sie Ihre Funktion erneut bereit:

$ doctl serverless deploy .

Diese Funktion verdoppelt naiverweise die durch die angegebene Zahl value Anforderungsparameter. Es enthält auch einen Zeitstempel mit jedem Antworttext. Das headers Feld wird im Antwortobjekt verwendet, um ein korrektes JSON anzuwenden Content-Type.

Sie können diese Funktion mit Doctl oder aufrufen curl im gleichen Stil wie zuvor:

$ curl $URL?value=2
{
  "timestamp": 1654784122966,
  "value": 4
}

Das manuelle erneute Bereitstellen Ihrer Funktion nach jeder Änderung ist mühsam und zeitaufwändig. Führen Sie die aus watch Befehl, während Sie daran arbeiten, Änderungen automatisch bereitzustellen, nachdem Sie Ihre Dateien geändert haben:

$ doctl serverless watch .
Watching '.' [use Control-C to terminate]

Lassen Sie das Terminalfenster geöffnet, während Sie Ihre Funktion entwickeln. Bei jeder neuen Bereitstellung wird eine Nachricht protokolliert, damit Sie wissen, wann Sie Ihre Änderungen testen können. Dies erleichtert eine effiziente Iteration bei der Entwicklung Ihrer Funktionen.

Sie können auch Protokolle von Ihren Funktionen streamen. Dies ist von unschätzbarem Wert, wenn eine Funktion abstürzt oder sich nicht wie erwartet verhält. Führen Sie diesen Befehl aus, um auf die mit Ihrer Demofunktion verknüpften Protokolle zuzugreifen:

$ doctl serverless activations logs --follow --function sample/hello

Bei jedem Aufruf Ihrer Funktion wird eine neue Zeile ausgegeben. Die Protokolle enthalten auch Meldungen, die Ihr Code an die Standardausgabe und Fehlerstreams der Umgebung ausgibt.

Bereitstellung in der Produktion

Das serverless deploy Der Befehl ist derzeit nur für Entwicklungszwecke konzipiert. Sie können für die Produktion bereitstellen, indem Sie ein Git-Repository für Ihr Functions-Projekt erstellen und es mit der App-Plattform von DigitalOcean starten.

Lesen Sie auch  Valneva als sechster Covid-Impfstoff Großbritanniens zugelassen | Coronavirus

Erstellen Sie ein neues Projekt auf GitHub oder GitLab und veröffentlichen Sie Ihren Code:

$ git init
$ git remote add origin [email protected]:user/repo.git
$ git add .
$ git commit -m "initial commit"
$ git push -u origin master

Bild zum Erstellen einer App in der DigitalOcean App Platform

Gehen Sie als nächstes zu Ihrem DigitalOcean-Kontrollfeld und klicken Sie auf den Link „Apps“ in der linken Seitenleiste. Klicken Sie auf die erscheinende Schaltfläche „App erstellen“. Folgen Sie auf dem nächsten Bildschirm den Anweisungen, um eine Verbindung zu Ihrem GitHub-Konto herzustellen, und wählen Sie Ihr neues Repository aus. Drücken Sie die blaue Schaltfläche „Weiter“.

Bild zum Erstellen einer App in der DigitalOcean App Platform

DigitalOcean erkennt Ihr Repository automatisch als Functions-Projekt, wenn Sie eine haben project.yml an seiner Wurzel. Klicken Sie auf die Schaltfläche „Zur Überprüfung springen“, um fortzufahren.

Bild einer Functions-App in der DigitalOcean App Platform

Der nächste Bildschirm sollte bestätigen, dass Ihnen der Funktionsplan in Rechnung gestellt wird.

Bild einer Functions-App in der DigitalOcean App Platform

Klicken Sie auf „Ressourcen erstellen“, um Ihre App bereitzustellen und mit der ersten Bereitstellung zu beginnen. Der Fortschritt wird auf dem Dashboard angezeigt.

Bild einer Functions-App, die in der DigitalOcean App Platform bereitgestellt wird

Die Endpunkte Ihrer Funktion sind öffentlich zugänglich, sobald die Bereitstellung abgeschlossen ist. Sie können den Standard Ihrer App finden ondigitalocean.app Domain, indem Sie in Ihrem Dashboard auf der Seite App-Einstellungen nach unten scrollen. In unserem Beispiel lautet die Domäne der App sea-lion-app.7ougx.ondigitalocean.app.

Bild zum Suchen der Domain einer App in der DigitalOcean App Platform

Funktionen werden automatisch als URIs verfügbar gemacht, die das folgende Format haben:

.ondigitalocean.app//

Sie können die zuvor erstellte Beispielfunktion aufrufen, indem Sie die folgende Anfrage stellen:

$ curl https://sea-lion-app.7ougx.ondigitalocean.app/sample/hello?value=2
{
  "timestamp": 1654786505969,
  "value": 4
}

Die Funktion wurde erfolgreich bereitgestellt! Sie können jetzt die Registerkarte Domänen in den Einstellungen Ihrer App verwenden, um eine benutzerdefinierte Domäne anstelle der Standarddomäne anzuhängen.

Zusammenfassung

DigitalOcean Functions ist der neueste Konkurrent im zunehmend überfüllten Bereich serverloser Funktionen. Mit der Plattform können Sie serverseitige Funktionen entwickeln, ohne VMs verwalten oder Ihren Code manuell containerisieren zu müssen.

Functions bietet eine umfassende CLI zum Erstellen und Testen Ihrer Endpunkte. Anschließend können Sie Ihre Funktionen in der bestehenden App-Plattformlösung von DigitalOcean bereitstellen, entweder als eigenständiges Projekt oder als Teil einer größeren App.

Sobald Sie eine grundlegende Funktion in Betrieb genommen haben, können Sie in der Dokumentation von DigitalOcean nachschlagen, um mit der Konfiguration erweiterter Verhaltensweisen zu beginnen. Sie können Umgebungsvariablen, mehrere Aktionen und Ressourcenlimits mithilfe der Felder in Ihrer einrichten project.yml -Datei, wodurch Sie schnell und einfach relativ komplexe On-Demand-Endpunkte erstellen können.

Leave a Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.