Rechenzeit bis zur Lebenserwartung (TTL)

Eine gängige Methode zur Implementierung von TTL besteht darin, eine Ablaufzeit für Elemente festzulegen, die darauf basieren, wann sie erstellt oder zuletzt aktualisiert wurden. Dies kann durch Hinzufügen von Zeit zu den Zeitstempeln createdAt und updatedAt Zeitstempeln erreicht werden. Beispielsweise kann die TTL für neu erstellte Elemente auf createdAt + 90 Tage festgelegt werden. Wenn das Element aktualisiert wird, kann die TTL auf + 90 Tage neu berechnet werden. updatedAt

Die berechnete Ablaufzeit muss im Epochenformat in Sekunden angegeben werden. Um für Ablauf und Löschung in Betracht gezogen zu werden, darf die TTL nicht länger als fünf Jahre zurückliegen. Wenn Sie ein anderes Format verwenden, ignorieren die TTL-Prozesse das Element. Wenn Sie das Ablaufdatum auf einen Zeitpunkt in der future festlegen, an dem der Artikel ablaufen soll, ist der Artikel nach diesem Zeitpunkt abgelaufen. Angenommen, Sie haben das Ablaufdatum auf 1724241326 festgelegt (das ist Montag, 21. August 2024 11:55:26 (GMT)). Der Artikel läuft nach der angegebenen Zeit ab.

Erstellen Sie ein Objekt und legen Sie die Gültigkeitsdauer fest

Das folgende Beispiel zeigt, wie die Ablaufzeit berechnet wird, wenn ein neues Element erstellt wird, wobei 'expireAt' der TTL-Attributname für JavaScript und 'expirationDate' für Python verwendet wird. Eine Zuweisungsanweisung ruft die aktuelle Uhrzeit als Variable ab. In diesem Beispiel wird die Ablaufzeit mit 90 Tagen ab der aktuellen Uhrzeit berechnet. Die Zeit wird dann in das Epochenformat konvertiert und als Integer-Datentyp im TTL-Attribut gespeichert.

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

In dieser Anfrage fügen wir Logik hinzu, um die Ablaufzeit des neu erstellten Elements zu berechnen:

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');

Aktualisiere einen Artikel und aktualisiere die Gültigkeitsdauer

Dieses Beispiel ist eine Fortsetzung des Beispiels aus dem vorherigen Abschnitt. Die Ablaufzeit kann neu berechnet werden, wenn der Artikel aktualisiert wird. Im folgenden Beispiel wird der expireAt Zeitstempel neu berechnet, sodass er 90 Tage von der aktuellen Uhrzeit abweicht.

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')

Die Ausgabe des Aktualisierungsvorgangs zeigt, dass die Uhrzeit zwar unverändert ist, die createdAt Uhrzeit updatedAt und die expireAt Uhrzeit jedoch aktualisiert wurden. Die expireAt Uhrzeit ist jetzt auf 90 Tage ab dem Zeitpunkt der letzten Aktualisierung festgelegt, nämlich am Donnerstag, den 19. Oktober 2023 um 13:27:15 Uhr.

partition_key	createdAt	updatedAt	Läuft ab am	Attribut_1	Attribut_2
irgendein Wert	2023-07-17 14:11:05.322 323	2023-07-19 13:27:15,213 423	1697722035	new_value	irgendein Wert

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');

Die in dieser Einführung erörterten TTL-Beispiele demonstrieren eine Methode, mit der sichergestellt werden kann, dass nur kürzlich aktualisierte Elemente in einer Tabelle gespeichert werden. Aktualisierte Elemente haben eine längere Lebensdauer, wohingegen Elemente, die nach der Erstellung nicht aktualisiert wurden, ablaufen und kostenlos gelöscht werden, wodurch der Speicherplatz reduziert und die Tabellen sauber gehalten werden.