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. # Traiter les événements Amazon DocumentDB avec Lambda Vous pouvez utiliser une fonction Lambda pour traiter les événements dans un [flux de modifications Amazon DocumentDB (compatible avec MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) en configurant un cluster Amazon DocumentDB comme source d’événements. Ensuite, vous pouvez automatiser les charges de travail orientées événements en invoquant votre fonction Lambda chaque fois que les données changent avec votre cluster Amazon DocumentDB. **Note** Lambda prend en charge uniquement les versions 4.0 et 5.0 d’Amazon DocumentDB. Lambda ne prend pas en charge la version 3.6. De plus, pour les mappages des sources d’événements, Lambda ne prend en charge que les clusters basés sur des instances et les clusters régionaux. Lambda ne prend pas en charge les [clusters élastiques](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html) ni les [clusters globaux](https://docs.aws.amazon.com/documentdb/latest/developerguide/global-clusters.html). Cette limitation ne s’applique pas lorsque vous utilisez Lambda en tant que client pour vous connecter à Amazon DocumentDB. Lambda peut se connecter à tous les types de clusters pour effectuer des opérations CRUD. Lambda traite les événements des flux de modifications Amazon DocumentDB de manière séquentielle dans l’ordre de leur arrivée. Pour cette raison, votre fonction ne peut gérer qu’une seule invocation simultanée d’Amazon DocumentDB à la fois. Pour surveiller votre fonction, vous pouvez suivre ses [métriques de simultanéité](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-concurrency.html). **Avertissement** Les mappages des sources d’événements Lambda traitent chaque événement au moins une fois, et le traitement des enregistrements peut être dupliqué. Pour éviter les problèmes potentiels liés à des événements dupliqués, nous vous recommandons vivement de rendre votre code de fonction idempotent. Pour en savoir plus, consultez [Comment rendre ma fonction Lambda idempotente](https://repost.aws/knowledge-center/lambda-function-idempotent) dans le Knowledge Center. AWS **Topics** + [ ## Exemple d’événement Amazon DocumentDB ](#docdb-sample-event) + [ ## Conditions préalables et autorisations ](#docdb-prereqs) + [ ## Configurer la sécurité réseau ](#docdb-network) + [ ## Création d’un mappage des sources d’événements Amazon DocumentDB (console) ](#docdb-configuration) + [ ## Création d’un mappage des sources d’événements Amazon DocumentDB (kit SDK ou CLI) ](#docdb-api) + [ ## Positions de départ des interrogations et des flux ](#docdb-stream-polling) + [ ## Surveillance de votre source d’événements Amazon DocumentDB ](#docdb-monitoring) + [ # Tutoriel : Utilisation AWS Lambda avec Amazon DocumentDB Streams ](with-documentdb-tutorial.md) ## Exemple d’événement Amazon DocumentDB ``` { "eventSourceArn": "arn:aws:rds:us-east-1:123456789012:cluster:canaryclusterb2a659a2-qo5tcmqkcl03", "events": [ { "event": { "_id": { "_data": "0163eeb6e7000000090100000009000041e1" }, "clusterTime": { "$timestamp": { "t": 1676588775, "i": 9 } }, "documentKey": { "_id": { "$oid": "63eeb6e7d418cd98afb1c1d7" } }, "fullDocument": { "_id": { "$oid": "63eeb6e7d418cd98afb1c1d7" }, "anyField": "sampleValue" }, "ns": { "db": "test_database", "coll": "test_collection" }, "operationType": "insert" } } ], "eventSource": "aws:docdb" } ``` Pour plus d’informations sur les événements de cet exemple et leurs formes, consultez la page [Événements de modification](https://www.mongodb.com/docs/manual/reference/change-events/) sur le site Web de la documentation MongoDB. ## Conditions préalables et autorisations Avant de pouvoir utiliser Amazon DocumentDB comme source d’événements pour votre fonction Lambda, veuillez prendre note des conditions préalables suivantes. Vous devez : + **Disposez d'un cluster Amazon DocumentDB existant au même endroit Région AWS que votre fonction Compte AWS et en tant que tel.** Si vous n’avez pas de cluster existant, vous pouvez en créer un en suivant les étapes de la section [Prise en main d’Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) dans le *Guide du développeur Amazon DocumentDB*. Sinon, la première série d’étapes de [Tutoriel : Utilisation AWS Lambda avec Amazon DocumentDB Streams](with-documentdb-tutorial.md) vous guide dans la création d’un cluster Amazon DocumentDB avec tous les prérequis nécessaires. + **Autorisez Lambda à accéder aux ressources Amazon Virtual Private Cloud (Amazon VPC) associées à votre cluster Amazon DocumentDB.** Pour de plus amples informations, veuillez consulter [Configurer la sécurité réseau](#docdb-network). + **Activez le protocole TLS sur votre cluster Amazon DocumentDB.** Il s’agit du paramètre par défaut. Si vous désactivez le protocole TLS, Lambda ne peut pas communiquer avec votre cluster. + **Activez les flux de modifications sur votre cluster Amazon DocumentDB.** Pour plus d’informations, veuillez consulter la rubrique [Utilisation des flux de modifications avec Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) dans le *Guide du développeur Amazon DocumentDB*. + **Fournissez à Lambda les informations d’identification pour accéder à votre cluster Amazon DocumentDB.** Lors de la configuration de la source d’événement, fournissez la clé [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) qui contient les informations d’authentification (nom d’utilisateur et mot de passe) requises pour accéder à votre cluster. Pour fournir cette clé lors de la configuration, procédez de l’une des manières suivantes : + Si vous utilisez la console Lambda pour la configuration, saisissez cette clé dans le champ **Clé du gestionnaire de secrets**. + Si vous utilisez le AWS Command Line Interface (AWS CLI) pour la configuration, fournissez cette clé dans l'`source-access-configurations`option. Vous pouvez inclure cette option avec la commande [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html) ou la commande [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html). Par exemple : ``` aws lambda create-event-source-mapping \ ... --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-west-2:123456789012:secret:DocDBSecret-AbC4E6"}]' \ ... ``` + **Accordez des autorisations à Lambda pour gérer les ressources liées à votre flux Amazon DocumentDB.** Ajoutez manuellement les autorisations suivantes au [rôle d’exécution](lambda-intro-execution-role.md) de votre fonction : + [RDS : Décrivez DBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) + [RDS DBCluster : Décrire les paramètres](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusterParameters.html) + [RDS DBSubnet : Décrire les groupes](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBSubnetGroups.html) + [EC2 : CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html) + [EC2 : DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html) + [EC2 : DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html) + [EC2 : DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html) + [EC2 : DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html) + [EC2 : DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html) + [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) + [responsable des secrets : GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) + **La taille des événements de flux de modifications Amazon DocumentDB que vous envoyez à Lambda doit être inférieure à 6 Mo.** Lambda prend en charge des charges utiles d’une taille maximale de 6 Mo. Si votre flux de modifications essaie d’envoyer à Lambda un événement supérieur à 6 Mo, Lambda supprime le message et émet la métrique `OversizedRecordCount`. Lambda émet toutes les métriques dans la mesure du possible. **Note** Alors que les fonctions Lambda ont généralement un délai d’expiration maximal de 15 minutes, les mappages des sources d’événement pour Amazon MSK, Apache Kafka autogéré, Amazon DocumentDB et Amazon MQ pour ActiveMQ et RabbitMQ ne prennent en charge que les fonctions dont le délai d’expiration maximal est de 14 minutes. Cette contrainte garantit que le mappage des sources d’événements peut gérer correctement les erreurs de fonction et effectuer de nouvelles tentatives. ## Configurer la sécurité réseau Pour donner à Lambda un accès complet à Amazon DocumentDB via votre mappage des sources d’événements, soit votre cluster doit utiliser un point de terminaison public (adresse IP publique), soit vous devez fournir un accès au VPC Amazon dans lequel vous avez créé le cluster. Lorsque vous utilisez Amazon DocumentDB avec Lambda, créez des [points de terminaison de VPC AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) qui permettent à votre fonction d’accéder aux ressources de votre Amazon VPC. **Note** AWS PrivateLink Les points de terminaison VPC sont requis pour les fonctions avec des mappages de sources d'événements qui utilisent le mode par défaut (à la demande) pour les sondeurs d'événements. Si le mappage de votre source d'événements utilise le [mode provisionné](invocation-eventsourcemapping.md#invocation-eventsourcemapping-provisioned-mode), vous n'avez pas besoin de configurer les points de terminaison AWS PrivateLink VPC. Créez un point de terminaison pour accéder aux ressources suivantes : + Lambda — Créez un point de terminaison pour le principal de service Lambda. + AWS STS — Créez un point de terminaison pour le AWS STS afin qu'un directeur de service assume un rôle en votre nom. + Secrets Manager : si votre cluster utilise Secrets Manager pour stocker les informations d’identification, créez un point de terminaison pour Secrets Manager. Vous pouvez également configurer une passerelle NAT sur chaque sous-réseau public d’Amazon VPC. Pour de plus amples informations, veuillez consulter [Activation de l’accès Internet pour les fonctions Lambda connectées à un VPC](configuration-vpc-internet.md). Lorsque vous créez un mappage de source d'événements pour Amazon DocumentDB, Lambda vérifie si des interfaces réseau élastiques (ENIs) sont déjà présentes pour les sous-réseaux et les groupes de sécurité configurés pour votre Amazon VPC. Si Lambda trouve des objets existants ENIs, il essaie de les réutiliser. Sinon, Lambda en crée un nouveau ENIs pour se connecter à la source de l'événement et appeler votre fonction. **Note** Les fonctions Lambda s'exécutent toujours au sein VPCs du service Lambda. La configuration VPC de votre fonction n’affecte pas le mappage des sources d’événements. Seule la configuration réseau des sources d’événements détermine la manière dont Lambda se connecte à votre source d’événements. Configurez les groupes de sécurité pour le VPC Amazon contenant votre cluster. Par défaut, Amazon DocumentDB utilise les ports suivants : `27017`. + Règles entrantes – Autorisent tout le trafic sur le port de l’agent par défaut pour le groupe de sécurité associé à votre source d’événement. Vous pouvez également utiliser une règle de groupe de sécurité avec référence circulaire pour autoriser l’accès à partir d’instances appartenant au même groupe de sécurité. + Règles de sortie : autorisez tout le trafic sur le port `443` pour les destinations externes si votre fonction doit communiquer avec les AWS services. Vous pouvez également utiliser une règle de groupe de sécurité à référencement automatique pour limiter l'accès au courtier si vous n'avez pas besoin de communiquer avec d'autres AWS services. + Règles entrantes relatives au point de terminaison Amazon VPC – Si vous utilisez un point de terminaison Amazon VPC, le groupe de sécurité associé à votre point de terminaison Amazon VPC doit autoriser le trafic entrant sur le port `443` en provenance du groupe de sécurité du cluster. Si votre cluster utilise l’authentification, vous pouvez également restreindre la politique de point de terminaison pour le point de terminaison Secrets Manager. Pour appeler l’API Secrets Manager, Lambda utilise votre rôle de fonction, et non le principal de service Lambda. **Example Politique de point de terminaison de VPC — Point de terminaison Secrets Manager** ``` { "Statement": [ { "Action": "secretsmanager:GetSecretValue", "Effect": "Allow", "Principal": { "AWS": [ "arn:aws::iam::123456789012:role/my-role" ] }, "Resource": "arn:aws::secretsmanager:us-west-2:123456789012:secret:my-secret" } ] } ``` Lorsque vous utilisez des points de terminaison Amazon VPC, AWS achemine vos appels d'API pour appeler votre fonction à l'aide de l'Elastic Network Interface (ENI) du point de terminaison. Le directeur du service Lambda doit faire appel à tous `lambda:InvokeFunction` les rôles et fonctions qui les utilisent. ENIs Par défaut, les points de terminaison Amazon VPC disposent de politiques IAM ouvertes qui permettent un accès étendu aux ressources. La meilleure pratique consiste à restreindre ces politiques pour effectuer les actions nécessaires à l’aide de ce point de terminaison. Pour garantir que votre mappage des sources d’événements est en mesure d’invoquer votre fonction Lambda, la politique de point de terminaison de VPC doit autoriser le principal de service Lambda à appeler `sts:AssumeRole` et `lambda:InvokeFunction`. Le fait de restreindre vos politiques de point de terminaison de VPC pour autoriser uniquement les appels d’API provenant de votre organisation empêche le mappage des sources d’événements de fonctionner correctement. C’est pourquoi `"Resource": "*"` est requis dans ces politiques. Les exemples de politiques de point de terminaison de VPC suivants montrent comment accorder l’accès requis au principal de service Lambda pour les points de terminaison AWS STS et Lambda. **Example Politique de point de terminaison VPC — point de terminaison AWS STS** ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` **Example Politique de point de terminaison de VPC — Point de terminaison Lambda** ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` ## Création d’un mappage des sources d’événements Amazon DocumentDB (console) Pour qu’une fonction Lambda puisse lire le flux de modifications d’un cluster Amazon DocumentDB, créez un [mappage des sources d’événements](invocation-eventsourcemapping.md). Cette section explique comment procéder à partir de la console Lambda. Pour le AWS SDK et les AWS CLI instructions, voir[Création d’un mappage des sources d’événements Amazon DocumentDB (kit SDK ou CLI)](#docdb-api). **Pour créer un mappage des sources d’événements Amazon DocumentDB (console)** 1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda. 1. Choisissez le nom d’une fonction. 1. Sous **Function overview (Présentation de la fonction)**, choisissez **Add trigger (Ajouter un déclencheur)**. 1. Sous **Configuration du déclencheur**, dans la liste déroulante, choisissez **DocumentDB**. 1. Configurez les options requises, puis choisissez **Add (Ajouter)**. Lambda prend en charge les options suivantes pour les sources d’événement Amazon DocumentDB : + **Cluster DocumentDB** : sélectionnez un cluster Amazon DocumentDB. + **Activer le déclencheur** : choisissez si vous voulez activer le déclencheur maintenant. Si vous cochez cette case, votre fonction commence immédiatement à recevoir du trafic provenant du flux de modifications Amazon DocumentDB spécifié lors de la création du mappage des sources d’événements. Nous vous recommandons de décocher la case pour créer le mappage des sources d’événements dans un état désactivé à des fins de test. Après la création, vous pouvez activer le mappage des sources d’événements à tout moment. + **Nom de la base de données –** Saisissez le nom de la base de données du cluster à utiliser. + (Facultatif) **Nom de la collection** : saisissez le nom d’une collection de la base de données à utiliser. Si vous n’indiquez pas de collection, Lambda écoute tous les événements de chaque collection de la base de données. + **Taille de lot –** Définissez le nombre maximum de messages à extraire dans un lot, jusqu’à 10 000. La taille du lot par défaut est de 100. + **Position de départ –** Choisissez la position dans le flux à partir de laquelle commencer la lecture des enregistrements. + **Derniers –** Traiter uniquement les nouveaux enregistrements qui sont ajoutés au flux. Votre fonction ne commence à traiter les enregistrements que lorsque Lambda a fini de créer votre source d’événements. Cela signifie que certains enregistrements peuvent être supprimés jusqu’à ce que la source de votre événement soit correctement créée. + **Trim horizon (Supprimer l’horizon)** – Traiter tous les enregistrements figurant dans le flux. Lambda utilise la durée de conservation des journaux de votre cluster pour déterminer par où commencer la lecture des événements. Plus précisément, Lambda commence à lire à partir de `current_time - log_retention_duration`. Votre flux de modifications doit déjà être actif avant cet horodatage pour que Lambda puisse lire correctement tous les événements. + **At timestamp (À l’horodatage)** – Traitez les enregistrements à partir d’une heure spécifique. Votre flux de modifications doit déjà être actif avant l’horodatage spécifié pour que Lambda puisse lire correctement tous les événements. + **Authentication –** Choisissez la méthode d’authentification pour accéder aux agents de votre cluster. + **BASIC\$1AUTH –** Avec l’authentification de base, vous devez fournir la clé Secrets Manager qui contient les informations d’identification pour accéder à votre cluster. + **Clé Secrets Manager** : choisissez la clé Secrets Manager qui contient les informations d’authentification (nom d’utilisateur et mot de passe) requises pour accéder à votre cluster Amazon DocumentDB. + (Facultatif) **Fenêtre de traitement par lot** : définissez l’intervalle de temps maximum (en secondes) pour collecter des enregistrements avant d’invoquer votre fonction, jusqu’à 300. + (Facultatif) **Configuration complète du document** : pour les opérations de mise à jour des documents, choisissez ce que vous voulez envoyer au flux. La valeur par défaut est `Default`, ce qui signifie que pour chaque événement de flux de modifications, Amazon DocumentDB envoie uniquement un delta décrivant les modifications apportées. Pour plus d'informations sur ce champ, consultez la documentation [FullDocument](https://mongodb.github.io/mongo-java-driver/3.9/javadoc/com/mongodb/client/model/changestream/FullDocument.html#DEFAULT)de l'API MongoDB Javadoc. + **Par défaut –** Lambda n’envoie qu’un document partiel décrivant les modifications apportées. + **UpdateLookup**— Lambda envoie un delta décrivant les modifications, ainsi qu'une copie de l'intégralité du document. ## Création d’un mappage des sources d’événements Amazon DocumentDB (kit SDK ou CLI) Pour créer ou gérer votre mappage des sources d’événements Amazon DocumentDB avec un [kit SDK AWS](https://aws.amazon.com/developer/tools/), vous pouvez utiliser les opérations d’API suivantes : + [CreateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_CreateEventSourceMapping.html) + [ListEventSourceMappings](https://docs.aws.amazon.com/lambda/latest/api/API_ListEventSourceMappings.html) + [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html) + [UpdateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html) + [DeleteEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteEventSourceMapping.html) Pour créer le mappage des sources d'événements avec le AWS CLI, utilisez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html)commande. L’exemple suivant utilise cette commande pour mapper une fonction nommée `my-function` à un flux de modifications Amazon DocumentDB. La source d’événement est spécifiée par un Amazon Resource Name (ARN), avec une taille de lot de 500, à partir de l’horodatage en heure Unix. La commande spécifie également la clé Secrets Manager que Lambda utilise pour se connecter à Amazon DocumentDB. De plus, elle inclut des paramètres `document-db-event-source-config` qui spécifient la base de données et la collection à partir de laquelle lire. ``` aws lambda create-event-source-mapping --function-name my-function \ --event-source-arn arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy --batch-size 500 \ --starting-position AT_TIMESTAMP \ --starting-position-timestamp 1541139109 \ --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-east-1:123456789012:secret:DocDBSecret-BAtjxi"}]' \ --document-db-event-source-config '{"DatabaseName":"test_database", "CollectionName": "test_collection"}' \ ``` Vous devriez obtenir un résultat du type suivant : ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "BatchSize": 500, "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "MaximumBatchingWindowInSeconds": 0, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541348195.412, "LastProcessingResult": "No records processed", "State": "Creating", "StateTransitionReason": "User action" } ``` Après la création, vous pouvez utiliser la commande [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html) pour mettre à jour les paramètres de votre source d’événements Amazon DocumentDB. L’exemple suivant met à jour la taille du lot à 1 000 et la fenêtre de traitement par lots à 10 secondes. Pour cette commande, vous avez besoin de l’UUID de votre mappage des sources d’événements, que vous pouvez récupérer à l’aide de la commande `list-event-source-mapping` ou de la console Lambda. ``` aws lambda update-event-source-mapping --function-name my-function \ --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \ --batch-size 1000 \ --batch-window 10 ``` Vous devriez obtenir un résultat du type suivant : ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "BatchSize": 500, "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "MaximumBatchingWindowInSeconds": 0, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541359182.919, "LastProcessingResult": "OK", "State": "Updating", "StateTransitionReason": "User action" } ``` Lambda met à jour les paramètres de façon asynchrone, il se peut donc que vous ne voyiez pas ces modifications dans la sortie tant que le processus n’est pas terminé. Pour afficher les paramètres actuels de votre mappage des sources d’événements, utilisez la commande [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-event-source-mapping.html). ``` aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b ``` Vous devriez obtenir un résultat du type suivant : ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "BatchSize": 1000, "MaximumBatchingWindowInSeconds": 10, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541359182.919, "LastProcessingResult": "OK", "State": "Enabled", "StateTransitionReason": "User action" } ``` Pour supprimer le mappage des sources d’événements Amazon DocumentDB, utilisez la commande [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-event-source-mapping.html). ``` aws lambda delete-event-source-mapping \ --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 ``` ## Positions de départ des interrogations et des flux Sachez que l’interrogation des flux lors des mises à jour et de la création du mappage des sources d’événements est finalement cohérente. + Lors de la création du mappage des sources d’événements, le démarrage de l’interrogation des événements depuis le flux peut prendre plusieurs minutes. + Lors des mises à jour du mappage des sources d’événements, l’arrêt et le redémarrage de l’interrogation des événements depuis le flux peuvent prendre plusieurs minutes. Ce comportement signifie que si vous spécifiez `LATEST` comme position de départ du flux, le mappage des sources d’événements peut manquer des événements lors de la création ou des mises à jour. Pour vous assurer de ne manquer aucun événement, spécifiez la position de départ du flux comme `TRIM_HORIZON` ou `AT_TIMESTAMP`. ## Surveillance de votre source d’événements Amazon DocumentDB Pour vous aider à surveiller votre source d’événements Amazon DocumentDB, Lambda émet la métrique `IteratorAge` lorsque votre fonction termine le traitement d’un lot d’enregistrements. *L’âge de l’itérateur* est la différence entre l’horodatage de l’événement le plus récent et l’horodatage actuel. La métrique `IteratorAge` indique essentiellement l’ancienneté du dernier enregistrement traité dans le lot. Si votre fonction traite actuellement de nouveaux événements, vous pouvez utiliser l’âge de l’itérateur pour estimer la latence entre le moment où un enregistrement est ajouté et celui où votre fonction le traite. Une tendance à la hausse de `IteratorAge` peut indiquer des problèmes liés à votre fonction. Pour de plus amples informations, veuillez consulter [Utilisation des métriques CloudWatch avec Lambda](monitoring-metrics.md). Les flux de modifications Amazon DocumentDB ne sont pas optimisés pour gérer les intervalles de temps importants entre les événements. Si votre source d’événements Amazon DocumentDB ne reçoit aucun événement pendant une longue période, Lambda peut désactiver le mappage des sources d’événements. Cette période peut varier de quelques semaines à quelques mois en fonction de la taille du cluster et des autres charges de travail. Lambda prend en charge des charges utiles allant jusqu’à 6 Mo. Cependant, les événements du flux de modification d’Amazon DocumentDB peuvent avoir une taille allant jusqu’à 16 Mo. Si votre flux de modifications tente d’envoyer à Lambda un événement d’une taille supérieure à 6 Mo, Lambda supprime le message et émet la métrique `OversizedRecordCount`. Lambda émet toutes les métriques dans la mesure du possible. # Tutoriel : Utilisation AWS Lambda avec Amazon DocumentDB Streams Dans ce tutoriel, vous créez une fonction Lambda de base qui consomme des événements à partir d’un flux de modifications Amazon DocumentDB (compatible avec MongoDB). Pour réaliser ce tutoriel, vous passerez par les étapes suivantes : + Configurez votre cluster Amazon DocumentDB, connectez-vous-y, et activez les flux de modifications sur ce cluster. + Créez votre fonction Lambda, et configurez votre cluster Amazon DocumentDB en tant que source d’événements pour votre fonction. + Testez la configuration en insérant des éléments dans votre base de données Amazon DocumentDB. ## Créer le cluster Amazon DocumentDB 1. Ouvrez la [console Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). Sous **Clusters**, sélectionnez **Créer**. 1. Créez un cluster avec la configuration suivante : + Pour **Type de cluster**, choisissez **Cluster basé sur l’instance**. Il s’agit de l’option par défaut. + Sous **Configuration du cluster**, assurez-vous que la **Version du moteur** 5.0.0 est sélectionnée. Il s’agit de l’option par défaut. + Sous **Configuration de l’instance** : + Pour **Classe d’instance de base de données**, sélectionnez **Classes à mémoire optimisée**. Il s’agit de l’option par défaut. + Pour **Nombre d’instances de réplica ordinaire**, choisissez 1. + Pour **Classe de l’instance**, utilisez la sélection par défaut. + Sous **Authentification**, saisissez un nom d’utilisateur pour l’utilisateur principal, puis choisissez **Autogéré**. Saisissez un mot de passe, puis confirmez-le. + Conservez tous les autres paramètres par défaut. 1. Choisissez **Créer un cluster**. ## Création d’un secret dans Secrets Manager Pendant qu'Amazon DocumentDB crée votre cluster, créez un AWS Secrets Manager secret pour stocker les informations d'identification de votre base de données. Vous fournirez ce secret lors de la création du mappage des sources d’événements Lambda lors d’une étape ultérieure. **Pour créer le secret dans Secrets Manager** 1. Ouvrez la console [Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#) et choisissez **Stocker un nouveau secret**. 1. Pour **Choisir le type de secret**, sélectionnez les options suivantes : + Sous **Informations de base** : + **Type de secret** : informations d’identification pour votre base de données Amazon DocumentDB + Sous **Informations d’identification**, saisissez les mêmes nom d’utilisateur et mot de passe que vous avez utilisés pour créer votre cluster Amazon DocumentDB. + **Base de données** : choisissez votre cluster Amazon DocumentDB. + Choisissez **Suivant**. 1. Pour **Configurer le secret**, choisissez les options suivantes : + **Nom secret** : `DocumentDBSecret` + Choisissez **Suivant**. 1. Choisissez **Suivant**. 1. Choisissez **Stocker**. 1. Actualisez la console pour vérifier que vous avez correctement enregistré le secret `DocumentDBSecret`. Notez l’**ARN du secret**. Vous en aurez besoin dans une étape ultérieure. ## Connexion au cluster **Connectez-vous à votre cluster Amazon DocumentDB à l'aide de AWS CloudShell** 1. Dans la console de gestion Amazon DocumentDB, sous **Clusters**, recherchez le cluster que vous avez créé. Sélectionnez votre cluster en cochant la case en regard de celui-ci. 1. Choisissez **Se connecter au cluster**. L'écran CloudShell **Exécuter la commande** apparaît. 1. Dans le champ **Nom du nouvel environnement**, saisissez un nom unique, comme « test », puis choisissez **Créer et exécuter**. 1. Lorsque vous y êtes invité, saisissez votre mot de passe. Lorsque l’invite affiche `rs0 [direct: primary] >`, vous êtes connecté avec succès à votre cluster Amazon DocumentDB. ## Activation des flux de modifications Pour ce tutoriel, vous allez suivre les modifications apportées à la collection `products` de la base de données `docdbdemo` dans votre cluster Amazon DocumentDB. Pour ce faire, vous activez les [flux de modifications](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html). **Pour créer une nouvelle base de données dans votre cluster** 1. Exécutez la commande suivante pour créer une nouvelle base de données appelée `docdbdemo` : ``` use docdbdemo ``` 1. Dans la fenêtre de terminal, utilisez la commande suivante pour insérer un enregistrement dans `docdbdemo` : ``` db.products.insertOne({"hello":"world"}) ``` Elle doit générer une sortie comme suit : ``` { acknowledged: true, insertedId: ObjectId('67f85066ca526410fd531d59') } ``` 1. Activez ensuite les flux de modifications sur la collection `products` de la base de données `docdbdemo` à l’aide de la commande suivante : ``` db.adminCommand({modifyChangeStreams: 1, database: "docdbdemo", collection: "products", enable: true}); ``` Vous devriez obtenir un résultat du type suivant : ``` { "ok" : 1, "operationTime" : Timestamp(1680126165, 1) } ``` ## Création de points de terminaison d’un VPC d’interface Créez ensuite des [points de terminaison d’un VPC d’interface](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) pour vous assurer que Lambda et Secrets Manager (utilisé plus tard pour stocker nos informations d’identification d’accès au cluster) peuvent se connecter à votre VPC par défaut. **Pour créer des points de terminaison d’un VPC d’interface** 1. Ouvrez la [console VPC](https://console.aws.amazon.com/vpc/home#). Dans le menu de gauche, sous **Cloud privé virtuel**, choisissez **Points de terminaison**. 1. Choisissez **Créer un point de terminaison**. Créez un point de terminaison avec la configuration suivante : + Pour **Balise de nom**, saisissez `lambda-default-vpc`. + Pour la **catégorie de service**, sélectionnez AWS services. + Pour **Services**, saisissez `lambda` dans la zone de recherche. Choisissez le service au format `com.amazonaws..lambda`. + Pour **VPC**, choisissez le VPC dans lequel se trouve votre cluster Amazon DocumentDB. Il s’agit généralement du [VPC par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + Pour **Sous-réseaux**, cochez les cases à côté de chaque zone de disponibilité. Choisissez l’ID de sous-réseau correct pour chaque zone de disponibilité. + Pour le **type d'adresse IP**, sélectionnez IPv4. + Pour **Groupes de sécurité**, choisissez le groupe de sécurité utilisé par votre cluster Amazon DocumentDB. Il s’agit généralement du groupe de sécurité `default`. + Conservez tous les autres paramètres par défaut. + Choisissez **Créer un point de terminaison**. 1. Choisissez à nouveau **Créer un point de terminaison**. Créez un point de terminaison avec la configuration suivante : + Pour **Balise de nom**, saisissez `secretsmanager-default-vpc`. + Pour la **catégorie de service**, sélectionnez AWS services. + Pour **Services**, saisissez `secretsmanager` dans la zone de recherche. Choisissez le service au format `com.amazonaws..secretsmanager`. + Pour **VPC**, choisissez le VPC dans lequel se trouve votre cluster Amazon DocumentDB. Il s’agit généralement du [VPC par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + Pour **Sous-réseaux**, cochez les cases à côté de chaque zone de disponibilité. Choisissez l’ID de sous-réseau correct pour chaque zone de disponibilité. + Pour le **type d'adresse IP**, sélectionnez IPv4. + Pour **Groupes de sécurité**, choisissez le groupe de sécurité utilisé par votre cluster Amazon DocumentDB. Il s’agit généralement du groupe de sécurité `default`. + Conservez tous les autres paramètres par défaut. + Choisissez **Créer un point de terminaison**. Ceci termine la partie de ce tutoriel concernant la configuration du cluster. ## Créer le rôle d’exécution Dans les étapes suivantes, vous allez créer votre fonction Lambda. Tout d’abord, vous devez créer le rôle d’exécution qui donne à votre fonction l’autorisation d’accéder à votre cluster. Vous faites cela en créant d’abord une politique IAM, puis en associant cette politique à un rôle IAM. **Pour créer une politique IAM** 1. Ouvrez la [page Politiques](https://console.aws.amazon.com/iam/home#/policies) dans la console IAM et choisissez **Créer une politique**. 1. Choisissez l’onglet **JSON**. Dans la politique suivante, remplacez l'ARN de la ressource Secrets Manager dans la dernière ligne de l'instruction par votre ARN secret précédent et copiez la politique dans l'éditeur. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "LambdaESMNetworkingAccess", "Effect": "Allow", "Action": [ "ec2:CreateNetworkInterface", "ec2:DescribeNetworkInterfaces", "ec2:DescribeVpcs", "ec2:DeleteNetworkInterface", "ec2:DescribeSubnets", "ec2:DescribeSecurityGroups", "kms:Decrypt" ], "Resource": "*" }, { "Sid": "LambdaDocDBESMAccess", "Effect": "Allow", "Action": [ "rds:DescribeDBClusters", "rds:DescribeDBClusterParameters", "rds:DescribeDBSubnetGroups" ], "Resource": "*" }, { "Sid": "LambdaDocDBESMGetSecretValueAccess", "Effect": "Allow", "Action": [ "secretsmanager:GetSecretValue" ], "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:DocumentDBSecret" } ] } ``` ------ 1. Choisissez **Suivant : Balises**, puis **Suivant : Vérification**. 1. Pour **Nom**, saisissez `AWSDocumentDBLambdaPolicy`. 1. Sélectionnez **Create policy** (Créer une politique). **Pour créer le rôle IAM** 1. Ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home#/roles) dans la console IAM et choisissez **Créer un rôle**. 1. Pour **Sélectionner une entité de confiance**, choisissez les options suivantes : + **Type d'entité de confiance** : AWS service + **Service ou cas d’utilisation** : Lambda + Choisissez **Suivant**. 1. Pour **Ajouter des autorisations**, choisissez la `AWSDocumentDBLambdaPolicy` politique que vous venez de créer, ainsi que celle permettant `AWSLambdaBasicExecutionRole` à votre fonction d'écrire sur Amazon CloudWatch Logs. 1. Choisissez **Suivant**. 1. Pour le **Nom du rôle**, saisissez `AWSDocumentDBLambdaExecutionRole`. 1. Choisissez **Créer un rôle**. ## Créer la fonction Lambda Ce didacticiel utilise le moteur d'exécution Python 3.14, mais nous avons également fourni des exemples de fichiers de code pour d'autres environnements d'exécution. Vous pouvez sélectionner l’onglet dans la zone suivante pour voir le code d’exécution qui vous intéresse. Le code reçoit une entrée d’événement Amazon DocumentDB et traite le message qu’elle contient. **Pour créer la fonction Lambda** 1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda. 1. Choisissez **Créer une fonction**. 1. Choisissez **Créer à partir de zéro**. 1. Sous **Basic information** (Informations de base), procédez comme suit : 1. Sous **Nom de la fonction**, saisissez `ProcessDocumentDBRecords`. 1. Pour **Runtime**, choisissez **Python 3.14**. 1. Pour **Architecture**, choisissez **x86\$164**. 1. Dans l’onglet **Modifier le rôle d’exécution par défaut**, procédez comme suit : 1. Ouvrez l’onglet, puis choisissez **Utiliser un rôle existant**. 1. Sélectionnez le `AWSDocumentDBLambdaExecutionRole` que vous avez créé précédemment. 1. Choisissez **Créer une fonction**. **Pour déployer le code de la fonction** 1. Choisissez l’onglet **Python** dans la zone suivante et copiez le code. ------ #### [ .NET ] **SDK pour .NET** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant .NET. ``` using Amazon.Lambda.Core; using System.Text.Json; using System; using System.Collections.Generic; using System.Text.Json.Serialization; //Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class. [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] namespace LambdaDocDb; public class Function { /// /// Lambda function entry point to process Amazon DocumentDB events. /// /// The Amazon DocumentDB event. /// The Lambda context object. /// A string to indicate successful processing. public string FunctionHandler(Event evnt, ILambdaContext context) { foreach (var record in evnt.Events) { ProcessDocumentDBEvent(record, context); } return "OK"; } private void ProcessDocumentDBEvent(DocumentDBEventRecord record, ILambdaContext context) { var eventData = record.Event; var operationType = eventData.OperationType; var databaseName = eventData.Ns.Db; var collectionName = eventData.Ns.Coll; var fullDocument = JsonSerializer.Serialize(eventData.FullDocument, new JsonSerializerOptions { WriteIndented = true }); context.Logger.LogLine($"Operation type: {operationType}"); context.Logger.LogLine($"Database: {databaseName}"); context.Logger.LogLine($"Collection: {collectionName}"); context.Logger.LogLine($"Full document:\n{fullDocument}"); } public class Event { [JsonPropertyName("eventSourceArn")] public string EventSourceArn { get; set; } [JsonPropertyName("events")] public List Events { get; set; } [JsonPropertyName("eventSource")] public string EventSource { get; set; } } public class DocumentDBEventRecord { [JsonPropertyName("event")] public EventData Event { get; set; } } public class EventData { [JsonPropertyName("_id")] public IdData Id { get; set; } [JsonPropertyName("clusterTime")] public ClusterTime ClusterTime { get; set; } [JsonPropertyName("documentKey")] public DocumentKey DocumentKey { get; set; } [JsonPropertyName("fullDocument")] public Dictionary FullDocument { get; set; } [JsonPropertyName("ns")] public Namespace Ns { get; set; } [JsonPropertyName("operationType")] public string OperationType { get; set; } } public class IdData { [JsonPropertyName("_data")] public string Data { get; set; } } public class ClusterTime { [JsonPropertyName("$timestamp")] public Timestamp Timestamp { get; set; } } public class Timestamp { [JsonPropertyName("t")] public long T { get; set; } [JsonPropertyName("i")] public int I { get; set; } } public class DocumentKey { [JsonPropertyName("_id")] public Id Id { get; set; } } public class Id { [JsonPropertyName("$oid")] public string Oid { get; set; } } public class Namespace { [JsonPropertyName("db")] public string Db { get; set; } [JsonPropertyName("coll")] public string Coll { get; set; } } } ``` ------ #### [ Go ] **Kit SDK pour Go V2** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant Go. ``` package main import ( "context" "encoding/json" "fmt" "github.com/aws/aws-lambda-go/lambda" ) type Event struct { Events []Record `json:"events"` } type Record struct { Event struct { OperationType string `json:"operationType"` NS struct { DB string `json:"db"` Coll string `json:"coll"` } `json:"ns"` FullDocument interface{} `json:"fullDocument"` } `json:"event"` } func main() { lambda.Start(handler) } func handler(ctx context.Context, event Event) (string, error) { fmt.Println("Loading function") for _, record := range event.Events { logDocumentDBEvent(record) } return "OK", nil } func logDocumentDBEvent(record Record) { fmt.Printf("Operation type: %s\n", record.Event.OperationType) fmt.Printf("db: %s\n", record.Event.NS.DB) fmt.Printf("collection: %s\n", record.Event.NS.Coll) docBytes, _ := json.MarshalIndent(record.Event.FullDocument, "", " ") fmt.Printf("Full document: %s\n", string(docBytes)) } ``` ------ #### [ Java ] **SDK pour Java 2.x** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant Java. ``` import java.util.List; import java.util.Map; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; public class Example implements RequestHandler, String> { @SuppressWarnings("unchecked") @Override public String handleRequest(Map event, Context context) { List> events = (List>) event.get("events"); for (Map record : events) { Map eventData = (Map) record.get("event"); processEventData(eventData); } return "OK"; } @SuppressWarnings("unchecked") private void processEventData(Map eventData) { String operationType = (String) eventData.get("operationType"); System.out.println("operationType: %s".formatted(operationType)); Map ns = (Map) eventData.get("ns"); String db = (String) ns.get("db"); System.out.println("db: %s".formatted(db)); String coll = (String) ns.get("coll"); System.out.println("coll: %s".formatted(coll)); Map fullDocument = (Map) eventData.get("fullDocument"); System.out.println("fullDocument: %s".formatted(fullDocument)); } } ``` ------ #### [ JavaScript ] **SDK pour JavaScript (v3)** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d'un événement Amazon DocumentDB avec Lambda à l'aide de. JavaScript ``` console.log('Loading function'); exports.handler = async (event, context) => { event.events.forEach(record => { logDocumentDBEvent(record); }); return 'OK'; }; const logDocumentDBEvent = (record) => { console.log('Operation type: ' + record.event.operationType); console.log('db: ' + record.event.ns.db); console.log('collection: ' + record.event.ns.coll); console.log('Full document:', JSON.stringify(record.event.fullDocument, null, 2)); }; ``` Utilisation d'un événement Amazon DocumentDB avec Lambda à l'aide de TypeScript ``` import { DocumentDBEventRecord, DocumentDBEventSubscriptionContext } from 'aws-lambda'; console.log('Loading function'); export const handler = async ( event: DocumentDBEventSubscriptionContext, context: any ): Promise => { event.events.forEach((record: DocumentDBEventRecord) => { logDocumentDBEvent(record); }); return 'OK'; }; const logDocumentDBEvent = (record: DocumentDBEventRecord): void => { console.log('Operation type: ' + record.event.operationType); console.log('db: ' + record.event.ns.db); console.log('collection: ' + record.event.ns.coll); console.log('Full document:', JSON.stringify(record.event.fullDocument, null, 2)); }; ``` ------ #### [ PHP ] **Kit SDK pour PHP** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant PHP. ``` logDocumentDBEvent($record['event']); } return 'OK'; } private function logDocumentDBEvent($event): void { // Extract information from the event record $operationType = $event['operationType'] ?? 'Unknown'; $db = $event['ns']['db'] ?? 'Unknown'; $collection = $event['ns']['coll'] ?? 'Unknown'; $fullDocument = $event['fullDocument'] ?? []; // Log the event details echo "Operation type: $operationType\n"; echo "Database: $db\n"; echo "Collection: $collection\n"; echo "Full document: " . json_encode($fullDocument, JSON_PRETTY_PRINT) . "\n"; } } return new DocumentDBEventHandler(); ``` ------ #### [ Python ] **Kit SDK for Python (Boto3)** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant Python. ``` import json def lambda_handler(event, context): for record in event.get('events', []): log_document_db_event(record) return 'OK' def log_document_db_event(record): event_data = record.get('event', {}) operation_type = event_data.get('operationType', 'Unknown') db = event_data.get('ns', {}).get('db', 'Unknown') collection = event_data.get('ns', {}).get('coll', 'Unknown') full_document = event_data.get('fullDocument', {}) print(f"Operation type: {operation_type}") print(f"db: {db}") print(f"collection: {collection}") print("Full document:", json.dumps(full_document, indent=2)) ``` ------ #### [ Ruby ] **Kit SDK pour Ruby** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant Ruby. ``` require 'json' def lambda_handler(event:, context:) event['events'].each do |record| log_document_db_event(record) end 'OK' end def log_document_db_event(record) event_data = record['event'] || {} operation_type = event_data['operationType'] || 'Unknown' db = event_data.dig('ns', 'db') || 'Unknown' collection = event_data.dig('ns', 'coll') || 'Unknown' full_document = event_data['fullDocument'] || {} puts "Operation type: #{operation_type}" puts "db: #{db}" puts "collection: #{collection}" puts "Full document: #{JSON.pretty_generate(full_document)}" end ``` ------ #### [ Rust ] **SDK pour Rust** Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant Rust. ``` use lambda_runtime::{service_fn, tracing, Error, LambdaEvent}; use aws_lambda_events::{ event::documentdb::{DocumentDbEvent, DocumentDbInnerEvent}, }; // Built with the following dependencies: //lambda_runtime = "0.11.1" //serde_json = "1.0" //tokio = { version = "1", features = ["macros"] } //tracing = { version = "0.1", features = ["log"] } //tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] } //aws_lambda_events = "0.15.0" async fn function_handler(event: LambdaEvent) ->Result<(), Error> { tracing::info!("Event Source ARN: {:?}", event.payload.event_source_arn); tracing::info!("Event Source: {:?}", event.payload.event_source); let records = &event.payload.events; if records.is_empty() { tracing::info!("No records found. Exiting."); return Ok(()); } for record in records{ log_document_db_event(record); } tracing::info!("Document db records processed"); // Prepare the response Ok(()) } fn log_document_db_event(record: &DocumentDbInnerEvent)-> Result<(), Error>{ tracing::info!("Change Event: {:?}", record.event); Ok(()) } #[tokio::main] async fn main() -> Result<(), Error> { tracing_subscriber::fmt() .with_max_level(tracing::Level::INFO) .with_target(false) .without_time() .init(); let func = service_fn(function_handler); lambda_runtime::run(func).await?; Ok(()) } ``` ------ 1. Dans le volet **Code source** de la console Lambda, collez le code dans l’éditeur de code, en remplaçant le code créé par Lambda. 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) ## Création du mappage des sources d’événements Lambda Créez le mappage des sources d’événements qui associe votre flux de modifications Amazon DocumentDB à votre fonction Lambda. Après avoir créé ce mappage des sources d'événements, commence AWS Lambda immédiatement à interroger le flux. **Pour créer le mappage des sources d’événements** 1. Ouvrez la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda. 1. Choisissez la fonction `ProcessDocumentDBRecords` que vous avez créée précédemment. 1. Choisissez l’onglet **Configuration**, puis **Déclencheurs** dans le menu de gauche. 1. Choisissez **Add trigger (Ajouter déclencheur)**. 1. Sous **Configuration du déclencheur**, pour la source, sélectionnez **Amazon DocumentDB**. 1. Créez le mappage des sources d’événements avec la configuration suivante : + **Cluster Amazon DocumentDB** : choisissez le cluster que vous avez créé précédemment. + **Nom de la base de données** : docdbdemo + **Nom de la collection** : products + **Taille du lot** : 1 + **Position de départ** : dernière + **Authentification** : BASIC\$1AUTH + **Clé Secrets Manager** : choisissez le secret de votre cluster Amazon DocumentDB. Son nom ressemblera à `rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f`. + **Fenêtre de traitement par lots** : 1 + **Configuration complète du document** : UpdateLookup 1. Choisissez **Ajouter**. La création de votre mappage des sources d’événements peut prendre quelques minutes. ## Test de votre fonction Attendez que le mappage des sources d’événements atteigne l’état **Activé**. Cela peut prendre plusieurs minutes. Testez ensuite la end-to-end configuration en insérant, en mettant à jour et en supprimant des enregistrements de base de données. Avant de commencer : 1. [Reconnectez-vous à votre cluster Amazon DocumentDB](#docdb-connect-to-cluster) dans CloudShell votre environnement. 1. Exécutez la commande suivante pour vous assurer que vous utilisez la base de données `docdbdemo` : ``` use docdbdemo ``` ### Insérer un enregistrement Insérez un enregistrement dans la collection `products` de la base de donnée `docdbdemo` : ``` db.products.insertOne({"name":"Pencil", "price": 1.00}) ``` Vérifiez que votre fonction a correctement traité cet événement en [vérifiant CloudWatch les journaux](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Vous devriez voir une entrée de journal comme celle-ci : ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/documentdb-insert-log.png) ### Mettre à jour un enregistrement Mettez à jour l’enregistrement que vous venez d’insérer à l’aide de la commande suivante : ``` db.products.updateOne( { "name": "Pencil" }, { $set: { "price": 0.50 }} ) ``` Vérifiez que votre fonction a correctement traité cet événement en [vérifiant CloudWatch les journaux](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Vous devriez voir une entrée de journal comme celle-ci : ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/documentdb-update-log.png) ### Supprimer un enregistrement Supprimez l’enregistrement que vous venez de mettre à jour à l’aide de la commande suivante : ``` db.products.deleteOne( { "name": "Pencil" } ) ``` Vérifiez que votre fonction a correctement traité cet événement en [vérifiant CloudWatch les journaux](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Vous devriez voir une entrée de journal comme celle-ci : ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/documentdb-delete-log.png) ## Résolution des problèmes Si aucun événement de base de données n'apparaît dans les CloudWatch journaux de votre fonction, vérifiez les points suivants : + Assurez-vous que le mappage des sources d’événements Lambda (également appelé déclencheur) est à l’état **Activé**. La création de mappages des sources d’événements peut prendre plusieurs minutes. + Si le mappage des sources d'événements est **activé** mais que les événements de base de données ne s'affichent toujours pas dans CloudWatch : + Assurez-vous que le **Nom de la base de données** dans le mappage des sources d’événements est défini sur `docdbdemo`. ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/documentdb-trigger.png) + Vérifiez si le champ **Résultat du dernier traitement** du mappage des sources d'événements contient le message « PROBLEM: Connection error. Your VPC must be able to connect to Lambda and STS, as well as Secrets Manager if authentication is required. » Si cette erreur s’affiche, assurez-vous que vous avez [créé les points de terminaison de l’interface VPC de Lambda et Secrets Manager](#docdb-create-interface-vpc-endpoints), et que les points de terminaison utilisent le même VPC et les mêmes sous-réseaux que ceux utilisés par votre cluster Amazon DocumentDB. ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/documentdb-lastprocessingresult.png) ## Nettoyage de vos ressources Vous pouvez maintenant supprimer les ressources que vous avez créées pour ce didacticiel, sauf si vous souhaitez les conserver. En supprimant des ressources AWS que vous n’utilisez plus, vous évitez les frais superflus 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 les points de terminaison d’un VPC** 1. Ouvrez la [console VPC](https://console.aws.amazon.com/vpc/home#). Dans le menu de gauche, sous **Cloud privé virtuel**, choisissez **Points de terminaison**. 1. Sélectionnez les points de terminaison que vous avez créés. 1. Choisissez **Actions**, **Delete VPC endpoints** (Supprimer le point de terminaison d’un VPC). 1. Saisissez **delete** dans le champ de saisie de texte. 1. Sélectionnez **Delete (Supprimer)**. **Pour supprimer le cluster Amazon DocumentDB** 1. Ouvrez la [console Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). 1. Sélectionnez le cluster Amazon DocumentDB que vous avez créé pour ce tutoriel et désactivez la protection contre la suppression. 1. Dans la page principale **Clusters**, choisissez à nouveau votre cluster Amazon DocumentDB. 1. Sélectionnez **Actions**, **Supprimer**. 1. Pour **Créer un instantané final du cluster**, sélectionnez **Non**. 1. Saisissez **delete** dans le champ de saisie de texte. 1. Sélectionnez **Delete (Supprimer)**. **Pour supprimer le secret dans Secrets Manager** 1. Ouvrez la [console Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#). 1. Sélectionnez le secret que vous avez créé pour ce tutoriel. 1. Choisissez **Actions**, **Supprimer le secret**. 1. Choisissez **Schedule deletion (Planifier la suppression)**.