Prérequis Téléchargement des exemples de fichiers d’application Création et remplissage de l’exemple de table DynamoDB Création de l’application de maintenance planifiée Test de l’application Étapes suivantes

Création d’une application de maintenance planifiée de la base de données

Vous pouvez utiliser AWS Lambda pour remplacer les processus planifiés tels que les sauvegardes automatisées du système, les conversions de fichiers et les tâches de maintenance. Dans cet exemple, vous créez une application sans serveur qui effectue une maintenance planifiée régulière sur une table DynamoDB en supprimant les anciennes entrées. L’application utilise le planificateur EventBridge pour invoquer une fonction Lambda selon une planification cron. Lorsqu’elle est invoquée, la fonction rechercher dans la table pour les éléments datant de plus d’un an et les supprime. La fonction journalise chaque élément supprimé dans CloudWatch Logs.

Pour implémenter cet exemple, créez d’abord une table DynamoDB et remplissez-la avec des données de test que votre fonction doit interroger. Créez ensuite une fonction Lambda Python avec un déclencheur EventBridge Scheduler et un rôle d’exécution IAM qui autorise la fonction à lire et à supprimer des éléments de votre table.

Schéma illustrant le flux de données entre un planning EventBridge Scheduler, une fonction Lambda et une table DynamoDB

Astuce

Si vous utilisez Lambda pour la première fois, nous vous recommandons de suivre le tutoriel Création de votre première fonction Lambda avant de créer cet exemple d’application.

Vous pouvez déployer votre application manuellement en créant et en configurant des ressources à l’aide de l’AWS Management Console. Vous pouvez également déployer l’application en utilisant AWS Serverless Application Model (AWS SAM). AWS SAM est un outil d’infrastructure en tant que code (IaC). Avec l’IaC, vous ne créez pas de ressources manuellement, mais vous les définissez dans le code, puis vous les déployez automatiquement.

Si vous souhaitez en savoir plus sur l’utilisation de Lambda avec l’IaC avant de déployer cet exemple d’application, consultez Utilisation de Lambda avec infrastructure en tant que code (IaC).

Prérequis

Avant de créer l’exemple d’application, assurez-vous que les outils et programmes de ligne de commande requis sont installés.

Python

