Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creare un'app per eseguire la manutenzione pianificata del database
<a name="scheduled-task-app"></a>

È possibile utilizzare AWS Lambda per sostituire processi pianificati come backup automatici di sistema, conversioni di file e attività di manutenzione. In questo esempio, viene creata un'applicazione serverless che esegue una manutenzione programmata regolare su una tabella DynamoDB eliminando le voci precedenti. L'app utilizza EventBridge Scheduler per richiamare una funzione Lambda su una pianificazione cron. Quando viene richiamata, la funzione interroga la tabella per individuare gli elementi più vecchi di un anno e li elimina. La funzione registra ogni elemento eliminato in Logs. CloudWatch 

Per implementare questo esempio, crea prima una tabella DynamoDB e completala con alcuni dati di test per la funzione da interrogare. Quindi, crea una funzione Python Lambda con un trigger EventBridge Scheduler e un ruolo di esecuzione IAM che dia alla funzione il permesso di leggere ed eliminare gli elementi dalla tua tabella.

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


**Suggerimento**  
Se non hai familiarità con Lambda, completa il tutorial [Crea la tua prima funzione Lambda](getting-started.md) prima di creare questa app di esempio.

Puoi distribuire la tua app manualmente creando e configurando risorse con. Console di gestione AWS Puoi anche distribuire l'app utilizzando (). AWS Serverless Application Model AWS SAM AWS SAM è uno strumento Infrastructure as Code (IaC). Con IaC, non vengono create risorse manualmente, ma le si definisce in codice e poi le si distribuisce automaticamente.

Se desideri saperne di più sull'utilizzo di Lambda con IaC prima di implementare questa app di esempio, consulta [Utilizzo di Lambda con l'infrastructure as code (IaC)](foundation-iac.md).

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

Prima di creare l'app di esempio, assicurati di aver installato gli strumenti e i programmi da riga di comando necessari.
+ **Python**

  Per popolare la tabella DynamoDB creata per testare l'app, questo esempio utilizza uno script Python e un file CSV per scrivere i dati nella tabella. Assicurati che Python versione 3.8 o successiva sia installato sulla tua macchina.
+ **AWS SAM CLI**

  Se desideri creare la tabella DynamoDB e distribuire l'app di esempio AWS SAM utilizzando, devi installare la CLI. AWS SAM Segui le [istruzioni di installazione](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) nella *Guida per l’utente di AWS SAM *.
+ **AWS CLI**

  Per utilizzare lo script Python fornito per popolare la tabella di test, è necessario aver installato e configurato il AWS CLI. Questo perché lo script utilizza il AWS SDK per Python (Boto3), che richiede l'accesso alle tue credenziali AWS Identity and Access Management (IAM). È inoltre necessario che AWS CLI sia installato per distribuire le risorse utilizzando. AWS SAM Installa la CLI seguendo le [istruzioni di installazione](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) riportate nella *Guida per l'utente di AWS Command Line Interface *.
+ **Docker**

  Per distribuire l'app utilizzando AWS SAM, Docker deve essere installato anche sulla macchina di compilazione. Segui le istruzioni in [Installa Docker Engine sul sito](https://docs.docker.com/engine/install/) Web della documentazione di Docker.

## Download dei file dell'app di esempio
<a name="scheduled-task-app-download"></a>

Per creare il database di esempio e l'app di manutenzione programmata, è necessario creare i seguenti file nella directory del progetto:

**File di database di esempio**
+ `template.yaml`- un AWS SAM modello che puoi usare per creare la tabella DynamoDB
+ `sample_data.csv`: un file CSV contenente dati di esempio da caricare nella tabella
+ `load_sample_data.py`: uno script Python che scrive i dati del file CSV nella tabella

**File dell'app di manutenzione programmata**
+ `lambda_function.py`: il codice della funzione Python per la funzione Lambda che esegue la manutenzione del database
+ `requirements.txt`: un file manifesto che definisce le dipendenze richieste dal codice della funzione Python
+ `template.yaml`- un AWS SAM modello che puoi usare per distribuire l'app

**File di test**
+ `test_app.py`: uno script Python che scansiona la tabella e conferma il corretto funzionamento della funzione emettendo tutti i record più vecchi di un anno

