Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verwendung von Pipeline-Resolvern in AWS AppSync

AWS AppSync bietet eine einfache Möglichkeit, ein GraphQL-Feld über Unit-Resolver mit einer einzelnen Datenquelle zu verbinden. Eine einzige Operation auszuführen, reicht jedoch möglicherweise nicht aus. Pipeline-Resolver bieten die Möglichkeit einer seriellen Ausführung von Operationen auf Datenquellen. Erstellen Sie Funktionen in Ihrem API und fügen Sie sie einem Pipeline-Resolver hinzu. Jedes Ergebnis einer Funktionsausführung wird an die nächste Funktion weitergeleitet, bis keine weitere Funktion mehr auszuführen ist. Mit Pipeline-Resolvern können Sie jetzt komplexere Workflows direkt darin erstellen. AWS AppSync In diesem Tutorial erstellen Sie eine einfache App für die Anzeige von Bildern, in der Benutzer Bilder veröffentlichen und von ihren Freunden veröffentlichte Bilder anzeigen können.

One-Click-Setup

Wenn Sie den GraphQL-Endpunkt automatisch AWS AppSync mit allen konfigurierten Resolvern und den erforderlichen AWS Ressourcen einrichten möchten, können Sie die folgende AWS CloudFormation Vorlage verwenden:

Dieser Stack erstellt die folgenden Ressourcen in Ihrem Konto:

Am Ende des AWS CloudFormation Stack-Erstellungsprozesses erhalten Sie eine E-Mail für jeden der drei Amazon Cognito Cognito-Benutzer, die erstellt wurden. Jede E-Mail enthält ein temporäres Passwort, mit dem Sie sich als Amazon Cognito Cognito-Benutzer an der AWS AppSync Konsole anmelden. Speichern Sie die Passwörter, damit Sie während des Tutorials darauf zurückgreifen können.

Manuelle Einrichtung

Wenn Sie es vorziehen, einen step-by-step Vorgang manuell über die AWS AppSync Konsole durchzuführen, folgen Sie dem unten stehenden Einrichtungsprozess.

Richten Sie Ihre AWS AppSync Nicht-Ressourcen ein

Die API kommuniziert mit zwei DynamoDB-Tabellen: einer Bildertabelle, in der Bilder gespeichert werden, und einer Freundes-Tabelle, in der Beziehungen zwischen Benutzern gespeichert werden. Der API ist so konfiguriert, dass er den Amazon Cognito Cognito-Benutzerpool als Authentifizierungstyp verwendet. Der folgende AWS CloudFormation Stack richtet diese Ressourcen im Konto ein.

Am Ende des AWS CloudFormation Stack-Erstellungsprozesses erhalten Sie eine E-Mail für jeden der drei Amazon Cognito Cognito-Benutzer, die erstellt wurden. Jede E-Mail enthält ein temporäres Passwort, mit dem Sie sich als Amazon Cognito Cognito-Benutzer an der AWS AppSync Konsole anmelden. Speichern Sie die Passwörter, damit Sie während des Tutorials darauf zurückgreifen können.

Erstellen Sie Ihr GraphQL API

Um GraphQL zu erstellen API in AWS AppSync:

Die AWS AppSync Konsole erstellt im API Schlüsselauthentifizierungsmodus ein neues GraphQL API für Sie. Sie können die Konsole verwenden, um den Rest von GraphQL einzurichten API und für den Rest dieses Tutorials Abfragen darauf auszuführen.

Konfiguration von GraphQL API

Sie müssen den AWS AppSync API mit dem Amazon Cognito Cognito-Benutzerpool konfigurieren, den Sie gerade erstellt haben.

Der API ist jetzt so eingerichtet, dass er den Amazon Cognito Cognito-Benutzerpool als Autorisierungstyp verwendet.

Konfiguration von Datenquellen für die DynamoDB-Tabellen

Nachdem die DynamoDB-Tabellen erstellt wurden, navigieren Sie API in der Konsole zu Ihrem AWS AppSync GraphQL und wählen Sie die Registerkarte Datenquellen. Jetzt erstellen Sie eine Datenquelle AWS AppSync für jede der DynamoDB-Tabellen, die Sie gerade erstellt haben.

Wiederholen Sie den Vorgang für die Friends-Tabelle. Der Name der DynamoDB-Tabelle sollte AppSyncTutorial-Friends lauten, wenn Sie den ResourceNamePrefixParameter bei der Erstellung des Stacks nicht geändert haben. CloudFormation

Erstellen des GraphQL-Schemas

Nachdem die Datenquellen nun mit Ihren DynamoDB-Tabellen verbunden sind, erstellen wir ein GraphQL-Schema. Stellen Sie im Schema-Editor in der AWS AppSync Konsole sicher, dass Ihr Schema dem folgenden Schema entspricht:

schema {
    query: Query
    mutation: Mutation
}

type Mutation {
    createPicture(input: CreatePictureInput!): Picture!
    @aws_auth(cognito_groups: ["Admins"])
    createFriendship(id: ID!, target: ID!): Boolean
    @aws_auth(cognito_groups: ["Admins"])
}

type Query {
    getPicturesByOwner(id: ID!): [Picture]
    @aws_auth(cognito_groups: ["Admins", "Viewers"])
}

type Picture {
    id: ID!
    owner: ID!
    src: String
}

input CreatePictureInput {
    owner: ID!
    src: String!
}

Klicken Sie auf Save Schema (Schema speichern), um Ihr Schema zu speichern.

Einige Schemafelder wurden mit der Richtlinie @aws_auth kommentiert. Da die API Standardaktionskonfiguration auf gesetzt ist DENY, API lehnt der alle Benutzer ab, die nicht Mitglied der in der @aws_auth -Direktive genannten Gruppen sind. Weitere Informationen darüber, wie Sie Ihre sichern könnenAPI, finden Sie auf der Seite Sicherheit. In diesem Fall haben nur Admin-Benutzer Zugriff auf die Mutation. createPictureund Mutation. createFriendshipFelder, während Benutzer, die entweder Mitglieder der Admins - oder Viewers-Gruppen sind, auf die Query zugreifen können. getPicturesByFeld „Besitzer“. Alle anderen Benutzer haben keinen Zugriff.

Konfigurieren von Resolvern

Nachdem Sie jetzt ein gültiges GraphQL-Schema und zwei Datenquellen besitzen, können Sie Resolver mit den GraphQL-Feldern auf dem Schema verbinden. Das API bietet die folgenden Funktionen:

Mutation. createPicture

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite Attach Resolver for createPicture(input: CreatePictureInput!): Picture! aus. Wählen Sie die DynamoDB-Datenquelle PicturesDynamoDBTableaus. Fügen Sie die folgende Vorlage im Abschnitt request mapping template (Zuweisungsvorlage für Anforderungen) ein:

#set($id = $util.autoId())

{
    "version" : "2018-05-29",

    "operation" : "PutItem",

    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($id),
        "owner": $util.dynamodb.toDynamoDBJson($ctx.args.input.owner)
    },

    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args.input)
}

Fügen Sie die folgende Vorlage im Abschnitt response mapping template (Zuweisungsvorlage für Antworten) ein:

#if($ctx.error)
    $util.error($ctx.error.message, $ctx.error.type)
#end
$util.toJson($ctx.result)

Die Funktion zum Erstellen eines Bildes ist fertig. Sie speichern ein Bild in der Tabelle Bilder, verwenden eine zufällig generierte UUID ID des Bilds und verwenden den Cognito-Benutzernamen als Eigentümer des Bilds.

Mutation. createFriendship

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite Attach Resolver for createFriendship(id: ID!, target: ID!): Boolean aus. Wählen Sie die DynamoDB-Datenquelle FriendsDynamoDBTableaus. Fügen Sie die folgende Vorlage im Abschnitt request mapping template (Zuweisungsvorlage für Anforderungen) ein:

#set($userToFriendFriendship = { "userId" : "$ctx.args.id", "friendId": "$ctx.args.target" })
#set($friendToUserFriendship = { "userId" : "$ctx.args.target", "friendId": "$ctx.args.id" })
#set($friendsItems = [$util.dynamodb.toMapValues($userToFriendFriendship), $util.dynamodb.toMapValues($friendToUserFriendship)])

{
    "version" : "2018-05-29",
    "operation" : "BatchPutItem",
    "tables" : {
        ## Replace 'AppSyncTutorial-' default below with the ResourceNamePrefix you provided in the CloudFormation template
        "AppSyncTutorial-Friends": $util.toJson($friendsItems)
    }
}

Wichtig: In der BatchPutItemAnforderungsvorlage sollte der genaue Name der DynamoDB-Tabelle vorhanden sein. Der Standardtabellenname ist AppSyncTutorial -Friends. Wenn Sie den falschen Tabellennamen verwenden, erhalten Sie eine Fehlermeldung, wenn Sie AppSync versuchen, die angegebene Rolle anzunehmen.

Gehen Sie in diesem Tutorial der Einfachheit halber so vor, als ob die Freundschaftsanfrage genehmigt worden wäre, und speichern Sie den Beziehungseintrag direkt in der AppSyncTutorialFriendsTabelle.

