Lambda-Proxy-Integrationen in API Gateway einrichten

API Gateway Lambda-Proxy-Integration kennenlernen

Die Amazon API Gateway-Lambda-Proxy-Integration ist ein einfacher, leistungsstarker und schneller Mechanismus zur Erstellung einer API mit der Einrichtung einer einzigen API-Methode. Die Lambda-Proxy-Integration ermöglicht es dem Client, eine einzelne Lambda-Funktion im Backend aufzurufen. Die Funktion greift auf viele Ressourcen oder Funktionen anderer - AWS Services zu, einschließlich des Aufrufs anderer Lambda-Funktionen.

Bei der Lambda-Proxy-Integration übergibt API Gateway beim Senden einer API-Anfrage ein Ereignisobjekt an die integrierte Lambda-Funktion. Allerdings wird die Reihenfolge der Anfrageparameter nicht beibehalten. Diese Anforderungsdaten umfassen die Abfrage-Header, Parameter für Abfragezeichenfolgen, die URL-Pfadvariablen, die Nutzlast und API-Konfigurationsdaten. Die Konfigurationsdaten können den aktuellen Bereitstellungsstufennamen, Stufenvariablen, die Benutzeridentität oder den Autorisierungskontext (falls vorhanden) umfassen. Die Backend-Lambda-Funktion analysiert die eingehenden Anfragedaten, um die eigene Antwort zu bestimmen. Damit API Gateway die Lambda-Ausgabe als API-Antwort an den Client weiterleiten kann, muss die Lambda-Funktion das Ergebnis in diesem Format zurückgeben.

Da API Gateway für die Lambda-Proxy-Integration zwischen dem Client und der Backend-Lambda-Funktion nur unwesentlich eingreift, können sich der Client und die integrierte Lambda-Funktion an Änderungen in der jeweils anderen Funktion anpassen, ohne die bestehende Integrationseinrichtung der API zu stören. Hierzu muss der Client den Anwendungsprotokollen der Backend-Lambda-Funktion folgen.

Sie können eine Lambda-Proxy-Integration für jede API-Methode einrichten. Aber eine Lambda-Proxy-Integration ist leistungsstärker, wenn sie über eine allgemeine Proxy-Ressource für eine API-Methode konfiguriert wird. Die allgemeine Proxy-Ressource kann durch eine spezielle Vorlagenpfadvariable {proxy+}, den Catch-All-ANY-Methodenplatzhalter oder beides angegeben werden. Der Client kann die Eingabe an die Backend-Lambda-Funktion in der eingehenden Anfrage als Anfrageparameter oder als entsprechende Nutzlast übergeben. Zu den Anforderungsparametern gehören Header-, URL-Pfadvariablen, Abfragezeichenfolgenparameter und die entsprechende Nutzlast. Die integrierte Lambda-Funktion prüft alle Eingangsquellen vor ihrer Verarbeitung und der Antwort an den Client mit sinnvollen Fehlermeldungen, falls die erforderliche Eingabe fehlt.

Beim Aufrufen einer mit der allgemeinen HTTP-Methode ANY und der allgemeinen Ressource {proxy+} integrierten API-Methode sendet der Client eine Anforderung mit einer bestimmten HTTP-Methode statt mit ANY. Der Client gibt zudem einen bestimmten URL-Pfad statt {proxy+} an und umfasst alle erforderlichen Header, Abfragezeichenfolgenparameter oder eine anwendbare Nutzlast.

Die folgende Liste enthält eine Zusammenfassung des Laufzeitverhaltens verschiedener API-Methoden bei der Lambda-Proxy-Integration:

• ANY /{proxy+}: Der Client muss eine bestimmte HTTP-Methode auswählen, eine bestimmte Ressourcenpfadhierarchie festlegen und kann alle Header, Parameter für Abfragezeichenfolgen und den Payload für die Eingabe an die integrierte Lambda-Funktion festlegen.

• ANY /res: Der Client muss eine bestimmte HTTP-Methode auswählen und kann alle Header, Parameter für Abfragezeichenfolgen und die Nutzlast für die Eingabe an die integrierte Lambda-Funktion festlegen.

