

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.

# Richten Sie die Lambda-Proxyintegration für API Gateway mit dem ein AWS CLI
<a name="set-up-lambda-proxy-integration-using-cli"></a>

In diesem Abschnitt zeigen wir Ihnen, wie Sie mithilfe von AWS CLI eine API mit der Lambda-Proxy-Integration einrichten. Detaillierte Anweisungen zur Verwendung der API Gateway-Konsole zur Konfiguration einer Proxy-Ressource mit der Lambda-Proxy-Integration finden Sie unter [Tutorial: Erstellen einer REST-API mit einer Lambda-Proxy-Integration](api-gateway-create-api-as-simple-proxy-for-lambda.md).

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

```
export const handler = async(event, context) => {
    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 + "!";
    return res
};
```

Vergleicht man dies mit der benutzerdefinierten Lambda-Integrationseinrichtung unter [Benutzerdefinierte Lambda-Integrationen in API Gateway einrichten](set-up-lambda-custom-integrations.md), kann die Eingabe für diese Lambda-Funktion in den Anfrageparametern und im Text 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-Proxyintegration 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": "HelloWorldProxy (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-resource](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 {proxy+}
   ```

   Die Ausgabe sieht wie folgt aus:

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

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

1. Verwenden Sie die folgende [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html), um eine `ANY`-Methodenanforderung von `ANY /{proxy+}` zu erstellen:

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

   Die Ausgabe sieht wie folgt aus:

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

1. Verwenden Sie den folgenden [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html)-Befehl, um die Integration der `ANY /{proxy+}`-Methode mit einer Lambda-Funktion mit dem Namen `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 \
         --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](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) 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](permissions.md#api-gateway-control-access-iam-permissions-model-for-calling-api).

   Die Ausgabe sieht wie folgt 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](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) verwenden, um ressourcenbasierte Berechtigungen hinzuzufügen. Dies erledigt die API Gateway-Konsole. 

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 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!
   ```