Da die Beziehung bidirektional ist, werden für jede Freundschaft faktisch zwei Elemente gespeichert. Weitere Informationen zu den bewährten Methoden von Amazon DynamoDB zur Darstellung von many-to-many Beziehungen finden Sie unter Bewährte Methoden für DynamoDB.

Fügen Sie die folgende Vorlage im Abschnitt response mapping template (Zuweisungsvorlage für Antworten) ein:

#if($ctx.error)
    $util.error($ctx.error.message, $ctx.error.type)
#end
true

Hinweis: Stellen Sie sicher, dass Ihre Anforderungsvorlage den richtigen Tabellennamen enthält. Der Standardname ist AppSyncTutorial-Friends, aber Ihr Tabellenname könnte abweichen, wenn Sie den Parameter ändern. CloudFormation ResourceNamePrefix

Abfrage. getPicturesByBesitzer

Nachdem Sie jetzt Freundschaften und Bilder besitzen, müssen Sie Benutzern die Möglichkeit bieten, die Bilder ihrer Freunde anzuzeigen. Um diese Anforderung zu erfüllen, müssen Sie zuerst prüfen, ob der Anforderer mit dem Eigentümer befreundet ist und anschließend die Bilder abrufen.

Da für diese Funktionalität zwei Datenquellenoperationen erforderlich sind, müssen Sie zwei Funktionen erstellen. Die erste Funktion prüft isFriend, ob der Anforderer und der Eigentümer Freunde sind. Die zweite Funktion, getPicturesByBesitzer, ruft die angeforderten Bilder mit einer Besitzer-ID ab. Schauen wir uns unten den Ausführungsablauf für den vorgeschlagenen Resolver in der Abfrage an. getPicturesByFeld „Besitzer“:

Erstellen wir zuerst die Funktionen.

isFriend Funktion

Ergebnis: Sie haben die isFriendFunktion erstellt.

getPicturesByFunktion „Besitzer“

Ergebnis: Sie haben die Funktion getPicturesByBesitzer erstellt. Nachdem die Funktionen erstellt wurden, fügen Sie der Abfrage einen Pipeline-Resolver hinzu. getPicturesByFeld „Besitzer“.

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite Attach Resolver for Query.getPicturesByOwner(id: ID!): [Picture] aus. Klicken Sie auf der folgenden Seite auf den Link Convert to pipeline resolver (In Pipeline-Resolver konvertieren), der unter der Dropdown-Liste der Datenquellen angezeigt wird. Verwenden Sie Folgendes für die Zuweisungsvorlage für Antworten:

#set($result = { "owner": $ctx.args.id, "callerId": $ctx.identity.username })
$util.toJson($result)

Verwenden Sie Folgendes für die Nachher-Zuweisungsvorlage:

#foreach($picture in $ctx.result.items)
    ## prepend "src://" to picture.src property
    #set($picture['src'] = "src://${picture['src']}")
#end
$util.toJson($ctx.result.items)

Wählen Sie Create Resolver (Resolver erstellen) aus. Sie haben erfolgreich Ihren ersten Pipeline-Resolver angefügt. Fügen Sie auf derselben Seite die beiden zuvor erstellten Funktionen hinzu. Wählen Sie im Bereich Funktionen die Option Funktion hinzufügen und wählen Sie dann den Namen der ersten Funktion aus oder geben Sie ihn ein. isFriend Fügen Sie die zweite Funktion hinzu, indem Sie den gleichen Vorgang für die Funktion getPicturesByBesitzer ausführen. Stellen Sie sicher, dass die isFriendFunktion zuerst in der Liste erscheint, gefolgt von der Funktion getPicturesByBesitzer. Mit den Pfeilen nach oben und unten können Sie die Ausführungsreihenfolge der Funktionen in der Pipeline verändern.

Nachdem der Pipeline-Resolver erstellt wurde und Sie die Funktionen angehängt haben, testen wir das neu erstellte API GraphQL.

Testen Sie Ihr GraphQL API

Zuerst müssen Sie Bilder und Freundschaften auffüllen, indem Sie mit dem erstellten Admin-Benutzer ein paar Mutationen ausführen. Wählen Sie auf der linken Seite der AWS AppSync Konsole die Registerkarte Abfragen aus.

createPicture Mutation

Lassen Sie uns ein paar createPictureMutationen senden, um die Bildertabelle zu füllen. Führen Sie die folgende GraphQL-Abfrage in der Konsole aus:

mutation {
  createPicture(input:{
    owner: "nadia"
    src: "nadia.jpg"
  }) {
    id
    owner
    src
  }
}

