

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configurez l'intégration du proxy Lambda pour API Gateway à l'aide du AWS CLI
<a name="set-up-lambda-proxy-integration-using-cli"></a>

Dans cette section, nous vous expliquons comment configurer une API avec l’intégration de proxy Lambda à l’aide de l’ AWS CLI. Pour obtenir des instructions détaillées sur l’utilisation de la console API Gateway afin de configurer une ressource proxy avec l’intégration de proxy Lambda, consultez [Didacticiel : création d’une API REST avec une intégration de proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).

À titre d’exemple, nous utilisons l’exemple suivant de fonction Lambda comme backend de l’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
};
```

Si l’on compare ce code à la configuration de l’intégration personnalisée Lambda dans [Configuration d’intégrations personnalisées Lambda dans API Gateway](set-up-lambda-custom-integrations.md), l’entrée de cette fonction Lambda peut être exprimée dans les paramètres et le corps de la demande. Vous avez plus de latitude pour permettre au client de transmettre les mêmes données d’entrée. Ici, le client peut transmettre le nom de l’hôte sous la forme d’une propriété de paramètre de chaîne de demande, d’en-tête ou de corps. La fonction peut également prendre en charge l’intégration personnalisée Lambda. La configuration de l’API est plus simple. Vous ne configurez pas du tout la réponse de la méthode ou la réponse de l’intégration.

**Pour configurer une intégration de proxy Lambda à l'aide du AWS CLI**

1. Utilisez la [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)commande suivante pour créer une API :

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

   Le résultat se présente comme suit :

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

   Vous allez utiliser l’API `id` (`te6si5ach7`) et `rootResourceId` (`krznpq9xpg`) tout au long de cet exemple.

1. Utilisez la commande [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html) suivante pour créer une [ressource](https://docs.aws.amazon.com/apigateway/latest/api/API_Resource.html) API Gateway de `/greeting` :

   ```
   aws apigateway create-resource \
         --rest-api-id te6si5ach7 \
         --parent-id krznpq9xpg \
         --path-part {proxy+}
   ```

   Le résultat se présente comme suit :

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

   Vous allez utiliser la valeur `id` (`2jf6xt`) de la ressource `{proxy+}` pour créer une méthode sur la ressource `/{proxy+}` à l’étape suivante.

1. Utilisez la commande [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html) suivante pour créer une demande de méthode `ANY` `ANY /{proxy+}` :

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

   Le résultat se présente comme suit :

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

   Cette méthode d’API permet au client de recevoir ou d’envoyer des salutations de la fonction Lambda au backend. 

1. Utilisez la commande [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html) suivante pour configurer l’intégration de la méthode `ANY /{proxy+}` avec une fonction Lambda nommée `HelloWorld`. Cette fonction répond à la demande par un message `"Hello, {name}!"` si le paramètre `greeter` est précisé, ou `"Hello, World!"` si le paramètre de chaîne de demande n’est pas défini.

   ```
   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
   ```
**Important**  
Pour les intégrations Lambda, vous devez utiliser la méthode HTTP `POST` pour la demande d’intégration, conformément à la [spécification de l’action de service Lambda pour les appels de fonction](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). Le rôle IAM `apigAwsProxyRole` doit avoir des politiques permettant au service `apigateway` d’appeler des fonctions Lambda. Pour plus d’informations sur les autorisations IAM, consultez [Modèle d’autorisation API Gateway pour l’appel d’une API](permissions.md#api-gateway-control-access-iam-permissions-model-for-calling-api).

   Le résultat se présente comme suit :

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

   Plutôt que de fournir un rôle IAM pour `credentials`, vous pouvez utiliser la commande [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) pour ajouter des autorisations basées sur les ressources. C’est ce que fait la console API Gateway. 

1. Utilisez la commande [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html) suivante pour déployer l’API sur une étape `test` :

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

1. Testez l’API à l’aide des commandes cURL suivantes dans un terminal.

   Appel de l’API avec le paramètre de chaîne de demande `?greeter=jane` :

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

   Appel de l’API avec un paramètre d’en-tête `greeter:jane` :

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

   Appel de l’API avec un corps `{"greeter":"jane"}` :

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

   Dans tous les cas, la sortie est une réponse 200 avec le corps de réponse suivant :

   ```
   Hello, jane!
   ```