DynamoDB-Beispiele mit AWS CLI

Die folgenden Codebeispiele zeigen Ihnen, wie Sie AWS Command Line Interface mit DynamoDB Aktionen ausführen und allgemeine Szenarien implementieren.

Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Aktionen zeigen Ihnen zwar, wie Sie einzelne Servicefunktionen aufrufen, aber Sie können Aktionen im Kontext der zugehörigen Szenarien sehen.

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

Themen

Aktionen

Aktionen

Das folgende Codebeispiel zeigt die Verwendungbatch-get-item.

AWS CLI

Um mehrere Elemente aus einer Tabelle abzurufen

Im folgenden batch-get-items Beispiel werden mithilfe eines Stapels von drei GetItem Anfragen mehrere Elemente aus der MusicCollection Tabelle gelesen und die Anzahl der durch den Vorgang verbrauchten Lesekapazitätseinheiten 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 Operations im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter BatchGetItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungbatch-write-item.

AWS CLI

Um mehrere Elemente zu einer Tabelle hinzuzufügen

Im folgenden batch-write-item Beispiel werden der MusicCollection Tabelle drei neue Elemente hinzugefügt, wobei ein Stapel von drei PutItem Anfragen verwendet wird. Außerdem werden Informationen über die Anzahl der durch den Vorgang verbrauchten Schreibkapazitätseinheiten sowie über alle durch den Vorgang geänderten Elementsammlungen angefordert.


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 Operations im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter BatchWriteItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungcreate-backup.

AWS CLI

Um ein Backup für eine bestehende DynamoDB-Tabelle zu erstellen

Im folgenden create-backup Beispiel wird eine Sicherungskopie 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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter CreateBackupBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungcreate-global-table.

AWS CLI

Um eine globale Tabelle zu erstellen

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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter CreateGlobalTableBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungcreate-table.

AWS CLI

Beispiel 1: Um eine Tabelle mit Tags zu erstellen

Im folgenden create-table Beispiel werden die angegebenen Attribute und das angegebene Schlüsselschema verwendet, um eine Tabelle mit dem Namen zu erstellenMusicCollection. Diese Tabelle verwendet den bereitgestellten Durchsatz und wird im Ruhezustand mit der Standardeinstellung AWS Owned CMK verschlüsselt. Der Befehl weist der Tabelle außerdem ein Tag mit dem Schlüssel Owner und dem Wert von 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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

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

Im folgenden Beispiel wird eine Tabelle erstellt, die im MusicCollection On-Demand-Modus und nicht im Bereitstellungs-Durchsatzmodus aufgerufen wird. 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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

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

Das folgende Beispiel erstellt eine Tabelle mit dem Namen MusicCollection und verschlüsselt sie mithilfe einer vom Kunden verwalteten Tabelle. CMK


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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

Beispiel 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 MusicCollection mit einem Namen für den lokalen sekundären Index zu erstellenAlbumTitleIndex.


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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

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

Im folgenden Beispiel wird eine Tabelle GameScores mit dem Namen „Globaler Sekundärer Index“ erstelltGameTitleIndex. Die Basistabelle hat einen Partitionsschlüssel von UserId und einen Sortierschlüssel vonGameTitle, sodass Sie effizient die beste Punktzahl eines einzelnen Benutzers für ein bestimmtes Spiel ermitteln können, wohingegen die Tabelle einen Partitionsschlüssel von GameTitle und einen Sortierschlüssel von GSI hatTopScore, sodass Sie schnell die höchste Gesamtpunktzahl für ein bestimmtes Spiel ermitteln können.


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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

Beispiel 6: So erstellen Sie eine Tabelle mit mehreren globalen Sekundärindizes gleichzeitig

Im folgenden Beispiel wird eine Tabelle erstellt, die GameScores mit zwei globalen sekundären Indizes benannt ist. 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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

Beispiel 7: So erstellen Sie eine Tabelle mit aktivierten Streams

Im folgenden Beispiel wird eine Tabelle GameScores mit aktiviertem DynamoDB Streams aufgerufen. Sowohl neue als auch alte Bilder jedes Elements 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 Basic Operations for Tables im Amazon DynamoDB Developer Guide.

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

Im folgenden Beispiel wird eine Tabelle GameScores mit aktiviertem DynamoDB Streams aufgerufen. Nur die Schlüsselattribute der geänderten Elemente 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 Change Data Capture for DynamoDB Streams im Amazon DynamoDB Developer Guide.

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

Im folgenden Beispiel wird eine Tabelle mit dem Namen Standard-Infrequent Access (DynamoDB Standard-IA) erstellt GameScores und ihr zugewiesen. Diese Tabellenklasse ist für Speicher optimiert, da 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 Amazon DynamoDB Developer Guide.

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

