Beispiele für die Verwendung der AWS CLI mit DynamoDB

Die folgenden Codebeispiele zeigen, wie Sie Aktionen durchführen und gängige Szenarien implementieren, indem Sie die AWS Command Line Interface mit DynamoDB nutzen.

Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.

Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anleitungen zum Einrichten und Ausführen des Codes im Kontext finden.

Themen

Aktionen

Aktionen

Das folgende Codebeispiel zeigt, wie batch-get-item verwendet wird.

AWS CLI

So rufen Sie mehrere Elemente aus einer Tabelle ab

Im folgenden batch-get-items-Beispiel werden mithilfe eines Stapels von drei GetItem-Abfragen mehrere Elemente aus der MusicCollection-Tabelle gelesen und die Anzahl der durch den Vorgang verbrauchten Lesekapazitätseinheiten wird abgefragt. Der Befehl gibt nur das AlbumTitle-Attribut zurück.


aws dynamodb batch-get-item \
    --request-items file://request-items.json \
    --return-consumed-capacity TOTAL

Inhalt von request-items.json:


{
    "MusicCollection": {
        "Keys": [
            {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Scared of My Shadow"}
            }
        ],
        "ProjectionExpression":"AlbumTitle"
    }
}

Ausgabe:


{
    "Responses": {
        "MusicCollection": [
            {
                "AlbumTitle": {
                    "S": "Somewhat Famous"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Blue Sky Blues"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Louder Than Ever"
                }
            }
        ]
    },
    "UnprocessedKeys": {},
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 1.5
        }
    ]
}

Weitere Informationen finden Sie unter Batch-Vorgänge im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter BatchGetItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie batch-write-item verwendet wird.

AWS CLI

So fügen Sie mehrere Elemente einer Tabelle hinzu

Im folgenden batch-write-item-Beispiel werden der MusicCollection-Tabelle drei neue Elemente hinzugefügt, wobei ein Batch von drei PutItem-Abfragen verwendet wird. Außerdem werden Informationen zur Anzahl der Schreibkapazitätseinheiten abgefragt, die von dem Vorgang verbraucht werden, sowie zu allen Elementsammlungen, die durch den Vorgang geändert werden.


aws dynamodb batch-write-item \
    --request-items file://request-items.json \
    --return-consumed-capacity INDEXES \
    --return-item-collection-metrics SIZE

Inhalt von request-items.json:


{
    "MusicCollection": [
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "No One You Know"},
                    "SongTitle": {"S": "Call Me Today"},
                    "AlbumTitle": {"S": "Somewhat Famous"}
                }
            }
        },
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "Acme Band"},
                    "SongTitle": {"S": "Happy Day"},
                    "AlbumTitle": {"S": "Songs About Life"}
                }
            }
        },
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "No One You Know"},
                    "SongTitle": {"S": "Scared of My Shadow"},
                    "AlbumTitle": {"S": "Blue Sky Blues"}
                }
            }
        }
    ]
}

Ausgabe:


{
    "UnprocessedItems": {},
    "ItemCollectionMetrics": {
        "MusicCollection": [
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "No One You Know"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            },
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "Acme Band"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            }
        ]
    },
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 6.0,
            "Table": {
                "CapacityUnits": 3.0
            },
            "LocalSecondaryIndexes": {
                "AlbumTitleIndex": {
                    "CapacityUnits": 3.0
                }
            }
        }
    ]
}

Weitere Informationen finden Sie unter Batch-Vorgänge im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter BatchWriteItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie create-backup verwendet wird.

AWS CLI

So erstellen Sie eine Sicherung für eine vorhandene DynamoDB-Tabelle

Im folgenden create-backup-Beispiel wird eine Sicherung der MusicCollection-Tabelle erstellt.


aws dynamodb create-backup \
    --table-name MusicCollection \
    --backup-name MusicCollectionBackup

Ausgabe:


{
    "BackupDetails": {
        "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
        "BackupName": "MusicCollectionBackup",
        "BackupSizeBytes": 0,
        "BackupStatus": "CREATING",
        "BackupType": "USER",
        "BackupCreationDateTime": 1576616366.715
    }
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter CreateBackup in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie create-global-table verwendet wird.

AWS CLI

So erstellen Sie eine globale Tabelle

Im folgenden create-global-table-Beispiel wird eine globale Tabelle aus zwei identischen Tabellen in den angegebenen, separaten AWS-Regionen erstellt.


aws dynamodb create-global-table \
    --global-table-name MusicCollection \
    --replication-group RegionName=us-east-2 RegionName=us-east-1 \
    --region us-east-2

Ausgabe:


{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "CREATING",
        "GlobalTableName": "MusicCollection"
    }
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter CreateGlobalTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie create-table verwendet wird.

AWS CLI

Beispiel 1: So erstellen Sie eine Tabelle mit Tags

Im folgenden create-table-Beispiel werden die angegebenen Attribute und das angegebene Schlüsselschema verwendet, um eine Tabelle mit dem Namen MusicCollection zu erstellen. Diese Tabelle verwendet den bereitgestellten Durchsatz und wird im Ruhezustand mit dem AWS-eigenen Standard-CMK verschlüsselt. Der Befehl weist der Tabelle außerdem ein Tag mit dem Schlüssel Owner und dem Wert blueTeam zu.


aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --tags Key=Owner,Value=blueTeam

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "TableName": "MusicCollection",
        "TableStatus": "CREATING",
        "KeySchema": [
            {
                "KeyType": "HASH",
                "AttributeName": "Artist"
            },
            {
                "KeyType": "RANGE",
                "AttributeName": "SongTitle"
            }
        ],
        "ItemCount": 0,
        "CreationDateTime": "2020-05-26T16:04:41.627000-07:00",
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So erstellen Sie eine Tabelle im On-Demand-Modus

Im folgenden Beispiel wird mit dem On-Demand-Modus anstelle des bereitgestellten Durchsatzmodus eine Tabelle mit dem Namen MusicCollection erstellt. Dies ist nützlich für Tabellen mit unvorhersehbaren Workloads.


aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --billing-mode PAY_PER_REQUEST

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T11:44:10.807000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 0,
            "WriteCapacityUnits": 0
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "BillingModeSummary": {
            "BillingMode": "PAY_PER_REQUEST"
        }
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So erstellen Sie eine Tabelle und verschlüsseln sie mit einem vom Kunden verwalteten CMK

Im folgenden Beispiel wird eine Tabelle mit dem Namen MusicCollection erstellt und mithilfe eines vom Kunden verwalteten CMK verschlüsselt.


aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --sse-specification Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-abcd-1234-a123-ab1234a1b234

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T11:12:16.431000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "SSEDescription": {
            "Status": "ENABLED",
            "SSEType": "KMS",
            "KMSMasterKeyArn": "arn:aws:kms:us-west-2:123456789012:key/abcd1234-abcd-1234-a123-ab1234a1b234"
        }
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Bespiel 4: So erstellen Sie eine Tabelle mit einem lokalen sekundären Index

Im folgenden Beispiel werden die angegebenen Attribute und das angegebene Schlüsselschema verwendet, um eine Tabelle namens MusicCollection mit dem lokalen sekundären Index AlbumTitleIndex zu erstellen.


aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S AttributeName=AlbumTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --local-secondary-indexes \
        "[
            {
                \"IndexName\": \"AlbumTitleIndex\",
                \"KeySchema\": [
                    {\"AttributeName\": \"Artist\",\"KeyType\":\"HASH\"},
                    {\"AttributeName\": \"AlbumTitle\",\"KeyType\":\"RANGE\"}
                ],
                \"Projection\": {
                    \"ProjectionType\": \"INCLUDE\",
                    \"NonKeyAttributes\": [\"Genre\", \"Year\"]
                }
            }
        ]"

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Genre",
                        "Year"
                    ]
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 5: So erstellen Sie eine Tabelle mit einem globalen sekundären Index

