

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.

# Didacticiel : création d’une API REST avec une intégration de proxy Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda"></a>

L’[intégration de proxy Lambda](set-up-lambda-proxy-integrations.md) est un type d’intégration d’API avec API Amazon Gateway léger et flexible qui permet d’intégrer une méthode d’API, ou une API complète, avec une fonction Lambda. La fonction Lambda peut être écrite dans [n’importe quelle langue prise en charge par Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). Puisqu’il s’agit d’une intégration de proxy, vous pouvez modifier la mise en œuvre de la fonction Lambda à tout moment, sans avoir à redéployer votre API.

Dans ce didacticiel, vous allez effectuer les opérations suivantes :
+ Créer une fonction Lambda « Hello, World\$1 » pour être le backend de l’API.
+ Créer et tester une API « Hello, World\$1 » avec intégration de proxy Lambda.

**Topics**
+ [Création d’une fonction Lambda « Hello, World\$1 »](#api-gateway-proxy-integration-create-lambda-backend)
+ [Création d’une API « Hello, World\$1 »](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Déploiement et test de l’API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)

## Création d’une fonction Lambda « Hello, World\$1 »
<a name="api-gateway-proxy-integration-create-lambda-backend"></a>

**Pour créer une fonction Lambda « Hello, World\$1 » dans la console Lambda**

1. [Connectez-vous à la console Lambda à l'adresse /lambda. https://console.aws.amazon.com](https://console.aws.amazon.com/lambda)

1. Dans la barre AWS de navigation, choisissez un [Région AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**Note**  
Notez la région où vous avez créé la fonction Lambda. Vous en aurez besoin lors de la création de l’API.

1. Choisissez **Fonctions** dans le panneau de navigation.

1. Choisissez **Créer une fonction**.

1. Choisissez **Créer à partir de zéro**.

1. Sous **Informations de base**, procédez comme suit :

   1. Sous **Nom de la fonction**, entrez **GetStartedLambdaProxyIntegration**.

   1. Pour **Exécution**, choisissez le dernier environnement d’exécution **Node.js** ou **Python** compatible.

   1. Pour **Architecture**, conservez le paramètre par défaut.

   1. Sous **Permissions** (Autorisations), développez **Change default execution role** (Modifier le rôle d’exécution par défaut). Dans la liste déroulante **Rôle d’exécution**, choisissez **Créer un nouveau rôle à partir de modèles de politique AWS **.

   1. Sous **Nom du rôle**, entrez **GetStartedLambdaBasicExecutionRole**.

   1. Laissez vide le champ **Modèles de politique**.

   1. Choisissez **Créer une fonction**.

1. Sous **Code de fonction**, dans l'éditeur de code en ligne, copy/paste le code suivant :

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

   ```
   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
   };
   ```

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

   ```
   import json
   
   
   def lambda_handler(event, context):
       print(event)
   
       greeter = 'World'
   
       try:
           if (event['queryStringParameters']) and (event['queryStringParameters']['greeter']) and (
                   event['queryStringParameters']['greeter'] is not None):
               greeter = event['queryStringParameters']['greeter']
       except KeyError:
           print('No greeter')
   
       try:
           if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
                   event['multiValueHeaders']['greeter'] is not None):
               greeter = " and ".join(event['multiValueHeaders']['greeter'])
       except KeyError:
           print('No greeter')
   
       try:
           if (event['headers']) and (event['headers']['greeter']) and (
                   event['headers']['greeter'] is not None):
               greeter = event['headers']['greeter']
       except KeyError:
           print('No greeter')
   
       if (event['body']) and (event['body'] is not None):
           body = json.loads(event['body'])
           try:
               if (body['greeter']) and (body['greeter'] is not None):
                   greeter = body['greeter']
           except KeyError:
               print('No greeter')
   
       res = {
           "statusCode": 200,
           "headers": {
               "Content-Type": "*/*"
           },
           "body": "Hello, " + greeter + "!"
       }
   
       return res
   ```

------

1. Choisissez **Deploy (Déployer)**.

## Création d’une API « Hello, World\$1 »
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-build"></a>

Maintenant, créez une API pour votre fonction Lambda « Hello, World \$1 » à l’aide de la console API Gateway.

**Pour créer une API « Hello, World\$1 »**

1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)

1. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous **REST API (API REST)**, choisissez **Build (Création)**. Lorsque la fenêtre contextuelle **Create Example API (Créer API exemple)** s’affiche, cliquez sur **OK**.

   Si ce n’est pas la première fois que vous utilisez API Gateway, choisissez **Create API (Créer une API)**. Sous **REST API (API REST)**, choisissez **Build (Création)**.

1.  Sous **API name (Nom de l’API)**, saisissez **LambdaProxyAPI**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Laissez **Type de point de terminaison d’API** défini sur **Régional**.

1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.

1. Sélectionnez **Create API** (Créer une API).

Une fois que vous avez créé une API, vous créez une ressource. En règle générale, les ressources API sont organisées dans une arborescence des ressources selon la logique de l’application. Pour cet exemple, vous créez une ressource **/helloworld**. 

**Pour créer une ressource**

1. Choisissez **Créer une ressource**.

1. Maintenez **Ressource proxy** désactivée. 

1. Conservez **Chemin de la ressource** sous la forme `/`.

1. Sous **Resource Name (Nom de la ressource)**, entrez **helloworld**.

1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.

1. Choisissez **Créer une ressource**.

 Dans une intégration de proxy, la totalité de la demande est envoyée à la fonction Lambda du backend en l’état, via une méthode `ANY` fourre-tout qui représente n’importe quelle méthode HTTP. La méthode HTTP concrète est spécifiée par le client au moment de l’exécution. La méthode `ANY` vous permet d’utiliser une seule configuration de méthode d’API pour toutes les méthodes HTTP prises en charge, `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` et `PUT`.

**Pour créer une méthode `ANY`**

1. Sélectionnez la ressource **/helloworld**, puis choisissez **Créer une méthode**.

1. Pour **Type de méthode**, sélectionnez **ANY**.

1. Pour **Type d’intégration**, sélectionnez **Fonction Lambda**.

1. Activez **Intégration de proxy Lambda**.

1. Pour la **fonction Lambda**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda, puis entrez le nom de la fonction.

1. Pour utiliser la valeur de délai d’expiration par défaut de 29 secondes, gardez **Délai d’expiration** activé. Pour définir un délai d’expiration personnalisé, choisissez **Délai d’expiration** et entrez une valeur de délai d’expiration comprise entre `50` et `29000` millisecondes.

1. Choisissez **Créer une méthode**.

## Déploiement et test de l’API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test"></a>

**Pour déployer votre API**

1. Sélectionnez **Deploy API (Déployer une API)**.

1. Pour **Étape**, sélectionnez **Nouvelle étape**.

1. Sous **Stage name (Nom de l’étape)**, entrez **test**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Choisissez **Déployer**.

1. Sous **Détails de l’étape**, choisissez l’icône de copie pour copier l’URL d’invocation de votre API.

### Utilisation du navigateur et de cURL pour tester une API avec l’intégration de proxy Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test-curl"></a>

Pour tester votre API, vous pouvez utiliser un navigateur ou [cURL](https://curl.se/).

Pour tester les demandes `GET` en utilisant uniquement les paramètres de chaîne de requête, vous pouvez saisir l’URL de la ressource `helloworld` de l’API dans la barre d’adresse d’un navigateur. 

Pour créer l’URL de la ressource `helloworld` de l’API, ajoutez la ressource `helloworld` et le paramètre de chaîne de requête `?greeter=John` à votre URL d’invocation. Votre URL doit ressembler à ce qui suit :

```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```

Pour les autres méthodes, vous devez utiliser les utilitaires de test plus avancés de l’API REST, tels que [POSTMAN](https://www.postman.com/) ou [cURL](https://curl.se/). Dans ce didacticiel, on utilise cURL. Dans les exemples de commande cURL ci-dessous, on suppose que cURL est installé sur votre ordinateur.

**Pour tester l’API déployée à l’aide de cURL :**

1. Ouvrez une fenêtre du terminal.

1. Copiez la commande cURL suivante et collez-la dans la fenêtre du terminal, et remplacez l’URL d’invocation par celle que vous avez copiée à l’étape précédente et ajoutez **/helloworld** à la fin de l’URL.
**Note**  
Si vous exécutez la commande sous Windows, utilisez plutôt cette syntaxe :  

   ```
   curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
   ```

   1. Pour appeler l’API avec le paramètre de chaîne de requête de `?greeter=John` :

      ```
      curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John'
      ```

   1. Pour appeler l’API avec un paramètre d’en-tête de `greeter:John` :

      ```
      curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -H 'greeter: John'
      ```

   1. Pour appeler l’API avec un corps `{"greeter":"John"}` :

      ```
      curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -d '{ "greeter": "John" }'
      ```

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

   ```
   Hello, John!
   ```