Share via

Konfigurieren eines GraphQL-Resolvers

  • Artikel

GILT FÜR: Alle API Management-Ebenen

Konfigurieren des Resolvers zum Abrufen oder Festlegen von Daten für ein GraphQL-Feld in einem Objekttyp, der in einem GraphQL-Schema angegeben ist. Das Schema muss als GraphQL-API in API Management importiert werden.

Derzeit unterstützt API Management Resolver, die auf die folgenden Datenquellen zugreifen können:

Wichtige Hinweise

  • Ein Resolver ist eine Ressource, die eine Richtliniendefinition enthält, die nur aufgerufen wird, wenn ein übereinstimmender Objekttyp und ein entsprechendes Feld im Schema ausgeführt wird.
  • Jeder Resolver löst Daten für ein einzelnes Feld auf. Um Daten für mehrere Felder aufzulösen, konfigurieren Sie jeweils einen separaten Resolver.
  • Resolverbezogene Richtlinien werden nach den Richtlinien inbound und backend in der Richtlinienausführungspipeline ausgewertet. Sie erben keine Richtlinien von anderen Bereichen. Weitere Informationen finden Sie unter Richtlinien in API Management.
  • Sie können API-bezogene Richtlinien für eine GraphQL-API konfigurieren, unabhängig von den resolverbezogenen Richtlinien. Fügen Sie beispielsweise die Richtlinie validate-graphql-request zum Bereich inbound hinzu, damit die Anforderung vor dem Aufruf des Resolvers überprüft wird. Konfigurieren Sie API-bezogene Richtlinien auf der Registerkarte API-Richtlinien für die API.
  • Zur Unterstützung von Schnittstellen- und Union-Typen in GraphQL-Resolvern muss die Back-End-Antwort entweder bereits das Feld __typename enthalten oder mithilfe der set-body-Richtlinie geändert werden, sodass __typename enthalten ist.

Voraussetzungen

Auswählen eines Resolvers

Mit den folgenden Schritten wird ein Resolver mithilfe einer HTTP-basierten Datenquelle erstellt. Die allgemeinen Schritte sind für alle Resolver ähnlich, die eine unterstützte Datenquelle verwenden.

  1. Navigieren Sie im Azure-Portal zu Ihrer API Management-Instanz.

  2. Wählen Sie im linken Menü APIs und dann den Namen Ihrer GraphQL-API.

  3. Überprüfen Sie auf der Registerkarte Schema das Schema für ein Feld in einem Objekttyp, in dem Sie einen Resolver konfigurieren möchten.

    1. Wählen Sie ein Feld aus, und fahren Sie dann mit dem Mauszeiger über den linken Rand.

    2. Wählen Sie + Resolver hinzufügen aus.

      Screenshot, der das Hinzufügen eines Resolvers aus einem Feld im GraphQL-Schema im Portal zeigt.

  4. Gehen Sie auf der Seite Resolver erstellen folgendermaßen vor:

    1. Aktualisieren Sie bei Bedarf die Eigenschaft Name, geben Sie optional eine Beschreibung ein, und bestätigen oder aktualisieren Sie die Auswahl für Typ und Feld.
    2. Wählen Sie die Datenquelle des Resolvers aus. Wählen Sie für dieses Beispiel HTTP API aus.

  5. Aktualisieren Sie im Editor Resolver-Richtlinien die Richtlinie http-data-source mit untergeordneten Elementen für Ihr Szenario.

    1. Aktualisieren Sie das erforderliche Element http-request mit Richtlinien, um den GraphQL-Vorgang in eine HTTP-Anforderung zu transformieren.

    2. Fügen Sie optional ein Element http-response hinzu, und fügen Sie untergeordnete Richtlinien hinzu, um die HTTP-Antwort des Resolvers zu transformieren. Wenn das Element http-response nicht angegeben ist, wird die Antwort als Rohzeichenfolge zurückgegeben.

    3. Klicken Sie auf Erstellen.

      Screenshot des Resolver-Richtlinien-Editors im Portal.

    Der Resolver wird an das Feld angefügt und auf der Registerkarte Resolver angezeigt.

    Screenshot der Resolverliste für die GraphQL-API im Portal.

Verwalten von Resolvern

Auf der Registerkarte Resolver einer GraphQL-API können Sie die Resolver der API auflisten und verwalten.

Screenshot: Verwalten von Resolvern für eine GraphQL-API im Portal

