Verwalten Sie serverlose APIs mit Apache APISIX

Serverless Computing ermöglicht es Entwicklern, Anwendungen schneller zu erstellen, indem sie sich nicht um die Verwaltung der Infrastruktur kümmern müssen. Mit serverlosen APIs in der Cloud stellt der Cloud-Dienstleister automatisch die Infrastruktur bereit, skaliert sie und verwaltet sie, um den Code auszuführen. In diesem Artikel erfahren Sie, wie Sie das Apache APISIX API Gateway mit Azure Functions integrieren, um Java-basierte serverlose APIs zu verwalten.

Lernziele

In diesem Artikel lernen Sie Folgendes:

• Was sind serverlose APIs?
• Die Rolle des API-Gateways bei der Verwaltung von komplexem serverlosem API-Verkehr.
• Wie man das Apache APISIX Gateway einrichtet.
• Wie man serverlose APIs mit Azure Functions erstellt.
• Wie man serverlose APIs als Upstream-Dienste verfügbar macht.
• Wie man serverlose APIs mit APISIX-Authentifizierungs-Plugins sichert.
• Wie man Ratenbegrenzungsrichtlinien anwendet.

Apache APISIX bietet weitere Plugins, die mit anderen serverlosen Lösungen wie AWS Lambda verwendet werden können.

Bevor wir mit dem praktischen Teil des Tutorials beginnen, gehen wir einige Konzepte durch.

Was sind serverlose APIs?

Serverlose APIs sind dasselbe wie traditionelle APIs, außer dass sie ein serverloses Backend nutzen. Für Unternehmen und Entwickler bedeutet serverloses Computing, dass sie sich nicht mehr um die Wartung oder Skalierung von Serverressourcen kümmern müssen, um die Benutzeranforderungen zu erfüllen. Serverlose APIs vermeiden das Problem der Skalierung, da sie bei jeder Anfrage Serverressourcen erstellen. Serverlose APIs reduzieren die Latenz, da sie auf einem Ursprungsserver gehostet werden. Last but not least ist serverloses Computing weitaus kosteneffizienter als die traditionelle Alternative, wie z. B. der Aufbau ganzer Microservices.

Serverlose APIs mit Azure Functions

Eine Azure Function ist eine einfache Möglichkeit, kleine Code-Schnipsel in der Cloud auszuführen. Sie müssen sich nicht um die Infrastruktur kümmern, die zur Ausführung dieses Codes erforderlich ist. Sie können die Funktion in C#, Java, JavaScript, PowerShell, Python oder einer der in den unterstützten Sprachen aufgeführten Sprachen schreiben.

Mit Azure Functions können Sie schnell HTTP-APIs für Ihre Web-Apps erstellen, ohne sich mit Web-Frameworks herumschlagen zu müssen. Azure Functions ist serverlos, daher werden Sie nur dann belastet, wenn ein HTTP-Endpunkt aufgerufen wird. Wenn die Endpunkte nicht verwendet werden, fallen keine Kosten an. Diese beiden Faktoren machen serverlose Plattformen wie Azure Functions zu einer idealen Wahl für APIs, bei denen unerwartete Traffic-Spitzen auftreten.

API-Gateway für die Verwaltung von serverlosem API-Verkehr

Ein API-Gateway ist ein grundlegender Bestandteil von serverlosen APIs, da es für die Verbindung zwischen einer definierten API und der Funktion verantwortlich ist, die Anfragen an diese API verarbeitet. Es gibt viele Vorteile eines API-Gateways in der serverlosen API-Architektur. Neben den primären Edge-Funktionen des API-Gateways wie Authentifizierung, Ratenbegrenzung, Beobachtbarkeit, Caching usw. ist es in der Lage, serverlose APIs aufzurufen, Ereignisse zu abonnieren und sie dann über Callbacks zu verarbeiten sowie Authentifizierungsanfragen an externe Autorisierungsdienste weiterzuleiten, mit vollständig benutzerdefinierter serverloser Funktionslogik.

Verwaltung von serverlosen APIs mit Apache APISIX Demo

