Erstellen einer Lambda-Funktion Eine Datenquelle für Lambda konfigurieren Erstellen Sie ein GraphQL-Schema Resolver konfigurieren Testen Sie Ihr GraphQL API Fehler zurücksenden Anwendungsfall für Fortgeschrittene: Batching

Verwendung von AWS Lambda Resolvern in AWS AppSync

Anmerkung

Wir unterstützen jetzt hauptsächlich die APPSYNC _JS-Laufzeit und ihre Dokumentation. Bitte erwägen Sie, die APPSYNC _JS-Laufzeit und ihre Anleitungen hier zu verwenden.

Sie können AWS Lambda with verwenden AWS AppSync , um jedes GraphQL-Feld aufzulösen. Beispielsweise könnte eine GraphQL-Abfrage einen Aufruf an eine Amazon Relational Database Service (AmazonRDS) -Instance senden, und eine GraphQL-Mutation könnte in einen Amazon Kinesis Kinesis-Stream schreiben. In diesem Abschnitt zeigen wir Ihnen, wie Sie eine Lambda-Funktion schreiben, die Geschäftslogik auf der Grundlage des Aufrufs einer GraphQL-Feldoperation ausführt.

Erstellen einer Lambda-Funktion

Das folgende Beispiel zeigt eine eingeschriebene Lambda-FunktionNode.js, die als Teil einer Blogpost-Anwendung verschiedene Operationen an Blogbeiträgen ausführt.


exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got an Invoke Request.");
    switch(event.field) {
        case "getPost":
            var id = event.arguments.id;
            callback(null, posts[id]);
            break;
        case "allPosts":
            var values = [];
            for(var d in posts){
                values.push(posts[d]);
            }
            callback(null, values);
            break;
        case "addPost":
            // return the arguments back
            callback(null, event.arguments);
            break;
        case "addPostErrorWithData":
            var id = event.arguments.id;
            var result = posts[id];
            // attached additional error information to the post
            result.errorMessage = 'Error with the mutation, data has changed';
            result.errorType = 'MUTATION_ERROR';
            callback(null, result);
            break;
        case "relatedPosts":
            var id = event.source.id;
            callback(null, relatedPosts[id]);
            break;
        default:
            callback("Unknown field, unable to resolve" + event.field, null);
            break;
    }
};

Diese Lambda-Funktion ruft einen Beitrag nach ID ab, fügt einen Beitrag hinzu, ruft eine Liste von Beiträgen ab und ruft verwandte Beiträge für einen bestimmten Beitrag ab.

Hinweis: Die Lambda-Funktion verwendet die switch Anweisung onevent.field, um zu ermitteln, welches Feld gerade aufgelöst wird.

Erstellen Sie diese Lambda-Funktion mit der AWS Management Console oder einem AWS CloudFormation Stack. Um die Funktion aus einem CloudFormation Stack zu erstellen, können Sie den folgenden Befehl AWS Command Line Interface (AWS CLI) verwenden:


aws cloudformation create-stack --stack-name AppSyncLambdaExample \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml \
--capabilities CAPABILITY_NAMED_IAM

Sie können den AWS CloudFormation Stack auch in der AWS Region USA West (Oregon) in Ihrem AWS Konto von hier aus starten:

Eine Datenquelle für Lambda konfigurieren

Nachdem Sie die Lambda-Funktion erstellt haben, navigieren Sie API in der AWS AppSync Konsole zu Ihrem GraphQL und wählen Sie dann die Registerkarte Datenquellen.

Wählen Sie Datenquelle erstellen, geben Sie einen benutzerfreundlichen Datenquellennamen ein (z. B.Lambda), und wählen Sie AWS Lambda dann als Datenquellentyp die Option Funktion aus. Wählen Sie für Region dieselbe Region wie Ihre Funktion aus. (Wenn Sie die Funktion aus dem bereitgestellten CloudFormation Stack erstellt haben, befindet sich die Funktion wahrscheinlich in US- WEST -2.) Wählen Sie für Function ARN den Amazon-Ressourcennamen (ARN) Ihrer Lambda-Funktion.

