

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 HTTP CRUD avec Lambda et DynamoDB
<a name="http-api-dynamo-db"></a>

Dans ce didacticiel, vous allez créer une API sans serveur qui crée, lit, met à jour et supprime des éléments d’une table DynamoDB. DynamoDB est un service de base de données NoSQL entièrement géré offrant des performances rapides et prévisibles avec une scalabilité simple. Ce didacticiel dure environ 30 minutes, et vous pouvez le suivre dans l’[offre gratuite AWS](https://aws.amazon.com/free/).

Tout d’abord, vous créez une table [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) à l’aide de la console DynamoDB. Vous créez ensuite une fonction [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) à l'aide de la AWS Lambda console. Ensuite, vous créez une API HTTP à l’aide de la console API Gateway. Enfin, vous testez votre API.

Lorsque vous appelez votre API HTTP, API Gateway achemine la requête vers votre fonction Lambda. La fonction Lambda interagit avec DynamoDB et renvoie une réponse à API Gateway. API Gateway vous renvoie ensuite une réponse.

![\[Vue d’ensemble de l’API HTTP que vous créez dans ce didacticiel.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/ddb-crud.png)


Pour effectuer cet exercice, vous avez besoin d'un AWS compte et d'un Gestion des identités et des accès AWS utilisateur ayant accès à la console. Pour de plus amples informations, veuillez consulter [Configuration d’API Gateway avant son utilisation](setting-up.md).

Dans ce didacticiel, vous utiliserez l’ AWS Management Console. Pour un AWS SAM modèle qui crée cette API et toutes les ressources associées, consultez [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).

**Topics**
+ [Étape 1 : création d’une table DynamoDB](#http-api-dynamo-db-create-table)
+ [Étape 2 : création d’une fonction Lambda](#http-api-dynamo-db-create-function)
+ [Étape 3 : création d’une API HTTP](#http-api-dynamo-db-create-api)
+ [Étape 4 : création de routes](#http-api-dynamo-db-create-routes)
+ [Étape 5 : création d’une intégration](#http-api-dynamo-db-create-integration)
+ [Étape 6 : attachement de votre intégration aux routes](#http-api-dynamo-db-attach-integrations)
+ [Étape 7 : test de votre API](#http-api-dynamo-db-invoke-api)
+ [Étape 8 : Nettoyage](#http-api-dynamo-db-cleanup)
+ [Prochaines étapes : Automatiser avec AWS SAM ou CloudFormation](#http-api-dynamo-db-next-steps)

## Étape 1 : création d’une table DynamoDB
<a name="http-api-dynamo-db-create-table"></a>

Vous utilisez une table [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) afin de stocker les données de votre API. 

Chaque élément a un ID unique, que nous utilisons en tant que [clé de partition](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) pour la table.

**Pour créer une table DynamoDB**

1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Choisissez **Create table (Créer une table)**.

1. Sous **Table name (Nom de la table)**, saisissez **http-crud-tutorial-items**.

1. Pour **Clé de partition**, saisissez **id**.

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

## Étape 2 : création d’une fonction Lambda
<a name="http-api-dynamo-db-create-function"></a>

Vous utilisez une fonction [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) pour le backend de votre API. Cette fonction Lambda crée, lit, met à jour et supprime des éléments de DynamoDB. La fonction utilise des [ événements d’API Gateway](http-api-develop-integrations-lambda.md#http-api-develop-integrations-lambda.proxy-format) afin de déterminer l’interaction avec DynamoDB. Pour plus de simplicité, ce didacticiel utilise une seule fonction Lambda. Il est recommandé de créer des fonctions distinctes pour chaque route. Pour plus d'informations, consultez [Le monolithe Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) (français non garanti).

**Pour créer une fonction Lambda**

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

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

1. Sous **Function name (Nom de la fonction)**, saisissez **http-crud-tutorial-function**.

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

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

1. Sélectionnez **Créer un nouveau rôle à partir de modèles de AWS politique**.

1. Sous **Role name (Nom du rôle)**, saisissez **http-crud-tutorial-role**.

1. Sous **Policy templates (Modèles de politique)**, choisissez **Simple microservice permissions**. Cette politique accorde à la fonction Lambda l’autorisation d’interagir avec DynamoDB.
**Note**  
Ce didacticiel utilise une politique gérée pour plus de simplicité. Il est recommandé de créer votre propre politique IAM afin d’accorder les autorisations minimales requises.

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

1. Ouvrez la fonction Lambda dans l’éditeur de code de la console et remplacez son contenu par le code suivant. Choisissez **Deploy (Déployer)** afin de mettre à jour votre fonction.

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

```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  ScanCommand,
  PutCommand,
  GetCommand,
  DeleteCommand,
} from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({});

const dynamo = DynamoDBDocumentClient.from(client);

const tableName = "http-crud-tutorial-items";

export const handler = async (event, context) => {
  let body;
  let statusCode = 200;
  const headers = {
    "Content-Type": "application/json",
  };

  try {
    switch (event.routeKey) {
      case "DELETE /items/{id}":
        await dynamo.send(
          new DeleteCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = `Deleted item ${event.pathParameters.id}`;
        break;
      case "GET /items/{id}":
        body = await dynamo.send(
          new GetCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = body.Item;
        break;
      case "GET /items":
        body = await dynamo.send(
          new ScanCommand({ TableName: tableName })
        );
        body = body.Items;
        break;
      case "PUT /items":
        let requestJSON = JSON.parse(event.body);
        await dynamo.send(
          new PutCommand({
            TableName: tableName,
            Item: {
              id: requestJSON.id,
              price: requestJSON.price,
              name: requestJSON.name,
            },
          })
        );
        body = `Put item ${requestJSON.id}`;
        break;
      default:
        throw new Error(`Unsupported route: "${event.routeKey}"`);
    }
  } catch (err) {
    statusCode = 400;
    body = err.message;
  } finally {
    body = JSON.stringify(body);
  }

  return {
    statusCode,
    body,
    headers,
  };
};
```

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

```
import json
import boto3
from decimal import Decimal

client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'


def lambda_handler(event, context):
    print(event)
    body = {}
    statusCode = 200
    headers = {
        "Content-Type": "application/json"
    }

    try:
        if event['routeKey'] == "DELETE /items/{id}":
            table.delete_item(
                Key={'id': event['pathParameters']['id']})
            body = 'Deleted item ' + event['pathParameters']['id']
        elif event['routeKey'] == "GET /items/{id}":
            body = table.get_item(
                Key={'id': event['pathParameters']['id']})
            body = body["Item"]
            responseBody = [
                {'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
            body = responseBody
        elif event['routeKey'] == "GET /items":
            body = table.scan()
            body = body["Items"]
            print("ITEMS----")
            print(body)
            responseBody = []
            for items in body:
                responseItems = [
                    {'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
                responseBody.append(responseItems)
            body = responseBody
        elif event['routeKey'] == "PUT /items":
            requestJSON = json.loads(event['body'])
            table.put_item(
                Item={
                    'id': requestJSON['id'],
                    'price': Decimal(str(requestJSON['price'])),
                    'name': requestJSON['name']
                })
            body = 'Put item ' + requestJSON['id']
    except KeyError:
        statusCode = 400
        body = 'Unsupported route: ' + event['routeKey']
    body = json.dumps(body)
    res = {
        "statusCode": statusCode,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": body
    }
    return res
```

------

## Étape 3 : création d’une API HTTP
<a name="http-api-dynamo-db-create-api"></a>

L’API HTTP fournit un point de terminaison HTTP pour votre fonction Lambda. Au cours de cette étape, vous créez une API vide. Dans les étapes suivantes, vous configurez des routes et des intégrations afin de connecter votre API et votre fonction Lambda.



**Pour créer une API HTTP**

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

1. Choisissez **Create API (Créer une API)**. Ensuite, sous **HTTP API (API HTTP)**, choisissez **Build (Création)**.

1. Sous **API name (Nom de l’API)**, saisissez **http-crud-tutorial-api**.

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

1. Choisissez **Suivant**.

1. Sous **Configure routes (Configurer des routes)**, choisissez **Next (Suivant)** afin d’ignorer la création de routes. Vous créerez des routes ultérieurement.

1. Consultez l’étape créée par API Gateway pour vous, puis choisissez **Next (Suivant)**.

1. Choisissez **Créer**.

## Étape 4 : création de routes
<a name="http-api-dynamo-db-create-routes"></a>

Les routes permettent d’envoyer les demandes d’API entrantes aux ressources backend. Les routes se composent de deux parties : une méthode HTTP et un chemin de ressource (par exemple, `GET /items`). Pour cet exemple d’API, nous créons quatre routes :
+ `GET /items/{id}`
+ `GET /items`
+ `PUT /items`
+ `DELETE /items/{id}`

**Pour créer des routes**

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

1. Choisissez votre API.

1. Choisissez **Routes**.

1. Choisissez **Créer**.

1. Pour **Méthode**, choisissez **GET**.

1. Pour le chemin, saisissez **/items/\$1id\$1**. Le `{id}` à la fin du chemin est un paramètre de chemin d’accès qu’API Gateway extrait du chemin d’accès de la demande lorsqu’un client effectue une demande.

1. Choisissez **Créer**.

1. Répétez les étapes 4 à 7 pour `GET /items`, `DELETE /items/{id}` et `PUT /items`.

![\[Votre API dispose de routes pour GET /items, GET /items/{id}, DELETE /items/{id} et PUT /items.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/ddb-create-routes.png)


## Étape 5 : création d’une intégration
<a name="http-api-dynamo-db-create-integration"></a>

Vous créez une intégration afin de connecter une route aux ressources backend. Pour cet exemple d’API, vous créez une intégration Lambda que vous utilisez pour toutes les routes.

**Pour créer une intégration**

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

1. Choisissez votre API.

1. Choisissez **Integrations (Intégrations)**.

1. Choisissez **Manage integrations (Gérer les intégrations)**, puis **Create (Créer)**.

1. Ignorez **Attach this integration to a route (Attacher cette intégration à une route)**. Vous vous en occuperez ultérieurement.

1. Sous **Integration type (Type d’intégration)**, choisissez **Lambda function (Fonction Lambda)**.

1. Sous **Lambda function (Fonction Lambda)**, saisissez **http-crud-tutorial-function**.

1. Choisissez **Créer**.

## Étape 6 : attachement de votre intégration aux routes
<a name="http-api-dynamo-db-attach-integrations"></a>

Pour cet exemple d’API, vous utilisez la même intégration Lambda pour toutes les routes. Après que l’intégration a été attachée à l’ensemble des routes de l’API, votre fonction Lambda est appelée lorsqu’un client appelle l’une de vos routes.



**Pour attacher des intégrations à des routes**

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

1. Choisissez votre API.

1. Choisissez **Integrations (Intégrations)**.

1. Choisissez une route.

1. Sous **Choose an existing integration (Choisir une intégration existante)**, choisissez **http-crud-tutorial-function**.

1. Choisissez **Attach integration (Attacher l’intégration)**.

1. Répétez les étapes 4 à 6 pour toutes les routes. 

Tous les itinéraires indiquent qu'une AWS Lambda intégration est attachée.

![\[La console s'affiche AWS Lambda sur tous les itinéraires pour indiquer que votre intégration est attachée.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/ddb-attach-integrations.png)


Maintenant que vous disposez d’une API HTTP avec des routes et des intégrations, vous pouvez tester votre API.

## Étape 7 : test de votre API
<a name="http-api-dynamo-db-invoke-api"></a>

Afin de vous assurer que votre API fonctionne, vous utilisez [curl](https://curl.se).

**Pour obtenir l’URL pour appeler votre API**

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

1. Choisissez votre API.

1. Notez l’URL d’appel de votre API. Elle apparaît sous **Invoke URL (Appeler l’URL)** sur la page **Details (Détails)**.  
![\[Une fois que vous avez créé votre API, la console affiche l’URL d’appel de votre API.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/ddb-invoke-url.png)

1. Copiez l’URL d’appel de votre API. 

   L’URL complète se présente sous la forme `https://abcdef123.execute-api.us-west-2.amazonaws.com`. 

**Pour créer ou mettre à jour un élément**
+ Utilisez la commande suivante afin de créer ou de mettre à jour un élément. La commande inclut un corps de demande et l’ID, le prix et le nom de l’élément.

  ```
  curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\", \"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-west-2.amazonaws.com/items
  ```

**Pour obtenir tous les éléments**
+ Utilisez la commande suivante afin de répertorier tous les éléments.

  ```
  curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
  ```

**Pour obtenir un élément**
+ Utilisez la commande suivante afin d’obtenir un élément par son ID.

  ```
  curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
  ```

**Pour supprimer un article**

1. Utilisez la commande suivante afin de supprimer un élément.

   ```
   curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
   ```

1. Obtenez tous les éléments afin de vérifier que l’élément a été supprimé.

   ```
   curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
   ```

## Étape 8 : Nettoyage
<a name="http-api-dynamo-db-cleanup"></a>

Pour éviter des coûts inutiles, supprimez les ressources que vous avez créées dans le cadre de cet exercice de démarrage. Les étapes suivantes suppriment votre API HTTP, votre fonction Lambda, ainsi que les ressources associées.

**Pour supprimer une table DynamoDB**

1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Sélectionnez votre table.

1. Choisissez **Supprimer la table**.

1. Confirmez votre choix et choisissez **Delete (Supprimer)**.

**Pour supprimer une API HTTP**

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

1. Sur la **APIs**page, sélectionnez une API. Choisissez **Actions**, puis **Supprimer**.

1. Sélectionnez **Delete**.

**Pour supprimer une fonction Lambda**

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

1. Sur la page **Functions (Fonctions)**, sélectionnez une fonction. Choisissez **Actions**, puis **Supprimer**.

1. Sélectionnez **Delete**.

**Pour supprimer le groupe de journaux d’une fonction Lambda**

1. Dans la CloudWatch console Amazon, ouvrez la [page Log groups](https://console.aws.amazon.com/cloudwatch/home#logs:).

1. Sur la page **Log groups (Groupes de journaux)**, sélectionnez le groupe de journaux de la fonction (`/aws/lambda/http-crud-tutorial-function`). Choisissez **Actions**, puis **Supprimer le groupe de journaux**.

1. Sélectionnez **Delete**.

**Pour supprimer le rôle d’exécution d’une fonction Lambda**

1. Dans la Gestion des identités et des accès AWS console, ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home?#/roles).

1. Sélectionnez le rôle de la fonction, par exemple, `http-crud-tutorial-role`.

1. Choisissez **Supprimer le rôle**.

1. Choisissez **Oui, supprimer**.

## Prochaines étapes : Automatiser avec AWS SAM ou CloudFormation
<a name="http-api-dynamo-db-next-steps"></a>

Vous pouvez automatiser la création et le nettoyage des AWS ressources en utilisant CloudFormation ou AWS SAM. Afin d’obtenir un exemple de modèle AWS SAM pour ce didacticiel, consultez [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).

Pour des exemples CloudFormation de modèles, voir les [exemples CloudFormation de modèles](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).