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. # 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 der [ Apache Velocity Template Language (VTL) geschrieben werden](https://velocity.apache.org/engine/2.0/vtl-reference.html), 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 ](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) Resolver-Tutorials (JavaScript) enthält ausführliche Tutorials zur Implementierung von Resolvern mithilfe von. JavaScript Der [ Abschnitt ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) Resolver-Referenz (JavaScript) enthält eine Erläuterung der Hilfsfunktionen, 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 erfahren Sie, wie Sie Resolver für Abfragen und Mutationen erstellen und konfigurieren. **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 Abfrage-Resolver 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 [ AppSync Konsole](https://console.aws.amazon.com/appsync/). 1. Wählen Sie im ** API-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 ](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) Anhängen einer Datenquelle. 1. Neben dem ** ** Schema-Editor befindet sich ein Fenster mit dem Namen ** Resolvers**. Dieses Feld enthält eine Liste der Typen und Felder, die 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 ** Attach Resolver können Sie unter ** Resolver-Typ ** 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](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) In diesem Handbuch werden verwendet. `pipeline resolvers` **Tipp** Beim Erstellen von Pipeline-Resolvern werden Ihre Datenquelle (n) 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, ihn festzulegen. Wenn Sie einen Unit-Resolver verwenden, ist die Datenquelle direkt mit dem Resolver verknüpft. Sie müssen ihn also auf dieser Seite festlegen. Wählen Sie für die ** Resolver-Laufzeit**, ob Sie `APPSYNC_JS` die Runtime 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 [ JavaScript Resolver-Übersicht. ](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; } ``` Unter diesem Abschnitt 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, um ihn bei Bedarf einem Resolver hinzuzufügen. 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 können Sie stattdessen eine ** Schaltfläche „Funktion ** erstellen“ sehen, die Sie auswählen können. 1. Wählen Sie eine Datenquelle aus. Dies wird die Datenquelle sein, auf der der Resolver agiert. **Anmerkung** In unserem Beispiel fügen 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 den gesetzt `id` und ist leer. 1. Geben Sie ein ein`Function name`. 1. Unter ** Funktionscode ** müssen Sie das Verhalten der Funktion implementieren. Das mag verwirrend sein, aber jede Funktion hat ihren eigenen lokalen Anfrage- und Antworthandler. Die Anforderung wird ausgeführt, dann wird die Datenquelle aufgerufen, um die Anforderung zu verarbeiten, und dann wird die Datenquellenantwort vom Antworthandler verarbeitet. Das Ergebnis wird im [https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) Kontextobjekt gespeichert. Danach wird die nächste Funktion in der Liste ausgeführt oder an den After-Step-Response-Handler übergeben, falls es sich um die letzte handelt. **Anmerkung** In unserem Beispiel fügen wir einen Resolver an`getPost`, der eine Liste von `Post` Objekten aus der Datenquelle abruft. Unsere Anforderungsfunktion fordert die Daten aus unserer Tabelle an, die Tabelle übergibt ihre Antwort an den Kontext (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, um solche Dinge ](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) 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 durch. Das Argument enthält das Kontextobjekt (`ctx`) oder einige Daten, die allen Resolvern zur Verfügung stehen, die eine bestimmte Operation ausführen. Es könnte beispielsweise Autorisierungsdaten, die aufgelösten Feldnamen usw. enthalten. Die Return-Anweisung führt eine [`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 ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) hier). Da wir mit DynamoDB arbeiten, dürfen wir einige der Operationen aus diesem Dienst 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 Response-Handler übergeben wird. Der `request` wird vor der Antwort in der Pipeline ausgeführt. `response`: Der Response-Handler, der die Ausgabe von zurückgibt`request`. Das Argument ist das aktualisierte Kontextobjekt, und die Rückgabeanweisung ist`ctx.prev.result`. An dieser Stelle im Handbuch sind Sie möglicherweise nicht mit diesem Wert 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 zuletzt ausgeführten Operation zurückgegeben, bei der es sich um den Request-Handler handelte. 1. Wählen Sie ** Erstellen, wenn Sie ** fertig sind. 1. Zurück auf dem Resolver-Bildschirm wählen Sie unter ** Funktionen ** das ** Dropdownmenü 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 Sprache der Funktion. Denn JavaScript der Name muss lauten`APPSYNC_JS`, und die Laufzeit,`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 zu einer TXT-Datei (oder einem ähnlichen Format) hinzuzufügen und es dann als Argument zu übergeben. **Anmerkung** Unser Abfragecode wird in einer Datei enthalten sein, 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 das `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 eine Einheit oder einen Pipeline-Resolver angibt. Setzen Sie diesen Wert auf, `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. Die`runtime`, die 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 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 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 Ihnen, die [ offizielle Dokumentation des CDK ](https://docs.aws.amazon.com/cdk/v2/guide/home.html) zusammen mit der [ CDK-Referenz zu AWS AppSync lesen. ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html) Die unten aufgeführten Schritte zeigen nur ein allgemeines Beispiel für das Snippet, das zum Hinzufügen einer bestimmten Ressource verwendet wird. Dies ** soll ** keine funktionierende Lösung in Ihrem Produktionscode sein. Wir gehen auch davon aus, dass Sie bereits eine funktionierende App haben. Eine einfache App benötigt die folgenden Dinge: 1. Richtlinien für den Import von Diensten 1. Schema-Code 1. Datenquellengenerator 1. Funktionscode 1. Resolver-Code Aus den [ Abschnitten Schema [ entwerfen ](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) und Datenquelle ](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) anhängen wissen wir, dass die Stack-Datei die Importdirektiven 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 Dienst zusammen mit unserer Datenquelle importieren, bei der es sich um eine DynamoDB-Tabelle handelte. 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 Elemente 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 die Manipulation von Metadaten. Wenn Sie mit dieser Import-Direktive vertraut sind, sich aber fragen, warum die CDK-Kernbibliothek hier nicht verwendet wird, schauen Sie auf der [https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html) Migrationsseite nach. `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 importiert. ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html) `import { Construct } from 'constructs';`: Wir benötigen dies, 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 als separate Datei in Ihrer CDK-App als Datei angezeigt`.graphql`. In der Stack-Datei können wir sie mithilfe des folgenden Formulars einem neuen GraphQL zuordnen: ``` 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 fügen wir eine neue GraphQL-API hinzu`add_api`, indem wir das `new` Schlüsselwort gefolgt von verwenden. `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` Unser Geltungsbereich ist`this`, die CFN-ID ist `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 mit folgenden Methoden 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 einem 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 Umfang war`this`, unsere CFN-ID war`func-get-posts`, und unsere Requisiten enthielten die tatsächlichen Funktionsdetails. Im Inneren der Requisiten haben wir Folgendes eingebaut: Die `name` der Funktion, die in der AWS AppSync Konsole (`get_posts_func_1`) vorhanden sein wird. Die GraphQL-API, die wir zuvor erstellt haben (`add_api`). Die Datenquelle; das 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 von uns erstellte Tabelle (`add_ddb_table`) und hängen sie mit einer der `GraphqlApi` Methoden (`add_api`) an die GraphQL-API ([`addDynamoDbDataSource`](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 Anfrage- und Antworthandler unserer Funktion. Dies ist ein einfacher Scan und eine Rückgabe. Die Laufzeit gibt an, dass wir die APPSYNC\_JS-Laufzeitversion 1.0.0 verwenden möchten. Beachten Sie, dass dies derzeit die einzige Version ist, die für APPSYNC\_JS verfügbar ist. Als Nächstes müssen wir die Funktion an den Pipeline-Resolver anhängen. Wir haben unseren Resolver mit dem Formular erstellt: ``` Resolver(scope: Construct, id: string, props: ResolverProps) ``` Unser Geltungsbereich war`this`, unsere CFN-ID war`pipeline-resolver-get-posts`, und unsere Requisiten enthielten die tatsächlichen Funktionsdetails. In den Requisiten waren enthalten: Die GraphQL-API, die wir zuvor erstellt haben ()`add_api`. Der spezielle Objekttypname; dies ist eine Abfrageoperation, also haben wir einfach den Wert `Query` hinzugefügt. Der Feldname (`getPost`) ist der Name des Feldes im Schema unter dem `Query` Typ. Der Code enthält Ihre Vorher- und Nachher-Handler. Unser Beispiel gibt nur die Ergebnisse zurück, die im Kontext waren, nachdem die Funktion ihre Operation ausgeführt hatte. Die Laufzeit gibt an, dass wir die APPSYNC\_JS-Laufzeitversion 1.0.0 verwenden möchten. Beachten Sie, dass dies derzeit die einzige Version ist, die für APPSYNC\_JS verfügbar ist. Die Pipeline-Konfiguration enthält den Verweis auf die Funktion, die wir erstellt haben (). `add_func` ------ Um zusammenzufassen, was in diesem Beispiel passiert ist, haben Sie 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 AWS AppSync und ihm mitgeteilt, welche Operation für Ihre DynamoDB-Datenquelle ausgeführt werden soll. Der Antworthandler gab die Liste der Elemente () zurück. `ctx.result.items` Die Liste der Elemente wurde dann automatisch dem `Post` GraphQL-Typ zugeordnet. ## Erstellung einfacher 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 [ AppSync Konsole](https://console.aws.amazon.com/appsync/). 1. Wählen Sie im ** API-Dashboard ** Ihre GraphQL-API aus. 1. Wählen Sie in der ** Seitenleiste ** Schema aus**. ** 1. Wähle im ** Abschnitt ** Resolvers und unter dem ** ** Mutationstyp ** neben deinem Feld die Option ** Anhängen aus. **Anmerkung** In unserem Beispiel fügen 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 den gesetzt `id` und leer. 1. Wählen Sie auf der ** Seite ** Attach Resolver unter ** Resolvertyp ** 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 die ** Resolver-Laufzeit**, 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ählen ** Sie Funktion ** hinzufügen und dann Neue Funktion ** erstellen**. Alternativ wird möglicherweise eine ** Schaltfläche „Funktion ** erstellen“ angezeigt, die 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 Anforderung idealerweise eine Zustandsänderungsoperation für die aufgerufene Datenquelle durch. Das Ergebnis wird von der Antwortfunktion verarbeitet. **Anmerkung** `createPost`fügt der Tabelle etwas Neues `Post` hinzu oder „fügt“ es ein, wobei unsere Parameter als Daten dienen. 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 Rückgabeanweisung des Anforderungshandlers führt einen [`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 eine integrierte DynamoDB-Operation handelt (Beispiele finden Sie [[ hier ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) oder hier](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html)). 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). Das `key` ist das `id` und `attributes` sind die `date` `title` Feldargumente und. Sie sind beide durch das [`util.dynamodb.toMapValues`](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js) Hilfsprogramm 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 ** Erstellen, wenn Sie ** fertig sind. 1. Zurück auf dem Resolver-Bildschirm wählen Sie unter ** Funktionen ** das ** Dropdownmenü 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 Sprache der Funktion. Denn JavaScript der Name muss lauten`APPSYNC_JS`, und die Laufzeit,`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 zu einer TXT-Datei (oder einem ähnlichen Format) hinzuzufügen und es dann als Argument zu übergeben. **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) { 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 das `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 Einheiten- oder Pipeline-Resolver angibt. Setzen Sie diesen Wert auf, `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. Die`runtime`, die war `APPSYNC_JS` (JavaScript). Das ist `runtimeVersion` derzeit`1.0.0`. 1. Der`code`, der den Vorher- und 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 Ihnen, die [ offizielle Dokumentation des CDK ](https://docs.aws.amazon.com/cdk/v2/guide/home.html) zusammen mit der [ CDK-Referenz zu AWS AppSync lesen. ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html) Die unten aufgeführten Schritte zeigen nur ein allgemeines Beispiel für das Snippet, das zum Hinzufügen einer bestimmten Ressource verwendet wird. 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, vorausgesetzt, Sie befinden sich im selben Projekt, können Sie sie wie die Abfrage zur Stack-Datei hinzufügen. Hier ist eine modifizierte Funktion und ein 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, erklären 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 in der AWS AppSync Konsole eine neue Zuordnung zu unserer Tabelle (`add_ddb_table`) vorgenommen, `table-for-posts-2` da die `addDynamoDbDataSource` Methode dies erfordert. Denken Sie daran, dass diese neue Zuordnung 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 ein hinzugefügt wird, `Post` indem sein `id` Wert automatisch generiert und die Eingabe eines Clients 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 AWS AppSync automatisch die im `createPost` Feld definierten Argumente aus Ihrem GraphQL-Schema in DynamoDB-Operationen. Das Beispiel speichert Datensätze in DynamoDB mit dem Schlüssel von`id`, der automatisch mit unserem Hilfsprogramm erstellt wird. `util.autoId()` 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 Hilfsprogramms 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 Anforderung an eine Datenquelle interaktiv anzeigen, wenn Sie eine Abfrage ausführen. Weitere Informationen finden Sie unter [ Testen und Debuggen von Resolvern (JavaScript) ](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) und [ Überwachen und Protokollieren. ](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring) ## Resolver für Fortgeschrittene Wenn Sie den Abschnitt zur optionalen Paginierung im Abschnitt [ Entwerfen Ihres Schemas befolgen](designing-your-schema.md#aws-appsync-designing-your-schema), müssen Sie Ihrer Anfrage dennoch Ihren Resolver hinzufügen, um die Paginierung nutzen zu können. In unserem Beispiel wurde eine Abfrage-Paginierung verwendet`getPosts`, die aufgerufen wurde, um jeweils nur einen Teil der 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` in 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 vom ersten `Post` bis zur Scan-Limit-Nummer durch. Die Datenquelle speichert das Ergebnis im Kontext, der an die Antwort übergeben wird. Die Antwort gibt das von `Posts` ihr abgerufene zurück und setzt dann den `nextToken` Wert auf den `Post` Eintrag, der direkt hinter dem Limit liegt. Die nächste Anfrage wird gesendet, um genau dasselbe zu tun, jedoch mit dem Offset direkt nach der ersten Abfrage. Beachten Sie, dass diese Art von Anfragen sequentiell und nicht parallel ausgeführt werden.