Tutorial: uso do AWS Lambda com o Amazon DocumentDB Streams

1. Abra o console do Amazon DocumentDB. Em Clusters, escolha Criar.

2. Crie um cluster com a seguinte configuração:

   • Em Tipo de cluster, escolha Cluster baseado em instância. Esta é a opção padrão.

   • Em Configuração do cluster, confira se a opção Engine versão 5.0.0 está selecionada. Esta é a opção padrão.

   • Em Configuração de instância:

     • Em Classe de instância de banco de dados, selecione Classes otimizadas para memória. Esta é a opção padrão.

     • Em Número de instâncias de réplicas regulares, escolha 1.

     • Em Classe de instância, use a seleção padrão.

   • Em Autenticação, insira um nome de usuário para o usuário principal e escolha Autogerenciado. Insira uma senha e confirme-a.

   • Mantenha todas as outras configurações como o padrão.

3. Selecione Criar cluster.

Para criar o segredo no Secrets Manager

1. Abra o console do Secrets Manager e escolha Armazenar um novo segredo.

2. Em Escolha o tipo de segredo, selecione as seguintes opções:

   • Em Detalhes básicos:

     • Tipo de segredo: credenciais para o banco de dados do Amazon DocumentDB

     • Em Credenciais, insira o nome de usuário e a senha que você usou para acessar o cluster do Amazon DocumentDB.

     • Banco de dados: escolha seu cluster do Amazon DocumentDB.

     • Escolha Próximo.

3. Em Configurar segredo, escolha as seguintes opções:

   • Nome de segredo: DocumentDBSecret

   • Escolha Próximo.

4. Escolha Próximo.

5. Escolha Armazenar.

6. Atualize o console para verificar se você armazenou o segredo DocumentDBSecret com êxito.

Conectar-se ao cluster do Amazon DocumentDB usando o AWS CloudShell

1. No console de gerenciamento do Amazon DocumentDB, em Clusters, localize o cluster que você criou. Escolha o cluster clicando na caixa de seleção ao lado dele.

2. Escolha Conectar-se ao cluster. A tela Executar comando do CloudShell é exibida.

3. No campo Nome do novo ambiente, insira um nome exclusivo, como "teste" e escolha Criar e executar.

4. Insira sua senha quando for solicitado. Quando o prompt se torna rs0 [direct: primary] <env-name>>, sua conexão com o cluster do Amazon DocumentDB foi estabelecida com sucesso.

Para criar um novo banco de dados em seu cluster

1. Execute o seguinte comando para criar um novo banco de dados denominado docdbdemo:

   use docdbdemo

2. Na janela do terminal, use o seguinte comando para inserir um registro no docdbdemo:

   db.products.insertOne({"hello":"world"})

   Você deve ver uma saída como esta:

   {
     acknowledged: true,
     insertedId: ObjectId('67f85066ca526410fd531d59')
   }

3. Em seguida, ative os streams de alterações na coleção de products do banco de dados docdbdemo usando o seguinte comando:

   db.adminCommand({modifyChangeStreams: 1,
       database: "docdbdemo",
       collection: "products", 
       enable: true});

   Você deve ver uma saída semelhante a:

   { "ok" : 1, "operationTime" : Timestamp(1680126165, 1) }

Para criar endpoints da VPC de interface

1. Abra o console da VPC. No menu à esquerda, em Nuvem privada virtual, escolha Endpoints.

2. Escolha Criar endpoint. Crie um endpoint com a seguinte configuração:

   • Em Nomear tag, insira lambda-default-vpc.

   • Em Categoria do serviço, escolha serviços da AWS.

   • Em Serviços, insira lambda na caixa de pesquisa. Escolha o serviço com formato com.amazonaws.<region>.lambda.

   • Em VPC, escolha a VPC em que está o cluster do Amazon DocumentDB. Normalmente, essa é a VPC padrão.

   • Em sub-redes, marque as caixas ao lado de cada zona de disponibilidade. Escolha O ID correto da sub-rede de cada zona de disponibilidade.

   • Em Tipo de endereço IP, selecione IPv4.

   • Em Grupos de segurança, escolha o grupo de segurança que o cluster do Amazon DocumentDB usa. Normalmente, esse é o grupo de segurança default.

   • Mantenha todas as outras configurações como o padrão.

   • Escolha Criar endpoint.

