# Tutorial: uso do AWS Lambda com o Amazon DocumentDB Streams Neste tutorial, você criará uma função do Lambda que consome eventos de um stream de alterações do Amazon DocumentDB (compativel com MongoDB). Para concluir este tutorial, você passará pelos estágios a seguir: + Configure seu cluster Amazon DocumentDB, conecte-se a ele e ative streams de alterações nele. + Crie a função do Lambda e configure seu cluster do Amazon DocumentDB como uma origem de eventos para a sua função. + Teste a configuração inserindo itens no banco de dados Amazon DocumentDB. ## Criar o cluster do Amazon DocumentDB 1. Abra o [console do Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). Em **Clusters**, escolha **Criar**. 1. Crie um cluster com a seguinte configuração: + Em **Tipo de cluster**, escolha **Cluster baseado em instância**. Essa é a opção padrão. + Em **Configuração do cluster**, confira se a opção **Engine versão 5.0.0** está selecionada. Essa é 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**. Essa é 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. 1. Selecione **Criar cluster**. ## Criar o segredo no Secrets Manager Enquanto o Amazon DocumentDB estiver criando o cluster, crie um segredo do AWS Secrets Manager para armazenar suas credenciais de banco de dados. Você fornecerá esse segredo ao criar o mapeamento da origem do evento do Lambda em uma etapa posterior. **Para criar o segredo no Secrets Manager** 1. Abra o console do [Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#) e escolha **Armazenar um novo segredo**. 1. 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**. 1. Em **Configurar segredo**, escolha as seguintes opções: + **Nome de segredo**: `DocumentDBSecret` + Escolha **Próximo**. 1. Escolha **Próximo**. 1. Escolha **Armazenar**. 1. Atualize o console para verificar se você armazenou o segredo `DocumentDBSecret` com êxito. Anote o **ARN do segredo**. Você precisará dele em uma etapa posterior. ## Conectar-se ao cluster **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. 1. Escolha **Conectar-se ao cluster**. A tela **Executar comando** do CloudShell é exibida. 1. No campo **Nome do novo ambiente**, insira um nome exclusivo, como "teste" e escolha **Criar e executar**. 1. Insira sua senha quando for solicitado. Quando o prompt se torna `rs0 [direct: primary] >`, sua conexão com o cluster do Amazon DocumentDB foi estabelecida com êxito. ## Ativar os streams de alteração Neste tutorial, você acompanhará as alterações na coleção de `products` do banco de dados `docdbdemo` em seu cluster do Amazon DocumentDB. Você faz isso com a ativação de [streams de alterações](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html). **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 ``` 1. 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') } ``` 1. 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) } ``` ## Criar endpoints da VPC de interface Em seguida, crie [endpoints da VPC de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) para garantir que o Lambda e o Secrets Manager (usados posteriormente para armazenar nossas credenciais de acesso ao cluster) possam se conectar à sua VPC padrão. **Para criar endpoints da VPC de interface** 1. Abra o [console da VPC](https://console.aws.amazon.com/vpc/home#). No menu à esquerda, em **Nuvem privada virtual**, escolha **Endpoints**. 1. 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..lambda`. + Em **VPC**, escolha a VPC em que está o cluster do Amazon DocumentDB. Normalmente, essa é a [VPC padrão](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + 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**. 1. 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..secretsmanager`. + Em **VPC**, escolha a VPC em que está o cluster do Amazon DocumentDB. Normalmente, essa é a [VPC padrão](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + 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**. Isso conclui a parte de configuração de cluster deste tutorial. ## Criar a função de execução No próximo conjunto de etapas, você criará sua função do Lambda. Primeiro, é necessário criar o perfil de execução que concede à sua função permissão para acessar o seu cluster. Você criará uma política do IAM primeiro e, em seguida, anexará essa política a um perfil do IAM. **Para criar uma política do IAM** 1. Abra a página [Políticas](https://console.aws.amazon.com/iam/home#/policies) no console do IAM e escolha **Criar política**. 1. 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. ------ #### [ 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. Escolha **Próximo: Tags**, e, em seguida, escolha **Próximo: Revisar**. 1. Em **Nome**, insira `AWSDocumentDBLambdaPolicy`. 1. Escolha **Criar política**. **Para criar perfil do IAM** 1. Abra a [página Perfis](https://console.aws.amazon.com/iam/home#/roles) no console do IAM e escolha **Criar perfil**. 1. 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**. 1. 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. 1. Escolha **Próximo**. 1. Em **Nome do perfil**, insira `AWSDocumentDBLambdaExecutionRole`. 1. Escolha **Create role** (Criar função). ## Criar a função do Lambda Este tutorial usa o runtime do Python 3.14, mas também fornecemos exemplos de arquivos de código para outros runtimes. É possível selecionar a guia na caixa a seguir para ver o código do runtime do seu interesse. O exemplo de código a seguir recebe uma entrada de evento do Amazon DocumentDB e processa a mensagem ali contida. **Para criar a função do Lambda** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a opção **Criar função**. 1. Escolher **Criar do zero** 1. Em **Basic information** (Informações básicas), faça o seguinte: 1. Em **Nome da função**, inserir `ProcessDocumentDBRecords` 1. Em **Runtime**, selecione **Python 3.14**. 1. Em **Architecture** (Arquitetura), escolha **x86\$164**. 1. 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**. 1. Selecione a `AWSDocumentDBLambdaExecutionRole` que você criou anteriormente. 1. 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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 { /// /// 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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, 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)** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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 => { 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Consumir um evento do Amazon DocumentDB com o Lambda usando 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).** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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** Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). 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) ->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. 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. 1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Crie o mapeamento da origem do evento do Lambda Crie o mapeamento da origem do evento que associa o seu fluxo de alterações do Amazon DocumentDB à sua função do Lambda. Depois que você criar esse mapeamento da origem do evento, o AWS Lambda começará imediatamente a sondar o stream. **Para criar o mapeamento da origem do evento** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda. 1. Escolha a função `ProcessDocumentDBRecords` criada anteriormente. 1. Escolha a guia **Configuração** e depois escolha **Acionadores** no menu à esquerda. 1. Escolha **Add trigger**. 1. Em **Configuração do acionador**, para a origem, selecione **Amazon DocumentDB**. 1. 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\$1AUTH + **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 1. Escolha **Adicionar**. A criação do mapeamento da origem do evento pode levar alguns minutos. ## Testar a função Espere o mapeamento da origem do evento atingir o estado de **Habilitado**. Isso pode demorar vários minutos. Depois, teste a configuração de ponta a ponta inserindo, atualizando e excluindo registros do banco de dados. Antes de começar: 1. [Reconecte-se ao cluster do Amazon DocumentDB](#docdb-connect-to-cluster) no ambiente do CloudShell. 1. Execute o comando a seguir para garantir que esteja usando o banco de dados `docdbdemo`: ``` use docdbdemo ``` ### Inserir um registro Insira um registro na coleção `products` do banco de dados `docdbdemo`: ``` db.products.insertOne({"name":"Pencil", "price": 1.00}) ``` Veja se a função processou o evento com êxito [verificando o CloudWatch Logs](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Você deve ver uma entrada de log como esta: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/documentdb-insert-log.png) ### Atualizar um registro Atualize o registro que você acabou de inserir com o seguinte comando: ``` db.products.updateOne( { "name": "Pencil" }, { $set: { "price": 0.50 }} ) ``` Veja se a função processou o evento com êxito [verificando o CloudWatch Logs](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Você deve ver uma entrada de log como esta: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/documentdb-update-log.png) ### Excluir um registro Exclua o registro que você acabou de atualizar com o seguinte comando: ``` db.products.deleteOne( { "name": "Pencil" } ) ``` Veja se a função processou o evento com êxito [verificando o CloudWatch Logs](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Você deve ver uma entrada de log como esta: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/documentdb-delete-log.png) ## Solução de problemas Se você não vir nenhum evento de banco de dados nos logs do CloudWatch da sua função, verifique o seguinte: + Confira se o mapeamento da origem do evento do Lambda (também conhecido como acionador) está no estado **Habilitado**. A criação de mapeamentos de origens de eventos pode levar vários minutos. + Se o mapeamento da origem do evento estiver **Habilitado**, mas os eventos do banco de dados ainda não estiverem visíveis no CloudWatch: + Confira se o **Nome do banco de dados** no mapeamento da origem do evento está definido como `docdbdemo`. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/documentdb-trigger.png) + Verifique se o campo **Último resultado de processamento** do mapeamento da origem do evento mostra a seguinte mensagem "PROBLEMA: erro de conexão. A VPC deve conseguir se conectar ao Lambda e ao STS, e também ao Secrets Manager se for exigida autenticação". Se você vir esse erro, confira se [criou os endpoints de interface da VPC do Lambda e do Secrets Manager](#docdb-create-interface-vpc-endpoints), e se os endpoints usam a mesma VPC e as mesmas sub-redes que o cluster Amazon DocumentDB. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/documentdb-lastprocessingresult.png) ## Limpe os recursos Agora você pode excluir os recursos criados para este tutorial, a menos que queira mantê-los. Excluindo os recursos da AWS que você não está mais usando, você evita cobranças desnecessárias em sua Conta da AWS. **Como excluir a função do Lambda** 1. Abra a página [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funções) no console do Lambda. 1. Selecione a função que você criou. 1. Selecione **Ações**, **Excluir**. 1. 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](https://console.aws.amazon.com/iam/home#/roles) (Funções) no console do IAM. 1. Selecione a função de execução que você criou. 1. Escolha **Excluir**. 1. 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](https://console.aws.amazon.com/vpc/home#). No menu à esquerda, em **Nuvem privada virtual**, escolha **Endpoints**. 1. Selecione os endpoints que você criou. 1. Escolha **Actions** (Ações), **Delete VPC endpoints** (Excluir endpoints da VPC). 1. Digite **delete** no campo de entrada de texto. 1. Escolha **Excluir**. **Para excluir o cluster do Amazon DocumentDB** 1. Abra o [console do Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). 1. Escolha o cluster do Amazon DocumentDB que você criou para este tutorial e desative a proteção contra exclusão. 1. Na página principal de **Clusters**, escolha seu cluster do Amazon DocumentDB novamente. 1. Selecione **Ações**, **Excluir**. 1. Em **Criar snapshot final do cluster**, selecione **Não**. 1. Digite **delete** no campo de entrada de texto. 1. Escolha **Excluir**. **Para excluir o segredo no Secrets Manager** 1. Abra o [console do Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#). 1. Escolha o segredo que você criou para este tutorial. 1. Escolha **Ações**, **Excluir segredo**. 1. Escolha **Schedule deletion**.