Nachdem Sie Ihre Lambda-Funktion ausgewählt haben, können Sie entweder eine neue Rolle AWS Identity and Access Management (IAM) erstellen (für die die entsprechenden Berechtigungen AWS AppSync zugewiesen werden) oder eine vorhandene Rolle mit der folgenden Inline-Richtlinie auswählen:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:REGION:ACCOUNTNUMBER:function/LAMBDA_FUNCTION"
        }
    ]
}

Sie müssen außerdem wie folgt eine Vertrauensbeziehung mit AWS AppSync der IAM Rolle einrichten:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "appsync.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Erstellen Sie ein GraphQL-Schema

Nachdem die Datenquelle mit Ihrer Lambda-Funktion verbunden ist, erstellen Sie ein GraphQL-Schema.

Stellen Sie im Schema-Editor in der AWS AppSync Konsole sicher, dass Ihr Schema dem folgenden Schema entspricht:


schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id:ID!): Post
    allPosts: [Post]
}

type Mutation {
    addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!
}

type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    relatedPosts: [Post]
}

Resolver konfigurieren

Nachdem Sie nun eine Lambda-Datenquelle und ein gültiges GraphQL-Schema registriert haben, können Sie Ihre GraphQL-Felder mithilfe von Resolvern mit Ihrer Lambda-Datenquelle verbinden.

Um einen Resolver zu erstellen, benötigen Sie Mapping-Vorlagen. Weitere Informationen zu Mapping-Vorlagen finden Sie unterResolver Mapping Template Overview.

Weitere Informationen zu Lambda-Mapping-Vorlagen finden Sie unterResolver mapping template reference for Lambda.

In diesem Schritt fügen Sie der Lambda-Funktion einen Resolver für die folgenden Felder hinzu:getPost(id:ID!): Post, allPosts: [Post]addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!, und. Post.relatedPosts: [Post]

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite Attach Resolver for aus. getPost(id:ID!): Post

Wählen Sie dann im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (VTLnur) aus.

Wählen Sie anschließend Ihre Lambda-Datenquelle aus. Wählen Sie im Bereich request mapping template (Anforderungszuweisungsvorlage) Invoke And Forward Arguments (Argumente aufrufen und weiterleiten).

Ändern Sie das Objekt payload, um den Feldnamen hinzuzufügen. Ihre Vorlage sollte jetzt wie folgt aussehen:


{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments":  $utils.toJson($context.arguments)
    }
}

Wählen Sie im Bereich response mapping template (Antwortzuweisungsvorlage) Return Lambda Result (Lambda-Ergebnis zurückgeben) aus.

Verwenden Sie in diesem Fall die Basisvorlage in unveränderter Form. Sie sollte wie folgt aussehen:


$utils.toJson($context.result)

Wählen Sie Save (Speichern) aus. Sie haben nun den ersten Resolver angehängt. Wiederholen Sie diese Operation wie folgt für die verbleibenden Felder:

Für die addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!-Anforderungszuweisungsvorlage:


{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "addPost",
        "arguments":  $utils.toJson($context.arguments)
    }
}

Für die addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!-Antwortzuweisungsvorlage:


$utils.toJson($context.result)

Für die allPosts: [Post]-Anforderungszuweisungsvorlage:


{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "allPosts"
    }
}

Für die allPosts: [Post]-Antwortzuweisungsvorlage:


$utils.toJson($context.result)

Für die Post.relatedPosts: [Post]-Anforderungszuweisungsvorlage:


{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "relatedPosts",
        "source":  $utils.toJson($context.source)
    }
}

Für die Post.relatedPosts: [Post]-Antwortzuweisungsvorlage:


$utils.toJson($context.result)

Testen Sie Ihr GraphQL API

Jetzt ist Ihre Lambda-Funktion mit GraphQL-Resolvern verbunden und Sie können einige Mutationen und Abfragen mithilfe der Konsole oder einer Client-Anwendung ausführen.

