

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 : Utiliser Lambda avec Amazon API Gateway
<a name="services-apigateway-tutorial"></a>

Dans ce tutoriel, vous créez une API REST par laquelle vous invoquez une fonction Lambda à l’aide d’une demande HTTP. Votre fonction Lambda effectuera des opérations de création, lecture, mise à jour et suppression (CRUD) sur une table DynamoDB. Cette fonction est fournie ici à titre de démonstration, mais vous apprendrez à configurer une API REST API Gateway qui peut invoquer n’importe quelle fonction Lambda.

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/APIG_tut_resources.png)


L’utilisation d’API Gateway fournit aux utilisateurs un point de terminaison HTTP sécurisé pour invoquer votre fonction Lambda et peut aider à gérer de gros volumes d’appels à votre fonction en limitant le trafic et en validant et autorisant automatiquement les appels d’API. API Gateway fournit également des contrôles de sécurité flexibles à l'aide de Gestion des identités et des accès AWS (IAM) et d'Amazon Cognito. Ceci est utile pour les cas d’utilisation où une autorisation préalable est requise pour les appels à votre application.

**Astuce**  
Lambda propose deux méthodes pour appeler votre fonction via un point de terminaison HTTP : API Gateway et fonction Lambda. URLs Si vous ne savez pas quelle est la meilleure méthode pour votre cas d’utilisation, consultez [Sélection d’une méthode pour invoquer votre fonction Lambda à l’aide d’une requête HTTP](apig-http-invoke-decision.md).

Pour réaliser ce tutoriel, vous passerez par les étapes suivantes :

1. Créer et configurer une fonction Lambda en Python ou Node.js pour effectuer des opérations sur une table DynamoDB.

1. Créer une API REST dans API Gateway pour se connecter à votre fonction Lambda.

1. Créer une table DynamoDB et la tester avec votre fonction Lambda dans la console.

1. Déployer votre API et tester la configuration complète en utilisant curl dans un terminal.

En suivant ces étapes, vous apprendrez à utiliser API Gateway pour créer un point de terminaison HTTP capable d’invoquer en toute sécurité une fonction Lambda à n’importe quelle échelle. Vous apprendrez également à déployer votre API, et à la tester dans la console et en envoyant une demande HTTP à l’aide d’un terminal.

## Création d’une stratégie d’autorisations
<a name="services-apigateway-tutorial-policy"></a>