• GET|POST|PUT|... /{proxy+}: Der Client kann eine bestimmte Ressourcenpfadhierarchie festlegen und kann alle Header, Parameter für Abfragezeichenfolgen und die Nutzlast für die Eingabe an die integrierte Lambda-Funktion festlegen.

• GET|POST|PUT|... /res/{path}/...: Der Client muss ein bestimmtes Pfadsegment (für die {path}-Variable) festlegen und kann alle Anfrage-Header, Parameter für Abfragezeichenfolgen und die Nutzlast für die Eingabedaten an die integrierte Lambda-Funktion festlegen.

• GET|POST|PUT|... /res: Der Client kann bestimmte Anfrage-Header auswählen und kann alle Header, Parameter für Abfragezeichenfolgen und die Nutzlast für die Eingabedaten an die integrierte Lambda-Funktion festlegen.

Sowohl die Proxy-Ressource {proxy+} und die benutzerdefinierte Ressource {custom} werden als Vorlagenpfadvariablen ausgedrückt. Allerdings kann {proxy+} auf alle Ressourcen in einer Pfadhierarchie verweisen, während sich {custom} nur auf ein bestimmtes Pfadsegment bezieht. Beispielsweise könnte ein Lebensmittelgeschäft sein Online-Produktsortiment nach Abteilungsnamen, Kategorien und Produktarten organisieren. Die Website des Lebensmittelgeschäfts kann dann verfügbare Produkte über die folgenden Vorlagenpfadvariablen darstellen: /{department}/{produce-category}/{product-type}. Zum Beispiel werden Äpfel mit /produce/fruit/apple und Karotten mit /produce/vegetables/carrot dargestellt. Es kann auch /{proxy+} als Platzhalter für eine beliebige Abteilung, eine beliebige Kategorie oder einen Produkttyp verwendet werden, nach dem ein Kunde im Online-Shop suchen kann. Beispielsweise kann /{proxy+} auf eines der folgenden Elemente verweisen:

• /produce

• /produce/fruit

• /produce/vegetables/carrot

Um Kunden nach den verfügbaren Produkten, der Kategorie und der zugeordneten Abteilung suchen zu lassen, können Sie eine einzelne GET /{proxy+}-Methode mit Leseberechtigungen bereitstellen. Um einem Supervisor das Aktualisieren des produce Abteilungsbestands zu ermöglichen, können Sie eine andere, einzelne PUT /produce/{proxy+}-Methode mit Lese-/Schreibberechtigungen hinzufügen. Um einem Kassierer das Aktualisieren der Gesamtsumme einer Gemüsesorte zu ermöglichen, können Sie eine POST /produce/vegetables/{proxy+}-Methode mit Lese-/Schreibberechtigungen einrichten. Wenn ein Shop-Manager sämtliche möglichen Aktionen für beliebige verfügbare Produkte durchführen soll, kann der Online-Shop-Entwickler die ANY /{proxy+} Methode mit Lese-/Schreibberechtigungen hinzufügen. In jedem Fall muss der Kunde oder der Mitarbeiter zur Laufzeit ein bestimmtes Produkt eines bestimmten Typs in einer bestimmten Abteilung, eine bestimmte Kategorie in einer bestimmten Abteilung, oder eine bestimmte Abteilung auswählen.

Weitere Informationen zum Einrichten der API Gateway-Proxy-Integrationen finden Sie unter Einrichten der Proxy-Integration mit einer Proxy-Ressource.

Die Proxy-Integration erfordert, dass der Client über detaillierte Kenntnisse der Backend-Anforderungen verfügt. Um eine optimale App-Leistung und Benutzererfahrung sicherzustellen, muss der Backend-Entwickler die Anforderungen des Backends klar an den Client-Entwickler kommunizieren. Er muss einen robusten Feedback-Mechanismus für nicht erfüllte Anforderungen bereitstellen.

Support für mehrwertige Header- und Abfragezeichenfolgenparameter

