Effizientes Management Ihrer GraphQL API mit API Gateway

Bobur Umurzokov

Bobur Umurzokov

March 21, 2023

Technology

GraphQL ist eine leistungsstarke Abfragesprache für APIs, die es Entwicklern ermöglicht, die Struktur der Daten zu definieren, die sie vom Server benötigen, und der Server antwortet nur mit diesen Daten. Dies macht es viel effizienter und flexibler als traditionelle REST APIs, die oft mehrere Anfragen benötigen, um dieselben Daten abzurufen. Die Verwaltung von GraphQL-APIs kann jedoch komplex und zeitaufwendig sein, insbesondere in großem Maßstab. Hier kommt ein API Gateway ins Spiel.

Eine der Schlüsselfunktionen moderner API-Gateways wie Apache APISIX ist die Unterstützung für GraphQL-APIs. APISIX macht es einfach, GraphQL-APIs mit seinem flexiblen Konfigurationssystem und leistungsstarken Plugins zu verwalten und zu skalieren. Ein solches Plugin ist das degrapghql-Plugin, das es uns ermöglicht, die GraphQL-API in eine REST-API umzuwandeln. In diesem Beitrag werden wir diese Funktion anhand eines Beispiels erkunden.

Lernziele

Im Laufe des Artikels werden Sie Antworten auf die folgenden Fragen finden und lernen:

  • Was ist das DeGraphQL-Plugin?
  • Was sind die Anwendungsfälle und Funktionen des DeGraphQL-Plugins?
  • Wie verwendet man das DeGraphQL-Plugin?
  • Wie transformiert man REST in GraphQL?
  • Wie verwaltet man den GraphQL-API-Datenverkehr?

Verwalten Sie Ihre GraphQL-API mit einem API-Gateway

Warum das DeGraphQL-Plugin verwenden?

Dieses Plugin ist in der Lage, APIs, die von einem GraphQL-Upstream (Backend-Dienst) bereitgestellt werden, in einen traditionellen REST-Endpunkt zu transformieren, indem URIs in GraphQL-Abfragen abgebildet werden. Der Aufruf von REST-APIs von einem typischen Client aus eröffnet die Vorteile von GraphQL für mehr Menschen. Betrachten Sie die folgenden Anwendungsfälle:

Anwendungsfall 1: Ihre bestehenden Kunden sind es gewohnt, REST-APIs zu nutzen, und sind nicht allzu vertraut damit, wie man GraphQL-Abfragen schreibt. Um es für sie einfach zu halten, können Sie das Apache APISIX API Gateway verwenden, um die GraphQL-API in eine REST-API umzuwandeln.

Anwendungsfall 2: Sie sind in einem Frontend-Entwicklungsteam, das die bestehenden GraphQL-API-Funktionen ausprobieren möchte, ohne das Backend-Team zu bitten, einen neuen GraphQL-Server zu implementieren.

Anwendungsfall 3: Sie haben keinen Zugriff auf das Backend, da es sich um eine bestehende Sammlung von GraphQL-APIs handelt, die möglicherweise von einem Drittanbieter verwaltet werden.

Anwendungsfall 4: Sie haben eine bestehende REST-API-Infrastruktur, möchten aber evaluieren, ob GraphQL für Ihre Anforderungen geeignet ist.

Anwendungsfall 5: Sie haben eine große Codebasis, und die Migration zu GraphQL findet im Backend statt, aber Sie möchten GraphQL jetzt verwenden, ohne zu warten.

Anwendungsfall 6: Sie haben mehrere Microservices, die beide Ansätze kombinieren. Sie möchten eine reibungslose Kommunikation zwischen ihnen ermöglichen.

Was sind die Funktionen des DeGraphQL-Plugins?

Das DeGraphQL-Plugin bietet eine Reihe nützlicher Funktionen, die es einfach machen, Ihre GraphQL-API zu konfigurieren und zu verwalten, darunter:

Anfragevalidierung: Es kann eingehende GraphQL-Anfragen validieren, um sicherzustellen, dass sie bestimmte Kriterien erfüllen. Dies kann die Überprüfung der Struktur der Abfrage, die Durchsetzung von Eingabetypbeschränkungen und mehr umfassen. Durch die Validierung von Anfragen können Sie sicherstellen, dass Ihre API immer gültige und wohlgeformte Anfragen erhält.

Abfrageparsing: Es kann auch GraphQL-Abfragen parsen, sodass Sie spezifische Informationen aus der Abfrage extrahieren und diese nutzen können, um das Verhalten Ihrer API zu beeinflussen. Dies kann die Auswahl des geeigneten Backend-Dienstes basierend auf den angeforderten Daten oder die Modifikation der Antwort basierend auf bestimmten Abfrageparametern umfassen.

