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.

AWS AppSync Referenz zur Resolver-Mapping-Vorlage für Lambda

Sie können AWS AppSync Funktionen und Resolver verwenden, um Lambda-Funktionen aufzurufen, die sich in Ihrem Konto befinden. Sie können Ihre Anforderungsnutzlasten und die Antwort Ihrer Lambda-Funktionen formen, bevor Sie sie an Ihre Kunden zurückgeben. Sie können Mapping-Vorlagen auch verwenden, um AWS AppSync Hinweise zur Art der Operation zu geben, die aufgerufen werden soll. In diesem Abschnitt werden die verschiedenen Mapping-Vorlagen für die unterstützten Lambda-Operationen beschrieben.

Mapping-Vorlage anfordern

Die Vorlage für die Lambda-Anforderungszuordnung verarbeitet Felder, die sich auf Ihre Lambda-Funktion beziehen:

{
  "version": string,
  "operation": Invoke|BatchInvoke,
  "payload": any type,
  "invocationType": RequestResponse|Event
}

Dies ist die JSON-Schemadarstellung der Lambda-Anforderungszuordnungsvorlage, wenn sie aufgelöst ist:

{
  "definitions": {},
  "$schema": "https://json-schema.org/draft-06/schema#",
  "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
  "type": "object",
  "properties": {
    "version": {
      "$id": "/properties/version",
      "type": "string",
      "enum": [
        "2018-05-29"
      ],
      "title": "The Mapping template version.",
      "default": "2018-05-29"
    },
    "operation": {
      "$id": "/properties/operation",
      "type": "string",
      "enum": [
        "Invoke",
        "BatchInvoke"
      ],
      "title": "The Mapping template operation.",
      "description": "What operation to execute.",
      "default": "Invoke"
    },
    "payload": {},
    "invocationType": {
      "$id": "/properties/invocationType",
      "type": "string",
      "enum": [
        "RequestResponse",
        "Event"
      ],
      "title": "The Mapping template invocation type.",
      "description": "What invocation type to execute.",
      "default": "RequestResponse"
    }
  },
  "required": [
    "version",
    "operation"
  ],
  "additionalProperties": false
}

Hier ist ein Beispiel, das eine invoke Operation verwendet, deren Nutzdaten das getPost Feld aus einem GraphQL-Schema zusammen mit seinen Argumenten aus dem Kontext sind:

{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": $util.toJson($context.arguments)
  }
}

Das gesamte Mapping-Dokument wird als Eingabe an Ihre Lambda-Funktion übergeben, sodass das vorherige Beispiel jetzt so aussieht:

{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": {
      "id": "postId1"
    }
  }
}

Version

Das ist allen Vorlagen für das Anforderungs-Mapping gemeinsam und version definiert die Version, die die Vorlage verwendet. Der version ist erforderlich und ist ein statischer Wert:

"version": "2018-05-29"

Operation

Mit der Lambda-Datenquelle können Sie zwei Operationen im operation Feld definieren: Invoke undBatchInvoke. Die Invoke Operation AWS AppSync informiert Sie darüber, dass Sie Ihre Lambda-Funktion für jeden GraphQL-Feldresolver aufrufen müssen. BatchInvokeweist an, Anfragen für AWS AppSync das aktuelle GraphQL-Feld zu stapeln. Das Feld operation ist ein Pflichtfeld.

Denn die Vorlage für Invoke die Zuordnung aufgelöster Anfragen entspricht der Eingabe-Nutzlast der Lambda-Funktion. Lassen Sie uns das obige Beispiel ändern:

{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": $util.toJson($context.arguments)
    }
}

Das wird gelöst und an die Lambda-Funktion übergeben, die etwa so aussehen könnte:

{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": {
        "id": "postId1"
      }
    }
}

Denn BatchInvoke die Mapping-Vorlage wird auf jeden Feld-Resolver im Batch angewendet. Der Übersichtlichkeit halber werden alle payload Werte der aufgelösten Zuordnungsvorlage in einer Liste unter einem einzelnen Objekt zusammengefasst, das der Zuordnungsvorlage entspricht. AWS AppSync Die folgende Vorlage zeigt die Zusammenfassung:

