Avant de commencer Étape 1 : création d'une table DynamoDB Étape 2 : enregistrer une cible évolutive Étape 3 : créer une politique de mise à l'échelle Étape 4 : Dirigez le trafic d'écriture vers TestTable Étape 5 : afficher les actions de scalabilité automatique d'application (Facultatif) Étape 6 : nettoyer

Utilisation de AWS CLI pour gérer la scalabilité automatique de DynamoDB

Au lieu d'utiliser l'AWS Management Console, vous pouvez utiliser l'AWS Command Line Interface (AWS CLI) pour gérer la scalabilité 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 effectuez 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 le dimensionnement de DynamoDB de manière à ce qu'il se produise à certains moments. Découvrez les étapes de base ici.

Rubriques

Avant de commencer
Étape 1 : création d'une table DynamoDB
Étape 2 : enregistrer une cible évolutive
Étape 3 : créer une politique de mise à l'échelle
Étape 4 : Dirigez le trafic d'écriture vers TestTable
Étape 5 : afficher les actions de scalabilité automatique d'application
(Facultatif) Étape 6 : nettoyer

Avant de commencer

Avant de commencer à suivre le didacticiel, accomplissez les tâches suivantes :

Installer 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
Configuration de l'interface AWS CLI (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). Si vous n'avez pas encore installé Python, vous pouvez télécharger Python..

Étape 1 : création d'une table DynamoDB

Au cours de cette étape, vous allez utiliser l'AWS CLI pour créer une 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.

Utilisez la commande AWS CLI 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

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 dans le Guide de l'utilisateur Application Auto Scaling.

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

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) 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.

Créez un fichier nommé scaling-policy.json avec les contenus suivants.


{
    "PredefinedMetricSpecification": {
        "PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
    },
    "ScaleOutCooldown": 60,
    "ScaleInCooldown": 60,
    "TargetValue": 50.0
}

Utilisez la commande AWS CLI 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

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.

Utilisez la commande AWS CLI suivante pour afficher des détails supplémentaires sur la politique de mise à l'échelle.


aws application-autoscaling describe-scaling-policies \
    --service-namespace dynamodb \
    --resource-id "table/TestTable" \
    --policy-name "MyScalingPolicy"

Dans la sortie, vérifiez que les paramètres de politique correspondent à vos spécifications de Étape 2 : enregistrer une cible évolutive et Étape 3 : créer une politique de mise à l'échelle.

É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.

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

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.

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.

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.

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"

Désenregistrez la cible évolutive


aws application-autoscaling deregister-scalable-target \
    --service-namespace dynamodb \
    --resource-id "table/TestTable" \
    --scalable-dimension "dynamodb:table:WriteCapacityUnits"

Supprimez la table TestTable.


aws dynamodb delete-table --table-name TestTable

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation de la AWS Management Console avec la scalabilité automatique de DynamoDB

Utilisation du kit SDK AWS pour configurer la mise à l'échelle automatique