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.

DynamoDB Streams et time-to-live

Vous pouvez sauvegarder ou traiter les éléments supprimés par Time to Live (TTL) en activant Amazon DynamoDB Streams sur la table et en traitant les enregistrements des flux des articles expirés. Pour de plus amples informations, veuillez consulter Lecture et traitement de flux.

L'enregistrement de flux contient un champ d'identité utilisateur Records[<index>].userIdentity.

Les éléments supprimés par le processus Time-to-live après expiration ont les champs suivants :

Ce qui suit JSON montre la partie pertinente d'un enregistrement de flux unique.

"Records": [
    {
        ...

        "userIdentity": {
            "type": "Service",
            "principalId": "dynamodb.amazonaws.com"
        }

        ...

    }
]

Utilisation de DynamoDB Streams et Lambda pour archiver les éléments supprimés TTL

La combinaison de DynamoDB Time to Live TTL (), DynamoDB Streams et AWS Lambda permet de simplifier l'archivage des données, de réduire les coûts de stockage DynamoDB et de réduire la complexité du code. L'utilisation de Lambda comme consommateur de flux présente de nombreux avantages, notamment la réduction des coûts par rapport à d'autres consommateurs tels que Kinesis Client Library (). KCL Les GetRecords API appels sur votre flux DynamoDB ne vous sont pas facturés lorsque vous utilisez Lambda pour consommer des événements, et Lambda peut fournir un filtrage des événements en identifiant des modèles dans un événement de flux. JSON Avec le filtrage de contenu des modèles d'événements, vous pouvez définir jusqu'à cinq filtres différents pour contrôler quels événements sont envoyés à Lambda en vue d'être traités. Cela permet de réduire les appels de vos fonctions Lambda, de simplifier le code et de réduire le coût global.

Alors que DynamoDB Streams contient toutes les modifications de données, telles que les actions Create, Modify et Remove, cela peut entraîner des appels indésirables de votre fonction Lambda d'archivage. Supposons, par exemple, que le flux de données soit modifié 2 millions de fois par heure, mais que moins de 5 % d'entre elles soient des suppressions d'éléments qui expireront au TTL cours du processus et devront être archivées. Avec les filtres de source d'événement Lambda, la fonction Lambda n'effectue que 100 000 appels par heure. Il en résulte que le filtrage des événements vous est facturé uniquement pour les appels nécessaires au lieu des 2 millions d'appels que vous auriez sans le filtrage des événements.

Le filtrage des événements est appliqué au mappage de source d'événement Lambda, une ressource qui lit à partir d'un événement choisi (le flux DynamoDB) et appelle une fonction Lambda. Dans le diagramme suivant, vous pouvez voir comment un élément time-to-live supprimé est consommé par une fonction Lambda utilisant des flux et des filtres d'événements.

Modèle de filtrage d'événement DynamoDB time-to-live

L'ajout des éléments suivants JSON à vos critères de filtre de mappage des sources d'événements permet d'invoquer votre fonction Lambda uniquement TTL pour les éléments supprimés :

{
    "Filters": [
        {
            "Pattern": { "userIdentity": { "type": ["Service"], "principalId": ["dynamodb.amazonaws.com"] } }
        }
    ]
}

Création d'un mappage des sources d' AWS Lambda événements

Utilisez les extraits de code suivants pour créer un mappage de source d'événement filtré que vous pouvez connecter au flux DynamoDB d'une table. Chaque bloc de code inclut le modèle de filtre d'événement.

AWS CLI

aws lambda create-event-source-mapping \
--event-source-arn 'arn:aws:dynamodb:eu-west-1:012345678910:table/test/stream/2021-12-10T00:00:00.000' \
--batch-size 10 \
--enabled \
--function-name test_func \
--starting-position LATEST \
--filter-criteria '{"Filters": [{"Pattern": "{\"userIdentity\":{\"type\":[\"Service\"],\"principalId\":[\"dynamodb.amazonaws.com\"]}}"}]}'

Java

LambdaClient client = LambdaClient.builder()
        .region(Region.EU_WEST_1)
        .build();

Filter userIdentity = Filter.builder()
        .pattern("{\"userIdentity\":{\"type\":[\"Service\"],\"principalId\":[\"dynamodb.amazonaws.com\"]}}")
        .build();

FilterCriteria filterCriteria = FilterCriteria.builder()
        .filters(userIdentity)
        .build();

CreateEventSourceMappingRequest mappingRequest = CreateEventSourceMappingRequest.builder()
        .eventSourceArn("arn:aws:dynamodb:eu-west-1:012345678910:table/test/stream/2021-12-10T00:00:00.000")
        .batchSize(10)
        .enabled(Boolean.TRUE)
        .functionName("test_func")
        .startingPosition("LATEST")
        .filterCriteria(filterCriteria)
        .build();

try{
    CreateEventSourceMappingResponse eventSourceMappingResponse = client.createEventSourceMapping(mappingRequest);
    System.out.println("The mapping ARN is "+eventSourceMappingResponse.eventSourceArn());

}catch (ServiceException e){
    System.out.println(e.getMessage());
}

Node

const client = new LambdaClient({ region: "eu-west-1" });

const input = {
    EventSourceArn: "arn:aws:dynamodb:eu-west-1:012345678910:table/test/stream/2021-12-10T00:00:00.000",
    BatchSize: 10,
    Enabled: true,
    FunctionName: "test_func",
    StartingPosition: "LATEST",
    FilterCriteria: { "Filters": [{ "Pattern": "{\"userIdentity\":{\"type\":[\"Service\"],\"principalId\":[\"dynamodb.amazonaws.com\"]}}" }] }
}

const command = new CreateEventSourceMappingCommand(input);

try {
    const results = await client.send(command);
    console.log(results);
} catch (err) {
    console.error(err);
}

Python

session = boto3.session.Session(region_name = 'eu-west-1')
client = session.client('lambda')

try:
    response = client.create_event_source_mapping(
        EventSourceArn='arn:aws:dynamodb:eu-west-1:012345678910:table/test/stream/2021-12-10T00:00:00.000',
        BatchSize=10,
        Enabled=True,
        FunctionName='test_func',
        StartingPosition='LATEST',
        FilterCriteria={
            'Filters': [
                {
                    'Pattern': "{\"userIdentity\":{\"type\":[\"Service\"],\"principalId\":[\"dynamodb.amazonaws.com\"]}}"
                },
            ]
        }
    )
    print(response)
except Exception as e:
    print(e)

JSON

{
  "userIdentity": {
     "type": ["Service"],
     "principalId": ["dynamodb.amazonaws.com"]
   }
}