Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Grundlegendes zum Warmdurchsatz von DynamoDB *Warmdurchsatz* bezieht sich auf die Anzahl der Lese- und Schreibvorgänge, die Ihre DynamoDB-Tabelle sofort unterstützen kann. Diese Werte sind standardmäßig für alle Tabellen und globalen sekundären Indizes (GSI) verfügbar und geben an, wie stark sie auf der Grundlage der historischen Nutzung skaliert wurden. Wenn Sie den On-Demand-Modus verwenden oder den bereitgestellten Durchsatz auf diese Werte aktualisieren, kann Ihre Anwendung sofort Anforderungen bis zu diesen Werten ausgeben. DynamoDB passt die Werte für den Warmdurchsatz automatisch an, wenn Ihre Nutzung zunimmt. Sie können diese Werte bei Bedarf auch proaktiv erhöhen, was besonders bei bevorstehenden Spitzenereignissen wie Produkteinführungen oder Verkäufen nützlich ist. Bei geplanten Spitzenereignissen, bei denen die Anforderungsraten an Ihre DynamoDB-Tabelle um das Zehn-, Hundertfache oder mehr steigen könnten, können Sie jetzt bewerten, ob der aktuelle Warmdurchsatz ausreicht, um den erwarteten Datenverkehr zu bewältigen. Ist dies nicht der Fall, können Sie den Wert für den Warmdurchsatz erhöhen, ohne Ihre Durchsatzeinstellungen oder den [Fakturierungsmodus](capacity-mode.md) zu ändern. Dieser Vorgang wird als *Vorwärmen* einer Tabelle bezeichnet, sodass Sie eine Baseline festlegen können, den Ihre Tabellen sofort unterstützen können. Dadurch wird sichergestellt, dass Ihre Anwendungen höhere Anforderungsraten von dem Moment an bewältigen können, in dem sie auftreten. Sobald die Werte für den Warmdurchsatz erhöht wurden, können sie nicht mehr verringert werden. Sie können den Wert für den Warmdurchsatz für Lesevorgänge, Schreibvorgänge oder beides erhöhen. Sie können diesen Wert für neue und bestehende Tabellen mit einer Region, globale Tabellen und GSIs erhöhen. Bei globalen Tabellen ist diese Funktion für [Version 2019.11.21 (aktuell)](GlobalTables.md) verfügbar. Die von Ihnen festgelegten Einstellungen für den Warmdurchsatz gelten automatisch für alle Replikattabellen in der globalen Tabelle. Es gibt keine Begrenzung der Anzahl von DynamoDB-Tabellen, die Sie jederzeit vorwärmen können. Die Dauer des Vorwärmens hängt von den von Ihnen eingestellten Werten und der Größe der Tabelle oder des Index ab. Sie können Anforderungen zum Vorwärmen gleichzeitig einreichen, ohne dass diese Anforderungen die Tabellenoperationen beeinträchtigen. Sie können Ihre Tabelle vorwärmen, bis das Tabellen- oder Indexkontingentlimit für Ihr Konto in dieser Region erreicht ist. Verwenden Sie die [Service-Quotas-Konsole](https://console.aws.amazon.com/servicequotas), um Ihre aktuellen Limits zu überprüfen und sie bei Bedarf zu erhöhen. Werte für den Warmdurchsatz sind standardmäßig für alle Tabellen und sekundären Indizes kostenlos verfügbar. Wenn Sie diese Standardwerte für den Warmdurchsatz jedoch proaktiv erhöhen, um die Tabellen vorzuwärmen, werden Ihnen diese Anforderungen in Rechnung gestellt. Weitere Informationen finden Sie unter [Amazon DynamoDB – Preise](https://aws.amazon.com/dynamodb/pricing/). Weitere Informationen zum Warmdurchsatz finden Sie in den folgenden Themen: **Topics** + [ # Überprüfen des aktuellen Warmdurchsatzes Ihrer DynamoDB-Tabelle ](check-warm-throughput.md) + [ # Erhöhen des Warmdurchsatzes für die vorhandene DynamoDB-Tabelle ](update-warm-throughput.md) + [ # Erstellen einer neuen DynamoDB-Tabelle mit einem höheren Warmdurchsatz ](create-table-warm-throughput.md) + [ # Grundlegendes zum DynamoDB-Warmdurchsatz in verschiedenen Szenarien ](warm-throughput-scenarios.md) # Überprüfen des aktuellen Warmdurchsatzes Ihrer DynamoDB-Tabelle Verwenden Sie die folgenden Anweisungen AWS CLI und die Anweisungen in der AWS Konsole, um den aktuellen Warmdurchsatzwert Ihrer Tabelle oder Ihres Indexes zu überprüfen. ## AWS-Managementkonsole So überprüfen Sie den Warmdurchsatz Ihrer DynamoDB-Tabelle mithilfe der DynamoDB-Konsole: 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Wählen Sie im linken Navigationsbereich Tables (Tabellen) aus. 1. Wählen Sie auf der Seite **Tabellen** die gewünschte Tabelle aus. 1. Wählen Sie **Zusätzliche Einstellungen** aus, um den aktuellen Warmdurchsatzwert anzuzeigen. Dieser Wert wird als Leseeinheiten pro Sekunde und Schreibeinheiten pro Sekunde angezeigt. ## AWS CLI Das folgende AWS CLI Beispiel zeigt Ihnen, wie Sie den Warmdurchsatz Ihrer DynamoDB-Tabelle überprüfen können. 1. Führen Sie die `describe-table`-Operation für die DynamoDB-Tabelle aus. ``` aws dynamodb describe-table --table-name GameScores ``` 1. Sie erhalten eine ähnliche Antwort wie die folgende. Ihre `WarmThroughput`-Einstellungen werden als `ReadUnitsPerSecond` und `WriteUnitsPerSecond` angezeigt. `Status` lautet `UPDATING`, wenn der Wert für den Warmdurchsatz aktualisiert wird, und `ACTIVE`, wenn der neue Warmdurchsatzwert festgelegt wird. ``` { "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" } } } ``` # Erhöhen des Warmdurchsatzes für die vorhandene DynamoDB-Tabelle Nachdem Sie den aktuellen Warmdurchsatzwert Ihrer DynamoDB-Tabelle überprüft haben, können Sie ihn mit den folgenden Schritten aktualisieren: ## AWS-Managementkonsole So überprüfen Sie den Warmdurchsatzwert Ihrer DynamoDB-Tabelle mithilfe der DynamoDB-Konsole: 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Wählen Sie im linken Navigationsbereich Tables (Tabellen) aus. 1. Wählen Sie auf der Seite **Tabellen** die gewünschte Tabelle aus. 1. Wählen Sie im Feld **Warmdurchsatz** die Option **Bearbeiten** aus. 1. Wählen Sie auf der Seite **Warmdurchsatz bearbeiten** die Option **Warmdurchsatz erhöhen** aus. 1. Passen Sie die **Leseeinheiten pro Sekunde** und die **Schreibeinheiten pro Sekunde** an. Diese beiden Einstellungen definieren den Durchsatz, den die Tabelle sofort verarbeiten kann. 1. Wählen Sie **Speichern** aus. 1. Ihre **Leseeinheiten pro Sekunde** und **Schreibeinheiten pro Sekunde** werden im Feld **Warmdurchsatz** aktualisiert, wenn die Bearbeitung der Anforderung abgeschlossen ist. **Anmerkung** Die Aktualisierung des Werts für den Warmdurchsatz ist eine asynchrone Aufgabe. `Status` ändert sich von `UPDATING` in `ACTIVE`, wenn die Aktualisierung abgeschlossen ist. ## AWS CLI Das folgende AWS CLI Beispiel zeigt Ihnen, wie Sie den Warmdurchsatzwert Ihrer DynamoDB-Tabelle aktualisieren. 1. Führen Sie die `update-table`-Operation für die DynamoDB-Tabelle aus. ``` 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. Sie erhalten eine ähnliche Antwort wie die folgende. Ihre `WarmThroughput`-Einstellungen werden als `ReadUnitsPerSecond` und `WriteUnitsPerSecond` angezeigt. `Status` lautet `UPDATING`, wenn der Wert für den Warmdurchsatz aktualisiert wird, und `ACTIVE`, wenn der neue Warmdurchsatzwert festgelegt wird. ``` { "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 Die folgenden SDK-Beispiele zeigen Ihnen, wie Sie den Wert für den Warmdurchsatz Ihrer DynamoDB-Tabelle aktualisieren können. ------ #### [ 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; } } ``` ------ # Erstellen einer neuen DynamoDB-Tabelle mit einem höheren Warmdurchsatz Sie können die Werte für den Warmdurchsatz beim Erstellen Ihrer DynamoDB-Tabelle anpassen, indem Sie die folgenden Schritte ausführen. Diese Schritte gelten auch für die Erstellung einer [globalen Tabelle](GlobalTables.md) oder eines [sekundären Index](SecondaryIndexes.md). ## AWS-Managementkonsole So erstellen Sie eine DynamoDB-Tabelle und passen die Werte für den Warmdurchsatz über die Konsole an: 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Wählen Sie **Tabelle erstellen** aus. 1. Wählen Sie einen **Tabellennamen**, einen **Partitionsschlüssel** und einen **Sortierschlüssel (optional)** aus. 1. Wählen Sie unter **Tabelleneinstellungen** die Option **Einstellungen anpassen** aus. 1. Wählen Sie im Feld **Warmdurchsatz** die Option **Warmdurchsatz erhöhen** aus. 1. Passen Sie die **Leseeinheiten pro Sekunde** und die **Schreibeinheiten pro Sekunde** an. Diese beiden Einstellungen definieren den maximalen Durchsatz, den die Tabelle sofort verarbeiten kann. 1. Fügen Sie weitere Tabellendetails hinzu und wählen Sie dann **Tabelle erstellen** aus. ## AWS CLI Das folgende AWS CLI Beispiel zeigt Ihnen, wie Sie eine DynamoDB-Tabelle mit benutzerdefinierten Warmdurchsatzwerten erstellen. 1. Führen Sie die `create-table`-Operation aus, um die folgende DynamoDB-Tabelle zu erstellen. ``` 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. Sie erhalten eine ähnliche Antwort wie die folgende. Ihre `WarmThroughput`-Einstellungen werden als `ReadUnitsPerSecond` und `WriteUnitsPerSecond` angezeigt. `Status` lautet `UPDATING`, wenn der Wert für den Warmdurchsatz aktualisiert wird, und `ACTIVE`, wenn der neue Warmdurchsatzwert festgelegt wird. ``` { "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 Die folgenden SDK-Beispiele zeigen Ihnen, wie Sie eine DynamoDB-Tabelle mit benutzerdefinierten Werden für den Warmdurchsatz erstellen. ------ #### [ 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; } } ``` ------ # Grundlegendes zum DynamoDB-Warmdurchsatz in verschiedenen Szenarien Im Folgenden finden Sie verschiedene Szenarien, die Ihnen bei der Arbeit mit DynamoDB-Warmdurchsatz begegnen können. **Topics** + [ ## Warmdurchsatz und ungleiche Zugriffsmuster ](#warm-throughput-scenarios-uneven) + [ ## Warmdurchsatz für eine bereitgestellte Tabelle ](#warm-throughput-scenarios-provisioned) + [ ## Warmdurchsatz für eine On-Demand-Tabelle ](#warm-throughput-scenarios-ondemand) + [ ## Warmdurchsatz für eine On-Demand-Tabelle mit konfiguriertem maximalem Durchsatz ](#warm-throughput-scenarios-max) ## Warmdurchsatz und ungleiche Zugriffsmuster Auch wenn eine Tabelle einen Warmdurchsatz von 30 000 Leseeinheiten pro Sekunde und 10 000 Schreibeinheiten pro Sekunde hat, kann es dennoch zu Drosselungen bei Lese- oder Schreibvorgängen kommen, bevor diese Werte erreicht werden. Das liegt wahrscheinlich an einer Hot-Partition. DynamoDB kann zwar weiter skaliert werden, um einen praktisch unbegrenzten Durchsatz zu unterstützen, aber jede einzelne Partition ist auf 1 000 Schreibeinheiten pro Sekunde und 3 000 Leseeinheiten pro Sekunde begrenzt. Wenn Ihre Anwendung zu viel Datenverkehr auf einen kleinen Teil der Tabellenpartitionen lenkt, kann es zu einer Drosselung kommen, noch bevor Sie die Werte für den Warmdurchsatz der Tabelle erreichen. Wir empfehlen, die [bewährten Methoden für DynamoDB](bp-partition-key-design.md) zu befolgen, um eine nahtlose Skalierbarkeit zu gewährleisten und Hot-Partitionen zu vermeiden. ## Warmdurchsatz für eine bereitgestellte Tabelle Stellen Sie sich eine bereitgestellte Tabelle mit einem Warmdurchsatz von 30 000 Leseeinheiten pro Sekunde und 10 000 Schreibeinheiten pro Sekunde vor, die derzeit jedoch über einen bereitgestellten Durchsatz von 4 000 RCU und 8 000 WCU verfügt. Sie können den bereitgestellten Durchsatz der Tabelle sofort auf bis zu 30 000 RCU oder 10 000 WCU skalieren, indem Sie Ihre Einstellungen für den bereitgestellten Durchsatz aktualisieren. Wenn Sie den bereitgestellten Durchsatz über diese Werte hinaus erhöhen, passt sich der Warmdurchsatz automatisch an die neuen höheren Werte an, da Sie einen neuen Spitzendurchsatz festgelegt haben. Wenn Sie beispielsweise den bereitgestellten Durchsatz auf 50 000 RCU festlegen, erhöht sich der Warmdurchsatz auf 50 000 Leseeinheiten pro Sekunde. ``` "ProvisionedThroughput": { "ReadCapacityUnits": 4000, "WriteCapacityUnits": 8000 } "WarmThroughput": { "ReadUnitsPerSecond": 30000, "WriteUnitsPerSecond": 10000 } ``` ## Warmdurchsatz für eine On-Demand-Tabelle Eine neue On-Demand-Tabelle beginnt mit einem Warmdurchsatz von 12 000 Leseeinheiten pro Sekunde und 4 000 Schreibeinheiten pro Sekunde. Ihre Tabelle kann anhaltenden Datenverkehr bis zu diesen Werten sofort verarbeiten. Wenn Ihre Anforderungen 12 000 Leseeinheiten pro Sekunde oder 4 000 Schreibeinheiten pro Sekunde überschreiten, passt sich der Warmdurchsatz automatisch an höhere Werte an. ``` "WarmThroughput": { "ReadUnitsPerSecond": 12000, "WriteUnitsPerSecond": 4000 } ``` ## Warmdurchsatz für eine On-Demand-Tabelle mit konfiguriertem maximalem Durchsatz Stellen Sie sich eine On-Demand-Tabelle mit einem Warmdurchsatz von 30 000 Leseeinheiten pro Sekunde vor, für die der [maximale Durchsatz](on-demand-capacity-mode-max-throughput.md) jedoch auf 5 000 Leseanforderungseinheiten (RRU) konfiguriert ist. In diesem Szenario wird der Durchsatz der Tabelle auf das von Ihnen festgelegte Maximum von 5 000 RRU begrenzt. Alle Durchsatzanforderungen, die diesen Höchstwert überschreiten, werden gedrosselt. Sie können den tabellenspezifischen maximalen Durchsatz jedoch jederzeit an die Anforderungen Ihrer Anwendung anpassen. ``` "OnDemandThroughput": { "MaxReadRequestUnits": 5000, "MaxWriteRequestUnits": 4000 } "WarmThroughput": { "ReadUnitsPerSecond": 30000, "WriteUnitsPerSecond": 10000 } ```