

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.

# Verwenden von GraphQL-Mutationen zum Hinzufügen von Daten zu einer DynamoDB-Tabelle in der Konsole AWS AppSync
<a name="add-data-with-graphql-mutation"></a>

Ihr nächster Schritt besteht darin, Ihrer leeren DynamoDB-Tabelle mithilfe einer GraphQL-Mutation Daten hinzuzufügen. Mutationen sind einer der grundlegenden Operationstypen in GraphQL. Sie sind im Schema definiert und ermöglichen es Ihnen, Daten in Ihrer Datenquelle zu manipulieren. In Bezug auf REST APIs sind diese Operationen wie `PUT` oder sehr ähnlich`POST`.

**Um Daten zu Ihrer Datenquelle hinzuzufügen**

1. Falls Sie dies noch nicht getan haben, melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSync Konsole](https://console.aws.amazon.com/appsync/). 

1. Wählen Sie Ihre API aus der Tabelle aus.

1. Wählen Sie in der Registerkarte auf der linken Seite **Abfragen** aus.

1. Auf der **Explorer-Registerkarte** links neben der Tabelle sehen Sie möglicherweise mehrere Mutationen und Abfragen, die bereits im Abfrage-Editor definiert wurden:  
![\[Explorer tab showing a dropdown menu with mutation and query options like createTodo and deleteTodo.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-1.png)
**Anmerkung**  
Diese Mutation ist tatsächlich als `Mutation` Typ in Ihrem Schema enthalten. Es hat den Code:  

   ```
   type Mutation {
   	createTodo(input: CreateTodoInput!): Todo
   	updateTodo(input: UpdateTodoInput!): Todo
   	deleteTodo(input: DeleteTodoInput!): Todo
   }
   ```
Wie Sie sehen können, ähneln die Operationen hier denen im Abfrage-Editor.

   AWS AppSync hat diese automatisch anhand des zuvor definierten Modells generiert. In diesem Beispiel wird die `createTodo` Mutation verwendet, um Einträge zu unserer *TodoAPITable* Tabelle hinzuzufügen.

1. Wählen Sie die `createTodo` Operation aus, indem Sie sie unter der `createTodo` Mutation erweitern:  
![\[Expanded createTodo mutation showing input fields like description, id, name, when, and where.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-2.png)

   Aktivieren Sie die Kontrollkästchen für alle Felder wie im Bild oben.
**Anmerkung**  
Die Attribute, die Sie hier sehen, sind die verschiedenen modifizierbaren Elemente der Mutation. Sie `input` können sich als Parameter von `createTodo` vorstellen. Die verschiedenen Optionen mit Checkboxen sind die Felder, die in der Antwort zurückgegeben werden, sobald ein Vorgang ausgeführt wird.

1. Im Code-Editor in der Mitte des Bildschirms werden Sie feststellen, dass die Operation unter der `createTodo` Mutation angezeigt wird:

   ```
   mutation createTodo($createtodoinput: CreateTodoInput!) {
     createTodo(input: $createtodoinput) {
       where
       when
       name
       id
       description
     }
   }
   ```
**Anmerkung**  
Um dieses Snippet richtig zu erklären, müssen wir uns auch den Schemacode ansehen. Die Deklaration `mutation createTodo($createtodoinput: CreateTodoInput!){}` ist die Mutation mit einer ihrer Operationen,. `createTodo` Die vollständige Mutation befindet sich im Schema:  

   ```
   type Mutation {
   	createTodo(input: CreateTodoInput!): Todo
   	updateTodo(input: UpdateTodoInput!): Todo
   	deleteTodo(input: DeleteTodoInput!): Todo
   }
   ```
Zurück zur Mutationsdeklaration aus dem Editor: Der Parameter ist ein Objekt, das `$createtodoinput` mit dem erforderlichen Eingabetyp aufgerufen wird`CreateTodoInput`. Beachten Sie, dass `CreateTodoInput` (und alle Eingaben in der Mutation) auch im Schema definiert sind. Hier ist zum Beispiel der Boilerplate-Code für: `CreateTodoInput`  

   ```
   input CreateTodoInput {
   	name: String
   	when: String
   	where: String
   	description: String
   }
   ```
Er enthält die Felder, die wir in unserem Modell definiert haben, nämlich`name`, `when``where`, und. `description`  
Um zum Editor-Code zurückzukehren, deklarieren wir die Eingabe als`$createtodoinput`, die auch in der Mutationsdeklaration verwendet wurde. `createTodo(input: $createtodoinput) {}` Wir tun dies, weil GraphQL so unsere Eingaben anhand der bereitgestellten Typen validieren und sicherstellen kann, dass sie mit den richtigen Eingaben verwendet werden.  
Der letzte Teil des Editor-Codes zeigt die Felder, die in der Antwort zurückgegeben werden, nachdem eine Operation ausgeführt wurde:  

   ```
   {
       where
       when
       name
       id
       description
     }
   ```

   Auf der Registerkarte **Abfragevariablen** unter diesem Editor wird es ein generisches `createtodoinput` Objekt geben, das die folgenden Daten enthalten kann:

   ```
   {
     "createtodoinput": {
       "name": "Hello, world!",
       "when": "Hello, world!",
       "where": "Hello, world!",
       "description": "Hello, world!"
     }
   }
   ```
**Anmerkung**  
Hier weisen wir die Werte für die zuvor erwähnte Eingabe zu:  

   ```
   input CreateTodoInput {
   	name: String
   	when: String
   	where: String
   	description: String
   }
   ```

   Ändern Sie das, `createtodoinput` indem Sie Informationen hinzufügen, die wir in unsere DynamoDB-Tabelle aufnehmen möchten. In diesem Fall wollten wir einige `Todo` Elemente als Erinnerung erstellen:

   ```
   {
     "createtodoinput": {
       "name": "Shopping List",
       "when": "Friday",
       "where": "Home",
       "description": "I need to buy eggs"
     }
   }
   ```

1. Wählen Sie oben im Editor die Option **Ausführen** aus. Wählen Sie in der Drop-down-Liste **CreateTodo** aus. Auf der rechten Seite des Editors sollten Sie die Antwort sehen. Dies kann etwa wie folgt aussehen:

   ```
   {
     "data": {
       "createTodo": {
         "where": "Home",
         "when": "Friday",
         "name": "Shopping List",
         "id": "abcdefgh-1234-1234-1234-abcdefghijkl",
         "description": "I need to buy eggs"
       }
     }
   }
   ```

   Wenn Sie zum DynamoDB-Dienst navigieren, sehen Sie jetzt einen Eintrag in Ihrer Datenquelle mit diesen Informationen:  
![\[TodoAPITable interface showing a completed scan with 1 item returned in a table format.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-3.png)

Um den Vorgang zusammenzufassen: Die GraphQL-Engine analysierte den Datensatz und ein Resolver fügte ihn in Ihre Amazon DynamoDB-Tabelle ein. Auch dies können Sie in der DynamoDB-Konsole überprüfen. Beachten Sie, dass Sie keinen Wert übergeben müssen. `id` Ein `id` wird generiert und in den Ergebnissen zurückgegeben. Das liegt daran, dass in dem Beispiel eine `autoId()` Funktion in einem GraphQL-Resolver für den Partitionsschlüssel verwendet wurde, der auf Ihren DynamoDB-Ressourcen festgelegt wurde. Wir werden in einem anderen Abschnitt behandeln, wie Sie Resolver erstellen können. Notieren Sie sich den zurückgegebenen `id` Wert. Sie werden ihn im nächsten Abschnitt verwenden, um Daten mit einer GraphQL-Abfrage abzurufen.