API Gateway unterstützt mehrere gleichnamige Header und Abfragezeichenfolgenparameter. Mehrwertige Header sowie einwertige Header und Parameter können in denselben Anforderungen und Antworten kombiniert werden. Weitere Informationen finden Sie unter Eingabeformat einer Lambda-Funktion für die Proxy-Integration und Ausgabeformat einer Lambda-Funktion für die Proxy-Integration.

Proxy-Ressource mit Lambda-Proxy-Integration einrichten

Erstellen Sie zum Einrichten einer Proxy-Ressource mit dem Lambda-Proxy-Integrationstyp eine API-Ressource mit einem Greedy-Pfadparameter (z. B. /parent/{proxy+}) und integrieren Sie diese Ressource mit einem Lambda-Funktions-Backend (z. B. arn:aws:lambda:us-west-2:123456789012:function:SimpleLambda4ProxyResource) für die Methode ANY. Der Greedy-Pfadparameter muss am Ende des API-Ressourcenpfads stehen. Wie bei einer Nicht-Proxy-Ressource können Sie die Proxy-Ressource einrichten, indem Sie die API Gateway-Konsole verwenden, eine OpenAPI-Definitionsdatei importieren oder die API Gateway-REST-API direkt aufrufen.

Die folgende OpenAPI-API-Definitionsdatei zeigt ein Beispiel für eine API mit einer Proxyressource, die mit der Lambda-Funktion SimpleLambda4ProxyResource integriert wird.

OpenAPI 3.0

{
   "openapi": "3.0.0",
   "info": {
      "version": "2016-09-12T17:50:37Z",
      "title": "ProxyIntegrationWithLambda"
   },
   "paths": {
      "/{proxy+}": {
         "x-amazon-apigateway-any-method": {
            "parameters": [
               {
                  "name": "proxy",
                  "in": "path",
                  "required": true,
                  "schema": {
                     "type": "string"
                  }
               }
            ],
            "responses": {},
            "x-amazon-apigateway-integration": {
               "responses": {
                  "default": {
                     "statusCode": "200"
                  }
               },
               "uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:SimpleLambda4ProxyResource/invocations",
               "passthroughBehavior": "when_no_match",
               "httpMethod": "POST",
               "cacheNamespace": "roq9wj",
               "cacheKeyParameters": [
                  "method.request.path.proxy"
               ],
               "type": "aws_proxy"
            }
         }
      }
   },
   "servers": [
      {
         "url": "https://gy415nuibc.execute-api.us-east-1.amazonaws.com/{basePath}",
         "variables": {
            "basePath": {
              "default": "/testStage"
            }
         }
      }
   ]
}

OpenAPI 2.0