Wählen Sie auf der linken Seite der AWS AppSync Konsole Abfragen aus und fügen Sie dann den folgenden Code ein:

addPost Mutation


mutation addPost {
    addPost(
        id: 6
        author: "Author6"
        title: "Sixth book"
        url: "https://www.amazon.com/"
        content: "This is the book is a tutorial for using GraphQL with AWS AppSync."
    ) {
        id
        author
        title
        content
        url
        ups
        downs
    }
}

getPost Anfrage


query getPost {
    getPost(id: "2") {
        id
        author
        title
        content
        url
        ups
        downs
    }
}

allPosts abfragen


query allPosts {
    allPosts {
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {
            id
            title
        }
    }
}

Fehler zurücksenden

Jede gegebene Feldauflösung kann zu einem Fehler führen. Mit AWS AppSync können Sie Fehler aus den folgenden Quellen melden:

Anforderungs- oder Antwortzuweisungsvorlage
Lambda-Funktion

Von der Zuweisungsvorlage

Um absichtliche Fehler auszulösen, können Sie die $utils.error Hilfsmethode aus der Vorlage Velocity Template Language (VTL) verwenden. Das Argument enthält die errorMessage, den errorType und einen optionalen data-Wert. data ist hilfreich, um zusätzliche Daten an den Client zurückzugeben, wenn ein Fehler auftritt. Das Objekt data wird errors der endgültigen GraphQL-Antwort hinzugefügt.

Das folgende Beispiel zeigt, wie Sie es in der Antwortzuweisungsvorlage Post.relatedPosts: [Post] verwenden:


$utils.error("Failed to fetch relatedPosts", "LambdaFailure", $context.result)

Dies löst eine GraphQL-Antwort ähnlich der Folgenden aus:


{
    "data": {
        "allPosts": [
            {
                "id": "2",
                "title": "Second book",
                "relatedPosts": null
            },
            ...
        ]
    },
    "errors": [
        {
            "path": [
                "allPosts",
                0,
                "relatedPosts"
            ],
            "errorType": "LambdaFailure",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ],
            "message": "Failed to fetch relatedPosts",
            "data": [
                {
                  "id": "2",
                  "title": "Second book"
                },
                {
                  "id": "1",
                  "title": "First book"
                }
            ]
        }
    ]
}

Dabei ist allPosts[0].relatedPosts gleich null, weil ein Fehler aufgetreten ist und errorMessage, errorType und data im Objekt data.errors[0] vorhanden sind.

Von der Lambda-Funktion

AWS AppSync versteht auch Fehler, die die Lambda-Funktion auslöst. Mit dem Lambda-Programmiermodell können Sie behandelte Fehler melden. Wenn die Lambda-Funktion einen Fehler ausgibt, AWS AppSync kann das aktuelle Feld nicht aufgelöst werden. Nur die von Lambda zurückgegebene Fehlermeldung ist in der Antwort enthalten. Derzeit können Sie keine überflüssigen Daten an den Client zurückgeben, indem Sie einen Fehler in der Lambda-Funktion auslösen.

Hinweis: Wenn Ihre Lambda-Funktion einen unbehandelten Fehler auslöst, AWS AppSync verwendet sie die von Lambda festgelegte Fehlermeldung.

Die folgenden Lambda-Funktion löst einen Fehler aus:


exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    callback("I fail. Always.");
};

Dadurch wird eine GraphQL-Antwort ähnlich der folgenden ausgegeben:


{
    "data": {
        "allPosts": [
            {
                "id": "2",
                "title": "Second book",
                "relatedPosts": null
            },
            ...
        ]
    },
    "errors": [
        {
            "path": [
                "allPosts",
                0,
                "relatedPosts"
            ],
            "errorType": "Lambda:Handled",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ],
            "message": "I fail. Always."
        }
    ]
}

Anwendungsfall für Fortgeschrittene: Batching

Die Lambda-Funktion in diesem Beispiel hat ein relatedPosts Feld, das eine Liste verwandter Beiträge für einen bestimmten Beitrag zurückgibt. In den Beispielabfragen gibt der allPosts Feldaufruf der Lambda-Funktion fünf Beiträge zurück. Da wir angegeben haben, dass wir auch relatedPosts für jeden zurückgegebenen Beitrag eine Auflösung durchführen möchten, wird die relatedPosts Feldoperation fünfmal aufgerufen.


query allPosts {
    allPosts {   // 1 Lambda invocation - yields 5 Posts
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {   // 5 Lambda invocations - each yields 5 posts
            id
            title
        }
    }
}

Das klingt in diesem speziellen Beispiel vielleicht nicht wesentlich, aber dieses verstärkte Überabrufen kann die Anwendung schnell untergraben.

Wenn wir z. B. in derselben Abfrage erneut relatedPosts für die zurückgegebenen verwandten Posts abrufen würden, würde die Anzahl der Abrufe dramatisch ansteigen.


query allPosts {
    allPosts {   // 1 Lambda invocation - yields 5 Posts
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {   // 5 Lambda invocations - each yield 5 posts = 5 x 5 Posts
            id
            title
            relatedPosts {  // 5 x 5 Lambda invocations - each yield 5 posts = 25 x 5 Posts
                id
                title
                author
            }
        }
    }
}

In dieser relativ einfachen Abfrage AWS AppSync würde die Lambda-Funktion 1 + 5 + 25 = 31 mal aufgerufen.

Dies ist eine häufig vorkommende Herausforderung, die oft als N+1-Problem (in diesem Fall N = 5) bezeichnet wird und zu höherer Latenz und höheren Kosten für die Anwendung führen kann.

Ein Ansatz zur Lösung dieses Problems besteht darin, ähnliche Feld-Resolver-Anforderungen zu bündeln. In diesem Beispiel könnte die Lambda-Funktion, anstatt eine Liste verwandter Beiträge für einen bestimmten Beitrag auflösen zu lassen, stattdessen eine Liste verwandter Beiträge für einen bestimmten Stapel von Beiträgen auflösen.

Um dies zu demonstrieren, müssen wir den Resolver Post.relatedPosts: [Post] in einen stapelfähigen Resolver ändern.

Wählen Sie auf der rechten Seite der AWS AppSync Konsole den vorhandenen Post.relatedPosts: [Post] Resolver aus. Ändern Sie die Zuweisungsvorlage für Anforderungen wie folgt:


{
    "version": "2017-02-28",
    "operation": "BatchInvoke",
    "payload": {
        "field": "relatedPosts",
        "source":  $utils.toJson($context.source)
    }
}

Nur das Feld operation wurde von Invoke in BatchInvoke geändert. Das Payload-Feld wird jetzt zu einem Array mit allem, was in der Vorlage angegeben ist. In diesem Beispiel erhält die Lambda-Funktion Folgendes als Eingabe:


[
    {
        "field": "relatedPosts",
        "source": {
            "id": 1
        }
    },
    {
        "field": "relatedPosts",
        "source": {
            "id": 2
        }
    },
    ...
]

Wenn in der Vorlage für die Anforderungszuweisung angegeben BatchInvoke ist, empfängt die Lambda-Funktion eine Liste von Anfragen und gibt eine Ergebnisliste zurück.

Insbesondere muss die Ergebnisliste der Größe und Reihenfolge der Payload-Einträge der Anfrage entsprechen, damit die Ergebnisse entsprechend abgeglichen werden AWS AppSync können.

In diesem Batching-Beispiel gibt die Lambda-Funktion eine Reihe von Ergebnissen wie folgt zurück:


[
    [{"id":"2","title":"Second book"}, {"id":"3","title":"Third book"}],   // relatedPosts for id=1
    [{"id":"3","title":"Third book"}]                                                             // relatedPosts for id=2
]

Die folgende Lambda-Funktion in Node.js demonstriert diese Batching-Funktionalität für das Post.relatedPosts Feld wie folgt:


exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
    // event is now an array
    var field = event[0].field;
    switch(field) {
        case "relatedPosts":
            var results = [];
            // the response MUST contain the same number
            // of entries as the payload array
            for (var i=0; i< event.length; i++) {
                console.log("post {}", JSON.stringify(event[i].source));
                results.push(relatedPosts[event[i].source.id]);
            }
            console.log("results {}", JSON.stringify(results));
            callback(null, results);
            break;
        default:
            callback("Unknown field, unable to resolve" + field, null);
            break;
    }
};

Rückgabe einzelner Fehler

Die vorherigen Beispiele zeigen, dass es möglich ist, einen einzelnen Fehler von der Lambda-Funktion zurückzugeben oder einen Fehler aus den Mapping-Vorlagen auszulösen. Bei Batch-Aufrufen wird durch das Auslösen eines Fehlers über die Lambda-Funktion ein ganzer Batch als fehlgeschlagen gekennzeichnet. Dies kann für bestimmte Szenarien akzeptabel sein, in denen ein nicht behebbarer Fehler auftritt, z. B. eine fehlgeschlagene Verbindung zu einem Datenspeicher. In Fällen, in denen einige Elemente im Stapel erfolgreich sind und andere fehlschlagen, ist es jedoch möglich, sowohl Fehler als auch gültige Daten zurückzugeben. Da die Batch-Antwort AWS AppSync erfordert, um Elemente aufzulisten, die der ursprünglichen Größe des Stapels entsprechen, müssen Sie eine Datenstruktur definieren, die gültige Daten von fehlerhaften Daten unterscheiden kann.

Wenn beispielsweise erwartet wird, dass die Lambda-Funktion einen Stapel verwandter Beiträge zurückgibt, könnten Sie sich dafür entscheiden, eine Liste von Response Objekten zurückzugeben, in der jedes Objekt optionale Daten errorMessage, und errorTypeFelder hat. Wenn das errorMessageFeld vorhanden ist, bedeutet dies, dass ein Fehler aufgetreten ist.

Der folgende Code zeigt, wie Sie die Lambda-Funktion aktualisieren können:


exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
    // event is now an array
    var field = event[0].field;
    switch(field) {
        case "relatedPosts":
            var results = [];
            results.push({ 'data': relatedPosts['1'] });
            results.push({ 'data': relatedPosts['2'] });
            results.push({ 'data': null, 'errorMessage': 'Error Happened', 'errorType': 'ERROR' });
            results.push(null);
            results.push({ 'data': relatedPosts['3'], 'errorMessage': 'Error Happened with last result', 'errorType': 'ERROR' });
            callback(null, results);
            break;
        default:
            callback("Unknown field, unable to resolve" + field, null);
            break;
    }
};

In diesem Beispiel analysiert die folgende Antwortzuordnungsvorlage jedes Element der Lambda-Funktion und löst alle auftretenden Fehler aus:


#if( $context.result && $context.result.errorMessage )
    $utils.error($context.result.errorMessage, $context.result.errorType, $context.result.data)
#else
    $utils.toJson($context.result.data)
#end

Dieses Beispiel gibt eine GraphQL-Antwort ähnlich der folgenden aus:


{
  "data": {
    "allPosts": [
      {
        "id": "1",
        "relatedPostsPartialErrors": [
          {
            "id": "4",
            "title": "Fourth book"
          }
        ]
      },
      {
        "id": "2",
        "relatedPostsPartialErrors": [
          {
            "id": "3",
            "title": "Third book"
          },
          {
            "id": "5",
            "title": "Fifth book"
          }
        ]
      },
      {
        "id": "3",
        "relatedPostsPartialErrors": null
      },
      {
        "id": "4",
        "relatedPostsPartialErrors": null
      },
      {
        "id": "5",
        "relatedPostsPartialErrors": null
      }
    ]
  },
  "errors": [
    {
      "path": [
        "allPosts",
        2,
        "relatedPostsPartialErrors"
      ],
      "errorType": "ERROR",
      "locations": [
        {
          "line": 4,
          "column": 9
        }
      ],
      "message": "Error Happened"
    },
    {
      "path": [
        "allPosts",
        4,
        "relatedPostsPartialErrors"
      ],
      "data": [
        {
          "id": "2",
          "title": "Second book"
        },
        {
          "id": "1",
          "title": "First book"
        }
      ],
      "errorType": "ERROR",
      "locations": [
        {
          "line": 4,
          "column": 9
        }
      ],
      "message": "Error Happened with last result"
    }
  ]
}