Mit genügend theoretischem Wissen können wir nun in eine praktische Sitzung einsteigen. Wir verwenden ein Beispielprojekt-Repo apisix-manage-serverless-apis, das auf GitHub gehostet wird. Sie finden den Quellcode und die Beispiel-Curl-Befehle, die wir in diesem Tutorial verwenden.

Für unser Mini-Projekt arbeiten wir mit zwei einfachen Azure Functions, die in Java geschrieben sind und unsere serverlosen APIs für Produkte und Bewertungen simulieren.

Voraussetzungen

• Grundlegende Kenntnisse über API-Konzepte
• Grundkenntnisse über Azure Functions, z. B. zeigt dieses Lernmodul, wie man eine HTTP-API mit der Azure Functions-Erweiterung für Visual Studio Code erstellt.
• Docker
• Azure-Konto
• Azure CLI
• Java Developer Kit, mindestens Version 8
• Maven
• Azure Functions Core Tools
• Visual Studio Code
• Azure Functions Core Tools (mind. Version 2.6.666)
• Azure Functions-Erweiterung für Visual Studio Code

Projekt einrichten

Das erste, was Sie tun müssen, ist das Projekt-Repo von GitHub zu klonen:

git clone https://github.com/Boburmirzo/apisix-manage-serverless-apis.git

Öffnen Sie den Projektordner in Ihrem bevorzugten Code-Editor. Das Tutorial verwendet VS Code.

Apache APISIX ausführen

Um Apache APISIX und Azure Functions lokal auszuführen, können Sie diese Schritte befolgen:

Öffnen Sie ein neues Terminalfenster und führen Sie den Befehl docker compose up aus dem Stammverzeichnis des Projekts aus:

docker compose up -d

Der obige Befehl führt Apache APISIX und etcd zusammen mit Docker aus. Wenn Docker Desktop auf Ihrem Computer installiert ist, können Sie die laufenden Container dort sehen:

Wir haben APISIX in dieser Demo in unserer lokalen Umgebung installiert, aber Sie können es auch auf Azure bereitstellen und auf Azure Container Instance ausführen. Siehe das folgende Tutorial.

Azure Functions ausführen

Navigieren Sie dann zum Ordner /upstream:

mvn clean install
mvn azure-functions:run

Die beiden Funktionen werden in einem Terminalfenster gestartet. Sie können beide serverlosen APIs in Ihrem Browser anfordern:

Zum Beispiel:

Azure Functions bereitstellen

Als Nächstes stellen wir den Funktionscode in der Azure Function App bereit, indem wir den folgenden Befehl ausführen:

mvn azure-functions:deploy

Oder Sie können einfach diesem Tutorial folgen, wie man das Funktionsprojekt auf Azure bereitstellt

Beachten Sie, dass der Name der Funktions-App zufällig basierend auf Ihrer artifactId generiert wird, gefolgt von einer zufällig generierten Nummer. In den Tutorial-Befehlen wird der Name der Funktions-App serverless-apis erwähnt.

Um sicherzustellen, dass unsere Funktion funktioniert, können wir einen Aufruf direkt über ihre URL im Browser testen:

https://serverless-apis.azurewebsites.net/api/products
https://serverless-apis.azurewebsites.net/api/reviews

Serverlose APIs in APISIX verfügbar machen

Sobald das Setup abgeschlossen ist, werden wir nun die serverlosen Azure Function APIs als Upstream-Dienste in APISIX verfügbar machen. Dazu müssen wir eine neue Route erstellen, bei der das azure-function-Plugin für beide products- und reviews-serverlosen Backend-APIs aktiviert ist.

Wenn das azure-function-Plugin auf einer Route aktiviert ist, lauscht APISIX auf Anfragen auf dem Pfad dieser Route und ruft dann den entfernten Azure Function-Code mit den Parametern aus dieser Anfrage auf.

Route für Produkte erstellen

Um eine Route für die Produktfunktion zu erstellen, führen Sie den folgenden Befehl aus:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Create a route with Azure function plugin",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        }
    },
    "uri": "/products"
}'

