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 Lambda sans proxy
<a name="getting-started-lambda-non-proxy-integration"></a>

Dans cette présentation, nous utilisons la console API Gateway pour créer une API qui permet à un client d’appeler des fonctions Lambda via l’intégration Lambda autre que de proxy (également désignée sous le nom d’intégration personnalisée). Pour en savoir plus sur AWS Lambda et les fonctions Lambda, consultez le [Guide du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/). 

Pour faciliter l’apprentissage, nous avons choisi une fonction Lambda simple avec une configuration d’API minimale pour vous guider à travers les étapes de création d’une API Amazon API Gateway avec l’intégration personnalisée Lambda. Lorsque nécessaire, nous décrivons un aspect de la logique. Pour un exemple plus détaillé de l’intégration personnalisée Lambda, consultez [Tutoriel : Création d'une API REST de calculatrice avec deux intégrations AWS de services et une intégration Lambda sans proxy](integrating-api-with-aws-services-lambda.md). 

Avant de créer l’API, configurez le backend Lambda en créant une fonction Lambda dans AWS Lambda, comme décrit ci-après.

**Topics**
+ [Création d’une fonction Lambda pour l’intégration Lambda autre que de proxy](#getting-started-new-lambda)
+ [Création d’une API avec l’intégration Lambda autre que de proxy](#getting-started-new-api)
+ [Test de l’appel de la méthode d’API](#getting-started-new-get)
+ [Déploiement de l’API](#getting-started-deploy-api)
+ [Test de l’API dans une phase de déploiement](#getting-started-test)
+ [Nettoyage](#getting-started-clean-up)

## Création d’une fonction Lambda pour l’intégration Lambda autre que de proxy
<a name="getting-started-new-lambda"></a>

**Note**  
La création de fonctions Lambda peut entraîner des frais sur votre AWS compte.

 Au cours de cette étape, vous allez créer une fonction Lambda de type « Hello, World \$1 » pour l’intégration Lambda personnalisée. Tout au long de cette procédure, la fonction est appelée `GetStartedLambdaIntegration`.

 La mise en œuvre de cette fonction Lambda `GetStartedLambdaIntegration` est la suivante : 

------
#### [ 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": greeting}
};
```

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

```
import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    name = event.get("name") or 'you'
    city = event.get("city") or 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}
```

------

Pour l’intégration personnalisée Lambda, API Gateway transmet les entrées à la fonction Lambda depuis le client en tant que corps de la demande d’intégration. L’objet `event` du gestionnaire de la fonction Lambda correspond à l’entrée. 

Notre fonction Lambda est simple. Elle analyse l’objet `event` en entrée par rapport aux propriétés `name`, `city`, `time` et `day`. Elle renvoie ensuite un message d’accueil, en tant qu’objet JSON `{"message":greeting}`, à l’appelant. Le message suit le modèle `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"`. Il est supposé que l’entrée de la fonction Lambda est l’objet JSON suivant : 

```
{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}
```

Pour plus d’informations, consultez le [Manuel du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html). 

En outre, la fonction enregistre son exécution sur Amazon CloudWatch en appelant`console.log(...)`. Cet aspect est précieux pour suivre les appels lors du débogage de la fonction. Pour permettre à la `GetStartedLambdaIntegration` fonction d'enregistrer l'appel, définissez un rôle IAM avec des politiques appropriées pour que la fonction Lambda crée CloudWatch les flux et ajoute des entrées de journal aux flux. La console Lambda vous guide tout au long de la création des rôles et politiques IAM requis.

Si vous configurez l’API sans utiliser la console API Gateway, par exemple en [important une API depuis un fichier OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), vous devez créer explicitement, si nécessaire, et configurer une politique et un rôle d’appel pour qu’API Gateway puisse appeler les fonctions Lambda. Pour plus d’informations sur la configuration des rôles d’appel et d’exécution Lambda pour une API Amazon API Gateway, consultez [Contrôle de l’accès à une API REST avec des autorisations IAM](permissions.md). 

 Par rapport à `GetStartedLambdaProxyIntegration`, la fonction Lambda pour l’intégration de proxy Lambda, la fonction `GetStartedLambdaIntegration` Lambda pour l’intégration personnalisée Lambda prend uniquement les entrées du corps de la requête d’intégration d’API Amazon API Gateway. La fonction peut renvoyer une sortie sous forme d’un objet JSON, d’une chaîne, d’un nombre, d’une valeur booléenne ou même d’un blob binaire. La fonction Lambda de l’intégration de proxy Lambda, en revanche, peut accepter les entrées de toutes données de la demande, mais doit renvoyer en sortie un objet JSON particulier. La fonction `GetStartedLambdaIntegration` pour l’intégration personnalisée Lambda peut avoir comme entrées les paramètres de la demande d’API, à condition qu’API Gateway mappe les paramètres de la demande d’API au corps de demande d’intégration avant de transférer la demande du client au backend. Pour que cela se produise, le développeur de l’API doit créer un modèle de mappage et le configurer sur la méthode de l’API lors de la création de l’API. 

Maintenant, créez la fonction Lambda `GetStartedLambdaIntegration`. 

**Pour créer la fonction Lambda `GetStartedLambdaIntegration` pour l’intégration personnalisée Lambda**

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

1. Effectuez l’une des actions suivantes :
   + Si la page de bienvenue s’affiche, choisissez **Get Started Now (Commencer maintenant)** puis **Create function (Créer une fonction)**.
   + Si la liste **Lambda > Functions (Fonctions)** apparaît, choisissez **Create function (Créer une fonction)**.

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

1. Dans le volet **Author from scratch (Créer à partir de zéro)**, procédez comme suit :

   1. Dans **Name (Nom)**, entrez **GetStartedLambdaIntegration** comme nom de la fonction Lambda.

   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. Pour **Role name (Nom du rôle)**, indiquez le nom de votre rôle, par exemple **GetStartedLambdaIntegrationRole**.

   1. Pour **Policy templates (Modèles de politique)**, choisissez **Simple microservice permissions (Autorisations Microservice simples)**.

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

1. Dans le volet **Configure function (Configurer la fonction)**, sous **Function code (Code de la fonction)**, suivez les étapes suivantes :

   1. Copiez le code de la fonction Lambda affiché au début de cette section et collez-le dans l’éditeur de code en ligne.

   1. Acceptez les choix par défaut pour tous les autres champs de cette section.

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

1. Pour tester la fonction nouvellement créée, cliquez sur l’onglet **Test**.

   1. Dans **Event name** (Nom de l’événement), saisissez **HelloWorldTest**. 

   1. Pour **JSON d’événement**, remplacez le code par défaut par le code suivant.

      ```
      {
        "name": "Jonny",
        "city": "Seattle",
        "time": "morning",
        "day": "Wednesday"
      }
      ```

   1.  Sélectionnez **Test** pour appeler la fonction. La section **Execution result: succeeded** s’affiche. Développez **Détails** pour voir la sortie suivante.

      ```
      {
          "greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
      }
      ```

      La sortie est également écrite dans CloudWatch Logs. 

 À titre d’exercice, vous pouvez utiliser la console IAM pour afficher le rôle IAM (`GetStartedLambdaIntegrationRole`) créé dans le cadre de la création de la fonction Lambda. Deux politiques en ligne sont attachées à ce rôle IAM. L’une stipule les autorisations les plus élémentaires pour l’exécution Lambda. Cela permet d'appeler toutes CloudWatch `CreateLogGroup` les CloudWatch ressources de votre compte dans la région où la fonction Lambda est créée. Cette politique permet également de créer les CloudWatch flux et de consigner les événements pour la fonction `GetStartedLambdaIntegration` Lambda. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:us-east-1:111111111111:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-east-1:111111111111:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}
```

------

L'autre document de politique s'applique à l'appel d'un autre AWS service qui n'est pas utilisé dans cet exemple. Vous pouvez l’ignorer pour l’instant. 

 Associée au rôle IAM se trouve une entité de confiance, qui est `lambda.amazonaws.com`. Voici la relation d’approbation : 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

 La combinaison de cette relation de confiance et de la politique intégrée permet à la fonction Lambda d'appeler `console.log()` une fonction pour consigner les événements CloudWatch dans Logs. 

## Création d’une API avec l’intégration Lambda autre que de proxy
<a name="getting-started-new-api"></a>

 Avec la fonction Lambda (`GetStartedLambdaIntegration`) créée et testée, vous êtes prêt à exposer la fonction via une API Amazon API Gateway. À des fins d’illustration, nous exposons la fonction Lambda avec une méthode HTTP générique. Nous utilisons le corps de la demande, une variable de chemin d’URL, une chaîne de requête et un en-tête pour recevoir les données d’entrée requises du client. Nous activons le validateur de demande API Gateway pour l’API afin de garantir que toutes les données requises sont correctement définies et spécifiées. Nous configurons un modèle de mappage pour qu’API Gateway transforme les données de la demande fournie par le client au format valide comme requis par la fonction Lambda du backend.

**Pour créer une API avec une intégration Lambda autre que de proxy**

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 **LambdaNonProxyAPI**.

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).

Après avoir créé votre API, vous créez une ressource **/\$1city\$1**. Ceci est un exemple de ressource avec une variable de chemin qui accepte une entrée du client. Par la suite, vous mapperez cette variable de chemin avec l’entrée de la fonction Lambda à l’aide d’un modèle de mappage.

**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 **\$1city\$1**.

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

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

Après avoir créé votre ressource **/\$1city\$1**, vous créez une méthode `ANY`. Le verbe HTTP `ANY` est un espace réservé pour une méthode HTTP valide qu’un client soumet au moment de l’exécution. Cet exemple montre que la méthode `ANY` peut être utilisée pour l’intégration personnalisée Lambda aussi bien que pour l’intégration de proxy Lambda.

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

1. Sélectionnez la ressource **/\$1city\$1**, 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. Maintenez **Intégration proxy Lambda** désactivée.

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. Choisissez **Paramètres de requête de méthode**.

   À présent, vous allez activer un valideur de requête pour une variable de chemin d’URL, un paramètre de chaîne de requête et un en-tête afin de vous assurer que toutes les données requises sont définies. Dans cet exemple, vous créez un paramètre de chaîne de requête `time` et un en-tête `day`. 

1. Pour **Validateur de requête**, sélectionnez **Valider les paramètres de chaîne de requête et les en-têtes**.

1. Choisissez **Paramètres de chaîne de requête d’URL** et procédez comme suit : 

   1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).

   1. Pour **Nom**, saisissez **time**.

   1. Activez **Obligatoire**.

   1. Maintenez **Mise en cache** désactivée. 

1. Choisissez **En-têtes de requête HTTP** et procédez comme suit : 

   1. Sélectionnez **Add header**.

   1. Pour **Nom**, saisissez **day**.

   1. Activez **Obligatoire**.

   1. Maintenez **Mise en cache** désactivée. 

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

Après avoir activé un validateur de requête, vous configurez la requête d’intégration pour la méthode `ANY` en ajoutant un modèle de mappage corporel pour transformer la requête entrante en une charge utile JSON, comme l’exige la fonction Lambda du backend. 

**Pour configurer la requête d’intégration**

1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.

1. Pour **Transmission du corps de requête**, sélectionnez **Lorsqu’aucun modèle n’est défini (recommandé)**.

1. Choisissez **Modèles de mappage**.

1. Sélectionnez **Add mapping template**.

1. Pour **Type de contenu**, entrez **application/json**.

1. Pour **Corps du modèle**, entrez le code suivant :

   ```
   #set($inputRoot = $input.path('$'))
   {
     "city": "$input.params('city')",
     "time": "$input.params('time')",
     "day":  "$input.params('day')",
     "name": "$inputRoot.callerName"
   }
   ```

1. Choisissez **Enregistrer**.

## Test de l’appel de la méthode d’API
<a name="getting-started-new-get"></a>

 La console API Gateway fournit une installation de test qui vous permet de tester l’appel de l’API avant qu’elle ne soit déployée. Vous utilisez la fonctionnalité Test de la console pour tester l’API en soumettant la demande suivante : 

```
POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}
```

 Dans cette demande de test, vous allez définir `ANY` sur `POST` et `{city}` sur `Seattle`, attribuer `Wednesday` comme valeur de l’en-tête `day` et attribuer `"John"` comme valeur de `callerName`. 

**Pour tester la méthode `ANY`**

1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.

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

1. Pour **Chemin**, sous **city**, entrez **Seattle**.

1. Pour **Chaînes de requête**, saisissez **time=morning**.

1. Pour **En-têtes**, saisissez **day:Wednesday**.

1. Pour **Corps de la requête**, saisissez **\$1 "callerName": "John" \$1**.

1. Sélectionnez **Test**.

Vérifiez que la charge utile de la réponse retournée se présente comme suit :

```
{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}
```

Vous pouvez également consulter les journaux pour examiner comment API Gateway traite la demande et la réponse.

```
Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200
```

Les journaux présentent la demande entrante avant le mappage et la demande d’intégration après le mappage. Lorsqu’un test échoue, les journaux sont utiles pour évaluer si l’entrée d’origine est correcte ou si le modèle de mappage fonctionne correctement. 

## Déploiement de l’API
<a name="getting-started-deploy-api"></a>

 L’appel du test est une simulation et possède ses limites. Par exemple, il contourne tout mécanisme d’autorisation activé sur l’API. Pour tester l’exécution de l’API en temps réel, vous devez d’abord déployer l’API. Pour déployer une API, vous créez une phase afin de créer un instantané de l’API à ce moment-là. Le nom de la phase définit également le chemin de base après le nom d’hôte par défaut de l’API. La ressource racine de l’API est ajoutée après le nom de la phase. Lorsque vous modifiez l’API, vous devez la redéployer vers une phase nouvelle ou existante pour que les modifications prennent effet. 

**Pour déployer l’API sur une phase**

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**.
**Note**  
L’entrée doit être du texte codé en UTF-8 (par exemple, non localisé).

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

1. Choisissez **Déployer**.

Sous **Détails de l’étape**, choisissez l’icône de copie pour copier l’URL d’invocation de votre API. Le modèle général de l’URL de base de l’API est `https://api-id.region.amazonaws.com/stageName`. Par exemple, l’URL de base de l’API (`beags1mnid`) créée dans la région `us-west-2` et déployée sur la phase `test` est `https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.

## Test de l’API dans une phase de déploiement
<a name="getting-started-test"></a>

Il existe plusieurs façons de tester une API déployée. Pour les requêtes GET n’utilisant que les variables de chemin d’URL ou les paramètres de chaîne de requête, vous pouvez saisir l’URL de la ressource d’API dans un navigateur. 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/).

**Pour tester l’API à l’aide de cURL**

1. Ouvrez une fenêtre de terminal sur votre ordinateur local connecté à Internet.

1. Pour tester `POST /Seattle?time=evening`:

   Copiez la commande cURL suivante et collez-la dans la fenêtre du terminal.

   ```
   curl -v -X POST \
     'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
     -H 'content-type: application/json' \
     -H 'day: Thursday' \
     -H 'x-amz-docs-region: us-west-2' \
     -d '{
   	"callerName": "John"
   }'
   ```

   Vous devriez obtenir une réponse positive avec la charge utile suivante :

   ```
   {"greeting":"Good evening, John of Seattle. Happy Thursday!"}
   ```

   Si vous modifiez `POST` en `PUT` dans la demande de cette méthode, vous obtenez la même réponse.

## Nettoyage
<a name="getting-started-clean-up"></a>

Si vous n’avez plus besoin des fonctions Lambda que vous avez créées pour cette procédure, vous pouvez maintenant les supprimer. Vous pouvez également supprimer les ressources IAM associées.

**Avertissement**  
Si vous avez l’intention d’effectuer les autres procédures de cette série, ne supprimez pas le rôle d’exécution Lambda, ni le rôle d’appel Lambda. Si vous supprimez une fonction Lambda sur laquelle vous APIs comptez, elle ne APIs fonctionnera plus. La suppression d’une fonction Lambda ne peut pas être annulée. Si vous souhaitez utiliser à nouveau cette fonction Lambda, vous devez la recréer.  
Si vous supprimez une ressource IAM sur laquelle repose une fonction Lambda, cette fonction Lambda ne fonctionnera plus, et APIs toutes celles qui s'appuient sur cette fonction ne fonctionneront plus. La suppression d'une ressource IAM ne peut pas être annulée. Si vous souhaitez utiliser à nouveau cette ressource IAM, vous devez la recréer. 

**Pour supprimer la fonction Lambda**

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

1. Dans la liste des fonctions, choisissez **GetStartedLambdaIntegration**, **Actions**, puis **Delete function (Supprimer la fonction)**. A l’invite, sélectionnez à nouveau **Delete**.

**Pour supprimer les ressources IAM associées**

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dans le volet **Details**, sélectionnez **Roles**.

1. Dans la liste des rôles, choisissez **GetStartedLambdaIntegrationRole**, **Role Actions (Actions du rôle)**, puis **Delete Role (Supprimer le rôle)**. Suivez les étapes de la console pour supprimer le rôle.