Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation du AWS CLI pour gérer le dimensionnement automatique de DynamoDB
Au lieu d'utiliser le () AWS Management Console, vous pouvez utiliser le AWS Command Line Interface (AWS CLI) pour gérer le dimensionnement automatique d'Amazon DynamoDB. Le didacticiel dans cette section montre comment installer et configurer l’ AWS CLI pour gérer la scalabilité automatique de DynamoDB. Dans ce didacticiel, vous allez effectuer les opérations suivantes :
+ Créez une table DynamoDB nommée `TestTable`. Les paramètres de débit initial sont 5 unités de capacité de lecture et 5 unités de capacité d’écriture.
+ Créez une politique de scalabilité automatique d’application pour `TestTable`. La politique vise à maintenir un ratio cible de 50 pour cent entre la capacité d’écriture consommée et la capacité d’écriture approvisionnée. La plage acceptée pour cette métrique est comprise entre 5 et 10 unités de capacité d’écriture. (La scalabilité automatique d’application n’est pas autorisée à ajuster le débit au-delà de cette plage.)
+ Exécutez un programme Python pour générer du trafic d’écriture vers `TestTable`. Lorsque le ratio cible est supérieur à 50 pour cent pendant une période prolongée, la scalabilité automatique d’application demande à DynamoDB d’augmenter le débit de `TestTable` pour maintenir le taux d’utilisation cible de 50 %.
+ Vérifiez que DynamoDB a correctement ajusté la capacité d’écriture approvisionnée pour `TestTable`.
**Note**
Vous pouvez également planifier la mise à l’échelle de DynamoDB de manière à ce qu’elle se produise à certains moments. Découvrez les étapes de base [ici](https://docs.aws.amazon.com/autoscaling/application/userguide/get-started-exercise.html).
**Topics**
+ [Avant de commencer](#AutoScaling.CLI.BeforeYouBegin)
+ [Étape 1 : création d’une table DynamoDB](#AutoScaling.CLI.CreateTable)
+ [Étape 2 : enregistrer une cible évolutive](#AutoScaling.CLI.RegisterScalableTarget)
+ [Étape 3 : créer une politique de mise à l’échelle](#AutoScaling.CLI.CreateScalingPolicy)
+ [Étape 4 : Dirigez le trafic d'écriture vers TestTable](#AutoScaling.CLI.DriveTraffic)
+ [Étape 5 : afficher les actions de scalabilité automatique d’application](#AutoScaling.CLI.ViewCWAlarms)
+ [(Facultatif) Étape 6 : nettoyer](#AutoScaling.CLI.CleanUp)
## Avant de commencer
Avant de commencer à suivre le didacticiel, accomplissez les tâches suivantes :
### Installez le AWS CLI
Si vous ne l’avez pas déjà fait, vous devez installer et configurer AWS CLI. Pour ce faire, suivez les instructions du *Guide de l’utilisateur AWS Command Line Interface * :
+ [Installation de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
+ [Configuration de l’interface AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) (français non garanti)
### Installation de Python
Une partie de ce didacticiel nécessite que vous exécutiez un programme Python (voir [Étape 4 : Dirigez le trafic d'écriture vers TestTable](#AutoScaling.CLI.DriveTraffic)). Si vous n’avez pas encore installé Python, vous pouvez [télécharger Python](https://www.python.org/downloads)..
## Étape 1 : création d’une table DynamoDB
Au cours de cette étape, vous devez utiliser le AWS CLI pour créer`TestTable`. La clé primaire est composée de `pk` (clé de partition) et de `sk` (clé de tri). Ces deux attributs sont de type `Number`. Les paramètres de débit initial sont 5 unités de capacité de lecture et 5 unités de capacité d’écriture.
1. Utilisez la AWS CLI commande suivante pour créer la table.
```
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. Pour vérifier l’état de la table, utilisez la commande suivante.
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
La table est prête pour utilisation quand son état est `ACTIVE`.
## Étape 2 : enregistrer une cible évolutive
Ensuite, vous enregistrez la capacité d’écriture de la table en tant que cible évolutive pour la scalabilité automatique d’application. Cela permet à Application Auto Scaling d'ajuster la capacité d'écriture allouée pour *TestTable*, mais uniquement dans la plage de 5 à 10 unités de capacité.
**Note**
La scalabilité automatique de DynamoDB nécessite la présence d’un rôle lié à un service (`AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`) qui effectue pour vous les actions de scalabilité automatique. Ce rôle est créé automatiquement pour vous. Pour plus d’informations, consultez [Rôles liés aux services pour Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
1. Entrez la commande suivante pour enregistrer la cible évolutive.
```
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. Pour vérifier l’enregistrement, utilisez la commande suivante.
```
aws application-autoscaling describe-scalable-targets \
--service-namespace dynamodb \
--resource-id "table/TestTable"
```
**Note**
Vous pouvez également enregistrer une cible évolutive par rapport à un index secondaire global. Par exemple, pour un index secondaire global (« test-index »), l’ID de ressource et les arguments de dimension évolutive sont mis à jour de manière appropriée.
```
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
```
## Étape 3 : créer une politique de mise à l’échelle
Dans cette étape, vous allez créer une politique de mise à l’échelle pour `TestTable`. La politique définit les détails des conditions dans lesquelles la scalabilité automatique d’application peut ajuster le débit approvisionné de votre table, et les actions à entreprendre à cet égard. Vous associez cette politique avec la cible évolutive que vous avez définie à l’étape précédente (unités de capacité d’écriture pour la table `TestTable`).
Cette politique contient les éléments suivants :
+ `PredefinedMetricSpecification` – Métrique que la scalabilité automatique d’application est autorisée à ajuster. Pour DynamoDB, les valeurs suivantes sont valides pour `PredefinedMetricType` :
+ `DynamoDBReadCapacityUtilization`
+ `DynamoDBWriteCapacityUtilization`
+ `ScaleOutCooldown` – Durée minimum (en secondes) entre chaque événement de scalabilité automatique d’application qui augmente le débit approvisionné. Ce paramètre permet à la scalabilité automatique d’application d’augmenter de façon continue, mais pas agressive, le débit en réponse aux charges de travail réelles. Le paramètre par défaut pour `ScaleOutCooldown` est 0.
+ `ScaleInCooldown` – Durée minimum (en secondes) entre chaque événement de scalabilité automatique d’application qui réduit le débit approvisionné. Ce paramètre permet à la scalabilité automatique d’application de réduire le débit progressivement et de façon prévisible. Le paramètre par défaut pour `ScaleInCooldown` est 0.
+ `TargetValue` – La scalabilité automatique d’application garantit que le ratio de capacité consommée par rapport à la capacité approvisionnée reste égal ou proche de cette valeur. Vous définissez `TargetValue` en tant que pourcentage.
**Note**
Pour mieux comprendre le fonctionnement de `TargetValue`, supposons que vous ayez une table avec un paramètre de débit approvisionné de 200 unités de capacité d’écriture. Vous décidez de créer une politique de mise à l’échelle pour cette table, avec une `TargetValue` de 70 pour cent.
Supposons maintenant que vous commencez à générer du trafic d’écriture vers la table de telle sorte que le débit d’écriture réel est de 150 unités de capacité. Le consumed-to-provisioned ratio est maintenant de (150/200), soit 75 %. Ce ratio dépassant votre cible, la scalabilité automatique d’application augmente la capacité d’écriture approvisionnée à 215, de façon que le ratio (150 / 215) soit de 69,77 %, aussi proche que possible de votre `TargetValue`, dans le dépasser.
Pour `TestTable`, vous définissez `TargetValue` sur 50 pour cent. Application Auto Scaling ajuste le débit provisionné de la table dans une fourchette de 5 à 10 unités de capacité (voir[Étape 2 : enregistrer une cible évolutive](#AutoScaling.CLI.RegisterScalableTarget)) afin que le consumed-to-provisioned ratio reste égal ou proche de 50 %. Vous définissez les valeurs pour `ScaleOutCooldown` et `ScaleInCooldown` sur 60 secondes.
1. Créez un fichier nommé `scaling-policy.json` avec les contenus suivants.
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
},
"ScaleOutCooldown": 60,
"ScaleInCooldown": 60,
"TargetValue": 50.0
}
```
1. Utilisez la AWS CLI commande suivante pour créer la politique.
```
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. Dans le résultat, notez qu'Application Auto Scaling a créé deux CloudWatch alarmes Amazon, une pour chacune des limites supérieure et inférieure de la plage cible de dimensionnement.
1. Utilisez la AWS CLI commande suivante pour afficher plus de détails sur la politique de dimensionnement.
```
aws application-autoscaling describe-scaling-policies \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--policy-name "MyScalingPolicy"
```
1. Dans la sortie, vérifiez que les paramètres de politique correspondent à vos spécifications de [Étape 2 : enregistrer une cible évolutive](#AutoScaling.CLI.RegisterScalableTarget) et [Étape 3 : créer une politique de mise à l’échelle](#AutoScaling.CLI.CreateScalingPolicy).
## Étape 4 : Dirigez le trafic d'écriture vers TestTable
Vous pouvez maintenant tester votre politique de mise à l’échelle en écrivant des données dans `TestTable`. Pour ce faire, vous exécutez un programme Python.
1. Créez un fichier nommé `bulk-load-test-table.py` avec les contenus suivants.
```
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. Pour exécuter le programme, entrez la commande suivante.
`python bulk-load-test-table.py`
La capacité d’écriture approvisionnée pour `TestTable` étant très faible (5 unités de capacité d’écriture), le programme se bloque occasionnellement en raison de la limitation d’écriture. Ce comportement est normal.
Laissez le programme poursuivre son exécution pendant que vous passez à l’étape suivante.
## Étape 5 : afficher les actions de scalabilité automatique d’application
Dans cette étape, vous allez afficher les actions de scalabilité automatique d’application qui ont été entreprises pour vous. Vous allez également vérifier que la scalabilité automatique d’application a mis à jour la capacité d’écriture approvisionnée pour `TestTable`.
1. Entrez la commande suivante pour afficher les actions de scalabilité automatique d’application.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace dynamodb
```
Réexécutez cette commande de temps en temps pendant l’exécution du programme Python (l’appel de votre politique de mise à l’échelle prend plusieurs minutes). Vous devriez voir la sortie suivante.
```
...
{
"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"
},
...
```
Cela indique que scalabilité automatique d’application a adressé une demande `UpdateTable` à DynamoDB.
1. Entrez la commande suivante pour vérifier que DynamoDB a augmenté la capacité d’écriture de la table.
```
aws dynamodb describe-table \
--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
```
La `WriteCapacityUnits` aurait dû être augmentée de `5` à `10`.
## (Facultatif) Étape 6 : nettoyer
Dans ce didacticiel, vous avez créé plusieurs ressources. Vous pouvez les supprimer si vous n’en avez plus besoin.
1. Supprimez la politique de mise à l’échelle pour `TestTable`.
```
aws application-autoscaling delete-scaling-policy \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy"
```
1. Désenregistrez la cible évolutive
```
aws application-autoscaling deregister-scalable-target \
--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits"
```
1. Supprimez la table `TestTable`.
```
aws dynamodb delete-table --table-name TestTable
```