Travailler avec des articles expirés

Les éléments expirés en attente de suppression peuvent être exclus des opérations de lecture et d'écriture. Cela est utile dans les scénarios où les données expirées ne sont plus valides et ne doivent pas être utilisées. S'ils ne sont pas filtrés, ils continueront à s'afficher dans les opérations de lecture et d'écriture jusqu'à ce qu'ils soient supprimés par le processus en arrière-plan.

Note

Ces éléments sont toujours pris en compte dans les coûts de stockage et de lecture jusqu'à ce qu'ils soient supprimés.

Les suppressions TTL peuvent être identifiées dans DynamoDB Streams, mais uniquement dans la région où la suppression a eu lieu. Les suppressions TTL répliquées dans les régions de table globales ne sont pas identifiables dans les flux DynamoDB des régions vers lesquelles la suppression est répliquée.

Filtrer les éléments expirés des opérations de lecture

Pour les opérations de lecture telles que Scan et Query, une expression de filtre peut filtrer les éléments expirés en attente de suppression. Comme indiqué dans l'extrait de code ci-dessous, l'expression du filtre peut filtrer les éléments dont le temps TTL est égal ou inférieur à l'heure actuelle. Cela se fait à l'aide d'une instruction d'affectation qui obtient l'heure actuelle sous forme de variable (now), qui est convertie au format int epoch time.

Python

import boto3
from datetime import datetime


def query_dynamodb_items(table_name, partition_key):
    """

    :param table_name: Name of the DynamoDB table
    :param partition_key:
    :return:
    """
    try:
        # Initialize a DynamoDB resource
        dynamodb = boto3.resource('dynamodb',
                                  region_name='us-east-1')

        # Specify your table
        table = dynamodb.Table(table_name)

        # Get the current time in epoch format
        current_time = int(datetime.now().timestamp())

        # Perform the query operation with a filter expression to exclude expired items
        # response = table.query(
        #    KeyConditionExpression=boto3.dynamodb.conditions.Key('partitionKey').eq(partition_key),
        #    FilterExpression=boto3.dynamodb.conditions.Attr('expireAt').gt(current_time)
        # )
        response = table.query(
            KeyConditionExpression=dynamodb.conditions.Key('partitionKey').eq(partition_key),
            FilterExpression=dynamodb.conditions.Attr('expireAt').gt(current_time)
        )

        # Print the items that are not expired
        for item in response['Items']:
            print(item)

    except Exception as e:
        print(f"Error querying items: {e}")


# Call the function with your values
query_dynamodb_items('Music', 'your-partition-key-value')

Le résultat de l'opération de mise à jour indique que, bien que l'createdAtheure soit inchangée, les expireAt heures updatedAt et heures ont été mises à jour. Le expireAt délai est désormais fixé à 90 jours à compter de la dernière mise à jour, soit le jeudi 19 octobre 2023 à 13 h 27 min 15 s.

partition_key	createdAt	updatedAt	Expire à	attribut_1	attribut_2
une certaine valeur	2023-07-17 14:11:05 .322 323	2023-07-19 13:27:15 ,213 423	1697722035	new_value	une certaine valeur

Javascript

import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";

async function queryDynamoDBItems(tableName, region, primaryKey) {
    const client = new DynamoDBClient({
        region: region,
        endpoint: `https://dynamodb.${region}.amazonaws.com`
    });

    const currentTime = Math.floor(Date.now() / 1000);

    const params = {
        TableName: tableName,
        KeyConditionExpression: "#pk = :pk",
        FilterExpression: "#ea > :ea",
        ExpressionAttributeNames: {
            "#pk": "primaryKey",
            "#ea": "expireAt"
        },
        ExpressionAttributeValues: marshall({
            ":pk": primaryKey,
            ":ea": currentTime
        })
    };

    try {
        const { Items } = await client.send(new QueryCommand(params));
        Items.forEach(item => {
            console.log(unmarshall(item))
        });
        return Items;
    } catch (err) {
        console.error(`Error querying items: ${err}`);
        throw err;
    }
}

//enter your own values here
queryDynamoDBItems('your-table-name', 'your-partition-key-value');

Écrire de manière conditionnelle aux articles expirés

Une expression de condition peut être utilisée pour éviter les écritures sur des éléments expirés. L'extrait de code ci-dessous est une mise à jour conditionnelle qui vérifie si le délai d'expiration est supérieur à l'heure actuelle. Si c'est vrai, l'opération d'écriture se poursuivra.