Antworttransformation: Schließlich kann es GraphQL-Antworten transformieren, bevor sie an den Client zurückgegeben werden. Dies kann nützlich sein, um Datenstrukturen zu normalisieren, sensible Informationen zu entfernen oder zusätzliche Daten zur Antwort hinzuzufügen.

Mit dieser Fähigkeit macht Apache APISIX nicht nur die gemeinsame Nutzung von REST und GraphQL einfach, sondern Sie können auch Ratenlimits definieren, Authentifizierung und Autorisierung durchsetzen, Clients blockieren, die versuchen, eine API zu missbrauchen, und sicherstellen, dass APIs nahtlos funktionieren, während sie mit Hilfe anderer integrierter Plugins aktualisiert werden.

Wie verwendet man das DeGraphQL-Plugin (Demo)

Mit genügend theoretischem Wissen im Hinterkopf können wir nun in eine praktische Demo des DeGraphQL-Plugins springen. DeGraphQL benötigt einen GraphQL-Endpunkt, um Abfragen durchzuführen. Als Beispiel verwenden wir eine der kostenlosen öffentlichen GraphQL-APIs, die Informationen über Länder, Kontinente und Sprachen abruft: https://countries.trevorblades.com/.

Wenn Sie den obigen Link zur Countries API aufrufen, öffnet sich ein Playground, in dem Sie einige Abfragen gegen die GraphQL-API auf der Benutzeroberfläche schreiben können.

Abfragen der GraphQL-API

Sie können auch Ihre eigene GraphQL-API mit StepZen oder ApollographQL erstellen, die Ihnen helfen, Ihre eigene GraphQL-API zu erstellen und bereitzustellen, indem Sie vorgefertigte APIs wie Accuweather, Airtable, GitHub, Twitter, Trello und mehr kombinieren. Zum Beispiel können Sie zwei Accuweather- und Countries-APIs kombinieren, um die Wetterinformationen eines Landes/Stadtnamens zu sammeln und APISIX voranzustellen, um die API über REST abzufragen.

Unsere Aufgabe besteht nun darin, die obige Abfragedefinition in einen einfachen REST-Aufruf umzuwandeln und sie als JSON-Daten zu senden. Als Ergebnis sollte das Apache APISIX API Gateway den REST-Endpunkt verfügbar machen und in der Lage sein, alle Anfragen an die GraphQL-API weiterzuleiten.

Zum Beispiel sollten alle REST-Anfragen an den API-Gateway-URI-Pfad /country-info mit einer zugrunde liegenden Abfrage nach einem Ländercode in die GraphQL-Countries-API https://countries.trevorblades.com/graphql umgewandelt und weitergeleitet werden.

Ein Beispiel für einen curl-Befehl könnte so aussehen:

curl -i http://127.0.0.1:9080/country-info  -X POST -d \
'{
   "code": "EE"
}'

Und wir sollten eine Antwort von der API wie folgt erhalten:

{
  "data": {
    "country": {
      "code": "EE",
      "capital": "Tallinn",
      "currency": "EUR",
      "languages": [
        {
          "name": "Estonian"
        }
      ]
    }
  }
}

In den nächsten Abschnitten werden wir Schritt für Schritt lernen, wie dies erreicht wird.

Lassen Sie uns Apache APISIX zum Laufen bringen

Bevor Sie das degrapghql-Plugin verwenden können, müssen Sie Apache APISIX installieren. Sie können den Installationsanleitungen auf der Apache APISIX-Website folgen, um loszulegen.

Voraussetzungen

  • Docker wird verwendet, um den containerisierten etcd und APISIX zu installieren.
  • curl wird verwendet, um Anfragen an APISIX zur Validierung zu senden. Sie können auch einfache Tools wie Postman verwenden, um mit der API zu interagieren.

APISIX kann einfach mit dem folgenden Quickstart-Skript installiert und gestartet werden:

curl -sL https://run.api7.ai/apisix/quickstart | sh

Dadurch werden zwei Docker-Container erstellt – ein etcd zur Speicherung der Konfiguration und das APISIX-Gateway selbst. Sobald Sie die Nachricht „✔ APISIX is ready!“ sehen, können wir einen Upstream, ein Plugin und eine Route über die Admin API von APISIX konfigurieren, die Anfragen an die GraphQL-API weiterleitet.

Erstellen eines Upstreams

Als Nächstes erstellen wir ein Upstream-Objekt, um unsere Countries GraphQL API im API-Gateway zu registrieren:

