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.

# Configuration d’intégrations personnalisées Lambda dans API Gateway
<a name="set-up-lambda-custom-integrations"></a>

 Pour vous montrer comment configurer l’intégration personnalisée Lambda, ou intégration sans proxy, nous allons créer une API d’API Gateway pour exposer la méthode `GET /greeting?greeter={name}` afin d’invoquer une fonction Lambda. Utilisez l’un des exemples de fonctions Lambda suivants pour votre API.

Utilisez l’un des exemples de fonctions Lambda suivants :

------
#### [ 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
```

------

La fonction répond avec un message `"Hello, {name}!"` si la valeur du paramètre `greeter` est une chaîne non vide. Elle renvoie un message `"Hello, World!"` si la valeur `greeter` est une chaîne vide. La fonction renvoie un message d’erreur `"Missing the required greeter parameter."` si le paramètre d’hôte n’est pas défini dans la demande entrante. Nous nommons la fonction `HelloWorld`.

Vous pouvez la créer dans la console Lambda ou à l’aide de la AWS CLI. Dans cette section, nous faisons référence à cette fonction avec l’ARN suivant :

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

Avec la fonction Lambda définie dans le backend, commencez à configurer l’API.<a name="set-up-lambda-custom-integration-using-cli"></a>

**Pour configurer l'intégration personnalisée 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": "HelloWorld (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 greeting
   ```

   Le résultat se présente comme suit :

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

   Vous allez utiliser la valeur `id` (`2jf6xt`) de la ressource `greeting` pour créer une méthode sur la ressource `/greeting` à 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 d’API `GET /greeting?greeter={name}` :

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

   Le résultat se présente comme suit :

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

   Cette méthode d’API permet au client de recevoir des salutations de la fonction Lambda au backend. Le paramètre `greeter` est facultatif, car le backend doit gérer soit un appelant anonyme, soit un appelant auto-identifié.

1. Utilisez la [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)commande suivante pour configurer la `200 OK` réponse à la demande de méthode de `GET /greeting?greeter={name}` :

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

   

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 `GET /greeting?greeter={name}` avec une fonction Lambda nommée `HelloWorld`. La 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 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
   ```

   Le modèle de mappage fourni ici convertit le paramètre de chaîne de demande `greeter` en propriété `greeter` de la charge utile JSON. Ceci est nécessaire parce que l’entrée d’une fonction Lambda doit être exprimée dans le corps.
**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 paramètre `uri` est l’ARN de l’action d’appel de fonction.  
Le résultat se présente comme suit :

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

   Le rôle IAM `apigAwsProxyRole` doit avoir des politiques qui permettent au service `apigateway` d’appeler des fonctions Lambda. Plutôt que de préciser un rôle IAM pour `credentials`, vous pouvez appeler 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 ainsi que la console API Gateway ajoute ces autorisations. 

1. Utilisez la [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)commande suivante pour configurer la réponse d'intégration afin de transmettre la sortie de la fonction Lambda au client en tant que réponse de `200 OK` méthode :

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

   En définissant le modèle de sélection sur une chaîne vide, la réponse `200 OK` est la valeur par défaut. 

   Le résultat se présente comme suit :

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

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 de la commande cURL suivante dans un 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'
   ```