{
  "swagger": "2.0",
  "info": {
    "version": "2016-09-12T17:50:37Z",
    "title": "ProxyIntegrationWithLambda"
  },
  "host": "gy415nuibc.execute-api.us-east-1.amazonaws.com",
  "basePath": "/testStage",
  "schemes": [
    "https"
  ],
  "paths": {
    "/{proxy+}": {
      "x-amazon-apigateway-any-method": {
        "produces": [
          "application/json"
        ],
        "parameters": [
          {
            "name": "proxy",
            "in": "path",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {},
        "x-amazon-apigateway-integration": {
          "responses": {
            "default": {
              "statusCode": "200"
            }
          },
          "uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:SimpleLambda4ProxyResource/invocations",
          "passthroughBehavior": "when_no_match",
          "httpMethod": "POST",
          "cacheNamespace": "roq9wj",
          "cacheKeyParameters": [
            "method.request.path.proxy"
          ],
          "type": "aws_proxy"
        }
      }
    }
  }
}

Bei der Lambda-Proxy-Integration ordnet API Gateway zur Laufzeit eine eingehende Anfrage dem Eingabe-event-Parameter der Lambda-Funktion zu. Die Eingabe umfasst die Anforderungsmethode, den Pfad, Header, jegliche Zeichenparameter, jegliche Nutzlast, zugehörigen Kontext und alle definierten Stufenvariablen. Eine Beschreibung des Eingabeformats finden Sie unter Eingabeformat einer Lambda-Funktion für die Proxy-Integration. Damit API Gateway die Lambda-Ausgabe erfolgreich den HTTP-API-Antworten zuordnen kann, muss die Lambda-Funktion das Ergebnis in dem unter Ausgabeformat einer Lambda-Funktion für die Proxy-Integration beschriebenen Format ausgeben.

Bei der Lambda-Proxy-Integration einer Proxy-Ressource durch die ANY-Methode dient die einzelne Backend-Lambda-Funktion als Ereignis-Handler für alle Anfragen über die Proxy-Ressource. Beispielsweise können Sie zum Protokollieren der Datenverkehrsmuster ein Mobilgerät veranlassen, seinen Standort mit Angaben zu Bundesland, Stadt, Straße und Gebäude zu senden, indem Sie eine Anforderung mit /state/city/street/house im URL-Pfad für die Proxy-Ressource übermitteln. Die Backend-Lambda-Funktion kann dann den URL-Pfad analysieren und die Location-tuples in eine DynamoDB-Tabelle einfügen.

Einrichten der Lambda-Proxy-Integration mithilfe der AWS CLI

In diesem Abschnitt zeigen wir, wie Sie verwenden, AWS CLI um eine API mit der Lambda-Proxy-Integration einzurichten.

Anmerkung

Detaillierte Anweisungen zur Verwendung der API Gateway-Konsole zur Konfiguration einer Proxy-Ressource mit der Lambda-Proxy-Integration finden Sie unter Tutorial: Hello World REST-API mit Lambda-Proxy-Integration erstellen.

Als Beispiel verwenden wir die folgende Lambda-Beispielfunktion als Backend der API:

export const handler = function(event, context, callback) {
    console.log('Received event:', JSON.stringify(event, null, 2));
    var res ={
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    };
    var greeter = 'World';
    if (event.greeter && event.greeter!=="") {
        greeter =  event.greeter;
    } else if (event.body && event.body !== "") {
        var body = JSON.parse(event.body);
        if (body.greeter && body.greeter !== "") {
            greeter = body.greeter;
        }
    } else if (event.queryStringParameters && event.queryStringParameters.greeter && event.queryStringParameters.greeter !== "") {
        greeter = event.queryStringParameters.greeter;
    } else if (event.multiValueHeaders && event.multiValueHeaders.greeter && event.multiValueHeaders.greeter != "") {
        greeter = event.multiValueHeaders.greeter.join(" and ");
    } else if (event.headers && event.headers.greeter && event.headers.greeter != "") {
        greeter = event.headers.greeter;
    } 
    
    res.body = "Hello, " + greeter + "!";
    callback(null, res);
};

Vergleicht man dies mit der benutzerdefinierten Lambda-Integrationseinrichtung , kann die Eingabe für diese Lambda-Funktion in den Anfrageparametern und im Datenteil definiert werden. Sie haben mehr Spielraum, um dem Client die Weitergabe der gleichen Eingabedaten zu ermöglichen. Hier kann der Client den Namen von "greeter" als Abfragezeichenfolgeparameter, Kopfzeile oder Texteigenschaft übergeben. Die Funktion kann außerdem die benutzerdefinierte Lambda-Integration unterstützen. Die API-Einrichtung ist einfacher. Sie müssen keine Methoden- oder Integrationsantwort konfigurieren.

So richten Sie eine Lambda-Proxy-Integration mithilfe der ein AWS CLI

1. Rufen Sie den Befehl create-rest-api auf, um eine API zu erstellen:

   aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)' --region us-west-2

   Notieren Sie den in der Antwort für die API-id angegebenen Wert (te6si5ach7).

   {
       "name": "HelloWorldProxy (AWS CLI)", 
       "id": "te6si5ach7", 
       "createdDate": 1508461860
   }

   Sie benötigen die API-id in diesem Abschnitt.

2. Rufen Sie den Befehl get-resources auf, um die id der Stammressource zu ermitteln.

   aws apigateway get-resources --rest-api-id te6si5ach7 --region us-west-2

   Die erfolgreiche Antwort wird wie folgt angezeigt:

   {
       "items": [
           {
               "path": "/", 
               "id": "krznpq9xpg"
           }
       ]
   }

   Notieren Sie den id-Wert (krznpq9xpg) der Ressource. Sie benötigen diese in den nächsten Schritten.

3. Rufen Sie create-resource auf, um eine API Gateway-Ressource /greeting zu erstellen:

   aws apigateway create-resource --rest-api-id te6si5ach7 \
         --region us-west-2 \
         --parent-id krznpq9xpg \
         --path-part {proxy+}

   Eine erfolgreiche Antwort ähnelt dem folgenden Beispiel:

   {
       "path": "/{proxy+}", 
       "pathPart": "{proxy+}", 
       "id": "2jf6xt", 
       "parentId": "krznpq9xpg"
   }

   Notieren Sie den ausgegebenen id-Wert (2jf6xt) der {proxy+}-Ressource. Sie benötigen die ID, um im nächsten Schritt eine Methode auf der /{proxy+}-Ressource zu erstellen.

4. Rufen Sie put-method zum Erstellen einer ANY-Methodenanforderung ANY /{proxy+} auf:

   aws apigateway put-method --rest-api-id te6si5ach7 \
          --region us-west-2 \
          --resource-id 2jf6xt \
          --http-method ANY \
          --authorization-type "NONE" 

   Eine erfolgreiche Antwort ähnelt dem folgenden Beispiel:

   {
       "apiKeyRequired": false, 
       "httpMethod": "ANY", 
       "authorizationType": "NONE"
   }

   Diese API-Methode gestattet dem Client, einen Gruß über die Lambda-Funktion am Backend zu empfangen oder zu senden.

5. Rufen Sie put-integration auf, um die Integration der ANY /{proxy+}-Methode mit einer Lambda-Funktion namens HelloWorld einzurichten. Diese Funktion beantwortet die Anforderung mit der Nachricht "Hello, {name}!", sofern der greeter-Parameter angegeben wurde, oder "Hello, World!", wenn kein Abfragezeichenfolgeparameter festgelegt wurde.

   aws apigateway put-integration \
           --region us-west-2 \
           --rest-api-id te6si5ach7 \
           --resource-id 2jf6xt \
           --http-method ANY \
           --type AWS_PROXY \
           --integration-http-method POST \
           --uri arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:HelloWorld/invocations \
           --credentials arn:aws:iam::123456789012:role/apigAwsProxyRole

   Wichtig

   Für Lambda-Integrationen müssen Sie entsprechend der Spezifikation der Lambda-Service-Aktion für Funktionsaufrufe die HTTP-Methode POST für die Integrationsanfrage verwenden. Die IAM-Rolle apigAwsProxyRole muss über Richtlinien verfügen, die es dem apigateway-Service erlauben, Lambda-Funktionen aufzurufen. Weitere Informationen zu IAM-Berechtigungen finden Sie unter API Gateway-Berechtigungsmodell für den Aufruf einer API.

   Im Erfolgsfall sieht die Ausgabe folgendermaßen oder ähnlich aus:

   {
       "passthroughBehavior": "WHEN_NO_MATCH", 
       "cacheKeyParameters": [], 
       "uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:1234567890:function:HelloWorld/invocations", 
       "httpMethod": "POST", 
       "cacheNamespace": "vvom7n", 
       "credentials": "arn:aws:iam::1234567890:role/apigAwsProxyRole", 
       "type": "AWS_PROXY"
   }

   Anstatt eine IAM-Rolle für credentials bereitzustellen, können Sie den Befehl add-permission aufrufen, um ressourcenbasierte Berechtigungen hinzuzufügen. Dies erledigt die API Gateway-Konsole.

6. Rufen Sie create-deployment auf, um die API für eine test-Stufe bereitzustellen:

   aws apigateway create-deployment --rest-api-id te6si5ach7 --stage-name test --region us-west-2

7. Testen Sie die API mithilfe der folgenden cURL-Befehle in einem Terminal.

   API-Aufruf mit dem Abfragezeichenfolgeparameter ?greeter=jane:

   curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=jane'

   API-Aufruf mit einem Header-Parameter greeter:jane:

   curl -X GET https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
     -H 'content-type: application/json' \
     -H 'greeter: jane'

   API-Aufruf mit einem Textkörper-Parameter {"greeter":"jane"}:

   curl -X POST https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
     -H 'content-type: application/json' \
     -d '{ "greeter": "jane" }'

   In allen Fällen ist die Ausgabe eine Antwort mit dem folgenden Antworttext: 200

   Hello, jane!

Eingabeformat einer Lambda-Funktion für die Proxy-Integration

Bei der Lambda-Proxy-Integration ordnet API Gateway die gesamte Client-Anforderung dem event-Eingabeparameter der Backend-Lambda-Funktion zu. Das folgende Beispiel zeigt die Struktur eines Ereignisses, das API Gateway an eine Lambda-Proxy-Integration sendet.

{
  "resource": "/my/path",
  "path": "/my/path",
  "httpMethod": "GET",
  "headers": {
    "header1": "value1",
    "header2": "value1,value2"
  },
  "multiValueHeaders": {
    "header1": [
      "value1"
    ],
    "header2": [
      "value1",
      "value2"
    ]
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "multiValueQueryStringParameters": {
    "parameter1": [
      "value1",
      "value2"
    ],
    "parameter2": [
      "value"
    ]
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "id",
    "authorizer": {
      "claims": null,
      "scopes": null
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "extendedRequestId": "request-id",
    "httpMethod": "GET",
    "identity": {
      "accessKey": null,
      "accountId": null,
      "caller": null,
      "cognitoAuthenticationProvider": null,
      "cognitoAuthenticationType": null,
      "cognitoIdentityId": null,
      "cognitoIdentityPoolId": null,
      "principalOrgId": null,
      "sourceIp": "IP",
      "user": null,
      "userAgent": "user-agent",
      "userArn": null,
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "path": "/my/path",
    "protocol": "HTTP/1.1",
    "requestId": "id=",
    "requestTime": "04/Mar/2020:19:15:17 +0000",
    "requestTimeEpoch": 1583349317135,
    "resourceId": null,
    "resourcePath": "/my/path",
    "stage": "$default"
  },
  "pathParameters": null,
  "stageVariables": null,
  "body": "Hello from Lambda!",
  "isBase64Encoded": false
}

Anmerkung

Wählen Sie im Bereich

• Der headersSchlüssel kann nur einwertige Header enthalten

• Der multiValueHeadersSchlüssel kann mehrwertige Header sowie einwertige Header enthalten.

• Wenn Sie Werte sowohl für headers als auch für multiValueHeaders angeben, führt API Gateway diese in einer einzigen Liste zusammen. Wenn in beiden das gleiche Schlüssel / Wert-Paar angegeben ist, werden nur die Werte von in der multiValueHeaderszusammengeführten Liste angezeigt.

In der Eingabe an die Backend-Lambda-Funktion ist das requestContext-Objekt eine Zuordnung von Schlüssel-Werte-Paaren. In jedem Paar ist der Schlüssel der Name einer $context-Variableneigenschaft, und der Wert ist der Wert dieser Eigenschaft. API Gateway kann der Zuordnung neue Schlüssel hinzufügen.

Abhängig von den aktivierten Funktionen kann die Zuweisung requestContext von API zu API unterschiedlich sein. Im obigen Beispiel ist z. B. kein Autorisierungstyp angegeben, sodass keine $context.authorizer.*- oder $context.identity.*-Eigenschaften vorhanden sind. Wenn ein Autorisierungstyp angegeben wird, bewirkt dies, dass API Gateway autorisierte Benutzerinformationen wie folgt in einem requestContext.identity-Objekt an den Integrationsendpunkt weiterleitet:

• Wenn der Autorisierungstyp AWS_IAM ist, enthalten die autorisierten Benutzerinformationen $context.identity.*-Eigenschaften.

• Wenn der Autorisierungstyp COGNITO_USER_POOLS ist (Amazon Cognito-Genehmiger), enthalten die autorisierten Benutzerinformationen die Eigenschaften $context.identity.cognito* und $context.authorizer.claims.*.

• Wenn der Autorisierungstyp CUSTOM (Lambda-Genehmiger) ist, enthalten die autorisierten Benutzerinformationen $context.authorizer.principalId- und andere relevante $context.authorizer.*-Eigenschaften.

Ausgabeformat einer Lambda-Funktion für die Proxy-Integration

Bei der Lambda-Proxy-Integration erfordert API Gateway, dass die Backend-Lambda-Funktion die Ausgabe gemäß dem folgenden JSON-Format zurückgibt:

{
    "isBase64Encoded": true|false,
    "statusCode": httpStatusCode,
    "headers": { "headerName": "headerValue", ... },
    "multiValueHeaders": { "headerName": ["headerValue", "headerValue2", ...], ... },
    "body": "..."
}

In der Konsolenausgabe:

• Die Schlüssel headers und multiValueHeaders können nicht angegeben werden, wenn keine zusätzlichen Antwortheader zurückgegeben werden sollen.

• Der headersSchlüssel kann nur einwertige Header enthalten

• Der multiValueHeadersSchlüssel kann mehrwertige Header sowie einwertige Header enthalten. Sie können den multiValueHeadersSchlüssel verwenden, um alle zusätzlichen Header anzugeben, einschließlich einzelner Werte.

• Wenn Sie Werte sowohl für headers als auch für multiValueHeaders angeben, führt API Gateway diese in einer einzigen Liste zusammen. Wenn in beiden das gleiche Schlüssel / Wert-Paar angegeben ist, werden nur die Werte von in der multiValueHeaderszusammengeführten Liste angezeigt.

Um CORS für die Lambda-Proxy-Integration zu aktivieren, müssen Sie der Ausgabe headers Access-Control-Allow-Origin:domain-name hinzufügen. domain-name kann * für einen beliebigen Domänennamen sein. Die Ausgabe body wird als Nutzlast der Methodenanforderung an das Frontend angeordnet Wenn body ein binärer Blob ist, können Sie ihn als Base64-kodierte Zeichenfolge codieren, indem Sie isBase64Encoded auf true festlegen und */* als Binary Media Type (Binärer Medientyp) konfigurieren. Andernfalls können Sie den Wert auf false festlegen oder keinen Wert angeben.

Anmerkung

Weitere Informationen zur Aktivierung der Unterstützung von Binärdateien finden Sie unter Binärunterstützung über die API Gateway-Konsole aktivieren. Eine Beispielfunktion für Lambda finden Sie unter Rückgabe binärer Medien von einer Lambda-Proxy-Integration.

Wenn die Funktionsausgabe ein anderes Format hat, gibt API Gateway eine 502 Bad Gateway-Fehlerantwort zurück.

Um eine Antwort in einer Lambda-Funktion in Node.js zurückzugeben, können Sie Befehle wie den folgenden verwenden:

• Um ein erfolgreiches Ergebnis zurückzugeben, rufen Sie au callback(null, {"statusCode": 200, "body": "results"}).

• Rufen Sie zum Auslösen einer Ausnahme au callback(new Error('internal server error')).

• Bei einem Fehler auf Clientseite, z. B. wenn ein erforderlicher Parameter fehlt, können Sie callback(null, {"statusCode": 400, "body": "Missing parameters of ..."}) aufrufen, um den Fehler zurückzugeben, ohne eine Ausnahme auszulösen.

In einer Lambda-async-Funktion in Node.js würde die entsprechende Syntax so lauten:

• Um ein erfolgreiches Ergebnis zurückzugeben, rufen Sie au return {"statusCode": 200, "body": "results"}.

• Rufen Sie zum Auslösen einer Ausnahme au throw new Error("internal server error").

• Bei einem Fehler auf Clientseite, z. B. wenn ein erforderlicher Parameter fehlt, können Sie return {"statusCode": 400, "body": "Missing parameters of ..."} aufrufen, um den Fehler zurückzugeben, ohne eine Ausnahme auszulösen.