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. # Erste Schritte: Erstellen Sie Ihre erste GraphQL-API in AWS AppSync Sie können die AWS AppSync Konsole verwenden, um eine GraphQL-API zu konfigurieren und zu starten. GraphQL benötigt APIs im Allgemeinen drei Komponenten: 1. **GraphQL-Schema** — Ihr GraphQL-Schema ist die Blaupause der API. Es definiert die Typen und Felder, die Sie anfordern können, wenn eine Operation ausgeführt wird. Um das Schema mit Daten zu füllen, müssen Sie Datenquellen mit der GraphQL-API verbinden. In dieser Schnellstartanleitung erstellen wir ein Schema mit einem vordefinierten Modell. 1. **Datenquellen** — Dies sind die Ressourcen, die die Daten zum Auffüllen Ihrer GraphQL-API enthalten. Dies kann eine DynamoDB-Tabelle, eine Lambda-Funktion usw. sein, die eine Vielzahl von Datenquellen AWS AppSync unterstützt, um robustes und skalierbares GraphQL zu erstellen. APIs Datenquellen sind mit Feldern im Schema verknüpft. Immer wenn eine Anforderung für ein Feld ausgeführt wird, wird das Feld mit den Daten aus der Quelle gefüllt. Dieser Mechanismus wird vom Resolver gesteuert. In dieser Schnellstartanleitung erstellen wir eine Datenquelle, die neben dem Schema ein vordefiniertes Modell verwendet. 1. **Resolver** — Resolver sind dafür verantwortlich, das Schemafeld mit der Datenquelle zu verknüpfen. Sie rufen die Daten aus der Quelle ab und geben dann das Ergebnis auf der Grundlage der Felddefinition zurück. AWS AppSync unterstützt JavaScript sowohl VTL als auch VTL zum Schreiben von Resolvern für Ihr GraphQL. APIs In dieser Schnellstartanleitung werden die Resolver automatisch auf der Grundlage des Schemas und der Datenquelle generiert. Wir werden uns in diesem Abschnitt nicht damit befassen. AWS AppSync unterstützt die Erstellung und Konfiguration aller GraphQL-Komponenten. Wenn Sie die Konsole öffnen, können Sie die folgenden Methoden verwenden, um Ihre API zu erstellen: 1. Entwerfen einer benutzerdefinierten GraphQL-API, indem sie über ein vordefiniertes Modell generiert und eine neue DynamoDB-Tabelle (Datenquelle) zur Unterstützung eingerichtet wird. 1. Entwerfen einer GraphQL-API mit einem leeren Schema und ohne Datenquellen oder Resolver. 1. Verwenden Sie eine DynamoDB-Tabelle, um Daten zu importieren und die Typen und Felder Ihres Schemas zu generieren. 1. Nutzung AWS AppSync der WebSocket Funktionen und der Pub/Sub Architektur zur Entwicklung in Echtzeit. APIs 1. Verwenden von vorhandenem GraphQL APIs (Quelle APIs), um eine Verknüpfung zu einer zusammengeführten API herzustellen. **Anmerkung** Wir empfehlen, den Abschnitt [Ein Schema entwerfen](designing-your-schema.md#aws-appsync-designing-your-schema) zu lesen, bevor Sie mit fortgeschritteneren Tools arbeiten. In diesen Leitfäden werden einfachere Beispiele erläutert, die Sie konzeptionell verwenden können, um komplexere Anwendungen zu erstellen. AWS AppSync AWS AppSync unterstützt auch mehrere Optionen, die keine Konsole sind, um APIs GraphQL zu erstellen. Dazu zählen: 1. AWS Amplify 1. AWS SAM 1. CloudFormation 1. Das CDK Das folgende Beispiel zeigt Ihnen, wie Sie die grundlegenden Komponenten einer GraphQL-API mithilfe vordefinierter Modelle und DynamoDB erstellen. **Topics** + [Ein Schema starten](schema-launch-start.md) + [Ein Rundgang durch die Konsole AWS AppSync](console-tour.md) + [Verwenden von GraphQL-Mutationen zum Hinzufügen von Daten zu einer DynamoDB-Tabelle](add-data-with-graphql-mutation.md) + [Verwenden von GraphQL-Abfragen zum Abrufen von Daten aus einer DynamoDB-Tabelle](retrieve-data-with-graphql-query.md) + [Zusätzliche Abschnitte](next-steps.md) # Ein Schema in der Konsole starten AWS AppSync In diesem Beispiel erstellen Sie eine `Todo` API, mit der Benutzer `Todo` Elemente für tägliche Arbeitserinnerungen wie *Finish task* oder erstellen können. *Pick up groceries* Diese API demonstriert, wie GraphQL-Operationen verwendet werden, bei denen der Status in einer DynamoDB-Tabelle persistiert. Konzeptionell gibt es drei Hauptschritte, um Ihre erste GraphQL-API zu erstellen. Sie müssen das Schema (Typen und Felder) definieren, Ihre Datenquelle (n) an Ihre Felder anhängen und dann den Resolver schreiben, der die Geschäftslogik verarbeitet. Die Konsolenerfahrung ändert jedoch die Reihenfolge. Wir definieren zunächst, wie unsere Datenquelle mit unserem Schema interagieren soll, und definieren dann später das Schema und den Resolver. **Um Ihre GraphQL-API zu erstellen** 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 **Dashboard** **Create API (API erstellen)** aus. 1. Wenn **GraphQL** ausgewählt APIs ist, wählen Sie **Design from scratch**. Wählen Sie anschließend **Weiter**. 1. **Ändern Sie für den **API-Namen** den vorausgefüllten Namen in **Todo API** und wählen Sie dann Weiter.** **Anmerkung** Es gibt hier auch andere Optionen, aber wir werden sie für dieses Beispiel nicht verwenden. 1. Gehen **Sie im Abschnitt GraphQL-Ressourcen angeben** wie folgt vor: 1. Wählen Sie **jetzt Typ erstellen, der von einer DynamoDB-Tabelle unterstützt wird**. **Anmerkung** Das bedeutet, dass wir eine neue DynamoDB-Tabelle erstellen werden, die als Datenquelle angehängt wird. 1. Geben Sie im Feld **Modellname** ein. **Todo** **Anmerkung** Unsere erste Anforderung besteht darin, unser Schema zu definieren. Dieser **Modellname** wird der Typname sein. Was Sie also wirklich tun, ist einen `type` Namen zu erstellen`Todo`, der im Schema vorhanden sein wird: ``` type Todo {} ``` 1. Gehen Sie unter **Felder** wie folgt vor: 1. Erstellen Sie ein Feld mit dem Namen**id**, dem Typ `ID` und der erforderlichen Einstellung auf`Yes`. **Anmerkung** Dies sind die Felder, die innerhalb des Gültigkeitsbereichs Ihres `Todo` Typs existieren werden. Ihr Feldname wird hier `id` mit dem folgenden Typ aufgerufen`ID!`: ``` type Todo { id: ID! } ``` AWS AppSync unterstützt mehrere Skalarwerte für verschiedene Anwendungsfälle. 1. Erstellen **Sie mit „Neues Feld hinzufügen**“ vier zusätzliche Felder mit den `Name` Werten**name**, **when****where**, und**description**. Ihre `Type` Werte werden sein`String`, `Array` und die `Required` Werte und werden beide auf gesetzt`No`. Sie sieht wie folgt aus: ![\[Model information form showing fields for a Todo model with ID, name, when, where, and description.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/model-information-tutorial.png) **Anmerkung** Der vollständige Typ und seine Felder werden wie folgt aussehen: ``` type Todo { id: ID! name: String when: String where: String description: String } ``` Da wir ein Schema unter Verwendung dieses vordefinierten Modells erstellen, wird es auch mit mehreren Standardmutationen gefüllt, die auf dem Typ basieren, z. B. `create``delete`, und `update` um Ihnen das einfache Auffüllen Ihrer Datenquelle zu erleichtern. 1. Geben **Sie unter Modelltabelle konfigurieren** einen Tabellennamen ein, z. B. **TodoAPITable** Stellen Sie den **Primärschlüssel** auf ein`id`. **Anmerkung** Wir erstellen im Wesentlichen eine neue DynamoDB-Tabelle namens*TodoAPITable*, die an die API als unsere primäre Datenquelle angehängt wird. Unser Primärschlüssel ist auf das erforderliche `id` Feld gesetzt, das wir zuvor definiert haben. Beachten Sie, dass diese neue Tabelle leer ist und außer dem Partitionsschlüssel nichts enthält. 1. Wählen Sie **Weiter** aus. 1. Überprüfen Sie Ihre Änderungen und wählen Sie **Create API**. Warten Sie einen Moment, bis der AWS AppSync Service die Erstellung Ihrer API abgeschlossen hat. Sie haben erfolgreich eine GraphQL-API mit ihrem Schema und der DynamoDB-Datenquelle erstellt. Um die obigen Schritte zusammenzufassen, haben wir uns entschieden, eine völlig neue GraphQL-API zu erstellen. Wir haben den Namen der API definiert und dann unsere Schemadefinition hinzugefügt, indem wir unseren ersten Typ hinzugefügt haben. Wir haben den Typ und seine Felder definiert und dann entschieden, eine Datenquelle an eines der Felder anzuhängen, indem wir eine neue DynamoDB-Tabelle ohne Daten erstellt haben. # Ein Rundgang durch die Konsole AWS AppSync Bevor wir Daten zu unserer DynamoDB-Tabelle hinzufügen, sollten wir uns die grundlegenden Funktionen der AWS AppSync Konsolenerfahrung ansehen. Über die AWS AppSync Konsolenregisterkarte auf der linken Seite der Seite können Benutzer einfach zu den wichtigsten Komponenten oder Konfigurationsoptionen navigieren, die Folgendes bieten: AWS AppSync ![\[AWS AppSync console navigation menu showing APIs, Todo API options, and Documentation link.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-5.jpg) ## Schema-Designer Wählen Sie **Schema**, um das Schema anzuzeigen, das Sie gerade erstellt haben. Wenn Sie den Inhalt des Schemas überprüfen, werden Sie feststellen, dass es bereits mit einer Reihe von Hilfsoperationen geladen wurde, um den Entwicklungsprozess zu optimieren. Wenn Sie im **Schema-Editor** durch den Code blättern, gelangen Sie schließlich zu dem Modell, das Sie im vorherigen Abschnitt definiert haben: ``` type Todo { id: ID! name: String when: String where: String description: String } ``` Ihr Modell wurde zum Basistyp, der in Ihrem gesamten Schema verwendet wurde. Wir werden damit beginnen, unserer Datenquelle Daten hinzuzufügen, indem wir Mutationen verwenden, die automatisch anhand dieses Typs generiert wurden. Hier sind einige zusätzliche Tipps und Fakten zum **Schema-Editor**: 1. Der Code-Editor verfügt über Funktionen zur Linting- und Fehlerüberprüfung, die Sie beim Schreiben Ihrer eigenen Apps verwenden können. 1. Die rechte Seite der Konsole zeigt die erstellten GraphQL-Typen und -Resolver verschiedener Typen der höchsten Ebene an, z. B. Abfragen. 1. Wenn Sie einem Schema neue Typen hinzufügen (z. B.`type User {...}`), können Sie DynamoDB-Ressourcen für Sie AWS AppSync bereitstellen lassen. Dazu gehören der richtige Primärschlüssel, Sortierschlüssel und das Index-Design für Ihr GraphQL-Datenzugriffsmuster. Wenn Sie oben **Create Resources (Ressourcen erstellen)** und einen der benutzerdefinierten Typen im Menü wählen, können Sie verschiedene Feldoptionen im Schemadesign auswählen. Wir werden dies im Abschnitt „[Ein Schema entwerfen](designing-your-schema.md#aws-appsync-designing-your-schema)“ behandeln. ### Resolver-Konfiguration Im Schema-Designer enthält der Abschnitt **Resolvers** alle Typen und Felder in Ihrem Schema. **Wenn Sie durch die Liste der Felder blättern, werden Sie feststellen, dass Sie Resolver an bestimmte Felder anhängen können, indem Sie Anhängen wählen.** Dadurch wird ein Code-Editor geöffnet, in dem Sie Ihren Resolver-Code schreiben können. AWS AppSync **unterstützt sowohl VTL als auch JavaScript Runtimes. Diese können oben auf der Seite geändert werden, indem Sie **Actions und dann Update Runtime** wählen.** Unten auf der Seite können Sie auch Funktionen erstellen, die mehrere Operationen nacheinander ausführen. Resolver sind jedoch ein fortgeschrittenes Thema, auf das wir in diesem Abschnitt nicht eingehen werden. ## Datenquellen Wählen Sie **Datenquellen aus**, um Ihre DynamoDB-Tabelle anzuzeigen. Wenn Sie die `Resource` Option auswählen (falls verfügbar), können Sie die Konfiguration Ihrer Datenquelle anzeigen. In unserem Beispiel führt dies zur DynamoDB-Konsole. Von dort aus können Sie Ihre Daten bearbeiten. Sie können einige Daten auch direkt bearbeiten, indem Sie die Datenquelle und dann **Bearbeiten** auswählen. Wenn Sie Ihre Datenquelle jemals löschen müssen, können Sie Ihre Datenquelle auswählen und dann **Löschen** auswählen. Schließlich können Sie neue Datenquellen erstellen, indem **Sie Datenquelle erstellen** auswählen und dann den Namen und den Typ konfigurieren. Beachten Sie, dass diese Option dazu dient, den AWS AppSync Dienst mit einer vorhandenen Ressource zu verknüpfen. Sie müssen die Ressource dennoch mit dem entsprechenden Dienst in Ihrem Konto erstellen, bevor sie AWS AppSync erkannt wird. ## Abfragen Wählen Sie **Abfragen**, um Ihre Abfragen und Mutationen anzuzeigen. Als wir unsere GraphQL-API mit unserem Modell erstellt haben, wurden AWS AppSync automatisch einige Hilfsmutationen und Abfragen zu Testzwecken generiert. **Im Abfrage-Editor befindet sich auf der linken Seite der Explorer.** Dies ist eine Liste mit all Ihren Mutationen und Abfragen. Sie können die Operationen und Felder, die Sie hier verwenden möchten, ganz einfach aktivieren, indem Sie auf deren Namenswerte klicken. Dadurch wird der Code automatisch in der Mitte des Editors angezeigt. Hier können Sie Ihre Mutationen und Abfragen bearbeiten, indem Sie Werte ändern. Am unteren Rand des Editors befindet sich der Editor für **Abfragevariablen**, mit dem Sie die Feldwerte für die Eingabevariablen Ihrer Operationen eingeben können. Wenn Sie oben im Editor **Ausführen** wählen, wird eine Dropdownliste angezeigt, in der Sie auswählen können, welche ausgeführt werden query/mutation sollen. Die Ausgabe für diesen Lauf wird auf der rechten Seite der Seite angezeigt. Zurück im **Explorer-Bereich** oben können Sie eine Operation (Abfrage, Mutation, Abonnement) auswählen und dann das **Pluszeichen** wählen, um eine neue Instanz dieser bestimmten Operation hinzuzufügen. Oben auf der Seite befindet sich eine weitere Dropdownliste, die den Autorisierungsmodus für Ihre Abfrageläufe enthält. Wir werden diese Funktion in diesem Abschnitt jedoch nicht behandeln (weitere Informationen finden Sie unter [Sicherheit](security-authz.md#aws-appsync-security).). ## Einstellungen Wählen Sie **Einstellungen**, um einige Konfigurationsoptionen für Ihre GraphQL-API anzuzeigen. Hier können Sie einige Optionen wie Protokollierung, Tracing und Firewall-Funktionen für Webanwendungen aktivieren. Sie können auch neue Autorisierungsmodi hinzufügen, um Ihre Daten vor unerwünschten Datenlecks zu schützen. Diese Optionen sind jedoch weiter fortgeschritten und werden in diesem Abschnitt nicht behandelt. **Anmerkung** Der Standardautorisierungsmodus verwendet einen API-Schlüssel`API_KEY`, um die Anwendung zu testen. Dies ist die Basisautorisierung, die allen neu erstellten GraphQL APIs erteilt wird. Wir empfehlen, dass Sie eine andere Methode für die Produktion verwenden. Für das Beispiel in diesem Abschnitt verwenden wir nur den API-Schlüssel. Weitere Informationen zu den unterstützten Autorisierungsmethoden finden Sie unter [Sicherheit](security-authz.md#aws-appsync-security). # Verwenden von GraphQL-Mutationen zum Hinzufügen von Daten zu einer DynamoDB-Tabelle in der Konsole AWS AppSync 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. # Verwenden von GraphQL-Abfragen zum Abrufen von Daten aus einer DynamoDB-Tabelle in der Konsole AWS AppSync Da nun ein Datensatz in Ihrer Datenbank vorhanden ist, erhalten Sie Ergebnisse, wenn Sie eine Abfrage ausführen. Eine Abfrage ist eine der anderen grundlegenden Operationen von GraphQL. Es wird verwendet, um Informationen aus Ihrer Datenquelle zu analysieren und abzurufen. In Bezug auf REST APIs ähnelt dies der `GET` Operation. Der Hauptvorteil von GraphQL-Abfragen ist die Möglichkeit, die genauen Datenanforderungen Ihrer Anwendung zu spezifizieren, sodass Sie die relevanten Daten zur richtigen Zeit abrufen. **Um Ihre Datenquelle abzufragen** 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. Erweitern Sie auf der **Explorer-Registerkarte** links neben der Tabelle unter `query` `listTodos` den `getTodo` Vorgang: ![\[Expanded getTodo operation showing fields id, description, name, when, and where.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-4.png) 1. Im Code-Editor sollten Sie den Operationscode sehen: ``` query listTodos { getTodo(id: "") { description id name when where } ``` Geben Sie im Feld den Wert ein, den Sie im Ergebnis der Mutationsoperation gespeichert haben. `(id:"")` In unserem Beispiel wäre das: ``` query listTodos { getTodo(id: "abcdefgh-1234-1234-1234-abcdefghijkl") { description id name when where } ``` 1. Wählen Sie **Run** und dann **ListToDos**. Das Ergebnis wird rechts neben dem Editor angezeigt. Unser Beispiel sah so aus: ``` { "data": { "getTodo": { "description": "I need to buy eggs", "id": "abcdefgh-1234-1234-1234-abcdefghijkl", "name": "Shopping List", "when": "Friday", "where": "Home" } } } ``` **Anmerkung** Abfragen geben nur die von Ihnen angegebenen Felder zurück. Sie können die Felder, die Sie nicht benötigen, abwählen, indem Sie sie aus dem Rückgabefeld löschen: ``` { description id name when where } ``` Sie können auch das Kontrollkästchen auf der Registerkarte **Explorer** neben dem Feld, das Sie löschen möchten, deaktivieren. 1. Sie können den `listTodos` Vorgang auch ausprobieren, indem Sie die Schritte zum Erstellen eines Eintrags in Ihrer Datenquelle wiederholen und dann die Abfrageschritte mit dem `listTodos` Vorgang wiederholen. Hier ist ein Beispiel, in dem wir eine zweite Aufgabe hinzugefügt haben: ``` { "createtodoinput": { "name": "Second Task", "when": "Monday", "where": "Home", "description": "I need to mow the lawn" } } ``` Durch den Aufruf der `listTodos` Operation wurden sowohl die alten als auch die neuen Einträge zurückgegeben: ``` { "data": { "listTodos": { "items": [ { "id": "abcdefgh-1234-1234-1234-abcdefghijkl", "name": "Shopping List", "when": "Friday", "where": "Home", "description": "I need to buy eggs" }, { "id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", "name": "Second Task", "when": "Monday", "where": "Home", "description": "I need to mow the lawn" } ] } } } ``` # Zusätzliche Abschnitte für die Konsole AWS AppSync Diese Abschnitte dienen als Referenz für weiterführende AWS AppSync Themen. Wir empfehlen, den Abschnitt *Zusätzliche Lektüre zu lesen*, bevor Sie etwas anderes tun. ## Integration Wenn Sie auf der Registerkarte „Konsole“ den Namen Ihrer API wählen, wird die **Integrationsseite** angezeigt: ![\[AWS AppSync sidebar menu with APIs, Todo API highlighted, and other options listed.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/explorer-example-6.png) Sie fasst die Schritte zur Einrichtung Ihrer API zusammen und beschreibt die nächsten Schritte zum Erstellen einer Client-Anwendung. Der Abschnitt In **Ihre App integrieren** enthält Informationen zur Verwendung der [AWS Amplify-Toolchain](https://aws-amplify.github.io/), um den Prozess der Verbindung Ihrer API mit iOS, Android und JavaScript Anwendungen durch Konfiguration und Codegenerierung zu automatisieren. Die Amplify-Toolchain bietet volle Unterstützung für die Erstellung von Projekten von Ihrer lokalen Workstation aus, einschließlich GraphQL-Bereitstellung und Workflows für CI/CD. Im Abschnitt **Client-Beispiele** sind auch Beispiel-Clientanwendungen (z. B. iOS JavaScript, Android) zum Testen einer end-to-end Erfahrung aufgeführt. Sie können diese Beispiele klonen und herunterladen. Die Konfigurationsdatei enthält die erforderlichen Informationen (z. B. Ihre Endpunkt-URL), die Sie für den Einstieg benötigen. Folgen Sie den Anweisungen auf der [AWS Amplify Toolchain-Seite](https://aws-amplify.github.io/), um Ihre App auszuführen. ## Zusätzliche Lektüre + [GraphQL APIs entwerfen mit AWS AppSync](designing-a-graphql-api.md)- Dies ist ein umfassender Leitfaden für die Erstellung Ihres GraphQL mit einem leeren Schema ohne Datenquellen oder Resolver.