3. Novamente, escolha Criar endpoint. Crie um endpoint com a seguinte configuração:

   • Em Nomear tag, insira secretsmanager-default-vpc.

   • Em Categoria do serviço, escolha serviços da AWS.

   • Em Serviços, insira secretsmanager na caixa de pesquisa. Escolha o serviço com formato com.amazonaws.<region>.secretsmanager.

   • Em VPC, escolha a VPC em que está o cluster do Amazon DocumentDB. Normalmente, essa é a VPC padrão.

   • Em sub-redes, marque as caixas ao lado de cada zona de disponibilidade. Escolha O ID correto da sub-rede de cada zona de disponibilidade.

   • Em Tipo de endereço IP, selecione IPv4.

   • Em Grupos de segurança, escolha o grupo de segurança que o cluster do Amazon DocumentDB usa. Normalmente, esse é o grupo de segurança default.

   • Mantenha todas as outras configurações como o padrão.

   • Escolha Criar endpoint.

Para criar uma política do IAM

1. Abra a página Políticas no console do IAM e escolha Criar política.

2. Selecione a guia JSON. Na política a seguir, substitua o ARN do recurso Secrets Manager na linha final da declaração pelo ARN do seu segredo de antes, e copie a política no editor.

   {
       "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"
           }
       ]
   }

3. Escolha Próximo: Tags, e, em seguida, escolha Próximo: Revisar.

4. Em Nome, insira AWSDocumentDBLambdaPolicy.

5. Escolha Criar política.

Para criar perfil do IAM

1. Abra a página Perfis no console do IAM e escolha Criar perfil.

2. Em Selecionar entidade confiável, escolha as seguintes opções:

   • Tipo de entidade confiável: serviço da AWS

   • Serviço ou caso de uso: Lambda

   • Escolha Próximo.

3. Em Adicionar permissões, escolha a política AWSDocumentDBLambdaPolicy que você acabou de criar, bem como AWSLambdaBasicExecutionRole para conceder à sua função permissões para gravar no Amazon CloudWatch Logs.

4. Escolha Próximo.

5. Em Nome do perfil, insira AWSDocumentDBLambdaExecutionRole.

6. Escolha Create role (Criar função).

Para criar a função do Lambda

1. Abra a página Funções do console do Lambda.

2. Escolha a opção Criar função.

3. Escolher Criar do zero

4. Em Basic information (Informações básicas), faça o seguinte:

   1. Em Nome da função, inserir ProcessDocumentDBRecords

   2. Em Runtime, selecione Python 3.13.

   3. Em Architecture (Arquitetura), escolha x86_64.

5. Na guia Alterar função de execução padrão, faça o seguinte:

   1. Expanda a guia e escolha Usar uma função existente.

   2. Selecione a AWSDocumentDBLambdaExecutionRole que você criou anteriormente.

6. Escolha Criar função.

Para implantar o código da função

