É possível usar o AWS Lambda para substituir processos agendados, como backups automáticos do sistema, conversões de arquivos e tarefas de manutenção. Neste exemplo, você criará uma aplicação com tecnologia sem servidor que realiza uma manutenção agendada em uma tabela do DynamoDB ao excluir entradas antigas. A aplicação usa o Agendador do EventBridge para invocar uma função do Lambda com um agendamento cron. Quando invocada, a função consulta a tabela em busca de itens com mais de um ano e os exclui. A função registra em log cada item excluído no CloudWatch Logs.
Para realizar a implementação deste exemplo, primeiro crie uma tabela do DynamoDB e a preencha com dados de teste que a função consultará. Em seguida, crie uma função do Lambda em Python com um acionador do Agendador do EventBridge e um perfil de execução do IAM que conceda à função permissão para ler e excluir itens da tabela.
dica
Caso você seja iniciante no Lambda, recomendamos que conclua o tutorial Criar sua primeira função do Lambda antes de realizar a criação desta aplicação de exemplo.
É possível implantar a aplicação manualmente ao criar e ao configurar recursos com o AWS Management Console. Você também pode implantar a aplicação usando o AWS Serverless Application Model (AWS SAM). O AWS SAM é uma ferramenta de infraestrutura como código (IaC). Usando IaC, você não cria os recursos manualmente, mas os define no código e depois os implanta automaticamente.
Se você quiser saber mais sobre como usar o Lambda com IaC antes de implantar esta aplicação de exemplo, consulte Usar o Lambda com a infraestrutura como código (IaC).
Pré-requisitos
Antes de criar a aplicação de exemplo, certifique-se de que as ferramentas de linha de comando e os programas necessários estejam instalados.
-
Python
Para preencher a tabela do DynamoDB que você cria para testar a aplicação, este exemplo usa um script em Python e um arquivo CSV para gravar os dados na tabela. Certifique-se de que você tenha o Python na versão 3.8, ou em versões superiores, instalado em sua máquina.
-
AWS SAM CLI
Se você deseja criar a tabela do DynamoDB e implantar a aplicação de exemplo usando o AWS SAM, é necessário instalar a CLI do AWS SAM. Siga as instruções de instalação apresentadas no Guia do usuário do AWS SAM.
-
AWS CLI
Para usar o script em Python fornecido para preencher a tabela de teste, é necessário ter a AWS CLI instalada e configurada. Isso ocorre porque o script usa o AWS SDK for Python (Boto3), que precisa acessar as credenciais do AWS Identity and Access Management (IAM). Além disso, a AWS CLI deve estar instalada para que você possa implantar recursos usando o AWS SAM. Instale a CLI seguindo as instruções de instalação apresentadas no Guia do usuário da AWS Command Line Interface.
-
Docker
Para realizar a implantação da aplicação usando o AWS SAM, também é necessário que o Docker esteja instalado na sua máquina de compilação. Siga as instruções apresentadas em Install Docker Engine
no site de documentação do Docker.
Baixar os arquivos da aplicação de exemplo
Para criar o banco de dados de exemplo e a aplicação de manutenção agendada, é necessário criar os seguintes arquivos em seu diretório de projeto:
Exemplos de arquivos de banco de dados
-
template.yaml: um modelo do AWS SAM que pode ser usado para criar a tabela do DynamoDB -
sample_data.csv: um arquivo CSV que contém dados de amostra para serem carregados em sua tabela -
load_sample_data.py: um script em Python que grava os dados do arquivo CSV na tabela
Arquivos da aplicação de manutenção agendada
-
lambda_function.py: o código da função em Python para a função do Lambda que executa a manutenção do banco de dados -
requirements.txt: um arquivo de manifesto que define as dependências que o código de função em Python exige -
template.yaml: um modelo do AWS SAM que você pode usar para implantar a aplicação
Arquivo de teste
-
test_app.py: um script em Python que faz a verificação da tabela e confirma o funcionamento correto da sua função ao listar todos os registros com mais de um ano
Expanda as seções a seguir para visualizar o código e saber mais sobre o papel de cada arquivo na criação e no teste da aplicação. Para criar os arquivos em sua máquina local, copie e cole o código apresentado abaixo.
Copie e cole o código a seguir em um novo arquivo denominado template.yaml.
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for DynamoDB Table with Order_number as Partition Key and Date as Sort Key
Resources:
MyDynamoDBTable:
Type: AWS::DynamoDB::Table
DeletionPolicy: Retain
UpdateReplacePolicy: Retain
Properties:
TableName: MyOrderTable
BillingMode: PAY_PER_REQUEST
AttributeDefinitions:
- AttributeName: Order_number
AttributeType: S
- AttributeName: Date
AttributeType: S
KeySchema:
- AttributeName: Order_number
KeyType: HASH
- AttributeName: Date
KeyType: RANGE
SSESpecification:
SSEEnabled: true
GlobalSecondaryIndexes:
- IndexName: Date-index
KeySchema:
- AttributeName: Date
KeyType: HASH
Projection:
ProjectionType: ALL
PointInTimeRecoverySpecification:
PointInTimeRecoveryEnabled: true
Outputs:
TableName:
Description: DynamoDB Table Name
Value: !Ref MyDynamoDBTable
TableArn:
Description: DynamoDB Table ARN
Value: !GetAtt MyDynamoDBTable.Arnnota
Os modelos do AWS SAM usam uma convenção de nomenclatura padrão, que é template.yaml. Neste exemplo, você terá dois arquivos de modelo: um para criar o banco de dados de exemplo e outro para criar a aplicação em si. Salve-os em subdiretórios separados na pasta de projeto.
Este modelo do AWS SAM define o recurso da tabela do DynamoDB que você cria para testar a aplicação. A tabela usa uma chave primária, chamada Order_number, com uma chave de classificação, chamada Date. Para que a função do Lambda localize itens diretamente pela data, também definimos um índice secundário global, chamado Date-index.
Para saber mais sobre como criar e configurar uma tabela do DynamoDB usando o recurso AWS::DynamoDB::Table, consulte AWS::DynamoDB::Table no Guia do usuário do AWS CloudFormation.
Copie e cole o código a seguir em um novo arquivo denominado sample_data.csv.
Date,Order_number,CustomerName,ProductID,Quantity,TotalAmount 2023-09-01,ORD001,Alejandro Rosalez,PROD123,2,199.98 2023-09-01,ORD002,Akua Mansa,PROD456,1,49.99 2023-09-02,ORD003,Ana Carolina Silva,PROD789,3,149.97 2023-09-03,ORD004,Arnav Desai,PROD123,1,99.99 2023-10-01,ORD005,Carlos Salazar,PROD456,2,99.98 2023-10-02,ORD006,Diego Ramirez,PROD789,1,49.99 2023-10-03,ORD007,Efua Owusu,PROD123,4,399.96 2023-10-04,ORD008,John Stiles,PROD456,2,99.98 2023-10-05,ORD009,Jorge Souza,PROD789,3,149.97 2023-10-06,ORD010,Kwaku Mensah,PROD123,1,99.99 2023-11-01,ORD011,Li Juan,PROD456,5,249.95 2023-11-02,ORD012,Marcia Oliveria,PROD789,2,99.98 2023-11-03,ORD013,Maria Garcia,PROD123,3,299.97 2023-11-04,ORD014,Martha Rivera,PROD456,1,49.99 2023-11-05,ORD015,Mary Major,PROD789,4,199.96 2023-12-01,ORD016,Mateo Jackson,PROD123,2,199.99 2023-12-02,ORD017,Nikki Wolf,PROD456,3,149.97 2023-12-03,ORD018,Pat Candella,PROD789,1,49.99 2023-12-04,ORD019,Paulo Santos,PROD123,5,499.95 2023-12-05,ORD020,Richard Roe,PROD456,2,99.98 2024-01-01,ORD021,Saanvi Sarkar,PROD789,3,149.97 2024-01-02,ORD022,Shirley Rodriguez,PROD123,1,99.99 2024-01-03,ORD023,Sofia Martinez,PROD456,4,199.96 2024-01-04,ORD024,Terry Whitlock,PROD789,2,99.98 2024-01-05,ORD025,Wang Xiulan,PROD123,3,299.97
Este arquivo contém alguns dados de teste de exemplo para preencher a tabela do DynamoDB em um formato padrão de valores separados por vírgula (CSV).
Copie e cole o código a seguir em um novo arquivo denominado load_sample_data.py.
import boto3
import csv
from decimal import Decimal
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyOrderTable')
print("DDB client initialized.")
def load_data_from_csv(filename):
with open(filename, 'r') as file:
csv_reader = csv.DictReader(file)
for row in csv_reader:
item = {
'Order_number': row['Order_number'],
'Date': row['Date'],
'CustomerName': row['CustomerName'],
'ProductID': row['ProductID'],
'Quantity': int(row['Quantity']),
'TotalAmount': Decimal(str(row['TotalAmount']))
}
table.put_item(Item=item)
print(f"Added item: {item['Order_number']} - {item['Date']}")
if __name__ == "__main__":
load_data_from_csv('sample_data.csv')
print("Data loading completed.")Primeiro, este script em Python usa o AWS SDK for Python (Boto3) para criar uma conexão com a tabela do DynamoDB. Em seguida, ele itera sobre cada linha no arquivo CSV de dados de exemplo, cria um item usando essa linha e grava o item na tabela do DynamoDB usando o SDK para Boto3.
Copie e cole o código a seguir em um novo arquivo denominado lambda_function.py.
import boto3
from datetime import datetime, timedelta
from boto3.dynamodb.conditions import Key, Attr
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
def lambda_handler(event, context):
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
# Specify the table name
table_name = 'MyOrderTable'
table = dynamodb.Table(table_name)
# Get today's date
today = datetime.now()
# Calculate the date one year ago
one_year_ago = (today - timedelta(days=365)).strftime('%Y-%m-%d')
# Scan the table using a global secondary index
response = table.scan(
IndexName='Date-index',
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago
}
)
# Delete old items
with table.batch_writer() as batch:
for item in response['Items']:
Order_number = item['Order_number']
batch.delete_item(
Key={
'Order_number': Order_number,
'Date': item['Date']
}
)
logger.info(f'deleted order number {Order_number}')
# Check if there are more items to scan
while 'LastEvaluatedKey' in response:
response = table.scan(
IndexName='DateIndex',
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago
},
ExclusiveStartKey=response['LastEvaluatedKey']
)
# Delete old items
with table.batch_writer() as batch:
for item in response['Items']:
batch.delete_item(
Key={
'Order_number': item['Order_number'],
'Date': item['Date']
}
)
return {
'statusCode': 200,
'body': 'Cleanup completed successfully'
}O código da função em Python contém a função do manipulador (lambda_handler) que o Lambda executa quando a função é invocada.
Quando a função é invocada pelo Agendador do EventBridge, ela usa o AWS SDK for Python (Boto3) para criar uma conexão com a tabela do DynamoDB na qual a tarefa de manutenção agendada será executada. Em seguida, a função usa a biblioteca datetime do Python para calcular a data de um ano atrás, antes de realizar a verificação da tabela em busca de itens mais antigos e excluí-los.
Lembre-se de que as respostas das operações de consulta e de verificação do DynamoDB são limitadas a um tamanho máximo de 1 MB. Se a resposta for maior que 1 MB, o DynamoDB fará a paginação dos dados e retornará um elemento LastEvaluatedKey na resposta. Para garantir que nossa função processe todos os registros apresentados na tabela, verificamos a presença dessa chave e continuamos executando verificações na tabela a partir da última posição avaliada até que toda a tabela tenha sido verificada.
Copie e cole o código a seguir em um novo arquivo denominado requirements.txt.
boto3
Neste exemplo, o código da função tem somente uma dependência que não faz parte da biblioteca padrão do Python, o SDK para Python (Boto3), que a função usa para realizar verificações e excluir itens da tabela do DynamoDB.
nota
Uma versão do SDK para Python (Boto3) está incluída como parte do runtime do Lambda, portanto, o código seria executado sem adicionar o Boto3 ao pacote de implantação da função. Porém, para manter total controle das dependências da função e evitar possíveis problemas de desalinhamento de versões, a prática recomendada para o Python é incluir todas as dependências da função no pacote de implantação da função. Para saber mais, consulte Dependências de runtime em Python.
Copie e cole o código a seguir em um novo arquivo denominado template.yaml.
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for Lambda function and EventBridge Scheduler rule
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: ScheduledDBMaintenance
CodeUri: ./
Handler: lambda_function.lambda_handler
Runtime: python3.11
Architectures:
- x86_64
Events:
ScheduleEvent:
Type: ScheduleV2
Properties:
ScheduleExpression: cron(0 3 1 * ? *)
Description: Run on the first day of every month at 03:00 AM
Policies:
- CloudWatchLogsFullAccess
- Statement:
- Effect: Allow
Action:
- dynamodb:Scan
- dynamodb:BatchWriteItem
Resource: !Sub 'arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/MyOrderTable'
LambdaLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub /aws/lambda/${MyLambdaFunction}
RetentionInDays: 30
Outputs:
LambdaFunctionName:
Description: Lambda Function Name
Value: !Ref MyLambdaFunction
LambdaFunctionArn:
Description: Lambda Function ARN
Value: !GetAtt MyLambdaFunction.Arnnota
Os modelos do AWS SAM usam uma convenção de nomenclatura padrão, que é template.yaml. Neste exemplo, você terá dois arquivos de modelo: um para criar o banco de dados de exemplo e outro para criar a aplicação em si. Salve-os em subdiretórios separados na pasta de projeto.
Este modelo do AWS SAM define os recursos para a aplicação. A função do Lambda é definida usando o recurso AWS::Serverless::Function. O agendamento do Agendador do EventBridge e o acionador para invocar a função do Lambda são criados ao usar a propriedade Events desse recurso, com o tipo ScheduleV2. Para saber mais informações sobre como definir agendamentos do Agendador do EventBridge em modelos do AWS SAM, consulte ScheduleV2 no Guia do desenvolvedor do AWS Serverless Application Model.
Além da função do Lambda e do agendamento do Agendador do EventBridge, também definimos um grupo de logs do CloudWatch para que a função envie registros dos itens excluídos.
Copie e cole o código a seguir em um novo arquivo denominado test_app.py.
import boto3
from datetime import datetime, timedelta
import json
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
# Specify your table name
table_name = 'YourTableName'
table = dynamodb.Table(table_name)
# Get the current date
current_date = datetime.now()
# Calculate the date one year ago
one_year_ago = current_date - timedelta(days=365)
# Convert the date to string format (assuming the date in DynamoDB is stored as a string)
one_year_ago_str = one_year_ago.strftime('%Y-%m-%d')
# Scan the table
response = table.scan(
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago_str
}
)
# Process the results
old_records = response['Items']
# Continue scanning if we have more items (pagination)
while 'LastEvaluatedKey' in response:
response = table.scan(
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago_str
},
ExclusiveStartKey=response['LastEvaluatedKey']
)
old_records.extend(response['Items'])
for record in old_records:
print(json.dumps(record))
# The total number of old records should be zero.
print(f"Total number of old records: {len(old_records)}")
Este script de teste usa o AWS SDK for Python (Boto3) para criar uma conexão com a tabela do DynamoDB e realizar a verificação de itens com mais de um ano. Para confirmar se a função do Lambda foi executada com êxito, ao final do teste, solicite que a função realize a impressão do número de registros com mais de um ano ainda presentes na tabela. Se a função do Lambda obteve êxito, o número de registros antigos na tabela deverá ser zero.
Criação e preenchimento da tabela de exemplo do DynamoDB
Para testar a aplicação de manutenção agendada, primeiro, crie uma tabela do DynamoDB e preencha-a com alguns dados de amostra. É possível criar a tabela manualmente usando o AWS Management Console ou usando o AWS SAM. Recomendamos o uso do AWS SAM para criar e configurar a tabela rapidamente usando alguns comandos da AWS CLI.
Para criar uma tabela do DynamoDB
-
Escolha Create table.
-
Para criar a tabela, faça o seguinte:
-
Em Detalhes da tabela, no campo Nome da tabela, insira
MyOrderTable. -
Em Chave de partição, insira
Order_numbere mantenha o tipo definido como String. -
Em Chave de classificação, insira
Datee mantenha o tipo definido como String. -
Mantenha as Configurações da tabela em Configurações padrão e selecione Criar tabela.
-
-
Assim que a criação da tabela for concluída e o Status estiver sendo mostrado como Ativa, crie um índice secundário global (GSI) conforme as etapas apresentadas a seguir. A aplicação usará esse GSI para pesquisar itens diretamente pela data e determinar quais devem ser excluídos.
-
Escolha MyOrderTable na lista de tabelas.
-
Selecione a guia Índices.
-
Em Índices secundários globais, escolha Criar índice.
-
Em Detalhes do índice, insira
Datea chave de partição e deixe o Tipo de dados definido como String. -
Em Nome do índice, insira
Date-index. -
Mantenha todos os outros parâmetros com os valores padrão definidos, role até o final da página e selecione Criar índice.
-
Após criar a tabela, adicione alguns dados de amostra para testar a aplicação. O arquivo CSV sample_data.csv, que você efetuou o download anteriormente, contém várias entradas de exemplo, compostas por números de pedidos, datas, informações de clientes e de pedidos. Use o script em Python fornecido, load_sample_data.py, para adicionar esses dados à sua tabela.
Para adicionar os dados de amostra à tabela
-
Acesse o diretório que contém os arquivos
sample_data.csveload_sample_data.py. Se esses arquivos estiverem em diretórios separados, mova-os para que fiquem salvos no mesmo local. -
Crie um ambiente virtual para Python a fim de executar o script ao executar o comando apresentado a seguir. Recomendamos o uso de um ambiente virtual, pois em uma etapa posterior será necessário instalar o AWS SDK for Python (Boto3).
python -m venv venv -
Ative o ambiente virtual ao executar o comando apresentado a seguir.
source venv/bin/activate -
Instale o SDK para Python (Boto3) no ambiente virtual ao executar o comando apresentado abaixo. O script usa essa biblioteca para se conectar à sua tabela do DynamoDB e adicionar os itens.
pip install boto3 -
Execute o script para preencher a tabela ao executar o comando apresentado a seguir.
python load_sample_data.pySe o script for executado com êxito, cada item será exibido no console à medida que for carregado, seguido da mensagem
Data loading completed. -
Desative o ambiente virtual ao executar o comando apresentado a seguir.
deactivate -
É possível verificar se os dados foram carregados na sua tabela do DynamoDB ao seguir estas etapas:
-
Abra a página Explorar itens
no console do DynamoDB e selecione sua tabela ( MyOrderTable). -
No painel Itens retornados, você deverá visualizar os 25 itens do arquivo CSV que o script adicionou à tabela.
-
Criação da aplicação de manutenção agendada
É possível criar e implantar os recursos desta aplicação de exemplo, etapa por etapa, ao usar o AWS Management Console ou o AWS SAM. Em um ambiente de produção, recomendamos o uso de uma ferramenta de infraestrutura como código (IaC), como o AWS SAM, para implantar repetidamente aplicações com tecnologia sem servidor sem a necessidade de processos manuais.
Para este exemplo, siga as instruções no console para aprender a configurar cada recurso da AWS separadamente, ou siga as instruções do AWS SAM para implantar rapidamente a aplicação usando comandos da AWS CLI.
Para criar a função usando o AWS Management Console
Primeiro, crie uma função que contenha um código inicial básico. Em seguida, substitua esse código pelo seu próprio código de função ao copiá-lo e colá-lo diretamente no editor de código do Lambda ou ao fazer o upload do código como um pacote .zip. Para esta tarefa, recomendamos simplesmente copiar e colar o código.
-
Abra a página Funções
do console do Lambda. -
Escolha Create function (Criar função).
-
Escolha Author from scratch (Criar do zero).
-
Em Basic information (Informações básicas), faça o seguinte:
-
Em Function name (Nome da função), insira
ScheduledDBMaintenance -
Em Runtime, escolha a versão mais recente do Python.
-
Em Architecture (Arquitetura), escolha x86_64.
-
-
Escolha a opção Criar função.
-
Após a criação da função, você pode configurá-la com o código da função fornecido.
-
No painel Origem do código, substitua o código Hello world criado pelo Lambda com o código da função em Python do arquivo
lambda_function.pyque você salvou anteriormente. -
Na seção DEPLOY, escolha Implantar para atualizar o código da função:
-
Para configurar a memória e o tempo limite da função (console)
-
Selecione a guia Configuração para a função.
-
No painel Configuração geral, escolha Editar.
-
Defina Memória como 256 MB e Tempo limite como 15 segundos. Se você estiver processando uma tabela extensa que contém muitos registros, por exemplo, em um ambiente de produção, pode ser útil definir o Tempo limite para um número maior. Isso permitirá que sua função tenha mais tempo para realizar a verificação e a limpeza do banco de dados.
-
Escolha Salvar.
Para configurar o formato de log (console)
É possível configurar as funções do Lambda para gerar logs em formato de texto não estruturado ou em JSON. Recomendamos o uso do formato JSON para logs, pois facilita a busca e a filtragem dos dados de log. Para saber mais sobre as opções de configuração de logs do Lambda, consulte Configurar controles avançados de registro em log para funções do Lambda.
-
Selecione a guia Configuração para a função.
-
Na barra lateral, selecione Ferramentas de monitoramento e operações.
-
No painel Configuração de registro em log, escolha Editar.
-
Em Configuração do registro em log, selecione JSON.
-
Escolha Salvar.
Para configurar as permissões do IAM
Para conceder à função as permissões necessárias para ler e excluir itens do DynamoDB, você deve adicionar uma política ao perfil de execução da função, definindo as permissões necessárias.
-
Abra a guia Configuração e, em seguida, escolha Permissões na barra de navegação esquerda.
-
Escolha o nome do perfil em Perfil de execução.
-
No console do IAM, clique em Adicionar permissões e, em seguida, em Criar política em linha.
-
Use o editor para JSON e insira a seguinte política:
{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "dynamodb:Scan", "dynamodb:DeleteItem", "dynamodb:BatchWriteItem" ], "Resource": "arn:aws:dynamodb:*:*:table/MyOrderTable" } ] } -
Nomeie a política como
DynamoDBCleanupPolicye, em seguida, crie-a.
Para configurar o Agendador EventBridge como um acionador (console)
-
Abra o console do EventBridge
. -
No painel de navegação à esquerda, escolha Agendadores na seção Agendador.
-
Clique em Criar programação.
-
Configure o agendamento da seguinte forma:
-
No campo Nome do agendamento, digite um nome para seu agendamento (por exemplo,
DynamoDBCleanupSchedule). -
Em Padrão de agendamento, selecione Agendamento recorrente.
-
Em Tipo de agendamento, mantenha o padrão como Agendamento baseado em cron e, em seguida, insira os seguintes detalhes do agendamento:
Minutos:
0Horas:
3Dia do mês:
1Mês:
*Dia da semana:
?Ano:
*
Quando avaliada, esta expressão cron é executada no primeiro dia de cada mês às 3h da manhã.
-
Em Janela de tempo flexível, selecione Desativado.
-
-
Escolha Próximo.
-
Configure o acionamento para sua função do Lambda da seguinte maneira:
-
No painel Detalhes do destino, mantenha a API de destino definida como Destinos modelados e, em seguida, selecione Invocar AWS Lambda.
-
Em Invocar, selecione a função do Lambda (
ScheduledDBMaintenance) na lista suspensa. -
Mantenha a Carga útil vazia e escolha Próximo.
-
Role para baixo até a seção Permissões e selecione Criar um novo perfil para este agendamento. Ao criar um novo agendamento do Agendador do EventBridge no console, o Agendador do EventBridge gera uma nova política com as permissões exigidas para que o agendamento invoque sua função. Para obter mais informações sobre o gerenciamento de permissões do seu agendamento, consulte Cron-based schedules no Guia do usuário do Agendador do EventBridge.
-
Escolha Próximo.
-
-
Analise suas configurações e escolha Criar agendamento para finalizar a criação do agendamento e do acionador do Lambda.
Testando a aplicação
Para testar se o agendamento aciona sua função corretamente e se a função limpa os registros do banco de dados conforme o esperado, é possível modificar temporariamente o agendamento para ser executado uma vez em um horário específico. Depois, você pode executar novamente o comando sam deploy para redefinir o agendamento recorrente da execução para uma vez por mês.
Para executar a aplicação usando o AWS Management Console
-
Retorne à página do console do Agendador do EventBridge.
-
Escolha seu agendamento e, em seguida, selecione Editar.
-
Na seção Padrão de agendamento, em Recorrência, escolha Agendamento único.
-
Defina o horário de invocação para alguns minutos a partir de agora, analise suas configurações e, em seguida, selecione Salvar.
Após o agendamento ser executado e invocar o destino, execute o script test_app.py para verificar se a função removeu com êxito todos os registros antigos da tabela do DynamoDB.
Para verificar se os registros antigos foram excluídos usando um script em Python
-
Na janela da linha de comando, navegue até a pasta em que você salvou
test_app.py. -
Executar o script.
python test_app.pySe a execução ocorrer com êxito, a saída apresentada a seguir será exibida.
Total number of old records: 0
Próximas etapas
Agora, você pode modificar o agendamento do Agendador do EventBridge para atender aos requisitos específicos da sua aplicação. O Agendador do EventBridge oferece suporte para as seguintes expressões de agendamento: cron, frequência e agendamentos únicos.
Para obter mais informações sobre as expressões de agendamento do Agendador do EventBridge, consulte Tipos de agendamento no Guia do usuário do Agendador do EventBridge.