curl "http://127.0.0.1:9180/apisix/admin/upstreams/1" -X PUT -d '
{
  "name": "GraphQL API upstream",
  "desc": "Register Countries GraphQL API as the upstream",
  "type": "roundrobin",
  "scheme": "https",
  "nodes": {
    "countries.trevorblades.com": 1
  }
}'

Erstellen einer Plugin-Konfiguration

Als Nächstes richten wir ein neues Plugin-Konfigurationsobjekt ein. Wir werden zwei Transformations-Plugins verwenden: proxy-rewrite und degraphql, um den Host und den URI der Anfrage umzuschreiben und eine Abfrage an die GraphQL-API zu stellen.

curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -X PUT -d '
{
   "plugins":{
      "proxy-rewrite":{
         "uri":"/graphql",
         "host":"countries.trevorblades.com"
      },
      "degraphql":{
         "query":"query Country($code: ID!) {
                country(code: $code) {
                    code
                    capital
                    currency
                    languages {
                        name
                    }
                }  
          }",
         "variables":[
            "code"
         ]
      }
   }
}'

In der obigen DeGraphQL-Plugin-Konfiguration haben wir zwei Attribute wie query und variables festgelegt. GraphQL-Abfragevariablen können im POST-Anfragekörper oder in URIs in einem REST-Aufruf definiert werden.

Die Abfrage, die wir in diesem Fall ausführen, sieht wie folgt aus, und Sie können sie durch Ihre eigene ersetzen:

query ($code: ID!) {
  country(code: $code) {
    code
    capital
    currency
    languages {
      name
    }
  }
}

Erstellen einer Route mit dem DeGraphQL-Plugin

Dieser Schritt beinhaltet das Einrichten einer neuen Route, die die Plugin-Konfiguration verwendet, und das Konfigurieren der Route, um mit dem Upstream (durch Referenzierung ihrer IDs) zu arbeiten, den wir in den vorherigen Schritten erstellt haben:

curl -i http://127.0.0.1:9180/apisix/admin/routes/1 -X PUT -d '
{
   "name":"GraphQL API route",
   "desc":"Create a new route in APISIX for the Countries GraphQL API",
   "uri":"/country-info",
   "upstream_id":"1",
   "plugin_config_id":1
}'

Testen der DeGraphQL-Plugin-Aktivierung

Lassen Sie uns nun dieses neue Setup mit dem folgenden curl-Befehl testen.

curl -i http://127.0.0.1:9080/country-info  -X POST -d \
'{
   "code": "EE"
}'

Wir erhalten eine Antwort von APISIX:

{
  "data": {
    "country": {
      "code": "EE",
      "capital": "Tallinn",
      "currency": "EUR",
      "languages": [
        {
          "name": "Estonian"
        }
      ]
    }
  }
}

Die gleiche code-Variable kann auch als GET-Argumente bereitgestellt werden:

curl -i http://127.0.0.1:9080/country-info?code=EE

Antworttransformation

Mit Hilfe des response-rewrite-Plugins von Apisix ist es möglich, GraphQL-Antworten zu transformieren, bevor sie an den Client zurückgegeben werden. Lassen Sie uns dieses Plugin verwenden, um den currency-Schlüssel und -Wert aus der JSON-Antwort zu entfernen, um nur alles andere anzuzeigen. Dazu müssen wir das response-rewrite-Plugin zur bestehenden Plugin-Konfiguration hinzufügen.

curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -X PATCH -d '
{
  "plugins":{
   "response-rewrite": {
      "filters":[
        {
          "regex":"(?:\"currency\":\")(.*?)(?:\")",
          "scope":"once",
          "replace":""
        }
      ],
      "vars":[
        [
          "status",
          "==",
          200
        ]
      ]
   }
  }
}'

Nachdem dieses Plugin installiert ist, können Sie erneut eine Anfrage an /country-info stellen und die transformierte Antwort sehen:

{
  "data": {
    "country": {
      "code": "EE",
      "capital": "Tallinn",
      "languages": [
        {
          "name": "Estonian"
        }
      ]
    }
  }
}

Zusammenfassung

Insgesamt ist das DeGraphQL-Plugin ein unverzichtbares Werkzeug für jeden Entwickler, der eine GraphQL-API mit APISIX erstellt. Seine leistungsstarken Funktionen und die benutzerfreundliche Konfiguration machen es einfach, es in Ihr bestehendes API-Gateway zu integrieren, während die Unterstützung für GraphQL-spezifische Funktionalität sicherstellt, dass Ihre API leistungsfähig, zuverlässig und skalierbar ist.

Verwandte Ressourcen

Tags:
API Gateway Concept
GraphQL
Plugin