Pour remplir la table DynamoDB que vous créez pour tester votre application, cet exemple utilise un script Python et un fichier CSV pour écrire des données dans la table. Assurez-vous que Python 3.8 ou version ultérieure est installé sur votre machine.
AWS SAM Interface de ligne de commande (CLI

Si vous souhaitez créer la table DynamoDB et déployer l’application d’exemple en utilisant AWS SAM, vous devez installer la CLI AWS SAM. Suivez les instructions d’installation dans le Guise de l’utilisateur AWS SAM.
AWS CLI

Pour utiliser le script Python fourni pour remplir votre table de test, vous devez avoir installé et configuré l’AWS CLI. Cela est dû au fait que le script utilise l’AWS SDK pour Python (Boto3), qui doit accéder à vos informations d’identification AWS Identity and Access Management (IAM). Vous devez également l’installer l’AWS CLI pour déployer des ressources à l’aide de AWS SAM. Installez la CLI en suivant les instructions d’installation du Guide de l’utilisateur AWS Command Line Interface.
Docker

Pour déployer l’application à l’aide de AWS SAM, Docker doit également être installé sur votre machine de compilation. Suivez les instructions dans Install Docker Engine sur le site Web de documentation de Docker.

Téléchargement des exemples de fichiers d’application

Pour créer la base de données d’exemple et l’application de maintenance planifiée, vous devez créer les fichiers suivants dans le répertoire de votre projet :

Exemples de fichiers de base de données

template.yaml : un modèle AWS SAM que vous pouvez utiliser pour créer la table DynamoDB
sample_data.csv : un fichier CSV contenant des exemples de données à charger dans votre tableau
load_sample_data.py : un script Python qui écrit les données du fichier CSV dans le tableau

Fichiers de l’application de maintenance planifiée

lambda_function.py : le code de fonction Python de la fonction Lambda qui effectue la maintenance de la base de données
requirements.txt : un fichier manifeste définissant les dépendances requises par le code de votre fonction Python
template.yaml : un modèle AWS SAM que vous pouvez utiliser pour déployer l’application

Fichier de test

test_app.py : un script Python qui scanne la table et confirme le bon fonctionnement de votre fonction en affichant tous les enregistrements datant de plus d’un an

Développez les sections suivantes pour afficher le code et pour en savoir plus sur le rôle de chaque fichier dans la création et le test de votre application. Pour créer les fichiers sur votre ordinateur local, copiez et collez le code ci-dessous.

Copiez et collez le code suivant dans un fichier nommé 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

Note

Les modèles AWS SAM utilisent une convention de dénomination standard template.yaml. Dans cet exemple, vous disposez de deux fichiers modèles : l’un pour créer la base de données d’exemple et l’autre pour créer l’application elle-même. Enregistrez-les dans des sous-répertoires distincts dans votre dossier de projet.

Ce modèle AWS SAM définit la ressource de table DynamoDB que vous créez pour tester votre application. La table utilise une clé primaire Order_number avec une clé de tri Date. Pour que votre fonction Lambda puisse rechercher des éléments directement par date, nous définissons également un index secondaire global nommé Date-index.

Pour en savoir plus sur la création et la configuration d’une table DynamoDB à l’aide de cette ressource AWS::DynamoDB::Table, consultez AWS::DynamoDB::Table dans le Guide de l’utilisateur AWS CloudFormation.

Copiez et collez le code suivant dans un fichier nommé 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

Ce fichier contient des exemples de données de test à utiliser dans votre table DynamoDB au format CSV (valeurs séparées par des virgules) standard.

Copiez et collez le code suivant dans un fichier nommé 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.")

Ce script Python utilise d’abord l’AWS SDK pour Python (Boto3) pour créer une connexion à votre table DynamoDB. Il effectue ensuite une itération sur chaque ligne du fichier CSV de données d’exemple, crée un élément à partir de cette ligne et écrit l’élément dans la table DynamoDB à l’aide du kit SDK boto3.

Copiez et collez le code suivant dans un fichier nommé 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'
    }

Le code de la fonction Python contient la fonction de gestion (lambda_handler) que Lambda exécute lorsque votre fonction est appelée.

Lorsque la fonction est invoquée par EventBridge Scheduler, elle utilise l’AWS SDK pour Python (Boto3) pour créer une connexion à la table DynamoDB sur laquelle la tâche de maintenance planifiée doit être exécutée. Il utilise ensuite la bibliothèque Python datetime pour calculer la date d’il y a un an, avant de rechercher dans la table les éléments plus anciens et de les supprimer.

Notez que les réponses issues des opérations de requête et d’analyse DynamoDB sont limitées à une taille d’au maximum 1 Mo. Si la réponse est supérieure à 1 Mo, DynamoDB pagine les données et renvoie un élément LastEvaluatedKey dans la réponse. Pour garantir que notre fonction traite tous les enregistrements de la table, nous vérifions la présence de cette clé et continuons à analyser la table à partir de la dernière position évaluée jusqu’à ce que toute la table ait été analysée.

Copiez et collez le code suivant dans un fichier nommé requirements.txt.


boto3

Dans cet exemple, le code de votre fonction n’a qu’une seule dépendance qui ne fait pas partie de la bibliothèque Python standard : le kit SDK pour Python (Boto3) que la fonction utilise pour analyser et supprimer des éléments de la table DynamoDB.

Note

Une version du kit SDK pour Python (Boto3) est incluse dans l’environnement d’exécution Lambda, de sorte que votre code s’exécute sans ajouter Boto3 au package de déploiement de votre fonction. Toutefois, pour garder le contrôle total des dépendances de votre fonction et éviter d’éventuels problèmes de désalignement de version, la bonne pratique pour Python consiste à inclure toutes les dépendances de fonction dans le package de déploiement de votre fonction. Pour en savoir plus, veuillez consulter Dépendances d’exécution dans Python.