Im folgenden Beispiel wird eine Tabelle mit dem Namen GameScores mit einem globalen sekundären Index namens GameTitleIndex erstellt. Die Basistabelle hat einen Partitionsschlüssel von UserId und einen Sortierschlüssel von GameTitle, mit dem Sie effizient die beste Punktzahl eines einzelnen Benutzers für ein bestimmtes Spiel finden können, während die GSI einen Partitionsschlüssel von GameTitle und einen Sortierschlüssel von TopScore hat, mit dem Sie finden Sie schnell die höchste Gesamtpunktzahl für ein bestimmtes Spiel.


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=10,WriteCapacityUnits=5 \
    --global-secondary-indexes \
        "[
            {
                \"IndexName\": \"GameTitleIndex\",
                \"KeySchema\": [
                    {\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
                    {\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE\"}
                ],
                \"Projection\": {
                    \"ProjectionType\":\"INCLUDE\",
                    \"NonKeyAttributes\":[\"UserId\"]
                },
                \"ProvisionedThroughput\": {
                    \"ReadCapacityUnits\": 10,
                    \"WriteCapacityUnits\": 5
                }
            }
        ]"

Ausgabe:


{
    "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": "2020-05-26T17:28:15.602000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "GameTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "TopScore",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "UserId"
                    ]
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 6: So erstellen Sie eine Tabelle mit mehreren globalen sekundären Indizes gleichzeitig

Im folgenden Beispiel wird eine Tabelle namens GameScores mit zwei globalen sekundären Indizes erstellt. Die GSI-Schemas werden über eine Datei und nicht über die Befehlszeile übergeben.


aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N AttributeName=Date,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --global-secondary-indexes file://gsi.json

Inhalt von gsi.json:


[
    {
        "IndexName": "GameTitleIndex",
        "KeySchema": [
            {
                "AttributeName": "GameTitle",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "TopScore",
                "KeyType": "RANGE"
            }
        ],
        "Projection": {
            "ProjectionType": "ALL"
        },
        "ProvisionedThroughput": {
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        }
    },
    {
        "IndexName": "GameDateIndex",
        "KeySchema": [
            {
                "AttributeName": "GameTitle",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "Date",
                "KeyType": "RANGE"
            }
        ],
        "Projection": {
            "ProjectionType": "ALL"
        },
        "ProvisionedThroughput": {
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        }
    }
]

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Date",
                "AttributeType": "S"
            },
            {
                "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": "2020-08-04T16:40:55.524000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "GameTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "TopScore",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
            },
            {
                "IndexName": "GameDateIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "Date",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameDateIndex"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 7: So erstellen Sie eine Tabelle mit aktivierten Streams

Im folgenden Beispiel wird die Tabelle GameScores mit aktiviertem DynamoDB Streams aufgerufen. Sowohl neue als auch alte Images von jedem Element werden in den Stream geschrieben.


aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --stream-specification StreamEnabled=TRUE,StreamViewType=NEW_AND_OLD_IMAGES

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T10:49:34.056000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_AND_OLD_IMAGES"
        },
        "LatestStreamLabel": "2020-05-27T17:49:34.056",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2020-05-27T17:49:34.056"
    }
}

Weitere Informationen finden Sie unter Grundlegende Operationen für Tabellen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 8: So erstellen Sie eine Tabelle mit aktiviertem Keys-Only-Stream

Im folgenden Beispiel wird die Tabelle GameScores mit aktiviertem DynamoDB Streams aufgerufen. Nur die Schlüsselattribute von geänderten Elementen werden in den Stream geschrieben.


aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --stream-specification StreamEnabled=TRUE,StreamViewType=KEYS_ONLY

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T18:45:34.140000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "KEYS_ONLY"
        },
        "LatestStreamLabel": "2023-05-25T18:45:34.140",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2023-05-25T18:45:34.140",
        "DeletionProtectionEnabled": false
    }
}

Weitere Informationen finden Sie unter Ändern der Datenerfassung für DynamoDB Streams im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 9: So erstellen Sie eine Tabelle mit der Klasse Standard Infrequent Access

Im folgenden Beispiel wird eine Tabelle mit dem Namen GameScores erstellt und die Tabellenklasse Standard-Infrequent Access (DynamoDB Standard-IA) zugewiesen. Diese Tabellenklasse ist dafür optimiert, dass Speicher der Hauptkostenfaktor ist.


aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --table-class STANDARD_INFREQUENT_ACCESS

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T18:33:07.581000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "TableClassSummary": {
            "TableClass": "STANDARD_INFREQUENT_ACCESS"
        },
        "DeletionProtectionEnabled": false
    }
}

Weitere Informationen finden Sie unter Tabellenklassen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 10: So erstellen Sie eine Tabelle mit aktiviertem Löschschutz

Im folgenden Beispiel wird eine Tabelle mit dem Namen GameScores erstellt und der Löschschutz aktiviert.


aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --deletion-protection-enabled

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T23:02:17.093000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "DeletionProtectionEnabled": true
    }
}

Weitere Informationen finden Sie unter Verwenden des Löschschutzes im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter CreateTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie delete-backup verwendet wird.

AWS CLI

So löschen Sie eine vorhandene DynamoDB-Sicherung

Das folgende delete-backup-Beispiel löscht die angegebene Sicherung.


aws dynamodb delete-backup \
    --backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a

Ausgabe:


{
    "BackupDescription": {
        "BackupDetails": {
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "BackupName": "MusicCollectionBackup",
            "BackupSizeBytes": 0,
            "BackupStatus": "DELETED",
            "BackupType": "USER",
            "BackupCreationDateTime": 1576616366.715
        },
        "SourceTableDetails": {
            "TableName": "MusicCollection",
            "TableId": "b0c04bcc-309b-4352-b2ae-9088af169fe2",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "TableSizeBytes": 0,
            "KeySchema": [
                {
                    "AttributeName": "Artist",
                    "KeyType": "HASH"
                },
                {
                    "AttributeName": "SongTitle",
                    "KeyType": "RANGE"
                }
            ],
            "TableCreationDateTime": 1576615228.571,
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 5,
                "WriteCapacityUnits": 5
            },
            "ItemCount": 0,
            "BillingMode": "PROVISIONED"
        },
        "SourceTableFeatureDetails": {}
    }
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DeleteBackup in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie delete-item verwendet wird.

AWS CLI

Beispiel 1: So löschen Sie ein Element

Im folgenden delete-item-Beispiel wird ein Element aus der MusicCollection-Tabelle gelöscht und es werden Details zu dem gelöschten Element und der von der Abfrage verwendeten Kapazität abgefragt.


