One-Click-Setup Manuelle Einrichtung Testen der GraphQL-API

Tutorial: Pipeline-Resolver

Anmerkung

Wir unterstützen jetzt hauptsächlich die APPSYNC_JS-Laufzeit und ihre Dokumentation. Bitte erwägen Sie, die APPSYNC_JS-Laufzeit und ihre Anleitungen hier zu verwenden.

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 Ihrer API und verbinden Sie diese mit einem Pipeline-Resolver. 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 direkt in AWS AppSync komplexere Workflows erstellen. 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:

IAM-Rolle für den Zugriff von AWS AppSync auf die Ressourcen in Ihrem Konto
2 DynamoDB-Tabellen
1 Amazon Cognito-Benutzerpool
2 Amazon Cognito-Benutzerpoolgruppen
3 Amazon Cognito-Benutzerpoolbenutzer
1 AWS AppSync -API

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-Benutzer bei 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 Prozess 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. Die API wird für die Verwendung des Amazon Cognito-Benutzerpools als Authentifizierungstyp konfiguriert. 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-Benutzer bei der AWS AppSync-Konsole anmelden. Speichern Sie die Passwörter, damit Sie während des Tutorials darauf zurückgreifen können.

Erstellen der GraphQL-API

Erstellen Sie die GraphQL-API in AWS AppSync wie folgt:

Öffnen Sie die AWS AppSync -Konsole und wählen Sie Build From Scratch (Neu entwerfen) und Start (Starten) aus.
Legen Sie den Namen der API auf AppSyncTutorial-PicturesViewer fest.
Wählen Sie Erstellen aus.

Die AWS AppSync -Konsole erstellt eine neue GraphQL-API mit einem API-Schlüssel als Authentifizierungsmodus. Sie können in der Konsole den Rest der GraphQL-API einrichten und im weiteren Verlauf dieses Tutorials abfragen.

Konfigurieren der GraphQL-API

Sie müssen die AWS AppSync -API mit dem gerade erstellten Amazon Cognito-Benutzerpool konfigurieren.

Wählen Sie die Registerkarte Settings.
Wählen Sie im Abschnitt Authorization Type (Autorisierungstyp) Amazon Cognito User Pool (Amazon Cognito-Benutzerpool) aus.
Wählen Sie unter Benutzerpool-Konfiguration die Option US-WEST-2 für die Region aus. AWS
Wählen Sie den UserPool Benutzerpool AppSyncTutorial- aus.
Wählen Sie DENY (VERWEIGERN) als Default Action (Standardaktion) aus.
Lassen Sie das AppId Client-Regex-Feld leer.
Wählen Sie Speichern aus.

Die API ist jetzt für die Verwendung des Amazon Cognito-Benutzerpools als Autorisierungstyp eingerichtet.

Konfiguration von Datenquellen für die DynamoDB-Tabellen

Nachdem die DynamoDB-Tabellen erstellt wurden, navigieren Sie in der Konsole zu Ihrer AWS AppSync GraphQL-API 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.

Klicken Sie auf die Registerkarte Data source (Datenquelle).
Wählen Sie New (Neu) aus, um eine neue Datenquelle zu erstellen.
Geben Sie als Namen für die Datenquelle PicturesDynamoDBTable ein.
Wählen Sie als Typ der Datenquelle Amazon DynamoDB table (Amazon DynamoDB-Tabelle) aus.
Wählen Sie US-WEST-2 als Region aus.
Wählen Sie aus der Tabellenliste die AppSyncTutorialDynamoDB-Tabelle -Pictures aus.
Wählen Sie im Abschnitt Eine bestehende Rolle erstellen oder verwenden die Option Bestehende Rolle aus.
Wählen Sie die Rolle aus, die gerade aus der CloudFormation Vorlage erstellt wurde. Wenn Sie das nicht geändert haben ResourceNamePrefix, sollte der Name der Rolle AppSyncTutorial-DynamodbRole lauten.
Wählen Sie Erstellen aus.

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. Prüfen Sie im Schema-Editor in der AWS AppSync -Konsole, ob 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 für die Konfiguration der Standardaktion der API DENY (VERWEIGERN) festgelegt ist, lehnt die API alle Benutzer ab, die kein Mitglied der in der Richtlinie @aws_auth aufgeführten Gruppen sind. Weitere Informationen zum Schutz Ihrer API finden Sie unter Security (Sicherheit). In diesem Fall haben nur Admin-Benutzer Zugriff auf die Felder Mutation.CreatePicture und Mutation.CreateFriendship, 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. Die API bietet folgende Funktionen:

Erstellen eines Bildes über das Feld Mutation.createPicture
Erstellen einer Freundschaft über das Feld Mutation.createFriendship
Abrufen eines Bildes über das Feld Query.getPicture

Mutation.createPicture

Wählen Sie im Schema-Editor in der AWS AppSync -Konsole auf der rechten Seite Attach Resolver (Resolver anhängen) für createPicture(input: CreatePictureInput!): Picture!. Wählen Sie die DynamoDB PicturesDynamoDbTable-Datenquelle aus. 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. Ein Bild wird in der Tabelle Pictures mit einer zufällig generierte UUID als ID des Bildes und unter Verwendung des Cognito-Benutzernamens für den Eigentümer des Bildes gespeichert.

Mutation.createFriendship

Wählen Sie im Schema-Editor in der AWS AppSync -Konsole auf der rechten Seite Attach Resolver (Resolver anhängen) für createFriendship(id: ID!, target: ID!): Boolean. Wählen Sie die DynamoDB FriendsDynamoDbTable-Datenquelle aus. 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, isFriend, prüft, 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“:

