# Procese eventos de Amazon DocumentDB con Lambda Puede utilizar una función de Lambda para procesar eventos en un [flujo de cambios de Amazon DocumentDB (con compatibilidad con MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) si configura un clúster de Amazon DocumentDB como origen de eventos. A continuación, puede automatizar las cargas de trabajo basadas en eventos al invocar la función de Lambda cada vez que los datos cambien en su clúster de Amazon DocumentDB. **nota** Lambda solo es compatible con la versión 4.0 y 5.0 de Amazon DocumentDB. Lambda no es compatible con la versión 3.6. Asimismo, en el caso de las asignaciones de orígenes de eventos, Lambda solo es compatible con clústeres basados en instancias y clústeres regionales. Lambda no admite [clústeres elásticos](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html) ni [clústeres globales](https://docs.aws.amazon.com/documentdb/latest/developerguide/global-clusters.html). Esta limitación no se aplica cuando se utiliza Lambda como cliente para conectarse a Amazon DocumentDB. Lambda puede conectarse a todos los tipos de clústeres para realizar operaciones CRUD. Lambda procesa los eventos de los flujos de cambios de Amazon DocumentDB de forma secuencial en el orden en que llegan. Por este motivo, la función solo puede gestionar una invocación simultánea desde Amazon DocumentDB a la vez. Para monitorear su función, puede realizar un seguimiento de sus [métricas de simultaneidad](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-concurrency.html). **aviso** Las asignaciones de orígenes de eventos de Lambda procesan cada evento al menos una vez, y puede producirse un procesamiento duplicado de registros. Para evitar posibles problemas relacionados con la duplicación de eventos, le recomendamos encarecidamente que haga que el código de la función sea idempotente. Para obtener más información, consulte [¿Cómo puedo hacer que mi función de Lambda sea idempotente?](https://repost.aws/knowledge-center/lambda-function-idempotent) en el Centro de conocimientos de AWS. **Topics** + [Ejemplo de evento de Amazon DocumentDB](#docdb-sample-event) + [Requisitos previos y permisos](#docdb-prereqs) + [Configuración de la seguridad de la red](#docdb-network) + [Creación de una asignación de orígenes de eventos de Amazon DocumentDB (consola)](#docdb-configuration) + [Creación de una asignación de orígenes de eventos de Amazon DocumentDB (SDK o CLI)](#docdb-api) + [Posiciones iniciales de flujos y sondeo](#docdb-stream-polling) + [Monitoreo del origen de eventos de Amazon DocumentDB](#docdb-monitoring) + [Tutorial: Uso de AWS Lambda con Amazon DocumentDB Streams](with-documentdb-tutorial.md) ## Ejemplo de evento de 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" } ``` Para obtener más información sobre los eventos de este ejemplo y sus formas, consulte [Eventos de cambio](https://www.mongodb.com/docs/manual/reference/change-events/) en el sitio web de la documentación de MongoDB. ## Requisitos previos y permisos Antes de utilizar Amazon DocumentDB como un origen de eventos para su función de Lambda, tenga en cuenta los siguientes requisitos previos. Debe hacer lo siguiente: + **Tener un clúster de Amazon DocumentDB existente en la misma Cuenta de AWS y Región de AWS que su función.** Si no dispone de un clúster existente, puede crearlo mediante los pasos de [Introducción a Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) en la *Guía para desarrolladores de Amazon DocumentDB*. Como alternativa, el primer conjunto de pasos de [Tutorial: Uso de AWS Lambda con Amazon DocumentDB Streams](with-documentdb-tutorial.md) lo guiará para crear un clúster de Amazon DocumentDB con todos los requisitos previos necesarios. + **Permitir que Lambda tenga acceso a los recursos de Amazon Virtual Private Cloud (Amazon VPC) asociados a su clúster de Amazon DocumentDB.** Para obtener más información, consulte [Configuración de la seguridad de la red](#docdb-network). + **Habilitar TLS en su clúster de Amazon DocumentDB.** Este es el valor predeterminado. Si deshabilita TLS, Lambda no podrá comunicarse con el clúster. + **Activar los flujos de cambios en su clúster de Amazon DocumentDB.** Para obtener más información, consulte [Uso de flujos de cambios de Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) en la *Guía para desarrolladores de Amazon DocumentDB*. + **Proporcionar a Lambda las credenciales para acceder a su clúster de Amazon DocumentDB.** Al configurar el origen de eventos, proporcione la clave de [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) que contiene los detalles de autenticación (nombre de usuario y contraseña) necesarios para acceder al clúster. Para proporcionar esta clave durante la configuración, puede realizar uno de los siguientes procedimientos: + Si está utilizando la consola de Lambda para la configuración, proporcione la clave en el campo **Clave del administrador de secretos**. + Si está utilizando la AWS Command Line Interface (AWS CLI), introduzca esta clave en la opción `source-access-configurations`. Puede incluir esta opción con los comandos [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) o [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). Por ejemplo: ``` aws lambda create-event-source-mapping \ ... --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-west-2:123456789012:secret:DocDBSecret-AbC4E6"}]' \ ... ``` + **Conceder permisos a Lambda para administrar los recursos relacionados con el flujo de Amazon DocumentDB.** Agregue los siguientes permisos de forma manual al [rol de ejecución](lambda-intro-execution-role.md) de su función: + [rds:DescribeDBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) + [rds:DescribeDBClusterParameters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusterParameters.html) + [rds:DescribeDBSubnetGroups](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) + [secretsmanager:GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) + **Mantener el tamaño de los eventos del flujo de cambios de Amazon DocumentDB que envíe a Lambda por debajo de 6 MB.** Lambda admite tamaños de carga de hasta 6 MB. Si el flujo de cambios intenta enviar a Lambda un evento de más de 6 MB, Lambda elimina el mensaje y emite la métrica `OversizedRecordCount`. Lambda emite todas las métricas dentro de lo posible. **nota** Si bien las funciones de Lambda suelen tener un límite de tiempo de espera máximo de 15 minutos, las asignaciones de orígenes de eventos para Amazon MSK, Apache Kafka autoadministrado, Amazon DocumentDB y Amazon MQ para ActiveMQ y RabbitMQ solo admiten funciones con límites de tiempo de espera máximos de 14 minutos. Esta restricción garantiza que la asignación de orígenes de eventos pueda gestionar correctamente los errores y reintentos de las funciones. ## Configuración de la seguridad de la red Para que Lambda tenga acceso completo a Amazon DocumentDB a través de su asignación de orígenes de eventos, debe proporcionar acceso a la instancia de Amazon VPC en la que creó el clúster o este debe utilizar un punto de conexión público (dirección IP pública). Cuando utilice Amazon DocumentDB con Lambda, cree [puntos de conexión de VPC de AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) que brinden a su función acceso a los recursos de su Amazon VPC. **nota** Los puntos de conexión de VPC de AWS PrivateLink son necesarios para las funciones con asignaciones de orígenes de eventos que utilizan el modo predeterminado (bajo demanda) para los sondeos de eventos. Si la asignación de orígenes de eventos utiliza el [modo aprovisionado](invocation-eventsourcemapping.md#invocation-eventsourcemapping-provisioned-mode), no es necesario configurar los puntos de conexión de VPC de AWS PrivateLink. Cree un punto de conexión para proporcionar acceso a los siguientes recursos: + Lambda: cree un punto de conexión para la entidad principal del servicio de Lambda. + AWS STS: cree un punto de conexión para AWS STS con el objetivo de que la entidad principal del servicio asuma un rol en su nombre. + Secrets Manager: si el clúster usa Secrets Manager para almacenar las credenciales, cree un punto de conexión para Secrets Manager. Como alternativa, configure una puerta de enlace de NAT en cada subred pública de la Amazon VPC. Para obtener más información, consulte [Habilitación del acceso a Internet para funciones de Lambda conectadas a VPC](configuration-vpc-internet.md). Al crear una asignación de orígenes de eventos para Amazon DocumentDB, Lambda comprueba si las interfaces de red elásticas (ENI) ya están presentes en las subredes y los grupos de seguridad configurados para la Amazon VPC. Si Lambda encuentra ENI existentes, intenta reutilizarlos. De lo contrario, Lambda crea nuevos ENI para conectarse al origen de eventos e invocar la función. **nota** Las funciones de Lambda siempre se ejecutan dentro de VPC propiedad del servicio de Lambda. La configuración de VPC de la función no afecta la asignación de orígenes de eventos. Solo la configuración de red del origen de eventos determina cómo se conecta Lambda al origen de eventos. Configure los grupos de seguridad para la Amazon VPC que contiene el clúster. De forma predeterminada, Amazon DocumentDB utiliza los siguientes puertos: `27017`. + Reglas de entrada: permiten todo el tráfico en el puerto del agente predeterminado para el grupo de seguridad asociado al origen de eventos. Como alternativa, puede usar una regla de grupo de seguridad con autorreferencia para permitir el acceso desde instancias que pertenecen al mismo grupo de seguridad. + Reglas de salida: permiten que todo el tráfico en el puerto `443` vaya a destinos externos en caso de que su función necesite comunicarse con servicios de AWS. Como alternativa, también puede usar una regla de grupo de seguridad con autorreferencia para limitar el acceso al agente en caso de que no necesite comunicarse con otros servicios de AWS. + Reglas de entrada del punto de conexión de Amazon VPC: si usa un punto de conexión de Amazon VPC, el grupo de seguridad asociado al punto de conexión de Amazon VPC debe permitir el tráfico entrante en el puerto `443` desde el grupo de seguridad del clúster. Si el clúster utiliza la autenticación, también puede restringir la política del punto de conexión para el punto de conexión de Secrets Manager. Para llamar a la API de Secrets Manager, Lambda usa su rol de función, no la entidad principal de servicio de Lambda. **Example Política de punto de conexión de VPC: punto de conexión de 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" } ] } ``` Cuando utiliza los puntos de conexión de VPC de Amazon, AWS enruta las llamadas a la API para invocar una función mediante la interfaz de red elástica (ENI) del punto de conexión. La entidad principal del servicio de Lambda debe llamar a `lambda:InvokeFunction` en cualquier rol y función que utilicen esas ENI. De forma predeterminada, los puntos de conexión de VPC de Amazon tienen políticas de IAM abiertas que permiten un amplio acceso a los recursos. La práctica recomendada es restringir estas políticas para realizar las acciones necesarias mediante ese punto de conexión. Para garantizar que la asignación de orígenes de eventos pueda invocar la función de Lambda, la política de punto de conexión de VPC debe permitir que la entidad principal del servicio de Lambda llame a `sts:AssumeRole` y `lambda:InvokeFunction`. Restringir las políticas de punto de conexión de VPC para permitir únicamente las llamadas a la API que se originen en su organización impide que la asignación de orígenes de eventos funcione correctamente, por lo que en estas políticas es necesario `"Resource": "*"`. En el siguiente ejemplo de políticas de puntos de conexión de VPC, se muestra cómo conceder el acceso necesario a las entidades principales del servicio de Lambda para AWS STS y los puntos de conexión de Lambda. **Example Política de punto de conexión de VPC: punto de conexión de AWS STS** ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` **Example Política de punto de conexión de VPC: punto de conexión de Lambda** ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` ## Creación de una asignación de orígenes de eventos de Amazon DocumentDB (consola) Para configurar una función de Lambda que lea desde un flujo de cambios de un clúster de Amazon DocumentDB, cree una [asignación de orígenes de eventos](invocation-eventsourcemapping.md). En esta sección, se describe cómo hacer esto desde la consola. Para obtener las instrucciones de AWS SDK y la AWS CLI, consulte [Creación de una asignación de orígenes de eventos de Amazon DocumentDB (SDK o CLI)](#docdb-api). **Para crear una asignación de orígenes de eventos de Amazon DocumentDB (consola)** 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de una función. 1. En **Descripción general de la función**, elija **Agregar desencadenador**. 1. En **Configuración del desencadenador**, seleccione **DocumentDB** de la lista desplegable. 1. Configure las opciones requeridas y luego elija **Agregar**. Lambda admite las siguientes opciones para los orígenes de eventos de Amazon DocumentDB: + **Clúster de DocumentDB**: seleccione un clúster de Amazon DocumentDB. + **Activar el desencadenador**: elija si desea activar el desencadenador de forma inmediata. Si marca esta casilla, la función comenzará a recibir tráfico de forma inmediata del flujo de cambios de Amazon DocumentDB que se especificó al crear la asignación de orígenes de eventos. Recomendamos desmarcar la casilla para crear la asignación de orígenes de eventos en un estado desactivado para realizar pruebas. Tras la creación, puede activar la asignación de orígenes de eventos en cualquier momento. + **Nombre de base de datos:** introduzca el nombre de una base de datos dentro del clúster a consumir. + (Opcional) **Nombre de la colección**: ingrese el nombre de la colección dentro de la base de datos que se va a consumir. Si no especifica una colección, Lambda escucha todos los eventos de cada colección en la base de datos. + **Tamaño del lote:** establezca el número máximo de mensajes que se recuperarán en un solo lote, con un máximo de 10 000. El tamaño predeterminado del lote es de 100. + **Posición inicial:** elija la posición en el flujo desde la que desea comenzar a leer los registros. + **Más recientes:** procesa solo los registros nuevos que se agreguen al flujo principal. La función comienza a procesar registros solo después de que Lambda termina de crear el origen de eventos. Esto significa que es posible que se eliminen algunos registros hasta que el origen de eventos se haya creado correctamente. + **Horizonte de supresión**: procesar todos los registros del flujo. Lambda utiliza la duración de retención de registros de su clúster para determinar desde dónde comenzar a leer los eventos. En concreto, Lambda comienza a leer desde `current_time - log_retention_duration`. Su flujo de cambios ya debe estar activo antes de esta marca de tiempo para que Lambda lea de forma correcta todos los eventos. + **En marca temporal**: procesar los registros comenzando a partir de un momento determinado. Su flujo de cambios ya debe estar activo antes de la marca de tiempo especificada para que Lambda lea de forma correcta todos los eventos. + **Autenticación:** elija el método de autenticación para acceder a los agentes en su clúster. + **BASIC\$1AUTH:** con la autenticación básica, debe proporcionar la clave de Secrets Manager que contiene las credenciales para acceder al clúster. + **Clave de Secrets Manager**: elija la clave de Secrets Manager que contiene los detalles de autenticación (nombre de usuario y contraseña) necesarios para acceder al clúster de Amazon DocumentDB. + (Opcional) **Intervalo de lote**: la cantidad de tiempo máxima para recopilar registros antes de invocar la función, arriba de 300. + (Opcional) **Configuración completa del documento**: para las operaciones de actualización de los documentos, elija lo que desea enviar al flujo. El valor predeterminado es `Default`, lo que significa que, para cada evento de flujo de cambios, Amazon DocumentDB envía solo un delta que describe los cambios realizados. Para obtener más información sobre este campo, consulte [FullDocument](https://mongodb.github.io/mongo-java-driver/3.9/javadoc/com/mongodb/client/model/changestream/FullDocument.html#DEFAULT) en la documentación de la API de Javadocs para MongoDB. + **Predeterminado:** Lambda envía solo un documento parcial que describe los cambios realizados. + **UpdateLookup:** Lambda envía un delta que describe los cambios, junto con una copia del documento completo. ## Creación de una asignación de orígenes de eventos de Amazon DocumentDB (SDK o CLI) Para crear o administrar una asignación de orígenes de eventos de Amazon DocumentDB con [AWS SDK](https://aws.amazon.com/developer/tools/), puede utilizar las siguientes operaciones de la API: + [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) Para crear la asignación de orígenes de eventos con la AWS CLI, use el comando [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). En el siguiente ejemplo, se utiliza este comando para asignar una función denominada `my-function` a un flujo de cambios de Amazon DocumentDB. El origen del evento se especifica mediante un nombre de recurso de Amazon (ARN) con un tamaño de lote de 500, que comienza desde una marca temporal en tiempo Unix. El comando también especifica la clave de Secrets Manager que Lambda utiliza para conectarse a Amazon DocumentDB. Además, incluye parámetros `document-db-event-source-config` que especifican la base de datos y la colección desde la que se va a leer. ``` 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"}' \ ``` Debería ver un resultado con un aspecto similar al siguiente: ``` { "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" } ``` Tras la creación, puede utilizar el comando [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) para actualizar la configuración relacionada con el origen de eventos de Amazon DocumentDB. El siguiente comando actualiza el tamaño del lote a 1000 y el intervalo del lote a 10 segundos. Para este comando, necesita el UUID de la asignación de orígenes de eventos, que puede recuperar mediante el comando `list-event-source-mapping` o desde la consola de Lambda. ``` aws lambda update-event-source-mapping --function-name my-function \ --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \ --batch-size 1000 \ --batch-window 10 ``` Debería ver esta salida con un aspecto similar al siguiente: ``` { "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 actualiza la configuración de forma asíncrona, por lo que es posible que no vea estos cambios en la salida hasta que se complete el proceso. Para ver la configuración actual de la asignación de orígenes de eventos, utilice el comando [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 ``` Debería ver esta salida con un aspecto similar al siguiente: ``` { "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" } ``` Para eliminar la asignación de orígenes de eventos de Amazon DocumentDB, utilice el comando [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 ``` ## Posiciones iniciales de flujos y sondeo Tenga en cuenta que el sondeo de flujos durante la creación y las actualizaciones de la asignación de orígenes de eventos es, en última instancia, coherente. + Durante la creación de la asignación de orígenes de eventos, es posible que se demore varios minutos en iniciar el sondeo de los eventos del flujo. + Durante las actualizaciones de la asignación de orígenes de eventos, es posible que se demore varios minutos en detener y reiniciar el sondeo de los eventos del flujo. Este comportamiento significa que, si especifica `LATEST` como posición inicial del flujo, la asignación de orígenes de eventos podría omitir eventos durante la creación o las actualizaciones. Para garantizar que no se pierda ningún evento, especifique la posición inicial del flujo como `TRIM_HORIZON` o `AT_TIMESTAMP`. ## Monitoreo del origen de eventos de Amazon DocumentDB Para ayudarlo a monitorear el origen de eventos de Amazon DocumentDB, Lambda emite la métrica `IteratorAge` cuando su función termina de procesar un lote de registros. La *antigüedad del iterador* es la diferencia entre la marca de tiempo del evento más reciente y la marca de tiempo actual. En esencia, la métrica `IteratorAge` indica la antigüedad del último registro procesado del lote. Si la función está procesando nuevos eventos en este momento, puede utilizar la antigüedad del iterador para estimar la latencia entre cuando un registro se agrega y cuando la función lo procesa. Una tendencia ascendente en `IteratorAge` puede indicar problemas con la función. Para obtener más información, consulte [Uso de métricas de CloudWatch con Lambda](monitoring-metrics.md). Los flujos de cambios de Amazon DocumentDB no están optimizados para gestionar grandes intervalos de tiempo entre eventos. Si su origen de eventos de Amazon DocumentDB no recibe ningún evento durante un periodo prolongado, Lambda puede deshabilitar la asignación de orígenes de eventos. La duración de este periodo puede variar de unas semanas a unos meses, según el tamaño del clúster y otras cargas de trabajo. Lambda admite cargas de hasta 6 MB. Sin embargo, los eventos del flujo de cambios de Amazon DocumentDB pueden tener un tamaño de hasta 16 MB. Si el flujo de cambios intenta enviar a Lambda un evento de flujo de cambios de más de 6 MB, Lambda elimina el mensaje y emite la métrica `OversizedRecordCount`. Lambda emite todas las métricas dentro de lo posible. # Tutorial: Uso de AWS Lambda con Amazon DocumentDB Streams En este tutorial, creará una función de Lambda básica que consuma eventos de un flujo de cambios de Amazon DocumentDB (con compatibilidad con MongoDB). Para completar este tutorial, pasará por las siguientes etapas: + Configure su clúster de Amazon DocumentDB, conéctese a él y active los flujos de cambios en él. + Cree la función de Lambda y configure el clúster de Amazon DocumentDB como origen de eventos para su función. + Para probar la configuración, inserte elementos en la base de datos de Amazon DocumentDB. ## Creación de un clúster de Amazon DocumentDB 1. Abra la [consola de Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). En **Clústeres**, elija **Crear**. 1. Cree un clúster con la siguiente configuración: + En **Tipo de clúster**, elija **Clúster basado en instancias**. Esta es la opción predeterminada. + En **Configuración del clúster**, asegúrese de haber seleccionado la **Versión del motor** 5.0.0. Esta es la opción predeterminada. + En **Configuración de la instancia**: + En **Clase de la instancia de base de datos**, seleccione **Clases optimizadas para memoria**. Esta es la opción predeterminada. + En **Número de instancias de réplicas regulares**, elija 1. + En **Clase de instancia**, use la selección predeterminada. + En **Autenticación**, ingrese un nombre de usuario para el usuario principal y, a continuación, elija **Autoadministrado**. Ingrese una contraseña y, a continuación, confírmela. + Conserve todas las otras opciones de configuración predeterminadas. 1. Elija **Create cluster**. ## Crear un secreto en Secrets Manager Mientras Amazon DocumentDB crea el clúster, cree un secreto de AWS Secrets Manager para almacenar las credenciales de la base de datos. Proporcionará este secreto cuando cree la asignación de orígenes de eventos de Lambda en un paso posterior. **Para crear un secreto en Secrets Manager** 1. Abra la consola de [Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#) y elija **Almacenar un nuevo secreto**. 1. En **Elegir tipo de secreto**, elija las siguientes opciones: + En **Detalles básicos**: + **Tipo de secreto**: credenciales para la base de datos de Amazon DocumentDB + En **Credenciales**, ingrese el mismo nombre de usuario y la contraseña que usó para crear el clúster de Amazon DocumentDB. + **Base de datos**: elija su clúster de Amazon DocumentDB. + Elija **Siguiente**. 1. En **Configurar secreto**, elija las siguientes opciones: + **Nombre del secreto**: `DocumentDBSecret` + Elija **Siguiente**. 1. Elija **Siguiente**. 1. Elija **Almacenar**. 1. Actualice la consola para comprobar que ha guardado correctamente el secreto `DocumentDBSecret`. Anote el **ARN del secreto**. Lo necesitará en un paso posterior. ## Conexión al clúster **Conexión al clúster de Amazon DocumentDB con AWS CloudShell** 1. En la consola de administración de Amazon DocumentDB, en **Clústeres**, localice el clúster que ha creado. Para elegir el clúster, haga clic en la casilla de verificación situada junto a él. 1. Elija **Conectarse al clúster**. Aparece la pantalla **Ejecutar comando** de CloudShell. 1. En el campo **Nombre del nuevo entorno**, ingrese un nombre único, como “prueba” y elija **Crear y ejecutar**. 1. Escriba la contraseña cuando se le solicite. Cuando la petición se convierte en `rs0 [direct: primary] >`, significa que se ha conectado correctamente al clúster de Amazon DocumentDB. ## Activar flujos de cambios En este tutorial, hará un seguimiento de los cambios en la colección `products` de la base de datos `docdbdemo` en el clúster de Amazon DocumentDB. Para ello, active los [flujos de cambios](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html). **Para crear una nueva base de datos dentro del clúster** 1. Ejecute el siguiente comando para crear una nueva base de datos denominada `docdbdemo`: ``` use docdbdemo ``` 1. En la ventana del terminal, use el siguiente comando para insertar un registro en `docdbdemo`: ``` db.products.insertOne({"hello":"world"}) ``` Debería ver una salida similar a esta: ``` { acknowledged: true, insertedId: ObjectId('67f85066ca526410fd531d59') } ``` 1. A continuación, active los flujos de cambios en la colección `products` de la base de datos `docdbdemo` con el siguiente comando: ``` db.adminCommand({modifyChangeStreams: 1, database: "docdbdemo", collection: "products", enable: true}); ``` Debería ver un resultado con un aspecto similar al siguiente: ``` { "ok" : 1, "operationTime" : Timestamp(1680126165, 1) } ``` ## Creación de puntos de conexión de VPC de interfaz A continuación, cree [puntos de conexión de VPC de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) para garantizar que Lambda y Secrets Manager (que se utilizarán más adelante para almacenar nuestras credenciales de acceso al clúster) puedan conectarse a su VPC predeterminada. **Cómo crear puntos de conexión de VPC de interfaz** 1. Abra la [consola de VPC](https://console.aws.amazon.com/vpc/home#). En el menú de la izquierda, en **Nube privada virtual**, seleccione **Puntos de conexión**. 1. Seleccione **Crear punto de conexión**. Cree un punto de conexión con la siguiente configuración: + En **Etiqueta de nombre**, ingrese `lambda-default-vpc`. + En **Categoría de servicios**, elija Servicios de AWS. + En **Servicios**, ingrese `lambda` en el cuadro de búsqueda. Elija el servicio con formato `com.amazonaws..lambda`. + En **VPC**, elija la VPC en la que se encuentra su clúster de Amazon DocumentDB. Suele ser la [VPC predeterminada](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + En **Subredes**, marque las casillas situadas junto a cada zona de disponibilidad. Elija el ID de subred correcto para cada zona de disponibilidad. + En **Tipo de dirección IP**, seleccione IPv4. + En **Grupos de seguridad**, elija el grupo de seguridad que utiliza su clúster de Amazon DocumentDB. Suele ser el grupo de seguridad `default`. + Conserve todas las otras opciones de configuración predeterminadas. + Seleccione **Crear punto de conexión**. 1. Elija nuevamente **Crear punto de conexión**. Cree un punto de conexión con la siguiente configuración: + En **Etiqueta de nombre**, ingrese `secretsmanager-default-vpc`. + En **Categoría de servicios**, elija Servicios de AWS. + En **Servicios**, ingrese `secretsmanager` en el cuadro de búsqueda. Elija el servicio con formato `com.amazonaws..secretsmanager`. + En **VPC**, elija la VPC en la que se encuentra su clúster de Amazon DocumentDB. Suele ser la [VPC predeterminada](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + En **Subredes**, marque las casillas situadas junto a cada zona de disponibilidad. Elija el ID de subred correcto para cada zona de disponibilidad. + En **Tipo de dirección IP**, seleccione IPv4. + En **Grupos de seguridad**, elija el grupo de seguridad que utiliza su clúster de Amazon DocumentDB. Suele ser el grupo de seguridad `default`. + Conserve todas las otras opciones de configuración predeterminadas. + Seleccione **Crear punto de conexión**. Esto completa la parte de configuración del clúster de este tutorial. ## Creación del rol de ejecución En la siguiente serie de pasos, creará la función de Lambda. Primero, debe crear el rol de ejecución que concederá a su función permiso para acceder al clúster. Para ello, primero creará una política de IAM y luego asociará esta política a un rol de IAM. **Para crear una política de IAM** 1. En la consola de IAM, abra la [página Políticas](https://console.aws.amazon.com/iam/home#/policies), y, a continuación, elija **Crear política**. 1. Seleccione la pestaña **JSON**. En la siguiente política, sustituya el ARN del recurso de Secrets Manager en la última línea de la instrucción por el ARN secreto anterior y copie la política en el editor. ------ #### [ 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. Elija **Siguiente: Etiquetas** y, a continuación, seleccione **Siguiente: Revisar**. 1. En **Name** (Nombre), ingrese `AWSDocumentDBLambdaPolicy`. 1. Elija **Crear política**. **Creación del rol de IAM** 1. Abra la [página Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM y elija **Crear rol**. 1. En **Seleccionar entidad de confianza**, elija las siguientes opciones: + **Tipo de entidad de confianza**: servicio de AWS + **Servicio o caso de uso**: Lambda + Elija **Siguiente**. 1. En **Agregar permisos**, elija la política `AWSDocumentDBLambdaPolicy` que acaba de crear y también `AWSLambdaBasicExecutionRole` para conceder a su función permisos para escribir en los Registros de Amazon CloudWatch. 1. Elija **Siguiente**. 1. En **Role name (Nombre del rol)**, introduzca `AWSDocumentDBLambdaExecutionRole`. 1. Elija **Create role** (Crear rol). ## Crear la función de Lambda En este tutorial, se utiliza el tiempo de ejecución de Python 3.14, pero también proporcionamos archivos de código de ejemplo para otros tiempos de ejecución. Puede seleccionar la pestaña del siguiente cuadro para ver el código del tiempo de ejecución que le interesa. El código recibe un evento de Amazon DocumentDB como entrada y procesa el mensaje que contiene. **Para crear la función de Lambda** 1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda. 1. Seleccione **Creación de función**. 1. Elija **Crear desde cero**. 1. Bajo **Información básica**, haga lo siguiente: 1. En **Nombre de la función**, ingrese `ProcessDocumentDBRecords`. 1. En **Tiempo de ejecución**, seleccione **Python 3.14**. 1. En **Arquitectura**, elija **x86\$164**. 1. En la pestaña **Cambiar rol de ejecución predeterminado**, haga lo siguiente: 1. Amplíe la pestaña y, a continuación, elija **Utilizar un rol existente**. 1. Seleccione el `AWSDocumentDBLambdaExecutionRole` que creó anteriormente. 1. Seleccione **Creación de función**. **Para implementar el código de la función** 1. Seleccione la pestaña **Python** en el siguiente cuadro y copie el código. ------ #### [ .NET ] **SDK para .NET** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante .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 ] **SDK para Go V2** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumir un evento de Amazon DocumentDB con Lambda utilizando 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 para Java 2.x** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Cómo consumir un evento de Amazon DocumentDB con Lambda mediante 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 para JavaScript (v3)** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante 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)); }; ``` Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 ] **SDK para PHP** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 ] **SDK para Python (Boto3)** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 ] **SDK para Ruby** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 para Rust** Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumo de un evento de Amazon DocumentDB con Lambda mediante 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. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el editor de código y sustituya el código creado por Lambda. 1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Crear la asignación de orígenes de eventos de Lambda Cree la asignación de orígenes de eventos que asocie su flujo de cambios de Amazon DocumentDB a la función de Lambda. Una vez creada esta asignación de orígenes de eventos, AWS Lambda comienza a sondear el flujo. **Para crear la asignación de orígenes de eventos** 1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija la función `ProcessDocumentDBRecords` que creó anteriormente. 1. Elija la pestaña **Configuración** y, a continuación, elija **Desencadenadores** en el menú de la izquierda. 1. Elija **Add trigger (Añadir disparador)**. 1. En **Configuración del desencadenador**, para el origen, seleccione **Amazon DocumentDB**. 1. Cree la asignación de orígenes de eventos con la siguiente configuración: + **Clúster de Amazon DocumentDB**: elija el clúster que creó anteriormente. + **Nombre de la base de datos:** docdbdemo + **Nombre de la colección**: productos + **Tamaño del lote**: 1 + **Posición inicial**: más reciente + **Autenticación**: BASIC\$1AUTH + **Clave de Secrets Manager**: elija el secreto de su clúster de Amazon DocumentDB. Tendrá un nombre similar a `rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f`. + **Intervalo del lote**: 1 + **Configuración de documentos completa**: UpdateLookup 1. Elija **Agregar**. Crear la asignación de orígenes de eventos puede tardar unos minutos. ## Comprobación de la función de Espere a que la asignación de orígenes de eventos llegue al estado **Habilitado**. Esto puede tardar varios minutos. A continuación, inserte, actualice y elimine los registros de base de datos para probar la configuración integral. Antes de empezar: 1. [Vuelva a conectarse al clúster de Amazon DocumentDB](#docdb-connect-to-cluster) en su entorno de CloudShell. 1. Ejecute el siguiente comando para asegurarse de que utiliza la base de datos `docdbdemo`: ``` use docdbdemo ``` ### Inserción de un registro Inserte un registro en la colección `products` de la base de datos `docdbdemo`: ``` db.products.insertOne({"name":"Pencil", "price": 1.00}) ``` Para verificar que la función procesó correctamente este evento, [compruebe los Registros de CloudWatch](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Debería ver un registro como este: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/documentdb-insert-log.png) ### Actualización de un registro Actualice el registro que acaba de insertar con el siguiente comando: ``` db.products.updateOne( { "name": "Pencil" }, { $set: { "price": 0.50 }} ) ``` Para verificar que la función procesó correctamente este evento, [compruebe los Registros de CloudWatch](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Debería ver un registro como este: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/documentdb-update-log.png) ### Eliminación de un registro Elimine el registro que acaba de actualizar con el siguiente comando: ``` db.products.deleteOne( { "name": "Pencil" } ) ``` Para verificar que la función procesó correctamente este evento, [compruebe los Registros de CloudWatch](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Debería ver un registro como este: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/documentdb-delete-log.png) ## Solución de problemas Si no ve ningún evento de base de datos en los registros de CloudWatch de la función, compruebe lo siguiente: + Asegúrese de que el estado de la asignación de orígenes de eventos de Lambda (también conocida como desencadenador) sea **Habilitado**. La creación de las asignaciones de orígenes de eventos puede tardar varios minutos. + Si la asignación de orígenes de eventos está **habilitada**, pero sigue sin ver los eventos de la base de datos en CloudWatch: + Asegúrese de que el **nombre de la base de datos** en la asignación de orígenes de eventos esté establecido en `docdbdemo`. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/documentdb-trigger.png) + Compruebe el campo **Resultado del último procesamiento** de la asignación de orígenes de eventos para ver el siguiente mensaje: “PROBLEMA: error de conexión. Su VPC debe poder conectarse a Lambda y STS, así como a Secrets Manager si se requiere autenticación”. Si ve este error, asegúrese de haber [creado los puntos de conexión de la interfaz de VPC de Lambda y Secrets Manager](#docdb-create-interface-vpc-endpoints) y de que los puntos de conexión utilicen la misma VPC y las mismas subredes que utiliza su clúster de Amazon DocumentDB. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/documentdb-lastprocessingresult.png) ## Eliminación de sus recursos A menos que desee conservar los recursos que creó para este tutorial, puede eliminarlos ahora. Si elimina los recursos de AWS que ya no utiliza, evitará gastos innecesarios en su Cuenta de AWS. **Cómo eliminar la función de Lambda** 1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Seleccione la función que ha creado. 1. Elija **Acciones**, **Eliminar**. 1. Escriba **confirm** en el campo de entrada de texto y elija **Delete**(Eliminar). **Cómo eliminar el rol de ejecución** 1. Abra la página [Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM. 1. Seleccione el rol de ejecución que creó. 1. Elija **Eliminar**. 1. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Delete** (Eliminar). **Para eliminar los puntos de conexión de VPC** 1. Abra la [consola de VPC](https://console.aws.amazon.com/vpc/home#). En el menú de la izquierda, en **Nube privada virtual**, seleccione **Puntos de conexión**. 1. Seleccione los puntos de conexión que ha creado. 1. Elija **Acciones**, **Eliminar puntos de conexión de VPC**. 1. Introduzca **delete** en el campo de entrada de texto. 1. Elija **Eliminar**. **Para eliminar el clúster de Amazon DocumentDB** 1. Abra la [consola de Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). 1. Elija el clúster de Amazon DocumentDB que creó para este tutorial y deshabilite la protección contra la eliminación. 1. En la página principal **Clústeres**, vuelva a elegir el clúster de Amazon DocumentDB. 1. Elija **Acciones**, **Eliminar**. 1. En **Crear instantánea final del clúster**, seleccione **No**. 1. Introduzca **delete** en el campo de entrada de texto. 1. Elija **Eliminar**. **Para eliminar el secreto en Secrets Manager** 1. Abra la [consola de Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#). 1. Elija el secreto que ha creado para este tutorial. 1. Elija **Acciones**, **Eliminar secreto**. 1. Elija **Schedule deletion**.