Création d’une application de maintenance planifiée de la base de données - AWS Lambda
PrérequisTéléchargement des exemples de fichiers d’applicationCréation et remplissage de l’exemple de table DynamoDBCréation de l’application de maintenance planifiéeTest de l’applicationÉtapes suivantes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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

Vous pouvez l'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 EventBridge Scheduler pour appeler une fonction Lambda selon un calendrier 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 enregistre 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 du AWS Management Console. Vous pouvez également déployer l'application en utilisant le 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'exemple d'application à l' AWS SAM aide, 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 le AWS SDK pour Python (Boto3), qui doit accéder à vos informations d'identification AWS Identity and Access Management (IAM). Vous devez également l' AWS CLI installer 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 Docker AWS SAM, vous devez é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 AWS SAM modèle 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 AWS SAM modèle 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

AWS SAM les modèles utilisent une convention de dénomination standard detemplate.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 AWS SAM modèle 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 le 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 le EventBridge planificateur, il utilise le AWS SDK pour Python (Boto3) pour créer une connexion à la table DynamoDB sur laquelle la tâche de maintenance planifiée doit être effectué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

AWS SAM les modèles utilisent une convention de dénomination standard detemplate.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 AWS SAM modèle définit les ressources de votre application. Nous définissons la fonction Lambda à l’aide de la ressource AWS::Serverless::Function. Le calendrier du EventBridge planificateur et le déclencheur permettant d'invoquer la fonction Lambda sont créés à l'aide de la Events propriété de cette ressource à l'aide d'un type de. ScheduleV2 Pour en savoir plus sur la définition des plannings du EventBridge planificateur dans les AWS SAM modèles, consultez ScheduleV2 dans le manuel du développeur.AWS Serverless Application Model

Outre la fonction Lambda et le calendrier du EventBridge planificateur, nous définissons également un groupe de CloudWatch journaux 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 le 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 AWS CLI commandes.

Console
Créer le tableau DynamoDB

  1. Ouvrez la page Tables (Tables) de la console DynamoDB.

  2. Choisissez Créer un tableau.

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

  4. 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. MyOrderTableChoisissez 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

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

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

  3. 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 --guided drapeau signifie que des instructions vous AWS SAM seront affichées 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.

    Une AWS SAM fois la création de la ressource DynamoDB terminée, le message suivant devrait s'afficher.

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

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

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

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

  3. Activez l’environnement virtuel en exécutant la commande suivante.

    source venv/bin/activate

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

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

  6. Désactivez l’environnement virtuel en exécutant la commande suivante.

    deactivate

  7. 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 pour cet exemple d'application étape par étape en utilisant AWS Management Console ou en utilisant AWS SAM. Dans un environnement de production, nous vous recommandons d'utiliser un outil Infrustracture-as-Code (iAc) permettant de déployer de manière répétitive des applications sans serveur sans recourir AWS SAM à des processus manuels.

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

Console
Pour créer la fonction à l'aide du 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.

  1. Ouvrez la page Functions (Fonctions) de la console Lambda.

  2. Choisissez Créer une fonction.

  3. Choisissez Créer à partir de zéro.

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

  5. Choisissez Créer une fonction.

  6. 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 :

      Bouton de déploiement dans l’éditeur de code de la console Lambda
Pour configurer la mémoire et le délai d’expiration d’une fonction (console)

  1. Sélectionnez l’onglet Configuration correspondant à votre fonction.

  2. Dans le volet de Configuration générale, choisissez Modifier.

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

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

  1. Sélectionnez l’onglet Configuration correspondant à votre fonction.

  2. Sélectionnez Outils de surveillance et d’exploitation.

  3. Dans le volet de configuration de la journalisation, choisissez Modifier.

  4. Pour Configuration de journalisation, sélectionnez JSON.

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

  1. Ouvrez l’onglet Configuration, puis choisissez Autorisations dans la barre de navigation de gauche.

  2. Sous Rôle d’exécution, choisissez le nom du rôle.

  3. Dans la console IAM, choisissez Ajouter des autorisations, puis Créer une politique intégrée.

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

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

Pour configurer le EventBridge planificateur en tant que déclencheur (console)

  1. Ouvrez la EventBridge console.

  2. Dans le volet de navigation de gauche, choisissez Planificateurs dans la section Planificateur.

  3. Choisissez Créer une planification.

  4. 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é.

  5. Choisissez Suivant.

  6. 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 un nouveau calendrier du EventBridge planificateur à l'aide de la console, le EventBridge planificateur crée une nouvelle politique avec les autorisations requises dont le calendrier a besoin pour appeler votre fonction. Pour plus d'informations sur la gestion de vos autorisations de planification, consultez la section Programmations basées sur Cron dans le guide de l'utilisateur du EventBridge planificateur.

    5. Choisissez Suivant.

  7. 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 de AWS SAM

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

  2. 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 AWS SAM modèle 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.

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

  4. Pour créer les ressources Lambda et EventBridge Scheduler spécifiées dans le template.yaml fichier, exécutez la commande suivante.

    sam deploy --guided

    L'utilisation du --guided drapeau signifie que des instructions vous AWS SAM seront affichées 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 vous aurez AWS SAM terminé 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

  5. 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 du AWS Management Console

  1. Retournez à la page de la console du EventBridge planificateur.

  2. Choisissez votre planification, puis choisissez Modifier.

  3. Dans la section Modèle de planification, sous Récurrence, sélectionnez Planification ponctuelle.

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

  1. Dans votre fenêtre de ligne de commande, accédez au dossier dans lequel vous avez enregistré test_app.py.

  2. 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 le calendrier du EventBridge planificateur pour répondre aux exigences spécifiques de votre application. EventBridge Le planificateur prend en charge les expressions de planification suivantes : cron, rate et plannings ponctuels.

Pour plus d'informations sur les expressions de planification du EventBridge planificateur, consultez la section Types de planification dans le guide de l'utilisateur du EventBridge planificateur.