Copiez et collez le code suivant dans un fichier nommé 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

Note

Ce modèle AWS SAM définit les ressources dans votre application. Nous définissons la fonction Lambda à l’aide de la ressource AWS::Serverless::Function. La planification EventBridge Scheduler et le déclencheur permettant d’invoquer la fonction Lambda sont créés en utilisant la propriété Events de cette ressource avec le type ScheduleV2. Pour en savoir plus sur la définition des planifications EventBridge Scheduler dans les modèles AWS SAM, consultez ScheduleV2 dans le Guide du développeur AWS Serverless Application Model.

Outre la fonction Lambda et la planification EventBridge Scheduler, nous définissons également un groupe de journaux CloudWatch auquel votre fonction doit envoyer les enregistrements des éléments supprimés.

Copiez et collez le code suivant dans un fichier nommé 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)}")

Ce script de test utilise l’AWS SDK pour Python (Boto3) pour créer une connexion à votre table DynamoDB et rechercher les éléments datant de plus d’un an. Pour confirmer que la fonction Lambda s’est bien exécutée, à la fin du test, la fonction affiche le nombre d’enregistrements de plus d’un an encore présents dans la table. Si l’exécution de la fonction Lambda a réussi, le nombre d’anciens enregistrements dans la table doit être égal à zéro.

Création et remplissage de l’exemple de table DynamoDB

Pour tester votre application de maintenance planifiée, vous devez d’abord créer une table DynamoDB et la remplir avec des exemples de données. Vous pouvez créer le tableau manuellement à l’aide de l’AWS Management Console ou en utilisant AWS SAM. Nous vous recommandons de l’utiliser AWS SAM pour créer et configurer rapidement le tableau à l’aide de quelques commandes AWS CLI.

Console

Créer le tableau DynamoDB

Ouvrez la page Tables (Tables) de la console DynamoDB.
Choisissez Créer un tableau.
Créez la table en procédant comme suit :
1. Sous Détails de la table, dans Nom de la table, saisissez MyOrderTable.
2. Pour Clé de partition, saisissez Order_number, et conservez le type défini sur Chaîne.
3. Pour la Clé de tri, saisissez Date et conservez le type défini sur Chaîne.
4. Laissez Paramètres du tableau définis sur Paramètres par défaut et choisissez Créer une table.
Lorsque la création de votre table est terminée et que son Statut affiche Actif, créez un index secondaire global (GSI) en procédant comme suit. Votre application utilisera ce GSI pour rechercher des éléments directement par date afin de déterminer ceux à supprimer.
1. Choisissez MyOrderTable dans la liste des tables.
2. Choisissez l’onglet Index.
3. Sous Index secondaires globaux, choisissez Créer un index.
4. Sous Détails de l’index, saisissez Date la Clé de partition et laissez Type de données défini sur Chaîne.
5. Pour Nom de l'index, saisissez Date-index.
6. Laissez les valeurs par défaut de tous les autres paramètres, faites défiler l’écran vers le bas et choisissez Créer un index.

AWS SAM

Créer le tableau DynamoDB

Accédez au dossier dans lequel vous avez enregistré le fichier template.yaml de la table DynamoDB. Notez que cet exemple utilise deux fichiers template.yaml. Assurez-vous qu’ils sont enregistrés dans des sous-dossiers distincts et que vous vous trouvez dans le bon dossier contenant le modèle pour créer votre table DynamoDB.
Exécutez la commande suivante.
```
sam build
```
Cette commande rassemble les artefacts de création pour les ressources que vous souhaitez déployer et les place dans le format et l’emplacement appropriés pour les déployer.
Pour créer la ressource DynamoDB spécifiée dans le fichier template.yaml, exécutez la commande suivante.
```
sam deploy --guided
```
L’utilisation du drapeau --guided signifie qu’AWS SAM affiche des invites pour vous guider tout au long du processus de déploiement. Pour ce déploiement, définissez Stack name sur cron-app-test-db et acceptez les valeurs par défaut pour toutes les autres options à l’aide de la touche Entrée.