Python

import boto3
from datetime import datetime, timedelta
from botocore.exceptions import ClientError


def update_dynamodb_item(table_name, region, primary_key, sort_key, ttl_attribute):
    """
    Updates an existing record in a DynamoDB table with a new or updated TTL attribute.

    :param table_name: Name of the DynamoDB table
    :param region: AWS Region of the table - example `us-east-1`
    :param primary_key: one attribute known as the partition key.
    :param sort_key: Also known as a range attribute.
    :param ttl_attribute: name of the TTL attribute in the target DynamoDB table
    :return:
    """
    try:
        dynamodb = boto3.resource('dynamodb', region_name=region)
        table = dynamodb.Table(table_name)

        # Generate updated TTL in epoch second format
        updated_expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())

        # Define the update expression for adding/updating a new attribute
        update_expression = "SET newAttribute = :val1"

        # Define the condition expression for checking if 'ttlExpirationDate' is not expired
        condition_expression = "ttlExpirationDate > :val2"

        # Define the expression attribute values
        expression_attribute_values = {
            ':val1': ttl_attribute,
            ':val2': updated_expiration_time
        }

        response = table.update_item(
            Key={
                'primaryKey': primary_key,
                'sortKey': sort_key
            },
            UpdateExpression=update_expression,
            ConditionExpression=condition_expression,
            ExpressionAttributeValues=expression_attribute_values
        )

        print("Item updated successfully.")
        return response['ResponseMetadata']['HTTPStatusCode']  # Ideally a 200 OK
    except ClientError as e:
        if e.response['Error']['Code'] == "ConditionalCheckFailedException":
            print("Condition check failed: Item's 'ttlExpirationDate' is expired.")
        else:
            print(f"Error updating item: {e}")
    except Exception as e:
        print(f"Error updating item: {e}")


# replace with your values
update_dynamodb_item('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value',
                     'your-ttl-attribute-value')

Le résultat de l'opération de mise à jour indique que, bien que l'createdAtheure soit inchangée, les expireAt heures updatedAt et heures ont été mises à jour. Le expireAt délai est désormais fixé à 90 jours à compter de la dernière mise à jour, soit le jeudi 19 octobre 2023 à 13 h 27 min 15 s.

partition_key	createdAt	updatedAt	Expire à	attribut_1	attribut_2
une certaine valeur	2023-07-17 14:11:05 .322 323	2023-07-19 13:27:15 ,213 423	1697722035	new_value	une certaine valeur

Javascript

import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";


// Example function to update an item in a DynamoDB table.
//  The function should take the table name, region, partition key, sort key, and new attribute as arguments.
//  The function should use the DynamoDB client to update the item.
//  The function should return the updated item.
//  The function should handle errors and exceptions.
const updateDynamoDBItem = async (tableName, region, partitionKey, sortKey, newAttribute) => {
    const client = new DynamoDBClient({
        region: region,
        endpoint: `https://dynamodb.${region}.amazonaws.com`
    });

    const currentTime = Math.floor(Date.now() / 1000);

    const params = {
        TableName: tableName,
        Key: marshall({
            artist: partitionKey,
            album: sortKey
        }),
        UpdateExpression: "SET newAttribute = :newAttribute",
        ConditionExpression: "expireAt > :expiration",
        ExpressionAttributeValues: marshall({
            ':newAttribute': newAttribute,
            ':expiration': currentTime
        }),
        ReturnValues: "ALL_NEW"
    };

    try {
        const response = await client.send(new UpdateItemCommand(params));
        const responseData = unmarshall(response.Attributes);
        console.log("Item updated successfully: ", responseData);
        return responseData;
    } catch (error) {
        if (error.name === "ConditionalCheckFailedException") {
            console.log("Condition check failed: Item's 'expireAt' is expired.");
        } else {
            console.error("Error updating item: ", error);
        }
        throw error;
    }
};

// Enter your values here
updateDynamoDBItem('your-table-name', "us-east-1",'your-partition-key-value', 'your-sort-key-value', 'your-new-attribute-value');

Identification des éléments supprimés dans DynamoDB Streams

L'enregistrement de flux contient un champ d'identité utilisateur Records[<index>].userIdentity. Les éléments supprimés par le processus TTL comportent les champs suivants :

Records[<index>].userIdentity.type
"Service"

Records[<index>].userIdentity.principalId
"dynamodb.amazonaws.com"

Le JSON suivant montre la partie pertinente d'un enregistrement de flux unique :

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