# Criação de uma aplicação para executar uma manutenção agendada no banco de dados
<a name="scheduled-task-app"></a>

É 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.

![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/ExampleApps/cron_app.png)


**dica**  
Caso você seja iniciante no Lambda, recomendamos que conclua o tutorial [Criar sua primeira função do Lambda](getting-started.md) 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 Console de gerenciamento da AWS. Também é possível 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)](foundation-iac.md).

## Pré-requisitos
<a name="scheduled-task-app-prereqs"></a>

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](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) 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 para 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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 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](https://docs.docker.com/engine/install/) no site de documentação do Docker.

## Baixar os arquivos da aplicação de exemplo
<a name="scheduled-task-app-download"></a>

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.

### Modelo do AWS SAM (exemplo de tabela do DynamoDB)
<a name="scheduled-task-app-table-yaml"></a>

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.Arn
```

**nota**  
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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html), 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](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) no *Guia do usuário do AWS CloudFormation*.

### Arquivo de dados do banco de dados de amostra
<a name="scheduled-task-app-csv-file"></a>

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).

### Script em Python para carregar dados de amostra
<a name="scheduled-task-app-load-script"></a>

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 para 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.

### Código de função em Python
<a name="scheduled-task-app-function-code"></a>

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](python-handler.md) (`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 para 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.

### Arquivo de manifesto `requirements.txt`
<a name="scheduled-task-app-dependencies"></a>

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](python-package.md#python-package-dependencies).

### Modelo do AWS SAM (aplicação de manutenção agendada)
<a name="scheduled-task-app-table-yaml"></a>

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.Arn
```

**nota**  
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](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-schedulev2.html) 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.

### Script de teste
<a name="scheduled-task-app-test-script"></a>

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 para 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
<a name="scheduled-task-app-create-table"></a>

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 Console de gerenciamento da AWS ou usando o AWS SAM. Recomendamos o uso do AWS SAM para criar e configurar a tabela rapidamente usando alguns comandos da AWS CLI.

------
#### [ Console ]

**Para criar uma tabela do DynamoDB**

1. Abra a [página Tables (Tabelas) no console do DynamoDB](https://console.aws.amazon.com/dynamodbv2/home#tables).

1. Escolha **Criar tabela**.

1. Para criar a tabela, faça o seguinte:

   1. Em **Detalhes da tabela**, no campo **Nome da tabela**, insira **MyOrderTable**.

   1. Em **Chave de partição**, insira **Order\$1number** e mantenha o tipo definido como **String**.

   1. Em **Chave de classificação**, insira **Date** e mantenha o tipo definido como **String**.

   1. Mantenha as **Configurações da tabela** em **Configurações padrão** e selecione **Criar tabela**.

1. 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.

   1. Escolha **MyOrderTable** na lista de tabelas.

   1. Selecione a guia **Índices**.

   1. Em **Índices secundários globais**, escolha **Criar índice**.

   1. Em **Detalhes do índice**, insira **Date** a **chave de partição** e deixe o **Tipo de dados** definido como **String**.

   1. Em **Nome do índice**, insira **Date-index**.

   1. Mantenha todos os outros parâmetros com os valores padrão definidos, role até o final da página e selecione **Criar índice**.

------
#### [ AWS SAM ]

**Para criar uma tabela do DynamoDB**

1. Acesse a pasta em que você salvou o arquivo `template.yaml` para a tabela do DynamoDB. Lembre-se de que este exemplo utiliza dois arquivos `template.yaml`. Verifique se os arquivos estão salvos em subpastas separadas e se você está na pasta correta que contém o modelo para criar a tabela do DynamoDB.

1. Execute o comando a seguir.

   ```
   sam build
   ```

   Este comando reúne os artefatos de compilação para os recursos que você deseja implantar e os organiza no formato e no local apropriados para a implantação.

1. Para criar o recurso do DynamoDB especificado no arquivo `template.yaml`, execute o comando apresentado a seguir.

   ```
   sam deploy --guided
   ```

   Usar o sinalizador `--guided` significa que o AWS SAM mostrará instruções para guiar você no processo de implantação. Para essa implantação, insira **cron-app-test-db** como `Stack name` e, em seguida, pressione Enter para aceitar os valores padrão para todas as outras opções.

   Quando o AWS SAM concluir a criação do recurso do DynamoDB, a mensagem apresentada a seguir deverá ser visualizada.

   ```
   Successfully created/updated stack - cron-app-test-db in us-west-2
   ```

1. Além disso, é possível confirmar se a tabela do DynamoDB foi criada ao abrir a página de [Tabelas](https://console.aws.amazon.com/dynamodbv2/home#tables) no console do DynamoDB. Você deverá ver uma tabela chamada `MyOrderTable`.

------

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**

1. Acesse o diretório que contém os arquivos `sample_data.csv` e `load_sample_data.py`. Se esses arquivos estiverem em diretórios separados, mova-os para que fiquem salvos no mesmo local.

1. 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 para Python (Boto3).

   ```
   python -m venv venv
   ```

1. Ative o ambiente virtual ao executar o comando apresentado a seguir.

   ```
   source venv/bin/activate
   ```

1. 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
   ```

1. Execute o script para preencher a tabela ao executar o comando apresentado a seguir.

   ```
   python load_sample_data.py
   ```

   Se o script for executado com êxito, cada item será exibido no console à medida que for carregado, seguido da mensagem `Data loading completed`.

1. Desative o ambiente virtual ao executar o comando apresentado a seguir.

   ```
   deactivate
   ```

1. É possível verificar se os dados foram carregados na sua tabela do DynamoDB ao seguir estas etapas:

   1. Abra a página [Explorar itens](https://console.aws.amazon.com/dynamodbv2/home#item-explorer) no console do DynamoDB e selecione sua tabela (`MyOrderTable`).

   1. 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
<a name="scheduled-task-app-create-app"></a>

É possível criar e implantar os recursos desta aplicação de exemplo, etapa por etapa, ao usar o Console de gerenciamento da AWS 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.

------
#### [ Console ]

**Para criar a função usando o Console de gerenciamento da AWS**

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 essa tarefa, recomendamos copiar e colar o código.

1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Escolha **Create function** (Criar função).

1. Escolha **Author from scratch** (Criar do zero).

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

   1. Em **Function name** (Nome da função), insira `ScheduledDBMaintenance`.

   1. Em **Runtime**, escolha a versão mais recente do Python.

   1. Em **Architecture** (Arquitetura), escolha **x86\$164**.

1. Escolha a opção **Criar função**.

1. Após a criação da função, você pode configurá-la com o código da função fornecido.

   1. 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.py` que você salvou anteriormente.

   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)

**Para configurar a memória e o tempo limite da função (console)**

1. Selecione a guia **Configuração** para a função.

1. No painel **Configuração geral**, escolha **Editar**.

1. 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.

1. 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](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

1. Selecione a guia **Configuração** para a função.

1. Na barra lateral, selecione **Ferramentas de monitoramento e operações**.

1. No painel **Configuração de registro em log**, escolha **Editar**.

1. Em **Configuração do registro em log**, selecione **JSON**.

1. 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](lambda-intro-execution-role.md) da função, definindo as permissões necessárias.

1. Abra a guia **Configuração** e, em seguida, escolha **Permissões** na barra de navegação esquerda.

1. Escolha o nome do perfil em **Perfil de execução**.

1. No console do IAM, clique em **Adicionar permissões** e, em seguida, em **Criar política em linha**.

1. 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"
           }
       ]
   }
   ```

1. Nomeie a política como **DynamoDBCleanupPolicy** e, em seguida, crie-a.

**Para configurar o Agendador EventBridge como um acionador (console)**

1. Abra o [console do EventBridge](https://console.aws.amazon.com/events/home).

1. No painel de navegação à esquerda, escolha **Agendadores** na seção **Agendador**.

1. Clique em **Criar programação**.

1. Configure o agendamento da seguinte forma:

   1. No campo **Nome do agendamento**, digite um nome para seu agendamento (por exemplo, **DynamoDBCleanupSchedule**).

   1. Em **Padrão de agendamento**, selecione **Agendamento recorrente**.

   1. Em **Tipo de agendamento**, mantenha o padrão como **Agendamento baseado em cron** e, em seguida, insira os seguintes detalhes do agendamento:
      + **Minutos**: **0**
      + **Horas**: **3**
      + **Dia do mês**: **1**
      + **Mês**: **\$1**
      + **Dia da semana**: **?**
      + **Ano**: **\$1**

      Quando avaliada, esta expressão cron é executada no primeiro dia de cada mês às 3h da manhã.

   1. Em **Janela de tempo flexível**, selecione **Desativado**.

1. Escolha **Próximo**.

1. Configure o acionamento para sua função do Lambda da seguinte maneira:

   1. No painel **Detalhes do destino**, mantenha a **API de destino** definida como **Destinos modelados** e, em seguida, selecione **Invocar AWS Lambda**.

   1. Em **Invocar**, selecione a função do Lambda (`ScheduledDBMaintenance`) na lista suspensa.

   1. Mantenha a **Carga útil** vazia e escolha **Próximo**.

   1. 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](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html#cron-based) no *Guia do usuário do Agendador do EventBridge*.

   1. Escolha **Próximo**.

1. Analise suas configurações e escolha **Criar agendamento** para finalizar a criação do agendamento e do acionador do Lambda.

------
#### [ AWS SAM ]

**Para implantar a aplicação usando o AWS SAM**

1. Acesse a pasta em que você salvou o arquivo `template.yaml` da aplicação. Lembre-se de que este exemplo utiliza dois arquivos `template.yaml`. Verifique se os arquivos estão salvos em subpastas separadas e se você está na pasta correta que contém o modelo para criar a aplicação.

1. Copie os arquivos `lambda_function.py` e `requirements.txt`, que você efetuou o download anteriormente, para a mesma pasta. O local do código especificado no modelo do AWS SAM é `./`, o que significa o diretório atual. O AWS SAM pesquisará nesta pasta o código da função do Lambda quando você tentar implantar a aplicação.

1. Execute o comando a seguir.

   ```
   sam build --use-container
   ```

   Este comando reúne os artefatos de compilação para os recursos que você deseja implantar e os organiza no formato e no local apropriados para a implantação. Especificar a opção `--use-container` compila a função dentro de um contêiner do Docker semelhante ao Lambda. Nós o usamos aqui para que você não precise ter o Python 3.12 instalado na máquina local para que a compilação funcione.

1. Para criar os recursos do Lambda e do Agendador do EventBridge especificados no arquivo `template.yaml`, execute o comando apresentado a seguir.

   ```
   sam deploy --guided
   ```

   Usar o sinalizador `--guided` significa que o AWS SAM mostrará instruções para guiar você no processo de implantação. Para essa implantação, insira **cron-maintenance-app** como `Stack name` e, em seguida, pressione Enter para aceitar os valores padrão para todas as outras opções.

   Quando o AWS SAM concluir a criação dos recursos do Lambda e do Agendador do EventBridge, a mensagem apresentada a seguir deverá ser visualizada.

   ```
   Successfully created/updated stack - cron-maintenance-app in us-west-2
   ```

1. Além disso, é possível confirmar que a função do Lambda foi criada ao abrir a página [Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. Você deverá visualizar uma função chamada `ScheduledDBMaintenance`.

------

## Testando a aplicação
<a name="scheduled-task-app-test-app"></a>

 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 Console de gerenciamento da AWS**

1. Retorne à página do console do Agendador do EventBridge.

1. Escolha seu agendamento e, em seguida, selecione **Editar**.

1. Na seção **Padrão de agendamento**, em **Recorrência**, escolha **Agendamento único**.

1.  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**

1.  Na linha de comando, navegue até a pasta em que você salvou `test_app.py`. 

1. Executar o script.

   ```
   python test_app.py
   ```

    Se a execução ocorrer com êxito, a saída apresentada a seguir será exibida. 

   ```
   Total number of old records: 0
   ```

## Próximas etapas
<a name="scheduled-task-app-next-steps"></a>

 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](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html) no *Guia do usuário do Agendador do EventBridge*. [Gerenciamento de acesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) no *Guia do usuário do IAM*