Espandi le seguenti sezioni per visualizzare il codice e per saperne di più sul ruolo di ciascun file nella creazione e nel test dell'app. Per creare i file sul tuo computer locale, copia e incolla il codice seguente.

### AWS SAM modello (tabella DynamoDB di esempio)
<a name="scheduled-task-app-table-yaml"></a>

Copia e incolla il codice seguente in un nuovo file `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**  
AWS SAM i modelli utilizzano una convenzione di denominazione standard di. `template.yaml` In questo esempio, hai due file modello: uno per creare il database di esempio e l'altro per creare l'app stessa. Salvali in sottodirectory separate nella cartella di progetto.

Questo AWS SAM modello definisce la risorsa della tabella DynamoDB che crei per testare la tua app. La tabella utilizza una chiave primaria di `Order_number` con una chiave di ordinamento di `Date`. Affinché la funzione Lambda trovi gli elementi direttamente in base alla data, definiamo anche un [indice secondario globale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) denominato `Date-index`.

Per ulteriori informazioni sulla creazione e la configurazione di una tabella DynamoDB tramite la risorsa `AWS::DynamoDB::Table`, consulta [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) nella *Guida per l'utente di AWS CloudFormation *.

### File di dati del database di esempio
<a name="scheduled-task-app-csv-file"></a>

Copia e incolla il codice seguente in un nuovo file `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
```

Questo file contiene alcuni esempi di dati di test con cui compilare la tabella DynamoDB in formato CSV (valori separati da virgola) standard.

### Script Python per caricare dati di esempio
<a name="scheduled-task-app-load-script"></a>

Copia e incolla il codice seguente in un nuovo file `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.")
```

Questo script Python utilizza innanzitutto il AWS SDK per Python (Boto3) per creare una connessione alla tabella DynamoDB. Quindi esegue un'iterazione su ogni riga del file CSV di dati di esempio, crea un elemento da quella riga e scrive l'elemento nella tabella DynamoDB utilizzando l'SDK boto3.

### Codice della funzione Python
<a name="scheduled-task-app-function-code"></a>

Copia e incolla il codice seguente in un nuovo file `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'
    }
```

Il codice della funzione Python contiene la [funzione handler](python-handler.md) (`lambda_handler`) che Lambda esegue quando viene invocata la funzione.

Quando la funzione viene richiamata da EventBridge Scheduler, utilizza il AWS SDK per Python (Boto3) per creare una connessione alla tabella DynamoDB su cui deve essere eseguita l'attività di manutenzione pianificata. Quindi utilizza la libreria `datetime` Python per calcolare la data di un anno fa, prima di scansionare la tabella alla ricerca di elementi più vecchi di questo ed eliminarli.

Tieni presente che le risposte delle operazioni di query e scansione di DynamoDB sono limitate a una dimensione massima di 1 MB. Se la risposta è superiore a 1 MB, DynamoDB impagina i dati e restituisce un elemento `LastEvaluatedKey` nella risposta. Per garantire che la nostra funzione elabori tutti i record della tabella, controlliamo la presenza di questa chiave e continuiamo a eseguire scansioni della tabella dall'ultima posizione valutata fino alla scansione dell'intera tabella.

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

Copia e incolla il codice seguente in un nuovo file `requirements.txt`.

```
boto3
```

Per questo esempio, il codice della funzione ha solo una dipendenza che non fa parte della libreria Python standard: l'SDK for Python (Boto3) che la funzione utilizza per scansionare ed eliminare elementi dalla tabella DynamoDB.

**Nota**  
Una versione dell'SDK for Python (Boto3) è inclusa come parte del runtime Lambda, quindi il codice può essere eseguito senza aggiungere Boto3 al pacchetto di implementazione della funzione. Tuttavia, per mantenere il pieno controllo delle tue dipendenze ed evitare possibili problemi di disallineamento della versione, la best practice per Python è includere tutte le dipendenze della funzione nel pacchetto di implementazione della tua funzione. Per ulteriori informazioni, consulta [Dipendenze di runtime in Python](python-package.md#python-package-dependencies).

### AWS SAM modello (app per manutenzione programmata)
<a name="scheduled-task-app-table-yaml"></a>

Copia e incolla il codice seguente in un nuovo file `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**  
AWS SAM i modelli utilizzano una convenzione di denominazione standard di. `template.yaml` In questo esempio, hai due file modello: uno per creare il database di esempio e l'altro per creare l'app stessa. Salvali in sottodirectory separate nella cartella di progetto.

