# Creación de una aplicación para llevar a cabo el mantenimiento programado de la base de datos
<a name="scheduled-task-app"></a>

Puede utilizar AWS Lambda para reemplazar los procesos programados, como las copias de seguridad automatizadas del sistema, las conversiones de archivos y las tareas de mantenimiento. En este ejemplo, se crea una aplicación sin servidor que lleva a cabo un mantenimiento programado regular en una tabla de DynamoDB mediante la eliminación de entradas antiguas. La aplicación utiliza el Programador de EventBridge para invocar una función de Lambda según una programación cron. Cuando se invoca, la función consulta la tabla en busca de elementos con más de un año de antigüedad y los elimina. La función registra cada elemento eliminado en Registros de CloudWatch.

Para implementar este ejemplo, cree antes una tabla de DynamoDB y llénela con algunos datos de prueba para que la función los consulte. A continuación, cree una función de Lambda de Python con un desencadenador del Programador de EventBridge y un rol de ejecución de IAM que dé permiso a la función para leer y eliminar elementos de la tabla.

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


**sugerencia**  
Si es la primera vez que utiliza Lambda, recomendamos que complete el tutorial [Creación de su primera función de Lambda](getting-started.md) antes de crear esta aplicación de ejemplo.

Para implementar la aplicación manualmente, cree y configure los recursos con la Consola de administración de AWS. También puede implementar la aplicación mediante AWS Serverless Application Model (AWS SAM). AWS SAM es una herramienta de Infraestructura como código (IaC). Con la IaC no se crean recursos de forma manual, sino que se definen en código y, a continuación, se implementan automáticamente.

Si desea obtener más información sobre el uso de Lambda con la IaC antes de implementar esta aplicación de ejemplo, consulte [Uso de Lambda con la infraestructura como código (IaC)](foundation-iac.md).

## Requisitos previos
<a name="scheduled-task-app-prereqs"></a>

Antes de poder crear la aplicación de ejemplo, asegúrese de tener instaladas los programas y las herramientas de línea de comando necesarios.
+ **Python**

  Para rellenar la tabla de DynamoDB que ha creado para probar la aplicación, en este ejemplo se utiliza un script de Python y un archivo CSV para escribir datos en la tabla. Asegúrese de tener instalado en el equipo la versión 3.8 o posterior de Python.
+ **AWS SAM CLI**

  Si desea crear la tabla de DynamoDB e implementar la aplicación de ejemplo mediante AWS SAM, debe instalar la AWS SAM CLI. Siga las [instrucciones de instalación](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) en la *Guía del usuario de AWS SAM*.
+ **AWS CLI**

  Para utilizar el script de Python proporcionado para rellenar la tabla de prueba, debe tener instalada y configurada la AWS CLI. Esto se debe a que el script usa AWS SDK para Python (Boto3), que necesita acceder a sus credenciales de AWS Identity and Access Management (IAM). También necesita la AWS CLI instalada para implementar los recursos mediante AWS SAM. Para instalar la CLI, siga las [instrucciones de instalación](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) en la *Guía del usuario de AWS Command Line Interface*.
