Richten Sie benutzerdefinierte Lambda-Integrationen in Gateway ein API

Um zu zeigen, wie die benutzerdefinierte Lambda-Integration eingerichtet wird, erstellen wir ein API Gateway, um die GET /greeting?greeter={name} Methode API zum Aufrufen einer Lambda-Funktion verfügbar zu machen. Verwenden Sie eine der folgenden Lambda-Beispielfunktionen für SieAPI.

Verwenden Sie eine der folgenden Lambda-Beispielfunktionen:

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.

Sie können sie in der Lambda-Konsole oder mithilfe der AWS CLI erstellen. In diesem Abschnitt verweisen wir wie folgt ARN auf diese Funktion:


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

Wenn die Lambda-Funktion im Backend eingestellt ist, fahren Sie mit der Einrichtung von fort. API

So richten Sie die benutzerdefinierte Lambda-Integration mit dem AWS CLI

Rufen Sie den create-rest-api Befehl auf, um ein API zu erstellen:
```
aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)' --region us-west-2
```
Notieren Sie sich den id Wert (te6si5ach7) API des Ergebnisses in der Antwort:
```
{
    "name": "HelloWorld (AWS CLI)", 
    "id": "te6si5ach7", 
    "createdDate": 1508461860
}
```
Sie benötigen den API id gesamten 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 zu erstellen von/greeting:
```
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 auf, um eine API Methodenanforderung zu erstellen vonGET /greeting?greeter={name}:


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 ermöglicht es dem Client, eine Begrüßung von der Lambda-Funktion im Backend zu erhalten. 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 Zuordnungsvorlage übersetzt den greeter Abfragezeichenfolgenparameter in die greeter Eigenschaft der Nutzlast. JSON Dies ist notwendig, da die Eingabe einer Lambda-Funktion im Textkörper ausgedrückt werden muss.

Wichtig
Für Lambda-Integrationen müssen Sie die HTTP Methode von POST für die Integrationsanforderung gemäß der Spezifikation der Lambda-Serviceaktion für Funktionsaufrufen verwenden. Der uri Parameter ist der der Aktion, die die Funktion aufruftARN.
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 von apigAwsProxyRole muss Richtlinien haben, die es dem apigateway Dienst ermöglichen, Lambda-Funktionen aufzurufen. Anstatt eine IAM Rolle für anzugebencredentials, 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, API um das in einer test Phase bereitzustellen:


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

Testen API Sie das mit dem folgenden URL C-Befehl 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

Richten Sie eine Proxyressource mit Lambda-Proxyintegration mit einer offenen API Definition ein

Asynchronen Aufruf der Backend-Lambda-Funktion einrichten

Richten Sie benutzerdefinierte Lambda-Integrationen in Gateway ein API

So richten Sie die benutzerdefinierte Lambda-Integration mit dem AWS CLI

Wichtig