Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden der auto AWS CLI Skalierung von DynamoDB zur Verwaltung
Anstatt das zu verwenden AWS-Managementkonsole, können Sie das AWS Command Line Interface (AWS CLI) verwenden, um die auto Skalierung von Amazon DynamoDB zu verwalten. Das Tutorial in diesem Abschnitt erläutert, wie der AWS CLI installiert und konfiguriert wird, um DynamoDB-Auto-Scaling zu verwalten. In diesem Tutorial führen Sie folgende Aufgaben aus:
+ Erstellen einer DynamoDB-Tabelle mit dem Namen `TestTable`. Die Ersteinstellungen des Durchsatzes sind 5 Lesekapazitätseinheiten und 5 Schreibkapazitätseinheiten.
+ Erstellen Sie die Application-Auto-Scaling-Richtlinie für `TestTable`. Die Richtlinie versucht ein 50 %-Zielverhältnis zwischen verbrauchter und bereitgestellter Schreibkapazität beizubehalten. Der Bereich für diese Metrik liegt zwischen 5 und 10 Schreibkapazitätseinheiten. (Application Auto Scaling darf den Durchsatz außerhalb dieses Bereichs nicht anpassen.)
+ Ausführen eines Python-Programms, um den Datenverkehr zu `TestTable` zu leiten. Wenn das Zielverhältnis 50 Prozent über einen anhaltenden Zeitraum überschreitet, benachrichtigt Application Auto Scaling DynamoDB, um den Durchsatz von `TestTable` nach oben anzupassen, sodass die 50 % Zielauslastung aufrechterhalten werden kann.
+ Überprüfen, ob DynamoDB die bereitgestellte Schreibkapazität für `TestTable` erfolgreich angepasst hat.
**Anmerkung**
Sie können die DynamoDB-Skalierung auch so planen, dass sie zu bestimmten Zeiten erfolgt. Erfahren Sie [hier](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html) mehr über die grundlegenden Schritte.
**Topics**
+ [Bevor Sie beginnen](#AutoScaling.CLI.BeforeYouBegin)
+ [Schritt 1: Erstellen einer DynamoDB-Tabelle](#AutoScaling.CLI.CreateTable)
+ [Schritt 2: Registrieren eines skalierbaren Ziels](#AutoScaling.CLI.RegisterScalableTarget)
+ [Schritt 3: Erstellen einer Skalierungsrichtlinie](#AutoScaling.CLI.CreateScalingPolicy)
+ [Schritt 4: Leiten Sie den Schreibverkehr weiter zu TestTable](#AutoScaling.CLI.DriveTraffic)
+ [Schritt 5: Anzeigen der Application Auto Scaling](#AutoScaling.CLI.ViewCWAlarms)
+ [(Optional) Schritt 6: Bereinigen](#AutoScaling.CLI.CleanUp)
## Bevor Sie beginnen
Führen Sie folgende Schritte durch, bevor Sie das Tutorial starten.
### Installieren Sie das AWS CLI
Wenn Sie es noch nicht getan haben, müssen Sie AWS CLI installieren und konfigurieren. Befolgen Sie hierzu die Anweisungen im *AWS Command Line Interface Benutzerhandbuch*:
+ [Installieren des AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
+ [Konfigurieren von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
### Installieren von Python
Ein Teil dieses Tutorials erfordert von Ihnen das Ausführen eines Python-Programms (siehe [Schritt 4: Leiten Sie den Schreibverkehr weiter zu TestTable](#AutoScaling.CLI.DriveTraffic)). Wenn Sie das noch nicht installiert haben, können Sie [Python herunterladen](https://www.python.org/downloads).
## Schritt 1: Erstellen einer DynamoDB-Tabelle
In diesem Schritt verwenden Sie die AWS CLI zum Erstellen`TestTable`. Der Primärschlüssel besteht aus `pk` (Partitionsschlüssel) und `sk` (Sortierschlüssel). Beide Attribute sind vom Typ `Number`. Die Ersteinstellungen des Durchsatzes sind 5 Lesekapazitätseinheiten und 5 Schreibkapazitätseinheiten.
1. Verwenden Sie den folgenden AWS CLI Befehl, um die Tabelle zu erstellen.
```
aws dynamodb create-table \
--table-name TestTable \
--attribute-definitions \
AttributeName=pk,AttributeType=N \
AttributeName=sk,AttributeType=N \
--key-schema \
AttributeName=pk,KeyType=HASH \
AttributeName=sk,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
1. Verwenden Sie den folgenden Befehl, um den Status der Tabelle zu überprüfen.
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
Die Tabelle ist betriebsbereit, wenn ihr Status `ACTIVE` ist.
## Schritt 2: Registrieren eines skalierbaren Ziels
Jetzt registrieren Sie die Schreibkapazität der Tabelle als ein skalierbares Ziel mit Application Auto Scaling. Auf diese Weise kann Application Auto Scaling die bereitgestellte Schreibkapazität für *TestTable*, jedoch nur im Bereich von 5—10 Kapazitätseinheiten, anpassen.
**Anmerkung**
DynamoDB-Auto-Scaling erfordert das Vorhandensein einer Rolle (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`), die in Ihrem Namen Auto-Scaling-Aktionen durchführt. Diese Rolle wird automatisch für Sie erstellt. Weitere Informationen finden Sie unter [Serviceverknüpfte Rollen für Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) im *Benutzerhandbuch zu Application Auto Scaling*.
1. Geben Sie den folgenden Befehl ein, um das skalierbare Ziel zu registrieren.
```
aws application-autoscaling register-scalable-target \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--min-capacity 5 \
--max-capacity 10
```
1. Verwenden Sie den folgenden Befehl, um die Registrierung zu überprüfen.
```
aws application-autoscaling describe-scalable-targets \
--service-namespace dynamodb \
--resource-id "table/TestTable"
```
**Anmerkung**
Sie können ein skalierbares Ziel auch für einen globalen sekundären Index registrieren. Beispielsweise werden für einen globalen sekundären Index („Testindex“) die Ressourcen-ID und die skalierbaren Dimensionsargumente entsprechend aktualisiert.
```
aws application-autoscaling register-scalable-target \
--service-namespace dynamodb \
--resource-id "table/TestTable/index/test-index" \
--scalable-dimension "dynamodb:index:WriteCapacityUnits" \
--min-capacity 5 \
--max-capacity 10
```
## Schritt 3: Erstellen einer Skalierungsrichtlinie
In diesem Schritt erstellen Sie eine Skalierungsrichtlinie für `TestTable`. Die Richtlinie definiert die Details, unter denen Application Auto Scaling den bereitgestellten Durchsatz Ihrer Tabelle anpassen kann und welche Aktionen erfolgen müssen, wenn dies geschieht. Sie ordnen diese Richtlinie dem skalierbaren Ziel zu, das Sie im vorherigen Schritt definiert haben (Schreibkapazitätseinheiten für die `TestTable`-Tabelle).
Die Richtlinie enthält die folgenden Elemente:
+ `PredefinedMetricSpecification` – Die Metrik, die Application Auto Scaling anpassen darf. Für DynamoDB sind die folgenden Werte gültige Werte für `PredefinedMetricType`:
+ `DynamoDBReadCapacityUtilization`
+ `DynamoDBWriteCapacityUtilization`
+ `ScaleOutCooldown` – Die Mindestzeit (in Sekunden) zwischen jedem Application-Auto-Scaling-Ereignis, das den bereitgestellten Durchsatz erhöht. Dieser Parameter ermöglicht Application Auto Scaling den Durchsatz als Reaktion auf reale Workloads fortlaufend, aber nicht aggressiv, zu erhöhen. Die Standardeinstellung für `ScaleOutCooldown` lautet 0.
+ `ScaleInCooldown` – Die Mindestzeit (in Sekunden) zwischen jedem Application-Auto-Scaling-Ereignis, das den bereitgestellten Durchsatz verringert. Dieser Parameter ermöglicht Application Auto Scaling den Durchsatz schrittweise und berechenbar zu verringern. Die Standardeinstellung für `ScaleInCooldown` lautet 0.
+ `TargetValue`—Application Auto Scaling stellt sicher, dass das Verhältnis von verbrauchter Kapazität zu bereitgestellter Kapazität diesem Wert nahezu entspricht. Sie definieren `TargetValue` als Prozentsatz.
**Anmerkung**
Um besser zu verstehen, wie der `TargetValue` funktioniert, nehmen Sie an, dass Sie über eine Tabelle mit einer Einstellung des bereitgestellten Durchsatzes von 200 Schreibkapazitätseinheiten verfügen. Sie entscheiden sich dafür, eine Skalierungsrichtlinie für diese Tabelle mit einem `TargetValue` von 70 % zu erstellen.
Angenommen, Sie beginnen den Schreibverkehr zu der Tabelle zu leiten, damit der tatsächliche Schreibdurchsatz bei 150 Kapazitätseinheiten liegt. Das consumed-to-provisioned Verhältnis liegt jetzt bei (150/ 200) oder 75 Prozent. Dieses Verhältnis überschreitet Ihr Ziel, sodass Application Auto Scaling die bereitgestellte Schreibkapazität auf 215 erhöht, damit das Verhältnis (150 / 215) oder 69,77 Prozent ist – so nah an Ihrem `TargetValue` wie möglich, jedoch nicht darüber.
Für `TestTable`, setzen Sie `TargetValue` 50 Prozent. Application Auto Scaling passt den bereitgestellten Durchsatz der Tabelle im Bereich von 5 bis 10 Kapazitätseinheiten (siehe[Schritt 2: Registrieren eines skalierbaren Ziels](#AutoScaling.CLI.RegisterScalableTarget)) an, sodass das consumed-to-provisioned Verhältnis bei oder nahe 50 Prozent bleibt. Sie legen die Werte für `ScaleOutCooldown` und `ScaleInCooldown` auf 60 Sekunden fest.
1. Erstellen Sie eine Datei mit dem Namen `scaling-policy.json` und dem folgenden Inhalt.
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
},
"ScaleOutCooldown": 60,
"ScaleInCooldown": 60,
"TargetValue": 50.0
}
```
1. Verwenden Sie den folgenden AWS CLI Befehl, um die Richtlinie zu erstellen.
```
aws application-autoscaling put-scaling-policy \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy" \
--policy-type "TargetTrackingScaling" \
--target-tracking-scaling-policy-configuration file://scaling-policy.json
```
1. Beachten Sie in der Ausgabe, dass Application Auto Scaling zwei CloudWatch Amazon-Alarme generiert hat — jeweils einen für die obere und untere Grenze des Skalierungszielbereichs.
1. Verwenden Sie den folgenden AWS CLI Befehl, um weitere Details zur Skalierungsrichtlinie anzuzeigen.
```
aws application-autoscaling describe-scaling-policies \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--policy-name "MyScalingPolicy"
```
1. Überprüfen Sie in der Ausgabe, dass die Richtlinieneinstellungen mit Ihren Spezifikationen von [Schritt 2: Registrieren eines skalierbaren Ziels](#AutoScaling.CLI.RegisterScalableTarget) und [Schritt 3: Erstellen einer Skalierungsrichtlinie](#AutoScaling.CLI.CreateScalingPolicy) übereinstimmen.
## Schritt 4: Leiten Sie den Schreibverkehr weiter zu TestTable
Jetzt können Sie Ihre Skalierungsrichtlinie testen, indem Sie Daten in die `TestTable` schreiben. Führen Sie dafür ein Python-Programm aus.
1. Erstellen Sie eine Datei mit dem Namen `bulk-load-test-table.py` und dem folgenden Inhalt.
```
import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table("TestTable")
filler = "x" * 100000
i = 0
while (i < 10):
j = 0
while (j < 10):
print (i, j)
table.put_item(
Item={
'pk':i,
'sk':j,
'filler':{"S":filler}
}
)
j += 1
i += 1
```
1. Geben Sie den folgenden Befehl ein, um das Programm auszuführen.
`python bulk-load-test-table.py`
Die bereitgestellte Schreibkapazität für `TestTable` ist sehr niedrig (5 Schreibkapazitätseinheiten), sodass das Programm aufgrund von Schreibeinschränkungen gelegentlich stockt. Dieses Verhalten wird erwartet.
Lassen Sie das Programm weiter ausführen, während Sie mit dem nächsten Schritt fortfahren.
## Schritt 5: Anzeigen der Application Auto Scaling
In diesem Schritt sehen Sie sich die Application-Auto-Scaling-Aktionen an, die in Ihrem Namen initiiert werden. Sie überprüfen ebenfalls, ob Application Auto Scaling die bereitgestellte Schreibkapazität für `TestTable` aktualisiert hat.
1. Geben Sie den folgenden Befehl ein, um die Application Auto Scaling-Aktionen anzuzeigen.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace dynamodb
```
Führen Sie diesen Befehl gelegentlich erneut aus, während das Python-Programm ausgeführt wird. (Es kann einige Minuten dauern, bevor die Skalierungsrichtlinie aufgerufen wird.) Sie sollten schließlich die folgende Ausgabe sehen.
```
...
{
"ScalableDimension": "dynamodb:table:WriteCapacityUnits",
"Description": "Setting write capacity units to 10.",
"ResourceId": "table/TestTable",
"ActivityId": "0cc6fb03-2a7c-4b51-b67f-217224c6b656",
"StartTime": 1489088210.175,
"ServiceNamespace": "dynamodb",
"EndTime": 1489088246.85,
"Cause": "monitor alarm AutoScaling-table/TestTable-AlarmHigh-1bb3c8db-1b97-4353-baf1-4def76f4e1b9 in state ALARM triggered policy MyScalingPolicy",
"StatusMessage": "Successfully set write capacity units to 10. Change successfully fulfilled by dynamodb.",
"StatusCode": "Successful"
},
...
```
Dies weist darauf hin, dass Application Auto Scaling eine `UpdateTable`Anforderung an DynamoDB ausgegeben hat.
1. Geben Sie den folgenden Befehl ein, um zu überprüfen, ob DynamoDB die Schreibkapazität der Tabelle erhöht hat:
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
Die `WriteCapacityUnits` hätten von `5` auf `10` skaliert werden sollen.
## (Optional) Schritt 6: Bereinigen
In diesem Tutorial haben Sie einige Ressourcen erstellt. Sie können diese Ressourcen löschen, wenn Sie sie nicht mehr benötigen.
1. Löschen Sie die Skalierungsrichtlinie für `TestTable`:
```
aws application-autoscaling delete-scaling-policy \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy"
```
1. Melden Sie das skalierbare Ziel ab.
```
aws application-autoscaling deregister-scalable-target \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits"
```
1. Löschen Sie die `TestTable`-Tabelle.
```
aws dynamodb delete-table --table-name TestTable
```