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.

# Benutzerdefinierte Lambda-Integrationen in API Gateway einrichten
<a name="set-up-lambda-custom-integrations"></a>

 Um zu zeigen, wie die benutzerdefinierte (nicht-Proxy-)Lambda-Integration eingerichtet wird, erstellen wir ein API in API Gateway, um die `GET /greeting?greeter={name}`-Methode zum Aufrufen einer Lambda-Funktion bereitzustellen. Verwenden Sie eine der folgenden Lambda-Beispielfunktionen für Ihre API.

Verwenden Sie eine der folgenden Lambda-Beispielfunktionen:

------
#### [ Node.js ]

```
'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

export const handler = async(event) => {
  console.log(event);
  // Parse the input for the name, city, time and day property values
  let name = event.name === null || event.name === undefined || event.name === "" ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  return greeting;
};
```

------
#### [ Python ]

```
import json


def lambda_handler(event, context):
    print(event)
    res = {
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    }

    if event['greeter'] == "":
        res['body'] = "Hello, World"
    elif (event['greeter']):
        res['body'] = "Hello, " + event['greeter'] + "!"
    else:
        raise Exception('Missing the required greeter parameter.')

    return res
```

------

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 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.<a name="set-up-lambda-custom-integration-using-cli"></a>

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

1. Verwenden Sie den folgenden [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)Befehl, um eine API zu erstellen:

   ```
   aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)'
   ```

   Die Ausgabe sieht wie folgt aus:

   ```
   {
       "name": "HelloWorld (AWS CLI)", 
       "id": "te6si5ach7",
       "rootResourceId" : "krznpq9xpg",
       "createdDate": 1508461860
   }
   ```

   In diesem Beispiel verwenden Sie durchgängig die API `id` (`te6si5ach7`) und die `rootResourceId` (`krznpq9xpg`).

1. Verwenden Sie den folgenden [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html)-Befehl, um eine API-Gateway-[Ressource](https://docs.aws.amazon.com/apigateway/latest/api/API_Resource.html) mit dem Namen `/greeting` zu erstellen:

   ```
   aws apigateway create-resource \
         --rest-api-id te6si5ach7 \
         --parent-id krznpq9xpg \
         --path-part greeting
   ```

   Die Ausgabe sieht wie folgt aus:

   ```
   {
       "path": "/greeting", 
       "pathPart": "greeting", 
       "id": "2jf6xt", 
       "parentId": "krznpq9xpg"
   }
   ```

   Sie verwenden den `id`-Wert der Ressource `greeting` (`2jf6xt`), um im nächsten Schritt eine Methode für die Ressource `/greeting` zu erstellen.

1. Verwenden Sie den folgenden [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html)-Befehl, um eine API-Methodenanforderung von `GET /greeting?greeter={name}` zu erstellen:

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

   Die Ausgabe sieht wie folgt aus:

   ```
   {
       "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.

1. Verwenden Sie den folgenden [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)Befehl, um die `200 OK` Antwort auf die Methodenanforderung von einzurichten`GET /greeting?greeter={name}`:

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

   

1. Verwenden Sie den folgenden [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html)-Befehl, um die Integration der `GET /greeting?greeter={name}`-Methode mit einer Lambda-Funktion mit dem Namen `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 \
           --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 im Textkörper ausgedrückt werden muss.
**Wichtig**  
Für Lambda-Integrationen müssen Sie entsprechend der [Spezifikation der Lambda-Service-Aktion für Funktionsaufrufe](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) die HTTP-Methode `POST` für die Integrationsanfrage verwenden. Der `uri`-Parameter ist der ARN der Aktion, die die Funktion aufruft.  
Die Ausgabe sieht wie folgt aus:

   ```
   {
       "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](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) aufrufen, um ressourcenbasierte Berechtigungen hinzuzufügen. Auf diese Weise fügt die API Gateway-Konsole diese Berechtigungen hinzu. 

1. Verwenden Sie den folgenden [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)Befehl, um die Integrationsantwort so einzurichten, dass die Ausgabe der Lambda-Funktion als `200 OK` Methodenantwort an den Client übergeben wird:

   ```
    aws apigateway put-integration-response \
           --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 Ausgabe sieht wie folgt aus:

   ```
    {
       "selectionPattern": "", 
       "statusCode": "200"
   }
   ```

1. Verwenden Sie den folgenden [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html)-Befehl, um die API für eine `test`-Stufe bereitzustellen:

   ```
   aws apigateway create-deployment \
           --rest-api-id te6si5ach7 \
           --stage-name test
   ```

1.  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'
   ```