+ **Docker**

  Para implementar la aplicación con AWS SAM, Docker también debe estar instalado en la máquina de compilación. Siga las instrucciones de [Instalar Docker Engine](https://docs.docker.com/engine/install/) en el sitio web de documentación de Docker.

## Descarga de los archivos de la aplicación de ejemplo
<a name="scheduled-task-app-download"></a>

Para crear la base de datos de ejemplo y la aplicación con el mantenimiento programado, debe crear los siguientes archivos en el directorio del proyecto:

**Ejemplos de archivos de base de datos**
+ `template.yaml`: una plantilla de AWS SAM que puede utilizar para crear la tabla de DynamoDB
+ `sample_data.csv`: un archivo CSV que contiene datos de muestra para cargarlos en la tabla
+ `load_sample_data.py`: un script de Python que escribe los datos del archivo CSV en la tabla

**Archivos de la aplicación con el mantenimiento programado**
+ `lambda_function.py`: es el código de la función de Python para la función de Lambda que lleva a cabo el mantenimiento de la base de datos
+ `requirements.txt`: es un archivo de manifiesto que define las dependencias que requiere el código de la función de Python
+ `template.yaml`: es una plantilla de AWS SAM que puede usar para implementar la aplicación

**Archivo de prueba**
+ `test_app.py`: un script de Python que analiza la tabla y confirma el correcto funcionamiento de la función al generar todos los registros con más de un año de antigüedad

Expanda las siguientes secciones para ver el código y obtener más información sobre la función de cada archivo a la hora de crear y probar la aplicación. Para crear los archivos en su equipo local, copie y pegue el siguiente código.

### Plantilla de AWS SAM (ejemplo de tabla de DynamoDB)
<a name="scheduled-task-app-table-yaml"></a>

Copie y pegue el siguiente código en un archivo 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**  
Las plantillas de AWS SAM utilizan una convención de nomenclatura estándar de `template.yaml`. En este ejemplo, tiene dos archivos de plantilla: uno para crear la base de datos del ejemplo y otro para crear la propia aplicación. Guárdelos en subdirectorios separados de la carpeta del proyecto.

Esta plantilla de AWS SAM define el recurso de la tabla de DynamoDB que se crea para probar la aplicación. La tabla usa una clave principal de `Order_number` con una clave de clasificación de `Date`. Para que la función de Lambda busque los elementos directamente por fecha, también definimos un [Índice secundario global](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) denominado `Date-index`.

Para obtener más información sobre cómo crear y configurar una tabla de DynamoDB con el recurso `AWS::DynamoDB::Table`, consulte [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) en la *Guía del usuario de AWS CloudFormation*.

### Archivo de datos de base de datos de ejemplo
<a name="scheduled-task-app-csv-file"></a>

Copie y pegue el siguiente código en un archivo 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 archivo contiene algunos datos de prueba de ejemplo con los que rellenar la tabla de DynamoDB en un formato de valores separados por comas (CSV) estándar.

### Script de Python para cargar datos de muestra
<a name="scheduled-task-app-load-script"></a>

Copie y pegue el siguiente código en un archivo 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.")
```

Este script de Python utiliza primero AWS SDK para Python (Boto3) para crear una conexión con la tabla de DynamoDB. A continuación, recorre en iteración cada fila del archivo CSV de datos de ejemplo, crea un elemento a partir de esa fila y escribe el elemento en la tabla de DynamoDB mediante el SDK de Boto3.

### Código de la función de Python
<a name="scheduled-task-app-function-code"></a>

Copie y pegue el siguiente código en un archivo 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'
    }
```

El código de la función de Python contiene la [función de controlador](python-handler.md) (`lambda_handler`) que Lambda ejecuta cuando se invoca la función.

Cuando el Programador de EventBridge invoca la función, utiliza AWS SDK para Python (Boto3) para crear una conexión con la tabla de DynamoDB en la que se va a llevar a cabo la tarea de mantenimiento programada. A continuación, utiliza la biblioteca `datetime` de Python para calcular la fecha de hace un año, antes de analizar la tabla en busca de elementos anteriores a este y eliminarlos.

Tenga en cuenta que las respuestas de las operaciones de consulta y análisis de DynamoDB están limitadas a un tamaño máximo de 1 MB. Si la respuesta es superior a 1 MB, DynamoDB pagina los datos y devuelve un elemento `LastEvaluatedKey` de la respuesta. Para garantizar que nuestra función procese todos los registros de la tabla, comprobamos la presencia de esta clave y continuamos analizando la tabla desde la última posición evaluada hasta analizar toda la tabla.

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

Copie y pegue el siguiente código en un archivo denominado `requirements.txt`.

```
boto3
```

En este ejemplo, el código de la función solo tiene una dependencia que no forma parte de la biblioteca estándar de Python: el SDK para Python (Boto3) que la función utiliza para analizar y eliminar elementos de la tabla de DynamoDB.

**nota**  
Como parte del tiempo de ejecución de Lambda, se incluye una versión del SDK para Python (Boto3), de modo que el código se ejecute sin agregar Boto3 al paquete de implementación de la función. Sin embargo, para mantener el control total de las dependencias de la función y evitar posibles problemas de alineación de versiones, la práctica recomendada para Python es incluir todas las dependencias de la función en el paquete de implementación de la función. Consulte [Dependencias de tiempo de ejecución en Python](python-package.md#python-package-dependencies) para obtener más información.

### Plantilla de AWS SAM (aplicación con el mantenimiento programado)
<a name="scheduled-task-app-table-yaml"></a>

Copie y pegue el siguiente código en un archivo 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**  
Las plantillas de AWS SAM utilizan una convención de nomenclatura estándar de `template.yaml`. En este ejemplo, tiene dos archivos de plantilla: uno para crear la base de datos del ejemplo y otro para crear la propia aplicación. Guárdelos en subdirectorios separados de la carpeta del proyecto.

Esta plantilla de AWS SAM define los recursos de la aplicación. Definimos la función de Lambda con el recurso `AWS::Serverless::Function`. La programación del Programador de EventBridge y el desencadenador para invocar la función de Lambda se crean mediante la propiedad `Events` de este recurso mediante un tipo de `ScheduleV2`. Para obtener más información sobre cómo definir programaciones del Programador de EventBridge en plantillas de AWS SAM, consulte [ScheduleV2](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-schedulev2.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.

Además de la función de Lambda y la programación del Programador de EventBridge, también definimos un grupo de registros de CloudWatch para que la función envíe los registros de los elementos eliminados.

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

Copie y pegue el siguiente código en un archivo 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 prueba utiliza AWS SDK para Python (Boto3) para crear una conexión con la tabla de DynamoDB y buscar elementos con más de un año de antigüedad. Para confirmar si la función de Lambda se ha ejecutado correctamente, al final de la prueba, la función imprime el número de registros con más de un año de antigüedad que aún se encuentran en la tabla. Si la función de Lambda se ejecutó correctamente, el número de registros antiguos de la tabla debería ser cero. 

## Creación y llenado de la tabla de DynamoDB de ejemplo
<a name="scheduled-task-app-create-table"></a>

Para probar la aplicación con el mantenimiento programado, antes debe crear una tabla de DynamoDB y rellenarla con algunos datos de ejemplo. Puede crear la tabla manualmente mediante la Consola de administración de AWS o AWS SAM. Le recomendamos que utilice AWS SAM para crear y configurar rápidamente la tabla mediante unos pocos comandos de la AWS CLI.

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

**Creación de la tabla de DynamoDB**

1. Abra la [página Tables (Tablas) en la consola de DynamoDB](https://console.aws.amazon.com/dynamodbv2/home#tables).

1. Seleccione **Create table (Creación de tabla)**.

1. Haga lo siguiente para crear la tabla:

   1. En **Detalles de la tabla**, en **Nombre de la tabla**, ingrese **MyOrderTable**.

   1. En **Clave de partición**, ingrese **Order\$1number** y mantenga el tipo de datos establecido como **Cadena**.

   1. En **Clave de clasificación**, ingrese **Date** y mantenga el tipo de datos establecido como **Cadena**.

   1. Deje la **Configuración de la tabla** establecida en **Configuración predeterminada** y elija **Crear tabla**.

1. Cuando la tabla haya terminado de crearse y su **Estado** aparezca como **Activo**, cree un índice secundario global (GSI) de la siguiente manera. La aplicación utilizará este GSI para buscar elementos directamente por fecha y determinar qué elementos se van a eliminar.

   1. Elija **MyOrderTable** en la lista de tablas.

   1. Seleccione la pestaña **Índices**.

   1. En **Índices secundarios globales**, elija **Crear índice**.

   1. En **Detalles del índice**, ingrese **Date** en **Clave de partición** y deje el **Tipo de datos** establecido en **Cadena**.

   1. En **Nombre de índice**, ingrese el **Date-index**.

   1. Deje los demás parámetros con los valores predeterminados, desplácese a la parte inferior de la página y elija **Crear índice**.

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

**Creación de la tabla de DynamoDB**

1. Vaya a la carpeta en la que guardó el archivo `template.yaml` de la tabla de DynamoDB. Tenga en cuenta que en este ejemplo se utilizan dos archivos `template.yaml`. Asegúrese de que estén guardados en subcarpetas independientes y de que se encuentra en la carpeta correcta que contiene la plantilla para crear la tabla de DynamoDB.

1. Ejecute el siguiente comando.

   ```
   sam build
   ```

   Este comando recopila los artefactos de compilación de los recursos que desea implementar y los coloca en el formato y la ubicación adecuados para implementarlos.

1. Para crear el recurso de DynamoDB especificado en el archivo `template.yaml`, ejecute el siguiente comando.

   ```
   sam deploy --guided
   ```

   El uso de la marca `--guided` significa que AWS SAM le mostrará instrucciones para guiarlo a lo largo del proceso de implementación. Para esta implementación, introduzca un `Stack name` de **cron-app-test-db** y acepte los valores predeterminados de todas las demás opciones mediante Entrar.

   Cuando AWS SAM haya terminado de crear el recurso de DynamoDB, debería ver el siguiente mensaje:

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

1. Para confirmar que la tabla de DynamoDB se haya creado, abra la página [Tablas](https://console.aws.amazon.com/dynamodbv2/home#tables) de la consola de DynamoDB. Debería ver una tabla llamada `MyOrderTable`.

------

Después de crear la tabla, debe agregar a continuación algunos datos de muestra para probar la aplicación. El archivo CSV `sample_data.csv` que descargó anteriormente contiene una serie de entradas de ejemplo compuestas por números de pedido, fechas e información de clientes y pedidos. Use el script de Python proporcionado `load_sample_data.py` para agregar estos datos a la tabla.

**Agregación de los datos de ejemplo a la tabla**

1. Vaya al directorio que contiene los archivos `sample_data.csv` y `load_sample_data.py`. Si estos archivos están en directorios distintos, muévalos para que se guarden en la misma ubicación.

1. Ejecute el siguiente comando para crear un entorno virtual de Python que ejecute el script: Le recomendamos que utilice un entorno virtual, ya que en el siguiente paso tendrá que instalar AWS SDK para Python (Boto3).

   ```
   python -m venv venv
   ```

1. Ejecute el siguiente comando para activar el entorno virtual.

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

1. Ejecute el siguiente comando para instalar SDK para Python (Boto3) en el entorno virtual. El script utiliza esta biblioteca para conectarse a la tabla de DynamoDB y agregar los elementos.

   ```
   pip install boto3
   ```

1. Ejecute el siguiente comando para ejecutar el script y rellenar la tabla.

   ```
   python load_sample_data.py
   ```

   Si el script se ejecuta correctamente, debería imprimir cada elemento en la consola a medida que lo carga y notificar `Data loading completed`.

1. Ejecute el siguiente comando para desactivar el entorno virtual.

   ```
   deactivate
   ```

1. Para verificar que los datos se hayan cargado en la tabla de DynamoDB, haga lo siguiente:

   1. Abra la página [Explorar elementos](https://console.aws.amazon.com/dynamodbv2/home#item-explorer) en la consola de DynamoDB y seleccione su tabla (`MyOrderTable`).

   1. En el panel **Elementos devueltos**, debería ver los 25 elementos del archivo CSV que el script agregó a la tabla.

## Creación de la aplicación con el mantenimiento programado
<a name="scheduled-task-app-create-app"></a>

Puede crear e implementar los recursos para esta aplicación de ejemplo paso a paso con la Consola de administración de AWS o mediante AWS SAM. En un entorno de producción, recomendamos que utilice una herramienta de infraestructura como código (IaC) como AWS SAM para implementar aplicaciones sin servidor repetidamente sin utilizar procesos manuales.

Para este ejemplo, siga las instrucciones de la consola para aprender a configurar cada recurso de AWS por separado o siga las instrucciones de AWS SAM para implementar la aplicación de forma rápida mediante comandos de la AWS CLI.

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

**Creación de la función con la Consola de administración de AWS**

En primer lugar, cree una función que contenga el código de inicio básico. A continuación, reemplace este código por su propio código de función, ya sea al copiar y pegar el código directamente en el editor de código de Lambda o mediante la carga del código como paquete `.zip`. Para esta tarea, le recomendamos simplemente copiar y pegar el código.

1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.

1. Elija **Crear función**.

1. Elija **Crear desde cero**.

1. Bajo **Información básica**, haga lo siguiente:

   1. En **Nombre de la función**, introduzca `ScheduledDBMaintenance`.

   1. En **Tiempo de ejecución**, elija la versión más reciente de Python.

   1. En **Arquitectura**, elija **x86\$164**.

1. Seleccione **Creación de función**.

1. Después de crear la función, puede configurarla con el código de función proporcionado.

   1. En el panel **Código de origen**, reemplace el código Hello world que creó Lambda por el código de la función de Python del archivo `lambda_function.py` que guardó anteriormente.

   1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

**Configuración de la memoria y el tiempo de espera de la función (consola)**

1. Seleccione la pestaña **Configuración** de la función.

1. En el panel **Configuración general**, seleccione **Editar**.

1. Establezca la **Memoria** en 256 MB y el **Tiempo de espera** en 15 segundos. Si está procesando una tabla grande con muchos registros, por ejemplo, en el caso de un entorno de producción, podría considerar la posibilidad de configurar **Tiempo de espera** con un número mayor. Esto le da a la función más tiempo para analizar y limpiar la base de datos.

1. Seleccione **Save**.

**Configuración del formato de registro (consola)**

Puede configurar las funciones de Lambda para generar registros en formato de texto no estructurado o JSON. Se recomienda utilizar el formato JSON para los registros a fin de facilitar la búsqueda y el filtrado de los datos del registro. Para obtener más información sobre las opciones de configuración de registros de Lambda, consulte [Configuración de controles de registro avanzados para las funciones de Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

1. Seleccione la pestaña **Configuración** de la función.

1. Seleccione **Herramientas de supervisión y operaciones**.

1. En el panel **Configuración de registros**, seleccione **Editar**.

1. Para la **configuración de registro**, seleccione **JSON**.

1. Seleccione **Save**.

**Configuración de permisos de IAM**

Para conceder a la función los permisos que necesita para leer y eliminar elementos de DynamoDB, debe añadir una política al [rol de ejecución](lambda-intro-execution-role.md) de la función que defina los permisos necesarios.

1. Abra la pestaña **Configuración** y, a continuación, seleccione **Permisos** en la barra de navegación izquierda.

1. Elija el nombre del rol en **Rol de ejecución**.

1. En la consola de IAM, elija **Agregar permisos** y, a continuación, **Crear política insertada**.

1. Utilice el editor de JSON e ingrese la política siguiente:  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "dynamodb:Scan",
                   "dynamodb:DeleteItem",
                   "dynamodb:BatchWriteItem"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/MyOrderTable"
           }
       ]
   }
   ```

1. Asigne un nombre a la política **DynamoDBCleanupPolicy** y, a continuación, créela.

**Configuración del Programador de EventBridge como desencadenador (consola)**

1. Abra la [consola de EventBridge](https://console.aws.amazon.com/events/home).

1. En el panel de navegación izquierdo, elija **Programadores** en la sección **Programador**.

1. Elija **Crear programación**.

1. Para configurar la programación, haga lo siguiente:

   1. En **Nombre de la programación**, ingrese un nombre para la programación (por ejemplo, **DynamoDBCleanupSchedule**).

   1. En **Patrón de programación**, elija **Programación periódica**.

   1. En **Tipo de programación**, deje el valor predeterminado como **Programación basada en cron** e ingrese los siguientes detalles de programación:
      + **Minutos**: **0**
      + **Horas**: **3**
      + **Día del mes**: **1**
      + **Mes**: **\$1**
      + **Día de la semana**: **?**
      + **Año**: **\$1**

      Cuando se evalúa, esta expresión cron se ejecuta el primer día de cada mes a las 03:00 h.

   1. En **Intervalo de tiempo flexible**, seleccione **Desactivado**.

1. Elija **Siguiente**.

1. Para configurar el desencadenador de la función de Lambda, haga lo siguiente:

   1. En el panel **Detalle del destino**, deje la opción **API de destino** establecida en **Destinos con plantillas** y, a continuación, seleccione **Invocación de AWS Lambda**.

   1. En **Invocar**, seleccione la función de Lambda (`ScheduledDBMaintenance`) en la lista desplegable.

   1. Deje la opción **Carga útil** vacía y seleccione **Siguiente**.

   1. Desplácese hacia abajo hasta **Permisos** y seleccione **Crear un nuevo rol para esta programación**. Al crear una nueva programación del Programador de EventBridge con la consola, el Programador de EventBridge crea una nueva política con los permisos necesarios que la programación necesita para invocar la función. Para obtener más información sobre la gestión de los permisos de programación, consulte [Cron-based schedules](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html#cron-based) en la *Guía del usuario del Programador de EventBridge*.

   1. Elija **Siguiente**.

1. Revise la configuración y elija **Crear programación** para completar la creación de la programación y el desencadenador de Lambda.

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

**Implementación de la aplicación mediante AWS SAM**

1. Vaya a la carpeta en la que guardó el archivo `template.yaml` de la aplicación. Tenga en cuenta que en este ejemplo se utilizan dos archivos `template.yaml`. Asegúrese de que estén guardados en subcarpetas independientes y de que se encuentra en la carpeta correcta que contiene la plantilla para crear la aplicación.

1. Copie los archivos `lambda_function.py` y `requirements.txt` que descargó anteriormente en la misma carpeta. La ubicación del código especificada en la plantilla de AWS SAM es `./`, es decir, la ubicación actual. AWS SAM buscará en esta carpeta el código de la función de Lambda cuando intente implementar la aplicación.

1. Ejecute el siguiente comando.

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

   Este comando recopila los artefactos de compilación de los recursos que desea implementar y los coloca en el formato y la ubicación adecuados para implementarlos. Con la opción `--use-container`, la función se crea dentro de un contenedor de Docker tipo Lambda. Lo usamos aquí para que no necesite tener Python 3.12 instalado en su máquina local para que la compilación funcione.

1. Para crear los recursos de Lambda y el Programador de EventBridge especificados en el archivo `template.yaml`, ejecute el siguiente comando.

   ```
   sam deploy --guided
   ```

   El uso de la marca `--guided` significa que AWS SAM le mostrará instrucciones para guiarlo a lo largo del proceso de implementación. Para esta implementación, introduzca un `Stack name` de **cron-maintenance-app** y acepte los valores predeterminados de todas las demás opciones mediante Entrar.

   Cuando AWS SAM haya terminado de crear los recursos de Lambda y el Programador de EventBridge, debería ver el siguiente mensaje:

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

1. Para confirmar que la función de Lambda se haya creado, también puede abrir la página [Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda. Debería ver una función llamada `ScheduledDBMaintenance`.

------

## Pruebas de la aplicación
<a name="scheduled-task-app-test-app"></a>

 Para comprobar que la programación desencadene correctamente la función y que la función limpie correctamente los registros de la base de datos, puede modificar temporalmente la programación para que se ejecute una vez cada cierto tiempo. A continuación, puede volver a ejecutar `sam deploy` para restablecer la programación de periodicidad para que se ejecute una vez al mes. 

**Ejecución de la aplicación mediante la Consola de administración de AWS**

1. Vuelva a la página de la consola del Programador de EventBridge.

1. Elija la programación y, a continuación, elija **Editar**.

1. En la sección **Patrón de programación**, en **Recurrencia**, elija **Programación única**.

1.  Establezca la hora de invocación en unos minutos a partir de ahora, revise la configuración y, a continuación, elija **Guardar**. 

 Una vez ejecutada la programación e invocado su destino, ejecute el script `test_app.py` para comprobar que la función haya eliminado correctamente todos los registros antiguos de la tabla de DynamoDB. 

**Verificación de la eliminación de los registros antiguos mediante un script de Python**

1.  En la línea de comandos, vaya a la carpeta en la que guardó `test_app.py`. 

1. Ejecute el script.

   ```
   python test_app.py
   ```

    Si todo va bien, obtendrá el siguiente resultado. 

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

## Siguientes pasos
<a name="scheduled-task-app-next-steps"></a>

 Ahora puede modificar la programación del Programador de EventBridge para adaptarla a los requisitos específicos de su aplicación. El Programador de EventBridge admite las siguientes expresiones de programación: cron, frecuencia y única. 

 Para obtener más información sobre las expresiones de programación del Programador de EventBridge, consulte [Tipos de programación](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html) en la *Guía del usuario del Programador de EventBridge*. [Administración de acceso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) en la *Guía del usuario de IAM*