Lorsque AWS SAM a fini de créer vos ressources, vous devriez voir s’afficher le message suivant.
```
Successfully created/updated stack - cron-app-test-db in us-west-2
```
Vous pouvez également vérifier que la table DynamoDB a été créée en ouvrant la page Tables de la console DynamoDB. Vous devriez voir une table nommée MyOrderTable.

Après avoir créé votre table, vous devez ensuite ajouter des exemples de données pour tester votre application. Le fichier CSV sample_data.csv que vous avez téléchargé précédemment contient un certain nombre d’exemples d’entrées comprenant des numéros de commande, des dates et des informations sur les clients et les commandes. Utilisez le script python load_sample_data.py fourni pour ajouter ces données à votre table.

Pour ajouter les exemples de données à la table

Naviguez jusqu’au répertoire contenant les fichiers sample_data.csv et load_sample_data.py. Si ces fichiers se trouvent dans des répertoires distincts, déplacez-les afin qu’ils soient enregistrés au même endroit.
Créez un environnement virtuel Python dans lequel exécuter le script en exécutant la commande suivante. Nous vous recommandons d’utiliser un environnement virtuel, car lors de l’étape suivante, vous devrez installer l’AWS SDK pour Python (Boto3).
```
python -m venv venv
```
Activez l’environnement virtuel en exécutant la commande suivante.
```
source venv/bin/activate
```
Installez le kit SDK for Python (Boto3) dans votre environnement virtuel en exécutant la commande suivante. Le script utilise cette bibliothèque pour se connecter à votre table DynamoDB et ajouter les éléments.
```
pip install boto3
```
Exécutez le script pour remplir la table en exécutant la commande suivante.
```
python load_sample_data.py
```
Si le script s’exécute correctement, il doit afficher chaque élément sur la console au fur et à mesure du chargement et du rapport Data loading completed.
Désactivez l’environnement virtuel en exécutant la commande suivante.
```
deactivate
```
Vous pouvez vérifier que les données ont été chargées dans votre table DynamoDB en procédant comme suit :
1. Ouvrez la page Explorer les éléments de la console DynamoDB et sélectionnez votre table (MyOrderTable).
2. Dans le volet Éléments renvoyés, vous devriez voir les 25 éléments du fichier CSV que le script a ajouté à la table.

Création de l’application de maintenance planifiée

Vous pouvez créer et déployer les ressources de cet exemple d’application étape par étape à l’aide de l’AWS Management Console ou en utilisant AWS SAM. Dans un environnement de production, nous vous recommandons d’utiliser un outil d’infrastructure en tant que code (IaC) comme AWS SAM pour déployer rapidement et de manière répétitive des applications complètes sans serveur sans recourir à des processus manuels.

Pour cet exemple, suivez les instructions de la console pour découvrir comment configurer chaque ressource AWS séparément, ou suivez les instructions AWS SAM pour déployer rapidement l’application à l’aide des commandes de l’AWS CLI.

Console

Pour créer une fonction à l’aide de l’AWS Management Console

Créez d’abord une fonction contenant le code de démarrage de base. Vous remplacez ensuite ce code par votre propre code de fonction en copiant et collant le code directement dans l’éditeur de code Lambda ou en chargeant votre code en tant que package .zip. Pour cette tâche, nous vous recommandons de copier-coller le code.

Ouvrez la page Functions (Fonctions) de la console Lambda.
Choisissez Créer une fonction.
Choisissez Créer à partir de zéro.
Sous Informations de base, procédez comme suit :
1. Sous Nom de la fonction, saisissez ScheduledDBMaintenance.
2. Pour Environnement d’exécution, choisissez la dernière version de Python.
3. Pour Architecture, choisissez x86_64.
Choisissez Créer une fonction.
Une fois votre fonction créée, vous pouvez la configurer à l’aide du code de fonction fourni.
1. Dans le volet Source du code, remplacez le code Hello world créé par Lambda par le code de fonction Python du fichier lambda_function.py que vous avez enregistré précédemment.
2. Dans la section DÉPLOYER, choisissez Déployer pour mettre à jour le code de votre fonction :