{
  "version": "2018-05-29",
  "operation": "BatchInvoke",
  "payload": $util.toJson($context)
}

Diese Vorlage ist in dem folgenden Zuweisungsdokument aufgelöst:

{
  "version": "2018-05-29",
  "operation": "BatchInvoke",
  "payload": [
    {...}, // context for batch item 1
    {...}, // context for batch item 2
    {...}  // context for batch item 3
  ]
}

Jedes Element der payload Liste entspricht einem einzelnen Batch-Element. Es wird auch erwartet, dass die Lambda-Funktion eine listenförmige Antwort zurückgibt, die der Reihenfolge der in der Anfrage gesendeten Elemente entspricht:

[
  { "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 1
  { "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 2
  { "data": {...}, "errorMessage": null, "errorType": null }  // result for batch item 3
]

Nutzlast

Das payload Feld ist ein Container, der verwendet wird, um jedes wohlgeformte JSON an die Lambda-Funktion zu übergeben. Wenn das operation Feld auf gesetzt istBatchInvoke, AWS AppSync fasst die vorhandenen payload Werte in eine Liste ein. Das Feld payload ist optional.

Aufruftyp

Mit der Lambda-Datenquelle können Sie zwei Aufruftypen definieren: und. RequestResponse Event Die Aufruftypen sind gleichbedeutend mit den in der Lambda-API definierten Aufruftypen. https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html Mit dem RequestResponse Aufruftyp können AWS AppSync Sie Ihre Lambda-Funktion synchron aufrufen, um auf eine Antwort zu warten. Der Event Aufruf ermöglicht es Ihnen, Ihre Lambda-Funktion asynchron aufzurufen. Weitere Informationen darüber, wie Lambda Anfragen vom Aufruftyp verarbeitet, finden Sie unter Asynchroner Event Aufruf. https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html Das Feld invocationType ist optional. Wenn dieses Feld nicht in der Anfrage enthalten ist, AWS AppSync wird standardmäßig der Aufruftyp verwendet. RequestResponse

Für jedes invocationType Feld entspricht die gelöste Anforderung der Eingabe-Nutzlast der Lambda-Funktion. Lassen Sie uns das obige Beispiel ändern:

{
  "version": "2018-05-29",
  "operation": "Invoke",
  "invocationType": "Event"
  "payload": {
    "arguments": $util.toJson($context.arguments)
  }
}

Das wird gelöst und an die Lambda-Funktion übergeben, die etwa so aussehen könnte:

{
  "version": "2018-05-29",
  "operation": "Invoke",
  "invocationType": "Event",
  "payload": {
    "arguments": {
      "id": "postId1"
    }
  }
}

Wenn die BatchInvoke Operation in Verbindung mit dem Feld für den Event Aufruftyp verwendet wird, wird der Feld-Resolver auf die oben beschriebene Weise AWS AppSync zusammengeführt, und die Anforderung wird als asynchrones Ereignis an Ihre Lambda-Funktion übergeben, wobei es sich um eine Liste von Werten handelt. payload Wir empfehlen, das Resolver-Caching für Resolver vom Typ Event Aufruf zu deaktivieren, da diese bei einem Cache-Treffer nicht an Lambda gesendet würden.

Vorlage für die Antwortzuordnung

Wie bei anderen Datenquellen sendet Ihre Lambda-Funktion eine Antwort AWS AppSync , die in einen GraphQL-Typ konvertiert werden muss.

Das Ergebnis der Lambda-Funktion wird für das context Objekt festgelegt, das über die Eigenschaft Velocity Template Language (VTL) verfügbar ist. $context.result

Wenn die Form Ihrer Lambda-Funktionsantwort exakt der Form des GraphQL-Formats entspricht, können Sie die Antwort unter Verwendung der folgenden Zuweisungsvorlage für Antworten weiterleiten:

$util.toJson($context.result)

Es gibt keine erforderlichen Felder oder Formeinschränkungen, die auf die Zuweisungsvorlage für Antworten zutreffen. Allerdings ist GraphQL stark typisiert. Deshalb muss die Zuweisungsvorlage, auf die der Resolver angewendet wurde, dem erwarteten GraphQL-Format entsprechen.

Batch-Antwort der Lambda-Funktion

Wenn das operation-Feld auf BatchInvoke festgelegt ist, erwartet AWS AppSync eine Liste mit Elementen aus der Lambda-Funktion. Damit jedes Ergebnis wieder AWS AppSync dem ursprünglichen Anforderungselement zugeordnet werden kann, muss die Antwortliste in Größe und Reihenfolge übereinstimmen. Es ist gültig, null Elemente in der Antwortliste zu haben; $ctx.result ist entsprechend auf Null gesetzt.

Direkte Lambda-Resolver

Wenn Sie die Verwendung von Mapping-Vorlagen vollständig umgehen möchten, AWS AppSync können Sie eine Standard-Nutzlast für Ihre Lambda-Funktion und eine Standard-Lambda-Funktionsantwort für einen GraphQL-Typ bereitstellen. Sie können wählen, ob Sie eine Anforderungsvorlage, eine Antwortvorlage oder keines von beiden bereitstellen möchten, und sie entsprechend behandeln. AWS AppSync

Direkte Vorlage für die Zuordnung von Lambda-Anfragen

Wenn die Vorlage für die Anforderungszuordnung nicht bereitgestellt AWS AppSync wird, wird das Context Objekt als Operation direkt an Ihre Lambda-Funktion gesendet. Invoke Weitere Informationen über die Struktur des Context-Objekts finden Sie unter AWS AppSync Kontextreferenz für Resolver-Mapping-Vorlagen.

Vorlage für die direkte Lambda-Antwortzuordnung

Wenn die Vorlage für die Antwortzuordnung nicht bereitgestellt wird, AWS AppSync führt nach Erhalt der Antwort Ihrer Lambda-Funktion eine von zwei Aktionen aus. Wenn Sie keine Vorlage für die Anforderungszuordnung bereitgestellt haben oder wenn Sie eine Vorlage für die Anforderungszuordnung mit der Version bereitgestellt haben2018-05-29, entspricht die Antwort der folgenden Vorlage für die Antwortzuordnung:

#if($ctx.error)
     $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
 #end
 $util.toJson($ctx.result)

Wenn Sie mit der Version eine Vorlage bereitgestellt haben2017-02-28, entspricht die Antwortlogik der folgenden Vorlage für die Antwortzuordnung:

$util.toJson($ctx.result)

Oberflächlich betrachtet funktioniert die Umgehung der Zuordnungsvorlage ähnlich wie die Verwendung bestimmter Zuordnungsvorlagen, wie in den vorangegangenen Beispielen gezeigt. Im Hintergrund wird die Auswertung der Mapping-Vorlagen jedoch vollständig umgangen. Da der Schritt zur Vorlagenbewertung umgangen wird, kann es in einigen Szenarien zu einem geringeren Overhead und einer geringeren Latenz bei der Antwort kommen als bei einer Lambda-Funktion mit einer Antwortzuordnungsvorlage, die evaluiert werden muss.

Benutzerdefinierte Fehlerbehandlung bei Direct Lambda Resolver-Antworten

Sie können die Fehlerantworten von Lambda-Funktionen, die Direct Lambda Resolvers aufrufen, anpassen, indem Sie eine benutzerdefinierte Ausnahme auslösen. Das folgende Beispiel zeigt, wie Sie eine benutzerdefinierte Ausnahme erstellen, indem Sie: JavaScript

class CustomException extends Error {
  constructor(message) {
    super(message);
    this.name = "CustomException";
  }
}
 
throw new CustomException("Custom message");

Wenn Ausnahmen ausgelöst werden, errorMessage sind errorType und jeweils das name und message des benutzerdefinierten Fehlers, der ausgelöst wird.

Wenn errorType jaUnauthorizedException, wird anstelle einer benutzerdefinierten Nachricht die Standardnachricht ("You are not authorized to make this call.") AWS AppSync zurückgegeben.

Das folgende Snippet ist ein Beispiel für eine GraphQL-Antwort, die eine benutzerdefinierte Version demonstriert: errorType

{
  "data": {
    "query": null
  },
  "errors": [
    {
      "path": [
        "query"
      ],
      "data": null,
      "errorType": "CustomException",
      "errorInfo": null,
      "locations": [
        {
          "line": 5,
          "column": 10,
          "sourceName": null
        }
      ],
      "message": "Custom Message"
    }
  ]
}

Direct Lambda Resolvers: Batching aktiviert

Sie können das Batching für Ihren Direct Lambda Resolver aktivieren, indem Sie das auf Ihrem Resolver konfigurieren. maxBatchSize Wenn auf einen höheren Wert als 0 für einen Direct Lambda-Resolver gesetzt maxBatchSize ist, AWS AppSync sendet Anfragen stapelweise an Ihre Lambda-Funktion in Größen bis zu. maxBatchSize

Wenn Sie einen Direct 0 Lambda-Resolver auf auf setzenmaxBatchSize, wird das Batching deaktiviert.

Weitere Informationen zur Funktionsweise der Batchverarbeitung mit Lambda-Resolvern finden Sie unter. Anwendungsfall für Fortgeschrittene: Batching

Vorlage für eine Zuordnung anfordern

Wenn die Stapelverarbeitung aktiviert ist und die Vorlage für die Anforderungszuordnung nicht bereitgestellt wird, wird eine Liste von Context Objekten als BatchInvoke Vorgang direkt an Ihre Lambda-Funktion AWS AppSync gesendet.

Vorlage für die Zuordnung von Antworten

Wenn die Stapelverarbeitung aktiviert ist und die Vorlage für die Antwortzuordnung nicht bereitgestellt wird, entspricht die Antwortlogik der folgenden Vorlage für die Antwortzuordnung:

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

Die Lambda-Funktion muss eine Liste von Ergebnissen in derselben Reihenfolge wie die Liste der gesendeten Context Objekte zurückgeben. Sie können einzelne Fehler zurückgeben, indem Sie errorType für ein bestimmtes Ergebnis ein errorMessage und angeben. Jedes Ergebnis in der Liste hat das folgende Format:

{
   "data" : { ... }, // your data
   "errorMessage" : { ... }, // optional, if included an error entry is added to the "errors" object in the AppSync response 
   "errorType" : { ... } // optional, the error type
}

Behandlung von Fehlern von Lambda

Sie können einen Fehler für alle Ergebnisse zurückgeben, indem Sie eine Ausnahme oder einen Fehler in Ihrer Lambda-Funktion auslösen. Wenn die Nutzlastanforderung oder die Antwortgröße für Ihre Batch-Anfrage zu groß ist, gibt Lambda einen Fehler zurück. In diesem Fall sollten Sie erwägen, Ihre maxBatchSize Antwort-Nutzlast zu reduzieren oder deren Größe zu reduzieren.

Informationen zum Umgang mit einzelnen Fehlern finden Sie unterRückgabe einzelner Fehler.

Beispiele für Lambda-Funktionen

Mithilfe des folgenden Schemas können Sie einen Direct Lambda-Resolver für den Post.relatedPosts Feldresolver erstellen und das Batching aktivieren, indem Sie die obigen Einstellungen vornehmen: maxBatchSize 0

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]
}

In der folgenden Abfrage wird die Lambda-Funktion mit Stapeln von zu lösenden Anforderungen aufgerufen: relatedPosts

query getAllPosts {
  allPosts {
    id
    relatedPosts {
      id
    }
  }
}

Im Folgenden finden Sie eine einfache Implementierung einer Lambda-Funktion:

const 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',
  },
}

const relatedPosts = {
  1: [posts['4']],
  2: [posts['3'], posts['5']],
  3: [posts['2'], posts['1']],
  4: [posts['2'], posts['1']],
  5: [],
}
exports.handler = async (event) => {
  console.log('event ->', event)
  // retrieve the ID of each post
  const ids = event.map((context) => context.source.id)
  // fetch the related posts for each post id
  const related = ids.map((id) => relatedPosts[id])

  // return the related posts; or an error if none were found
  return related.map((r) => {
    if (r.length > 0) {
      return { data: r }
    } else {
      return { data: null, errorMessage: 'Not found', errorType: 'ERROR' }
    }
  })
}