aws dynamodb delete-item \
    --table-name MusicCollection \
    --key file://key.json \
    --return-values ALL_OLD \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE

Inhalt von key.json:


{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Scared of My Shadow"}
}

Ausgabe:


{
    "Attributes": {
        "AlbumTitle": {
            "S": "Blue Sky Blues"
        },
        "Artist": {
            "S": "No One You Know"
        },
        "SongTitle": {
            "S": "Scared of My Shadow"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 2.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "No One You Know"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So löschen Sie ein Element bedingungsabhängig

Im folgenden Beispiel wird ein Element nur dann aus der ProductCatalog-Tabelle gelöscht, wenn ProductCategory entweder Sporting Goods oder Gardening Supplies ist und der Preis zwischen 500 und 600 liegt. Es werden Details zu dem gelöschten Element zurückgegeben.


aws dynamodb delete-item \
    --table-name ProductCatalog \
    --key '{"Id":{"N":"456"}}' \
    --condition-expression "(ProductCategory IN (:cat1, :cat2)) and (#P between :lo and :hi)" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-values ALL_OLD

Inhalt von names.json:


{
    "#P": "Price"
}

Inhalt von values.json:


{
    ":cat1": {"S": "Sporting Goods"},
    ":cat2": {"S": "Gardening Supplies"},
    ":lo": {"N": "500"},
    ":hi": {"N": "600"}
}

Ausgabe:


{
    "Attributes": {
        "Id": {
            "N": "456"
        },
        "Price": {
            "N": "550"
        },
        "ProductCategory": {
            "S": "Sporting Goods"
        }
    }
}

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DeleteItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie delete-table verwendet wird.

AWS CLI

So löschen Sie eine Tabelle

Das folgende delete-table-Beispiel löscht die Tabelle MusicCollection.


aws dynamodb delete-table \
    --table-name MusicCollection

Ausgabe:


{
    "TableDescription": {
        "TableStatus": "DELETING",
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableName": "MusicCollection",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        }
    }
}

Weitere Informationen finden Sie unter Löschen einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DeleteTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-backup verwendet wird.

AWS CLI

So rufen Sie Informationen über eine bestehende Sicherung aus einer Tabelle ab

Im folgenden describe-backup-Beispiel werden Informationen zur angegebenen Sicherung angezeigt.


aws dynamodb describe-backup \
    --backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a

Ausgabe:


{
    "BackupDescription": {
        "BackupDetails": {
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "BackupName": "MusicCollectionBackup",
            "BackupSizeBytes": 0,
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupCreationDateTime": 1576616366.715
        },
        "SourceTableDetails": {
            "TableName": "MusicCollection",
            "TableId": "b0c04bcc-309b-4352-b2ae-9088af169fe2",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "TableSizeBytes": 0,
            "KeySchema": [
                {
                    "AttributeName": "Artist",
                    "KeyType": "HASH"
                },
                {
                    "AttributeName": "SongTitle",
                    "KeyType": "RANGE"
                }
            ],
            "TableCreationDateTime": 1576615228.571,
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 5,
                "WriteCapacityUnits": 5
            },
            "ItemCount": 0,
            "BillingMode": "PROVISIONED"
        },
        "SourceTableFeatureDetails": {}
    }
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DescribeBackup in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-continuous-backups verwendet wird.

AWS CLI

So rufen Sie Informationen über kontinuierliche Sicherungen für eine DynamoDB-Tabelle ab

Im folgenden describe-continuous-backups-Beispiel werden Details zu den Einstellungen für kontinuierliche Sicherungen für die MusicCollection-Tabelle angezeigt.


aws dynamodb describe-continuous-backups \
    --table-name MusicCollection

Ausgabe:


{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "DISABLED"
        }
    }
}

Weitere Informationen finden Sie unter Wiederherstellung auf einen bestimmten Zeitpunkt für DynamoDB im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter DescribeContinuousBackups in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-contributor-insights verwendet wird.

AWS CLI

So zeigen Sie Contributor-Insights-Einstellungen für eine DynamoDB-Tabelle an

Im folgenden describe-contributor-insights-Beispiel werden die Contributor-Insights-Einstellungen für die MusicCollection-Tabelle und den globalen sekundären Index AlbumTitle-index angezeigt.


aws dynamodb describe-contributor-insights \
    --table-name MusicCollection \
    --index-name AlbumTitle-index

Ausgabe:


{
    "TableName": "MusicCollection",
    "IndexName": "AlbumTitle-index",
    "ContributorInsightsRuleList": [
        "DynamoDBContributorInsights-PKC-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-SKC-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-PKT-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-SKT-MusicCollection-1576629651520"
    ],
    "ContributorInsightsStatus": "ENABLED",
    "LastUpdateDateTime": 1576629654.78
}

Weitere Informationen finden Sie unter Analysieren des Datenzugriffs mithilfe von CloudWatch Contributor Insights für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DescribeContributorInsights in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-endpoints verwendet wird.

AWS CLI

So zeigen Sie regionale Endpunktinformationen an

Im folgenden describe-endpoints-Beispiel werden Details zu den Endpunkten für die aktuelle AWS-Region angezeigt.


aws dynamodb describe-endpoints

Ausgabe:


{
    "Endpoints": [
        {
            "Address": "dynamodb.us-west-2.amazonaws.com",
            "CachePeriodInMinutes": 1440
        }
    ]
}

Weitere Informationen finden Sie unter Endpunkte und Kontingente von Amazon DynamoDB in der Allgemeinen Referenz zu AWS.

API-Details finden Sie unter DescribeEndpoints in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-global-table-settings verwendet wird.

AWS CLI

So rufen Sie Informationen über die Einstellungen einer globalen DynamoDB-Tabelle ab

Im folgenden describe-global-table-settings-Beispiel werden die Einstellungen für die globale MusicCollection-Tabelle angezeigt.


aws dynamodb describe-global-table-settings \
    --global-table-name MusicCollection

Ausgabe:


{
    "GlobalTableName": "MusicCollection",
    "ReplicaSettings": [
        {
            "RegionName": "us-east-1",
            "ReplicaStatus": "ACTIVE",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 5,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-2",
            "ReplicaStatus": "ACTIVE",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 5,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        }
    ]
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter DescribeGlobalTableSettings in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-global-table verwendet wird.

AWS CLI

So zeigen Sie Informationen zu einer globalen DynamoDB-Tabelle an

Im folgenden describe-global-table-Beispiel werden Details zur globalen MusicCollection-Tabelle angezeigt.


aws dynamodb describe-global-table \
    --global-table-name MusicCollection

Ausgabe:


{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "ACTIVE",
        "GlobalTableName": "MusicCollection"
    }
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter DescribeGlobalTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-limits verwendet wird.

AWS CLI

So zeigen Sie die Limits für die bereitgestellte Kapazität an

Im folgenden describe-limits-Beispiel werden die Limits der bereitgestellten Kapazität für Ihr Konto in der aktuellen AWS-Region angezeigt.


aws dynamodb describe-limits

Ausgabe:


{
    "AccountMaxReadCapacityUnits": 80000,
    "AccountMaxWriteCapacityUnits": 80000,
    "TableMaxReadCapacityUnits": 40000,
    "TableMaxWriteCapacityUnits": 40000
}

Weitere Informationen finden Sie unter Limits in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DescribeLimits in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-table-replica-auto-scaling verwendet wird.

AWS CLI

So zeigen Sie Auto-Scaling-Einstellungen für Replikate einer globalen Tabelle an

Im folgenden describe-table-replica-auto-scaling-Beispiel werden Auto-Scaling-Einstellungen für alle Replikate der globalen MusicCollection-Tabelle angezeigt.


aws dynamodb describe-table-replica-auto-scaling \
    --table-name MusicCollection

Ausgabe:


{
    "TableAutoScalingDescription": {
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "Replicas": [
            {
                "RegionName": "us-east-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-2",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter DescribeTableReplicaAutoScaling in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-table verwendet wird.

AWS CLI

So beschreiben Sie eine Tabelle

Das folgende describe-table-Beispiel beschreibt die MusicCollection-Tabelle.


aws dynamodb describe-table \
    --table-name MusicCollection

Ausgabe:


{
    "Table": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "KeySchema": [
            {
                "KeyType": "HASH",
                "AttributeName": "Artist"
            },
            {
                "KeyType": "RANGE",
                "AttributeName": "SongTitle"
            }
        ],
        "ItemCount": 0,
        "CreationDateTime": 1421866952.062
    }
}

Weitere Informationen finden Sie unter Beschreiben einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DescribeTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-time-to-live verwendet wird.

AWS CLI

So zeigen Sie Time-to-Live-Einstellungen für eine Tabelle an

Im folgenden describe-time-to-live-Beispiel werden die Time-to-Live-Einstellungen für die MusicCollection-Tabelle angezeigt.


aws dynamodb describe-time-to-live \
    --table-name MusicCollection

Ausgabe:


{
    "TimeToLiveDescription": {
        "TimeToLiveStatus": "ENABLED",
        "AttributeName": "ttl"
    }
}

Weitere Informationen finden Sie unter Time to Live im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter DescribeTimeToLive in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie get-item verwendet wird.

AWS CLI

Beispiel 1: So lesen Sie ein Element in einer Tabelle

Das folgende get-item-Beispiel ruft ein Element aus der MusicCollection-Tabelle ab. Die Tabelle verwendet einen Hash- und Bereichs-Primärschlüssel (Artist und SongTitle), daher müssen Sie diese Attribute beide angeben. Der Befehl fragt auch Informationen über die Lesekapazität ab, die von der Operation verbraucht wird.


aws dynamodb get-item \
    --table-name MusicCollection \
    --key file://key.json \
    --return-consumed-capacity TOTAL

Inhalt von key.json:


{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}

Ausgabe:


{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}

Weitere Informationen finden Sie unter Lesen eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So lesen Sie ein Element mit einem konsistenten Lesevorgang

Das folgende Beispiel ruft mithilfe von strikt konsistenten Lesevorgängen ein Element aus der MusicCollection-Tabelle ab.


aws dynamodb get-item \
    --table-name MusicCollection \
    --key file://key.json \
    --consistent-read \
    --return-consumed-capacity TOTAL

Inhalt von key.json:


{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}

Ausgabe:


{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}

Weitere Informationen finden Sie unter Lesen eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So rufen Sie bestimmte Attribute eines Elements ab

Im folgenden Beispiel wird ein Projektionsausdruck verwendet, um nur drei Attribute des gewünschten Elements abzurufen.


aws dynamodb get-item \
    --table-name ProductCatalog \
    --key '{"Id": {"N": "102"}}' \
    --projection-expression "#T, #C, #P" \
    --expression-attribute-names file://names.json

Inhalt von names.json:


{
    "#T": "Title",
    "#C": "ProductCategory",
    "#P": "Price"
}

Ausgabe:


{
    "Item": {
        "Price": {
            "N": "20"
        },
        "Title": {
            "S": "Book 102 Title"
        },
        "ProductCategory": {
            "S": "Book"
        }
    }
}

Weitere Informationen finden Sie unter Lesen eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter GetItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-backups verwendet wird.

AWS CLI

Beispiel 1: So listen Sie alle vorhandenen DynamoDB-Sicherungen auf

Im folgenden list-backups-Beispiel werden alle vorhandenen Sicherungen aufgeführt.


aws dynamodb list-backups

Ausgabe:


{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        },
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So listen Sie von Benutzern erstellte Sicherungen in einem bestimmten Zeitraum auf

Im folgenden Beispiel werden nur Sicherungen der MusicCollection-Tabelle aufgeführt, die vom Benutzer (nicht automatisch von DynamoDB) erstellt wurden und deren Erstellungsdatum zwischen dem 1. Januar 2020 und dem 1. März 2020 liegt.


aws dynamodb list-backups \
    --table-name MusicCollection \
    --time-range-lower-bound 1577836800 \
    --time-range-upper-bound 1583020800 \
    --backup-type USER

Ausgabe:


{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        }
    ]
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So begrenzen Sie die Seitengröße

Das folgende Beispiel gibt eine Liste aller vorhandenen Sicherungen zurück, ruft jedoch bei jedem Aufruf nur ein Element ab und führt gegebenenfalls mehrere Aufrufe durch, um die gesamte Liste abzurufen. Die Begrenzung der Seitengröße ist nützlich, wenn Listenbefehle für eine große Anzahl von Ressourcen ausgeführt werden, was zu einem Timeout-Fehler führen kann, wenn die Standardseitengröße von 1 000 verwendet wird.


aws dynamodb list-backups \
    --page-size 1

Ausgabe:


{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        },
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 4: So begrenzen Sie die Anzahl der zurückgegebenen Elemente

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Elemente auf 1 begrenzt. Die Antwort enthält einen NextToken-Wert, mit dem die nächste Ergebnisseite abgerufen werden kann.


aws dynamodb list-backups \
    --max-items 1

Ausgabe:


{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 5: So rufen Sie die nächste Ergebnisseite ab

Der folgende Befehl verwendet den NextToken-Wert eines vorherigen Aufrufs des list-backups-Befehls, um eine weitere Ergebnisseite abzurufen. Da die Antwort in diesem Fall keinen NextToken-Wert enthält, wissen wir, dass wir das Ende der Ergebnisse erreicht haben.


aws dynamodb list-backups \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9

Output


{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter ListBackups in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-contributor-insights verwendet wird.

AWS CLI

Beispiel 1: So zeigen Sie eine Liste mit Contributor-Insights-Zusammenfassungen an

Im folgenden Beispiel für list-contributor-insights wird eine Liste der Contributor-Insights-Zusammenfassungen angezeigt.


aws dynamodb list-contributor-insights

Ausgabe:


{
    "ContributorInsightsSummaries": [
        {
            "TableName": "MusicCollection",
            "IndexName": "AlbumTitle-index",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "ProductCatalog",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Forum",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Reply",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Thread",
            "ContributorInsightsStatus": "ENABLED"
        }
    ]
}

Weitere Informationen finden Sie unter Analysieren des Datenzugriffs mithilfe von CloudWatch Contributor Insights für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So begrenzen Sie die Anzahl der zurückgegebenen Elemente

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Elemente auf 4 begrenzt. Die Antwort enthält einen NextToken-Wert, mit dem die nächste Ergebnisseite abgerufen werden kann.


aws dynamodb list-contributor-insights \
    --max-results 4

Ausgabe:


{
    "ContributorInsightsSummaries": [
        {
            "TableName": "MusicCollection",
            "IndexName": "AlbumTitle-index",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "ProductCatalog",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Forum",
            "ContributorInsightsStatus": "ENABLED"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Weitere Informationen finden Sie unter Analysieren des Datenzugriffs mithilfe von CloudWatch Contributor Insights für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So rufen Sie die nächste Ergebnisseite ab

Der folgende Befehl verwendet den NextToken-Wert eines vorherigen Aufrufs des list-contributor-insights-Befehls, um eine weitere Ergebnisseite abzurufen. Da die Antwort in diesem Fall keinen NextToken-Wert enthält, wissen wir, dass wir das Ende der Ergebnisse erreicht haben.


aws dynamodb list-contributor-insights \
    --max-results 4 \
    --next-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9

Ausgabe:


{
    "ContributorInsightsSummaries": [
        {
            "TableName": "Reply",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Thread",
            "ContributorInsightsStatus": "ENABLED"
        }
    ]
}

Weitere Informationen finden Sie unter Analysieren des Datenzugriffs mithilfe von CloudWatch Contributor Insights für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter ListContributorInsights in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-global-tables verwendet wird.

AWS CLI

So listen Sie vorhandene globale DynamoDB-Tabellen auf

Im folgenden list-global-tables-Beispiel werden alle vorhandenen globalen Tabellen aufgeführt.


aws dynamodb list-global-tables

Ausgabe:


{
    "GlobalTables": [
        {
            "GlobalTableName": "MusicCollection",
            "ReplicationGroup": [
                {
                    "RegionName": "us-east-2"
                },
                {
                    "RegionName": "us-east-1"
                }
            ]
        }
    ]
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter ListGlobalTables in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-tables verwendet wird.

AWS CLI

Beispiel 1: So listen Sie Tabellen auf

Im folgenden Beispiel für list-tables werden die mit Ihrem aktuellen AWS-Konto und Ihrer Region verknüpften Tabellen aufgelistet.


aws dynamodb list-tables

Ausgabe:


{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}

Weitere Informationen finden Sie unter Auflisten von Tabellennamen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So begrenzen Sie die Seitengröße

Das folgende Beispiel gibt eine Liste aller vorhandenen Tabellen zurück, ruft jedoch bei jedem Aufruf nur ein Element ab und führt gegebenenfalls mehrere Aufrufe durch, um die gesamte Liste abzurufen. Die Begrenzung der Seitengröße ist nützlich, wenn Listenbefehle für eine große Anzahl von Ressourcen ausgeführt werden, was zu einem Timeout-Fehler führen kann, wenn die Standardseitengröße von 1 000 verwendet wird.


aws dynamodb list-tables \
    --page-size 1

Ausgabe:


{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}

Weitere Informationen finden Sie unter Auflisten von Tabellennamen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So begrenzen Sie die Anzahl der zurückgegebenen Elemente

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Elemente auf 2 begrenzt. Die Antwort enthält einen NextToken-Wert, mit dem die nächste Ergebnisseite abgerufen werden kann.


aws dynamodb list-tables \
    --max-items 2

Ausgabe:


{
    "TableNames": [
        "Forum",
        "ProductCatalog"
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Weitere Informationen finden Sie unter Auflisten von Tabellennamen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 4: So rufen Sie die nächste Ergebnisseite ab

Der folgende Befehl verwendet den NextToken-Wert eines vorherigen Aufrufs des list-tables-Befehls, um eine weitere Ergebnisseite abzurufen. Da die Antwort in diesem Fall keinen NextToken-Wert enthält, wissen wir, dass wir das Ende der Ergebnisse erreicht haben.


aws dynamodb list-tables \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9

Ausgabe:


{
    "TableNames": [
        "Reply",
        "Thread"
    ]
}

Weitere Informationen finden Sie unter Auflisten von Tabellennamen im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter ListTables in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-tags-of-resource verwendet wird.

AWS CLI

Beispiel 1: So listen Sie Tags einer DynamoDB-Ressource auf

Im folgenden list-tags-of-resource-Beispiel werden Tags für die MusicCollection-Tabelle angezeigt.


aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection

Ausgabe:


{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        },
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}

Weitere Informationen finden Sie unter Tagging für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So begrenzen Sie die Anzahl der zurückgegebenen Tags

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Tags auf 1 begrenzt. Die Antwort enthält einen NextToken-Wert, mit dem die nächste Ergebnisseite abgerufen werden kann.


aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --max-items 1

Ausgabe:


{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Weitere Informationen finden Sie unter Tagging für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So rufen Sie die nächste Ergebnisseite ab

Der folgende Befehl verwendet den NextToken-Wert eines vorherigen Aufrufs des list-tags-of-resource-Befehls, um eine weitere Ergebnisseite abzurufen. Da die Antwort in diesem Fall keinen NextToken-Wert enthält, wissen wir, dass wir das Ende der Ergebnisse erreicht haben.


aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9

Ausgabe:


{
    "Tags": [
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}

Weitere Informationen finden Sie unter Tagging für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter ListTagsOfResource in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie put-item verwendet wird.

AWS CLI

Beispiel 1: So fügen Sie einer Tabelle ein Element hinzu

Im folgenden put-item-Beispiel wird der Tabelle MusicCollection ein neues Element hinzugefügt.


aws dynamodb put-item \
    --table-name MusicCollection \
    --item file://item.json \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE

Inhalt von item.json:


{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Call Me Today"},
    "AlbumTitle": {"S": "Greatest Hits"}
}

Ausgabe:


{
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "No One You Know"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So überschreiben Sie ein Element in einer Tabelle bedingungsabhängig

Im folgenden put-item-Beispiel wird ein vorhandenes Element in der MusicCollection-Tabelle nur dann überschrieben, wenn dieses vorhandene Element ein AlbumTitle-Attribut mit dem Wert Greatest Hits hat. Der Befehl gibt den vorherigen Wert des Elements zurück.


aws dynamodb put-item \
    --table-name MusicCollection \
    --item file://item.json \
    --condition-expression "#A = :A" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-values ALL_OLD

Inhalt von item.json:


{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Call Me Today"},
    "AlbumTitle": {"S": "Somewhat Famous"}
}

Inhalt von names.json:


{
    "#A": "AlbumTitle"
}

Inhalt von values.json:


{
    ":A": {"S": "Greatest Hits"}
}

Ausgabe:


{
    "Attributes": {
        "AlbumTitle": {
            "S": "Greatest Hits"
        },
        "Artist": {
            "S": "No One You Know"
        },
        "SongTitle": {
            "S": "Call Me Today"
        }
    }
}

Wenn der Schlüssel bereits existiert, sollten Sie die folgende Ausgabe sehen:


A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter PutItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie query verwendet wird.

AWS CLI

Beispiel 1: So fragen Sie eine Tabelle ab

Das folgende query-Beispiel fragt Elemente in der Tabelle MusicCollection ab. Die Tabelle verwendet einen Hash-und-Bereichs-Primärschlüssel (Artist und SongTitle), aber in dieser Abfrage wird nur der Hash-Schlüsselwert angegeben. Es werden Songtitel des Künstlers mit dem Namen „No One You Know“ zurückgegeben.


aws dynamodb query \
    --table-name MusicCollection \
    --projection-expression "SongTitle" \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --return-consumed-capacity TOTAL

Inhalt von expression-attributes.json:


{
    ":v1": {"S": "No One You Know"}
}

Ausgabe:


{
    "Items": [
        {
            "SongTitle": {
                "S": "Call Me Today"
            },
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}

Weitere Informationen finden Sie unter Arbeiten mit Abfragen in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So fragen Sie eine Tabelle mit strikt konsistenten Lesevorgängen ab und durchlaufen den Index in absteigender Reihenfolge

Im folgenden Beispiel wird dieselbe Abfrage wie im ersten Beispiel ausgeführt, die Ergebnisse werden jedoch in umgekehrter Reihenfolge zurückgegeben und es werden strikt konsistente Lesevorgänge verwendet.


aws dynamodb query \
    --table-name MusicCollection \
    --projection-expression "SongTitle" \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --consistent-read \
    --no-scan-index-forward \
    --return-consumed-capacity TOTAL

Inhalt von expression-attributes.json:


{
    ":v1": {"S": "No One You Know"}
}

Ausgabe:


{
    "Items": [
        {
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        },
        {
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}

Weitere Informationen finden Sie unter Arbeiten mit Abfragen in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So filtern Sie bestimmte Ergebnisse heraus

Das folgende Beispiel fragt MusicCollection ab, schließt jedoch Ergebnisse mit bestimmten Werten im AlbumTitle-Attribut aus. Beachten Sie, dass sich dies nicht auf ScannedCount oder ConsumedCapacity auswirkt, da der Filter angewendet wird, nachdem die Elemente gelesen wurden.


aws dynamodb query \
    --table-name MusicCollection \
    --key-condition-expression "#n1 = :v1" \
    --filter-expression "NOT (#n2 IN (:v2, :v3))" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-consumed-capacity TOTAL

Inhalt von values.json:


{
    ":v1": {"S": "No One You Know"},
    ":v2": {"S": "Blue Sky Blues"},
    ":v3": {"S": "Greatest Hits"}
}

Inhalt von names.json:


{
    "#n1": "Artist",
    "#n2": "AlbumTitle"
}

Ausgabe:


{
    "Items": [
        {
            "AlbumTitle": {
                "S": "Somewhat Famous"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 1,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}

Weitere Informationen finden Sie unter Arbeiten mit Abfragen in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 4: So rufen Sie nur die Elementanzahl ab

Das folgende Beispiel ruft eine Anzahl von Elementen ab, die der Abfrage entsprechen, ruft jedoch keines der Elemente selbst ab.


aws dynamodb query \
    --table-name MusicCollection \
    --select COUNT \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json

Inhalt von expression-attributes.json:


{
    ":v1": {"S": "No One You Know"}
}

Ausgabe:


{
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": null
}

Weitere Informationen finden Sie unter Arbeiten mit Abfragen in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 5: So rufen Sie einen Index ab

Das folgende Beispiel fragt den globalen sekundären Index AlbumTitleIndex ab. Die Abfrage gibt alle Attribute aus der Basistabelle zurück, die in den lokalen sekundären Index projiziert wurden. Beachten Sie, dass Sie bei der Abfrage eines lokalen sekundären Index oder eines globalen sekundären Index auch den Namen der Basistabelle mit dem table-name-Parameter angeben müssen.


aws dynamodb query \
    --table-name MusicCollection \
    --index-name AlbumTitleIndex \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --select ALL_PROJECTED_ATTRIBUTES \
    --return-consumed-capacity INDEXES

Inhalt von expression-attributes.json:


{
    ":v1": {"S": "No One You Know"}
}

Ausgabe:


{
    "Items": [
        {
            "AlbumTitle": {
                "S": "Blue Sky Blues"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        },
        {
            "AlbumTitle": {
                "S": "Somewhat Famous"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5,
        "Table": {
            "CapacityUnits": 0.0
        },
        "LocalSecondaryIndexes": {
            "AlbumTitleIndex": {
                "CapacityUnits": 0.5
            }
        }
    }
}

Weitere Informationen finden Sie unter Arbeiten mit Abfragen in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter Query in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie restore-table-from-backup verwendet wird.

AWS CLI

So stellen Sie eine DynamoDB-Tabelle aus einer vorhandenen Sicherung wieder her

Das folgende restore-table-from-backup-Beispiel stellt die angegebene Tabelle aus einer vorhandenen Sicherung wieder her.


aws dynamodb restore-table-from-backup \
    --target-table-name MusicCollection \
    --backup-arnarn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection2",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": 1576618274.326,
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection2",
        "TableId": "114865c9-5ef3-496c-b4d1-c4cbdd2d44fb",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED"
        },
        "RestoreSummary": {
            "SourceBackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "SourceTableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "RestoreDateTime": 1576616366.715,
            "RestoreInProgress": true
        }
    }
}

Weitere Informationen finden Sie unter On-Demand-Backup und -Wiederherstellung für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter RestoreTableFromBackup in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie restore-table-to-point-in-time verwendet wird.

AWS CLI

So stellen Sie eine DynamoDB-Tabelle zu einem bestimmten Zeitpunkt wieder her

Das folgende restore-table-to-point-in-time-Beispiel stellt die MusicCollection-Tabelle zum angegebenen Zeitpunkt wieder her.


aws dynamodb restore-table-to-point-in-time \
    --source-table-name MusicCollection \
    --target-table-name MusicCollectionRestore \
    --restore-date-time 1576622404.0

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollectionRestore",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": 1576623311.86,
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollectionRestore",
        "TableId": "befd9e0e-1843-4dc6-a147-d6d00e85cb1f",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED"
        },
        "RestoreSummary": {
            "SourceTableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "RestoreDateTime": 1576622404.0,
            "RestoreInProgress": true
        }
    }
}

Weitere Informationen finden Sie unter Wiederherstellung auf einen bestimmten Zeitpunkt für DynamoDB im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter RestoreTableToPointInTime in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie scan verwendet wird.

AWS CLI

So scannen Sie eine Tabelle

Das folgende scan-Beispiel scannt die gesamte MusicCollection-Tabelle und grenzt die Ergebnisse dann auf Songs des Künstlers „No One You Know“ ein. Für jedes Element werden nur der Albumtitel und der Songtitel zurückgegeben.


aws dynamodb scan \
    --table-name MusicCollection \
    --filter-expression "Artist = :a" \
    --projection-expression "#ST, #AT" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json

Inhalt von expression-attribute-names.json:


{
    "#ST": "SongTitle",
    "#AT":"AlbumTitle"
}

Inhalt von expression-attribute-values.json:


{
    ":a": {"S": "No One You Know"}
}

Ausgabe:


{
    "Count": 2,
    "Items": [
        {
            "SongTitle": {
                "S": "Call Me Today"
            },
            "AlbumTitle": {
                "S": "Somewhat Famous"
            }
        },
        {
            "SongTitle": {
                "S": "Scared of My Shadow"
            },
            "AlbumTitle": {
                "S": "Blue Sky Blues"
            }
        }
    ],
    "ScannedCount": 3,
    "ConsumedCapacity": null
}

Weitere Informationen finden Sie unter Arbeiten mit Scans in DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter Scan in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie tag-resource verwendet wird.

AWS CLI

So fügen Sie einer DynamoDB-Ressource Tags hinzu

Das folgende tag-resource-Beispiel fügt der MusicCollection-Tabelle ein Tag-Schlüssel-Wert-Paar hinzu.


aws dynamodb tag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tags Key=Owner,Value=blueTeam

Mit diesem Befehl wird keine Ausgabe zurückgegeben.

Weitere Informationen finden Sie unter Tagging für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter TagResource in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie transact-get-items verwendet wird.

AWS CLI

So rufen Sie verschiedene Elemente aus einer oder mehreren Tabellen atomar ab

Im folgenden transact-get-items-Beispiel werden mehrere Elemente atomar abgerufen.


aws dynamodb transact-get-items \
    --transact-items file://transact-items.json \
    --return-consumed-capacity TOTAL

Inhalt von transact-items.json:


[
    {
        "Get": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "TableName": "MusicCollection"
        }
    },
    {
        "Get": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection"
        }
    }
]

Ausgabe:


{
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 4.0,
            "ReadCapacityUnits": 4.0
        }
    ],
    "Responses": [
        {
            "Item": {
                "AlbumTitle": {
                    "S": "Songs About Life"
                },
                "Artist": {
                    "S": "Acme Band"
                },
                "SongTitle": {
                    "S": "Happy Day"
                }
            }
        },
        {
            "Item": {
                "AlbumTitle": {
                    "S": "Somewhat Famous"
                },
                "Artist": {
                    "S": "No One You Know"
                },
                "SongTitle": {
                    "S": "Call Me Today"
                }
            }
        }
    ]
}

Weitere Informationen finden Sie unter Verwalten komplexer Workflows mit DynamoDB-Transaktionen im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter TransactGetItems in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie transact-write-items verwendet wird.

AWS CLI

Beispiel 1: So schreiben Sie Elemente atomar in eine oder mehrere Tabellen

Im folgenden transact-write-items-Beispiel wird ein Element aktualisiert und ein anderes gelöscht. Der Vorgang schlägt fehl, wenn bei einer der Operationen ein Fehler auftritt oder eines der Elemente ein Rating-Attribut enthält.


aws dynamodb transact-write-items \
    --transact-items file://transact-items.json \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE

Inhalt der transact-items.json-Datei:


[
    {
        "Update": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "UpdateExpression": "SET AlbumTitle = :newval",
            "ExpressionAttributeValues": {
                ":newval": {"S": "Updated Album Title"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    },
    {
        "Delete": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    }
]

Ausgabe:


{
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 10.0,
            "WriteCapacityUnits": 10.0
        }
    ],
    "ItemCollectionMetrics": {
        "MusicCollection": [
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "No One You Know"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            },
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "Acme Band"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            }
        ]
    }
}

Weitere Informationen finden Sie unter Verwalten komplexer Workflows mit DynamoDB-Transaktionen im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So schreiben Sie Elemente mithilfe eines Clientanforderungstoken atomar

Der folgende Befehl verwendet ein Clientanforderungstoken, um den Aufruf an transact-write-items idempotent zu gestalten, was bedeutet, dass mehrere Aufrufe den gleichen Effekt haben wie ein einziger Aufruf.


aws dynamodb transact-write-items \
    --transact-items file://transact-items.json \
    --client-request-token abc123

Inhalt der transact-items.json-Datei:


[
    {
        "Update": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "UpdateExpression": "SET AlbumTitle = :newval",
            "ExpressionAttributeValues": {
                ":newval": {"S": "Updated Album Title"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    },
    {
        "Delete": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    }
]

Mit diesem Befehl wird keine Ausgabe zurückgegeben.

Weitere Informationen finden Sie unter Verwalten komplexer Workflows mit DynamoDB-Transaktionen im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter TransactWriteItems in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie untag-resource verwendet wird.

AWS CLI

So entfernen Sie ein Tag aus einer DynamoDB-Ressource

Im folgenden untag-resource-Beispiel wird das Tag mit dem Schlüssel Owner aus der Tabelle MusicCollection entfernt.


aws dynamodb untag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tag-keys Owner

Mit diesem Befehl wird keine Ausgabe zurückgegeben.

Weitere Informationen finden Sie unter Tagging für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter UntagResource in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-continuous-backups verwendet wird.

AWS CLI

So aktualisieren Sie die Einstellungen für kontinuierliche Sicherungen für eine DynamoDB-Tabelle

Im folgenden update-continuous-backups-Beispiel wird die zeitpunktbezogene Wiederherstellung für die MusicCollection-Tabelle aktiviert.


aws dynamodb update-continuous-backups \
    --table-name MusicCollection \
    --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true

Ausgabe:


{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "ENABLED",
            "EarliestRestorableDateTime": 1576622404.0,
            "LatestRestorableDateTime": 1576622404.0
        }
    }
}

Weitere Informationen finden Sie unter Wiederherstellung auf einen bestimmten Zeitpunkt für DynamoDB im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter UpdateContinuousBackups in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-contributor-insights verwendet wird.

AWS CLI

So aktivieren Sie Contributor Insights für eine Tabelle

Im folgenden update-contributor-insights-Beispiel wird Contributor Insights für die MusicCollection-Tabelle und den globalen sekundären Index AlbumTitle-index aktiviert.


aws dynamodb update-contributor-insights \
    --table-name MusicCollection \
    --index-name AlbumTitle-index \
    --contributor-insights-action ENABLE

Ausgabe:


{
    "TableName": "MusicCollection",
    "IndexName": "AlbumTitle-index",
    "ContributorInsightsStatus": "ENABLING"
}

Weitere Informationen finden Sie unter Analysieren des Datenzugriffs mithilfe von CloudWatch Contributor Insights für DynamoDB im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter UpdateContributorInsights in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-global-table-settings verwendet wird.

AWS CLI

So aktualisieren Sie die bereitgestellten Schreibkapazitätseinstellungen für eine globale DynamoDB-Tabelle

Im folgenden update-global-table-settings-Beispiel wird die bereitgestellte Schreibkapazität der globalen MusicCollection-Tabelle auf 15 festgelegt.


aws dynamodb update-global-table-settings \
    --global-table-name MusicCollection \
    --global-table-provisioned-write-capacity-units 15

Ausgabe:


{
    "GlobalTableName": "MusicCollection",
    "ReplicaSettings": [
        {
            "RegionName": "eu-west-1",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-1",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-2",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        }
    ]
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter UpdateGlobalTableSettings in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-global-table verwendet wird.

AWS CLI

So aktualisieren Sie eine globale DynamoDB-Tabelle

Im folgenden update-global-table-Beispiel wird der globalen Tabelle MusicCollection ein Replikat in der angegebenen Region hinzugefügt.


aws dynamodb update-global-table \
    --global-table-name MusicCollection \
    --replica-updates Create={RegionName=eu-west-1}

Ausgabe:


{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "eu-west-1"
            },
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "ACTIVE",
        "GlobalTableName": "MusicCollection"
    }
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter UpdateGlobalTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-item verwendet wird.

AWS CLI

Beispiel 1: So aktualisieren Sie ein Element in einer Tabelle

Das folgende update-item-Beispiel aktualisiert ein Element in der Tabelle MusicCollection. Es fügt ein neues Attribut (Year) hinzu und ändert das Attribut AlbumTitle. Alle Attribute im Element, wie sie nach dem Update erscheinen, werden in der Antwort zurückgegeben.


aws dynamodb update-item \
    --table-name MusicCollection \
    --key file://key.json \
    --update-expression "SET #Y = :y, #AT = :t" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json  \
    --return-values ALL_NEW \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE

Inhalt von key.json:


{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}

Inhalt von expression-attribute-names.json:


{
    "#Y":"Year", "#AT":"AlbumTitle"
}

Inhalt von expression-attribute-values.json:


{
    ":y":{"N": "2015"},
    ":t":{"S": "Louder Than Ever"}
}

Ausgabe:


{
    "Attributes": {
        "AlbumTitle": {
            "S": "Louder Than Ever"
        },
        "Awards": {
            "N": "10"
        },
        "Artist": {
            "S": "Acme Band"
        },
        "Year": {
            "N": "2015"
        },
        "SongTitle": {
            "S": "Happy Day"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 3.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "Acme Band"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So aktualisieren Sie ein Element bedingungsabhängig

Im folgenden Beispiel wird ein Element in der MusicCollection-Tabelle aktualisiert, jedoch nur, wenn das vorhandene Element noch kein Year-Attribut besitzt.


aws dynamodb update-item \
    --table-name MusicCollection \
    --key file://key.json \
    --update-expression "SET #Y = :y, #AT = :t" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json  \
    --condition-expression "attribute_not_exists(#Y)"

Inhalt von key.json:


{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}

Inhalt von expression-attribute-names.json:


{
    "#Y":"Year",
    "#AT":"AlbumTitle"
}

Inhalt von expression-attribute-values.json:


{
    ":y":{"N": "2015"},
    ":t":{"S": "Louder Than Ever"}
}

Wenn das Element bereits über ein Year-Attribut verfügt, gibt DynamoDB die folgende Ausgabe zurück.


An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed

Weitere Informationen finden Sie unter Schreiben eines Elements im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter UpdateItem in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-table-replica-auto-scaling verwendet wird.

AWS CLI

So aktualisieren Sie Auto-Scaling-Einstellungen für Replikate einer globalen Tabelle

Im folgenden update-table-replica-auto-scaling-Beispiel werden Auto-Scaling-Einstellungen für die Schreibkapazität für alle Replikate der angegebenen globalen Tabelle angezeigt.


aws dynamodb update-table-replica-auto-scaling \
    --table-name MusicCollection \
    --provisioned-write-capacity-auto-scaling-update file://auto-scaling-policy.json

Inhalt von auto-scaling-policy.json:


{
    "MinimumUnits": 10,
    "MaximumUnits": 100,
    "AutoScalingDisabled": false,
    "ScalingPolicyUpdate": {
        "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
        "TargetTrackingScalingPolicyConfiguration": {
            "TargetValue": 80
        }
    }
}

Ausgabe:


{
    "TableAutoScalingDescription": {
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "Replicas": [
            {
                "RegionName": "eu-central-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-2",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Globale DynamoDB-Tabellen im Amazon-DynamoDB-Entwicklerhandbuch.

API-Details finden Sie unter UpdateTableReplicaAutoScaling in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-table verwendet wird.

AWS CLI

Beispiel 1: So ändern Sie den Fakturierungsmodus einer Tabelle

Das folgende update-table-Beispiel erhöht die bereitgestellte Lese- und Schreibkapazität für die MusicCollection-Tabelle.


aws dynamodb update-table \
    --table-name MusicCollection \
    --billing-mode PROVISIONED \
    --provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T13:18:18.921000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        }
    }
}

Weitere Informationen finden Sie unter Aktualisieren einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 2: So erstellen Sie einen globalen sekundären Index

Das folgende Beispiel fügt der MusicCollection-Tabelle einen globalen sekundären Index hinzu.


aws dynamodb update-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=AlbumTitle,AttributeType=S \
    --global-secondary-index-updates file://gsi-updates.json

Inhalt von gsi-updates.json:


[
    {
        "Create": {
            "IndexName": "AlbumTitle-index",
            "KeySchema": [
                {
                    "AttributeName": "AlbumTitle",
                    "KeyType": "HASH"
                }
            ],
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 10,
                "WriteCapacityUnits": 10
            },
            "Projection": {
                "ProjectionType": "ALL"
            }
        }
    }
]

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "Backfilling": false,
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ]
    }
}

Weitere Informationen finden Sie unter Aktualisieren einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 3: So aktivieren Sie DynamoDB Streams für eine Tabelle

Der folgende Befehl aktiviert DynamoDB Streams für die MusicCollection-Tabelle.


aws dynamodb update-table \
    --table-name MusicCollection \
    --stream-specification StreamEnabled=true,StreamViewType=NEW_IMAGE

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Year",
                        "Genre"
                    ]
                },
                "IndexSizeBytes": 139,
                "ItemCount": 2,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ],
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "ACTIVE",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ],
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_IMAGE"
        },
        "LatestStreamLabel": "2020-07-28T21:53:39.112",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/stream/2020-07-28T21:53:39.112"
    }
}

Weitere Informationen finden Sie unter Aktualisieren einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

Beispiel 4: So aktivieren Sie die serverseitige Verschlüsselung

Im folgenden Beispiel wird die serverseitige Verschlüsselung für die MusicCollection-Tabelle aktiviert.


aws dynamodb update-table \
    --table-name MusicCollection \
    --sse-specification Enabled=true,SSEType=KMS

Ausgabe:


{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "ACTIVE",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Year",
                        "Genre"
                    ]
                },
                "IndexSizeBytes": 139,
                "ItemCount": 2,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ],
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "ACTIVE",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ],
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_IMAGE"
        },
        "LatestStreamLabel": "2020-07-28T21:53:39.112",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/stream/2020-07-28T21:53:39.112",
        "SSEDescription": {
            "Status": "UPDATING"
        }
    }
}

Weitere Informationen finden Sie unter Aktualisieren einer Tabelle im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter UpdateTable in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-time-to-live verwendet wird.

AWS CLI

So aktualisieren Sie die Time-to-Live-Einstellungen für eine Tabelle

Im folgenden update-time-to-live-Beispiel wird Time to Live für die angegebene Tabelle aktiviert.


aws dynamodb update-time-to-live \
    --table-name MusicCollection \
    --time-to-live-specification Enabled=true,AttributeName=ttl

Ausgabe:


{
    "TimeToLiveSpecification": {
        "Enabled": true,
        "AttributeName": "ttl"
    }
}

Weitere Informationen finden Sie unter Time to Live im Entwicklerhandbuch zu Amazon DynamoDB.

API-Details finden Sie unter UpdateTimeToLive in der AWS CLI-Befehlsreferenz.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Amazon DocumentDB

DynamoDB-Streams