1. Escolha a guia Python na caixa a seguir e copie o código.

   .NET

   SDK para .NET

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Processando um evento do Amazon DocumentDB com o Lambda ao usar .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
   {
       
        /// <summary>
       /// Lambda function entry point to process Amazon DocumentDB events.
       /// </summary>
       /// <param name="event">The Amazon DocumentDB event.</param>
       /// <param name="context">The Lambda context object.</param>
       /// <returns>A string to indicate successful processing.</returns>
       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<DocumentDBEventRecord> 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<string, object> 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

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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<Map<String, Object>, String> {
   
       @SuppressWarnings("unchecked")
       @Override
       public String handleRequest(Map<String, Object> event, Context context) {
           List<Map<String, Object>> events = (List<Map<String, Object>>) event.get("events");
           for (Map<String, Object> record : events) {
               Map<String, Object> eventData = (Map<String, Object>) record.get("event");
               processEventData(eventData);
           }
   
           return "OK";
       }
   
       @SuppressWarnings("unchecked")
       private void processEventData(Map<String, Object> eventData) {
           String operationType = (String) eventData.get("operationType");
           System.out.println("operationType: %s".formatted(operationType));
   
           Map<String, Object> ns = (Map<String, Object>) 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<String, Object> fullDocument = (Map<String, Object>) eventData.get("fullDocument");
           System.out.println("fullDocument: %s".formatted(fullDocument));
       }
   
   }
   
   

   JavaScript

   SDK para JavaScript (v3)

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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));
   };
   
   
   

   Consumir um evento do Amazon DocumentDB com o Lambda usando TypeScript

   import { DocumentDBEventRecord, DocumentDBEventSubscriptionContext } from 'aws-lambda';
   
   console.log('Loading function');
   
   export const handler = async (
     event: DocumentDBEventSubscriptionContext,
     context: any
   ): Promise<string> => {
     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

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando PHP.

   <?php
   
   require __DIR__.'/vendor/autoload.php';
   
   use Bref\Context\Context;
   use Bref\Event\Handler;
   
   class DocumentDBEventHandler implements Handler
   {
       public function handle($event, Context $context): string
       {
   
           $events = $event['events'] ?? [];
           foreach ($events as $record) {
               $this->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).

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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

   nota

   Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

   Consumir um evento do Amazon DocumentDB com o Lambda usando 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<DocumentDbEvent>) ->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(())
       
   }
   
   

2. No painel de Origem do código no console do Lambda, cole o código no editor de código, substituindo o código criado pelo Lambda.

3. Na seção DEPLOY, escolha Implantar para atualizar o código da função:

   

Para criar o mapeamento da origem do evento

1. Abra a página Funções no console do Lambda.

2. Escolha a função ProcessDocumentDBRecords criada anteriormente.

3. Escolha a guia Configuração e depois escolha Acionadores no menu à esquerda.

4. Escolha Add trigger.

5. Em Configuração do acionador, para a origem, selecione Amazon DocumentDB.

6. Crie o mapeamento da origem do evento com a seguinte configuração:

   • Cluster do Amazon DocumentDB: escolha o cluster que você criou anteriormente.

   • Nome do banco de dados: docdbdemo

   • Nome da coleção: produtos

   • Tamanho do lote: 1

   • Posição inicial: a última

   • Autenticação: BASIC_AUTH

   • Chave do Secrets Manager: escolha o segredo do cluster do Amazon DocumentDB. O nome da chave será algo como rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f.

   • Janela de lote: 1

   • Configuração do documento total: UpdateLookup

7. Escolha Adicionar. A criação do mapeamento da origem do evento pode levar alguns minutos.

1. Reconecte-se ao cluster do Amazon DocumentDB no ambiente do CloudShell.

2. Execute o comando a seguir para garantir que esteja usando o banco de dados docdbdemo:

   use docdbdemo

Como excluir a função do Lambda

1. Abra a página Functions (Funções) no console do Lambda.

2. Selecione a função que você criou.

3. Selecione Ações, Excluir.

4. Digite confirm no campo de entrada de texto e escolha Delete (Excluir).

Para excluir a função de execução

1. Abra a página Roles (Funções) no console do IAM.

2. Selecione a função de execução que você criou.

3. Escolha Excluir.

4. Insira o nome do perfil no campo de entrada de texto e escolha Delete (Excluir).

Para excluir os endpoints da VPC

1. Abra o console da VPC. No menu à esquerda, em Nuvem privada virtual, escolha Endpoints.

2. Selecione os endpoints que você criou.

3. Escolha Actions (Ações), Delete VPC endpoints (Excluir endpoints da VPC).

4. Digite delete no campo de entrada de texto.

5. Escolha Excluir.

Para excluir o cluster do Amazon DocumentDB

1. Abra o console do Amazon DocumentDB.

2. Escolha o cluster do Amazon DocumentDB que você criou para este tutorial e desative a proteção contra exclusão.

3. Na página principal de Clusters, escolha seu cluster do Amazon DocumentDB novamente.

4. Selecione Ações, Excluir.

5. Em Criar snapshot final do cluster, selecione Não.

6. Digite delete no campo de entrada de texto.

7. Escolha Excluir.

Para excluir o segredo no Secrets Manager

1. Abra o console do Secrets Manager.

2. Escolha o segredo que você criou para este tutorial.

3. Escolha Ações, Excluir segredo.

4. Escolha Schedule deletion.