Das folgende Beispiel erstellt eine Tabelle mit dem Namen GameScores und aktiviert den Löschschutz.


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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter CreateTable AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-backup.

AWS CLI

Um ein vorhandenes DynamoDB-Backup zu löschen

Im folgenden delete-backup Beispiel wird die angegebene vorhandene Sicherung gelöscht.


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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DeleteBackupBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdelete-item.

AWS CLI

Beispiel 1: Um ein Element zu löschen

Das folgende delete-item Beispiel löscht ein Element aus der MusicCollection Tabelle und fordert Details zu dem gelöschten Element und der von der Anforderung verwendeten Kapazität an.


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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 2: Um einen Artikel unter bestimmten Bedingungen zu löschen

Im folgenden Beispiel wird ein Artikel nur dann aus der ProductCatalog Tabelle gelöscht, wenn er entweder Sporting Goods oder ProductCategory ist Gardening Supplies und sein Preis zwischen 500 und 600 liegt. Es gibt Details zu dem Element zurück, das gelöscht wurde.


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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter DeleteItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-table.

AWS CLI

Um eine Tabelle zu löschen

Im folgenden delete-table Beispiel wird die MusicCollection Tabelle gelöscht.


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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter DeleteTable AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-backup.

AWS CLI

Um Informationen über eine bestehende Sicherung einer Tabelle abzurufen

Im folgenden describe-backup Beispiel werden Informationen über die angegebene vorhandene 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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeBackupBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-continuous-backups.

AWS CLI

Um Informationen über kontinuierliche Backups für eine DynamoDB-Tabelle abzurufen

Im folgenden describe-continuous-backups Beispiel werden Details zu den Einstellungen für kontinuierliche Backups 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 Point-in-Time Recovery for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeContinuousBackupsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-contributor-insights.

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 AlbumTitle-index globalen Sekundärindex 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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. DescribeContributorInsightsAWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-endpoints.

AWS CLI

Um regionale Endpunktinformationen anzuzeigen

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 Amazon DynamoDB Endpoints and Quotas in der AWS Allgemeinen Referenz.

APIEinzelheiten finden Sie unter Befehlsreferenz DescribeEndpoints.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-global-table-settings.

AWS CLI

Um Informationen über die Einstellungen einer globalen DynamoDB-Tabelle abzurufen

Im folgenden describe-global-table-settings Beispiel werden die Einstellungen für die MusicCollection globale 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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeGlobalTableSettingsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-global-table.

AWS CLI

So zeigen Sie Informationen zu einer globalen DynamoDB-Tabelle an

Im folgenden describe-global-table Beispiel werden Details zur MusicCollection globalen 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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeGlobalTableBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-limits.

AWS CLI

Um die Limits für die bereitgestellte Kapazität anzuzeigen

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


aws dynamodb describe-limits

Ausgabe:


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

Weitere Informationen finden Sie unter Limits in DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeLimitsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-table-replica-auto-scaling.

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 MusicCollection globalen 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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeTableReplicaAutoScalingBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungdescribe-table.

AWS CLI

Um eine Tabelle zu beschreiben

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 Describing a Table im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter DescribeTable AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-time-to-live.

AWS CLI

Um Time-to-Live-Einstellungen für eine Tabelle anzuzeigen

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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter DescribeTimeToLive AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungget-item.

AWS CLI

Beispiel 1: Um ein Element in einer Tabelle zu lesen

Im folgenden get-item Beispiel wird ein Element aus der MusicCollection Tabelle abgerufen. Die Tabelle hat einen hash-and-range Primärschlüssel (ArtistundSongTitle), daher müssen Sie diese beiden Attribute angeben. Der Befehl fordert auch Informationen über die durch den Vorgang verbrauchte Lesekapazität an.


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 Artikel lesen im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 2: Um ein Element mit einem konsistenten Lesevorgang zu lesen

Im folgenden Beispiel wird mithilfe stark konsistenter Lesevorgänge ein Element aus der MusicCollection Tabelle abgerufen.


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 Artikel lesen im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 3: So rufen Sie bestimmte Attribute eines Artikels 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 Artikel lesen im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter GetItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-backups.

AWS CLI

Beispiel 1: Um alle vorhandenen DynamoDB-Backups aufzulisten

Das folgende list-backups Beispiel listet alle Ihre vorhandenen Backups auf.


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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

Beispiel 2: Um von Benutzern erstellte Backups in einem bestimmten Zeitraum aufzulisten

Im folgenden Beispiel werden nur Backups der MusicCollection Tabelle aufgeführt, die vom Benutzer erstellt wurden (nicht die automatisch von DynamoDB erstellten), 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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

Beispiel 3: Um die Seitengröße zu begrenzen

Das folgende Beispiel gibt eine Liste aller vorhandenen Backups zurück, ruft jedoch bei jedem Aufruf nur ein Element ab und führt bei Bedarf 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. Dies kann bei Verwendung der Standardseitengröße von 1000 zu einem Timeout-Fehler führen.


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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

Beispiel 4: Um die Anzahl der zurückgegebenen Artikel zu begrenzen

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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter ListBackupsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendunglist-contributor-insights.

AWS CLI

Beispiel 1: Um eine Liste von Contributor Insights-Zusammenfassungen anzuzeigen

Im folgenden list-contributor-insights Beispiel wird eine Liste von 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 for DynamoDB im Amazon DynamoDB Developer Guide.

Beispiel 2: Um die Anzahl der zurückgegebenen Artikel zu begrenzen

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Artikel 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 for DynamoDB im Amazon DynamoDB Developer Guide.

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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. ListContributorInsightsAWS CLI

Das folgende Codebeispiel zeigt die Verwendunglist-global-tables.

AWS CLI

Um bestehende globale DynamoDB-Tabellen aufzulisten

Das folgende list-global-tables Beispiel listet alle Ihre vorhandenen globalen Tabellen auf.


aws dynamodb list-global-tables

Ausgabe:


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

Weitere Informationen finden Sie unter DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter ListGlobalTablesBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendunglist-tables.

AWS CLI

Beispiel 1: Um Tabellen aufzulisten

Das folgende list-tables Beispiel listet alle Tabellen auf, die dem AWS Girokonto und der Region zugeordnet sind.


aws dynamodb list-tables

Ausgabe:


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

Weitere Informationen finden Sie unter Tabellennamen auflisten im Amazon DynamoDB Developer Guide.

Beispiel 2: Um die Seitengröße zu begrenzen

Das folgende Beispiel gibt eine Liste aller vorhandenen Tabellen zurück, ruft jedoch bei jedem Aufruf nur ein Element ab und führt bei Bedarf 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. Dies kann bei Verwendung der Standardseitengröße von 1000 zu einem Timeout-Fehler führen.


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

Ausgabe:


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

Weitere Informationen finden Sie unter Tabellennamen auflisten im Amazon DynamoDB Developer Guide.

Beispiel 3: Um die Anzahl der zurückgegebenen Artikel zu begrenzen

Im folgenden Beispiel wird die Anzahl der zurückgegebenen Artikel 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 Tabellennamen auflisten im Amazon DynamoDB Developer Guide.

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 Tabellennamen auflisten im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter ListTables AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-tags-of-resource.

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 for DynamoDB im Amazon DynamoDB Developer Guide.

Beispiel 2: Um die Anzahl der zurückgegebenen Tags zu begrenzen

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 for DynamoDB im Amazon DynamoDB Developer Guide.

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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. ListTagsOfResourceAWS CLI

Das folgende Codebeispiel zeigt die Verwendungput-item.

AWS CLI

Beispiel 1: Um ein Element zu einer Tabelle hinzuzufügen

Das folgende put-item Beispiel fügt der MusicCollectionTabelle ein neues Element hinzu.


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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 2: Um ein Element in einer Tabelle bedingt zu überschreiben

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 hat. Greatest Hits 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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter PutItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungquery.

AWS CLI

Beispiel 1: Um eine Tabelle abzufragen

Im folgenden query Beispiel werden Elemente in der MusicCollection Tabelle abgefragt. Die Tabelle hat einen hash-and-range Primärschlüssel (ArtistundSongTitle), aber diese Abfrage gibt nur den Hashschlüsselwert an. Es gibt Songtitel des Künstlers mit dem Namen „No One You Know“ zurück.


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 Amazon DynamoDB Developer Guide.

Beispiel 2: Um eine Tabelle mit stark konsistenten Lesevorgängen abzufragen und den Index in absteigender Reihenfolge zu durchlaufen

Im folgenden Beispiel wird dieselbe Abfrage wie im ersten Beispiel ausgeführt, die Ergebnisse werden jedoch in umgekehrter Reihenfolge zurückgegeben und es werden stark 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 Amazon DynamoDB Developer Guide.

Beispiel 3: Um bestimmte Ergebnisse herauszufiltern

Das folgende Beispiel fragt die abMusicCollection, schließt jedoch Ergebnisse mit bestimmten Werten im AlbumTitle Attribut aus. Beachten Sie, dass sich dies nicht auf ScannedCount oder auswirktConsumedCapacity, 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 Amazon DynamoDB Developer Guide.

Beispiel 4: Um nur eine Artikelanzahl abzurufen

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 Amazon DynamoDB Developer Guide.

Beispiel 5: So fragen Sie einen Index ab

Im folgenden Beispiel wird der lokale sekundäre Index abgefragtAlbumTitleIndex. 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ärindexes oder eines globalen Sekundärindexes auch den Namen der Basistabelle mithilfe des table-name Parameters 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 Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Query in Command Reference.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungrestore-table-from-backup.