Gehen Sie auf der Registerkarte Resolver folgendermaßen vor:

  • Die Spalte Verknüpft gibt an, ob der Resolver für ein Feld konfiguriert ist, das sich derzeit im GraphQL-Schema befindet. Wenn ein Resolver nicht verknüpft ist, kann er nicht aufgerufen werden.

  • Suchen Sie im Kontextmenü (...) für einen Resolver nach den Befehlen zum Klonen, Bearbeiten oder Löschen eines Resolvers. Klonen Sie einen aufgelisteten Resolver, um schnell einen ähnlichen Resolver zu erstellen, der auf einen anderen Typ und ein anderes Feld ausgerichtet ist.

  • Durch Auswahl von + Erstellen können Sie einen neuen Resolver erstellen.

Bearbeiten und Testen eines Resolvers

Wenn Sie einen einzelnen Resolver bearbeiten, wird die Seite Resolver bearbeiten geöffnet. Sie können Folgendes ausführen:

  • Aktualisieren Sie die Resolverrichtlinie und optional die Datenquelle. Das Ändern der Datenquelle überschreibt die aktuelle Resolverrichtlinie.

  • Ändern Sie den Typ und das Feld, auf den/das der Resolver ausgerichtet ist.

  • Testen und debuggen Sie die Konfiguration des Resolvers. Wählen Sie beim Bearbeiten der Resolverrichtlinie Test ausführen aus, um die Ausgabe der Datenquelle zu überprüfen. Diese können Sie anhand des Schemas validieren. Wenn Fehler auftreten, enthält die Antwort Informationen zur Problembehandlung.

    Screenshot: Bearbeiten eines Resolvers im Portal

GraphQL-Kontext

  • Der Kontext für die Anforderung und Antwort des Resolvers (falls angegeben) unterscheidet sich vom Kontext für die ursprüngliche Gateway-API-Anforderung:
    • context.GraphQL-Eigenschaften werden für die aktuelle Resolverausführung auf die Argumente (Arguments) und das übergeordnete Objekt (Parent) festgelegt.
    • Der Anforderungskontext enthält Argumente, die in der GraphQL-Abfrage als deren Textkörper übergeben werden.
    • Beim Antwortkontext handelt es sich um die Antwort des unabhängigen Aufrufs des Resolvers, nicht um den Kontext für die vollständige Antwort für die Gatewayanforderung. Die context-Variable, die über die Anforderungs- und Antwortpipeline übergeben wird, wird mit dem GraphQL-Kontext erweitert, wenn sie mit einem GraphQL-Resolver verwendet wird.

context.GraphQL.parent

Das context.GraphQL.parent wird auf das übergeordnete Objekt für die aktuelle Auflösungsausführung festgelegt. Betrachten Sie folgendes partielles Schema.

type Comment {
    id: ID!
    owner: string!
    content: string!
}

type Blog {
    id: ID!
    title: string!
    content: string!
    comments: [Comment]!
    comment(id: ID!): Comment
}

type Query {
    getBlog(): [Blog]!
    getBlog(id: ID!): Blog
}

Berücksichtigen Sie auch eine GraphQL-Abfrage für alle Informationen für einen bestimmten Blog:

query {
    getBlog(id: 1) {
        title
        content
        comments {
            id
            owner
            content
        }
    }
}

Wenn Sie einen Resolver für das Feld comments im Typ Blog festlegen, sollten Sie wissen, welche Blog-ID verwendet werden soll. Sie können die ID des Blogs mit context.GraphQL.Parent["id"] abrufen, wie im folgenden Resolver gezeigt:

<http-data-source>
    <http-request>
        <set-method>GET</set-method>
        <set-url>@($"https://data.contoso.com/api/blog/{context.GraphQL.Parent["id"]}")
        </set-url>
    </http-request>
</http-data-source>

context.GraphQL.Arguments

Die Argumente für eine parametrisierte GraphQL-Abfrage werden zu context.GraphQL.Arguments hinzugefügt. Sehen Sie sich beispielsweise die folgenden zwei Abfragen an:

query($id: Int) {
    getComment(id: $id) {
        content
    }
}

query {
    getComment(id: 2) {
        content
    }
}

Diese Abfragen sind zwei Möglichkeiten zum Aufrufen des getComment-Auflösungsgebers. GraphQL sendet die folgende JSON-Nutzlast:

{
    "query": "query($id: Int) { getComment(id: $id) { content } }",
    "variables": { "id": 2 }
}

{
    "query": "query { getComment(id: 2) { content } }"
}

Sie können den Auflösungsgeber wie folgt definieren:

<http-data-source>
    <http-request>
        <set-method>GET</set-method>
        <set-url>@($"https://data.contoso.com/api/comment/{context.GraphQL.Arguments["id"]}")</set-url>
    </http-request>
</http-data-source>

Nächste Schritte

Weitere Resolverbeispiele finden Sie unter: