Prérequis Créer une stratégie d’autorisations Créer un rôle d’exécution Créer la fonction Invoquez la fonction à l'aide du AWS CLI Créer une API REST avec API Gateway Créez une ressource sur votre API REST Création d’une méthode HTTP POST Créez une table DynamoDB Test de l’intégration d’API Gateway, Lambda et DynamoDB Déploiement de l’API Utilisez curl pour invoquer votre fonction à l’aide de demandes HTTP Nettoyer vos ressources (facultatif)

Didacticiel : Utiliser Lambda avec Amazon API Gateway

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.

Services et ressources utilisés dans ce tutoriel

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 AWS Identity and Access Management (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.

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

Créer et configurer une fonction Lambda en Python ou Node.js pour effectuer des opérations sur une table DynamoDB.
Créer une API REST dans API Gateway pour se connecter à votre fonction Lambda.
Créer une table DynamoDB et la tester avec votre fonction Lambda dans la console.
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.

Sections

Prérequis
Créer une stratégie d’autorisations
Créer un rôle d’exécution
Créer la fonction
Invoquez la fonction à l'aide du AWS CLI
Créer une API REST avec API Gateway
Créez une ressource sur votre API REST
Création d’une méthode HTTP POST
Créez une table DynamoDB
Test de l’intégration d’API Gateway, Lambda et DynamoDB
Déploiement de l’API
Utilisez curl pour invoquer votre fonction à l’aide de demandes HTTP
Nettoyer vos ressources (facultatif)

Prérequis

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

Pour vous inscrire à un Compte AWS

Ouvrez https://portal.aws.amazon.com/billing/signup.
Suivez les instructions en ligne.

Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

Lorsque vous vous inscrivez à un Compte AWS, un Utilisateur racine d'un compte AWSest créé. Par défaut, seul l’utilisateur root a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur administratif, et à uniquement utiliser l’utilisateur root pour effectuer tâches nécessitant un accès utilisateur root.

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. Vous pouvez afficher l’activité en cours de votre compte et gérer votre compte à tout moment en accédant à https://aws.amazon.com/ et en cliquant sur Mon compte.

Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

Sécurisez votre Utilisateur racine d'un compte AWS

Connectez-vous en AWS Management Consoletant que propriétaire du compte en choisissant Utilisateur root et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur root, consultez Connexion en tant qu’utilisateur root dans le Guide de l’utilisateur Connexion à AWS .
Activez l’authentification multifactorielle (MFA) pour votre utilisateur root.

Pour obtenir des instructions, voir Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console) dans le guide de l'utilisateur IAM.

Création d’un utilisateur administratif

Activez IAM Identity Center.

Pour obtenir des instructions, consultez Activation d’ AWS IAM Identity Center dans le Guide de l’utilisateur AWS IAM Identity Center .
Dans IAM Identity Center, octroyez un accès administratif à un utilisateur administratif.

Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center dans le Guide de AWS IAM Identity Center l'utilisateur.

Connexion en tant qu’utilisateur administratif

Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.

Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section Connexion au portail AWS d'accès dans le guide de l'Connexion à AWS utilisateur.

Si vous ne l'avez pas encore installé AWS Command Line Interface, suivez les étapes décrites dans la section Installation ou mise à jour de la dernière version du AWS CLI pour l'installer.

Ce tutoriel nécessite un terminal de ligne de commande ou un shell pour exécuter les commandes. Sous Linux et macOS, utilisez votre gestionnaire de shell et de package préféré.

Note

Sous Windows, certaines commandes CLI Bash que vous utilisez couramment avec Lambda (par exemple zip) ne sont pas prises en charge par les terminaux intégrés du système d’exploitation. Installez le sous-système Windows pour Linux afin d’obtenir une version intégrée à Windows d’Ubuntu et Bash.

Créer une stratégie d’autorisations

Avant de créer un rôle d'exécution 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

Ouvrez la page stratégies de la console IAM.
Choisissez Créer une stratégie.

Choisissez l’onglet JSON, puis collez la stratégie personnalisée suivante dans l’éditeur 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"
    }
  ]
}

Choisissez Suivant : Balises.
Choisissez Suivant : Vérification.
Sous Examiner une stratégie, pour le Nom de la stratégie, saisissez lambda-apigateway-policy.
Choisissez Créer une stratégie.

Créer un rôle d’exécution

Un rôle d'exécution est un rôle AWS Identity and Access Management (IAM) qui accorde à une fonction Lambda l'autorisation d' AWS accéder aux services et aux 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

Ouvrez la page Rôles de la console IAM.
Sélectionnez Créer un rôle.
Pour le type d’entité de confiance, choisissez Service AWS , puis pour le cas d’utilisation, choisissez Lambda.
Choisissez Suivant.
Dans la zone de recherche de stratégie, entrez lambda-apigateway-policy.
Dans les résultats de la recherche, sélectionnez la stratégie que vous avez créée (lambda-apigateway-policy), puis choisissez Suivant.
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).

Plus loin dans le tutoriel, vous aurez besoin d’Amazon Resource Name (ARN) du rôle que vous venez de créer. Sur la page Roles (Rôles) de la console IAM, choisissez le nom de votre rôle (lambda-apigateway-role) et copiez le Role ARN (ARN du rôle) affiché sur la page Summary (Récapitulatif).

Créer la fonction

L’exemple de code suivant reçoit une entrée d’événement de API Gateway spécifiant une opération à effectuer sur la table DynamoDB que vous allez créer et quelques données utiles. Si les paramètres que la fonction reçoit sont valides, elle exécute l’opération demandée sur la table.

Node.js

Exemple index.mjs


console.log('Loading function');

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

const ddbClient = new DynamoDBClient({ region: "us-west-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;
        
        switch (operation) {
          case 'create':
               await ddbDocClient.send(new PutCommand(event.payload));
               break;
          case 'read':
               var table_item = await ddbDocClient.send(new GetCommand(event.payload));
               console.log(table_item);
               break;
          case 'update':
               await ddbDocClient.send(new UpdateCommand(event.payload));
               break;
          case 'delete':
               await ddbDocClient.send(new DeleteCommand(event.payload));
               break;
          default:
            return ('Unknown 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, consultez la section Utilisation de variables d' AWS Lambda environnement.

Pour créer la fonction

Enregistrez l'exemple de code sous forme de fichier nommé index.mjs et, si nécessaire, modifiez la AWS région spécifiée dans le code. La région spécifiée dans le code doit être la même que celle dans laquelle vous créez votre table DynamoDB plus loin dans le tutoriel.
Créez un package de déploiement à l’aide de la commande zip suivante.
```
zip function.zip index.mjs
```

Créez une fonction Lambda à l'aide de la create-function AWS CLI commande. Pour le paramètre role, saisissez Amazon Resource Name (ARN) du rôle d’exécution, que vous avez copié précédemment.


aws lambda create-function \
--function-name LambdaFunctionOverHttps \
--zip-file fileb://function.zip \
--handler index.handler \
--runtime nodejs20.x \
--role arn:aws:iam::123456789012:role/service-role/lambda-apigateway-role

Python 3

Exemple LambdaFunctionOverHttps.py


import boto3
import json

# define the DynamoDB table that Lambda will connect to
tableName = "lambda-apigateway"

# create the DynamoDB resource
dynamo = boto3.resource('dynamodb').Table(tableName)

print('Loading function')

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
    '''
    
    # define the functions used to perform the CRUD operations
    def ddb_create(x):
        dynamo.put_item(**x)

    def ddb_read(x):
        dynamo.get_item(**x)

    def ddb_update(x):
        dynamo.update_item(**x)
        
    def ddb_delete(x):
        dynamo.delete_item(**x)

    def echo(x):
        return x

    operation = event['operation']

    operations = {
        'create': ddb_create,
        'read': ddb_read,
        'update': ddb_update,
        'delete': ddb_delete,
        'echo': echo,
    }

    if operation in operations:
        return operations[operation](event.get('payload'))
    else:
        raise ValueError('Unrecognized operation "{}"'.format(operation))

Note

Pour créer la fonction

Enregistrez l’exemple de code en tant que fichier nommé LambdaFunctionOverHttps.py.
Créez un package de déploiement à l’aide de la commande zip suivante.
```
zip function.zip LambdaFunctionOverHttps.py
```


aws lambda create-function \
--function-name LambdaFunctionOverHttps \
--zip-file fileb://function.zip \
--handler LambdaFunctionOverHttps.lambda_handler \
--runtime python3.12 \
--role arn:aws:iam::123456789012:role/service-role/lambda-apigateway-role

Invoquez la fonction à l'aide du AWS CLI

Avant d’intégrer votre fonction à API Gateway, confirmez que vous avez déployé la fonction avec succès. Créez un événement de test contenant les paramètres que votre API API Gateway enverra à Lambda et utilisez la AWS CLI invoke commande pour exécuter votre fonction.

Pour appeler la fonction Lambda avec AWS CLI

Enregistrez le JSON suivant en tant que fichier nommé input.txt.


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

Exécutez la commande suivante invoke AWS CLI .
```
aws lambda invoke \
--function-name LambdaFunctionOverHttps \
--payload file://input.txt outputfile.txt \
--cli-binary-format raw-in-base64-out
```
L'cli-binary-formatoption est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez aws configure set cli-binary-format raw-in-base64-out. Pour plus d’informations, consultez les options de ligne de commande globales prises en charge par l’AWS CLI dans le Guide de l’utilisateur AWS Command Line Interface version 2.

Vous devriez voir la réponse suivante :
```
{
"StatusCode": 200,
"ExecutedVersion": "LATEST"
}
```
Confirmez que votre fonction a effectué l’opération echo que vous avez spécifiée dans l’événement de test JSON. Inspectez le fichier outputfile.txt et vérifiez qu’il contient les éléments suivants :
```
{"somekey1": "somevalue1", "somekey2": "somevalue2"}
```

Créer une API REST avec API Gateway

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

Pour créer l’API

Ouvrez la console API Gateway.
Sélectionnez Create API (Créer une API).
Dans la boîte de dialogue API REST, choisissez Créer.
Sous Détails de l’API, laissez Nouvelle API sélectionnée et pour Nom de l’API, saisissez DynamoDBOperations.
Sélectionnez Create API (Créer une API).

Créez une ressource sur votre API REST

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

Dans la console API Gateway, sur la page Ressources de votre API, choisissez Create Resource (Créer une ressource).
Dans Détails de la ressource, pour Nom de la ressource saisissez DynamoDBManager.
Choisissez Create Resource.

Création d’une méthode HTTP POST

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 dans Serverless Land.

Pour créer la méthode POST

Sur la page Ressources de votre API, assurez-vous que la ressource /DynamoDBManager est surlignée. Ensuite, dans le volet Méthodes, choisissez Create Method (Créer une méthode).
Pour Type de méthode, sélectionnez POST.
Pour Type d’intégration, laissez la Fonction Lambda sélectionnée.
Pour la Fonction Lambda, choisissez l’Amazon Resource Name (ARN) pour votre fonction (LambdaFunctionOverHttps).
Choisissez Créer une méthode.

Créez une table DynamoDB

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

Créer le tableau DynamoDB

Ouvrez la page Tables (Tables) de la console DynamoDB.
Choisissez Créer un tableau.
Sous Détails du tableau, procédez comme suit :
1. Sous Nom du tableau, saisissez lambda-apigateway.
2. Pour Clé de partition, saisissez id, et conservez le type de données défini comme Chaîne.
Sous Table settings (Paramètres de la table), conservez les Default settings (Paramètres par défaut).
Choisissez Créer un tableau.

Test de l’intégration d’API Gateway, Lambda et DynamoDB

Étape 9 : tester l’intégration d’API Gateway, Lambda et DynamoDB

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

Dans la console API Gateway, choisissez votre API (DynamoDBOperations).
Choisissez la méthode POST sous la DynamoDBManager ressource.
Choisissez l’onglet Test. Vous devrez peut-être choisir la flèche droite pour afficher l'onglet.
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
    }
  }
}
```
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.
Ouvrez la page Tables de la console DynamoDB et choisissez la table lambda-apigateway.
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.

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

Dans la Console API Gateway, revenez à l’onglet Test votre méthode POST.

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"
        },
        "AttributeUpdates": {
            "number": {
                "Value": 10
            }
        }
    }
}

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é.
Ouvrez la page Tables de la console DynamoDB et choisissez la table lambda-apigateway.
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.

Déploiement de l’API

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

Ouvrez la page APIs (Les API) de la console API Gateway et choisissez l’API DynamoDBOperations.
Sur la page Ressources de votre API, choisissez Deploy API (Déployer l’API).
Pour Stage (Étape), choisissez *New stage* (Nouvelle étape), puis pour Stage name (Nom de l’étape), saisissez test.
Choisissez Deploy (Déployer).
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

Étape 11 : invoquer la fonction à l’aide d’une demande HTTP

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 le supprimer.

Pour invoquer la fonction Lambda à l’aide de curl

Exécutez la commande curl suivante en utilisant l’URL invoquée que vous avez copiée à l’étape précédente. Lorsque vous utilisez curl avec l’option -d (data), il utilise automatiquement la méthode HTTP POST.
```
curl https://l8togsqxd8.execute-api.us-west-2.amazonaws.com/test/DynamoDBManager \
-d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}'
```
Pour vérifier que l’opération de création a réussi, procédez comme suit :
1. Ouvrez la page Tables de la console DynamoDB et choisissez la table lambda-apigateway.
2. 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.

Exécutez la commande curl suivante pour supprimer l’élément que vous venez de créer. Utilisez votre propre URL invoquée.


curl https://l8togsqxd8.execute-api.us-west-2.amazonaws.com/test/DynamoDBManager \
-d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}'

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)

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

Ouvrez la page Functions (Fonctions) de la console Lambda.
Sélectionnez la fonction que vous avez créée.
Sélectionnez Actions, Supprimer.
Saisissez delete dans la zone de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer le rôle d’exécution

Ouvrez la page Roles (Rôles) de la console IAM.
Sélectionnez le rôle d’exécution que vous avez créé.
Sélectionnez Delete (Supprimer).
Saisissez le nom du rôle dans le champ de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer l’API

Ouvrez la page API de la console API Gateway.
Sélectionnez l’API que vous avez créée.
Sélectionnez Actions, Supprimer.
Sélectionnez Supprimer.

Pour supprimer la table DynamoDB

Ouvrez la page Tables (Tables) de la console DynamoDB.
Sélectionnez la table que vous avez créée.
Choisissez Supprimer.
Saisissez delete dans la zone de texte.
Choisissez Supprimer la table.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

API Gateway

Application Composer