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
**Anmerkung**
Wir unterstützen jetzt hauptsächlich die APPSYNC\$1JS-Laufzeit und ihre Dokumentation. [Bitte erwägen Sie, die APPSYNC\$1JS-Laufzeit und ihre Anleitungen hier zu verwenden.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)
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:
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml)
Dieser Stack erstellt die folgenden Ressourcen in Ihrem Konto:
+ IAM-Rolle für den Zugriff AWS AppSync auf die Ressourcen in Ihrem Konto
+ 2 DynamoDB-Tabellen
+ 1 Amazon Cognito-Benutzerpool
+ 2 Amazon Cognito-Benutzerpoolgruppen
+ 3 Amazon Cognito-Benutzerpoolbenutzer
+ 1 API AWS AppSync
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. Die API wird für die Verwendung des Amazon Cognito-Benutzerpools als Authentifizierungstyp konfiguriert. Der folgende CloudFormation Stack richtet diese Ressourcen im Konto ein.
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml)
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
Um die GraphQL-API zu erstellen in AWS AppSync:
1. Öffnen Sie die AWS AppSync Konsole und wählen Sie **Build From Scratch** und dann **Start**.
1. Legen Sie den Namen der API auf `AppSyncTutorial-PicturesViewer` fest.
1. Wählen Sie **Erstellen** aus.
Die AWS AppSync Konsole erstellt mithilfe des API-Schlüsselauthentifizierungsmodus eine neue GraphQL-API für Sie. 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 Amazon Cognito Cognito-Benutzerpool konfigurieren, den Sie gerade erstellt haben.
1. Wählen Sie die Registerkarte **Einstellungen**.
1. Wählen Sie im Abschnitt **Authorization Type (Autorisierungstyp)** *Amazon Cognito User Pool (Amazon Cognito-Benutzerpool)* aus.
1. *Wählen Sie unter **Benutzerpool-Konfiguration** die Option **US-WEST-2** für die Region aus.AWS *
1. Wählen Sie den UserPool Benutzerpool **AppSyncTutorial-** aus.
1. Wählen Sie **DENY (VERWEIGERN)** als *Default Action (Standardaktion)* aus.
1. Lassen Sie das **AppId Client-Regex-Feld leer**.
1. Wählen Sie **Speichern**.
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.
1. Klicken Sie auf die Registerkarte **Data source (Datenquelle)**.
1. Wählen Sie **New (Neu)** aus, um eine neue Datenquelle zu erstellen.
1. Geben Sie als Namen für die Datenquelle `PicturesDynamoDBTable` ein.
1. Wählen Sie als Typ der Datenquelle **Amazon DynamoDB table (Amazon DynamoDB-Tabelle)** aus.
1. Wählen Sie **US-WEST-2** als Region aus.
1. Wählen Sie aus der Tabellenliste die **AppSyncTutorialDynamoDB-Tabelle -Pictures** aus.
1. **Wählen **Sie im Abschnitt Eine bestehende Rolle erstellen oder verwenden die Option Bestehende Rolle** aus.**
1. Wählen Sie die Rolle aus, die gerade aus der CloudFormation Vorlage erstellt wurde. Wenn Sie die nicht geändert haben *ResourceNamePrefix*, sollte der Name der Rolle **AppSyncTutorial-Dynamo lauten DBRole**.
1. 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 *ResourceNamePrefix*Parameter 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\$1auth* 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\$1auth* aufgeführten Gruppen sind. Weitere Informationen zum Schutz Ihrer API finden Sie unter [Security (Sicherheit)](security-authz.md#aws-appsync-security). *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** for `createPicture(input: CreatePictureInput!): Picture!` aus. Wählen Sie die DynamoDB-Datenquelle *PicturesDynamoDBTable*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** for aus. `createFriendship(id: ID!, target: ID!): Boolean` Wählen Sie die DynamoDB-Datenquelle **FriendsDynamoDBTable**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 **BatchPutItem**Anforderungsvorlage 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 **AppSyncTutorialFriends**Tabelle.
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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html).
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*“:
1. Vorher-Zuweisungsvorlage: Bereitet den Kontext und die Eingabeargumente für das Feld vor.
1. 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.
1. getPicturesByOwner-Funktion: Ruft mithilfe einer DynamoDB-Abfrageoperation für den globalen Sekundärindex des *Eigentümerindexes* Bilder aus der Tabelle Pictures ab.
1. 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
1. Wählen Sie die Registerkarte **Functions (Funktionen)** aus.
1. Wählen Sie **Create Function (Funktion erstellen)** aus, um eine Funktion zu erstellen.
1. Geben Sie als Namen für die Datenquelle `FriendsDynamoDBTable` ein.
1. Geben Sie für den Namen der Funktion *isFriend* ein.
1. 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)
}
}
```
1. 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)
```
1. Wählen Sie **Create Function**.
Ergebnis: Sie haben die Funktion **isFriend** erstellt.
##### getPicturesByFunktion „Besitzer“
1. Wählen Sie die Registerkarte **Functions (Funktionen)** aus.
1. Wählen Sie **Create Function (Funktion erstellen)** aus, um eine Funktion zu erstellen.
1. Geben Sie als Namen für die Datenquelle `PicturesDynamoDBTable` ein.
1. Geben Sie für den Namen der Funktion `getPicturesByOwner` ein.
1. 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"
}
```
1. 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)
```
1. 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** 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 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 **getPicturesByOwner ausführen**. Stellen Sie sicher, dass die Funktion **IsFriend** 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, 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 **Abfragen** aus.
### createPicture-Mutation
1. Wählen Sie in der AWS AppSync Konsole die Registerkarte **Abfragen** aus.
1. Wählen Sie **Login With User Pools (Anmeldung mit Benutzerpools)** aus.
1. Geben Sie im Modal die Cognito Sample Client ID ein, die vom CloudFormation Stack erstellt wurde (z. B. 37solo6mmhh7k4v63cqdfgdg5d).
1. Geben Sie den Benutzernamen ein CloudFormation , den Sie als Parameter an den Stack übergeben haben. Der Standardwert lautet **nadia**.
1. 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*).
1. 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 *earlyReturnedValue*Schlüssel stellt die Daten dar, die von der *\$1return* -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.