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 Apache Velocity Template Language (VTL)
In diesem Abschnitt wird beschrieben, wie Resolver mithilfe von konfiguriert werden. JavaScript Der Abschnitt Resolver-Tutorials (JavaScript) enthält ausführliche Anleitungen zur Implementierung von Resolvern mithilfe von. JavaScript Der Abschnitt Resolver-Referenz (JavaScript) 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 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
-
-
Melden Sie sich bei der an AWS Management Console und öffnen Sie die AppSyncKonsole
. -
Wählen Sie im APIsDashboard Ihr GraphQL API aus.
-
Wählen Sie in der Seitenleiste Schema.
-
-
Geben Sie die Details Ihres Schemas und Ihrer Datenquelle ein. Weitere Informationen finden Sie in den Abschnitten Entwerfen Ihres Schemas und Anhängen einer Datenquelle.
-
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.
-
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. 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 -
Sie können dafür das Caching aktivieren. API Wir empfehlen, diese Funktion vorerst auszuschalten. Wählen Sie Create (Erstellen) aus.
-
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.
Anmerkung
In unserem Beispiel lassen wir die Anfrage einfach leer und die Antwort wird so eingestellt, dass sie das letzte Datenquellenergebnis aus dem Kontext 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.
-
Wählen Sie eine Datenquelle aus. Dies ist die Datenquelle, 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. -
Geben Sie ein
Function name
. -
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 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 vonPost
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, 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 eineScan
Operation aus (Beispiele finden Sie hier). 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 alsresult
Container gespeichert, bevor es an den Antworthandler übergeben wird. Dasrequest
wird vor der Antwort in der Pipeline ausgeführt. -
response
: Der Antworthandler, der die Ausgabe von zurückgibtrequest
. Das Argument ist das aktualisierte Kontextobjekt und die Rückgabeanweisung istctx.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 warrequest
. Derresult
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.
-
-
Wenn Sie fertig sind, wählen Sie Create.
-
-
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.
-
Wählen Sie Speichern, um den Resolver zu aktualisieren.
-
- CLI
-
Um Ihre Funktion hinzuzufügen
-
Erstellen Sie mit dem
create-function
Befehl eine Funktion für Ihren Pipeline-Resolver.Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
-
Der
api-id
von dirAPI. -
Die
name
der Funktion in der AWS AppSync Konsole. -
Der oder der Name der Datenquelle
data-source-name
, die die Funktion verwenden wird. Es muss bereits im AWS AppSync Service erstellt und mit Ihrem GraphQL API verknüpft sein. -
Die
runtime
oder Umgebung und die Sprache der Funktion. Für JavaScript mussAPPSYNC_JS
der Name und die Laufzeit, lauten1.0.0
. -
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'; /** * 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 zurückgegebenCLI. 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 aufnehmen, 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 dencreate-resolver
Befehl ausführen.Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
-
Der
api-id
von dirAPI. -
Der
type-name
oder der spezielle Objekttyp in Ihrem Schema (Query, Mutation, Subscription). -
Die
field-name
oder die Feldoperation innerhalb des speziellen Objekttyps, an den Sie den Resolver anhängen möchten. -
Der
kind
, der einen Units- oder Pipeline-Resolver angibt. Stellen Sie diesen Wert auf ein,PIPELINE
um Pipeline-Funktionen zu aktivieren. -
Die oder die Funktion (en)
pipeline-config
, die an den Resolver angehängt werden sollen. Stellen Sie sicher, dass Sie diefunctionId
Werte Ihrer Funktionen kennen. Die Reihenfolge der Auflistung ist wichtig. -
Das
runtime
, was warAPPSYNC_JS
(JavaScript). Das istruntimeVersion
derzeit1.0.0
. -
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 zurückgegebenCLI. 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 verwendenCDK, empfehlen wir Ihnen, die offizielle Dokumentation CDK von zusammen mit AWS AppSync der CDKReferenz zu 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:
-
Richtlinien für den Import von Diensten
-
Schemacode
-
Datenquellengenerator
-
Funktionscode
-
Resolver-Code
Aus den Abschnitten Entwerfen Ihres Schemas und Anhängen einer Datenquelle 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, 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. -
import * as appsync from 'aws-cdk-lib/aws-appsync';
: Dadurch wird der AWS AppSync Dienst importiert. -
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
: Dadurch wird der DynamoDB-Dienst importiert. -
import { Construct } from 'constructs';
: Wir benötigen das, um das Root-Konstrukt zu definieren.
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 fügen wir ein neues GraphQL hinzu
add_api
, das dasnew
Schlüsselwort gefolgt von APIappsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)
verwendet. Unser Bereich istthis
, die CFN ID istgraphQL-example
, und unsere Requisiten sindmy-first-api
(Name von API in der Konsole) undschema.graphql
(der absolute Pfad zur Schemadatei).Um eine Datenquelle hinzuzufügen, müssen Sie zuerst Ihre Datenquelle zum Stack hinzufügen. Dann müssen Sie es API mithilfe der quellenspezifischen Methode mit GraphQL 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 warfunc-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
). -
Das GraphQL, das API wir zuvor erstellt haben (
add_api
). -
Die Datenquelle; das ist der Punkt, an dem wir die Datenquelle mit dem API GraphQL-Wert verknüpfen und sie dann an die Funktion anhängen. Wir nehmen die Tabelle, die wir erstellt haben (
add_ddb_table
) und hängen sie mit einer derGraphqlApi
Methoden API (add_api
) an GraphQL (addDynamoDbDataSource
) 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: -
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 _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 der folgenden Form erstellt:
Resolver(scope: Construct, id: string, props: ResolverProps)
Unser Umfang war
this
, unsere CFN ID warpipeline-resolver-get-posts
, und unsere Requisiten enthielten die tatsächlichen Funktionsdetails. Zu den Requisiten gehörten:-
Das GraphQL, das API 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 demQuery
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 _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 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
-
-
Melden Sie sich bei der an AWS Management Console und öffnen Sie die AppSyncKonsole
. -
Wählen Sie im APIsDashboard Ihr GraphQL API aus.
-
Wählen Sie in der Seitenleiste Schema.
-
-
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 einPost
Objekt hinzufügt. Nehmen wir an, wir verwenden dieselbe DynamoDB-Tabelle aus dem letzten Abschnitt. Ihr Partitionsschlüssel ist auf „gesetzt“id
und leer. -
Wählen Sie auf der Seite Attach Resolver unter Resolver-Typ die Option.
pipeline resolvers
Zur Erinnerung: Weitere Informationen zu Resolvern finden Sie hier. Wählen Sie für Resolver Runtime aus, ob SieAPPSYNC_JS
die Laufzeit aktivieren möchten. JavaScript -
Sie können dafür das Caching aktivieren. API Wir empfehlen, diese Funktion vorerst auszuschalten. Wählen Sie Create (Erstellen) aus.
-
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.
-
Wählen Sie Ihre -Datenquelle aus. Dies sollte die Quelle sein, deren Daten Sie mit der Mutation manipulieren werden.
-
Geben Sie ein
Function name
. -
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 neuesPost
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
auchresponse
Funktionen hinzugefügt:-
request
: Der Request-Handler akzeptiert den Kontext als Argument. Die Return-Anweisung des Request-Handlers führt einenPutItem
Befehl aus, bei dem es sich um einen integrierten DynamoDB-Vorgang handelt (Beispiele finden Sie hier oder hier). DerPutItem
Befehl fügt unserer DynamoDB-Tabelle einPost
Objekt hinzu, indem er denkey
Partitionswert (automatisch generiert vonutil.autoid()
) undattributes
die Eingabe des Kontextarguments verwendet (dies sind die Werte, die wir in unserer Anfrage übergeben werden). Diekey
Feldargumenteattributes
sindid
und sind diedate
title
Feldargumente. Sie sind beide über denutil.dynamodb.toMapValues
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.
-
-
Wählen Sie Create, wenn Sie fertig sind.
-
-
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.
-
Wählen Sie Speichern, um den Resolver zu aktualisieren.
-
- CLI
-
Um Ihre Funktion hinzuzufügen
-
Erstellen Sie mit dem
create-function
Befehl eine Funktion für Ihren Pipeline-Resolver.Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
-
Der
api-id
von dirAPI. -
Die
name
der Funktion in der AWS AppSync Konsole. -
Der oder der Name der Datenquelle
data-source-name
, die die Funktion verwenden wird. Es muss bereits im AWS AppSync Service erstellt und mit Ihrem GraphQL API verknüpft sein. -
Die
runtime
oder Umgebung und die Sprache der Funktion. Für JavaScript mussAPPSYNC_JS
der Name und die Laufzeit, lauten1.0.0
. -
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 zurückgegebenCLI. 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 aufnehmen, 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 dencreate-resolver
Befehl ausführen.Für diesen speziellen Befehl müssen Sie einige Parameter eingeben:
-
Der
api-id
von dirAPI. -
Der
type-name
oder der spezielle Objekttyp in Ihrem Schema (Query, Mutation, Subscription). -
Die
field-name
oder die Feldoperation innerhalb des speziellen Objekttyps, an den Sie den Resolver anhängen möchten. -
Der
kind
, der einen Units- oder Pipeline-Resolver angibt. Stellen Sie diesen Wert auf ein,PIPELINE
um Pipeline-Funktionen zu aktivieren. -
Die oder die Funktion (en)
pipeline-config
, die an den Resolver angehängt werden sollen. Stellen Sie sicher, dass Sie diefunctionId
Werte Ihrer Funktionen kennen. Die Reihenfolge der Auflistung ist wichtig. -
Das
runtime
, was warAPPSYNC_JS
(JavaScript). Das istruntimeVersion
derzeit1.0.0
. -
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 zurückgegebenCLI. 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 verwendenCDK, empfehlen wir Ihnen, die offizielle Dokumentation CDK von zusammen mit AWS AppSync der CDKReferenz zu 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 etwas hinzufügenPosts
. 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 dieaddDynamoDbDataSource
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 alstable-for-posts
und eine für die Mutation alstable-for-posts-2
. Der Code wurde dahingehend geändert, dass a hinzugefügt wurde,Post
indem seinid
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 TabellePosts
etwas hinzufügen. Um die Mutation im Schema widerzuspiegeln, wurde der Typname inMutation
, und der Name,createPost
geändert. Die Pipeline-Konfiguration wurde auf unsere neue Mutationsfunktion eingestelltadd_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 vonid
, 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 und Protokollieren.
Fortgeschrittene Resolver
Wenn Sie dem optionalen Abschnitt zur Paginierung unter Ihr Schema entwerfen folgen, müssen Sie dennoch Ihren Resolver zu Ihrer Anfrage hinzufügen, um die Paginierung nutzen zu können. In unserem Beispiel wurde eine Abfrage-Paginierung verwendetgetPosts
, 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.