Durée de vie calculée (TTL)

Une méthode courante pour implémenter le TTL consiste à définir un délai d'expiration pour les éléments en fonction de leur date de création ou de dernière mise à jour. Cela peut être fait en ajoutant l'heure aux updatedAt horodatages createdAt et. Par exemple, le TTL pour les articles nouvellement créés peut être défini sur createdAt + 90 jours. Lorsque l'article est mis à jour, le TTL peut être recalculé à updatedAt + 90 jours.

Le délai d'expiration calculé doit être au format Epoch, en secondes. Pour que l'expiration et la suppression soient prises en compte, le TTL ne doit pas dater de plus de cinq ans. Si vous utilisez un autre format, les processus TTL ignorent l'élément. Si vous définissez la date d'expiration à un moment futur où vous souhaitez que l'article expire, l'article expirera après cette date. Supposons, par exemple, que vous ayez défini la date d'expiration sur 1724241326 (c'est-à-dire le lundi 21 août 2024 11:55:26 (GMT)). L'article expirera après le délai spécifié.

Créez un article et définissez le Time to Live

L'exemple suivant montre comment calculer le délai d'expiration lors de la création d'un nouvel élément, en utilisant 'expireAt' comme nom d'attribut TTL pour JavaScript et 'expirationDate' pour Python. Une instruction d'affectation obtient l'heure actuelle sous forme de variable. Dans l'exemple, le délai d'expiration est calculé comme étant de 90 jours à compter de l'heure actuelle. L'heure est ensuite convertie au format epoch et enregistrée sous forme de type de données entier dans l'attribut TTL.

Python

import boto3
from datetime import datetime, timedelta


def create_dynamodb_item(table_name, region, primary_key, sort_key):
    """
    Creates a DynamoDB item with an attached expiry attribute.

    :param table_name: Table name for the boto3 resource to target when creating an item
    :param region: string representing the AWS region. Example: `us-east-1`
    :param primary_key: one attribute known as the partition key.
    :param sort_key: Also known as a range attribute.
    :return: Void (nothing)
    """
    try:
        dynamodb = boto3.resource('dynamodb', region_name=region)
        table = dynamodb.Table(table_name)

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

        # Calculate the expiration time (90 days from now) in epoch second format
        expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())

        item = {
            'primaryKey': primary_key,
            'sortKey': sort_key,
            'creationDate': current_time,
            'expirationDate': expiration_time
        }

        table.put_item(Item=item)

        print("Item created successfully.")
    except Exception as e:
        print(f"Error creating item: {e}")
        raise


# Use your own values
create_dynamodb_item('your-table-name', 'us-west-2', 'your-partition-key-value', 'your-sort-key-value')

JavaScript

Dans cette demande, nous ajoutons une logique pour calculer le délai d'expiration de l'article nouvellement créé :

import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";

function createDynamoDBItem(table_name, region, partition_key, sort_key) {
    const client = new DynamoDBClient({
        region: region,
        endpoint: `https://dynamodb.${region}.amazonaws.com`
    });

    // Get the current time in epoch second format
    const current_time = Math.floor(new Date().getTime() / 1000);

    // Calculate the expireAt time (90 days from now) in epoch second format
    const expire_at = Math.floor((new Date().getTime() + 90 * 24 * 60 * 60 * 1000) / 1000);

    // Create DynamoDB item
    const item = {
        'partitionKey': {'S': partition_key},
        'sortKey': {'S': sort_key},
        'createdAt': {'N': current_time.toString()},
        'expireAt': {'N': expire_at.toString()}
    };

    const putItemCommand = new PutItemCommand({
        TableName: table_name,
        Item: item,
        ProvisionedThroughput: {
            ReadCapacityUnits: 1,
            WriteCapacityUnits: 1,
        },
    });

    client.send(putItemCommand, function(err, data) {
        if (err) {
            console.log("Exception encountered when creating item %s, here's what happened: ", data, ex);
            throw err;
        } else {
            console.log("Item created successfully: %s.", data);
            return data;
        }
    });
}

// use your own values
createDynamoDBItem('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value');

Mettre à jour un élément et actualiser le Time to Live

Cet exemple est la suite de celui de la section précédente. Le délai d'expiration peut être recalculé si l'article est mis à jour. L'exemple suivant recalcule l'expireAthorodatage à 90 jours à partir de l'heure actuelle.

Python

import boto3
from datetime import datetime, timedelta


def update_dynamodb_item(table_name, region, primary_key, sort_key):
    """
    Update an existing DynamoDB item with a TTL.
    :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.
    :return: Void (nothing)
    """
    try:
        # Create the DynamoDB resource.
        dynamodb = boto3.resource('dynamodb', region_name=region)
        table = dynamodb.Table(table_name)

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

        # Calculate the expireAt time (90 days from now) in epoch second format
        expire_at = int((datetime.now() + timedelta(days=90)).timestamp())

        table.update_item(
            Key={
                'partitionKey': primary_key,
                'sortKey': sort_key
            },
            UpdateExpression="set updatedAt=:c, expireAt=:e",
            ExpressionAttributeValues={
                ':c': current_time,
                ':e': expire_at
            },
        )

        print("Item updated successfully.")
    except Exception as e:
        print(f"Error updating item: {e}")


# Replace with your own values
update_dynamodb_item('your-table-name', 'us-west-2', 'your-partition-key-value', 'your-sort-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 date 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";

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

    const currentTime = Math.floor(Date.now() / 1000);
    const expireAt = Math.floor((Date.now() + 90 * 24 * 60 * 60 * 1000) / 1000); ////is there a better way to do this?

    const params = {
        TableName: tableName,
        Key: marshall({
            partitionKey: partitionKey,
            sortKey: sortKey
        }),
        UpdateExpression: "SET updatedAt = :c, expireAt = :e",
        ExpressionAttributeValues: marshall({
            ":c": currentTime,
            ":e": expireAt
        }),
    };

    try {
        const data = await client.send(new UpdateItemCommand(params));
        const responseData = unmarshall(data.Attributes);
        console.log("Item updated successfully: %s", responseData);
        return responseData;
    } catch (err) {
        console.error("Error updating item:", err);
        throw err;
    }
}

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

Les exemples TTL présentés dans cette introduction illustrent une méthode permettant de garantir que seuls les éléments récemment mis à jour sont conservés dans une table. Les éléments mis à jour voient leur durée de vie prolongée, tandis que les éléments non mis à jour après leur création expirent et sont supprimés gratuitement, ce qui réduit le stockage et permet de maintenir des tables propres.