Avant de créer un [rôle d'exécution](lambda-intro-execution-role.md) pour votre fonction Lambda, vous devez d'abord créer une politique d'autorisation pour autoriser votre fonction à accéder aux ressources requises AWS . Pour ce didacticiel, la politique permet à Lambda d'effectuer des opérations CRUD sur une table DynamoDB et d'écrire sur Amazon Logs. CloudWatch 

**Pour créer la politique**

1. Ouvrez la [page stratégies](https://console.aws.amazon.com/iam/home#/policies) de la console IAM.

1. Choisissez **Créer une stratégie**.

1. Choisissez l’onglet **JSON**, puis collez la stratégie personnalisée suivante dans l’éditeur JSON.

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

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "Stmt1428341300017",
         "Action": [
           "dynamodb:DeleteItem",
           "dynamodb:GetItem",
           "dynamodb:PutItem",
           "dynamodb:Query",
           "dynamodb:Scan",
           "dynamodb:UpdateItem"
         ],
         "Effect": "Allow",
         "Resource": "*"
       },
       {
         "Sid": "",
         "Resource": "*",
         "Action": [
           "logs:CreateLogGroup",
           "logs:CreateLogStream",
           "logs:PutLogEvents"
         ],
         "Effect": "Allow"
       }
     ]
   }
   ```

------

1. Choisissez **Suivant : Balises**.

1. Choisissez **Suivant : Vérification**.

1. Sous **Examiner une stratégie**, pour le **Nom** de la stratégie, saisissez **lambda-apigateway-policy**.

1. Choisissez **Créer une stratégie**.

## Créer un rôle d’exécution
<a name="services-apigateway-tutorial-role"></a>

Un [rôle d'exécution](lambda-intro-execution-role.md) est un rôle Gestion des identités et des accès AWS (IAM) qui accorde à une fonction Lambda l'autorisation d' Services AWS accès et de ressources. Pour permettre à votre fonction d’effectuer des opérations sur une table DynamoDB, vous attachez la politique d’autorisation que vous avez créée à l’étape précédente.

**Pour créer un rôle d’exécution et attacher votre politique d’autorisations personnalisée**

1. Ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.

1. Sélectionnez **Créer un rôle**.

1. Pour le type d’entité de confiance, choisissez **Service AWS **, puis pour le cas d’utilisation, choisissez **Lambda**.

1. Choisissez **Suivant**.

1. Dans la zone de recherche de stratégie, entrez **lambda-apigateway-policy**.

1. Dans les résultats de la recherche, sélectionnez la stratégie que vous avez créée (`lambda-apigateway-policy`), puis choisissez **Suivant**.

1. Sous **Role details** (Détails du rôle), pour **Role name** (Nom du rôle), saisissez **lambda-apigateway-role**, puis sélectionnez **Create role** (Créer un rôle).

## Créer la fonction Lambda
<a name="services-apigateway-tutorial-function"></a>

1. Ouvrez la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda et choisissez **Créer une fonction**.

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

1. Sous **Nom de la fonction**, saisissez `LambdaFunctionOverHttps`.

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

1. Sous **Permissions** (Autorisations), développez **Change default execution role** (Modifier le rôle d’exécution par défaut).

1. Sélectionnez **Utiliser un rôle existant**, sélectionnez le rôle **lambda-apigateway-role** que vous avez créé précédemment.

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

1. Dans le volet **Source du code**, remplacez le code par défaut par le code Node.js ou Python suivant.

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

   Le `region` paramètre doit correspondre à l' Région AWS endroit où vous déployez la fonction et [créez la table DynamoDB](#services-apigateway-tutorial-table).

**Example index.mjs**  

   ```
   import { DynamoDBDocumentClient, PutCommand, GetCommand, 
            UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb";
   import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
   
   const ddbClient = new DynamoDBClient({ region: "us-east-2" });
   const ddbDocClient = DynamoDBDocumentClient.from(ddbClient);
   
   // Define the name of the DDB table to perform the CRUD operations on
   const tablename = "lambda-apigateway";
   
   /**
    * Provide an event that contains the following keys:
    *
    *   - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo'
    *   - payload: a JSON object containing the parameters for the table item
    *     to perform the operation on
    */
   export const handler = async (event, context) => {
      
        const operation = event.operation;
      
        if (operation == 'echo'){
             return(event.payload);
        }
        
       else { 
           event.payload.TableName = tablename;
           let response;
           
           switch (operation) {
             case 'create':
                  response = await ddbDocClient.send(new PutCommand(event.payload));
                  break;
             case 'read':
                  response = await ddbDocClient.send(new GetCommand(event.payload));
                  break;
             case 'update':
                  response = ddbDocClient.send(new UpdateCommand(event.payload));
                  break;
             case 'delete':
                  response = ddbDocClient.send(new DeleteCommand(event.payload));
                  break;
             default:
               response = 'Unknown operation: ${operation}';
             }
           console.log(response);
           return response;
       }
   };
   ```

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

**Example lambda\$1function.py**  

   ```
   import boto3
   
   # Define the DynamoDB table that Lambda will connect to
   table_name = "lambda-apigateway"
   
   # Create the DynamoDB resource
   dynamo = boto3.resource('dynamodb').Table(table_name)
   
   # Define some functions to perform the CRUD operations
   def create(payload):
       return dynamo.put_item(Item=payload['Item'])
   
   def read(payload):
       return dynamo.get_item(Key=payload['Key'])
   
   def update(payload):
       return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 
       'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload})
   
   def delete(payload):
       return dynamo.delete_item(Key=payload['Key'])
   
   def echo(payload):
       return payload
   
   operations = {
       'create': create,
       'read': read,
       'update': update,
       'delete': delete,
       'echo': echo,
   }
   
   def lambda_handler(event, context):
       '''Provide an event that contains the following keys:
         - operation: one of the operations in the operations dict below
         - payload: a JSON object containing parameters to pass to the 
           operation being performed
       '''
       
       operation = event['operation']
       payload = event['payload']
       
       if operation in operations:
           return operations[operation](payload)
           
       else:
           raise ValueError(f'Unrecognized operation "{operation}"')
   ```

------
**Note**  
Dans cet exemple, le nom de la table DynamoDB est défini comme une variable dans le code de votre fonction. Dans une application réelle, passer ce paramètre comme une variable d’environnement et éviter de coder en dur le nom de la table constitue une bonne pratique. Pour plus d'informations, voir [Utilisation de variables d' AWS Lambda environnement](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html).

1. Dans la section **DÉPLOYER**, choisissez **Déployer** pour mettre à jour le code de votre fonction :  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

## Tester la fonction
<a name="services-apigateway-tutorial-test-function"></a>

Avant d’intégrer votre fonction à API Gateway, confirmez que vous avez déployé la fonction avec succès. Utilisez la console Lambda pour envoyer un événement de test à votre fonction.

1. Dans la page de votre fonction de la console Lambda, choisissez l’onglet **Tester**.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/test-tab.png)

1. Défilez jusqu’à la section **JSON d’événement** et remplacez l’événement par défaut par ce qui suit. Cet événement correspond à la structure attendue par la fonction Lambda.

   ```
   {
       "operation": "echo",
       "payload": {
           "somekey1": "somevalue1",
           "somekey2": "somevalue2"
       }
   }
   ```

1. Sélectionnez **Tester)**.

1. Sous **Exécution de la fonction : succès**, développez **Détails**. Vous devriez voir la réponse suivante :

   ```
   {
     "somekey1": "somevalue1",
     "somekey2": "somevalue2"
   }
   ```

## Créer une API REST avec API Gateway
<a name="services-apigateway-tutorial-api"></a>

Dans cette étape, vous créez l’API REST API Gateway que vous utiliserez pour invoquer votre fonction Lambda.

**Pour créer l’API**

1. Ouvrez la [console API Gateway](https://console.aws.amazon.com/apigateway).

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

1. Dans la boîte de dialogue **API REST**, choisissez **Créer**.

1. Sous **Détails de l’API**, laissez **Nouvelle API** sélectionnée et pour **Nom de l’API**, saisissez **DynamoDBOperations**.

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

## Créez une ressource sur votre API REST
<a name="services-apigateway-tutorial-resource"></a>

Pour ajouter une méthode HTTP à votre API, vous devez d’abord créer une ressource pour que cette méthode puisse fonctionner. Ici, vous créez la ressource pour gérer votre table DynamoDB.

**Pour créer la ressource**

1. Dans la [console API Gateway](https://console.aws.amazon.com/apigateway), sur la page **Ressources** de votre API, choisissez **Créer une ressource**.

1. Dans **Détails de la ressource**, pour **Nom de la ressource** saisissez **DynamoDBManager**.

1. Choisissez **Create Resource**.

## Création d’une méthode HTTP POST
<a name="services-apigateway-tutorial-method"></a>

Dans cette étape, vous créez une méthode (`POST`) pour votre ressource `DynamoDBManager`. Vous liez cette méthode `POST` à votre fonction Lambda de sorte que lorsque la méthode reçoit une demande HTTP, API Gateway invoque votre fonction Lambda.

**Note**  
 Dans le cadre de ce tutoriel, une méthode HTTP (`POST`) est utilisée pour invoquer une seule fonction Lambda qui exécute toutes les opérations sur votre table DynamoDB. Dans une application réelle, l’utilisation d’une fonction Lambda et d’une méthode HTTP différentes pour chaque opération constitue une bonne pratique. Pour plus d’informations, consultez [Le monolithe Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) dans Serverless Land. 

**Pour créer la méthode POST**

1. Sur la page **Ressources** de votre API, assurez-vous que la ressource `/DynamoDBManager` est surlignée. Ensuite, dans le volet **Méthodes**, choisissez **Créer une méthode**.

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

1. Pour **Type d’intégration**, laissez la **Fonction Lambda** sélectionnée.

1. Pour la **Fonction Lambda**, choisissez l’Amazon Resource Name (ARN) pour votre fonction (`LambdaFunctionOverHttps`).

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

## Créez une table DynamoDB
<a name="services-apigateway-tutorial-table"></a>

Créez une table DynamoDB vide sur laquelle votre fonction Lambda effectuera des opérations CRUD.

**Créer le tableau DynamoDB**

1. Ouvrez la [page Tables (Tables)](https://console.aws.amazon.com/dynamodbv2#tables) de la console DynamoDB.

1. Choisissez **Créer un tableau**.

1. Sous **Détails du tableau**, procédez comme suit :

   1. Sous **Nom du tableau**, saisissez **lambda-apigateway**.

   1. Pour **Clé de partition**, saisissez **id**, et conservez le type de données défini comme **Chaîne**.

1. Sous **Table settings** (Paramètres de la table), conservez les **Default settings** (Paramètres par défaut).

1. Choisissez **Créer un tableau**.

## Test de l’intégration d’API Gateway, Lambda et DynamoDB
<a name="services-apigateway-tutorial-test-setup"></a>

Vous êtes maintenant prêt à tester l’intégration de votre méthode API Gateway avec votre fonction Lambda et votre table DynamoDB. À l’aide de la console API Gateway, vous envoyez des demandes directement à votre méthode `POST` en utilisant la fonction de test de la console. Dans cette étape, vous utilisez d’abord une opération `create` pour ajouter un nouvel élément à votre table DynamoDB, puis vous utilisez une opération `update` pour modifier l’élément.

**Test 1 : Pour créer un nouvel élément dans votre table DynamoDB**

1. Dans la [console API Gateway](https://console.aws.amazon.com/apigateway), choisissez votre API (`DynamoDBOperations`).

1. Choisissez la méthode **POST** sous la ressource `DynamoDBManager`.

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

1. Sous **Méthode de test**, laissez les **Chaînes de requête** et les **En-têtes** vides. Pour **Corps de requête**, collez l’élément JSON suivant :

   ```
   {
     "operation": "create",
     "payload": {
       "Item": {
         "id": "1234ABCD",
         "number": 5
       }
     }
   }
   ```

1. Sélectionnez **Tester)**.

   Les résultats qui s’affichent à la fin du test doivent indiquer le statut `200`. Ce code d’état indique que l’opération `create` a réussi.

    Pour confirmer, vérifiez que votre table DynamoDB contient maintenant le nouvel élément.

1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodbv2#tables) de la console DynamoDB et choisissez la table `lambda-apigateway`.

1. Choisissez **Explore table items** (Explorer les éléments de la table). Dans le volet **Items returned** (Éléments retournés), vous devriez voir un élément avec l’**id** `1234ABCD` et le **numéro** `5`. Exemple :  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/items-returned.png)

**Test 2 : Pour mettre à jour l’élément dans votre table DynamoDB**

1. Dans la [Console API Gateway](https://console.aws.amazon.com/apigateway), revenez à l’onglet **Test** votre méthode POST.

1. Sous **Méthode de test**, laissez les **Chaînes de requête** et les **En-têtes** vides. Pour **Corps de requête**, collez l’élément JSON suivant :

   ```
   {
       "operation": "update",
       "payload": {
           "Key": {
               "id": "1234ABCD"
           },
           "UpdateExpression": "SET #num = :newNum",
           "ExpressionAttributeNames": {
               "#num": "number"
           },
           "ExpressionAttributeValues": {
               ":newNum": 10
           }
       }
   }
   ```

1. Sélectionnez **Tester)**.

   Les résultats qui s’affichent à la fin du test devraient montrer l’état `200`. Ce code d’état indique que l’opération `update` a réussi.

    Pour confirmer, vérifiez que l’élément dans votre table DynamoDB a été modifié.

1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodbv2#tables) de la console DynamoDB et choisissez la table `lambda-apigateway`.

1. Choisissez **Explore table items** (Explorer les éléments de la table). Dans le volet **Items returned** (Éléments retournés), vous devriez voir un élément avec l’**id** `1234ABCD` et le **numéro** `10`.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/items-returned-2.png)

## Déploiement de l’API
<a name="services-apigateway-tutorial-deploy-api"></a>

Pour qu’un client puisse appeler l’API, vous devez créer un déploiement et une étape associée. Une étape représente un instantané de votre API, y compris ses méthodes et intégrations.

**Pour déployer l’API**

1. Ouvrez la **APIs**page de la [console API Gateway](https://console.aws.amazon.com/apigateway) et choisissez l'`DynamoDBOperations`API.

1. Sur la page **Ressources** de votre API, choisissez **Deploy API** (Déployer l’API).

1. Pour **Stage** (Étape), choisissez **\$1New stage\$1** (Nouvelle étape), puis pour **Stage name** (Nom de l’étape), saisissez **test**.

1. Choisissez **Déployer**.

1. Dans le volet **Stage details** (Détails de l’étape), copiez **Invoke URL** (URL d’invocation). Vous l’utiliserez à l’étape suivante pour invoquer votre fonction à l’aide d’une demande HTTP.

## Utilisez curl pour invoquer votre fonction à l’aide de demandes HTTP
<a name="services-apigateway-tutorial-invoke-function"></a>

Vous pouvez maintenant invoquer votre fonction Lambda en émettant une demande HTTP vers votre API. Dans cette étape, vous allez créer un nouvel élément dans votre table DynamoDB, puis effectuer des oéprations de lecture, de mise à jour et de suppression sur cet élément.

**Pour créer un élément dans votre table DynamoDB à l’aide de curl**

1. Ouvrez un terminal ou une invite de commande sur votre machine locale et exécutez la commande `curl` suivante en utilisant l’URL d’invocation que vous avez copiée à l’étape précédente. Cette commande utilise les options suivantes :
   + `-H` : ajoute un en-tête personnalisé à la demande. Ici, le paramètre spécifie le type de contenu comme étant du JSON.
   + `-d` : envoie des données dans le corps de la demande. Cette option utilise une méthode HTTP POST par défaut.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}'
   ```

------

   Si l’opération a réussi, vous devriez voir une réponse renvoyée avec un code d’état HTTP de 200.

1. Vous pouvez également utiliser la console DynamoDB pour vérifier que le nouvel élément figure dans votre table en procédant comme suit :

   1. Ouvrez la [page Tables](https://console.aws.amazon.com/dynamodbv2#tables) de la console DynamoDB et choisissez la table `lambda-apigateway`.

   1. Sélectionnez **Explore table items** (Explorer les éléments de la table). Dans le volet **Items returned** (Éléments retournés), vous devriez voir un élément avec l’**id** `5678EFGH` et le **numéro** `15`.

**Pour lire l’élément dans votre table DynamoDB à l’aide de curl**
+ Dans votre terminal ou invite de commande, exécutez la commande `curl` suivante pour lire la valeur l’élément que vous venez de créer. Utilisez votre propre URL invoquée.

------
#### [ Linux/macOS ]

  ```
  curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
  -H "Content-Type: application/json" \
  -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
  ```

------
#### [ PowerShell ]

  ```
  curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
  ```

------

  Vous devriez obtenir un résultat semblable à l’un des suivants selon que vous avez choisi le code de fonction Node.js ou Python :

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

  ```
  {"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG",
  "attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}}
  ```

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

  ```
  {"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG",
  "HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0",
  "content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"},
  "RetryAttempts":0}}
  ```

------

**Pour mettre à jour l’élément dans votre table DynamoDB à l’aide de curl**

1. Dans votre terminal ou invite de commande, exécutez la commande `curl` suivante pour mettre à jour l’élément que vous venez de créer en modifiant la valeur `number`. Utilisez votre propre URL invoquée.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}'
   ```

------

1. Pour confirmer que la valeur de `number` de l’élément a été mise à jour, exécutez une autre commande de lecture :

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
   ```

------

**Pour supprimer l’élément dans votre table DynamoDB à l’aide de curl**

1. Dans votre terminal ou invite de commande, exécutez la commande `curl` suivante pour supprimer l’élément que vous venez de créer. Utilisez votre propre URL invoquée.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
   ```

------

1. Confirmez que l’opération de suppression a réussi. Dans le volet **Items returned** (Éléments retournés) de la page **Explore items** (Explorer les éléments) de la console DynamoDB, vérifiez que l’élément avec l’**id** `5678EFGH` n’est plus dans la table.

## Nettoyer vos ressources (facultatif)
<a name="cleanup"></a>

Vous pouvez maintenant supprimer les ressources que vous avez créées pour ce didacticiel, sauf si vous souhaitez les conserver. En supprimant AWS les ressources que vous n'utilisez plus, vous évitez des frais inutiles pour votre Compte AWS.

**Pour supprimer la fonction Lambda**

1. Ouvrez la [page Functions (Fonctions)](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda.

1. Sélectionnez la fonction que vous avez créée.

1. Sélectionnez **Actions**, **Supprimer**.

1. Saisissez **confirm** dans la zone de saisie de texte et choisissez **Delete** (Supprimer).

**Pour supprimer le rôle d’exécution**

1. Ouvrez la [page Roles (Rôles)](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.

1. Sélectionnez le rôle d’exécution que vous avez créé.

1. Sélectionnez **Delete (Supprimer)**.

1. Saisissez le nom du rôle dans le champ de saisie de texte et choisissez **Delete** (Supprimer).

**Pour supprimer l’API**

1. Ouvrez la [APIs page](https://console.aws.amazon.com/apigateway/main/apis) de la console API Gateway.

1. Sélectionnez l’API que vous avez créée.

1. Sélectionnez **Actions**, **Supprimer**.

1. Sélectionnez **Supprimer**.

**Pour supprimer la table DynamoDB**

1. Ouvrez la [page Tables (Tables)](https://console.aws.amazon.com//dynamodb/home#tables:) de la console DynamoDB.

1. Sélectionnez la table que vous avez créée.

1. Choisissez **Supprimer**.

1. Saisissez **delete** dans la zone de texte.

1. Choisissez **Supprimer la table**.