Vorher-Zuweisungsvorlage: Bereitet den Kontext und die Eingabeargumente für das Feld vor.
isFriend-Funktion: Prüft, ob der Anforderer der Eigentümer des Bildes ist. Wenn nicht, überprüft es, ob die Benutzer des Anforderers und des Besitzers Freunde sind, indem es eine GetItem DynamoDB-Operation in der Friends-Tabelle ausführt.
getPicturesByOwner-Funktion: Ruft mithilfe einer DynamoDB-Abfrageoperation für den globalen Sekundärindex des Eigentümerindexes Bilder aus der Tabelle Pictures ab.
Nachher-Zuweisungsvorlage: Weist die resultierenden Bilder so zu, dass die DynamoDB-Attribute den erwarteten Feldern des GraphQL-Typs korrekt zugewiesen sind.

Erstellen wir zuerst die Funktionen.

isFriend-Funktion

Wählen Sie die Registerkarte Functions (Funktionen) aus.
Wählen Sie Create Function (Funktion erstellen) aus, um eine Funktion zu erstellen.
Geben Sie als Namen für die Datenquelle FriendsDynamoDBTable ein.
Geben Sie für den Namen der Funktion isFriend ein.

Fügen Sie die folgende Vorlage in den Textbereich der Zuweisungsvorlage für Anforderungen ein:


#set($ownerId = $ctx.prev.result.owner)
#set($callerId = $ctx.prev.result.callerId)

## if the owner is the caller, no need to make the check
#if($ownerId == $callerId)
    #return($ctx.prev.result)
#end

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

    "operation" : "GetItem",

    "key" : {
        "userId" : $util.dynamodb.toDynamoDBJson($callerId),
        "friendId" : $util.dynamodb.toDynamoDBJson($ownerId)
    }
}

Fügen Sie die folgende Vorlage in den Textbereich der Zuweisungsvorlage für Antworten ein:


#if($ctx.error)
    $util.error("Unable to retrieve friend mapping message: ${ctx.error.message}", $ctx.error.type)
#end

## if the users aren't friends
#if(!$ctx.result)
    $util.unauthorized()
#end

$util.toJson($ctx.prev.result)

Wählen Sie Create Function.

Ergebnis: Sie haben die Funktion isFriend erstellt.

getPicturesByFunktion „Besitzer“

Wählen Sie die Registerkarte Functions (Funktionen) aus.
Wählen Sie Create Function (Funktion erstellen) aus, um eine Funktion zu erstellen.
Geben Sie als Namen für die Datenquelle PicturesDynamoDBTable ein.
Geben Sie für den Namen der Funktion getPicturesByOwner ein.

Fügen Sie die folgende Vorlage in den Textbereich der Zuweisungsvorlage für Anforderungen ein:


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

    "operation" : "Query",

    "query" : {
        "expression": "#owner = :owner",
        "expressionNames": {
            "#owner" : "owner"
        },
        "expressionValues" : {
            ":owner" : $util.dynamodb.toDynamoDBJson($ctx.prev.result.owner)
        }
    },

    "index": "owner-index"
}

Fügen Sie die folgende Vorlage in den Textbereich der Zuweisungsvorlage für Antworten ein:


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

$util.toJson($ctx.result)

Wählen Sie Create Function.

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 (Resolver anhängen) für Query.getPicturesByOwner(id: ID!): [Picture]. 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 Abschnitt für Funktionen Add A Funktion (Funktion hinzufügen) aus. Wählen Sie dann den Namen der ersten Funktion, isFriend, aus oder geben Sie ihn ein. Fügen Sie die zweite Funktion hinzu, indem Sie den gleichen Vorgang für die Funktion getPicturesByBesitzer ausführen. Stellen Sie sicher, dass die Funktion isFriend zuerst in der Liste erscheint, gefolgt von der Funktion getPicturesByOwner. 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, wollen wir die neu erstellte GraphQL-API testen.

Testen der 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 Queries (Abfragen) aus.

createPicture-Mutation

Wählen Sie in der AWS AppSync -Konsole die Registerkarte Queries (Abfragen) aus.
Wählen Sie Login With User Pools (Anmeldung mit Benutzerpools) aus.
Geben Sie im Modal die Cognito Sample Client ID ein, die vom CloudFormation Stack erstellt wurde (z. B. 37solo6mmhh7k4v63cqdfgdg5d).
Geben Sie den Benutzernamen ein CloudFormation , den Sie als Parameter an den Stack übergeben haben. Der Standardwert lautet nadia.
Verwenden Sie das temporäre Passwort, das an die von Ihnen angegebene E-Mail gesendet wurde, als Parameter für den CloudFormation Stack (z. B. UserPoolUserEmail).
Wählen Sie Login (Anmelden) aus. Sie sollten jetzt sehen, dass die Schaltfläche in Logout nadia umbenannt wurde, oder in einen anderen Benutzernamen, den Sie bei der Erstellung des CloudFormation Stacks gewählt haben (d. h. UserPoolUsername).

Lassen Sie uns nun einige createPicture-Mutationen senden, um die Tabelle mit Bildern 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 in diesem Fall die GetItem IsFriend-Operation nicht ausgeführt wird. Versuchen Sie, die folgende Abfrage auszuführen:


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

Wenn Sie die Protokollierung auf Ihrer API aktiviert haben (im Bereich Settings (Einstellungen)), legen Sie für die Debugging-Stufe ALL fest und führen Sie die gleiche Abfrage erneut, damit Protokolle für die Feldausführung zurückgegeben werden. In den Protokollen können Sie prüfen, ob die Rückgabe der Funktion isFriend zu einem frühen Zeitpunkt während der Phase der Zuweisungsvorlage für Anforderungen erfolgt ist:


{
  "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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Lernprogramm: Aurora Serverless

Anleitung: Delta Sync