Questo AWS SAM modello definisce le risorse per la tua app. Definiamo la funzione Lambda utilizzando la risorsa `AWS::Serverless::Function`. La EventBridge pianificazione dello Scheduler e il trigger per richiamare la funzione Lambda vengono creati utilizzando la `Events` proprietà di questa risorsa utilizzando un tipo di. `ScheduleV2` *Per ulteriori informazioni sulla definizione delle EventBridge pianificazioni di Scheduler nei AWS SAM modelli, consulta [ScheduleV2 nella Guida per gli sviluppatori](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-schedulev2.html).AWS Serverless Application Model *

Oltre alla funzione Lambda e alla EventBridge pianificazione Scheduler, definiamo anche un gruppo di CloudWatch log a cui la funzione può inviare i record degli elementi eliminati.

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

Copia e incolla il codice seguente in un nuovo file `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)}")
```

Questo script di test utilizza il AWS SDK per Python (Boto3) per creare una connessione alla tabella DynamoDB ed eseguire la scansione degli elementi più vecchi di un anno. Per confermare se la funzione Lambda è stata eseguita correttamente, alla fine del test, la funzione stampa il numero di record più vecchi di un anno ancora nella tabella. Se la funzione Lambda ha avuto successo, il numero di vecchi record nella tabella dovrebbe essere zero. 

## Creazione e compilazione della tabella DynamoDB di esempio
<a name="scheduled-task-app-create-table"></a>

Per testare la tua app di manutenzione programmata, devi prima creare una tabella DynamoDB e popolarla con alcuni dati di esempio. È possibile creare la tabella manualmente utilizzando o la Console di gestione AWS o AWS SAM. Si consiglia di AWS SAM utilizzarlo per creare e configurare rapidamente la tabella utilizzando alcuni AWS CLI comandi.

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

**Creare la tabella DynamoDB**