Beachten Sie, dass wir das Attribut ssl_verify des azure-functions-Plugins auf false gesetzt haben, um die SSL-Überprüfung nur für Demo-Zwecke zu deaktivieren. Sie können es auch aktivieren, um sicherere Anfragen von APISIX an Azure Functions durchzuführen. Erfahren Sie mehr über andere Konfigurationsparameter.

Test mit einem curl-Request

Wir können curl verwenden, um eine Anfrage zu senden und zu überprüfen, ob APISIX den Pfad korrekt abhört und die Anfrage erfolgreich an den Upstream-Dienst weiterleitet:

curl -i -XGET http://127.0.0.1:9080/products
HTTP/1.1 200 OK
[
  {
    "id": 1,
    "name": "Product1",
    "description": "Description1"
  },
  {
    "id": 2,
    "name": "Product2",
    "description": "Description2"
  }
]

Großartig! Wir haben eine Antwort von der tatsächlichen serverlosen API auf Azure Function erhalten.

Als Nächstes werden wir eine ähnliche Konfiguration für die reviews-Funktion vornehmen.

Route für Bewertungen erstellen und testen

Erstellen Sie die zweite Route mit aktiviertem Azure Function-Plugin:

curl http://127.0.0.1:9180/apisix/admin/routes/2 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/reviews",
            "ssl_verify": false
        }
    },
    "uri": "/reviews"
}'

Testen Sie die Antwort der serverlosen API:

curl -i -XGET http://127.0.0.1:9080/reviews

In diesem Abschnitt haben wir die neue Route eingeführt und das azure-functions-Plugin zu unseren serverlosen APIs hinzugefügt, damit APISIX entfernte Azure Functions aufrufen und den Verkehr verwalten kann. In den folgenden Abschnitten werden wir lernen, wie man API-Konsumenten authentifiziert und Laufzeitrichtlinien wie Ratenbegrenzung anwendet.

Serverlose APIs mit APISIX-Authentifizierungs-Plugins sichern

Bisher sind unsere serverlosen APIs öffentlich und für nicht autorisierte Benutzer zugänglich. In diesem Abschnitt werden wir die Authentifizierungsfunktion aktivieren, um nicht autorisierte Anfragen an serverlose APIs zu verhindern.

Apache APISIX kann die Identität, die mit API-Anfragen verbunden ist, durch die Validierung von Anmeldeinformationen und Token überprüfen. Außerdem kann es feststellen, welcher Verkehr autorisiert ist, um die API zu den Backend-Diensten zu passieren. Sie können alle verfügbaren Authentifizierungs-Plugins überprüfen.

Lassen Sie uns einen neuen Consumer für unsere serverlosen APIs erstellen und das basic-auth-Plugin für die bestehende Route hinzufügen, sodass nur berechtigte Benutzer darauf zugreifen können.

Neuen Consumer für serverlose APIs erstellen

Der folgende Befehl erstellt unseren neuen Consumer mit seinen Anmeldeinformationen wie Benutzername und Passwort:

curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "username": "consumer1",
    "plugins": {
        "basic-auth": {
            "username": "username1",
            "password": "password1"
        }
    }
}'

Basic-Auth-Plugin zu den bestehenden Produkt- und Bewertungsrouten hinzufügen

Jetzt konfigurieren wir das basic-auth-Plugin für die Routen, damit APISIX bei jedem API-Aufruf den Anfrage-Header mit den Anmeldeinformationen des API-Consumers überprüft:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Create a route with Azure function plugin",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        },
        "basic-auth": {}
    },
    "uri": "/products"
}'

curl http://127.0.0.1:9180/apisix/admin/routes/2 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/reviews",
            "ssl_verify": false
        },
        "basic-auth": {}
    },
    "uri": "/reviews"
}'

Basic-Auth-Plugin testen

Wenn wir jetzt die serverlosen APIs ohne Benutzeranmeldeinformationen im Header anfordern, erhalten wir einen nicht autorisierten Fehler:

curl -i http://127.0.0.1:9080/products
HTTP/1.1 401 Unauthorized

