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.
# Resolver konfigurieren in AWS AppSync
In den vorherigen Abschnitten haben Sie gelernt, wie Sie Ihr GraphQL-Schema und Ihre Datenquelle erstellen und diese dann im AWS AppSync Service miteinander verknüpft haben. In Ihrem Schema haben Sie möglicherweise ein oder mehrere Felder (Operationen) in Ihrer Abfrage und Mutation eingerichtet. Das Schema beschrieb zwar die Arten von Daten, die die Operationen von der Datenquelle anfordern würden, es wurde jedoch nie implementiert, wie sich diese Operationen in Bezug auf die Daten verhalten würden.
Das Verhalten einer Operation wird immer im Resolver implementiert, der mit dem Feld verknüpft wird, das die Operation ausführt. Weitere Informationen zur Funktionsweise von Resolvern im Allgemeinen finden Sie auf der [Resolver-Seite](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html).
In AWS AppSync ist Ihr Resolver an eine Runtime gebunden, das ist die Umgebung, in der Ihr Resolver ausgeführt wird. Laufzeiten bestimmen die Sprache, in der Ihr Resolver geschrieben wird. Derzeit werden zwei Laufzeiten unterstützt: APPSYNC\$1JS (JavaScript) und Apache Velocity Template Language (VTL).
Bei der Implementierung von Resolvern gibt es eine allgemeine Struktur, der sie folgen:
+ **Schritt vor dem**: Wenn eine Anfrage vom Client gestellt wird, werden den Resolvern für die verwendeten Schemafelder (normalerweise Ihre Abfragen, Mutationen, Abonnements) die Anforderungsdaten übergeben. Der Resolver beginnt mit der Verarbeitung der Anforderungsdaten mit einem Before-Step-Handler, der es ermöglicht, einige Vorverarbeitungsvorgänge durchzuführen, bevor die Daten den Resolver passieren.
+ **Funktion (en)**: Nachdem der vorherige Schritt ausgeführt wurde, wird die Anforderung an die Funktionsliste übergeben. Die erste Funktion in der Liste wird für die Datenquelle ausgeführt. Eine Funktion ist eine Teilmenge des Codes Ihres Resolvers, die einen eigenen Anfrage- und Antworthandler enthält. Ein Anforderungshandler nimmt die Anforderungsdaten und führt Operationen an der Datenquelle durch. Der Antworthandler verarbeitet die Antwort der Datenquelle, bevor er sie an die Liste zurückgibt. Wenn es mehr als eine Funktion gibt, werden die Anforderungsdaten zur Ausführung an die nächste Funktion in der Liste gesendet. Die Funktionen in der Liste werden seriell in der vom Entwickler festgelegten Reihenfolge ausgeführt. Sobald alle Funktionen ausgeführt wurden, wird das Endergebnis an den nächsten Schritt übergeben.
+ **Nach dem Schritt**: Der Nachschritt ist eine Handler-Funktion, mit der Sie einige letzte Operationen an der Antwort der endgültigen Funktion ausführen können, bevor Sie sie an die GraphQL-Antwort übergeben.
Dieser Flow ist ein Beispiel für einen Pipeline-Resolver. Pipeline-Resolver werden in beiden Laufzeiten unterstützt. Dies ist jedoch eine vereinfachte Erklärung dessen, was Pipeline-Resolver leisten können. Außerdem beschreiben wir nur eine mögliche Resolver-Konfiguration. [Weitere Informationen zu unterstützten Resolver-Konfigurationen finden Sie in der [Resolver-Übersicht für APPSYNC\$1JS oder in der Übersicht über JavaScript Resolver-Mapping-Vorlagen](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) für VTL.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html)
Wie Sie sehen können, sind Resolver modular aufgebaut. Damit die Komponenten des Resolvers ordnungsgemäß funktionieren, müssen sie in der Lage sein, von anderen Komponenten aus auf den Status der Ausführung zuzugreifen. Aus dem Abschnitt [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) wissen Sie, dass jeder Komponente im Resolver wichtige Informationen über den Status der Ausführung als Satz von Argumenten (`args``context`, usw.) übergeben werden können. Darin wird AWS AppSync dies ausschließlich von der abgewickelt. `context` Es ist ein Container für die Informationen über das Feld, das aufgelöst wird. Dies kann alles beinhalten, von übergebenen Argumenten über Ergebnisse bis hin zu Autorisierungsdaten, Header-Daten usw. Weitere Informationen zum Kontext finden Sie in der [Resolver-Kontext-Objektreferenz für APPSYNC\$1JS oder in der Kontextreferenz](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) für [Resolver-Mapping-Vorlagen](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html) für VTL.
Der Kontext ist nicht das einzige Tool, mit dem Sie Ihren Resolver implementieren können. AWS AppSync unterstützt eine Vielzahl von Hilfsprogrammen für die Wertgenerierung, Fehlerbehandlung, Analyse, Konvertierung usw. [Eine Liste der Dienstprogramme finden Sie [hier](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) für APPSYNC\$1JS oder hier für VTL.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference.html)
In den folgenden Abschnitten erfahren Sie, wie Sie Resolver in Ihrer GraphQL-API konfigurieren.
**Topics**
+ [Einfache Abfragen erstellen (JavaScript)](configuring-resolvers-js.md)
+ [Basisabfragen erstellen (VTL)](configuring-resolvers.md)
# Einfache Abfragen erstellen (JavaScript)
GraphQL-Resolver verbinden die Felder in einem Schema mit einer Datenquelle. Resolver sind der Mechanismus, mit dem Anfragen erfüllt werden.
Resolver, die AWS AppSync verwendet werden JavaScript , um einen GraphQL-Ausdruck in ein Format zu konvertieren, das die Datenquelle verwenden kann. Alternativ können Mapping-Vorlagen in [Apache Velocity Template Language (VTL)](https://velocity.apache.org/engine/2.0/vtl-reference.html) geschrieben werden, um einen GraphQL-Ausdruck in ein Format zu konvertieren, das die Datenquelle verwenden kann.
In diesem Abschnitt wird beschrieben, wie Resolver mithilfe von konfiguriert werden. JavaScript Der Abschnitt [Resolver-Tutorials (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) enthält ausführliche Anleitungen zur Implementierung von Resolvern mithilfe von. JavaScript Der Abschnitt [Resolver-Referenz (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) enthält eine Erläuterung der Hilfsoperationen, die mit Resolvern verwendet werden können. JavaScript
Wir empfehlen, diese Anleitung zu befolgen, bevor Sie versuchen, eines der oben genannten Tutorials zu verwenden.
In diesem Abschnitt werden wir uns mit der Erstellung und Konfiguration von Resolvern für Abfragen und Mutationen befassen.
**Anmerkung**
In diesem Handbuch wird davon ausgegangen, dass Sie Ihr Schema erstellt haben und mindestens eine Abfrage oder Mutation haben. Wenn Sie nach Abonnements (Echtzeitdaten) suchen, lesen Sie [diese](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html) Anleitung.
In diesem Abschnitt finden Sie einige allgemeine Schritte zur Konfiguration von Resolvern sowie ein Beispiel, das das folgende Schema verwendet:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Einfache Abfragerolver erstellen
In diesem Abschnitt erfahren Sie, wie Sie einen einfachen Abfrageauflöser erstellen.
------
#### [ Console ]
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSyncKonsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. **Wählen Sie in der **Seitenleiste** Schema aus.**
1. Geben Sie die Details Ihres Schemas und Ihrer Datenquelle ein. Weitere Informationen finden Sie in den Abschnitten [Entwerfen Ihres Schemas](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) und [Anhängen einer Datenquelle](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Neben dem **Schema-Editor** befindet sich ein Fenster mit dem Namen **Resolvers**. Dieses Feld enthält eine Liste der Typen und Felder, wie sie in Ihrem **Schemafenster** definiert sind. Sie können Resolver an Felder anhängen. Höchstwahrscheinlich werden Sie Resolver an Ihre Feldoperationen anhängen. In diesem Abschnitt werden wir uns einfache Abfragekonfigurationen ansehen. Wählen Sie unter dem **Abfragetyp** neben dem Feld Ihrer Abfrage die Option **Anhängen** aus.
1. Auf der Seite **Resolver anhängen** können Sie unter **Resolvertyp** zwischen Pipeline- und Unit-Resolvern wählen. [Weitere Informationen zu diesen Typen finden Sie unter Resolver.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) In diesem Handbuch werden verwendet. `pipeline resolvers`
**Tipp**
Bei der Erstellung von Pipeline-Resolvern werden Ihre Datenquellen an die Pipeline-Funktion (en) angehängt. Funktionen werden erstellt, nachdem Sie den Pipeline-Resolver selbst erstellt haben. Aus diesem Grund gibt es auf dieser Seite keine Option, sie festzulegen. Wenn Sie einen Unit-Resolver verwenden, ist die Datenquelle direkt mit dem Resolver verknüpft, sodass Sie sie auf dieser Seite einstellen würden.
Wählen Sie für die **Resolver-Runtime**, ob Sie `APPSYNC_JS` die Laufzeit aktivieren möchten. JavaScript
1. Sie können das [Caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) für diese API aktivieren. Wir empfehlen, diese Funktion vorerst auszuschalten. Wählen Sie **Erstellen** aus.
1. Auf der Seite **Resolver bearbeiten** gibt es einen Code-Editor namens **Resolver-Code**, mit dem Sie die Logik für den Resolver-Handler und die Antwort (vor und nach den Schritten) implementieren können. [Weitere Informationen finden Sie in der Übersicht über die JavaScript Resolver.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
**Anmerkung**
In unserem Beispiel lassen wir die Anfrage einfach leer und die Antwort wird so eingestellt, dass sie das letzte Datenquellenergebnis aus dem [Kontext](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) zurückgibt:
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Unterhalb dieses Abschnitts befindet sich eine Tabelle mit dem Namen **Functions**. Mit Funktionen können Sie Code implementieren, der für mehrere Resolver wiederverwendet werden kann. Anstatt Code ständig neu zu schreiben oder zu kopieren, können Sie den Quellcode als Funktion speichern, die Sie einem Resolver hinzufügen können, wann immer Sie ihn benötigen.
Funktionen machen den Großteil der Operationsliste einer Pipeline aus. Wenn Sie mehrere Funktionen in einem Resolver verwenden, legen Sie die Reihenfolge der Funktionen fest, und sie werden nacheinander in dieser Reihenfolge ausgeführt. Sie werden ausgeführt, nachdem die Anforderungsfunktion ausgeführt wurde und bevor die Antwortfunktion beginnt.
Um eine neue Funktion hinzuzufügen, wählen Sie unter **Funktionen** die Option **Funktion hinzufügen** und dann **Neue Funktion erstellen** aus. Alternativ wird Ihnen möglicherweise die Schaltfläche **Funktion erstellen** angezeigt, aus der Sie stattdessen auswählen können.
1. Wählen Sie eine Datenquelle aus. Dies wird die Datenquelle sein, auf die der Resolver reagiert.
**Anmerkung**
In unserem Beispiel hängen wir einen Resolver für an`getPost`, der ein Objekt von abruft. `Post` `id` Nehmen wir an, wir haben bereits eine DynamoDB-Tabelle für dieses Schema eingerichtet. Ihr Partitionsschlüssel ist auf „gesetzt“ `id` und leer.
1. Geben Sie ein`Function name`.
1. Unter **Funktionscode** müssen Sie das Verhalten der Funktion implementieren. Das mag verwirrend sein, aber jede Funktion wird ihren eigenen lokalen Anfrage- und Antworthandler haben. Die Anforderung wird ausgeführt, dann erfolgt der Datenquellenaufruf, um die Anfrage zu bearbeiten, und dann wird die Datenquellenantwort vom Antworthandler verarbeitet. Das Ergebnis wird im [Kontextobjekt](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) gespeichert. Danach wird die nächste Funktion in der Liste ausgeführt oder an den Antworthandler nach dem Schritt übergeben, falls es sich um die letzte handelt.
**Anmerkung**
In unserem Beispiel hängen wir einen Resolver an`getPost`, der eine Liste von `Post` Objekten aus der Datenquelle erhält. Unsere Anforderungsfunktion fordert die Daten aus unserer Tabelle an, die Tabelle leitet ihre Antwort an den Kontext weiter (ctx), dann gibt die Antwort das Ergebnis im Kontext zurück. AWS AppSync Die Stärke liegt in der Vernetzung mit anderen Diensten. AWS Da wir DynamoDB verwenden, verfügen wir über eine [Reihe von Operationen](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html), um solche Dinge zu vereinfachen. Wir haben auch einige Standardbeispiele für andere Datenquellentypen.
Unser Code wird so aussehen:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
In diesem Schritt haben wir zwei Funktionen hinzugefügt:
`request`: Der Anforderungshandler führt den Abrufvorgang für die Datenquelle aus. Das Argument enthält das Kontextobjekt (`ctx`) oder einige Daten, die allen Resolvern zur Verfügung stehen, die eine bestimmte Operation ausführen. Es kann beispielsweise Autorisierungsdaten, die aufgelösten Feldnamen usw. enthalten. Die Return-Anweisung führt eine [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)Operation aus (Beispiele finden Sie [hier](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html)). Da wir mit DynamoDB arbeiten, dürfen wir einige der Operationen dieses Dienstes verwenden. Der Scan führt einen einfachen Abruf aller Elemente in unserer Tabelle durch. Das Ergebnis dieser Operation wird im Kontextobjekt als `result` Container gespeichert, bevor es an den Antworthandler übergeben wird. Das `request` wird vor der Antwort in der Pipeline ausgeführt.
`response`: Der Antworthandler, der die Ausgabe von zurückgibt`request`. Das Argument ist das aktualisierte Kontextobjekt und die Rückgabeanweisung ist`ctx.prev.result`. Zu diesem Zeitpunkt in der Anleitung sind Sie mit diesem Wert möglicherweise noch nicht vertraut. `ctx`bezieht sich auf das Kontextobjekt. `prev`bezieht sich auf die vorherige Operation in der Pipeline, die unsere war`request`. Der `result` enthält die Ergebnisse des Resolvers, während er sich durch die Pipeline bewegt. Wenn Sie alles zusammenfügen, `ctx.prev.result` wird das Ergebnis der letzten ausgeführten Operation zurückgegeben, bei der es sich um den Request-Handler handelte.
1. Wenn Sie fertig sind, wählen Sie **Create**.
1. Zurück auf dem Resolver-Bildschirm wählen Sie unter **Funktionen** das Drop-down-Menü **Funktion hinzufügen** und fügen Sie Ihre Funktion zu Ihrer Funktionsliste hinzu.
1. Wählen Sie **Speichern**, um den Resolver zu aktualisieren.
------
#### [ CLI ]
**Um Ihre Funktion hinzuzufügen**
+ Erstellen Sie mit dem `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)` Befehl eine Funktion für Ihren Pipeline-Resolver.
Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Die `name` der Funktion in der AWS AppSync Konsole.
1. Der oder der Name der Datenquelle`data-source-name`, die die Funktion verwenden wird. Es muss bereits erstellt und mit Ihrer GraphQL-API im AWS AppSync Service verknüpft sein.
1. Die `runtime` oder Umgebung und die Sprache der Funktion. Für JavaScript muss `APPSYNC_JS` der Name und die Laufzeit, lauten`1.0.0`.
1. Die `code` oder Request- und Response-Handler Ihrer Funktion. Sie können es zwar manuell eingeben, es ist jedoch viel einfacher, es einer TXT-Datei (oder einem ähnlichen Format) hinzuzufügen und es dann als Argument zu übergeben.
**Anmerkung**
Unser Abfragecode wird in einer Datei gespeichert, die als Argument übergeben wird:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**Anmerkung**
Stellen Sie sicher, dass Sie `functionId` irgendwo aufzeichnen, da dies verwendet wird, um die Funktion an den Resolver anzuhängen.
**Um deinen Resolver zu erstellen**
+ Erstellen Sie eine Pipeline-Funktion für, `Query` indem Sie den `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` Befehl ausführen.
Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Der `type-name` oder der spezielle Objekttyp in Ihrem Schema (Query, Mutation, Subscription).
1. Die `field-name` oder die Feldoperation innerhalb des speziellen Objekttyps, an den Sie den Resolver anhängen möchten.
1. Der`kind`, der einen Units- oder Pipeline-Resolver angibt. Stellen Sie diesen Wert auf ein, `PIPELINE` um Pipeline-Funktionen zu aktivieren.
1. Die oder die Funktion (en)`pipeline-config`, die an den Resolver angehängt werden sollen. Stellen Sie sicher, dass Sie die `functionId` Werte Ihrer Funktionen kennen. Die Reihenfolge der Auflistung ist wichtig.
1. Das`runtime`, was war `APPSYNC_JS` (JavaScript). Das ist `runtimeVersion` derzeit`1.0.0`.
1. Der`code`, der die Vorher- und Nachher-Schritthandler enthält.
**Anmerkung**
Unser Abfragecode wird in einer Datei gespeichert, die als Argument übergeben wird:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tipp**
Bevor Sie das CDK verwenden, empfehlen wir, die [offizielle Dokumentation](https://docs.aws.amazon.com/cdk/v2/guide/home.html) des CDK zusammen mit der [CDK-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html) zu AWS AppSync lesen.
Die unten aufgeführten Schritte zeigen nur ein allgemeines Beispiel für das Snippet, das zum Hinzufügen einer bestimmten Ressource verwendet wurde. Dies soll **keine** funktionierende Lösung in Ihrem Produktionscode sein. Wir gehen auch davon aus, dass Sie bereits eine funktionierende App haben.
Eine Basis-App benötigt die folgenden Dinge:
1. Richtlinien für den Import von Diensten
1. Schemacode
1. Datenquellengenerator
1. Funktionscode
1. Resolver-Code
Aus den Abschnitten [Entwerfen Ihres Schemas](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) und [Anhängen einer Datenquelle](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) wissen wir, dass die Stack-Datei die Importanweisungen des Formulars enthalten wird:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**Anmerkung**
In den vorherigen Abschnitten haben wir nur erklärt, wie AWS AppSync Konstrukte importiert werden. In echtem Code müssen Sie mehr Dienste importieren, nur um die App auszuführen. Wenn wir in unserem Beispiel eine sehr einfache CDK-App erstellen würden, würden wir zumindest den AWS AppSync Service zusammen mit unserer Datenquelle importieren, bei der es sich um eine DynamoDB-Tabelle handelt. Wir müssten auch einige zusätzliche Konstrukte importieren, um die App bereitzustellen:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Um jedes dieser Dinge zusammenzufassen:
`import * as cdk from 'aws-cdk-lib';`: Auf diese Weise können Sie Ihre CDK-App und Konstrukte wie den Stack definieren. Es enthält auch einige nützliche Hilfsfunktionen für unsere Anwendung, wie z. B. die Manipulation von Metadaten. Wenn Sie mit dieser Importdirektive vertraut sind, sich aber fragen, warum die CDK-Kernbibliothek hier nicht verwendet wird, lesen Sie die [Migrationsseite](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: Dadurch wird der [AWS AppSync Dienst](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html) importiert.
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: Dadurch wird der [DynamoDB-Dienst](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html) importiert.
`import { Construct } from 'constructs';`[: Wir benötigen das, um das Root-Konstrukt zu definieren.](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html)
Die Art des Imports hängt von den Diensten ab, die Sie aufrufen. Wir empfehlen, in der CDK-Dokumentation nach Beispielen zu suchen. Das Schema oben auf der Seite wird eine separate Datei in Ihrer CDK-App als `.graphql` Datei sein. In der Stack-Datei können wir sie mit einem neuen GraphQL verknüpfen, indem wir das folgende Formular verwenden:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**Anmerkung**
In diesem Bereich `add_api` fügen wir eine neue GraphQL-API hinzu, die das `new` Schlüsselwort gefolgt von `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` verwendet. Unser Geltungsbereich lautet`this`, die CFN-ID lautet`graphQL-example`, und unsere Requisiten sind `my-first-api` (Name der API in der Konsole) und `schema.graphql` (der absolute Pfad zur Schemadatei).
Um eine Datenquelle hinzuzufügen, müssen Sie zuerst Ihre Datenquelle zum Stack hinzufügen. Anschließend müssen Sie es mithilfe der quellenspezifischen Methode mit der GraphQL-API verknüpfen. Die Zuordnung erfolgt, wenn Sie Ihren Resolver zum Laufen bringen. Lassen Sie uns in der Zwischenzeit ein Beispiel verwenden, indem wir die DynamoDB-Tabelle wie folgt erstellen: `dynamodb.Table`
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**Anmerkung**
Wenn wir dies in unserem Beispiel verwenden würden, würden wir eine neue DynamoDB-Tabelle mit der CFN-ID von `posts-table` und dem Partitionsschlüssel von hinzufügen. `id (S)`
Als Nächstes müssen wir unseren Resolver in der Stack-Datei implementieren. Hier ist ein Beispiel für eine einfache Abfrage, die nach allen Elementen in einer DynamoDB-Tabelle sucht:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**Anmerkung**
Zuerst haben wir eine Funktion namens erstellt. `add_func` Diese Reihenfolge der Erstellung mag etwas kontraintuitiv erscheinen, aber Sie müssen die Funktionen in Ihrem Pipeline-Resolver erstellen, bevor Sie den Resolver selbst erstellen. Eine Funktion folgt der Form:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Unser Anwendungsbereich war`this`, unsere CFN-ID war`func-get-posts`, und unsere Requisiten enthielten die tatsächlichen Funktionsdetails. Zu den Requisiten gehörten:
Die Funktion, die in `name` der AWS AppSync Konsole vorhanden sein wird (`get_posts_func_1`).
Die GraphQL-API, die wir zuvor erstellt haben (`add_api`).
Die Datenquelle; dies ist der Punkt, an dem wir die Datenquelle mit dem GraphQL-API-Wert verknüpfen und ihn dann an die Funktion anhängen. Wir nehmen die Tabelle, die wir erstellt haben (`add_ddb_table`) und hängen sie mit einer der `GraphqlApi` Methoden (`add_api`) an die GraphQL-API ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)) an. Der ID-Wert (`table-for-posts`) ist der Name der Datenquelle in der AWS AppSync Konsole. Eine Liste quellenspezifischer Methoden finden Sie auf den folgenden Seiten:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
Der Code enthält die Request- und Response-Handler unserer Funktion, was ein einfaches Scannen und Zurückgeben ist.
Die Laufzeit gibt an, dass wir die APPSYNC\$1JS-Laufzeitversion 1.0.0 verwenden möchten. Beachten Sie, dass dies derzeit die einzige Version ist, die für APPSYNC\$1JS verfügbar ist.
Als Nächstes müssen wir die Funktion an den Pipeline-Resolver anhängen. Wir haben unseren Resolver mit der folgenden Form erstellt:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Unser Umfang war`this`, unsere CFN-ID war`pipeline-resolver-get-posts`, und unsere Requisiten enthielten die tatsächlichen Funktionsdetails. Zu den Requisiten gehörten:
Die GraphQL-API, die wir zuvor erstellt haben (`add_api`).
Der Name des speziellen Objekttyps; dies ist eine Abfrageoperation, also haben wir einfach den Wert `Query` hinzugefügt.
Der Feldname (`getPost`) ist der Name des Felds im Schema unter dem `Query` Typ.
Der Code enthält Ihre Vorher- und Nachher-Handler. Unser Beispiel gibt nur die Ergebnisse zurück, die sich im Kontext befanden, nachdem die Funktion ihre Operation ausgeführt hat.
Die Laufzeit gibt an, dass wir die APPSYNC\$1JS-Laufzeitversion 1.0.0 verwenden möchten. Beachten Sie, dass dies derzeit die einzige Version ist, die für APPSYNC\$1JS verfügbar ist.
Die Pipeline-Konfiguration enthält den Verweis auf die von uns erstellte Funktion (). `add_func`
------
Um zusammenzufassen, was in diesem Beispiel passiert ist: Sie haben eine AWS AppSync Funktion gesehen, die einen Anfrage- und Antworthandler implementiert hat. Die Funktion war für die Interaktion mit Ihrer Datenquelle verantwortlich. Der Anforderungshandler hat eine `Scan` Operation an gesendet und ihm mitgeteilt AWS AppSync, welche Operation mit Ihrer DynamoDB-Datenquelle ausgeführt werden soll. Der Antworthandler hat die Liste der Elemente () zurückgegeben. `ctx.result.items` Die Liste der Elemente wurde dann automatisch dem `Post` GraphQL-Typ zugeordnet.
## Erstellung grundlegender Mutationslöser
In diesem Abschnitt erfahren Sie, wie Sie einen einfachen Mutationslöser erstellen.
------
#### [ Console ]
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSyncKonsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. **Wählen Sie in der **Seitenleiste** Schema aus.**
1. Wählen Sie unter dem Abschnitt **Resolver** und dem **Mutationstyp** neben Ihrem Feld die Option **Anhängen** aus.
**Anmerkung**
In unserem Beispiel hängen wir einen Resolver für an`createPost`, der unserer Tabelle ein `Post` Objekt hinzufügt. Nehmen wir an, wir verwenden dieselbe DynamoDB-Tabelle aus dem letzten Abschnitt. Ihr Partitionsschlüssel ist auf „gesetzt“ `id` und leer.
1. Wählen Sie auf der Seite **Attach Resolver** unter **Resolver-Typ** die Option. `pipeline resolvers` [Zur Erinnerung: Weitere Informationen zu Resolvern finden Sie hier.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Wählen Sie für **Resolver Runtime** aus, ob Sie `APPSYNC_JS` die Laufzeit aktivieren möchten. JavaScript
1. Sie können das [Caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) für diese API aktivieren. Wir empfehlen, diese Funktion vorerst auszuschalten. Wählen Sie **Erstellen** aus.
1. Wähle „**Funktion hinzufügen**“ und dann „**Neue Funktion erstellen**“. Alternativ wird Ihnen möglicherweise die Schaltfläche **Funktion erstellen** angezeigt, aus der Sie stattdessen auswählen können.
1. Wählen Sie Ihre -Datenquelle aus. Dies sollte die Quelle sein, deren Daten Sie mit der Mutation manipulieren werden.
1. Geben Sie ein`Function name`.
1. Unter **Funktionscode** müssen Sie das Verhalten der Funktion implementieren. Da es sich um eine Mutation handelt, führt die Anfrage idealerweise einen Vorgang zur Änderung des Zustands an der aufgerufenen Datenquelle durch. Das Ergebnis wird von der Antwortfunktion verarbeitet.
**Anmerkung**
`createPost`fügt der Tabelle ein neues `Post` hinzu oder „fügt“ es mit unseren Parametern als Daten ein. Wir könnten so etwas hinzufügen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
In diesem Schritt haben wir `request` auch `response` Funktionen hinzugefügt:
`request`: Der Request-Handler akzeptiert den Kontext als Argument. Die Return-Anweisung des Request-Handlers führt einen [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)Befehl aus, bei dem es sich um einen integrierten DynamoDB-Vorgang handelt (Beispiele finden Sie [hier](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) [oder hier](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)). Der `PutItem` Befehl fügt unserer DynamoDB-Tabelle ein `Post` Objekt hinzu, indem er den `key` Partitionswert (automatisch generiert von`util.autoid()`) und `attributes` die Eingabe des Kontextarguments verwendet (dies sind die Werte, die wir in unserer Anfrage übergeben werden). Die `key` Feldargumente `attributes` sind `id` und sind die `date` `title` Feldargumente. Sie sind beide über den [https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)Helper vorformatiert, um mit der DynamoDB-Tabelle zu arbeiten.
`response`: Die Antwort akzeptiert den aktualisierten Kontext und gibt das Ergebnis des Request-Handlers zurück.
1. Wählen Sie **Create**, wenn Sie fertig sind.
1. Zurück auf dem Resolver-Bildschirm wählen Sie unter **Funktionen** das Drop-down-Menü **Funktion hinzufügen** und fügen Sie Ihre Funktion zu Ihrer Funktionsliste hinzu.
1. Wählen Sie **Speichern**, um den Resolver zu aktualisieren.
------
#### [ CLI ]
**Um Ihre Funktion hinzuzufügen**
+ Erstellen Sie mit dem `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)` Befehl eine Funktion für Ihren Pipeline-Resolver.
Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Die `name` der Funktion in der AWS AppSync Konsole.
1. Der oder der Name der Datenquelle`data-source-name`, die die Funktion verwenden wird. Es muss bereits erstellt und mit Ihrer GraphQL-API im AWS AppSync Service verknüpft sein.
1. Die `runtime` oder Umgebung und die Sprache der Funktion. Für JavaScript muss `APPSYNC_JS` der Name und die Laufzeit, lauten`1.0.0`.
1. Die `code` oder Request- und Response-Handler Ihrer Funktion. Sie können es zwar manuell eingeben, aber es ist viel einfacher, es einer TXT-Datei (oder einem ähnlichen Format) hinzuzufügen und es dann als Argument zu übergeben.
**Anmerkung**
Unser Abfragecode wird sich in einer Datei befinden, die als Argument übergeben wird:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**Anmerkung**
Stellen Sie sicher, dass Sie `functionId` irgendwo aufzeichnen, da dies verwendet wird, um die Funktion an den Resolver anzuhängen.
**Um deinen Resolver zu erstellen**
+ Erstellen Sie eine Pipeline-Funktion für, `Mutation` indem Sie den `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` Befehl ausführen.
Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Der `type-name` oder der spezielle Objekttyp in Ihrem Schema (Query, Mutation, Subscription).
1. Die `field-name` oder die Feldoperation innerhalb des speziellen Objekttyps, an den Sie den Resolver anhängen möchten.
1. Der`kind`, der einen Units- oder Pipeline-Resolver angibt. Stellen Sie diesen Wert auf ein, `PIPELINE` um Pipeline-Funktionen zu aktivieren.
1. Die oder die Funktion (en)`pipeline-config`, die an den Resolver angehängt werden sollen. Stellen Sie sicher, dass Sie die `functionId` Werte Ihrer Funktionen kennen. Die Reihenfolge der Auflistung ist wichtig.
1. Das`runtime`, was war `APPSYNC_JS` (JavaScript). Das ist `runtimeVersion` derzeit`1.0.0`.
1. Der`code`, der den Vorher-Nachher-Schritt enthält.
**Anmerkung**
Unser Abfragecode wird in einer Datei enthalten sein, die als Argument übergeben wird:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tipp**
Bevor Sie das CDK verwenden, empfehlen wir, die [offizielle Dokumentation](https://docs.aws.amazon.com/cdk/v2/guide/home.html) des CDK zusammen mit der [CDK-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html) zu AWS AppSync lesen.
Die unten aufgeführten Schritte zeigen nur ein allgemeines Beispiel für das Snippet, das zum Hinzufügen einer bestimmten Ressource verwendet wurde. Dies soll **keine** funktionierende Lösung in Ihrem Produktionscode sein. Wir gehen auch davon aus, dass Sie bereits eine funktionierende App haben.
+ Um eine Mutation vorzunehmen, können Sie, vorausgesetzt, Sie befinden sich im selben Projekt, diese wie die Abfrage zur Stack-Datei hinzufügen. Hier sind eine modifizierte Funktion und ein modifizierter Resolver für eine Mutation, die der Tabelle eine neue `Post` hinzufügen:
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**Anmerkung**
Da diese Mutation und die Abfrage ähnlich strukturiert sind, erläutern wir nur die Änderungen, die wir vorgenommen haben, um die Mutation vorzunehmen.
In der Funktion haben wir die CFN-ID in `func-add-post` und den Namen in geändert, `add_posts_func_1` um der Tatsache Rechnung zu tragen, dass wir der Tabelle `Posts` etwas hinzufügen. In der Datenquelle haben wir eine neue Zuordnung zu unserer Tabelle (`add_ddb_table`) in der AWS AppSync Konsole vorgenommen, `table-for-posts-2` weil die `addDynamoDbDataSource` Methode dies erfordert. Denken Sie daran, dass diese neue Assoziation immer noch dieselbe Tabelle verwendet, die wir zuvor erstellt haben, aber wir haben jetzt zwei Verbindungen zu ihr in der AWS AppSync Konsole: eine für die Abfrage als `table-for-posts` und eine für die Mutation als`table-for-posts-2`. Der Code wurde dahingehend geändert, dass a hinzugefügt wurde, `Post` indem sein `id` Wert automatisch generiert wurde und die Eingabe eines Kunden für die restlichen Felder akzeptiert wurde.
Im Resolver haben wir den ID-Wert in geändert, `pipeline-resolver-create-posts` um der Tatsache Rechnung zu tragen, dass wir der Tabelle `Posts` etwas hinzufügen. Um die Mutation im Schema widerzuspiegeln, wurde der Typname in`Mutation`, und der Name, `createPost` geändert. Die Pipeline-Konfiguration wurde auf unsere neue Mutationsfunktion eingestellt`add_func_2`.
------
Um zusammenzufassen, was in diesem Beispiel passiert: Konvertiert die in dem `createPost` Feld definierten Argumente AWS AppSync automatisch aus Ihrem GraphQL-Schema in DynamoDB-Operationen. Das Beispiel speichert Datensätze in DynamoDB mit dem Schlüssel von`id`, der automatisch mit unserem `util.autoId()` Helper erstellt wird. Alle anderen Felder, die Sie aus Anfragen in der AWS AppSync Konsole oder auf andere Weise an die Kontextargumente (`ctx.args.input`) übergeben, werden als Attribute der Tabelle gespeichert. Sowohl der Schlüssel als auch die Attribute werden mithilfe des Helpers automatisch einem kompatiblen DynamoDB-Format zugeordnet. `util.dynamodb.toMapValues(values)`
AWS AppSync unterstützt auch Test- und Debug-Workflows für die Bearbeitung von Resolvern. Sie können ein `context` Scheinobjekt verwenden, um den transformierten Wert der Vorlage zu sehen, bevor Sie sie aufrufen. Optional können Sie die vollständige Anfrage an eine Datenquelle interaktiv anzeigen, wenn Sie eine Abfrage ausführen. Weitere Informationen finden Sie unter [Resolver testen und debuggen (JavaScript) und [Überwachen](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring) und Protokollieren](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html).
## Fortgeschrittene Resolver
Wenn Sie dem optionalen Abschnitt zur Paginierung unter [Ihr Schema entwerfen folgen, müssen Sie dennoch Ihren](designing-your-schema.md#aws-appsync-designing-your-schema) Resolver zu Ihrer Anfrage hinzufügen, um die Paginierung nutzen zu können. In unserem Beispiel wurde eine Abfrage-Paginierung verwendet`getPosts`, die aufgerufen wurde, um nur einen Teil der gleichzeitig angeforderten Dinge zurückzugeben. Der Code unseres Resolvers in diesem Feld könnte so aussehen:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
In der Anfrage geben wir den Kontext der Anfrage weiter. Unser `limit` ist*20*, was bedeutet, dass wir `Posts` bei der ersten Abfrage bis zu 20 zurückgeben. Unser `nextToken` Cursor ist auf den ersten `Post` Eintrag in der Datenquelle fixiert. Diese werden an die Argumente übergeben. Die Anfrage führt dann einen Scan von der ersten `Post` bis zur Anzahl der Scanlimits durch. Die Datenquelle speichert das Ergebnis im Kontext, der an die Antwort übergeben wird. Die Antwort gibt den `Posts` abgerufenen Wert zurück und setzt dann den `nextToken` Wert auf den `Post` Eintrag, der direkt hinter dem Grenzwert liegt. Die nächste Anfrage wird gesendet, um genau dasselbe zu tun, aber ab dem Offset direkt nach der ersten Abfrage. Denken Sie daran, dass diese Art von Anfragen sequentiell und nicht parallel ausgeführt werden.
# Resolver in AWS AppSync () testen und debuggen JavaScript
AWS AppSync führt Resolver in einem GraphQL-Feld gegen eine Datenquelle aus. Bei der Arbeit mit Pipeline-Resolvern interagieren Funktionen mit Ihren Datenquellen. Wie in der [Übersicht über JavaScript Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) beschrieben, kommunizieren Funktionen mit Datenquellen, indem sie Anforderungs- und Antworthandler verwenden, die in der Laufzeit geschrieben sind JavaScript und dort ausgeführt werden. `APPSYNC_JS` Auf diese Weise können Sie vor und nach der Kommunikation mit der Datenquelle benutzerdefinierte Logik und Bedingungen bereitstellen.
Um Entwicklern beim Schreiben, Testen und Debuggen dieser Resolver zu helfen, bietet die AWS AppSync Konsole auch Tools zum Erstellen einer GraphQL-Anfrage und -Antwort mit Scheindaten bis hin zum einzelnen Field-Resolver. Darüber hinaus können Sie Abfragen, Mutationen und Abonnements in der AWS AppSync Konsole durchführen und einen detaillierten Protokollstream der gesamten Anfrage von Amazon einsehen CloudWatch. Dies schließt Ergebnisse aus der Datenquelle ein.
## Testen mit Scheindaten
Wenn ein GraphQL-Resolver aufgerufen wird, enthält er ein `context` Objekt, das relevante Informationen über die Anfrage enthält. Dazu gehören Argumente von einem Client, Identitätsinformationen sowie Daten aus dem übergeordneten GraphQL-Feld. Es speichert auch die Ergebnisse aus der Datenquelle, die im Antworthandler verwendet werden können. Weitere Informationen zu dieser Struktur und den verfügbaren Hilfsprogrammen, die beim Programmieren verwendet werden können, finden Sie in der [Resolver-Kontextobjektreferenz.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html)
*Beim Schreiben oder Bearbeiten einer Resolverfunktion können Sie ein Modell- oder *Testkontextobjekt* an den Konsoleneditor übergeben.* Auf diese Weise können Sie sehen, wie sowohl der Anforderungs- als auch der Antworthandler ausgewertet werden, ohne dass es tatsächlich mit einer Datenquelle zu tun hat. Beispiel: Sie können ein `firstname: Shaggy`-Testargument übergeben und sehen, wie es bei der Verwendung von `ctx.args.firstname` in Ihrem Vorlagencode ausgewertet wird. Sie können auch die Auswertung eines Dienstprogramm-Helferobjekts wie `util.autoId()` oder `util.time.nowISO8601()` testen.
### Resolver werden getestet
In diesem Beispiel werden Resolver mithilfe der AWS AppSync Konsole getestet.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSyncKonsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. **Wählen Sie in der **Seitenleiste** Funktionen.**
1. Wählen Sie eine bestehende Funktion aus.
1. Wählen Sie oben auf der Seite „**Funktion aktualisieren**“ die **Option Testkontext** auswählen und anschließend **Neuen Kontext erstellen** aus.
1. Wählen Sie ein Beispielkontextobjekt aus oder füllen Sie die JSON-Datei manuell im Fenster **Testkontext konfigurieren** unten aus.
1. Geben Sie einen **Namen für den Textkontext** ein.
1. Wählen Sie die Schaltfläche **Save (Speichern)** aus.
1. Wählen Sie **Run Test (Test ausführen)**, um den Resolver unter Verwendung dieses Mock-Kontexts auszuwerten.
Ein praktischeres Beispiel: Angenommen, Sie haben eine App, die einen GraphQL-Typ speichert`Dog`, die automatische ID-Generierung für Objekte verwendet und diese in Amazon DynamoDB speichert. Sie möchten auch einige Werte aus den Argumenten einer GraphQL-Mutation schreiben und nur bestimmten Benutzern ermöglichen, eine Antwort zu sehen. Der folgende Ausschnitt zeigt, wie das Schema aussehen könnte:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Sie können eine AWS AppSync Funktion schreiben und sie Ihrem `addDog` Resolver hinzufügen, um die Mutation zu behandeln. Um Ihre AWS AppSync Funktion zu testen, können Sie ein Kontextobjekt wie im folgenden Beispiel auffüllen. Nachstehend werden die Argumente `name` und `age` des Clients verwendet und ein `username` im `identity`-Objekt mit Daten gefüllt:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Sie können Ihre AWS AppSync Funktion mit dem folgenden Code testen:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
Der ausgewertete Anforderungs- und Antworthandler enthält die Daten aus Ihrem Testkontextobjekt und den generierten Wert von`util.autoId()`. Wenn Sie `username` zu einem anderen Wert als `Nadia` ändern, werden die Ergebnisse nicht zurückgegeben, da die Autorisierungsprüfung fehlschlägt. Weitere Informationen zur detaillierten Zugriffskontrolle finden Sie unter [Anwendungsfälle für die Autorisierung](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Testen von Anforderungs- und Antworthandlern mit AWS AppSync APIs
Sie können den `EvaluateCode` API-Befehl verwenden, um Ihren Code aus der Ferne mit simulierten Daten zu testen. Um mit dem Befehl zu beginnen, stellen Sie sicher, dass Sie die `appsync:evaluateMappingCode` Berechtigung zu Ihrer Richtlinie hinzugefügt haben. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Sie können den Befehl nutzen, indem Sie das [AWS CLI](https://aws.amazon.com/cli/)oder verwenden [AWS SDKs](https://aws.amazon.com/tools/). Nehmen wir zum Beispiel das `Dog` Schema und seine AWS AppSync Funktionsanforderungs- und Antworthandler aus dem vorherigen Abschnitt. Speichern Sie den Code mithilfe der CLI auf Ihrer lokalen Station in einer Datei mit dem Namen `code.js` und speichern Sie das `context` Objekt anschließend in einer Datei mit dem Namen`context.json`. Führen Sie in Ihrer Shell den folgenden Befehl aus:
```
$ aws appsync evaluate-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
Die Antwort `evaluationResult` enthält eine, die die von Ihrem Handler zurückgegebene Nutzlast enthält. Es enthält auch ein `logs` Objekt, das die Liste der Protokolle enthält, die von Ihrem Handler während der Auswertung generiert wurden. Auf diese Weise können Sie Ihre Codeausführung einfach debuggen und Informationen zu Ihrer Evaluierung abrufen, um bei der Fehlerbehebung zu helfen. Beispiel:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
Das `evaluationResult` kann als JSON geparst werden, was Folgendes ergibt:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Mit dem SDK können Sie ganz einfach Tests aus Ihrer bevorzugten Testsuite integrieren, um das Verhalten Ihrer Handler zu überprüfen. Wir empfehlen, Tests mit dem [Jest Testing Framework](https://jestjs.io/) zu erstellen, aber jede Testsuite funktioniert. Der folgende Ausschnitt zeigt einen hypothetischen Validierungslauf. Beachten Sie, dass wir davon ausgehen, dass es sich bei der Bewertungsantwort um ein gültiges JSON handelt. Daher verwenden wir diese Methode, `JSON.parse` um JSON aus der Zeichenkettenantwort abzurufen:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Dies führt zu dem folgenden Ergebnis:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
## Debuggen einer Live-Abfrage
Es gibt keinen Ersatz für einen end-to-end Test und eine Protokollierung, um eine Produktionsanwendung zu debuggen. AWS AppSync ermöglicht es Ihnen, Fehler und vollständige Anfragedetails über Amazon zu protokollieren CloudWatch. Darüber hinaus können Sie die AWS AppSync Konsole verwenden, um GraphQL-Abfragen, -Mutationen und -Abonnements zu testen und Protokolldaten für jede Anfrage live zurück in den Abfrage-Editor zu streamen, um sie in Echtzeit zu debuggen. Für Abonnements zeigen die Protokolle Verbindungszeitinformationen an.
Um dies durchzuführen, müssen Sie Amazon CloudWatch Logs im Voraus aktiviert haben, wie unter [Überwachung und Protokollierung](monitoring.md#aws-appsync-monitoring) beschrieben. Wählen Sie als Nächstes in der AWS AppSync Konsole die Registerkarte **Abfragen** und geben Sie dann eine gültige GraphQL-Abfrage ein. Klicken Sie im unteren rechten Bereich auf das **Protokollfenster und ziehen Sie es, um die Protokollansicht** zu öffnen. Wählen Sie oben auf der Seite das Wiedergabe-Pfeilsymbol, um die GraphQL-Abfrage auszuführen. In wenigen Augenblicken werden Ihre vollständigen Anfrage- und Antwortprotokolle für den Vorgang in diesen Bereich gestreamt und Sie können sie in der Konsole einsehen.
# Konfiguration und Verwendung von Pipeline-Resolvern in AWS AppSync () JavaScript
AWS AppSync führt Resolver auf einem GraphQL-Feld aus. In einigen Fällen müssen Anwendungen mehrere Operationen ausführen, um ein einziges GraphQL-Feld aufzulösen. Mit Pipeline-Resolvern können Entwickler jetzt Operationen, sogenannte Funktionen, zusammenstellen und sie nacheinander ausführen. Pipeline-Resolver sind nützlich für Anwendungen, die z. B. eine Autorisierungsprüfung ausführen müssen, bevor sie Daten für ein Feld abrufen.
Weitere Informationen zur Architektur eines JavaScript Pipeline-Resolvers finden Sie in der Übersicht über die [JavaScriptResolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js).
## Schritt 1: Einen Pipeline-Resolver erstellen
Gehen Sie in der AWS AppSync Konsole zur **Schemaseite**.
Speichern Sie das folgende Schema:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
Wir werden einen Pipeline-Resolver an das **signUp**-Feld mit dem Typ der **Mutation** anhängen. Wählen Sie im Bereich **Mutationstyp** auf der rechten Seite neben dem `signUp` Mutationsfeld die Option **Anhängen** aus. Stellen Sie den Resolver auf `pipeline resolver` und die `APPSYNC_JS` Laufzeit ein und erstellen Sie dann den Resolver.
Unser Pipeline-Resolver meldet einen Benutzer an, indem er zuerst die eingegebene E-Mail-Adresse validiert und den Benutzer dann im System speichert. **Wir werden die E-Mail-Validierung in einer **ValidateEmail-Funktion** und das Speichern des Benutzers in einer SaveUser-Funktion kapseln.** Die **validateEmail**-Funktion wird zuerst ausgeführt, und, sofern die E-Mail gültig ist, anschließend die **saveUser**-Funktion.
Der Ausführungsablauf wird wie folgt aussehen:
1. Anforderungshandler für Mutation.SignUp Resolver
1. Funktion validateEmail
1. Funktion saveUser
1. Antworthandler für den Mutation.SignUp-Resolver
Da wir die Funktion **validateEmail** wahrscheinlich in anderen Resolvern auf unserer API wiederverwenden werden, möchten wir den Zugriff vermeiden, `ctx.args` da sich diese von einem GraphQL-Feld zum anderen ändern. Wir können stattdessen `ctx.stash` verwenden, um das E-Mail-Attribut aus dem Eingabefeldargument `signUp(input: Signup)` zu speichern.
Aktualisieren Sie Ihren Resolver-Code, indem Sie Ihre Anfrage- und Antwortfunktionen ersetzen:
```
export function request(ctx) {
ctx.stash.email = ctx.args.input.email
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Wählen Sie **Erstellen** oder **Speichern**, um den Resolver zu aktualisieren.
## Schritt 2: Eine Funktion erstellen
Klicken Sie auf der Pipeline-Resolver-Seite im Abschnitt **Funktionen** auf **Funktion hinzufügen** und dann auf **Neue Funktion erstellen**. Es ist auch möglich, Funktionen zu erstellen, ohne die Resolver-Seite aufrufen zu müssen. Rufen Sie dazu in der AWS AppSync Konsole die Seite **Funktionen** auf. Wählen Sie die Schaltfläche **Create function** (Funktion erstellen). Wir erstellen eine Funktion, die prüft, ob eine E-Mail gültig ist und von einer bestimmten Domäne stammt. Sofern die E-Mail nicht gültig ist, löst die Funktion einen Fehler aus. Andernfalls leitet sie sämtliche Eingaben weiter.
Stellen Sie sicher, dass Sie eine Datenquelle vom Typ **NONE** erstellt haben. Wählen Sie diese Datenquelle in der Liste **Datenquellenname** aus. Geben Sie für den **Funktionsnamen** in ein`validateEmail`. Überschreiben Sie im **Funktionscode-Bereich** alles mit diesem Snippet:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { email } = ctx.stash;
const valid = util.matches(
'^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
email
);
if (!valid) {
util.error(`"${email}" is not a valid email.`);
}
return { payload: { email } };
}
export function response(ctx) {
return ctx.result;
}
```
**Überprüfe deine Eingaben und wähle dann Erstellen.** Wir haben unsere **validateEmail**-Funktion erstellt. Wiederholen Sie diese Schritte, um die **SaveUser-Funktion** mit dem folgenden Code zu erstellen (Der Einfachheit halber verwenden wir eine **NONE-Datenquelle** und tun so, als ob der Benutzer nach der Ausführung der Funktion im System gespeichert wurde. ):
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return ctx.prev.result;
}
export function response(ctx) {
ctx.result.id = util.autoId();
return ctx.result;
}
```
Wir haben gerade unsere **SaveUser-Funktion** erstellt.
## Schritt 3: Hinzufügen einer Funktion zu einem Pipeline-Resolver
Unsere Funktionen hätten automatisch zu dem gerade erstellten Pipeline-Resolver hinzugefügt werden sollen. **Wenn dies nicht der Fall war oder Sie die Funktionen über die Funktionsseite erstellt haben, können Sie auf der `signUp` Resolver-Seite wieder auf **Funktion hinzufügen** klicken, um sie anzuhängen.** Fügen Sie dem Resolver sowohl die Funktionen **validateEmail** als auch **saveUser** hinzu. Die Funktion **validateEmail** muss vor der Funktion **saveUser** platziert werden. Wenn Sie weitere Funktionen hinzufügen, können Sie die Optionen „**Nach oben“ und „Nach** **unten“ verwenden,** um die Reihenfolge der Ausführung Ihrer Funktionen neu zu organisieren. Überprüfen Sie Ihre Änderungen und wählen Sie dann **Speichern**.
## Schritt 4: Eine Abfrage ausführen
Rufen Sie in der AWS AppSync Konsole die Seite **Abfragen** auf. Stellen Sie im Explorer sicher, dass Sie Ihre Mutation verwenden. Wenn nicht, wählen Sie `Mutation` in der Drop-down-Liste und dann`+`. Geben Sie die folgende Abfrage ein:
```
mutation {
signUp(input: {email: "nadia@myvaliddomain.com", username: "nadia"}) {
id
username
}
}
```
Dies sollte etwa Folgendes zurückgeben:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"username": "nadia"
}
}
}
```
Wir haben mit einem Pipeline-Resolver unseren Benutzer erfolgreich angemeldet und die eingegebene E-Mail validiert.
# Basisabfragen erstellen (VTL)
**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/configuring-resolvers-js.html)
GraphQL-Resolver verbinden die Felder in einem Schema mit einer Datenquelle. Resolver sind der Mechanismus, mit dem Anfragen erfüllt werden. AWS AppSync kann Resolver automatisch aus einem Schema erstellen und verbinden oder ein Schema erstellen und Resolver aus einer vorhandenen Tabelle verbinden, ohne dass Sie Code schreiben müssen.
Resolver, die AWS AppSync verwendet werden JavaScript , um einen GraphQL-Ausdruck in ein Format zu konvertieren, das die Datenquelle verwenden kann. Alternativ können Mapping-Vorlagen in [Apache Velocity Template Language (VTL)](https://velocity.apache.org/engine/2.0/vtl-reference.html) geschrieben werden, um einen GraphQL-Ausdruck in ein Format zu konvertieren, das die Datenquelle verwenden kann.
In diesem Abschnitt erfahren Sie, wie Sie Resolver mithilfe von VTL konfigurieren. [Eine einführende Programmieranleitung im Stil eines Tutorials zum Schreiben von Resolvern finden Sie im Programmierhandbuch für [Resolver-Mapping-Vorlagen. Hilfsprogramme, die Sie beim Programmieren](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide) verwenden können, finden Sie in der Kontextreferenz für Resolver-Mapping-Vorlagen.](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync verfügt außerdem über integrierte Test- und Debug-Workflows, die Sie verwenden können, wenn Sie von Grund auf neu bearbeiten oder Inhalte erstellen. Weitere Informationen finden Sie unter Resolver [testen und debuggen](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Wir empfehlen, diese Anleitung zu befolgen, bevor Sie versuchen, eines der oben genannten Tutorials zu verwenden.
In diesem Abschnitt erfahren Sie, wie Sie einen Resolver erstellen, einen Resolver für Mutationen hinzufügen und erweiterte Konfigurationen verwenden.
## Erstellen Sie Ihren ersten Resolver
In Anlehnung an die Beispiele aus den vorherigen Abschnitten besteht der erste Schritt darin, einen Resolver für Ihren `Query` Typ zu erstellen.
------
#### [ Console ]
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** Schema aus.**
1. **Auf der rechten Seite der Seite befindet sich ein Fenster namens Resolvers.** Dieses Feld enthält eine Liste der Typen und Felder, wie sie in Ihrem **Schemafenster** auf der linken Seite der Seite definiert sind. Sie können Resolver an Felder anhängen. Wählen Sie beispielsweise unter dem **Abfragetyp** neben dem `getTodos` Feld die Option **Anhängen** aus.
1. Wählen Sie auf der Seite „**Resolver erstellen**“ die Datenquelle aus, die Sie im Handbuch [Datenquellen anhängen](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) erstellt haben. Im Fenster **Zuordnungsvorlagen konfigurieren** können Sie mithilfe der Dropdownliste auf der rechten Seite sowohl die generischen Vorlagen für die Anfrage als auch die Vorlage für die Antwortzuordnung auswählen oder Ihre eigenen erstellen.
**Anmerkung**
Die Kopplung einer Vorlage für die Zuordnung von Anfragen mit einer Vorlage für die Zuordnung von Antworten wird als Unit-Resolver bezeichnet. Unit-Resolver sind in der Regel für Routineoperationen vorgesehen. Wir empfehlen, sie nur für einzelne Operationen mit einer kleinen Anzahl von Datenquellen zu verwenden. Für komplexere Operationen empfehlen wir die Verwendung von Pipeline-Resolvern, die mehrere Operationen mit mehreren Datenquellen nacheinander ausführen können.
Weitere Informationen zum Unterschied zwischen Vorlagen für die Zuordnung von Anfragen und Antworten finden Sie unter [Unit-Resolver](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Weitere Informationen zur Verwendung von Pipeline-Resolvern finden Sie unter [Pipeline-Resolver](pipeline-resolvers.md#aws-appsync-pipeline-resolvers).
1. Für allgemeine Anwendungsfälle verfügt die AWS AppSync Konsole über integrierte Vorlagen, mit denen Sie Elemente aus Datenquellen abrufen können (z. B. Abfragen aller Elemente, einzelne Suchvorgänge usw.). In der einfachen Version des Schemas aus [Designing your schema](designing-your-schema.md#aws-appsync-designing-your-schema), in der `getTodos` es keine Paginierung gab, sieht die Vorlage für die Anforderungszuweisung zum Auflisten von Elementen beispielsweise wie folgt aus:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Sie benötigen immer eine Vorlage für die Antwortzuweisung, die der Anfrage beiliegt. Die Konsole stellt eine Standardvorlage mit dem folgenden Pass-Through-Wert für Listen bereit:
```
$util.toJson($ctx.result.items)
```
In diesem Beispiel hat das `context`-Objekt (mit dem Alias `$ctx`) für Listen mit Elementen die Form `$context.result.items`. Wenn die GraphQL-Operation ein einzelnes Element zurückgibt, würde es sich um `$context.result` handeln. AWS AppSync stellt Hilfsfunktionen für allgemeine Operationen bereit, z. B. die oben aufgelistete Funktion `$util.toJson`, mit denen die Antworten richtig formatiert werden können. Eine vollständige Liste der Funktionen finden Sie unter [Referenz zum Resolver Mapping Template Utility.](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference)
1. Wählen Sie „**Resolver speichern**“.
------
#### [ API ]
1. Erstellen Sie ein Resolver-Objekt, indem Sie die [https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)API aufrufen.
1. Sie können die Felder Ihres Resolvers ändern, indem Sie die [https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)API aufrufen.
------
#### [ CLI ]
1. Erstellen Sie einen Resolver, indem Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)Befehl ausführen.
Für diesen speziellen Befehl müssen Sie 6 Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Der `type-name` Typ, den Sie in Ihrem Schema ändern möchten. Im Konsolenbeispiel war das`Query`.
1. Das `field-name` Feld, das Sie in Ihrem Typ ändern möchten. Im Konsolenbeispiel war das`getTodos`.
1. Die `data-source-name` der Datenquelle, die Sie im Handbuch [Datenquellen anhängen](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) erstellt haben.
1. Der`request-mapping-template`, welcher der Hauptteil der Anfrage ist. Im Konsolenbeispiel lautete das:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Das`response-mapping-template`, was der Hauptteil der Antwort ist. Im Konsolenbeispiel lautete das:
```
$util.toJson($ctx.result.items)
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Führen Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)Befehl aus, um die Vorlagen für die and/or Feldzuweisung eines Resolvers zu ändern.
Mit Ausnahme des `api-id` Parameters werden die im `create-resolver` Befehl verwendeten Parameter durch die neuen Werte aus dem `update-resolver` Befehl überschrieben.
------
## Einen Resolver für Mutationen hinzufügen
Der nächste Schritt besteht darin, einen Resolver für Ihren `Mutation` Typ zu erstellen.
------
#### [ Console ]
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** Schema aus.**
1. Wählen Sie unter dem **Mutationstyp** neben dem `addTodo` Feld die Option **Anhängen** aus.
1. Wählen Sie auf der Seite „**Resolver erstellen**“ die Datenquelle aus, die Sie im Handbuch [Datenquellen anhängen](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) erstellt haben.
1. Im Fenster **Zuordnungsvorlagen konfigurieren** müssen Sie die Anforderungsvorlage ändern, da es sich um eine Mutation handelt, bei der Sie DynamoDB ein neues Element hinzufügen. Verwenden Sie die folgende Abfrage-Zuweisungsvorlage:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync konvertiert automatisch die im `addTodo` Feld definierten Argumente aus Ihrem GraphQL-Schema in DynamoDB-Operationen. Im vorherigen Beispiel werden Datensätze in DynamoDB mit dem Schlüssel von gespeichert`id`, der vom Mutationsargument as übergeben wird. `$ctx.args.id` Alle anderen Felder, die Sie durchlaufen, werden automatisch DynamoDB-Attributen mit zugeordnet. `$util.dynamodb.toMapValuesJson($ctx.args)`
Verwenden Sie für diesen Resolver die folgende Antwortzuweisungsvorlage:
```
$util.toJson($ctx.result)
```
AWS AppSync unterstützt auch Test- und Debug-Workflows für die Bearbeitung von Resolvern. Sie können ein `context`-Mock-Objekt verwenden, um den transformierten Wert der Vorlage vor dem Aufrufen anzuzeigen. Optional können Sie die vollständige Anforderungsausführung für eine Datenquelle interaktiv anzeigen, während Sie eine Abfrage ausführen. [Weitere Informationen finden Sie unter [Resolver testen und debuggen und Überwachen und Protokollieren](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).](monitoring.md#aws-appsync-monitoring)
1. Wählen Sie „Resolver **speichern**“.
------
#### [ API ]
Sie können dies auch tun, APIs indem Sie die Befehle im Abschnitt [Erstellen Sie Ihren ersten Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) und die Parameterdetails aus diesem Abschnitt verwenden.
------
#### [ CLI ]
Sie können dies auch in der CLI tun, indem Sie die Befehle im Abschnitt [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) und die Parameterdetails aus diesem Abschnitt verwenden.
------
Wenn Sie die erweiterten Resolver nicht verwenden, können Sie zu diesem Zeitpunkt mit der Verwendung Ihrer GraphQL-API beginnen, wie [unter Verwenden Ihrer](using-your-api.md#aws-appsync-using-your-api) API beschrieben.
## Fortgeschrittene Resolver
Wenn Sie dem Abschnitt „Erweitert“ folgen und unter [Entwerfen Ihres Schemas](designing-your-schema.md#aws-appsync-designing-your-schema) für einen paginierten Scan ein Beispielschema erstellen, verwenden Sie stattdessen die folgende Anforderungsvorlage für das `getTodos` Feld:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
In diesem Paginierungsanwendungsfall ist die Antwortzuweisung mehr als nur ein Pass-Through, da sie sowohl den *Cursor* (damit der Kunde weiß, mit welcher Seite das nächste Mal begonnen wird) als auch den Ergebnissatz enthält. Die Zuweisungsvorlage sieht folgendermaßen aus:
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Die Felder in der vorherigen Antwortzuweisungsvorlage sollten mit den in Ihrem `TodoConnection`-Typ definierten Feldern übereinstimmen.
Für Beziehungen, bei denen Sie eine `Comments` Tabelle haben und das Kommentarfeld für den Typ auflösen (was den `Todo` Typ von zurückgibt`[Comment]`), können Sie eine Zuordnungsvorlage verwenden, die eine Abfrage für die zweite Tabelle ausführt. Dazu müssen Sie bereits eine Datenquelle für die `Comments` Tabelle erstellt haben, wie unter Hinzufügen [einer Datenquelle](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch) beschrieben.
**Anmerkung**
Wir verwenden einen Abfragevorgang für eine zweite Tabelle nur zur Veranschaulichung. Sie könnten stattdessen eine andere Operation gegen DynamoDB verwenden. Darüber hinaus könnten Sie die Daten aus einer anderen Datenquelle abrufen, z. B. AWS Lambda aus Amazon OpenSearch Service, da die Beziehung durch Ihr GraphQL-Schema gesteuert wird.
------
#### [ Console ]
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** Schema aus.**
1. Wählen Sie unter dem Typ **Todo** neben dem Feld die `comments` Option **Anhängen** aus.
1. Wählen Sie auf der Seite „**Resolver erstellen**“ die Datenquelle für die Tabelle „**Kommentare**“ aus. Der Standardname für die Tabelle **Kommentare** aus den Schnellstartanleitungen lautet`AppSyncCommentTable`, er kann jedoch variieren, je nachdem, welchen Namen Sie der Tabelle gegeben haben.
1. Fügen Sie Ihrer Vorlage für die Anforderungszuweisung den folgenden Ausschnitt hinzu:
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. `context.source` verweist auf das übergeordnete Objekt des aktuellen Felds, das aufgelöst wird. In diesem Beispiel verweist `source.id` auf das `Todo`-Objekt, das dann für den Abfrageausdruck verwendet wird.
Sie können die Pass-Through-Antwortzuweisungsvorlage folgendermaßen verwenden:
```
$util.toJson($ctx.result.items)
```
1. Wählen Sie „Resolver **speichern**“.
1. Gehen Sie abschließend zurück zur **Schemaseite** in der Konsole, fügen Sie dem `addComment` Feld einen Resolver hinzu und geben Sie die Datenquelle für die `Comments` Tabelle an. Die Anforderungszuweisungsvorlage ist in diesem Fall eine einfache `PutItem`-Anweisung mit der spezifischen `todoid`, die als Argument kommentiert ist, aber Sie verwenden das Dienstprogramm `$utils.autoId()` zum Erstellen eines eindeutigen Sortierschlüssels für den Kommentar:
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Verwenden Sie folgendermaßen eine Pass-Through-Antwortvorlage:
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Sie können dies auch tun, APIs indem Sie die Befehle im Abschnitt [Erstellen Sie Ihren ersten Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) und die Parameterdetails in diesem Abschnitt verwenden.
------
#### [ CLI ]
Sie können dies auch in der CLI tun, indem Sie die Befehle im Abschnitt [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) und die Parameterdetails aus diesem Abschnitt verwenden.
------
# Deaktivieren von VTL-Mapping-Vorlagen mit direkten Lambda-Resolvern (VTL)
**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/configuring-resolvers-js.html)
Mit direkten Lambda-Resolvern können Sie die Verwendung von VTL-Mapping-Vorlagen bei der Verwendung von Datenquellen umgehen. AWS Lambda AWS AppSync kann eine Standardnutzlast für Ihre Lambda-Funktion sowie eine Standardübersetzung aus der Antwort einer Lambda-Funktion auf einen GraphQL-Typ bereitstellen. Sie können wählen, ob Sie eine Anforderungsvorlage, eine Antwortvorlage oder beides bereitstellen möchten, und AWS AppSync werden diese entsprechend behandeln.
Weitere Informationen über die standardmäßige Anforderungsnutzlast und die damit AWS AppSync verbundene Antwortübersetzung finden Sie in der [Direct Lambda Resolver-Referenz](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Weitere Informationen zum Einrichten einer AWS Lambda Datenquelle und zum Einrichten einer IAM-Vertrauensrichtlinie finden Sie unter Eine Datenquelle [anhängen](attaching-a-data-source.md).
## Direkte Lambda-Resolver konfigurieren
In den folgenden Abschnitten erfahren Sie, wie Sie Lambda-Datenquellen anhängen und Lambda-Resolver zu Ihren Feldern hinzufügen.
### Fügen Sie eine Lambda-Datenquelle hinzu
Bevor Sie direkte Lambda-Resolver aktivieren können, müssen Sie eine Lambda-Datenquelle hinzufügen.
------
#### [ Console ]
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 **unter Datenquellenname** einen Namen für Ihre Datenquelle ein, z. B. **myFunction**
1. Wählen Sie als **Datenquellentyp** die Option **AWS Lambda Funktion** aus.
1. Wählen Sie für **Region** die entsprechende Region aus.
1. Wählen Sie für **Function ARN** die Lambda-Funktion aus der Dropdownliste aus. Sie können nach dem Funktionsnamen suchen oder den ARN der Funktion, die Sie verwenden möchten, manuell eingeben.
1. Erstellen Sie eine neue IAM-Rolle (empfohlen) oder wählen Sie eine vorhandene Rolle aus, die über die `lambda:invokeFunction` IAM-Berechtigung verfügt. 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 die Schaltfläche **Erstellen** aus.
------
#### [ CLI ]
1. Erstellen Sie ein Datenquellenobjekt, indem Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html)Befehl ausführen.
Für diesen speziellen Befehl müssen Sie 4 Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Die `name` Ihrer Datenquelle. Im Konsolenbeispiel ist dies der **Name der Datenquelle**.
1. Der `type` Wert der Datenquelle. Im Konsolenbeispiel ist dies eine **AWS Lambda Funktion**.
1. Das`lambda-config`, was die **Funktion ARN** im Konsolenbeispiel ist.
**Anmerkung**
Es gibt andere Parameter wie diesen`Region`, die konfiguriert werden müssen, aber normalerweise werden sie standardmäßig auf Ihre CLI-Konfigurationswerte gesetzt.
Ein Beispielbefehl könnte wie folgt aussehen:
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name myFunction --type AWS_LAMBDA --lambda-config lambdaFunctionArn=arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"dataSource": {
"dataSourceArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/datasources/myFunction",
"type": "AWS_LAMBDA",
"name": "myFunction",
"lambdaConfig": {
"lambdaFunctionArn": "arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example"
}
}
}
```
1. Führen Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html)Befehl aus, um die Attribute einer Datenquelle zu ändern.
Mit Ausnahme des `api-id` Parameters werden die im `create-data-source` Befehl verwendeten Parameter durch die neuen Werte aus dem `update-data-source` Befehl überschrieben.
------
### Direkte Lambda-Resolver aktivieren
Nachdem Sie eine Lambda-Datenquelle erstellt und die entsprechende IAM-Rolle eingerichtet haben, um den Aufruf der Funktion AWS AppSync zu ermöglichen, können Sie sie mit einer Resolver- oder Pipeline-Funktion verknüpfen.
------
#### [ Console ]
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** Schema aus.**
1. Wählen Sie im **Resolver-Fenster** ein Feld oder eine Operation aus und klicken Sie dann auf die Schaltfläche „**Anhängen**“.
1. Wählen Sie auf der Seite **Neuen Resolver erstellen** die Lambda-Funktion aus der Dropdownliste aus.
1. Um direkte Lambda-Resolver zu nutzen, stellen Sie sicher, dass Vorlagen für die Anfrage- und Antwortzuordnung im Abschnitt **Zuordnungsvorlagen konfigurieren** deaktiviert sind.
1. Wählen Sie die Schaltfläche „**Resolver speichern**“.
------
#### [ CLI ]
+ Erstellen Sie einen Resolver, indem Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)Befehl ausführen.
Für diesen speziellen Befehl müssen Sie 6 Parameter eingeben:
1. Die `api-id` Ihrer API.
1. Der `type-name` Typ in Ihrem Schema.
1. Der `field-name` des Felds in Ihrem Schema.
1. Der `data-source-name` oder der Name Ihrer Lambda-Funktion.
1. Der`request-mapping-template`, welcher der Hauptteil der Anfrage ist. Im Konsolenbeispiel wurde dies deaktiviert:
```
" "
```
1. Das`response-mapping-template`, was der Hauptteil der Antwort ist. Im Konsolenbeispiel wurde dies ebenfalls deaktiviert:
```
" "
```
Ein Beispielbefehl könnte so aussehen:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Eine Ausgabe wird in der CLI zurückgegeben. Hier ein Beispiel:
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Wenn Sie Ihre Mapping-Vorlagen deaktivieren, treten mehrere zusätzliche Verhaltensweisen auf in AWS AppSync:
+ Indem Sie eine Zuordnungsvorlage deaktivieren, signalisieren Sie, AWS AppSync dass Sie die in der [Direct Lambda-Resolver-Referenz](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers) angegebenen Standarddatenübersetzungen akzeptieren.
+ [Wenn Sie die Vorlage für die Anforderungszuweisung deaktivieren, erhält Ihre Lambda-Datenquelle eine Nutzlast, die aus dem gesamten Context-Objekt besteht.](resolver-context-reference.md)
+ Wenn Sie die Antwortzuordnungsvorlage deaktivieren, wird das Ergebnis Ihres Lambda-Aufrufs je nach Version der Anforderungszuordnungsvorlage übersetzt oder ob die Anforderungszuordnungsvorlage ebenfalls deaktiviert ist.
# Resolver in AWS AppSync (VTL) testen und debuggen
**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/configuring-resolvers-js.html)
AWS AppSync führt Resolver in einem GraphQL-Feld gegen eine Datenquelle aus. Wie in der [Übersicht über Resolver-Mapping-Vorlagen beschrieben, kommunizieren Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview) mithilfe einer Vorlagensprache mit Datenquellen. Auf diese Weise können Sie das Verhalten anpassen und Logik und Bedingungen vor und nach der Kommunikation mit der Datenquelle anwenden. Eine einführende Programmieranleitung im Stil eines Tutorials zum Schreiben von Resolvern finden Sie im Programmierleitfaden für [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide).
Um Entwicklern beim Schreiben, Testen und Debuggen dieser Resolver zu helfen, bietet die AWS AppSync Konsole auch Tools zum Erstellen einer GraphQL-Anfrage und -Antwort mit Scheindaten bis hin zum einzelnen Field-Resolver. Darüber hinaus können Sie Abfragen, Mutationen und Abonnements in der AWS AppSync Konsole durchführen und einen detaillierten Protokollstream der gesamten Anfrage CloudWatch von Amazon einsehen. Dieser umfasst die Ergebnisse aus einer Datenquelle.
## Testen mit Scheindaten
Wenn ein GraphQL-Resolver aufgerufen wird, enthält er ein `context` Objekt, das Informationen über die Anfrage enthält. Dazu gehören Argumente von einem Client, Identitätsinformationen sowie Daten aus dem übergeordneten GraphQL-Feld. Es enthält auch die Ergebnisse aus der Datenquelle, die in der Antwortvorlage verwendet werden können. Weitere Informationen über diese Struktur und die verfügbaren Helferobjekt-Dienstprogramme finden Sie in der [Referenz zur Resolver-Zuweisungsvorlage "Context"](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
*Beim Schreiben oder Bearbeiten eines Resolvers können Sie ein Modell- oder *Testkontextobjekt* an den Konsoleneditor übergeben.* Auf diese Weise können Sie sehen, wie sowohl die Anforderungs- als auch die Antwortvorlage ausgewertet werden, ohne tatsächlich auf eine Datenquelle zuzugreifen. Beispiel: Sie können ein `firstname: Shaggy`-Testargument übergeben und sehen, wie es bei der Verwendung von `$ctx.args.firstname` in Ihrem Vorlagencode ausgewertet wird. Sie können auch die Auswertung eines Dienstprogramm-Helferobjekts wie `$util.autoId()` oder `util.time.nowISO8601()` testen.
### Resolver testen
In diesem Beispiel werden Resolver mithilfe der AWS AppSync Konsole getestet.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSyncKonsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **APIs Dashboard** Ihre GraphQL-API aus.
1. **Wählen Sie in der **Seitenleiste** Schema aus.**
1. Falls Sie dies noch nicht getan haben, wählen Sie unter dem Typ und neben dem Feld die Option **Anhängen** aus, um Ihren Resolver hinzuzufügen.
[Weitere Informationen zum Erstellen eines vollständigen Resolvers finden Sie unter Resolver konfigurieren.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html)
Wählen Sie andernfalls den Resolver aus, der sich bereits im Feld befindet.
1. Wählen Sie oben auf der Seite **Resolver bearbeiten** die **Option Testkontext auswählen und dann Neuen Kontext** **erstellen** aus.
1. Wählen Sie ein Beispielkontextobjekt aus oder füllen Sie die JSON-Datei manuell im Fenster mit dem **Ausführungskontext unten** aus.
1. Geben Sie einen **Namen für den Textkontext** ein.
1. Wählen Sie die Schaltfläche **Save (Speichern)** aus.
1. Wählen Sie oben auf der Seite **„Resolver bearbeiten**“ die Option **Test ausführen** aus.
Ein praktischeres Beispiel: Angenommen, Sie haben eine App, die einen GraphQL-Typ speichert`Dog`, die automatische ID-Generierung für Objekte verwendet und diese in Amazon DynamoDB speichert. Sie können außerdem einige Werte aus den Argumenten einer GraphQL-Mutation schreiben und nur bestimmten Benutzern das Anzeigen einer Antwort erlauben. Das Schema kann beispielsweise wie folgt aussehen:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Wenn Sie einen Resolver für die `addDog` Mutation hinzufügen, können Sie ein Kontextobjekt wie im folgenden Beispiel auffüllen. Nachstehend werden die Argumente `name` und `age` des Clients verwendet und ein `username` im `identity`-Objekt mit Daten gefüllt:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Sie können dies mithilfe der folgenden Anforderungs- und Antwortzuweisungsvorlagen testen:
**Request Template**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Antwortvorlage**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
Die ausgewertete Vorlage enthält die Daten aus Ihrem Testkontextobjekt und den generierten Wert aus `$util.autoId()`. Wenn Sie `username` zu einem anderen Wert als `Nadia` ändern, werden die Ergebnisse nicht zurückgegeben, da die Autorisierungsprüfung fehlschlägt. Weitere Informationen zur detaillierten Zugriffskontrolle finden Sie unter Anwendungsfälle für die [Autorisierung](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Testen von Mapping-Vorlagen mit's AWS AppSync APIs
Sie können den `EvaluateMappingTemplate` API-Befehl verwenden, um Ihre Mapping-Vorlagen mit simulierten Daten aus der Ferne zu testen. Um mit dem Befehl zu beginnen, stellen Sie sicher, dass Sie die `appsync:evaluateMappingTemplate` entsprechende Berechtigung zu Ihrer Richtlinie hinzugefügt haben. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Sie können den Befehl nutzen, indem Sie das [AWS CLI](https://aws.amazon.com/cli/)oder verwenden [AWS SDKs](https://aws.amazon.com/tools/). Nehmen Sie zum Beispiel das `Dog` Schema und die zugehörigen request/response Mapping-Vorlagen aus dem vorherigen Abschnitt. Speichern Sie die Anforderungsvorlage mithilfe der CLI auf Ihrer lokalen Station in einer Datei mit dem Namen `request.vtl` und speichern Sie das `context` Objekt anschließend in einer Datei mit dem Namen`context.json`. Führen Sie in Ihrer Shell den folgenden Befehl aus:
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
Dieser Befehl gibt die folgende Antwort zurück.
```
{
"evaluationResult": "{\n \"version\" : \"2017-02-28\",\n \"operation\" : \"PutItem\",\n \"key\" : {\n \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n },\n \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}
```
Das `evaluationResult` enthält die Ergebnisse des Testens Ihrer bereitgestellten Vorlage mit der bereitgestellten`context`. Sie können Ihre Vorlagen auch mit dem testen AWS SDKs. Hier ist ein Beispiel für die Verwendung des AWS SDK für JavaScript V2:
```
const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
client
.evaluateMappingTemplate({ template, context })
.promise()
.then((data) => console.log(data))
```
Mit dem SDK können Sie ganz einfach Tests aus Ihrer bevorzugten Testsuite integrieren, um das Verhalten Ihrer Vorlage zu überprüfen. Wir empfehlen, Tests mit dem [Jest Testing Framework](https://jestjs.io/) zu erstellen, aber jede Testsuite funktioniert. Der folgende Ausschnitt zeigt einen hypothetischen Validierungslauf. Beachten Sie, dass wir davon ausgehen, dass es sich bei der Bewertungsantwort um ein gültiges JSON handelt. Daher verwenden wir diese Methode, `JSON.parse` um JSON aus der Zeichenkettenantwort abzurufen:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
test('request correctly calls DynamoDB', async () => {
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateMappingTemplate({ template, context }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Dies führt zu dem folgenden Ergebnis:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 1.511 s, estimated 2 s
```
## Debuggen einer Live-Abfrage
Es gibt keinen Ersatz für einen end-to-end Test und eine Protokollierung, um eine Produktionsanwendung zu debuggen. AWS AppSync ermöglicht es Ihnen, Fehler und vollständige Anfragedetails über Amazon zu protokollieren CloudWatch. Darüber hinaus können Sie die AWS AppSync Konsole verwenden, um GraphQL-Abfragen, -Mutationen und -Abonnements zu testen und Protokolldaten für jede Anfrage live zurück in den Abfrage-Editor zu streamen, um sie in Echtzeit zu debuggen. Für Abonnements zeigen die Protokolle Verbindungszeitinformationen an.
Um dies durchzuführen, müssen Sie Amazon CloudWatch Logs im Voraus aktiviert haben, wie unter [Überwachung und Protokollierung](monitoring.md#aws-appsync-monitoring) beschrieben. Wählen Sie als Nächstes in der AWS AppSync Konsole die Registerkarte **Abfragen** und geben Sie dann eine gültige GraphQL-Abfrage ein. Klicken Sie im unteren rechten Bereich auf das **Protokollfenster und ziehen Sie es, um die Protokollansicht** zu öffnen. Wählen Sie oben auf der Seite das Wiedergabe-Pfeilsymbol, um die GraphQL-Abfrage auszuführen. In wenigen Augenblicken werden die vollständigen Anforderungs- und Antwortprotokolle für die Operation an diesen Abschnitt der Konsole gestreamt und können angezeigt werden.
# Konfiguration und Verwendung von Pipeline-Resolvern in AWS AppSync (VTL)
**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/configuring-resolvers-js.html)
AWS AppSync führt Resolver auf einem GraphQL-Feld aus. In einigen Fällen müssen Anwendungen mehrere Operationen ausführen, um ein einziges GraphQL-Feld aufzulösen. Mit Pipeline-Resolvern können Entwickler jetzt Operationen, sogenannte Funktionen, zusammenstellen und sie nacheinander ausführen. Pipeline-Resolver sind nützlich für Anwendungen, die z. B. eine Autorisierungsprüfung ausführen müssen, bevor sie Daten für ein Feld abrufen.
Ein Pipeline-Resolver besteht aus einer Zuweisungsvorlage für **Vorher**, einer Zuweisungsvorlage für **Nachher** und einer Liste von Funktionen. Jede Funktion verfügt über eine Vorlage für die Zuordnung von **Anfragen** und **Antworten**, die sie anhand einer Datenquelle ausführt. Da ein Pipeline-Resolver die Ausführung an eine Liste von Funktionen delegiert, ist er mit keiner Datenquelle verknüpft. Unit-Resolver und Funktionen sind Primitive, die Operationen an Datenquellen ausführen. Weitere Informationen finden Sie in der [Übersicht über die Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Schritt 1: Einen Pipeline-Resolver erstellen
Rufen Sie in der AWS AppSync Konsole die **Schemaseite** auf.
Speichern Sie das folgende Schema:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
Wir werden einen Pipeline-Resolver an das **signUp**-Feld mit dem Typ der **Mutation** anhängen. Wählen Sie im Bereich **Mutationstyp** auf der rechten Seite neben dem `signUp` Mutationsfeld die Option **Anhängen** aus. Klicken Sie auf der Seite „Resolver erstellen“ auf **Aktionen** und dann auf **Laufzeit aktualisieren**. Wählen Sie`Pipeline Resolver`, wählen Sie dann `VTL` und wählen Sie dann **Aktualisieren**. Die Seite sollte nun drei Abschnitte enthalten: einen Textbereich **Vor dem Zuordnen der Vorlage**, einen Abschnitt mit **Funktionen** und einen Textbereich **Nach dem Zuordnen der Vorlage**.
Unser Pipeline-Resolver meldet einen Benutzer an, indem er zuerst die eingegebene E-Mail-Adresse validiert und den Benutzer dann im System speichert. Wir kapseln die E-Mail-Validierung in einer **validateEmail**-Funktion und das Speichern des Benutzers in einer **saveUser**-Funktion. Die **validateEmail**-Funktion wird zuerst ausgeführt, und, sofern die E-Mail gültig ist, anschließend die **saveUser**-Funktion.
Der Ausführungsablauf sieht wie folgt aus:
1. Resolver-Zuweisungsvorlage für Anforderungen Mutation.signUp
1. Funktion validateEmail
1. Funktion saveUser
1. Resolver-Zuweisungsvorlage für Antworten Mutation.signUp
Da wir die Funktion **validateEmail** wahrscheinlich in anderen Resolvern auf unserer API wiederverwenden werden, möchten wir den Zugriff vermeiden, `$ctx.args` da sich diese von einem GraphQL-Feld zum anderen ändern. Wir können stattdessen `$ctx.stash` verwenden, um das E-Mail-Attribut aus dem Eingabefeldargument `signUp(input: Signup)` zu speichern.
**VOR der Zuordnungsvorlage:**
```
## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}
```
Die Konsole stellt eine standardmäßige **Passthrough-AFTER-Zuordnungsvorlage** bereit, die wir verwenden werden:
```
$util.toJson($ctx.result)
```
Wählen Sie **Erstellen** oder **Speichern**, um den Resolver zu aktualisieren.
## Schritt 2: Eine Funktion erstellen
Klicken Sie auf der Pipeline-Resolver-Seite im Abschnitt **Funktionen** auf **Funktion hinzufügen** und dann auf **Neue Funktion erstellen**. Es ist auch möglich, Funktionen zu erstellen, ohne die Resolver-Seite aufrufen zu müssen. Rufen Sie dazu in der AWS AppSync Konsole die Seite **Funktionen** auf. Wählen Sie die Schaltfläche **Create function** (Funktion erstellen). Wir erstellen eine Funktion, die prüft, ob eine E-Mail gültig ist und von einer bestimmten Domäne stammt. Sofern die E-Mail nicht gültig ist, löst die Funktion einen Fehler aus. Andernfalls leitet sie sämtliche Eingaben weiter.
Wählen Sie auf der Seite „Neue Funktionen“ die Option „**Aktionen**“ und dann „**Laufzeit aktualisieren**“. Wählen Sie „`VTL`**Aktualisieren**“. Stellen Sie sicher, dass Sie eine Datenquelle vom Typ **NONE** erstellt haben. Wählen Sie diese Datenquelle in der Liste **Datenquellenname** aus. Geben Sie für **den Funktionsnamen** in ein`validateEmail`. Überschreiben Sie im **Funktionscode-Bereich** alles mit diesem Snippet:
```
#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
$util.error("$ctx.stash.email is not a valid email.")
#end
{
"payload": { "email": $util.toJson(${ctx.stash.email}) }
}
```
Fügen Sie dies in die Antwortzuordnungsvorlage ein:
```
$util.toJson($ctx.result)
```
Überprüfen Sie Ihre Änderungen und wählen Sie dann **Erstellen** aus. Wir haben unsere **validateEmail**-Funktion erstellt. Wiederholen Sie diese Schritte, um die **SaveUser-Funktion** mit den folgenden Anforderungs- und Antwortzuordnungsvorlagen zu erstellen (Der Einfachheit halber verwenden wir eine **NONE-Datenquelle** und tun so, als ob der Benutzer nach der Ausführung der Funktion im System gespeichert wurde. ):
Zuweisungsvorlage für Anforderungen:
```
## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
"payload": $util.toJson($ctx.prev.result)
}
```
Zuweisungsvorlage für Antworten:
```
## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($ctx.result)
```
Wir haben gerade unsere **SaveUser-Funktion** erstellt.
## Schritt 3: Hinzufügen einer Funktion zu einem Pipeline-Resolver
Unsere Funktionen hätten automatisch zu dem Pipeline-Resolver hinzugefügt werden sollen, den wir gerade erstellt haben. **Wenn dies nicht der Fall war oder Sie die Funktionen über die Seite Funktionen erstellt haben, können Sie auf der Resolver-Seite auf **Funktion hinzufügen** klicken, um sie anzuhängen.** Fügen Sie dem Resolver sowohl die Funktionen **validateEmail** als auch **saveUser** hinzu. Die Funktion **validateEmail** muss vor der Funktion **saveUser** platziert werden. Wenn Sie weitere Funktionen hinzufügen, können Sie die Optionen „**Nach oben“ und „Nach** **unten“ verwenden,** um die Reihenfolge der Ausführung Ihrer Funktionen neu zu organisieren. Überprüfen Sie Ihre Änderungen und wählen Sie dann **Speichern**.
## Schritt 4: Eine Abfrage ausführen
Rufen Sie in der AWS AppSync Konsole die Seite **Abfragen** auf. Stellen Sie im Explorer sicher, dass Sie Ihre Mutation verwenden. Wenn nicht, wählen Sie `Mutation` in der Drop-down-Liste und dann`+`. Geben Sie die folgende Abfrage ein:
```
mutation {
signUp(input: {
email: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Dies sollte etwa Folgendes zurückgeben:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
Wir haben mit einem Pipeline-Resolver unseren Benutzer erfolgreich angemeldet und die eingegebene E-Mail validiert. Ein detailliertes Tutorial zu Pipeline-Resolvern finden Sie unter [Tutorial: Pipeline-Resolver](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers)