Como calcular a vida útil (TTL)
Uma forma comum de implementar a TTL é definir um prazo de validade para os itens com base em quando eles foram criados ou atualizados pela última vez. Isso pode ser feito adicionando hora aos carimbos de data e hora createdAt e updatedAt. Por exemplo, a TTL para itens recém-criados pode ser definida como createdAt + noventa dias. Quando o item é atualizado, a TTL pode ser recalculada para updatedAt + noventa dias.
O prazo de validade calculado deve estar no formato de época, em segundos. Para ser considerada para validade e exclusão, a TTL não pode ter mais de cinco anos no passado. Se você usar qualquer outro formato, os processos TTL ignorarão o item. Se você definir a data de validade como algum momento no futuro em que quiser que o item expire, o item vai expirar após esse período. Por exemplo, digamos que você defina a data de validade como 1724241326 (que é segunda-feira, 21 de agosto de 2024, 11:55:26 (GMT)). O item vai expirar após o horário especificado.
Criar um item e definir a vida útil
O exemplo a seguir demonstra como calcular o prazo de validade ao criar um item, usando 'expireAt' como nome do atributo TTL para JavaScript e 'expirationDate' para Python. Uma declaração de atribuição exibe a hora atual como uma variável. No exemplo, o prazo de validade é calculado como noventa dias a partir do horário atual. A hora é então convertida no formato de época e salva como um tipo de dados inteiro no atributo 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
-
Nessa solicitação, adicionamos lógica para calcular o prazo de validade do item recém-criado:
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');
Atualizar um item e atualizar a vida útil
Este exemplo é uma continuação do exemplo da seção anterior. O prazo de validade poderá ser recalculado se o item for atualizado. O exemplo a seguir recalcula o carimbo de data e hora expireAt para ser noventa dias a partir da hora atual.
- 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')
A saída da operação de atualização mostra que, embora o horário createdAt permaneça inalterado, os horários updatedAt e expireAt foram atualizados. O horário expireAt agora está definido como noventa dias desde o momento da última atualização, que é quinta-feira, 19 de outubro de 2023, às 13:27:15.
| partition_key |
createdAt |
updatedAt |
expireAt |
attribute_1 |
attribute_2 |
|
some_value
|
2023-07-17 14:11:05.322323 |
2023-07-19 13:27:15.213423 |
1697722035 |
new_value |
some_value |
- 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');
Os exemplos de TTL abordados nesta introdução demonstram um método que garante que somente os itens atualizados recentemente sejam mantidos em uma tabela. Os itens atualizados têm sua vida útil estendida, enquanto os itens não atualizados após a criação expiram e são excluídos sem nenhum custo, reduzindo o armazenamento e mantendo as tabelas limpas.