Pour configurer la mémoire et le délai d’expiration d’une fonction (console)

Sélectionnez l’onglet Configuration correspondant à votre fonction.
Dans le volet de Configuration générale, choisissez Modifier.
Réglez Mémoire sur 256 Mo et Délai d’expiration sur 15 secondes. Si vous traitez une table volumineuse contenant de nombreux enregistrements, par exemple dans le cas d’un environnement de production, vous pouvez envisager de définir un délai d’expiration plus élevé. Cela donne à votre fonction plus de temps pour scanner et nettoyer la base de données.
Choisissez Enregistrer.

Pour configurer le format de journal (console)

Vous pouvez configurer les fonctions Lambda pour générer des journaux au format texte non structuré ou au format JSON. Nous vous recommandons d’utiliser le format JSON pour les journaux afin de faciliter la recherche et le filtrage des données de journal. Pour en savoir plus sur les options de configuration du journal Lambda, consultez Configuration de commandes de journalisation avancées pour votre fonction Lambda.

Sélectionnez l’onglet Configuration correspondant à votre fonction.
Sélectionnez Outils de surveillance et d’exploitation.
Dans le volet de configuration de la journalisation, choisissez Modifier.
Pour Configuration de journalisation, sélectionnez JSON.
Choisissez Enregistrer.

Pour configurer les autorisations IAM

Pour donner à votre fonction les autorisations nécessaires pour lire et supprimer des éléments DynamoDB, vous devez ajouter une politique au rôle d’exécution de votre fonction définissant les autorisations nécessaires.

Ouvrez l’onglet Configuration, puis choisissez Autorisations dans la barre de navigation de gauche.
Sous Rôle d’exécution, choisissez le nom du rôle.
Dans la console IAM, choisissez Ajouter des autorisations, puis Créer une politique intégrée.

Utilisez l’éditeur JSON et saisissez la politique suivante :


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

Nommez la politique DynamoDBCleanupPolicy, puis créez-la.

Pour configurer EventBridge Scheduler comme déclencheur (console)

Ouvrez la console EventBridge.
Dans le volet de navigation de gauche, choisissez Planificateurs dans la section Planificateur.
Choisissez Créer une planification.
Configurez la planification en procédant comme suit :
1. Pour Nom de la planification, saisissez un nom à attribuer à votre planification (par exemple, DynamoDBCleanupSchedule).
2. Sous Modèle de planification, choisissez Planification récurrente.
3. Pour Type de planification, laissez la valeur sur Planification basée sur Cron par défaut, puis saisissez les détails de planification suivants :
  - Minutes: 0
  - Heures: 3
  - Jour du mois: 1
  - Mois: *
  - Jour de la semaine: ?
  - Année: *
  Lorsqu’elle est évaluée, cette expression cron s’exécute le premier jour de chaque mois à 03h00.
4. Pour Fenêtre horaire flexible, sélectionnez Désactivé.
Choisissez Suivant.
Configurez le déclencheur de votre fonction Lambda en procédant comme suit :
1. Dans le volet Détails de la cible, laissez API de la cible définie sur Cibles modélisées, puis sélectionnez Invocation AWS Lambda.
2. Sous Invocation, sélectionnez votre fonction Lambda (ScheduledDBMaintenance) dans la liste déroulante.
3. Laissez Données utiles vide et choisissez Suivant.
4. Faites défiler la page jusqu’à Autorisations et sélectionnez Créer un rôle pour cette planification. Lorsque vous créez une planification EventBridge Scheduler à l’aide de la console, EventBridge Scheduler crée une politique avec les autorisations requises dont la planification a besoin pour invoquer votre fonction. Pour plus d’informations sur la gestion de vos autorisations de planification, consultez Cron-based schedules dans le Guide de l’utilisateur EventBridge Scheduler.
5. Choisissez Suivant.
Vérifiez vos paramètres et choisissez Créer une planification pour terminer la création de la planification et du déclencheur Lambda.