Die Antwort sollte wie folgt aussehen:

{
  "data": {
    "createPicture": {
      "id": "c6fedbbe-57ad-4da3-860a-ffe8d039882a",
      "owner": "nadia",
      "src": "nadia.jpg"
    }
  }
}

Lassen Sie uns noch einige weitere Bilder hinzufügen:

mutation {
  createPicture(input:{
    owner: "shaggy"
    src: "shaggy.jpg"
  }) {
    id
    owner
    src
  }
}

mutation {
  createPicture(input:{
    owner: "rex"
    src: "rex.jpg"
  }) {
    id
    owner
    src
  }
}

Sie haben mit nadia als Admin-Benutzer drei Bilder hinzugefügt.

createFriendship Mutation

Lassen Sie uns einen Freundschaftseintrag hinzufügen. Führen Sie die folgenden Mutationen in der Konsole aus.

Hinweis: Sie müssen weiterhin als Admin-Benutzer angemeldet sein (der standardmäßige Admin-Benutzer ist nadia).

mutation {
  createFriendship(id: "nadia", target: "shaggy")
}

Die Antwort sollte wie folgt aussehen:

{
  "data": {
    "createFriendship": true
  }
}

nadia und shaggy sind Freunde. rex ist mit niemandem befreundet.

getPicturesByBesitzer-Anfrage

Melden Sie sich für diesen Schritt mithilfe von Cognito-Benutzerpools als Benutzer nadia an, indem Sie die zu Beginn dieses Tutorials eingerichteten Anmeldeinformationen verwenden. Rufen Sie als nadia die Bilder im Besitz von shaggy ab.

query {
    getPicturesByOwner(id: "shaggy") {
        id
        owner
        src
    }
}

Da nadia und shaggy Freunde sind, gibt die Abfrage das entsprechende Bild zurück.

{
  "data": {
    "getPicturesByOwner": [
      {
        "id": "05a16fba-cc29-41ee-a8d5-4e791f4f1079",
        "owner": "shaggy",
        "src": "src://shaggy.jpg"
      }
    ]
  }
}

nadia kann auch ihre eigenen Bilder erfolgreich abrufen. Der Pipeline-Resolver wurde so optimiert, dass der isFriend GetItem Vorgang in diesem Fall nicht ausgeführt werden muss. Versuchen Sie, die folgende Abfrage auszuführen:

query {
    getPicturesByOwner(id: "nadia") {
        id
        owner
        src
    }
}

Wenn Sie die Protokollierung auf Ihrem aktivieren API (im Bereich Einstellungen), die Debug-Stufe auf ALLfestlegen und dieselbe Abfrage erneut ausführen, werden Protokolle für die Feldausführung zurückgegeben. Anhand der Protokolle können Sie feststellen, ob die isFriendFunktion zu einem früheren Zeitpunkt in der Phase der Vorlage für die Anforderungszuweisung zurückgegeben wurde:

{
  "errors": [],
  "mappingTemplateType": "Request Mapping",
  "path": "[getPicturesByOwner]",
  "resolverArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/types/Query/fields/getPicturesByOwner",
  "functionArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/functions/o2f42p2jrfdl3dw7s6xub2csdfs",
  "functionName": "isFriend",
  "earlyReturnedValue": {
    "owner": "nadia",
    "callerId": "nadia"
  },
  "context": {
    "arguments": {
      "id": "nadia"
    },
    "prev": {
      "result": {
        "owner": "nadia",
        "callerId": "nadia"
      }
    },
    "stash": {},
    "outErrors": []
  },
  "fieldInError": false
}

Der earlyReturnedValueSchlüssel stellt die Daten dar, die von der #return -Direktive zurückgegeben wurden.

Schließlich wird Rex, obwohl er Mitglied der Viewers Cognito UserPool Group ist und weil Rex mit niemandem befreundet ist, auf keines der Bilder zugreifen können, die Shaggy oder Nadia gehören. Wenn Sie sich als rex in der Konsole anmelden und die folgende Abfrage ausführen:

query {
    getPicturesByOwner(id: "nadia") {
        id
        owner
        src
    }
}

Sie erhalten folgenden Fehler wegen fehlender Autorisierung:

{
  "data": {
    "getPicturesByOwner": null
  },
  "errors": [
    {
      "path": [
        "getPicturesByOwner"
      ],
      "data": null,
      "errorType": "Unauthorized",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 9,
          "sourceName": null
        }
      ],
      "message": "Not Authorized to access getPicturesByOwner on type Query"
    }
  ]
}

Sie haben erfolgreich eine komplexe Autorisierung mit Pipeline-Resolvern implementiert.