Didacticiel : création d’une API HTTP CRUD avec Lambda et DynamoDB - Amazon API Gateway
Étape 1 : création d’une table DynamoDBÉtape 2 : création d’une fonction LambdaÉtape 3 : création d’une API HTTPÉtape 4 : création de routesÉtape 5 : création d’une intégrationÉtape 6 : attachement de votre intégration aux routesÉtape 7 : test de votre APIÉtape 8 : NettoyageProchaines étapes : automatiser avec AWS SAM ou CloudFormation

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

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.

Tout d’abord, vous créez une table DynamoDB à l’aide de la console DynamoDB. Ensuite, vous créez une fonction Lambda à l’aide de la console AWS Lambda. 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.

Pour effectuer cet exercice, vous avez besoin d’un compte AWS et d’un utilisateur AWS Identity and Access Management avec accès à la console. Pour de plus amples informations, veuillez consulter Configuration d’API Gateway avant son utilisation.

Dans ce didacticiel, vous utiliserez la AWS Management Console. Pour obtenir un modèle AWS SAM qui crée cette API et toutes les ressources connexes, consultez template.yaml.

Étape 1 : création d’une table DynamoDB

Vous utilisez une table DynamoDB 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 pour la table.

Pour créer une table DynamoDB

  1. Ouvrez la console DynamoDB à l’adresse https://console.aws.amazon.com/dynamodb/.

  2. Choisissez Create table (Créer une table).

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

  4. Pour Clé de partition, saisissez id.

  5. Choisissez Create table (Créer une table).

Étape 2 : création d’une fonction Lambda

Vous utilisez une fonction Lambda 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 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 (français non garanti).

Pour créer une fonction Lambda

  1. Connectez-vous à la console Lambda à l’adresse https://console.aws.amazon.com/lambda/.

  2. Choisissez Créer une fonction.

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

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

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

  6. Sélectionnez Créer un nouveau rôle à partir de modèles de politiques AWS.

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

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

  9. Choisissez Créer une fonction.

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

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.

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

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

  4. Pour Type d’adresse IP, sélectionnez IPv4.

  5. Choisissez Suivant.

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

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

  8. Choisissez Créer.

Étape 4 : création de routes

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.

  2. Choisissez votre API.

  3. Choisissez Routes.

  4. Choisissez Créer.

  5. Pour Méthode, choisissez GET.

  6. Pour le chemin, saisissez /items/{id}. 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.

  7. Choisissez Créer.

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

Étape 5 : création d’une intégration

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.

  2. Choisissez votre API.

  3. Choisissez Integrations (Intégrations).

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

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

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

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

  8. Choisissez Créer.

Étape 6 : attachement de votre intégration aux routes

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.

  2. Choisissez votre API.

  3. Choisissez Integrations (Intégrations).

  4. Choisissez une route.

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

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

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

Toutes les routes indiquent qu’une intégration AWS Lambda est attachée.

La console affiche AWS Lambda sur tous les routes afin d’indiquer que votre intégration est attachée.

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

Afin de vous assurer que votre API fonctionne, vous utilisez curl.

Pour obtenir l’URL pour appeler votre API

  1. Connectez-vous à la console API Gateway à l’adresse https://console.aws.amazon.com/apigateway.

  2. Choisissez votre API.

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

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

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

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

  2. Sélectionnez votre table.

  3. Choisissez Supprimer la table.

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

  2. Sur la page APIs (API), sélectionnez une API. Choisissez Actions, puis Supprimer.

  3. Sélectionnez Delete.

Pour supprimer une fonction Lambda

  1. Connectez-vous à la console Lambda à l’adresse https://console.aws.amazon.com/lambda/.

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

  3. Sélectionnez Delete.

Pour supprimer le groupe de journaux d’une fonction Lambda

  1. Dans la console Amazon CloudWatch, ouvrez la page Groupes de journaux.

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

  3. Sélectionnez Delete.

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

  1. Dans la console AWS Identity and Access Management, ouvrez la page Rôles.

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

  3. Choisissez Supprimer le rôle.

  4. Choisissez Oui, supprimer.

Prochaines étapes : automatiser avec AWS SAM ou CloudFormation

Vous pouvez automatiser la création et le nettoyage des ressources AWS en utilisant CloudFormation ou AWS SAM. Afin d’obtenir un exemple de modèle AWS SAM pour ce didacticiel, consultez template.yaml.

Pour des exemples de modèles CloudFormation, consultez exemples de modèles CloudFormation.