AWS SAM

Pour déployer l’application à l’aide d’AWS SAM

Accédez au dossier dans lequel vous avez enregistré le fichier template.yaml de l’application. Notez que cet exemple utilise deux fichiers template.yaml. Assurez-vous qu’ils sont enregistrés dans des sous-dossiers distincts et que vous vous trouvez dans le bon dossier contenant le modèle pour créer l’application.
Copiez les fichiers lambda_function.py et requirements.txt que vous avez téléchargés précédemment dans le même dossier. L’emplacement du code spécifié dans le modèle AWS SAM est ./, c’est-à-dire l’emplacement actuel. AWS SAM recherchera dans ce dossier le code de la fonction Lambda lorsque vous tenterez de déployer l’application.
Exécutez la commande suivante.
```
sam build --use-container
```
Cette commande rassemble les artefacts de création pour les ressources que vous souhaitez déployer et les place dans le format et l’emplacement appropriés pour les déployer. En spécifiant l’option --use-container, vous créez votre fonction à l’intérieur d’un conteneur Docker de type Lambda. Nous l’utilisons ici, vous n’avez donc pas besoin d’installer Python 3.12 sur votre machine locale pour que la compilation fonctionne.
Pour créer les ressources Lambda et EventBridge Scheduler spécifiées dans le fichier template.yaml, exécutez la commande suivante.
```
sam deploy --guided
```
L’utilisation du drapeau --guided signifie qu’AWS SAM affiche des invites pour vous guider tout au long du processus de déploiement. Pour ce déploiement, définissez Stack name sur cron-maintenance-app et acceptez les valeurs par défaut pour toutes les autres options à l’aide de la touche Entrée.

Lorsque AWS SAM a fini de créer les ressources Lambda et EventBridge Scheduler, le message suivant devrait s’afficher.
```
Successfully created/updated stack - cron-maintenance-app in us-west-2
```
Vous pouvez également vérifier que la fonction Lambda a été créée en ouvrant la page Fonctions de la console Lambda. Vous devriez voir une fonction nommée ScheduledDBMaintenance.

Test de l’application

Pour vérifier que votre planification déclenche correctement votre fonction et que celle-ci nettoie correctement les enregistrements de la base de données, vous pouvez modifier temporairement votre planification pour qu’elle ne s’exécute qu’une seule fois à une heure précise. Vous pouvez ensuite exécuter à nouveau sam deploy pour réinitialiser votre planification récurrente afin qu’elle s’exécute une fois par mois.

Pour exécuter l’application à l’aide de l’AWS Management Console

Revenez à la page de la console EventBridge Scheduler.
Choisissez votre planification, puis choisissez Modifier.
Dans la section Modèle de planification, sous Récurrence, sélectionnez Planification ponctuelle.
Réglez votre durée d’invocation sur quelques minutes, vérifiez vos paramètres, puis choisissez Enregistrer.

Une fois la planification exécutée et sa cible invoquée, vous exécutez le script test_app.py pour vérifier que votre fonction a bien supprimé tous les anciens enregistrements de la table DynamoDB.

Pour vérifier que les anciens enregistrements sont supprimés à l’aide d’un script Python

Dans votre ligne de commande, accédez au dossier dans lequel vous avez enregistré test_app.py.
Exécutez le script.
```
python test_app.py
```
En cas de succès, vous verrez la sortie suivante.
```
Total number of old records: 0
```

Étapes suivantes

Vous pouvez désormais modifier la planification d’EventBridge Scheduler pour répondre aux exigences spécifiques de votre application. EventBridge Scheduler prend en charge les expressions de planification suivantes : cron, rate et planifications ponctuelles.

Pour plus d’informations sur les expressions de planifications d’EventBridge Scheduler, consultez Schedule types dans le Guide de l’utilisateur EventBridge Scheduler. Gestion des accès dans le guide de l’utilisateur IAM

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Application de traitement de fichiers

Outils de développement