# Processar eventos do Amazon DocumentDB com o Lambda É possível usar uma função do Lambda para processar eventos em um [fluxo de alterações do Amazon DocumentDB (compatível com MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) ao configurar um cluster do Amazon DocumentDB como uma origem do evento. Em seguida, você pode automatizar workloads orientadas por eventos invocando a função do Lambda sempre que os dados são alterados com o cluster do Amazon DocumentDB. **nota** O Lambda é compatível somente com as versões 4.0 e 5.0 do Amazon DocumentDB. O Lambda não é compatível com a versão 3.6. Além disso, para os mapeamentos da origem do evento, o Lambda oferece suporte somente a clusters baseados em instâncias e a clusters regionais. O Lambda não é compatível com [clusters elásticos](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html) ou [clusters globais](https://docs.aws.amazon.com/documentdb/latest/developerguide/global-clusters.html). Essa limitação não se aplica ao usar o Lambda como cliente para se conectar ao Amazon DocumentDB. O Lambda pode se conectar a todos os tipos de cluster para realizar operações CRUD. O Lambda processa eventos dos fluxos de alterações do Amazon DocumentDB sequencialmente na ordem em que chegam. Consequentemente, a função só pode processar uma invocação simultânea do Amazon DocumentDB de cada vez. Para monitorar a função, você pode rastrear as [métricas de simultaneidade](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-concurrency.html) dela. **Atenção** Os mapeamentos da origem do evento do Lambda processam cada evento ao menos uma vez, podendo haver o processamento duplicado de registros. Para evitar possíveis problemas relacionados a eventos duplicados, é altamente recomendável tornar o código da função idempotente. Para saber mais, consulte [Como tornar minha função do Lambda idempotente](https://repost.aws/knowledge-center/lambda-function-idempotent) no Centro de Conhecimentos da AWS. **Topics** + [Exemplo de evento do Amazon DocumentDB](#docdb-sample-event) + [Pré-requisitos e permissões](#docdb-prereqs) + [Configuração da segurança de rede](#docdb-network) + [Criar um mapeamento da origem do evento do Amazon DocumentDB (console)](#docdb-configuration) + [Criar um mapeamento da origem do evento do Amazon DocumentDB (SDK ou CLI)](#docdb-api) + [Posições iniciais de sondagem e fluxo](#docdb-stream-polling) + [Monitorar a origem do evento do Amazon DocumentDB](#docdb-monitoring) + [Tutorial: uso do AWS Lambda com o Amazon DocumentDB Streams](with-documentdb-tutorial.md) ## Exemplo de evento do 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 obter mais informações sobre os eventos neste exemplo e suas formas, consulte [Alterar eventos](https://www.mongodb.com/docs/manual/reference/change-events/) no site de documentação do MongoDB. ## Pré-requisitos e permissões Antes que você possa usar o Amazon DocumentDB como origem do evento a sua função do Lambda, observe os pré-requisitos a seguir. Você deve: + **Ter um cluster do Amazon DocumentDB existente na mesma Conta da AWS e Região da AWS como sua função.** Se você não tiver um cluster existente, poderá criar um seguindo as etapas em [Get Started with Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) no *Guia do desenvolvedor do Amazon DocumentDB*. Como alternativa, o primeiro conjunto de etapas do [Tutorial: uso do AWS Lambda com o Amazon DocumentDB Streams](with-documentdb-tutorial.md) orientará você ao longo do processo de criação de um cluster do Amazon DocumentDB com todos os pré-requisitos necessários. + **Permitir que o Lambda tenha acesso aos recursos da Amazon Virtual Private Cloud (Amazon VPC) associados ao cluster do Amazon DocumentDB.** Para obter mais informações, consulte [Configuração da segurança de rede](#docdb-network). + **Habilitar o TLS no cluster do Amazon DocumentDB.** Essa é a configuração padrão. Se você desabilitar o TLS, o Lambda não poderá se comunicar com o cluster. + **Ativar os fluxos de alterações no cluster do Amazon DocumentDB.** Para obter mais informações, consulte [Usar fluxos de alterações com o Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) no *Guia do desenvolvedor do Amazon DocumentDB*. + **Fornecer ao Lambda credenciais para acessar o cluster  do Amazon DocumentDB.** Ao configurar a origem do evento, forneça a chave [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) que contém os detalhes de autenticação (nome de usuário e senha) necessários para acessar o cluster. Para fornecer essa chave durante a configuração, execute uma das seguintes ações: + Se você estiver usando o console do Lambda para configurar, forneça essa chave no campo **chave do Secrets Manager**. + Se você estiver usando o AWS Command Line Interface (AWS CLI) para configuração, forneça essa chave na opção `source-access-configurations`. É possível incluir essa opção com o 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) ou o 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). Por exemplo: ``` aws lambda create-event-source-mapping \ ... --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-west-2:123456789012:secret:DocDBSecret-AbC4E6"}]' \ ... ``` + **Conceder permissões ao Lambda para gerenciar recursos relacionados ao fluxo do Amazon DocumentDB.** Adicione manualmente as seguintes permissões à [função de execução](lambda-intro-execution-role.md) da função: + [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) + **Manter o tamanho dos eventos de fluxos de alterações do Amazon DocumentDB que você envia para o Lambda abaixo de 6 MB.** O Lambda suporta apenas cargas úteis de até 6 MB. Se seu fluxo de alterações tentar enviar ao Lambda um evento maior que 6 MB, o Lambda descartará a mensagem e emitirá a métrica `OversizedRecordCount`. O Lambda emite todas as métricas com base no melhor esforço. **nota** Embora as funções do Lambda normalmente tenham um limite máximo de tempo de 15 minutos, os mapeamentos da origem dos eventos para o Amazon MSK, o Apache Kafka autogerenciado, o Amazon DocumentDB e o Amazon MQ para ActiveMQ e RabbitMQ são compatíveis somente com funções com limites máximos de tempo limite de 14 minutos. Essa restrição garante que o mapeamento da origem do evento possa solucionar adequadamente os erros de função e repetições. ## Configuração da segurança de rede Para conceder ao Lambda acesso total ao Amazon DocumentDB por meio do mapeamento da origem do evento, seu cluster deve usar um endpoint público (endereço IP público) ou você deve fornecer acesso à Amazon VPC na qual o cluster foi criado. Ao usar o Amazon DocumentDB com o Lambda, recomendamos a criação de [endpoints de VPC do AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) para conceder acesso da sua função aos recursos na sua Amazon VPC. **nota** Os endpoints de VPC do AWS PrivateLink são necessários para funções com mapeamentos da origem de eventos que usam o modo padrão (sob demanda) para agentes de sondagem de eventos. Se o mapeamento da origem do evento usa o [modo provisionado](invocation-eventsourcemapping.md#invocation-eventsourcemapping-provisioned-mode), você não precisa configurar endpoints de VPC do AWS PrivateLink. Crie um endpoint para fornecer acesso aos seguintes recursos: + Lambda: crie um endpoint para a entidade principal de serviço do Lambda. + AWS STS: crie um endpoint para o AWS STS com a finalidade de possibilitar que uma entidade principal de serviço assuma um perfil em seu nome. + Secrets Manager: caso o seu cluster use o Secrets Manager para armazenar credenciais, crie um endpoint específico para o Secrets Manager. Como alternativa, configure um gateway de NAT em cada sub-rede pública da Amazon VPC. Para obter mais informações, consulte [Habilitar o acesso à Internet para funções do Lambda conectadas à VPC](configuration-vpc-internet.md). Ao criar um mapeamento da origem do evento para o Amazon DocumentDB, o Lambda verifica se as interfaces de rede elástica (ENIs) já estão presentes nas sub-redes e nos grupos de segurança configurados para a Amazon VPC. Se o Lambda encontrar ENIs existentes, ele tentará reutilizá-las. Caso contrário, o Lambda criará novas ENIs para se conectar à origem do evento e invocar sua função. **nota** As funções do Lambda sempre são executadas em VPCs de propriedade do serviço Lambda. A configuração de VPC da sua função não afetará o mapeamento da origem do evento. Somente a configuração de rede da origem dos eventos determina como o Lambda estabelece conexão com a origem dos eventos. Configure os grupos de segurança para a Amazon VPC que contém o cluster. Por padrão, o Amazon DocumentDB faz uso das seguintes portas: `27017`. + Regras de entrada: permitem todo o tráfego na porta padrão do agente para o grupo de segurança associado à origem dos eventos. Como alternativa, é possível usar uma regra de grupo de segurança autorreferenciada para permitir o acesso de instâncias dentro do mesmo grupo de segurança. + Regras de saída: permitir todo o tráfego na porta `443` para destinos externos se sua função precisar se comunicar com serviços da AWS. Como alternativa, você também poderá usar uma regra de grupo de segurança autorreferenciada para limitar o acesso ao operador se não precisar se comunicar com outros serviços AWS. + Regras de entrada para o endpoint da Amazon VPC: caso você esteja usando um endpoint da Amazon VPC, o grupo de segurança associado ao endpoint da Amazon VPC deve permitir o tráfego de entrada na porta `443` usando o grupo de segurança do cluster. Caso o cluster use autenticação, é possível restringir a política de endpoint para o endpoint do Secrets Manager. Para chamar a API do Secrets Manager, o Lambda usa seu perfil de função, e não a entidade principal de serviço do Lambda. **Example Política de endpoint da VPC: endpoint do 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" } ] } ``` Quando você usa os endpoints da Amazon VPC, a AWS roteia suas chamadas de API para invocar sua função usando a interface de rede elástica (ENI) do endpoint. A entidade principal do serviço Lambda precisa chamar `lambda:InvokeFunction` para quaisquer perfis e funções que usem essas ENIs. Por padrão, os endpoints da Amazon VPC têm políticas do IAM abertas que permitem amplo acesso aos recursos. A prática recomendada é restringir essas políticas para executar as ações necessárias usando esse endpoint. Para garantir que seu mapeamento da origem do evento seja capaz de invocar sua função do Lambda, a política de endpoint da VPC deve permitir que a entidade principal do serviço Lambda chame `sts:AssumeRole` e `lambda:InvokeFunction`. A restrição de suas políticas de endpoint da VPC para permitir apenas chamadas de API originadas em sua organização impedirá o funcionamento adequado do mapeamento da origem do evento; portanto, `"Resource": "*"` é necessário nessas políticas. O seguinte exemplo de políticas de endpoint da VPC mostra como conceder o acesso necessário à entidade principal do serviço Lambda para os endpoints do AWS STS e Lambda. **Example Política de endpoint da VPC: endpoint do AWS STS** ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` **Example Política de endpoint da VPC: endpoint do Lambda** ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` ## Criar um mapeamento da origem do evento do Amazon DocumentDB (console) Para que uma função do Lambda faça leituras de um fluxo de alterações de um cluster do Amazon DocumentDB, crie um [mapeamento da origem do evento](invocation-eventsourcemapping.md). Esta seção descreve como fazer isso pelo console do Lambda. Para obter o AWS SDK e instruções da AWS CLI, consulte [Criar um mapeamento da origem do evento do Amazon DocumentDB (SDK ou CLI)](#docdb-api). **Para criar um mapeamento da origem do evento do Amazon DocumentDB (console)** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome de uma função. 1. Em **Visão geral da função**, escolha **Adicionar gatilho**. 1. Em **Configuração do acionador**, na lista suspensa, escolha **DocumentDB**. 1. Configure as opções necessárias e escolha **Add** (Adicionar). O Lambda oferece suporte às seguintes opções de origem do evento do Amazon DocumentDB: + **Cluster do DocumentDB**: selecione um cluster do Amazon DocumentDB. + **Ativar acionador**: escolha se você deseja ativar o acionador imediatamente. Se você marcar esta caixa de seleção, a função começará imediatamente a receber tráfego do fluxo de alterações do Amazon DocumentDB especificado após a criação do mapeamento da origem do evento. Recomendamos desmarcar a caixa de seleção para criar o mapeamento da origem do evento em um estado desativado para testes. Após a criação, é possível ativar o mapeamento da origem do evento a qualquer momento. + **Nome do banco de dados:** insira o nome de um banco de dados do cluster a ser consumido. + (Opcional) **Nome da coleção**: insira o nome de uma coleção no banco de dados a ser consumida. Se você não especificar uma coleção, o Lambda receberá todos os eventos de cada coleção no banco de dados. + **Tamanho do lote**: defina o número máximo de mensagens a serem recuperadas em um único lote, até 10 mil. O tamanho padrão do lote é 100. + **Posição inicial:** escolha a posição no fluxo para começar a ler registros. + **Mais recente**: processe somente novos registros adicionados ao fluxo. Sua função começa a processar registros somente depois que o Lambda termina de criar a origem do evento. Isso significa que alguns registros podem ser descartados até que a origem do evento seja criada com êxito. + **Trim horizon** (Redução horizontal): processe todos os registros na transmissão. O Lambda usa a duração da retenção de logs do cluster para determinar por onde começar a ler os eventos. Especificamente, o Lambda começa a ler a partir de `current_time - log_retention_duration`. O fluxo de alterações já deve estar ativo antes desse carimbo de data e hora para que o Lambda leia corretamente todos os eventos. + **At timestamp** (Na data e hora): processe registros a partir de uma hora específica. O fluxo de alterações já deve estar ativo antes do carimbo de data e hora especificado para que o Lambda leia corretamente todos os eventos. + **Autenticação**: escolha o método de autenticação para acessar os agentes do Kafka no cluster. + **BASIC\$1AUTH:** com a autenticação básica, é necessário fornecer a chave do Secrets Manager que contém as credenciais para acessar o cluster. + **Chave do Secrets Manager**: escolha a chave do Secrets Manager que contém os detalhes de autenticação (nome de usuário e senha) necessários para acessar o cluster do Amazon DocumentDB. + (Opcional) **Janela de lote**: defina o tempo máximo em segundos para reunir registros antes de invocar a função, até 300. + (Opcional) **Configuração completa do documento**: para operações de atualização de documentos, escolha o que você deseja enviar ao fluxo. O valor padrão é `Default`, o que significa que, para cada evento de fluxo de alterações, o Amazon DocumentDB enviará somente um delta descrevendo as alterações feitas. Para obter mais informações sobre esse campo, consulte [FullDocument](https://mongodb.github.io/mongo-java-driver/3.9/javadoc/com/mongodb/client/model/changestream/FullDocument.html#DEFAULT) na documentação da API do Javadoc do MongoDB. + **Padrão:** o Lambda envia somente um documento parcial descrevendo as alterações feitas. + **UpdateLookup:** o Lambda envia um delta descrevendo as alterações, junto com uma cópia de todo o documento. ## Criar um mapeamento da origem do evento do Amazon DocumentDB (SDK ou CLI) Para criar ou gerenciar um mapeamento da origem do evento do Amazon DocumentDB com um [AWS SDK](https://aws.amazon.com/developer/tools/), você pode usar as seguintes operações de 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 criar o mapeamento da origem do evento com a AWS CLI, use o 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). O exemplo a seguir usa esse comando para mapear uma função denominada `my-function` para um fluxo de alterações do Amazon DocumentDB. A origem do evento é especificada por um nome do recurso da Amazon (ARN), com um tamanho de lote de 500, a partir do timestamp no horário do Unix. O comando também especifica a chave do Secrets Manager que o Lambda usa para se conectar ao Amazon DocumentDB. Além disso, ele inclui parâmetros `document-db-event-source-config` que especificam o banco de dados e a coleção de onde serão feitas as leituras. ``` 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"}' \ ``` Você deve ver uma saída semelhante a: ``` { "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" } ``` Após a criação, você pode usar o 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 atualizar as configurações da origem do evento do Amazon DocumentDB. O exemplo a seguir atualiza o tamanho do lote para 1 mil e a janela do lote para dez segundos. Para esse comando, é necessário o UUID do mapeamento da origem do evento, que pode ser recuperado usando o comando `list-event-source-mapping` ou o console do Lambda. ``` aws lambda update-event-source-mapping --function-name my-function \ --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \ --batch-size 1000 \ --batch-window 10 ``` Você deve ver uma saída semelhante a: ``` { "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" } ``` O Lambda atualiza as configurações de maneira assíncrona. Talvez você não veja essas alterações na saída até que o processo seja concluído. Para visualizar as configurações atuais do mapeamento da origem do evento, use o 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 ``` Você deve ver uma saída semelhante a: ``` { "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 excluir o mapeamento da origem do evento do  Amazon DocumentDB, use o 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 ``` ## Posições iniciais de sondagem e fluxo Esteja ciente de que a sondagem do fluxo durante a criação e as atualizações do mapeamento da origem do evento é, finalmente, consistente. + Durante a criação do mapeamento da origem do evento, pode levar alguns minutos para a sondagem de eventos do fluxo iniciar. + Durante as atualizações do mapeamento da origem do evento, pode levar alguns minutos para interromper e reiniciar a sondagem de eventos do fluxo. Esse comportamento significa que, se você especificar `LATEST` como posição inicial do fluxo, o mapeamento da origem do evento poderá perder eventos durante a criação ou as atualizações. Para garantir que nenhum evento seja perdido, especifique a posição inicial do fluxo como `TRIM_HORIZON` ou `AT_TIMESTAMP`. ## Monitorar a origem do evento do Amazon DocumentDB Para ajudar você a monitorar a origem do evento do Amazon DocumentDB, o Lambda gera a métrica `IteratorAge` quando a função termina de processar um lote de registros. *Idade do iterador* é a diferença entre o carimbo de data e hora do evento mais recente e o carimbo de data e hora atual. Essencialmente a métrica `IteratorAge` indica a idade do último registro processado no lote. Se a função atualmente estiver processando novos eventos, você poderá usar a idade do iterador para estimar a latência entre quando um registro é adicionado e quando a função o processa. Uma tendência crescente em `IteratorAge` pode indicar problemas com a função. Para obter mais informações, consulte [Uso de métricas do CloudWatch com o Lambda](monitoring-metrics.md). Os fluxos de alterações do Amazon DocumentDB não são otimizados para processar grandes intervalos de tempo entre os eventos. Se sua origem de eventos do Amazon DocumentDB não receber nenhum evento por um longo período de tempo, o Lambda poderá desabilitar o mapeamento da origem do evento. A duração desse período pode variar de algumas semanas a alguns meses, dependendo do tamanho do cluster e de outras workloads. O Lambda é compatível com cargas úteis de até 6 MB. Entretanto, os eventos de fluxo de alterações do Amazon DocumentDB podem ter até 16 MB. Se seu fluxo de alterações tentar enviar ao Lambda um evento de fluxo de alterações maior que 6 MB, o Lambda descartará a mensagem e emitirá a métrica `OversizedRecordCount`. O Lambda emite todas as métricas com base no melhor esforço. # 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**.