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.
# Erstellen einer einfachen Post-Anwendung mit DynamoDB-Resolvern
**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)
Dieses Tutorial zeigt, wie Sie Ihre eigenen Amazon DynamoDB-Tabellen mit einer GraphQL-API verbinden können. AWS AppSync
Sie können DynamoDB-Ressourcen in Ihrem Namen AWS AppSync bereitstellen lassen. Alternativ können Sie auch vorhandene Tabellen mit einem GraphQL-Schema verbinden, indem Sie eine Datenquelle und einen Resolver erstellen. In beiden Fällen können Sie Lese- und Schreibvorgänge in Ihrer DynamoDB-Datenbank über GraphQL-Anweisungen ausführen – und Echtzeit-Daten abonnieren.
Es müssen bestimmte Konfigurationsschritte ausgeführt werden, damit GraphQL-Anweisungen in DynamoDB-Operationen und die Antworten wieder in GraphQL übersetzt werden können. In diesem Tutorial wird der Konfigurationsprozess anhand mehrerer Szenarien und Datenzugriffsmuster aus der Praxis veranschaulicht.
## DynamoDB-Tabellen einrichten
Um mit diesem Tutorial zu beginnen, müssen Sie zunächst die folgenden Schritte ausführen, um Ressourcen bereitzustellen AWS .
1. Stellen Sie AWS Ressourcen mithilfe der folgenden AWS CloudFormation Vorlage in der CLI bereit:
```
aws cloudformation create-stack \
--stack-name AWSAppSyncTutorialForAmazonDynamoDB \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml \
--capabilities CAPABILITY_NAMED_IAM
```
Alternativ können Sie den folgenden CloudFormation Stack in der Region US-West 2 (Oregon) in Ihrem AWS Konto starten.
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml)
Dadurch wird Folgendes erstellt:
+ Eine DynamoDB-Tabelle namens`AppSyncTutorial-Post`, die Daten enthalten `Post` wird.
+ Eine IAM-Rolle und die zugehörige, von IAM verwaltete Richtlinie, um die Interaktion mit der Tabelle AWS AppSync zu ermöglichen. `Post`
1. Wenn Sie weitere Informationen zum Stack und den erstellten Ressourcen benötigen, führen Sie den folgenden CLI-Befehl aus:
```
aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```
1. Wenn Sie die Ressourcen später löschen möchten, führen Sie folgenden Befehl aus:
```
aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```
## Erstellen Sie Ihre GraphQL-API
Um die GraphQL-API zu erstellen in AWS AppSync:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSync Konsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** **Create API** aus.
1. Wählen **Sie im Fenster Passen Sie Ihre API an oder importieren Sie aus Amazon DynamoDB** die Option **Von Grund auf neu erstellen**.
1. Wählen Sie rechts neben demselben Fenster **Start** aus.
1. Stellen Sie im Feld **API-Name** den Namen der API auf ein`AWSAppSyncTutorial`.
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.
## Definition einer grundlegenden Post-API
Nachdem Sie eine AWS AppSync GraphQL-API erstellt haben, können Sie ein grundlegendes Schema einrichten, das das grundlegende Erstellen, Abrufen und Löschen von Post-Daten ermöglicht.
1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AppSync Konsole.](https://console.aws.amazon.com/appsync/)
1. Wählen Sie im **APIs Dashboard** die API aus, die Sie gerade erstellt haben.
1. Wählen Sie in der **Seitenleiste** **Schema** aus.
1. Ersetzen Sie im **Schemabereich** den Inhalt durch den folgenden Code:
```
schema {
query: Query
mutation: Mutation
}
type Query {
getPost(id: ID): Post
}
type Mutation {
addPost(
id: ID!
author: String!
title: String!
content: String!
url: String!
): Post!
}
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
}
```
1. Wählen Sie **Speichern**.
Dieses Schema definiert einen `Post`-Typ und Operationen zum Hinzufügen und Abrufen von `Post`-Objekten.
## Konfiguration der Datenquelle für die DynamoDB-Tabellen
Verknüpfen Sie als Nächstes die im Schema definierten Abfragen und Mutationen mit der `AppSyncTutorial-Post` DynamoDB-Tabelle.
Zunächst AWS AppSync müssen Sie sich Ihrer Tabellen bewusst sein. Hierzu richten Sie eine Datenquelle in AWS AppSync ein:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSync Konsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. Wählen Sie in der **Seitenleiste** **Datenquellen** aus.
1. Klicken Sie auf **Create data source**.
1. Geben Sie als **Namen der Datenquelle** in `PostDynamoDBTable` ein.
1. Wählen Sie als **Datenquellentyp** **Amazon DynamoDB-Tabelle** aus.
1. **Wählen Sie für **Region US-WEST-2** aus.**
1. Wählen Sie als **Tabellenname** die DynamoDB-Tabelle **AppSyncTutorial-Post** aus.
1. Erstellen Sie eine neue IAM-Rolle (empfohlen) oder wählen Sie eine vorhandene Rolle aus, die über die IAM-Berechtigung verfügt. `lambda:invokeFunction` Für bestehende Rollen ist eine Vertrauensrichtlinie erforderlich, wie im Abschnitt [Eine Datenquelle anhängen](attaching-a-data-source.md) beschrieben.
Im Folgenden finden Sie ein Beispiel für eine IAM-Richtlinie, die über die erforderlichen Berechtigungen für die Ausführung von Vorgängen auf der Ressource verfügt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:function:myFunction",
"arn:aws:lambda:us-east-1:111122223333:function:myFunction:*"
]
}
]
}
```
------
1. Wählen Sie **Erstellen** aus.
## Den AddPost-Resolver einrichten (DynamoDB) PutItem
**Nachdem AWS AppSync Sie die DynamoDB-Tabelle erkannt haben, können Sie sie mit einzelnen Abfragen und Mutationen verknüpfen, indem Sie Resolver definieren.** Der erste Resolver, den Sie erstellen, ist der `addPost` Resolver, mit dem Sie einen Beitrag in der `AppSyncTutorial-Post` DynamoDB-Tabelle erstellen können.
Resolver bestehen aus folgenden Komponenten:
+ Die Stelle im GraphQL-Schema, an der der Resolver angefügt werden soll. In diesem Fall richten Sie einen Resolver im Feld `addPost` im Typ `Mutation` ein. Diesen Resolver können Sie mit `mutation { addPost(...){...} }` aufrufen.
+ Die Datenquelle für diesen Resolver. In diesem Fall soll die zuvor definierte Datenquelle `PostDynamoDBTable` verwendet werden, damit Sie Einträge in der DynamoDB-Tabelle `AppSyncTutorial-Post` hinzufügen können.
+ Die Zuweisungsvorlage für Anforderungen. Der Zweck der Vorlage für die Anforderungszuweisung besteht darin, die eingehende Anfrage des Aufrufers entgegenzunehmen und sie in Anweisungen zur Ausführung gegen DynamoDB AWS AppSync zu übersetzen.
+ Die Zuweisungsvorlage für Antworten. Eine Zuweisungsvorlage für Antworten übersetzt die Antwort aus DynamoDB zurück in eine Eingabe, die GraphQL erwartet. Dies ist nützlich, wenn sich das Format der Daten in DynamoDB vom `Post`-Typ in GraphQL unterscheidet. In diesem Fall stimmt die Form jedoch überein, daher werden die Daten direkt übergeben.
Richten Sie den Resolver wie folgt ein:
1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole. AppSync ](https://console.aws.amazon.com/appsync/)
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. Wählen Sie in der **Seitenleiste** **Datenquellen** aus.
1. Klicken Sie auf **Create data source**.
1. Geben Sie als **Namen der Datenquelle** in `PostDynamoDBTable` ein.
1. Wählen Sie als **Datenquellentyp** **Amazon DynamoDB-Tabelle** aus.
1. **Wählen Sie für **Region US-WEST-2** aus.**
1. Wählen Sie als **Tabellenname** die DynamoDB-Tabelle **AppSyncTutorial-Post** aus.
1. Erstellen Sie eine neue IAM-Rolle (empfohlen) oder wählen Sie eine vorhandene Rolle aus, die über die IAM-Berechtigung verfügt. `lambda:invokeFunction` Für bestehende Rollen ist eine Vertrauensrichtlinie erforderlich, wie im Abschnitt [Eine Datenquelle anhängen](attaching-a-data-source.md) beschrieben.
Im Folgenden finden Sie ein Beispiel für eine IAM-Richtlinie, die über die erforderlichen Berechtigungen für die Ausführung von Vorgängen auf der Ressource verfügt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-west-2:123456789012:function:myFunction",
"arn:aws:lambda:us-west-2:123456789012:function:myFunction:*"
]
}
]
}
```
------
1. Wählen Sie **Erstellen** aus.
1. Wählen Sie die Registerkarte **Schema** aus.
1. Suchen Sie rechts im Bereich **Data types (Datentypen)** das Feld **addPost** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
1. Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
1. Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
1. Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"attributeValues" : {
"author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
"title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
"content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
"url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
"ups" : { "N" : 1 },
"downs" : { "N" : 0 },
"version" : { "N" : 1 }
}
}
```
**Hinweis:** Für alle Schlüssel und Attributwerte wird ein *Typ* angegeben. So legen Sie beispielsweise das Feld `author` auf `{ "S" : "${context.arguments.author}" }` fest. Der `S` Teil gibt an AWS AppSync und DynamoDB an, dass der Wert ein Zeichenkettenwert sein wird. Der tatsächliche Wert wird aus dem `author`-Argument eingefügt. Das Feld `version` ist ein Zahlenfeld, da als Typ `N` verwendet wird. Schließlich initialisieren Sie auch die Felder `ups`, `downs` und `version`.
Für dieses Tutorial haben Sie angegeben, dass der `ID!` GraphQL-Typ, der das neue Element, das in DynamoDB eingefügt wird, indexiert, Teil der Client-Argumente ist. AWS AppSync enthält ein Hilfsprogramm zur automatischen ID-Generierung namens`$utils.autoId()`, das Sie auch in der Form von hätten verwenden können. `"id" : { "S" : "${$utils.autoId()}" }` Dann würden Sie `id: ID!` nicht in der Schemadefinition von `addPost()` angeben, sondern die ID würde automatisch eingefügt. Sie werden diese Technik in diesem Tutorial nicht verwenden, sollten sie jedoch als bewährte Methode beim Schreiben in DynamoDB-Tabellen betrachten.
Weitere Informationen zu Lambda-Zuweisungsvorlagen finden Sie in der Referenzdokumentation [Übersicht über die Resolver-Zuweisungsvorlage](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview). Weitere Informationen zur GetItem Anforderungszuordnung finden Sie in der [GetItem](aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.md)Referenzdokumentation. Weitere Informationen zu Typen enthält die Referenzdokumentation [Typsystem (Anforderungszuweisung)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md).
1. Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
**Hinweis:** Da das Format der Daten in der Tabelle `AppSyncTutorial-Post` genau mit dem Format des `Post`-Typs in GraphQL übereinstimmt, übergibt die Zuweisungsvorlage für die Antwort die Ergebnisse einfach direkt. Beachten Sie auch, dass in allen Beispielen in diesem Tutorial die gleiche Zuweisungsvorlage für Antworten verwendet wird, sodass Sie nur eine Datei erstellen müssen.
1. Wählen Sie **Speichern**.
### Aufrufen der API zum Hinzufügen eines Posts
Jetzt, da der Resolver eingerichtet ist, AWS AppSync kann er eine eingehende `addPost` Mutation in eine PutItem DynamoDB-Operation übersetzen. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle hinzuzufügen.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein:
```
mutation addPost {
addPost(
id: 123
author: "AUTHORNAME"
title: "Our first post!"
content: "This is our first post."
url: "https://aws.amazon.com/appsync/"
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Die Ergebnisse des neu erstellten Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"addPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
Folgendes wurden ausgeführt:
+ AWS AppSync hat eine Mutationsanfrage erhalten. `addPost`
+ AWS AppSync hat die Anfrage und die Vorlage für die Anforderungszuweisung entgegengenommen und ein Dokument zur Anforderungszuweisung generiert. Dies sieht wie folgt aus:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "123" }
},
"attributeValues" : {
"author": { "S" : "AUTHORNAME" },
"title": { "S" : "Our first post!" },
"content": { "S" : "This is our first post." },
"url": { "S" : "https://aws.amazon.com/appsync/" },
"ups" : { "N" : 1 },
"downs" : { "N" : 0 },
"version" : { "N" : 1 }
}
}
```
+ AWS AppSync hat das Anforderungszuordnungsdokument verwendet, um eine `PutItem` DynamoDB-Anforderung zu generieren und auszuführen.
+ AWS AppSync nahm die Ergebnisse der `PutItem` Anfrage und konvertierte sie wieder in GraphQL-Typen.
```
{
"id" : "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups" : 1,
"downs" : 0,
"version" : 1
}
```
+ Dann wurden sie über das Antwortzuweisungsdokument unverändert weiter übergeben.
+ Das neu erstellte Objekt wurde in der GraphQL-Antwort zurückgegeben.
## Einrichtung des GetPost-Resolvers (DynamoDB) GetItem
Jetzt, da Sie der `AppSyncTutorial-Post` DynamoDB-Tabelle Daten hinzufügen können, müssen Sie die `getPost` Abfrage so einrichten, dass sie diese Daten aus der `AppSyncTutorial-Post` Tabelle abrufen kann. Hierzu richten Sie einen weiteren Resolver ein.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das Feld **getPost** des Typs **Query (Abfrage)** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
}
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
### Aufrufen der API zum Abrufen eines Posts
Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende `getPost` Abfrage in eine `GetItem` DynamoDB-Operation übersetzt. Sie können jetzt eine Abfrage ausführen, um den zuvor erstellten Post abzurufen.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie im Bereich **Abfragen** Folgendes ein:
```
query getPost {
getPost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der von DynamoDB abgerufene Beitrag sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"getPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
Folgendes wurden ausgeführt:
+ AWS AppSync hat eine `getPost` Abfrageanforderung erhalten.
+ AWS AppSync hat die Anfrage und die Vorlage für die Anforderungszuweisung entgegengenommen und ein Dokument zur Anforderungszuweisung generiert. Dies sieht wie folgt aus:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : { "S" : "123" }
}
}
```
+ AWS AppSync hat das Anforderungszuordnungsdokument verwendet, um eine GetItem DynamoDB-Anforderung zu generieren und auszuführen.
+ AWS AppSync nahm die Ergebnisse der `GetItem` Anfrage und konvertierte sie wieder in GraphQL-Typen.
```
{
"id" : "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups" : 1,
"downs" : 0,
"version" : 1
}
```
+ Dann wurden sie über das Antwortzuweisungsdokument unverändert weiter übergeben.
+ Das abgerufene Objekt wurde in der Antwort zurückgegeben.
Nehmen Sie alternativ das folgende Beispiel:
```
query getPost {
getPost(id:123) {
id
author
title
}
}
```
Wenn Ihre `getPost` Abfrage nur das`id`, und benötigt`author`, können Sie Ihre Anforderungszuordnungsvorlage so ändern`title`, dass Projektionsausdrücke verwendet werden, um nur die gewünschten Attribute aus Ihrer DynamoDB-Tabelle anzugeben, um unnötige Datenübertragungen von DynamoDB zu zu zu vermeiden. AWS AppSync Die Vorlage für die Anforderungszuweisung könnte beispielsweise wie der folgende Ausschnitt aussehen:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"projection" : {
"expression" : "#author, id, title",
"expressionNames" : { "#author" : "author"}
}
}
```
## Eine UpdatePost-Mutation erstellen (DynamoDB) UpdateItem
Bisher können Sie `Post` Objekte in DynamoDB erstellen und abrufen. Als Nächstes richten Sie eine neue Mutation ein, um ein Objekt zu aktualisieren. Dazu verwenden Sie die UpdateItem DynamoDB-Operation.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Mutation` Typ, um eine neue `updatePost` Mutation hinzuzufügen, wie folgt:
```
type Mutation {
updatePost(
id: ID!,
author: String!,
title: String!,
content: String!,
url: String!
): Post
addPost(
author: String!
title: String!
content: String!
url: String!
): Post!
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **updatePost** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "SET author = :author, title = :title, content = :content, #url = :url ADD version :one",
"expressionNames": {
"#url" : "url"
},
"expressionValues": {
":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
":content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
":url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
":one" : { "N": 1 }
}
}
}
```
**Hinweis:** Dieser Resolver verwendet DynamoDB UpdateItem, was sich erheblich von der Operation unterscheidet. PutItem Anstatt das gesamte Element zu schreiben, bitten Sie DynamoDB lediglich, bestimmte Attribute zu aktualisieren. Dies erfolgt mithilfe von DynamoDB-Aktualisierungsausdrücken. Der Ausdruck selbst wird im Feld `expression` im Abschnitt `update` angegeben. Er gibt an, dass die Attribute `author`, `title`, `content` und "url" festgelegt werden sollen und dann das Feld `version` inkrementiert werden soll. Die zu verwendenden Werte werden nicht im Ausdruck selbst angegeben. Der Ausdruck enthält Platzhalter, deren Namen mit einem Doppelpunkt beginnen. Diese werden dann im Feld `expressionValues` definiert. Schließlich hat DynamoDB reservierte Wörter, die nicht in der vorkommen dürfen. `expression` `url` ist beispielsweise ein reservierter Begriff. Zum Aktualisieren des Felds `url` können Sie daher Platzhalter für Namen verwenden und sie im Feld `expressionNames` definieren.
Weitere Informationen zur `UpdateItem` Anforderungszuordnung finden Sie in der [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md)Referenzdokumentation. Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der [DynamoDB-Dokumentation UpdateExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html).
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
### Aufrufen der API zum Aktualisieren eines Posts
Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende `update` Mutation in eine `Update` DynamoDB-Operation übersetzt. Sie können jetzt eine Mutation ausführen, um das zuvor geschriebene Element zu aktualisieren.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation updatePost {
updatePost(
id:"123"
author: "A new author"
title: "An updated author!"
content: "Now with updated content!"
url: "https://aws.amazon.com/appsync/"
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der aktualisierte Beitrag in DynamoDB sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"updatePost": {
"id": "123",
"author": "A new author",
"title": "An updated author!",
"content": "Now with updated content!",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 2
}
}
}
```
In diesem Beispiel wurden die `downs` Felder `ups` und nicht geändert, da die Vorlage für die Anforderungszuweisung DynamoDB nicht AWS AppSync aufforderte, irgendetwas mit diesen Feldern zu tun. Außerdem wurde das `version` Feld um 1 erhöht, weil Sie DynamoDB gebeten AWS AppSync haben, dem Feld 1 hinzuzufügen. `version`
## Ändern des UpdatePost-Resolvers (DynamoDB) UpdateItem
Dies war ein erfolgreicher Start für die `updatePost`-Mutation, es gibt aber zwei wesentliche Probleme:
+ Auch wenn nur ein einzelnes Feld aktualisiert werden soll, müssen alle Felder aktualisiert werden.
+ Wenn zwei Benutzer das Objekt ändern, können Informationen verloren gehen.
Um diese Probleme zu beheben, ändern wir die `updatePost`-Mutation so, dass nur Argumente geändert werden, die in der Anforderung angegeben wurden. Dann fügen wir der `UpdateItem`-Operation eine Bedingung hinzu.
1. Wählen Sie die Registerkarte **Schema** aus.
1. Ändern Sie im Bereich **Schema** das Feld `updatePost` im Typ `Mutation`, um die Ausrufungszeichen aus den Argumenten `author`, `title`, `content` und `url` zu entfernen. Achten Sie dabei darauf, das Feld `id` nicht zu ändern. Hierdurch werden die Argumente optional. Fügen Sie außerdem ein neues erforderliches `expectedVersion`-Argument hinzu.
```
type Mutation {
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!
title: String!
content: String!
url: String!
): Post!
}
```
1. Wählen Sie **Speichern**.
1. Suchen Sie im Bereich **Data types (Datentypen)** auf der rechten Seite das Feld **updatePost** des Typs **Mutation**.
1. Wählen Sie, ob der vorhandene Resolver geöffnet **PostDynamoDBTable**werden soll.
1. Ändern Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** folgendermaßen die Anforderungszuweisungsvorlage:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
## Set up some space to keep track of things you're updating **
#set( $expNames = {} )
#set( $expValues = {} )
#set( $expSet = {} )
#set( $expAdd = {} )
#set( $expRemove = [] )
## Increment "version" by 1 **
$!{expAdd.put("version", ":one")}
$!{expValues.put(":one", { "N" : 1 })}
## Iterate through each argument, skipping "id" and "expectedVersion" **
#foreach( $entry in $context.arguments.entrySet() )
#if( $entry.key != "id" && $entry.key != "expectedVersion" )
#if( (!$entry.value) && ("$!{entry.value}" == "") )
## If the argument is set to "null", then remove that attribute from the item in DynamoDB **
#set( $discard = ${expRemove.add("#${entry.key}")} )
$!{expNames.put("#${entry.key}", "$entry.key")}
#else
## Otherwise set (or update) the attribute on the item in DynamoDB **
$!{expSet.put("#${entry.key}", ":${entry.key}")}
$!{expNames.put("#${entry.key}", "$entry.key")}
$!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
#end
#end
#end
## Start building the update expression, starting with attributes you're going to SET **
#set( $expression = "" )
#if( !${expSet.isEmpty()} )
#set( $expression = "SET" )
#foreach( $entry in $expSet.entrySet() )
#set( $expression = "${expression} ${entry.key} = ${entry.value}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Continue building the update expression, adding attributes you're going to ADD **
#if( !${expAdd.isEmpty()} )
#set( $expression = "${expression} ADD" )
#foreach( $entry in $expAdd.entrySet() )
#set( $expression = "${expression} ${entry.key} ${entry.value}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Continue building the update expression, adding attributes you're going to REMOVE **
#if( !${expRemove.isEmpty()} )
#set( $expression = "${expression} REMOVE" )
#foreach( $entry in $expRemove )
#set( $expression = "${expression} ${entry}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
"update" : {
"expression" : "${expression}"
#if( !${expNames.isEmpty()} )
,"expressionNames" : $utils.toJson($expNames)
#end
#if( !${expValues.isEmpty()} )
,"expressionValues" : $utils.toJson($expValues)
#end
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
}
}
}
```
1. Wählen Sie **Speichern**.
Diese Vorlage ist eines der komplexeren Beispiele. Es zeigt die Leistung und Flexibilität der Zuweisungsvorlagen. Es durchläuft alle Argumente und springt dann zu `id` und `expectedVersion`. Wenn das Argument auf etwas gesetzt ist, fordert AWS AppSync es DynamoDB auf, dieses Attribut für das Objekt in DynamoDB zu aktualisieren. Wenn das Attribut auf Null gesetzt ist, fordert AWS AppSync es DynamoDB auf, dieses Attribut aus dem Post-Objekt zu entfernen. Wenn ein Argument nicht angegeben wurde, wird das Attribut nicht geändert. Außerdem wird das Feld `version` inkrementiert.
Außerdem gibt es einen neuen `condition`-Abschnitt. Ein Bedingungsausdruck ermöglicht es Ihnen AWS AppSync , DynamoDB anhand des Status des Objekts, das sich bereits vor der Ausführung des Vorgangs in DynamoDB befand, mitzuteilen, ob die Anforderung erfolgreich sein soll oder nicht. In diesem Fall möchten Sie, dass die `UpdateItem` Anfrage nur erfolgreich ist, wenn das `version` Feld des Elements, das sich derzeit in DynamoDB befindet, genau mit dem `expectedVersion` Argument übereinstimmt.
Weitere Informationen zu Bedingungsausdrücken finden Sie in der [Bedingungsausdrücke](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md)-Referenzdokumentation.
### Aufrufen der API zum Aktualisieren eines Posts
Aktualisieren wir nun unser `Post`-Objekt mit dem neuen Resolver:
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation updatePost {
updatePost(
id:123
title: "An empty story"
content: null
expectedVersion: 2
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der aktualisierte Beitrag in DynamoDB sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"updatePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 3
}
}
}
```
In dieser Anfrage haben Sie DynamoDB gebeten AWS AppSync , nur das `content` Feld `title` und zu aktualisieren. Alle anderen Felder bleiben unverändert (nur das Feld `version` wird inkrementiert). Das `title`-Attribut wurde auf einen neuen Wert festgelegt und das `content`-Attribut wurde aus dem Post entfernt. Die Felder `author`, `url`, `ups` und `downs` blieben unverändert.
Führen Sie die Mutationsanforderung erneut aus und belassen Sie sie dabei unverändert. Es wird eine Antwort ähnlich der folgenden angezeigt:
```
{
"data": {
"updatePost": null
},
"errors": [
{
"path": [
"updatePost"
],
"data": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 3
},
"errorType": "DynamoDB:ConditionalCheckFailedException",
"locations": [
{
"line": 2,
"column": 3
}
],
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
}
]
}
```
Die Anforderung schlägt fehl, weil der Bedingungsausdruck als "false" ausgewertet wird:
+ Als Sie die Anfrage zum ersten Mal ausgeführt haben, war der Wert des `version` Felds des Beitrags in DynamoDB`2`, der `expectedVersion` dem Argument entsprach. Die Anfrage war erfolgreich, was bedeutete, dass das `version` Feld in DynamoDB auf inkrementiert wurde. `3`
+ Als Sie die Anfrage zum zweiten Mal ausgeführt haben, war der Wert des `version` Felds des Beitrags in DynamoDB`3`, der nicht mit dem `expectedVersion` Argument übereinstimmte.
Dieses Muster wird normalerweise als *optimistische Sperre* bezeichnet.
Ein Merkmal eines AWS AppSync DynamoDB-Resolvers besteht darin, dass er den aktuellen Wert des Post-Objekts in DynamoDB zurückgibt. Sie finden dies im Feld `data` im Abschnitt `errors` der GraphQL-Antwort. Ihre Anwendung kann anhand dieser Informationen entscheiden, wie weiter vorgegangen werden soll. In diesem Fall können Sie sehen, dass das `version` Feld des Objekts in DynamoDB auf `3` gesetzt ist. Sie könnten also das `expectedVersion` Argument einfach auf aktualisieren `3` und die Anfrage wäre wieder erfolgreich.
Weitere Informationen zum Behandeln von Fehlern bei Bedingungsprüfungen finden Sie in der Zuweisungsvorlagen-Referenzdokumentation für [Bedingungsausdrücke](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md).
## UpvotePost- und DownvotePost-Mutationen erstellen (DynamoDB) UpdateItem
Der Typ `Post` verfügt über die Felder `ups` und `downs`, mit denen Upvotes und Downvotes erfasst werden können. In der API können sie allerdings derzeit nicht verwendet werden. Fügen Sie daher einige Mutationen hinzu, um Upvotes und Downvotes für die Posts zu ermöglichen.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Mutation` Typ, um neue Mutationen hinzuzufügen, wie folgt: `upvotePost` `downvotePost`
```
type Mutation {
upvotePost(id: ID!): Post
downvotePost(id: ID!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **upvotePost** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "ADD ups :plusOne, version :plusOne",
"expressionValues" : {
":plusOne" : { "N" : 1 }
}
}
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld `downvotePost` des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "ADD downs :plusOne, version :plusOne",
"expressionValues" : {
":plusOne" : { "N" : 1 }
}
}
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
### Aufrufen der API für ein Upvote oder Downvote eines Posts
Jetzt wurden die neuen Resolver eingerichtet, AWS AppSync weiß, wie man eine eingehende Operation `upvotePost` oder eine `downvote` Mutation in eine UpdateItem DynamoDB-Operation übersetzt. Sie können jetzt Mutationen ausführen, um Upvotes oder Downvotes für den zuvor erstellten Post auszuführen.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation votePost {
upvotePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der Beitrag wurde in DynamoDB aktualisiert und sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"upvotePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 0,
"version": 4
}
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** einige weitere Male. Jedes Mal, wenn Sie die Abfrage ausführen, sollten die Felder `ups` und `version` um 1 erhöht werden.
+ Ändern Sie folgendermaßen die Abfrage zum Aufrufen der `downvotePost`-Mutation:
```
mutation votePost {
downvotePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche). Jedes Mal, wenn Sie die Abfrage ausführen, sollten jetzt die Felder `downs` und `version` um 1 erhöht werden.
```
{
"data": {
"downvotePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 4,
"version": 12
}
}
}
```
## Den DeletePost-Resolver einrichten (DynamoDB) DeleteItem
Mit der nächsten Mutation, die Sie einrichten möchten, soll ein Post gelöscht werden. Dazu verwenden Sie die `DeleteItem` DynamoDB-Operation.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Mutation` Typ, um eine neue `deletePost` Mutation hinzuzufügen, wie folgt:
```
type Mutation {
deletePost(id: ID!, expectedVersion: Int): Post
upvotePost(id: ID!): Post
downvotePost(id: ID!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
Dieses Mal wurde das Feld `expectedVersion` als optional konfiguriert. Dies wird später erläutert, wenn Sie die Anforderungszuweisungsvorlage hinzufügen.
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **delete** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "DeleteItem",
"key": {
"id": $util.dynamodb.toDynamoDBJson($context.arguments.id)
}
#if( $context.arguments.containsKey("expectedVersion") )
,"condition" : {
"expression" : "attribute_not_exists(id) OR version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
}
}
#end
}
```
**Hinweis:** Das Argument `expectedVersion` ist ein optionales Argument. Wenn der Aufrufer ein `expectedVersion` Argument in der Anfrage festlegt, fügt die Vorlage eine Bedingung hinzu, die nur dann den Erfolg der `DeleteItem` Anfrage ermöglicht, wenn das Element bereits gelöscht wurde oder wenn das `version` Attribut des Beitrags in DynamoDB genau dem entspricht. `expectedVersion` Wenn es ausgelassen wird, wird kein Bedingungsausdruck für die `DeleteItem`-Anforderung angegeben. Es ist erfolgreich`version`, unabhängig vom Wert von oder ob das Element in DynamoDB vorhanden ist oder nicht.
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
**Hinweis:** Auch wenn Sie ein Element löschen, können Sie das gelöschte Element zurückgeben, sofern es nicht bereits vorher gelöscht wurde.
+ Wählen Sie **Speichern**.
Weitere Informationen zur `DeleteItem` Anforderungszuordnung finden Sie in der [DeleteItem](aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.md)Referenzdokumentation.
### Aufrufen der API zum Löschen eines Posts
Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende `delete` Mutation in eine `DeleteItem` DynamoDB-Operation übersetzt. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle zu löschen.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation deletePost {
deletePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der Beitrag wurde aus DynamoDB gelöscht. Beachten Sie, dass der Wert des Elements AWS AppSync zurückgegeben wird, das aus DynamoDB gelöscht wurde und der im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden sollte. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"deletePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 4,
"version": 12
}
}
}
```
Der Wert wird nur zurückgegeben, wenn dieser Aufruf von `deletePost` derjenige war, der ihn tatsächlich aus DynamoDB gelöscht hat.
+ Wählen Sie erneut **Execute query (Abfrage ausführen)**.
+ Der Aufruf ist weiterhin erfolgreich, es wird jedoch kein Wert zurückgegeben.
```
{
"data": {
"deletePost": null
}
}
```
Löschen wir jetzt einen Post. Dieses Mal geben wir aber einen `expectedValue` an. Zuerst müssen Sie jedoch einen neuen Post erstellen, da der Post, mit dem Sie bisher gearbeitet haben, gerade gelöscht wurde.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein:
```
mutation addPost {
addPost(
id:123
author: "AUTHORNAME"
title: "Our second post!"
content: "A new post."
url: "https://aws.amazon.com/appsync/"
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Die Ergebnisse des neu erstellten Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Notieren Sie die `id` des neu erstellten Objekts, da diese gleich benötigt wird. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"addPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our second post!",
"content": "A new post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
Jetzt versuchen wir, diesen Post zu löschen, geben aber einen falschen Wert für `expectedVersion` an:
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 9999
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
```
{
"data": {
"deletePost": null
},
"errors": [
{
"path": [
"deletePost"
],
"data": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our second post!",
"content": "A new post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
},
"errorType": "DynamoDB:ConditionalCheckFailedException",
"locations": [
{
"line": 2,
"column": 3
}
],
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
}
]
}
```
Die Anforderung ist fehlgeschlagen, weil der Bedingungsausdruck als falsch ausgewertet wird: Der Wert für `version` des Beitrags in DynamoDB entspricht nicht dem in den Argumenten `expectedValue` angegebenen Wert. Der aktuelle Wert des Objekts wird im Feld `data` im Abschnitt `errors` der GraphQL-Antwort zurückgegeben.
+ Wiederholen Sie die Anforderung und korrigieren Sie dabei `expectedVersion`:
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 1
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Diesmal ist die Anfrage erfolgreich und der Wert, der aus DynamoDB gelöscht wurde, wird zurückgegeben:
```
{
"data": {
"deletePost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our second post!",
"content": "A new post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
+ Wählen Sie erneut **Execute query (Abfrage ausführen)**.
+ Der Aufruf ist immer noch erfolgreich, aber diesmal wird kein Wert zurückgegeben, da der Beitrag bereits in DynamoDB gelöscht wurde.
```
{
"data": {
"deletePost": null
}
}
```
## Einrichten des allPost-Resolvers (DynamoDB Scan)
Bisher ist die API nur nützlich, wenn Sie die `id` eines jeden Beitrags kennen, den Sie betrachten möchten. Fügen wir jetzt einen neuen Resolver hinzu, der alle Posts in der Tabelle zurückgibt.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Query` Typ, um eine neue `allPost` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPost(count: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
+ Fügen Sie einen neuen `PaginationPosts`-Typ hinzu:
```
type PaginatedPosts {
posts: [Post!]!
nextToken: String
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **allPost** des Typs **Query (Abfrage)** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
#if( ${context.arguments.count} )
,"limit": $util.toJson($context.arguments.count)
#end
#if( ${context.arguments.nextToken} )
,"nextToken": $util.toJson($context.arguments.nextToken)
#end
}
```
Dieser Resolver verfügt über zwei optionale Argumente: `count` gibt die maximale Anzahl von Elementen an, die in einem Aufruf zurückgegeben werden sollen, und mit `nextToken` kann der nächste Ergebnissatz abgerufen werden. (Später wird erläutert, woher der Wert für `nextToken` stammt.)
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
**Hinweis:** Diese Zuweisungsvorlage für Antworten unterscheidet sich von allen bisher betrachteten Zuweisungsvorlagen. Das Ergebnis der `allPost`-Abfrage ist `PaginatedPosts` mit einer Liste von Posts und einem Paginierungs-Token. Die Form dieses Objekts unterscheidet sich von dem, was vom AWS AppSync DynamoDB-Resolver zurückgegeben wird: Die Liste der Beiträge wird `items` in den AWS AppSync DynamoDB-Resolver-Ergebnissen aufgerufen, aber sie wird aufgerufen. `posts` `PaginatedPosts`
+ Wählen Sie **Speichern**.
[Weitere Informationen zur Zuordnung von `Scan` Anfragen finden Sie in der Referenzdokumentation zum Scannen.](aws-appsync-resolver-mapping-template-reference-dynamodb-scan.md)
### Aufrufen der API zum Scannen aller Posts
Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende `allPost` Abfrage in eine `Scan` DynamoDB-Operation übersetzt. Sie können jetzt die Tabelle scannen, um alle Posts abzurufen.
Bevor Sie dies ausprobieren können, muss allerdings die Tabelle mit Daten gefüllt werden, da Sie alle Daten gelöscht haben, mit denen Sie bislang gearbeitet haben.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein:
```
mutation addPost {
post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
Scannen wir jetzt die Tabelle so, dass jeweils fünf Ergebnisse zurückgegeben werden.
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
query allPost {
allPost(count: 5) {
posts {
id
title
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Die ersten fünf Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPost": {
"posts": [
{
"id": "5",
"title": "A series of posts, Volume 5"
},
{
"id": "1",
"title": "A series of posts, Volume 1"
},
{
"id": "6",
"title": "A series of posts, Volume 6"
},
{
"id": "9",
"title": "A series of posts, Volume 9"
},
{
"id": "7",
"title": "A series of posts, Volume 7"
}
],
"nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRkJEdXdUK09hcnovRGhNTGxLTGdMUEFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF6ajFodkhKU1paT1pncTRaUUNBUkNBZ2dHWnJiR1dQWGxkMDB1N0xEdGY4Z2JsbktzRjRua1VCcks3TFJLcjZBTFRMeGFwVGJZMDRqOTdKVFQyYVRwSzdzbVdtNlhWWFVCTnFIOThZTzBWZHVkdDI2RlkxMHRqMDJ2QTlyNWJTUWpTbWh6NE5UclhUMG9KZWJSQ2JJbXBlaDRSVlg0Tis0WTVCN1IwNmJQWWQzOVhsbTlUTjBkZkFYMVErVCthaXZoNE5jMk50RitxVmU3SlJ5WmpzMEFkSGduM3FWd2VrOW5oeFVVd3JlK1loUks5QkRzemdiMDlmZmFPVXpzaFZ4cVJRbC93RURlOTcrRmVJdXZNby9NZ1F6dUdNbFRyalpNR3FuYzZBRnhwa0VlZTFtR0FwVDFISElUZlluakptYklmMGUzUmcxbVlnVHVSbDh4S0trNmR0QVoraEhLVDhuNUI3VnF4bHRtSnlNUXBrZGl6KzkyL3VzNDl4OWhrMnVxSW01ZFFwMjRLNnF0dm9ZK1BpdERuQTc5djhzb0grVytYT3VuQ2NVVDY4TVZ1Wk5KYkRuSEFSSEVlaTlVNVBTelU5RGZ6d2pPdmhqWDNJMWhwdWUrWi83MDVHVjlPQUxSTGlwZWZPeTFOZFhwZTdHRDZnQW00bUJUK2c1eC9Ec3ZDbWVnSDFDVXRTdHVuU1ZFa2JpZytQRC9oMUwyRTNqSHhVQldaa28yU256WUc0cG0vV1RSWkFVZHZuQT09In0="
}
}
}
```
Sie haben fünf Ergebnisse und ein `nextToken`, das zum Abrufen des nächsten Ergebnissatzes verwendet werden kann.
+ Aktualisieren Sie die `allPost`-Abfrage, um das `nextToken` aus dem vorherigen Ergebnissatz einzuschließen:
```
query allPost {
allPost(
count: 5
nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0="
) {
posts {
id
author
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Die verbleibenden vier Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Dieser Ergebnissatz enthält kein `nextToken`, weil Sie alle neun Posts durchlaufen haben und keine mehr übrig sind. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPost": {
"posts": [
{
"id": "2",
"title": "A series of posts, Volume 2"
},
{
"id": "3",
"title": "A series of posts, Volume 3"
},
{
"id": "4",
"title": "A series of posts, Volume 4"
},
{
"id": "8",
"title": "A series of posts, Volume 8"
}
],
"nextToken": null
}
}
}
```
## Den allPostsBy Author Resolver einrichten (DynamoDB Query)
Sie können DynamoDB nicht nur nach allen Beiträgen durchsuchen, sondern auch DynamoDB abfragen, um Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden. Die DynamoDB-Tabelle, die Sie zuvor erstellt haben, hat bereits einen `GlobalSecondaryIndex` Aufruf, den `author-index` Sie mit einer `Query` DynamoDB-Operation verwenden können, um alle Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Query` Typ, um eine neue `allPostsByAuthor` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
allPost(count: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
**Hinweis:** Hier wird der gleiche `PaginatedPosts`-Typ wie in der `allPost`-Abfrage verwendet.
+ Wählen Sie **Speichern**.
+ Suchen Sie im Bereich **Datentypen** auf der rechten Seite nach dem neu erstellten **allPostsByAutorenfeld** für den **Abfragetyp**, und wählen Sie dann **Anhängen** aus.
+ Wählen Sie im **Menü Aktion** die Option **Laufzeit aktualisieren** und anschließend **Unit Resolver (nur VTL**) aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "Query",
"index" : "author-index",
"query" : {
"expression": "author = :author",
"expressionValues" : {
":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author)
}
}
#if( ${context.arguments.count} )
,"limit": $util.toJson($context.arguments.count)
#end
#if( ${context.arguments.nextToken} )
,"nextToken": "${context.arguments.nextToken}"
#end
}
```
Dieser Resolver verfügt wie der `allPost`-Resolver über zwei optionale Argumente: `count` gibt die maximale Anzahl von Elementen an, die in einem Aufruf zurückgegeben werden sollen, und mit `nextToken` kann der nächste Ergebnissatz abgerufen werden. (Der Wert für `nextToken` kann aus einem vorherigen Abruf übernommen werden.)
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
**Hinweis:** Dies ist die gleiche Zuweisungsvorlage für Antworten, die auch im `allPost`-Resolver verwendet wurde.
+ Wählen Sie **Speichern**.
Weitere Informationen zur `Query` Anforderungszuordnung finden Sie in der [Query-Referenzdokumentation](aws-appsync-resolver-mapping-template-reference-dynamodb-query.md).
### Aufrufen der API zum Abfragen aller Posts von einem Autor
Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende `allPostsByAuthor` Mutation in eine `Query` DynamoDB-Operation gegen den Index übersetzt. `author-index` Sie können nun die Tabelle abfragen, um alle Posts von einem bestimmten Autor abzurufen.
Zuvor müssen Sie jedoch die Tabelle mit weiteren Post-Daten füllen, da bisher alle Posts den gleichen Autor haben.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein:
```
mutation addPost {
post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title }
post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title }
post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title }
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
Wir fragen jetzt die Tabelle ab, so dass alle Posts von `Nadia` zurückgegeben werden.
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
query allPostsByAuthor {
allPostsByAuthor(author: "Nadia") {
posts {
id
title
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle Posts von `Nadia` sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you know...?"
}
],
"nextToken": null
}
}
}
```
Die Paginierung funktioniert für `Query` genauso wie für `Scan`. Suchen wir z. B. nach allen Posts von `AUTHORNAME`, wobei jeweils fünf Posts abgerufen werden.
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
count: 5
) {
posts {
id
title
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle Posts von `AUTHORNAME` sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "6",
"title": "A series of posts, Volume 6"
},
{
"id": "4",
"title": "A series of posts, Volume 4"
},
{
"id": "2",
"title": "A series of posts, Volume 2"
},
{
"id": "7",
"title": "A series of posts, Volume 7"
},
{
"id": "1",
"title": "A series of posts, Volume 1"
}
],
"nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
}
}
}
```
+ Aktualisieren Sie das `nextToken`-Argument mit dem Wert, der in der vorherigen Abfrage zurückgegeben wurde:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
count: 5
nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
) {
posts {
id
title
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle verbleibenden Posts von `AUTHORNAME` sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "8",
"title": "A series of posts, Volume 8"
},
{
"id": "5",
"title": "A series of posts, Volume 5"
},
{
"id": "3",
"title": "A series of posts, Volume 3"
},
{
"id": "9",
"title": "A series of posts, Volume 9"
}
],
"nextToken": null
}
}
}
```
## Verwenden von Sätzen
Bis zu diesem Zeitpunkt war der `Post` Typ ein flaches Objekt. key/value Sie können mit dem AWS AppSyncDynamo DB-Resolver auch komplexe Objekte wie Gruppen, Listen und Maps modellieren.
Aktualisieren wir jetzt den `Post`-Typ, so dass er Tags enthält. Ein Beitrag kann 0 oder mehr Tags haben, die in DynamoDB als String-Set gespeichert werden. Außerdem richten Sie einige Mutationen ein, um Tags hinzuzufügen und zu entfernen, sowie eine neue Abfrage zum Scannen nach Posts mit einem bestimmten Tag.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Ändern Sie im **Schemabereich** den `Post` Typ wie folgt, um ein neues `tags` Feld hinzuzufügen:
```
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
tags: [String!]
}
```
+ Ändern Sie im **Schemabereich** den `Query` Typ, um eine neue `allPostsByTag` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPostsByTag(tag: String!, count: Int, nextToken: String): PaginatedPosts!
allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
allPost(count: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
+ Ändern Sie im **Schemabereich** den `Mutation` Typ, um neue `addTag` und `removeTag` Mutationen hinzuzufügen, wie folgt:
```
type Mutation {
addTag(id: ID!, tag: String!): Post
removeTag(id: ID!, tag: String!): Post
deletePost(id: ID!, expectedVersion: Int): Post
upvotePost(id: ID!): Post
downvotePost(id: ID!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie im Bereich **Datentypen** auf der rechten Seite nach dem neu erstellten **allPostsByTag-Feld** für den **Abfragetyp**, und wählen Sie dann **Anhängen** aus.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"filter": {
"expression": "contains (tags, :tag)",
"expressionValues": {
":tag": $util.dynamodb.toDynamoDBJson($context.arguments.tag)
}
}
#if( ${context.arguments.count} )
,"limit": $util.toJson($context.arguments.count)
#end
#if( ${context.arguments.nextToken} )
,"nextToken": $util.toJson($context.arguments.nextToken)
#end
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **addTag** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "ADD tags :tags, version :plusOne",
"expressionValues" : {
":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
":plusOne" : { "N" : 1 }
}
}
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **removeTag** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "DELETE tags :tags ADD version :plusOne",
"expressionValues" : {
":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
":plusOne" : { "N" : 1 }
}
}
}
```
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
### Aufrufen der API zum Arbeiten mit Tags
Jetzt, wo Sie die Resolver eingerichtet haben, AWS AppSync weiß er, wie eingehende `addTag` `allPostsByTag` Anfragen und Anfragen in DynamoDB `UpdateItem` und Operationen übersetzt werden. `removeTag` `Scan`
Wählen Sie zum Ausprobieren einen der zuvor erstellten Posts aus. Verwenden wir als Beispiel einen Post, der von `Nadia` verfasst wurde.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "Nadia"
) {
posts {
id
title
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle Posts von Nadia sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you known...?"
}
],
"nextToken": null
}
}
}
```
+ Verwenden wir den Post mit dem Titel `"The cutest dog in the world"`. Notieren Sie dessen `id`, da diese später benötigt wird.
Fügen wir jetzt den Tag `dog` hinzu.
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation addTag {
addTag(id:10 tag: "dog") {
id
title
tags
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der Post wird mit dem neuen Tag aktualisiert.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
Sie können weitere Tags folgendermaßen hinzufügen:
+ Aktualisieren Sie die Mutation und ändern Sie das `tag`-Argument in `puppy`.
```
mutation addTag {
addTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der Post wird mit dem neuen Tag aktualisiert.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
}
}
```
Tags können auch gelöscht werden:
+ Fügen Sie die folgende Mutation in den Bereich **Queries (Abfragen)** ein. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation removeTag {
removeTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Der Post wird aktualisiert und das Tag `puppy` wird gelöscht.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
Sie können auch alle Posts mit einem Tag suchen:
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
query allPostsByTag {
allPostsByTag(tag: "dog") {
posts {
id
title
tags
}
nextToken
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle Posts mit dem Tag `dog` werden folgendermaßen zurückgegeben:
```
{
"data": {
"allPostsByTag": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
],
"nextToken": null
}
}
}
```
## Verwenden von Listen und Zuordnungen
Neben DynamoDB-Sets können Sie auch DynamoDB-Listen und -Maps verwenden, um komplexe Daten in einem einzigen Objekt zu modellieren.
Fügen wir nun die Möglichkeit hinzu, Posts Kommentare hinzuzufügen. Dies wird als Liste von Kartenobjekten für das `Post` Objekt in DynamoDB modelliert.
**Hinweis:** In einer realen Anwendung würden Sie Kommentare in der eigenen Tabelle modellieren. Für dieses Tutorial fügen Sie sie einfach in die `Post`-Tabelle ein.
+ Wählen Sie die Registerkarte **Schema** aus.
+ Fügen Sie im Bereich **Schema** folgendermaßen einen neuen `Comment`-Typ hinzu:
```
type Comment {
author: String!
comment: String!
}
```
+ Ändern Sie im **Schemabereich** den `Post` Typ wie folgt, um ein neues `comments` Feld hinzuzufügen:
```
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
tags: [String!]
comments: [Comment!]
}
```
+ Ändern Sie im **Schemabereich** den `Mutation` Typ wie folgt, um eine neue `addComment` Mutation hinzuzufügen:
```
type Mutation {
addComment(id: ID!, author: String!, comment: String!): Post
addTag(id: ID!, tag: String!): Post
removeTag(id: ID!, tag: String!): Post
deletePost(id: ID!, expectedVersion: Int): Post
upvotePost(id: ID!): Post
downvotePost(id: ID!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
+ Wählen Sie **Speichern**.
+ Suchen Sie rechts im Bereich **Data types (Datentypen)** das neue Feld **addComment** des Typs **Mutation** und wählen Sie dann **Attach (Anhängen)**.
+ Wählen Sie für **Data source name (Datenquellenname)** die Option **PostDynamoDBTable** aus.
+ Fügen Sie unter **Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren)** Folgendes ein:
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
},
"update" : {
"expression" : "SET comments = list_append(if_not_exists(comments, :emptyList), :newComment) ADD version :plusOne",
"expressionValues" : {
":emptyList": { "L" : [] },
":newComment" : { "L" : [
{ "M": {
"author": $util.dynamodb.toDynamoDBJson($context.arguments.author),
"comment": $util.dynamodb.toDynamoDBJson($context.arguments.comment)
}
}
] },
":plusOne" : $util.dynamodb.toDynamoDBJson(1)
}
}
}
```
Dieser Aktualisierungsausdruck fügt eine Liste mit dem neuen Kommentar an die vorhandene `comments`-Liste an. Wenn die Liste noch nicht vorhanden ist, wird sie erstellt.
+ Fügen Sie unter **Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren)** Folgendes ein:
```
$utils.toJson($context.result)
```
+ Wählen Sie **Speichern**.
### Aufrufen der API zum Hinzufügen eines Kommentars
Jetzt, wo Sie die Resolver eingerichtet haben, AWS AppSync weiß, wie eingehende `addComment` Anfragen in `UpdateItem` DynamoDB-Operationen übersetzt werden.
Fügen Sie zum Ausprobieren einen Kommentar zu dem Post hinzu, dem auch die Tags hinzugefügt wurden.
+ Wählen Sie die Registerkarte **Queries** aus.
+ Fügen Sie im Bereich **Queries (Abfragen)** die folgende Abfrage ein:
```
mutation addComment {
addComment(
id:10
author: "Steve"
comment: "Such a cute dog."
) {
id
comments {
author
comment
}
}
}
```
+ Wählen Sie **Execute query (Abfrage ausführen)** (orangefarbene Wiedergabeschaltfläche).
+ Alle Posts von Nadia sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"addComment": {
"id": "10",
"comments": [
{
"author": "Steve",
"comment": "Such a cute dog."
}
]
}
}
}
```
Wenn Sie die Anforderung mehrmals ausführen, werden mehrere Kommentare an die Liste angefügt.
## Schlussfolgerung
In diesem Tutorial haben Sie eine API erstellt, mit der wir Post-Objekte in DynamoDB mithilfe AWS AppSync von GraphQL bearbeiten können. Weitere Informationen finden Sie unter [Referenz für Resolver-Zuweisungsvorlagen](resolver-mapping-template-reference.md#aws-appsync-resolver-mapping-template-reference).
Zum Aufräumen können Sie die AppSync GraphQL-API von der Konsole löschen.
Um die DynamoDB-Tabelle und die IAM-Rolle zu löschen, die Sie für dieses Tutorial erstellt haben, können Sie Folgendes ausführen, um den `AWSAppSyncTutorialForAmazonDynamoDB` Stack zu löschen, oder die CloudFormation Konsole aufrufen und den Stack löschen:
```
aws cloudformation delete-stack \
--stack-name AWSAppSyncTutorialForAmazonDynamoDB
```