AWS CLI

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

Im folgenden restore-table-from-backup Beispiel wird die angegebene Tabelle aus einer vorhandenen Sicherung wiederhergestellt.


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 and Restore für DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter RestoreTableFromBackupBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungrestore-table-to-point-in-time.

AWS CLI

So stellen Sie eine DynamoDB-Tabelle auf einen bestimmten Zeitpunkt zurück

Im folgenden restore-table-to-point-in-time Beispiel wird die MusicCollection Tabelle auf den angegebenen Zeitpunkt zurückgesetzt.


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 Point-in-Time Recovery for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter RestoreTableToPointInTimeBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungscan.

AWS CLI

Um eine Tabelle zu scannen

Im folgenden scan Beispiel wird die gesamte MusicCollection Tabelle gescannt und die Ergebnisse dann auf Songs des Künstlers „No One You Know“ eingegrenzt. 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 Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Scan in Command Reference.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungtag-resource.

AWS CLI

So fügen Sie einer DynamoDB-Ressource Tags hinzu

Im folgenden tag-resource Beispiel wird der Tabelle ein Tag-Schlüssel/Wert-Paar hinzugefügt. MusicCollection


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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. TagResourceAWS CLI

Das folgende Codebeispiel zeigt die Verwendungtransact-get-items.

AWS CLI

Um mehrere Elemente atomar aus einer oder mehreren Tabellen abzurufen

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 Managing Complex Workflows with DynamoDB Transactions im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter TransactGetItemsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungtransact-write-items.

AWS CLI

Beispiel 1: Um Elemente atomar in eine oder mehrere Tabellen zu schreiben

Im folgenden transact-write-items Beispiel wird ein Element aktualisiert und ein anderes gelöscht. Der Vorgang schlägt fehl, wenn einer der Operationen fehlschlägt oder wenn 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 Managing Complex Workflows with DynamoDB Transactions im Amazon DynamoDB Developer Guide.

Beispiel 2: Um Elemente mithilfe eines Client-Request-Tokens atomar zu schreiben

Der folgende Befehl verwendet ein Client-Anforderungstoken, um den Aufruf an transact-write-items idempotent zu richten, 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 Datei: transact-items.json


[
    {
        "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 Managing Complex Workflows with DynamoDB Transactions im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter TransactWriteItemsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendunguntag-resource.

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 MusicCollection Tabelle 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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. UntagResourceAWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-continuous-backups.

AWS CLI

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

Das folgende update-continuous-backups Beispiel aktiviert die point-in-time Wiederherstellung für die MusicCollection Tabelle.


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 Point-in-Time Recovery for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter UpdateContinuousBackupsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-contributor-insights.

AWS CLI

Um Contributor Insights für eine Tabelle zu aktivieren

Im folgenden update-contributor-insights Beispiel wird Contributor Insights für die MusicCollection Tabelle und den AlbumTitle-index globalen Sekundärindex 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 for DynamoDB im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter Befehlsreferenz. UpdateContributorInsightsAWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-global-table-settings.

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 MusicCollection globalen 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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter UpdateGlobalTableSettingsBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-global-table.

AWS CLI

So aktualisieren Sie eine globale DynamoDB-Tabelle

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


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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter UpdateGlobalTableBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-item.

AWS CLI

Beispiel 1: Um ein Element in einer Tabelle zu aktualisieren

Das folgende update-item-Beispiel aktualisiert ein Element in der Tabelle MusicCollection. Es fügt ein neues Attribut (Year) hinzu und ändert das AlbumTitle Attribut. Alle Attribute im Element, so wie sie nach der Aktualisierung 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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 2: Um einen Artikel unter bestimmten Bedingungen zu aktualisieren

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 Artikel schreiben im Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter UpdateItem AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-table-replica-auto-scaling.

AWS CLI

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

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


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 DynamoDB Global Tables im Amazon DynamoDB Developer Guide.

APIEinzelheiten finden Sie unter UpdateTableReplicaAutoScalingBefehlsreferenz.AWS CLI

Das folgende Codebeispiel zeigt die Verwendungupdate-table.

AWS CLI

Beispiel 1: Um den Abrechnungsmodus einer Tabelle zu ändern

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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

Beispiel 4: Um die serverseitige Verschlüsselung zu aktivieren

Das folgende Beispiel aktiviert die serverseitige Verschlüsselung für die MusicCollection Tabelle.


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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter UpdateTable AWS CLIBefehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-time-to-live.

AWS CLI

Um die Time-to-Live-Einstellungen in einer Tabelle zu aktualisieren

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 Amazon DynamoDB DynamoDB-Entwicklerhandbuch.

APIEinzelheiten finden Sie unter UpdateTimeToLive AWS CLIBefehlsreferenz.

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