Claro, você também pode usar o DynamoDB Streams para acionar os processos downstream e as funções do AWS Lambda. O Lambda, por definição, é um serviço de computação sem servidor que executa seu código em resposta a eventos e gerencia automaticamente os recursos de computação para você.
Você pode usar o Lambda para escrever o código em Node.js, Python, Java ou C# para processar os registros de stream e executar as ações apropriadas. O principal benefício da integração do DynamoDB Streams com o Lambda é que o Lambda permite que você execute os serviços de backup ou códigos de aplicativo sem a necessidade de administração.
Como usar os fluxos do AWS DynamoDB com o Lambda
Embora seja possível criar uma função do Lambda que consuma os eventos e ocorrências de um fluxo do DynamoDB, o processo pode ser bastante trabalhoso, principalmente na primeira tentativa. As seguintes etapas ajudarão:
Etapa 1: Certifique-se de que seu sistema atenda aos pré-requisitos
Este procedimento só será bem-sucedido se você conhecer as operações e processos básicos do Lambda. Portanto, este deve ser o primeiro a garantir que sua compreensão do Lambda esteja acima da média.
O segundo pré-requisito que vale a pena considerar é confirmar a versão da AWS do seu sistema. Você pode usar o seguinte comando:
aws –versão
O resultado para o comando fornecido deve ser semelhante a este:
aws-cli/ 2 .x.x Python/ 3 .x.x Linux/ 4 .x.x-xxx-std botocore/ 2 .x.xA resposta de amostra fornecida contém a versão instalada da AWS CLI ( aws-cli/2.x.x ), a versão Python ( Python/3.x.x ) e o sistema operacional ( Linux/4.x.x-xxx-std ). A parte final da resposta define a versão da biblioteca Botocore na qual sua AWS CLI é executada ( botocore/2.x.x ).
Você vai, portanto, acabar com algo assim:
Etapa 2: criar uma função de execução
A próxima etapa é criar uma função de execução na AWS CLI. Uma função de execução é uma função do AWS Identity and Access Management (IAM) assumida por um serviço da AWS para executar as tarefas em seu nome. Ele fornece acesso aos recursos da AWS necessários ao longo do caminho.
Você pode criar uma função usando o seguinte comando:
aws iam criar função \--role-name LambdaDynamoDBExecutionRole \
--assume-role-policy-document file://assume-role-policy.json \
--Descrição ' AWSLambdaDynamoDBExecutionRole' \
--service-name lambda.amazonaws.com
O comando anterior é um comando da AWS CLI para criar uma função. Você também pode usar o Amazon Management Console para criar uma função. Quando estiver no console do IAM, abra o Funções página e clique no botão Criar função botão.
Prossiga para inserir o seguinte:
- Entidade confiável: Lambda
- Nome da função: lambda-dynamodb-role
- Permissões: AWSLambdaDynamoDBExecutionRole
Você também pode usar o Python instalando primeiro o AWS SDK para Python:
pip instalar boto3Etapa 3: habilitar os fluxos do DynamoDB em sua mesa
Você precisa habilitar o DynamoDB Streams em sua mesa. Para esta ilustração, usamos o Boto3, SDK da AWS para Python. O seguinte comando ajudará:
importar boto3# Conecte-se ao serviço DynamoDB
dynamodb = boto3.client( 'dynamodb' )
# Habilita streams do DynamoDB na tabela 'my-table'
resposta = dynamodb.update_table(
TableName= 'minha mesa' ,
StreamSpecification={
'StreamEnabled' : Verdadeiro,
'StreamViewType' : 'NEW_AND_OLD_IMAGES'
}
)
# Verifique a resposta para garantir que o stream foi ativado com sucesso
se resposta[ 'Especificação de fluxo' ][ 'StreamEnabled' ]:
imprimir( 'Fluxo do DynamoDB habilitado com sucesso' )
outro:
imprimir( 'Erro ao ativar o fluxo do DynamoDB' )
Esse código habilita o fluxo do DynamoDB na tabela “mytable” que transmite as imagens novas e antigas dos itens assim que ocorrer qualquer alteração. Você pode optar por transmitir apenas as novas imagens assim que o StreamViewType for “NEW_IMAGE”.
Notavelmente, a execução desse código só pode habilitar os fluxos em suas tabelas depois de um tempo. Em vez disso, o processo pode levar algum tempo. Você pode usar o método describe_table para verificar o status do stream.
Etapa 4: criar a função Lambda
A próxima etapa é criar uma função do Lambda que acione o fluxo do DynamoDB. As seguintes etapas devem ajudar:
- Abra o console do AWS Lambda e clique na guia “Criar função”. Na página “Criar função”, escolha “Autor do zero” e insira um nome para sua função. Você também precisa inserir seu tempo de execução neste ponto. Selecionamos Python para esta ilustração.
- Em “Escolher ou criar uma função de execução”, selecione “Criar uma nova função com permissões básicas do Lambda” para criar uma função do IAM com as permissões necessárias para sua função do Lambda.
- Clique no botão 'Criar função' para criar sua função Lambda.
- Na página “Configuração” da sua função, role para baixo até a seção “Designer” e clique na guia “Adicionar acionador”.
- Na caixa “Trigger configuration” que aparece, selecione “DynamoDB” no menu suspenso “Trigger”.
- Selecione a tabela do DynamoDB que deseja usar para acionar a função. Depois de concluído, escolha se deseja que a função seja acionada em todas as atualizações da tabela ou apenas em atualizações específicas (como atualizações em colunas específicas).
- Clique no botão 'Adicionar' para criar o gatilho.
- No editor “Código de função”, escreva o código Python para sua função. Você pode usar o objeto de evento passado para sua função para acessar os dados que acionam a função.
- Clique no botão “Salvar” para salvar a função.
Isso é tudo o que acontece ao criar uma função Lambda! Sua função agora é acionada sempre que houver atualizações na tabela especificada do DynamoDB.
Aqui está um exemplo de uma função Python simples que o fluxo do DynamoDB pode acionar:
def lambda_handler(evento, contexto):para registro no evento[ 'Registros' ]:
imprimir(gravar[ 'dynamodb' ][ 'Nova imagem' ])
Essa função itera pelos registros no objeto de evento e imprime a nova imagem do item na tabela do DynamoDB que aciona a função.
Etapa 5: testar a função Lambda
Para testar uma função do Lambda que um stream do DynamoDB pode acionar, você pode usar o boto3 biblioteca para acessar a API do DynamoDB e o invocar método do lambda cliente para acionar a função.
Aqui está um exemplo de como fazer:
importar boto3# Conecte-se ao serviço DynamoDB
dynamodb = boto3.client( 'dynamodb' )
# Conecte-se ao serviço Lambda
lambda_client = boto3.client( 'lambda' )
# Insere um item na tabela 'my-table'
resposta = dynamodb.put_item(
TableName= 'minha mesa' ,
Item={
'Eu iria' :{ 'N' : '123' },
'nome' :{ 'S' : 'Joel Austin},
' era ':{' N ':' 3. 4 '}
}
)
# Verifique a resposta para garantir que o item foi inserido com sucesso
se resposta[' RespostaMetadados '][' HTTPStatusCode '] == 200:
print('Item inserido com sucesso')
outro:
print('Erro ao inserir item')
# Acionar a função Lambda que está inscrita no ' minha mesa ' tabela
resposta = lambda_client.invoke(
Function,
Tipo de Invocação=' Evento ',
LogType=' Cauda ',
Carga =' { 'Registros' :[{ 'dinamodb' :{ 'Nova imagem' :{ 'Eu iria' :{ 'N' : '123' }, 'nome' :{ 'S' : 'Joel Austin' }, 'era' :{ 'N' : '3.4' }}}}]} '
)
# Verifique a resposta para garantir que a função foi acionada com sucesso
se resposta[' Código de status '] == 202:
print('Função Lambda acionada com sucesso')
outro:
print('Erro ao acionar a função Lambda')
Este código primeiro insere um item no minha mesa tabela e, em seguida, aciona o minha função Função Lambda enviando uma carga útil de evento de amostra para a função usando o método invocar método. A carga do evento simula um evento de fluxo do DynamoDB que inclui a nova imagem do item que acabou de ser inserido.
Você pode então verificar os logs da função Lambda para ver se ela acionou e processou com sucesso os dados do evento.
Conclusão
É vital observar que você pode invocar várias vezes para o mesmo registro de fluxo que um fluxo do DynamoDB pode acionar uma função do Lambda. A principal razão por trás disso é que os registros de fluxo são eventualmente consistentes e é possível processar o mesmo registro várias vezes pela função Lambda. É crucial projetar sua função Lambda para lidar com esse caso corretamente.