Konfiguration der maximalen Batchgröße

Standardmäßig werden bei der Verwendung BatchInvoke Anfragen AWS AppSync an Ihre Lambda-Funktion in Stapeln von bis zu fünf Elementen gesendet. Sie können die maximale Batchgröße Ihrer Lambda-Resolver konfigurieren.

Um die maximale Batchgröße auf einem Resolver zu konfigurieren, verwenden Sie den folgenden Befehl in der (): AWS Command Line Interface AWS CLI


$ aws appsync create-resolver --api-id <api-id> --type-name Query --field-name relatedPosts \
 --request-mapping-template "<template>" --response-mapping-template "<template>" --data-source-name "<lambda-datasource>" \ 
 --max-batch-size X

Anmerkung

Wenn Sie eine Vorlage für die Anforderungszuweisung bereitstellen, müssen Sie den BatchInvoke Vorgang verwenden, um Batching zu verwenden.

Sie können auch den folgenden Befehl verwenden, um Batching auf Direct Lambda Resolvern zu aktivieren und zu konfigurieren:


$ aws appsync create-resolver --api-id <api-id> --type-name Query --field-name relatedPosts \
 --data-source-name "<lambda-datasource>" \ 
 --max-batch-size X

Konfiguration der maximalen Batchgröße mit Vorlagen VTL

Bei Lambda-Resolvern mit Vorlagen VTL auf Anfrage hat die maximale Batchgröße keine Auswirkung, es sei denn, sie wurde direkt als BatchInvoke Operation in angegeben. VTL Ebenso wird, wenn Sie eine Mutation der obersten Ebene durchführen, kein Batching für Mutationen durchgeführt, da die GraphQL-Spezifikation verlangt, dass parallel Mutationen sequentiell ausgeführt werden.

Nehmen wir zum Beispiel die folgenden Mutationen:


type Mutation {
    putItem(input: Item): Item
    putItems(inputs: [Item]): [Item]
}

Mit der ersten Mutation können wir 10 erstellen, Items wie im folgenden Ausschnitt gezeigt:


mutation MyMutation {
    v1: putItem($someItem1) {
        id,
        name
    }
    v2: putItem($someItem2) {
        id,
        name
    }
    v3: putItem($someItem3) {
        id,
        name
    } 
    v4: putItem($someItem4) {
        id,
        name
    }
    v5: putItem($someItem5) {
        id,
        name
    }
    v6: putItem($someItem6) {
        id,
        name
    } 
    v7: putItem($someItem7) {
        id,
        name
    }
    v8: putItem($someItem8) {
        id,
        name
    }
    v9: putItem($someItem9) {
        id,
        name
    }
    v10: putItem($someItem10) {
        id,
        name
    }
}

In diesem Beispiel Items werden die nicht in einer Gruppe von 10 gebündelt, auch wenn die maximale Batchgröße im Lambda Resolver auf 10 gesetzt ist. Stattdessen werden sie sequentiell gemäß der GraphQL-Spezifikation ausgeführt.

Um eine tatsächliche Batch-Mutation durchzuführen, können Sie dem folgenden Beispiel folgen und die zweite Mutation verwenden:


mutation MyMutation {
    putItems([$someItem1, $someItem2, $someItem3,$someItem4, $someItem5, $someItem6, 
    $someItem7, $someItem8, $someItem9, $someItem10]) {
    id,
    name
    }
}

Weitere Informationen zur Verwendung von Batching mit Direct Lambda Resolvern finden Sie unter. Direkte Lambda-Resolver

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen einer einfachen Post-Anwendung mit DynamoDB-Resolvern

Verwenden von OpenSearch Service-Resolvern