Benutzerdefinierte Lambda-Integrationen in API Gateway einrichten

Um zu zeigen, wie die benutzerdefinierte Lambda-Integration eingerichtet wird, erstellen wir ein API Gateway-API, um die GET /greeting?greeter={name}-Methode zum Aufrufen einer Lambda-Funktion bereitzustellen. Die Funktion gibt die Nachricht "Hello, {name}!" zurück, sofern der greeter-Parameterwert keine leere Zeichenfolge ist. Wenn der "Hello, World!"-Wert eine leere Zeichenfolge ist, wird als Antwort greeter zurückgegeben. Die Funktion gibt eine Fehlermeldung zurück, "Missing the required greeter parameter." wenn der "greeter"-Parameter in der eingehenden Anforderung nicht festgelegt ist. Wir geben der Funktion den Namen HelloWorld.

Eine Node.js-Version der Lambda-Funktion sieht wie folgt aus:


export const handler = function(event, context, callback) {
    var res ={
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    };
    if (event.greeter==null) {
        callback(new Error('Missing the required greeter parameter.'));
    } else if (event.greeter === "") {
        res.body = "Hello, World";
        callback(null, res);
    } else {
        res.body = "Hello, " + event.greeter +"!";
        callback(null, res);
    }
};

Sie können sie in der Lambda-Konsole oder mithilfe der AWS CLI erstellen. In diesem Abschnitt definieren wir diese Funktion mithilfe des folgenden ARN:


arn:aws:lambda:us-east-1:123456789012:function:HelloWorld

Wenn die Lambda-Funktion im Backend eingerichtet ist, fahren Sie mit dem Einrichten der API fort.

So richten Sie die benutzerdefinierte Lambda-Integration mithilfe der AWS CLI ein:

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": "HelloWorld (AWS CLI)", 
    "id": "te6si5ach7", 
    "createdDate": 1508461860
}
```
Sie benötigen die API-id in diesem Abschnitt.
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 lautet folgendermaßen:
```
{
    "items": [
        {
            "path": "/", 
            "id": "krznpq9xpg"
        }
    ]
}
```
Notieren Sie den id-Wert (krznpq9xpg) der Ressource. Sie benötigen diese in den nächsten Schritten.
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 greeting
```
Eine erfolgreiche Antwort ähnelt dem folgenden Beispiel:
```
{
    "path": "/greeting", 
    "pathPart": "greeting", 
    "id": "2jf6xt", 
    "parentId": "krznpq9xpg"
}
```
Notieren Sie den ausgegebenen id-Wert (2jf6xt) der greeting-Ressource. Sie benötigen die ID, um im nächsten Schritt eine Methode auf der /greeting-Ressource zu erstellen.

Rufen Sie put-method zum Erstellen einer GET /greeting?greeter={name}-API-Methodenanforderung auf:


aws apigateway put-method --rest-api-id te6si5ach7 \
       --region us-west-2 \
       --resource-id 2jf6xt \
       --http-method GET \
       --authorization-type "NONE" \
       --request-parameters method.request.querystring.greeter=false

Eine erfolgreiche Antwort ähnelt dem folgenden Beispiel:


{
    "apiKeyRequired": false, 
    "httpMethod": "GET", 
    "authorizationType": "NONE", 
    "requestParameters": {
        "method.request.querystring.greeter": false
    }
}

Diese API-Methode gestattet dem Client, einen Gruß über die Lambda-Funktion am Backend zu empfangen. Der greeter-Parameter ist optional, da das Backend entweder einen anonymen Aufrufer oder einen selbst identifizierten Aufrufer verarbeiten sollte.

Rufen Sie put-method-response auf, um auf die Anforderung von 200 OK die Antwort GET /greeting?greeter={name} einzurichten:


aws apigateway put-method-response \
        --region us-west-2 \
        --rest-api-id te6si5ach7 \ 
        --resource-id 2jf6xt \
        --http-method GET \
        --status-code 200

Rufen Sie put-integration auf, um die Integration der GET /greeting?greeter={name}-Methode mit einer Lambda-Funktion namens HelloWorld einzurichten. Die 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 GET \
        --type AWS \
        --integration-http-method POST \
        --uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations \
        --request-templates '{"application/json":"{\"greeter\":\"$input.params('greeter')\"}"}' \
        --credentials arn:aws:iam::123456789012:role/apigAwsProxyRole
```
Die hier bereitgestellte Mapping-Vorlage übersetzt den greeter-Abfragezeichenfolgeparameter in den greeter-Parameter der JSON-Nutzlast. Dies ist notwendig, da die Eingabe einer Lambda-Funktion in der Lambda-Funktion im Datenteil ausgedrückt werden muss. Sie können die JSON-Zeichenfolge der Zuordnung (z. B. "{\"greeter"\: \"'john'\"}") als request-template-Eingabewert für den put-integration-Befehl verwenden. Durch die Verwendung der Dateieingabe wird jedoch das schwierige und manchmal unmögliche Setzen der Anführungszeichen zum Umwandeln eines JSON-Objekts in eine Zeichenfolge vermieden.

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. Der uri-Parameter ist der ARN der Aktion, die die Funktion aufruft.
Im Erfolgsfall sollte die Ausgabe in etwa folgendermaßen aussehen:
```
{
    "passthroughBehavior": "WHEN_NO_MATCH", 
    "cacheKeyParameters": [], 
    "uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations", 
    "httpMethod": "POST", 
    "requestTemplates": {
        "application/json": "{\"greeter\":\"$input.params('greeter')\"}"
    }, 
    "cacheNamespace": "krznpq9xpg", 
    "credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole", 
    "type": "AWS"
}
```
Die IAM-Rolle apigAwsProxyRole muss über Richtlinien verfügen, die es dem apigateway-Service erlauben, Lambda-Funktionen aufzurufen. Anstatt eine IAM-Rolle für credentials bereitzustellen, können Sie den Befehl add-permission aufrufen, um ressourcenbasierte Berechtigungen hinzuzufügen. Auf diese Weise fügt die API Gateway-Konsole diese Berechtigungen hinzu.
Rufen Sie put-integration-response auf, um die Integrationsantwort zur Übergabe der Ausgabe der Lambda-Funktion an den Client als Antwort auf die 200 OK-Methode einzurichten.
```
 aws apigateway put-integration-response \
        --region us-west-2 \
        --rest-api-id te6si5ach7 \
        --resource-id 2jf6xt \
        --http-method GET \
        --status-code 200 \
        --selection-pattern ""  
        
```
Beim Festlegen des Auswahlmusters auf eine leere Zeichenfolge lautet die voreingestellte Antwort 200 OK.

Die erfolgreiche Antwort sollte nachstehender Antwort entsprechen:
```
 {
    "selectionPattern": "", 
    "statusCode": "200"
}
```

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

Testen Sie die API mithilfe des folgenden cURL-Befehls in einem Terminal:


curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=me' \
  -H 'authorization: AWS4-HMAC-SHA256 Credential={access_key}/20171020/us-west-2/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=f327...5751'

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

Lambda-Proxy-Integrationen einrichten

Asynchronen Aufruf der Backend-Lambda-Funktion einrichten