{"message":"Missing authorization in request"}

Das Ergebnis ist wie erwartet. Wenn wir jedoch die korrekten Benutzeranmeldeinformationen in der Anfrage angeben und denselben Endpunkt aufrufen, sollte es problemlos funktionieren:

curl -i -u username1:password1 http://127.0.0.1:9080/products
HTTP/1.1 200 OK

Wir haben die Identität des Clients, der versucht, serverlose APIs anzufordern, mithilfe des Basic-Authentifizierungs-Plugins mit Apache APISIX validiert.

Ratenbegrenzungsrichtlinien für serverlose APIs anwenden

In diesem Abschnitt werden wir serverlose APIs vor Missbrauch schützen, indem wir eine Drosselungsrichtlinie anwenden. Im Apache APISIX Gateway können wir Ratenbegrenzungen anwenden, um die Anzahl der eingehenden Aufrufe zu beschränken.

Ratenbegrenzungsrichtlinie anwenden und testen

Mit den bestehenden Routenkonfigurationen für die Produkt- und Bewertungsfunktionen können wir eine Ratenbegrenzungsrichtlinie mit dem limit-count-Plugin anwenden, um unsere API vor abnormaler Nutzung zu schützen. Wir werden die Anzahl der API-Aufrufe auf 2 pro 60 Sekunden pro API-Consumer begrenzen.

Um das limit-count-Plugin für die bestehende Produktroute zu aktivieren, müssen wir das Plugin zum Plugins-Attribut in unserer JSON-Routenkonfiguration hinzufügen:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Create a route with Azure function plugin",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        },
        "basic-auth": {},
        "limit-count": {
            "count": 2,
            "time_window": 60,
            "rejected_code": 403,
            "rejected_msg": "Requests are too frequent, please try again later."
        }
    },
    "uri": "/products"
}'

Apache APISIX wird die ersten beiden Anfragen wie gewohnt behandeln. Eine dritte Anfrage in demselben Zeitraum gibt jedoch einen 403 HTTP Forbidden-Code mit unserer benutzerdefinierten Fehlermeldung zurück:

HTTP/1.1 403 Forbidden

{"error_msg":"Requests are too frequent, please try again later."}

Nächste Schritte

In diesem Artikel haben wir Schritt für Schritt gelernt, wie man Java-basierte serverlose APIs mit Azure Functions und dem Apache APISIX Gateway erstellt, um Ihre APIs während ihres gesamten Lebenszyklus zu verwalten, von der Verfügbarmachung der serverlosen APIs als Upstream-Dienste in APISIX bis hin zur ordnungsgemäßen Sicherung und Anwendung von Ratenbegrenzungen, um die Anzahl der Anfragen zu begrenzen. Dies öffnet die Tür zu weiteren Anwendungsfällen der Integration von API-Gateways und serverlosen APIs.

Sie können andere Fähigkeiten des APISIX Gateways erkunden, indem Sie verschiedene integrierte Plugins kombinieren, um Anfragen zu transformieren, die Verfügbarkeit zu überwachen, die Leistung und Nutzung unserer serverlosen APIs zu überwachen, API-Antworten zu cachen und sie weiterzuentwickeln, indem Sie APIs versionieren, was Ihnen hilft, die Entwicklungszeit zu verkürzen, die Skalierbarkeit zu erhöhen und Kosten zu sparen.

Apache APISIX ist eine vollständig Open-Source-API-Gateway-Lösung. Wenn Sie erweiterte API-Management-Funktionen für serverlose APIs benötigen, können Sie API7 Enterprise oder API7 Cloud verwenden, die auf APISIX basieren.

Verwandte Ressourcen

• Azure Functions.

• Serverlose APIs mit Azure Functions erstellen.

• Erstellen einer Java-Funktion in Azure mit Visual Studio Code.

• Apache APISIX auf Microsoft Azure Container Instance ausführen.

Empfohlene Inhalte

• Wie man das richtige API-Gateway auswählt.

• Warum ist Apache APISIX das beste API-Gateway?

• Was sind API-Gateway-Richtlinien?.