# Noções básicas sobre o throughput a quente do DynamoDB
*Throughput a quente* refere-se ao número de operações de leitura e de gravação que sua tabela do DynamoDB pode comportar instantaneamente. Esses valores estão disponíveis por padrão para todas as tabelas e índices secundários globais (GSI) e representam o quanto eles foram ajustados com base no histórico de uso. Se você estiver usando o modo sob demanda ou se atualizar o throughput provisionado para esses valores, sua aplicação poderá emitir solicitações até esses valores instantaneamente.
O DynamoDB ajustará automaticamente os valores de throughput a quente à medida que o uso aumentar. Você também pode aumentar esses valores de maneira proativa quando necessário, o que é especialmente útil para eventos de pico futuros, como lançamentos de produtos ou vendas. Em relação a eventos de pico planejados, nos quais as taxas de solicitação para sua tabela do DynamoDB podem aumentar em 10x, 100x ou mais, agora você pode avaliar se o throughput a quente atual é suficiente para lidar com o tráfego esperado. Caso não seja, você poderá aumentar o valor de throughput a quente sem alterar suas configurações de throughput nem o [modo de faturamento](capacity-mode.md). Esse processo é conhecido como *preaquecimento* de uma tabela. Ele permite que você defina uma linha de base que suas tabelas possam comportar instantaneamente. Isso garante que as aplicações possam lidar com taxas de solicitação mais altas a partir do momento em que elas ocorrem. Depois de aumentados, os valores de taxa de throughput a quente não podem ser diminuídos.
É possível aumentar o valor do throughput a quente para operações de leitura, de gravação ou ambas. É possível aumentar esse valor para tabelas de região única novas e existentes, tabelas globais e GSIs. Em relação a tabelas globais, esse recurso está disponível para a [versão 2019.11.21 (atual)](GlobalTables.md), e as configurações de throughput a quente que você definir serão aplicadas automaticamente a todas as tabelas de réplica na tabela global. Não há limite para o número de tabelas do DynamoDB que você pode preaquecer a qualquer momento. O tempo para concluir o preaquecimento depende dos valores definidos e do tamanho da tabela ou do índice. É possível enviar solicitações simultâneas de preaquecimento, e essas solicitações não interferirão em nenhuma operação da tabela. É possível preaquecer a tabela até o limite de cota de tabela ou do índice da sua conta nessa região. Use o [console do Service Quotas](https://console.aws.amazon.com/servicequotas) para conferir seus limites atuais e aumentá-los, se necessário.
Os valores de throughput a quente estão disponíveis por padrão para todas as tabelas e índices secundários, sem nenhum custo. No entanto, se você aumentar proativamente esses valores padrão de throughput a quente para preaquecer as tabelas, haverá cobranças por essas solicitações. Para obter mais informações, consulte a [Definição de preço do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Para ter mais informações sobre throughput a quente, consulte os seguintes tópicos:
**Topics**
+ [Conferir o throughput a quente atual da tabela do DynamoDB](check-warm-throughput.md)
+ [Aumentar o throughput a quente de sua tabela existente do DynamoDB](update-warm-throughput.md)
+ [Criar uma tabela do DynamoDB com um throughput a quente mais alto](create-table-warm-throughput.md)
+ [Noções básicas sobre throughput a quente do DynamoDB em diferentes cenários](warm-throughput-scenarios.md)
# Conferir o throughput a quente atual da tabela do DynamoDB
Use as instruções a seguir da AWS CLI e do console da AWS para conferir o valor atual do throughput a quente da tabela ou do índice.
## Console de gerenciamento da AWS
Para conferir o throughput a quente da sua tabela do DynamoDB usando o console do DynamoDB:
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação à esquerda, selecione Tables (Tabelas).
1. Na página **Tabelas**, escolha a tabela desejada.
1. Selecione **Configurações adicionais** para visualizar o valor atual do throughput a quente. Esse valor é mostrado como unidades de leitura e de gravação por segundo.
## AWS CLI
O exemplo da AWS CLI a seguir mostra como conferir o throughput a quente da tabela do DynamoDB.
1. Execute a operação `describe-table` na tabela do DynamoDB.
```
aws dynamodb describe-table --table-name GameScores
```
1. Você receberá uma resposta semelhante à seguinte. Suas configurações de `WarmThroughput` serão exibidas como `ReadUnitsPerSecond` e `WriteUnitsPerSecond`. O `Status` será `UPDATING` quando o valor de throughput a quente estiver sendo atualizado, e `ACTIVE` quando o novo valor de throughput a quente for definido.
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "TopScore",
"AttributeType": "N"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "ACTIVE",
"CreationDateTime": 1726128388.729,
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 0,
"WriteCapacityUnits": 0
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores",
"TableId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
"BillingModeSummary": {
"BillingMode": "PAY_PER_REQUEST",
"LastUpdateToPayPerRequestDateTime": 1726128388.729
},
"GlobalSecondaryIndexes": [
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"UserId"
]
},
"IndexStatus": "ACTIVE",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 0,
"WriteCapacityUnits": 0
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores/index/GameTitleIndex",
"WarmThroughput": {
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000,
"Status": "ACTIVE"
}
}
],
"DeletionProtectionEnabled": false,
"WarmThroughput": {
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000,
"Status": "ACTIVE"
}
}
}
```
# Aumentar o throughput a quente de sua tabela existente do DynamoDB
Depois de conferir o valor atual do throughput a quente da tabela do DynamoDB, você poderá atualizá-lo por meio das seguintes etapas:
## Console de gerenciamento da AWS
Para conferir o throughput a quente da sua tabela do DynamoDB usando o console do DynamoDB:
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação à esquerda, selecione Tables (Tabelas).
1. Na página **Tabelas**, escolha a tabela desejada.
1. No campo **Throughput a quente**, selecione **Editar**.
1. Na página **Editar throughput a quente**, escolha **Aumentar throughput a quente**.
1. Ajuste as **unidades de leitura por segundo** e **unidades de gravação por segundo**. Essas duas configurações definem o throughput que sua tabela pode processar instantaneamente.
1. Selecione **Salvar**.
1. Suas **unidades de leitura por segundo** e **unidades de gravação por segundo** serão atualizadas no campo **Throughput a quente** quando o processamento da solicitação for concluído.
**nota**
Atualizar o valor de throughput a quente é uma tarefa assíncrona. O `Status` mudará de `UPDATING` para `ACTIVE` quando a atualização for concluída.
## AWS CLI
O exemplo de AWS CLI a seguir mostra como atualizar o valor de throughput a quente da tabela do DynamoDB.
1. Execute a operação `update-table` na tabela do DynamoDB.
```
aws dynamodb update-table \
--table-name GameScores \
--warm-throughput ReadUnitsPerSecond=12345,WriteUnitsPerSecond=4567 \
--global-secondary-index-updates \
"[
{
\"Update\": {
\"IndexName\": \"GameTitleIndex\",
\"WarmThroughput\": {
\"ReadUnitsPerSecond\": 88,
\"WriteUnitsPerSecond\": 77
}
}
}
]" \
--region us-east-1
```
1. Você receberá uma resposta semelhante à seguinte. Suas configurações de `WarmThroughput` serão exibidas como `ReadUnitsPerSecond` e `WriteUnitsPerSecond`. O `Status` será `UPDATING` quando o valor de throughput a quente estiver sendo atualizado, e `ACTIVE` quando o novo valor de throughput a quente for definido.
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "TopScore",
"AttributeType": "N"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "ACTIVE",
"CreationDateTime": 1730242189.965,
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 20,
"WriteCapacityUnits": 10
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores",
"TableId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
"GlobalSecondaryIndexes": [
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"UserId"
]
},
"IndexStatus": "ACTIVE",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 50,
"WriteCapacityUnits": 25
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores/index/GameTitleIndex",
"WarmThroughput": {
"ReadUnitsPerSecond": 50,
"WriteUnitsPerSecond": 25,
"Status": "UPDATING"
}
}
],
"DeletionProtectionEnabled": false,
"WarmThroughput": {
"ReadUnitsPerSecond": 12300,
"WriteUnitsPerSecond": 4500,
"Status": "UPDATING"
}
}
}
```
## AWS SDK
Os exemplos de SDK a seguir mostram como atualizar o valor de throughput a quente da tabela do DynamoDB.
------
#### [ Java ]
```
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.GlobalSecondaryIndexUpdate;
import software.amazon.awssdk.services.dynamodb.model.UpdateGlobalSecondaryIndexAction;
import software.amazon.awssdk.services.dynamodb.model.UpdateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.WarmThroughput;
...
public static WarmThroughput buildWarmThroughput(final Long readUnitsPerSecond,
final Long writeUnitsPerSecond) {
return WarmThroughput.builder()
.readUnitsPerSecond(readUnitsPerSecond)
.writeUnitsPerSecond(writeUnitsPerSecond)
.build();
}
public static void updateDynamoDBTable(DynamoDbClient ddb,
String tableName,
Long tableReadUnitsPerSecond,
Long tableWriteUnitsPerSecond,
String globalSecondaryIndexName,
Long globalSecondaryIndexReadUnitsPerSecond,
Long globalSecondaryIndexWriteUnitsPerSecond) {
final WarmThroughput tableWarmThroughput = buildWarmThroughput(tableReadUnitsPerSecond, tableWriteUnitsPerSecond);
final WarmThroughput gsiWarmThroughput = buildWarmThroughput(globalSecondaryIndexReadUnitsPerSecond, globalSecondaryIndexWriteUnitsPerSecond);
final GlobalSecondaryIndexUpdate globalSecondaryIndexUpdate = GlobalSecondaryIndexUpdate.builder()
.update(UpdateGlobalSecondaryIndexAction.builder()
.indexName(globalSecondaryIndexName)
.warmThroughput(gsiWarmThroughput)
.build()
).build();
final UpdateTableRequest request = UpdateTableRequest.builder()
.tableName(tableName)
.globalSecondaryIndexUpdates(globalSecondaryIndexUpdate)
.warmThroughput(tableWarmThroughput)
.build();
try {
ddb.updateTable(request);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.out.println("Done!");
}
```
------
#### [ Python ]
```
from boto3 import resource
from botocore.exceptions import ClientError
def update_dynamodb_table_warm_throughput(table_name, table_read_units, table_write_units, gsi_name, gsi_read_units, gsi_write_units, region_name="us-east-1"):
"""
Updates the warm throughput of a DynamoDB table and a global secondary index.
:param table_name: The name of the table to update.
:param table_read_units: The new read units per second for the table's warm throughput.
:param table_write_units: The new write units per second for the table's warm throughput.
:param gsi_name: The name of the global secondary index to update.
:param gsi_read_units: The new read units per second for the GSI's warm throughput.
:param gsi_write_units: The new write units per second for the GSI's warm throughput.
:param region_name: The AWS Region name to target. defaults to us-east-1
"""
try:
ddb = resource('dynamodb', region_name)
# Update the table's warm throughput
table_warm_throughput = {
"ReadUnitsPerSecond": table_read_units,
"WriteUnitsPerSecond": table_write_units
}
# Update the global secondary index's warm throughput
gsi_warm_throughput = {
"ReadUnitsPerSecond": gsi_read_units,
"WriteUnitsPerSecond": gsi_write_units
}
# Construct the global secondary index update
global_secondary_index_update = [
{
"Update": {
"IndexName": gsi_name,
"WarmThroughput": gsi_warm_throughput
}
}
]
# Construct the update table request
update_table_request = {
"TableName": table_name,
"GlobalSecondaryIndexUpdates": global_secondary_index_update,
"WarmThroughput": table_warm_throughput
}
# Update the table
ddb.update_table(**update_table_request)
print("Table updated successfully!")
except ClientError as e:
print(f"Error updating table: {e}")
raise e
```
------
#### [ Javascript ]
```
import { DynamoDBClient, UpdateTableCommand } from "@aws-sdk/client-dynamodb";
async function updateDynamoDBTableWarmThroughput(
tableName,
tableReadUnits,
tableWriteUnits,
gsiName,
gsiReadUnits,
gsiWriteUnits,
region = "us-east-1"
) {
try {
const ddbClient = new DynamoDBClient({ region: region });
// Construct the update table request
const updateTableRequest = {
TableName: tableName,
GlobalSecondaryIndexUpdates: [
{
Update: {
IndexName: gsiName,
WarmThroughput: {
ReadUnitsPerSecond: gsiReadUnits,
WriteUnitsPerSecond: gsiWriteUnits,
},
},
},
],
WarmThroughput: {
ReadUnitsPerSecond: tableReadUnits,
WriteUnitsPerSecond: tableWriteUnits,
},
};
const command = new UpdateTableCommand(updateTableRequest);
const response = await ddbClient.send(command);
console.log(`Table updated successfully! Response: ${response}`);
} catch (error) {
console.error(`Error updating table: ${error}`);
throw error;
}
}
```
------
# Criar uma tabela do DynamoDB com um throughput a quente mais alto
É possível ajustar os valores de throughput a quente ao criar sua tabela do DynamoDB seguindo as etapas abaixo. Essas etapas também se aplicam ao criar uma [tabela global](GlobalTables.md) ou um [índice secundário](SecondaryIndexes.md).
## Console de gerenciamento da AWS
Para criar uma tabela do DynamoDB e ajustar os valores de throughput a quente por meio do console:
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. Selecione **Criar tabela**.
1. Escolha o **Nome da tabela**, a **Chave de partição** e a **Chave de classificação (opcional)**.
1. Em **Configurações da tabela**, selecione **Personalizar configurações**.
1. No campo **Throughput a quente**, escolha **Aumentar throughput a quente**.
1. Ajuste as **unidades de leitura por segundo** e **unidades de gravação por segundo**. Essas duas configurações definem o throughput máximo que sua tabela pode processar instantaneamente.
1. Continue adicionando os detalhes restantes da tabela e selecione **Criar tabela**.
## AWS CLI
O exemplo da AWS CLI a seguir mostra como criar uma tabela do DynamoDB com valores personalizados de throughput a quente.
1. Execute a operação `create-table` para criar a tabela do DynamoDB a seguir.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S \
AttributeName=GameTitle,AttributeType=S \
AttributeName=TopScore,AttributeType=N \
--key-schema AttributeName=UserId,KeyType=HASH \
AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=20,WriteCapacityUnits=10 \
--global-secondary-indexes \
"[
{
\"IndexName\": \"GameTitleIndex\",
\"KeySchema\": [{\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
{\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE\"}],
\"Projection\":{
\"ProjectionType\":\"INCLUDE\",
\"NonKeyAttributes\":[\"UserId\"]
},
\"ProvisionedThroughput\": {
\"ReadCapacityUnits\": 50,
\"WriteCapacityUnits\": 25
},\"WarmThroughput\": {
\"ReadUnitsPerSecond\": 1987,
\"WriteUnitsPerSecond\": 543
}
}
]" \
--warm-throughput ReadUnitsPerSecond=12345,WriteUnitsPerSecond=4567 \
--region us-east-1
```
1. Você receberá uma resposta semelhante à seguinte. Suas configurações de `WarmThroughput` serão exibidas como `ReadUnitsPerSecond` e `WriteUnitsPerSecond`. O `Status` será `UPDATING` quando o valor de throughput a quente estiver sendo atualizado, e `ACTIVE` quando o novo valor de throughput a quente for definido.
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "TopScore",
"AttributeType": "N"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": 1730241788.779,
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 20,
"WriteCapacityUnits": 10
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores",
"TableId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
"GlobalSecondaryIndexes": [
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"UserId"
]
},
"IndexStatus": "CREATING",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 50,
"WriteCapacityUnits": 25
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-east-1:XXXXXXXXXXXX:table/GameScores/index/GameTitleIndex",
"WarmThroughput": {
"ReadUnitsPerSecond": 1987,
"WriteUnitsPerSecond": 543,
"Status": "UPDATING"
}
}
],
"DeletionProtectionEnabled": false,
"WarmThroughput": {
"ReadUnitsPerSecond": 12345,
"WriteUnitsPerSecond": 4567,
"Status": "UPDATING"
}
}
}
```
## AWS SDK
Os exemplos de SDK a seguir mostram como criar uma tabela do DynamoDB com valores personalizados de throughput a quente.
------
#### [ Java ]
```
import software.amazon.awscdk.services.dynamodb.ProjectionType;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.CreateTableResponse;
import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;
import software.amazon.awssdk.services.dynamodb.model.KeyType;
import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughput;
import software.amazon.awssdk.services.dynamodb.model.Projection;
import software.amazon.awssdk.services.dynamodb.model.GlobalSecondaryIndex;
import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;
import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;
import software.amazon.awssdk.services.dynamodb.model.WarmThroughput;
...
public static WarmThroughput buildWarmThroughput(final Long readUnitsPerSecond,
final Long writeUnitsPerSecond) {
return WarmThroughput.builder()
.readUnitsPerSecond(readUnitsPerSecond)
.writeUnitsPerSecond(writeUnitsPerSecond)
.build();
}
private static AttributeDefinition buildAttributeDefinition(final String attributeName,
final ScalarAttributeType scalarAttributeType) {
return AttributeDefinition.builder()
.attributeName(attributeName)
.attributeType(scalarAttributeType)
.build();
}
private static KeySchemaElement buildKeySchemaElement(final String attributeName,
final KeyType keyType) {
return KeySchemaElement.builder()
.attributeName(attributeName)
.keyType(keyType)
.build();
}
public static void createDynamoDBTable(DynamoDbClient ddb,
String tableName,
String partitionKey,
String sortKey,
String miscellaneousKeyAttribute,
String nonKeyAttribute,
Long tableReadCapacityUnits,
Long tableWriteCapacityUnits,
Long tableWarmReadUnitsPerSecond,
Long tableWarmWriteUnitsPerSecond,
String globalSecondaryIndexName,
Long globalSecondaryIndexReadCapacityUnits,
Long globalSecondaryIndexWriteCapacityUnits,
Long globalSecondaryIndexWarmReadUnitsPerSecond,
Long globalSecondaryIndexWarmWriteUnitsPerSecond) {
// Define the table attributes
final AttributeDefinition partitionKeyAttribute = buildAttributeDefinition(partitionKey, ScalarAttributeType.S);
final AttributeDefinition sortKeyAttribute = buildAttributeDefinition(sortKey, ScalarAttributeType.S);
final AttributeDefinition miscellaneousKeyAttributeDefinition = buildAttributeDefinition(miscellaneousKeyAttribute, ScalarAttributeType.N);
final AttributeDefinition[] attributeDefinitions = {partitionKeyAttribute, sortKeyAttribute, miscellaneousKeyAttributeDefinition};
// Define the table key schema
final KeySchemaElement partitionKeyElement = buildKeySchemaElement(partitionKey, KeyType.HASH);
final KeySchemaElement sortKeyElement = buildKeySchemaElement(sortKey, KeyType.RANGE);
final KeySchemaElement[] keySchema = {partitionKeyElement, sortKeyElement};
// Define the provisioned throughput for the table
final ProvisionedThroughput provisionedThroughput = ProvisionedThroughput.builder()
.readCapacityUnits(tableReadCapacityUnits)
.writeCapacityUnits(tableWriteCapacityUnits)
.build();
// Define the Global Secondary Index (GSI)
final KeySchemaElement globalSecondaryIndexPartitionKeyElement = buildKeySchemaElement(sortKey, KeyType.HASH);
final KeySchemaElement globalSecondaryIndexSortKeyElement = buildKeySchemaElement(miscellaneousKeyAttribute, KeyType.RANGE);
final KeySchemaElement[] gsiKeySchema = {globalSecondaryIndexPartitionKeyElement, globalSecondaryIndexSortKeyElement};
final Projection gsiProjection = Projection.builder()
.projectionType(String.valueOf(ProjectionType.INCLUDE))
.nonKeyAttributes(nonKeyAttribute)
.build();
final ProvisionedThroughput gsiProvisionedThroughput = ProvisionedThroughput.builder()
.readCapacityUnits(globalSecondaryIndexReadCapacityUnits)
.writeCapacityUnits(globalSecondaryIndexWriteCapacityUnits)
.build();
// Define the warm throughput for the Global Secondary Index (GSI)
final WarmThroughput gsiWarmThroughput = buildWarmThroughput(globalSecondaryIndexWarmReadUnitsPerSecond, globalSecondaryIndexWarmWriteUnitsPerSecond);
final GlobalSecondaryIndex globalSecondaryIndex = GlobalSecondaryIndex.builder()
.indexName(globalSecondaryIndexName)
.keySchema(gsiKeySchema)
.projection(gsiProjection)
.provisionedThroughput(gsiProvisionedThroughput)
.warmThroughput(gsiWarmThroughput)
.build();
// Define the warm throughput for the table
final WarmThroughput tableWarmThroughput = buildWarmThroughput(tableWarmReadUnitsPerSecond, tableWarmWriteUnitsPerSecond);
final CreateTableRequest request = CreateTableRequest.builder()
.tableName(tableName)
.attributeDefinitions(attributeDefinitions)
.keySchema(keySchema)
.provisionedThroughput(provisionedThroughput)
.globalSecondaryIndexes(globalSecondaryIndex)
.warmThroughput(tableWarmThroughput)
.build();
CreateTableResponse response = ddb.createTable(request);
System.out.println(response);
}
```
------
#### [ Python ]
```
from boto3 import resource
from botocore.exceptions import ClientError
def create_dynamodb_table_warm_throughput(table_name, partition_key, sort_key, misc_key_attr, non_key_attr, table_provisioned_read_units, table_provisioned_write_units, table_warm_reads, table_warm_writes, gsi_name, gsi_provisioned_read_units, gsi_provisioned_write_units, gsi_warm_reads, gsi_warm_writes, region_name="us-east-1"):
"""
Creates a DynamoDB table with a warm throughput setting configured.
:param table_name: The name of the table to be created.
:param partition_key: The partition key for the table being created.
:param sort_key: The sort key for the table being created.
:param misc_key_attr: A miscellaneous key attribute for the table being created.
:param non_key_attr: A non-key attribute for the table being created.
:param table_provisioned_read_units: The newly created table's provisioned read capacity units.
:param table_provisioned_write_units: The newly created table's provisioned write capacity units.
:param table_warm_reads: The read units per second setting for the table's warm throughput.
:param table_warm_writes: The write units per second setting for the table's warm throughput.
:param gsi_name: The name of the Global Secondary Index (GSI) to be created on the table.
:param gsi_provisioned_read_units: The configured Global Secondary Index (GSI) provisioned read capacity units.
:param gsi_provisioned_write_units: The configured Global Secondary Index (GSI) provisioned write capacity units.
:param gsi_warm_reads: The read units per second setting for the Global Secondary Index (GSI)'s warm throughput.
:param gsi_warm_writes: The write units per second setting for the Global Secondary Index (GSI)'s warm throughput.
:param region_name: The AWS Region name to target. defaults to us-east-1
"""
try:
ddb = resource('dynamodb', region_name)
# Define the table attributes
attribute_definitions = [
{ "AttributeName": partition_key, "AttributeType": "S" },
{ "AttributeName": sort_key, "AttributeType": "S" },
{ "AttributeName": misc_key_attr, "AttributeType": "N" }
]
# Define the table key schema
key_schema = [
{ "AttributeName": partition_key, "KeyType": "HASH" },
{ "AttributeName": sort_key, "KeyType": "RANGE" }
]
# Define the provisioned throughput for the table
provisioned_throughput = {
"ReadCapacityUnits": table_provisioned_read_units,
"WriteCapacityUnits": table_provisioned_write_units
}
# Define the global secondary index
gsi_key_schema = [
{ "AttributeName": sort_key, "KeyType": "HASH" },
{ "AttributeName": misc_key_attr, "KeyType": "RANGE" }
]
gsi_projection = {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [non_key_attr]
}
gsi_provisioned_throughput = {
"ReadCapacityUnits": gsi_provisioned_read_units,
"WriteCapacityUnits": gsi_provisioned_write_units
}
gsi_warm_throughput = {
"ReadUnitsPerSecond": gsi_warm_reads,
"WriteUnitsPerSecond": gsi_warm_writes
}
global_secondary_indexes = [
{
"IndexName": gsi_name,
"KeySchema": gsi_key_schema,
"Projection": gsi_projection,
"ProvisionedThroughput": gsi_provisioned_throughput,
"WarmThroughput": gsi_warm_throughput
}
]
# Define the warm throughput for the table
warm_throughput = {
"ReadUnitsPerSecond": table_warm_reads,
"WriteUnitsPerSecond": table_warm_writes
}
# Create the DynamoDB client and create the table
response = ddb.create_table(
TableName=table_name,
AttributeDefinitions=attribute_definitions,
KeySchema=key_schema,
ProvisionedThroughput=provisioned_throughput,
GlobalSecondaryIndexes=global_secondary_indexes,
WarmThroughput=warm_throughput
)
print(response)
except ClientError as e:
print(f"Error creating table: {e}")
raise e
```
------
#### [ Javascript ]
```
import { DynamoDBClient, CreateTableCommand } from "@aws-sdk/client-dynamodb";
async function createDynamoDBTableWithWarmThroughput(
tableName,
partitionKey,
sortKey,
miscKeyAttr,
nonKeyAttr,
tableProvisionedReadUnits,
tableProvisionedWriteUnits,
tableWarmReads,
tableWarmWrites,
indexName,
indexProvisionedReadUnits,
indexProvisionedWriteUnits,
indexWarmReads,
indexWarmWrites,
region = "us-east-1"
) {
try {
const ddbClient = new DynamoDBClient({ region: region });
const command = new CreateTableCommand({
TableName: tableName,
AttributeDefinitions: [
{ AttributeName: partitionKey, AttributeType: "S" },
{ AttributeName: sortKey, AttributeType: "S" },
{ AttributeName: miscKeyAttr, AttributeType: "N" },
],
KeySchema: [
{ AttributeName: partitionKey, KeyType: "HASH" },
{ AttributeName: sortKey, KeyType: "RANGE" },
],
ProvisionedThroughput: {
ReadCapacityUnits: tableProvisionedReadUnits,
WriteCapacityUnits: tableProvisionedWriteUnits,
},
WarmThroughput: {
ReadUnitsPerSecond: tableWarmReads,
WriteUnitsPerSecond: tableWarmWrites,
},
GlobalSecondaryIndexes: [
{
IndexName: indexName,
KeySchema: [
{ AttributeName: sortKey, KeyType: "HASH" },
{ AttributeName: miscKeyAttr, KeyType: "RANGE" },
],
Projection: {
ProjectionType: "INCLUDE",
NonKeyAttributes: [nonKeyAttr],
},
ProvisionedThroughput: {
ReadCapacityUnits: indexProvisionedReadUnits,
WriteCapacityUnits: indexProvisionedWriteUnits,
},
WarmThroughput: {
ReadUnitsPerSecond: indexWarmReads,
WriteUnitsPerSecond: indexWarmWrites,
},
},
],
});
const response = await ddbClient.send(command);
console.log(response);
} catch (error) {
console.error(`Error creating table: ${error}`);
throw error;
}
}
```
------
# Noções básicas sobre throughput a quente do DynamoDB em diferentes cenários
Veja a seguir alguns cenários diferentes que você pode encontrar ao trabalhar com o throughput a quente do DynamoDB.
**Topics**
+ [Throughput a quente e padrões de acesso desiguais](#warm-throughput-scenarios-uneven)
+ [Throughput a quente para uma tabela provisionada](#warm-throughput-scenarios-provisioned)
+ [Throughput a quente para uma tabela sob demanda](#warm-throughput-scenarios-ondemand)
+ [Throughput a quente para uma tabela sob demanda com throughput máximo configurado](#warm-throughput-scenarios-max)
## Throughput a quente e padrões de acesso desiguais
Uma tabela pode ter um throughput a quente de 30 mil unidades de leitura por segundo e 10 mil unidades de gravação por segundo, mas você ainda pode experimentar controle de utilização em leituras ou gravações antes de atingir esses valores. Isso provavelmente se deve a uma partição sobrecarregada. Embora o DynamoDB possa continuar a escalar para comportar um throughput praticamente ilimitado, cada partição individual é limitada a mil unidades de gravação por segundo e 3 mil unidades de leitura por segundo. Se a aplicação direcionar muito tráfego para uma pequena parte das partições da tabela, poderá ocorrer controle de utilização mesmo antes de você atingir os valores de throughput a quente da tabela. Recomendamos seguir as [práticas recomendadas do DynamoDB](bp-partition-key-design.md) para garantir uma escalabilidade perfeita e evitar partições sobrecarregadas.
## Throughput a quente para uma tabela provisionada
Pense em uma tabela provisionada que tenha um throughput a quente de 30 mil unidades de leitura por segundo e 10 mil unidades de gravação por segundo, mas que atualmente tenha um throughput provisionado de 4 mil RCU e 8 mil WCU. É possível escalar instantaneamente o throughput provisionado da tabela até 30 mil RCU ou 10 mil WCU atualizando suas configurações de throughput provisionado. À medida que você aumenta o throughput provisionado além desses valores, o throughput a quente se ajustará automaticamente aos novos valores mais altos, porque você estabeleceu um novo throughput de pico. Por exemplo, se você definir o throughput provisionado para 50 mil RCU, o throughput a quente aumentará para 50 mil unidades de leitura por segundo.
```
"ProvisionedThroughput":
{
"ReadCapacityUnits": 4000,
"WriteCapacityUnits": 8000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```
## Throughput a quente para uma tabela sob demanda
Uma nova tabela sob demanda começa com um throughput a quente de 12 mil unidades de leitura por segundo e 4 mil unidades de gravação por segundo. Sua tabela pode acomodar instantaneamente o tráfego sustentado até esses níveis. Quando suas solicitações excederem 12 mil unidades de leitura por segundo ou 4 mil unidades de gravação por segundo, o throughput a quente se ajustará automaticamente a valores mais altos.
```
"WarmThroughput":
{
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000
}
```
## Throughput a quente para uma tabela sob demanda com throughput máximo configurado
Pense em uma tabela sob demanda com um throughput a quente de 30 mil unidades de leitura por segundo, mas com um [throughput máximo](on-demand-capacity-mode-max-throughput.md) configurado em 5 mil unidades de solicitação de leitura (RRU). Nesse cenário, o throughput da tabela será limitado ao máximo de 5 mil RRU que você definiu. Qualquer solicitação de throughput que exceda esse máximo terá controle de utilização. No entanto, é possível modificar o throughput máximo específico da tabela a qualquer momento, com base nas necessidades da aplicação.
```
"OnDemandThroughput":
{
"MaxReadRequestUnits": 5000,
"MaxWriteRequestUnits": 4000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```