1. Aprire la pagina [Tables (Tabelle)](https://console.aws.amazon.com/dynamodbv2/home#tables) della console DynamoDB.

1. Scegliere **Create table (Crea tabella)**.

1. Crea la tabella completando le operazioni seguenti:

   1. In **Dettagli tabella**, per **Nome tabella**, immetti **MyOrderTable**.

   1. Per **Partition key (Chiave di partizione)**, immettere **Order\$1number** e mantenere il tipo di dati impostato come **String (Stringa)**.

   1. Per **Chiave di ordinamento**, immetti **Date** e lascia il tipo come **String**.

   1. Lascia **Impostazioni della tabella** impostato su **Impostazioni predefinite** e scegli **Crea tabella**.

1. Una volta completata la creazione della tabella e lo **stato** è impostato su **Attivo**, crea un indice secondario globale (GSI) procedendo come segue. L'app utilizzerà questo GSI per cercare gli elementi direttamente in base alla data e determinare cosa eliminare.

   1. Scegliete **MyOrderTable**dall'elenco delle tabelle.

   1. Scegli la scheda **Indici**.

   1. **In **Indici secondari globali, scegli Crea indice**.**

   1. In **Dettagli dell'indice**, inserisci **Date** per **Chiave di partizione** e lascia il campo **Tipo di dati** impostato su **Stringa**.

   1. Per **Index name (Nome indice)**, inserisci **Date-index**.

   1. Lascia tutti gli altri parametri impostati sui valori predefiniti, scorri fino alla parte inferiore della pagina e scegli **Crea indice**.

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

**Creare la tabella DynamoDB**

1. Passa alla cartella in cui è stato salvato il file `template.yaml` per la tabella DynamoDB. Nota che questo esempio utilizza due file `template.yaml`. Assicurati che siano salvati in sottocartelle separate e di trovarti nella cartella corretta contenente il modello per creare la tua tabella DynamoDB.

1. Eseguire il seguente comando seguente.

   ```
   sam build
   ```

   Questo comando raccoglie gli artefatti di compilazione per l'applicazione e li colloca nel formato e nella posizione corretti per l'implementazione.

1. Per creare la risorsa DynamoDB specificata nel file `template.yaml`, eseguire il comando seguente.

   ```
   sam deploy --guided
   ```

   L'uso del `--guided` flag significa che ti AWS SAM verranno mostrate le istruzioni per guidarti nel processo di distribuzione. Per questa implementazione, inserisci un `Stack name` pari a **cron-app-test-db** e accetta i valori predefiniti per tutte le altre opzioni utilizzando Invio.

   Al AWS SAM termine della creazione della risorsa DynamoDB, dovrebbe apparire il seguente messaggio.

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

1. È inoltre possibile confermare che la tabella DynamoDB è stata creata aprendo la pagina [Tabelle](https://console.aws.amazon.com/dynamodbv2/home#tables) della console DynamoDB. Dovresti vedere una tabella denominata `MyOrderTable`.

------

Dopo aver creato la tabella, aggiungi alcuni dati di esempio per testare l'app. Il file CSV `sample_data.csv` scaricato in precedenza contiene una serie di voci di esempio tra cui numeri d'ordine, date e informazioni su clienti e ordini. Usa lo script python `load_sample_data.py` fornito per aggiungere questi dati alla tua tabella.

**Per aggiungere i dati di esempio alla tabella**

1. Passa alla directory contenente i file `sample_data.csv` e `load_sample_data.py`. Se questi file si trovano in directory separate, spostali in modo che vengano salvati nella stessa posizione.

1. Crea un ambiente virtuale Python in cui eseguire lo script mediante il comando seguente. Ti consigliamo di utilizzare un ambiente virtuale perché nel passaggio successivo dovrai installare AWS SDK per Python (Boto3).

   ```
   python -m venv venv
   ```

1. Nell'ambiente virtuale, esegui il comando seguente.

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

1. Installa l'SDK per Python (Boto3) nell'ambiente virtuale mediante il comando seguente. Lo script utilizza questa libreria per connettersi alla tabella DynamoDB e aggiungere gli elementi.

   ```
   pip install boto3
   ```

1. Esegui lo script per popolare la tabella mediante il comando seguente.

   ```
   python load_sample_data.py
   ```

   Se lo script viene eseguito correttamente, dovrebbe stampare ogni elemento sulla console man mano che lo carica e riporta `Data loading completed`.

1. Per disattivare l'ambiente virtuale, esegui il comando seguente.

   ```
   deactivate
   ```

1. È possibile verificare che i dati siano stati caricati nella tabella DynamoDB eseguendo le operazioni seguenti:

   1. Apri la pagina [Esplora elementi](https://console.aws.amazon.com/dynamodbv2/home#item-explorer) della console DynamoDB e seleziona la tua tabella (`MyOrderTable`).

   1. Nel riquadro **Elementi restituiti**, dovresti vedere i 25 elementi del file CSV che lo script ha aggiunto alla tabella.

## Creazione dell'app per la manutenzione programmata
<a name="scheduled-task-app-create-app"></a>

È possibile creare e distribuire le risorse per questa app di esempio passo dopo passo utilizzando Console di gestione AWS o utilizzando. AWS SAM In un ambiente di produzione, si consiglia di utilizzare uno strumento Infrustracture-as-Code (IaC), AWS SAM ad esempio per distribuire ripetutamente applicazioni serverless senza utilizzare processi manuali.

Per questo esempio, segui le istruzioni della console per scoprire come configurare ogni AWS risorsa separatamente oppure segui AWS SAM le istruzioni per distribuire rapidamente l'app utilizzando i comandi. AWS CLI 

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

**Per creare la funzione utilizzando Console di gestione AWS**

Innanzitutto, crea una funzione contenente il codice di avvio di base. Quindi, sostituisci questo codice con il codice della tua funzione copiando e incollando il codice direttamente nell'editor di codice Lambda o caricandolo come pacchetto `.zip`. Per questa operazione, si consiglia di copiare e incollare il codice.

1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.

1. Selezionare **Create function (Crea funzione)**.

1. Scegli **Author from scratch** (Crea da zero).

1. In **Basic information (Informazioni di base)** eseguire queste operazioni:

   1. Nel campo **Function name (Nome funzione)**, immettere `ScheduledDBMaintenance`.

   1. Per **Runtime** scegli l'ultima versione di Python.

   1. In **Architecture** (Architettura), scegli **x86\$164**.

1. Scegli **Crea funzione**.

1. Dopo aver creato la funzione, è possibile configurarla con il codice di funzione fornito.

   1. Nel riquadro **Codice sorgente**, sostituisci il codice Hello world creato da Lambda con il codice della funzione Python dal file `lambda_function.py` salvato in precedenza.

   1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:  
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

**Per configurare la memoria e il timeout della funzione (console)**

1. Seleziona la scheda **Configurazione** per la tua funzione.

1. Nel riquadro **Configurazione generale**, scegli **Modifica**.

1. Imposta **Memoria** su 256 MB e **Timeout** su 15 secondi. Se stai elaborando una tabella di grandi dimensioni con molti record, ad esempio nel caso di un ambiente di produzione, potresti prendere in considerazione l'impostazione di **Timeout** su un numero maggiore. In questo modo la funzione ha più tempo per scansionare e pulire il database.

1. Scegli **Save** (Salva).

**Per configurare il formato di log (console)**

Puoi configurare le funzioni Lambda per generare log in formato testo non strutturato o JSON. È consigliabile utilizzare il formato JSON per i log per agevolare la ricerca e il filtraggio dei dati di log. Per ulteriori informazioni sulle opzioni di configurazione del log Lambda, consulta [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

1. Seleziona la scheda **Configurazione** per la tua funzione.

1. Seleziona **Strumenti di monitoraggio e operazioni**.

1. Nel riquadro **Configurazione della registrazione**, scegli **Modifica**.

1. Per **Configurazione della registrazione**, seleziona **JSON**.

1. Scegli **Save** (Salva).

**Impostazione delle autorizzazioni IAM**

Per concedere alla funzione le autorizzazioni necessarie per leggere ed eliminare gli elementi di DynamoDB, è necessario aggiungere una policy al [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione che definisca le autorizzazioni necessarie.

1. Apri la scheda **Configurazione**, quindi scegli **Autorizzazioni** dalla barra di navigazione a sinistra.

1. Scegli il nome del ruolo **Ruolo di esecuzione**.

1. Nella console IAM, scegli **Aggiungi autorizzazioni**, quindi **Crea policy in linea**.

1. Utilizza l'editor JSON e inserisci la seguente policy:  
****  

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

1. Assegna un nome alla policy **DynamoDBCleanupPolicy**, quindi creala.

**Per configurare EventBridge Scheduler come trigger (console)**

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

1. Nel riquadro di navigazione a sinistra, scegli **Pianificatori** nella sezione **Pianificatore**.

1. Scegli **Crea pianificazione**.

1. Configura le impostazioni del VPC effettuando le seguenti operazioni:

   1. Per **Nome pianificazione**, inserisci un nome per la pianificazione (ad esempio, **DynamoDBCleanupSchedule**).

   1. In **Schema di pianificazione**, scegli **Pianificazione ricorrente**.

   1. Per **Tipo di pianificazione**, lascia l'impostazione predefinita come **Pianificazione basata su CRON**, quindi inserisci i seguenti dettagli di pianificazione:
      + ** **minuti**0**
      + **Ore**: **3**
      + **Giorno del mese**: **1**
      + **Mese**: **\$1**
      + **Giorno della settimana**: **?**
      + **Anno**: **\$1**

      Una volta valutata, questa espressione cron viene eseguita il primo giorno di ogni mese alle 03:00.

   1. Per **Finestra temporale flessibile**, seleziona **Off**.

1. Scegli **Next (Successivo)**.

1. Configura il trigger per la tua funzione Lambda eseguendo le operazioni seguenti:

   1. Nel riquadro **Dettagli della destinazione**, lascia il campo **API di destinazione** impostato su **Destinazioni basate su modelli**, quindi seleziona **Invocazione di AWS Lambda **.

   1. In **Richiama**, seleziona la tua funzione Lambda (`ScheduledDBMaintenance`) dall'elenco a discesa.

   1. Lascia vuoto il campo **Payload** e scegli **Avanti**.

   1. Scorri verso il basso fino a **Autorizzazioni** e seleziona **Crea un nuovo ruolo per questa pianificazione**. Quando crei una nuova EventBridge pianificazione di Scheduler utilizzando la console, EventBridge Scheduler crea una nuova politica con le autorizzazioni necessarie alla pianificazione per richiamare la tua funzione. *Per ulteriori informazioni sulla gestione delle autorizzazioni di pianificazione, consulta Pianificazioni [basate su CRON. nella Guida per l'utente di Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html#cron-based). EventBridge *

   1. Scegli **Next (Successivo)**.

1. Controlla le impostazioni e scegli **Crea pianificazione** per completare la creazione della pianificazione e del trigger Lambda.

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

**Per distribuire l'app utilizzando AWS SAM**

1. Passa alla cartella in cui è stato salvato il file `template.yaml` per l'app. Nota che questo esempio utilizza due file `template.yaml`. Assicurati che siano salvati in sottocartelle separate e di trovarti nella cartella corretta contenente il modello per creare l'app.

1. Copia i file `lambda_function.py` e `requirements.txt` che hai scaricato in precedenza nella stessa cartella. La posizione del codice specificata nel AWS SAM modello è`./`, ovvero la posizione corrente. AWS SAM cercherà in questa cartella il codice della funzione Lambda quando tenti di distribuire l'app.

1. Eseguire il seguente comando seguente.

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

   Questo comando raccoglie gli artefatti di compilazione per l'applicazione e li colloca nel formato e nella posizione corretti per l'implementazione. La specifica dell'opzione `--use-container` consente di creare la funzione all'interno di un container Docker simile a Lambda. Lo usiamo qui quindi non è necessario che Python 3.12 sia installato sul computer locale per far funzionare la build.

1. Per creare le risorse Lambda e EventBridge Scheduler specificate nel `template.yaml` file, esegui il comando seguente.

   ```
   sam deploy --guided
   ```

   L'uso del `--guided` flag significa che ti AWS SAM verranno mostrate delle istruzioni per guidarti nel processo di distribuzione. Per questa implementazione, inserisci un `Stack name` pari a **cron-maintenance-app** e accetta i valori predefiniti per tutte le altre opzioni utilizzando Invio.

   Al AWS SAM termine della creazione delle risorse Lambda e EventBridge Scheduler, dovrebbe apparire il seguente messaggio.

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

1. Puoi inoltre confermare che la funzione Lambda è stata creata aprendo la pagina [Funzioni della console](https://console.aws.amazon.com/lambda/home#/functions) Lambda. Dovresti vedere una funzione denominata. `ScheduledDBMaintenance`

------

## Test dell'app
<a name="scheduled-task-app-test-app"></a>

 Per verificare che la pianificazione attivi correttamente la funzione e che la funzione pulisca correttamente i record dal database, è possibile modificare temporaneamente la pianificazione in modo che venga eseguita una volta in un momento specifico. È quindi possibile eseguire `sam deploy` nuovamente l'operazione per reimpostare il programma di ricorrenza in modo che venga eseguito una volta al mese. 

**Per eseguire l'applicazione utilizzando Console di gestione AWS**

1. Torna alla pagina della console EventBridge Scheduler.

1. **Scegli la tua pianificazione, quindi scegli Modifica.**

1. Nella sezione **Schema di pianificazione**, in **Ricorrenza**, scegli Pianificazione **unica**.

1.  **Imposta il tempo di chiamata a pochi minuti da oggi, rivedi le impostazioni, quindi scegli Salva.** 

 Dopo l'esecuzione della pianificazione e il richiamo della destinazione, esegui `test_app.py` lo script per verificare che la funzione abbia rimosso correttamente tutti i vecchi record dalla tabella DynamoDB. 

**Per verificare che i vecchi record vengano eliminati utilizzando uno script Python**

1.  Nella riga di comando, accedi alla cartella in cui hai salvato`test_app.py`. 

1. Eseguire lo script.

   ```
   python test_app.py
   ```

    Se il test viene superato, viene visualizzato il seguente output. 

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

## Fasi successive
<a name="scheduled-task-app-next-steps"></a>

 Ora puoi modificare la EventBridge pianificazione dello Scheduler per soddisfare i requisiti specifici dell'applicazione. EventBridge Scheduler supporta le seguenti espressioni di pianificazione: cron, rate e one-time schedules. 

 *Per ulteriori informazioni sulle espressioni di EventBridge pianificazione di Scheduler, consulta Scheduler [types](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html) nella Scheduler User GuideEventBridge .* [Gestione degli accessi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) nella Guida per l'utente *IAM*