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. # Gestion automatique de la capacité de débit avec la scalabilité automatique de DynamoDB De nombreuses charges de travail de base de données sont cycliques par nature, tandis que d’autres sont difficiles à prévoir. Prenons l’exemple d’une application de réseau social où la plupart des utilisateurs sont actifs pendant la journée. La base de données doit être capable de gérer l’activité durant cette période, mais elle n’a pas besoin des mêmes niveaux de débit pendant la nuit. Prenons également l’exemple d’une nouvelle application de jeux pour appareils mobiles qui, contre toute attente, est rapidement adoptée par les utilisateurs. Si le jeu devient trop populaire, les ressources de base de données disponibles risquent d’être dépassées, entraînant un ralentissement des performances et le mécontentement des clients. Ce type de charges de travail nécessite souvent une intervention manuelle pour augmenter ou diminuer les ressources de base de données en fonction de la variation des niveaux d’utilisation. Amazon DynamoDB Auto Scaling AWS utilise le service Application Auto Scaling pour ajuster dynamiquement la capacité de débit allouée en votre nom, en réponse aux modèles de trafic réels. Cela permet à une table ou à un index secondaire global (GSI) d’augmenter sa capacité de lecture et d’écriture approvisionnée afin de gérer les hausses soudaines de trafic sans limitation. Lorsque la charge de travail diminue, la scalabilité automatique d’application réduit le débit de sorte que vous ne payez pas pour une capacité approvisionnée non utilisée. **Note** Si vous utilisez le AWS Management Console pour créer une table ou un index secondaire global, le dimensionnement automatique de DynamoDB est activé par défaut. Vous pouvez modifier vos paramètres de scalabilité automatique à tout moment. Pour de plus amples informations, veuillez consulter [Utilisation de la mise AWS Management Console à l'échelle automatique avec DynamoDB](AutoScaling.Console.md). Lorsque vous supprimez une table ou une réplique de table globale, les cibles évolutives, les politiques de dimensionnement ou les CloudWatch alarmes associées ne sont pas automatiquement supprimées avec elle. Avec la scalabilité automatique d’application, vous créez une *politique de mise à l’échelle* pour une table ou un index secondaire global. La politique de mise à l’échelle spécifie si vous souhaitez mettre à l’échelle la capacité de lecture ou d’écriture (ou les deux), ainsi que les paramètres d’unité de capacité approvisionnée minimum et maximum pour la table ou l’index. La politique de mise à l’échelle contient également une *utilisation cible*, c’est-à-dire le pourcentage du débit approvisionné consommé à un moment donné. La scalabilité automatique d’application utilise un algorithme de *suivi de cible* pour ajuster le débit approvisionné de la table (ou de l’index) en réponse aux charges de travail réelles, de façon que l’utilisation de capacité réelle reste au niveau ou à un niveau proche de votre utilisation cible. DynamoDB produit le débit provisionné consommé pendant des périodes d’une minute. La mise à l'échelle automatique se déclenche lorsque la capacité consommée dépasse l'utilisation cible configurée pendant deux minutes consécutives. CloudWatch les alarmes peuvent avoir un court délai de quelques minutes avant de déclencher le redimensionnement automatique. Ce délai garantit une évaluation CloudWatch précise des mesures. Si les pics de débit consommés sont espacés de plus d’une minute, l’autoscaling risque de ne pas se déclencher. De même, un événement de réduction verticale peut être déclenché lorsque 15 points de données consécutifs sont en dessous de l’utilisation cible. Dans les deux cas, après le déclenchement de l'autoscaling, l'[UpdateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API est invoquée. Plusieurs minutes sont ensuite nécessaires pour mettre à jour la capacité provisionnée pour la table ou l’index. Pendant cette période, toutes les demandes dépassant la capacité provisionnée précédente pour les tables seront limitées. **Important** Vous ne pouvez pas ajuster le nombre de points de données à dépasser pour déclencher l’alarme sous-jacente (bien que le nombre actuel puisse changer à l’avenir). Vous pouvez également définir les valeurs d’utilisation cibles de la scalabilité automatique entre 20 % et 90 % pour votre capacité de lecture et d’écriture. **Note** Outre les tables, la scalabilité automatique de DynamoDB prend également en charge les index secondaires globaux. Chaque index secondaire global a sa propre capacité de débit approvisionné, distincte de celle de sa table de base. Lorsque vous créez une politique de mise à l’échelle pour un index secondaire global, la scalabilité automatique d’application ajuste les paramètres de débit approvisionné pour l’index afin de s’assurer que l’utilisation réelle reste au niveau ou à une niveau proche du ratio d’utilisation souhaité. ## Comment fonctionne la scalabilité automatique de DynamoDB **Note** Pour commencer rapidement à utiliser la scalabilité automatique de DynamoDB, consultez [Utilisation de la mise AWS Management Console à l'échelle automatique avec DynamoDB](AutoScaling.Console.md). Le diagramme suivant fournit une présentation de haut niveau de la manière dont la scalabilité automatique de DynamoDB gère la capacité de débit pour une table. ![\[L’autoscaling DynamoDB ajuste la capacité de débit d’une table pour répondre à la demande.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/auto-scaling.png) Les étapes suivantes résument le processus de scalabilité automatique illustré dans le diagramme précédent : 1. Vous créez une politique de scalabilité automatique d’application pour votre table DynamoDB. 1. DynamoDB publie des statistiques de capacité consommée sur Amazon. CloudWatch 1. Si la capacité consommée de la table dépasse votre objectif d'utilisation (ou tombe en dessous de l'objectif) pendant un certain temps, Amazon CloudWatch déclenche une alarme. Vous pouvez voir l’alarme sur la console et recevoir des notifications via Amazon Simple Notification Service (Amazon SNS). 1. L' CloudWatch alarme appelle Application Auto Scaling pour évaluer votre politique de dimensionnement. 1. La scalabilité automatique d’application émet une demande `UpdateTable` pour ajuster le débit approvisionné de votre table. 1. DynamoDB traite la demande `UpdateTable` en augmentant (ou réduisant) de manière dynamique la capacité de débit approvisionné de la table de façon que celle-ci se rapproche de votre utilisation cible. Pour comprendre la manière dont fonctionne la scalabilité automatique de DynamoDB, supposons que vous ayez une table nommée `ProductCatalog`. Cette table est chargée en masse de manière occasionnelle, elle n’entraîne donc pas une importante activité en écriture. Toutefois, elle ne connaît pas une activité en lecture très élevée, qui varie avec le temps. En surveillant les CloudWatch métriques Amazon pour`ProductCatalog`, vous déterminez que la table nécessite 1 200 unités de capacité de lecture (pour éviter que DynamoDB ne limite les demandes de lecture lorsque l'activité est maximale). Vous déterminez également que `ProductCatalog` requiert au minimum 150 unités de capacité de lecture lorsque le trafic de lecture est à son point le plus bas. Pour plus d’informations sur la prévention de la limitation, consultez [Résolution des problèmes de limitation dans Amazon DynamoDB](TroubleshootingThrottling.md). Dans la plage de 150 à 1 200 unités de capacité de lecture, vous décidez qu’une utilisation cible de 70 % conviendrait pour la table `ProductCatalog`. L’*utilisation cible* correspond au ratio des unités de capacité consommées par rapport aux unités de capacité approvisionnées, exprimé sous forme de pourcentage. La scalabilité automatique d’application utilise son algorithme de suivi de cible pour s’assurer que la capacité de lecture approvisionnée de `ProductCatalog` est correctement ajustée, de sorte que l’utilisation demeure proche de 70 %. **Note** La scalabilité automatique de DynamoDB modifie les paramètres de débit approvisionné uniquement lorsque la charge de travail réelle reste élevée ou basse pendant une période continue de plusieurs minutes. L’algorithme de suivi de cible de la scalabilité automatique d’application cherche à maintenir l’utilisation cible au niveau ou à un niveau proche de la valeur choisie sur le long terme. Les pics soudains de l’activité de lecture sont gérés par la capacité de transmission en mode rafale intégrée de la table. Pour de plus amples informations, veuillez consulter [Capacité de débordement](burst-adaptive-capacity.md#burst-capacity). Pour activer la scalabilité automatique de DynamoDB pour la table `ProductCatalog`, vous devez créer une politique de mise à l’échelle. La politique spécifie les éléments suivants : + Table ou index secondaire global que vous voulez gérer + Le type de capacité à gérer (lecture ou écriture) + Les limites supérieure et inférieure pour les paramètres du débit provisionné. + Votre utilisation cible Lorsque vous créez une politique de dimensionnement, Application Auto Scaling crée une paire d' CloudWatch alarmes Amazon en votre nom. Chaque paire représente les limites supérieure et inférieure pour vos paramètres de débit provisionné. Ces CloudWatch alarmes sont déclenchées lorsque l'utilisation réelle de la table s'écarte de votre utilisation cible pendant une période prolongée. Lorsque l'une des CloudWatch alarmes est déclenchée, Amazon SNS vous envoie une notification (si vous l'avez activée). L' CloudWatch alarme appelle ensuite Application Auto Scaling, qui à son tour indique à DynamoDB d'ajuster la capacité allouée à la `ProductCatalog` table à la hausse ou à la baisse, selon le cas. Lors d'un événement de dimensionnement, AWS Config est facturé par élément de configuration enregistré. Lorsqu'un événement de dimensionnement se produit, quatre CloudWatch alarmes sont créées pour chaque événement d'auto-scaling en lecture et en écriture : ProvisionedCapacity alarmes : ProvisionedCapacityLow, ProvisionedCapacityHigh et ConsumedCapacity alarmes : AlarmHigh,. AlarmLow Cela se traduit par un total de huit alarmes. Par conséquent, AWS Config enregistre huit éléments de configuration pour chaque événement de dimensionnement. **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). ## Notes d’utilisation Avant de commencer à utiliser la scalabilité automatique de DynamoDB, vous devez être conscient de ce qui suit : + La scalabilité automatique de DynamoDB peut augmenter la capacité de lecture ou d’écriture aussi souvent que nécessaire, selon votre politique de scalabilité automatique. Tous les quotas DynamoDB restent en vigueur, comme décrit dans [Quotas dans Amazon DynamoDB](ServiceQuotas.md). + La scalabilité automatique de DynamoDB ne vous empêche pas de modifier manuellement les paramètres de débit approvisionné. Ces réglages manuels n'ont aucune incidence sur les CloudWatch alarmes existantes liées au dimensionnement automatique de DynamoDB. + Si vous activez la scalabilité automatique de DynamoDB pour une table contenant un ou plusieurs index secondaires globaux, nous vous recommandons vivement d’appliquer également la scalabilité automatique de manière uniforme à ces index. Cela permettra de garantir de meilleures performances pour les écritures et les lectures de table et d’éviter les limitations. Vous pouvez activer la mise à l’échelle automatique en sélectionnant **Apply same settings to global secondary indexes (Appliquer les mêmes paramètres aux index secondaires globaux)** dans la AWS Management Console. Pour de plus amples informations, veuillez consulter [Activation de la scalabilité automatique de DynamoDB sur des tables existantes](AutoScaling.Console.md#AutoScaling.Console.ExistingTable). + Lorsque vous supprimez une table ou une réplique de table globale, les cibles évolutives, les politiques de dimensionnement ou les CloudWatch alarmes associées ne sont pas automatiquement supprimées. + Lors de la création d’un index secondaire global pour une table existante, la scalabilité automatique n’est pas activée pour l’index secondaire global. Vous devrez gérer manuellement la capacité pendant la construction de l’index secondaire global. Une fois que le remplissage de l’index secondaire global est terminé et qu’il a atteint le statut actif, la mise à l’échelle automatique fonctionne normalement. # Utilisation de la mise AWS Management Console à l'échelle automatique avec DynamoDB Lorsque vous utilisez le AWS Management Console pour créer une nouvelle table, le dimensionnement auto d'Amazon DynamoDB est activé par défaut pour cette table. Vous pouvez également utiliser la console pour activer la scalabilité automatique pour des tables existantes, modifier les paramètres de scalabilité automatique ou désactiver la scalabilité automatique. **Note** Pour des fonctionnalités plus avancées, telles que la définition des temps de recharge de mise à l'échelle initiale et inférieure, utilisez le AWS Command Line Interface () pour AWS CLI gérer le dimensionnement automatique de DynamoDB. Pour de plus amples informations, veuillez consulter [Utilisation du AWS CLI pour gérer le dimensionnement automatique de DynamoDB](AutoScaling.CLI.md). **Topics** + [Avant de commencer : octroi d’autorisations utilisateur pour la scalabilité automatique de DynamoDB](#AutoScaling.Permissions) + [Création d’une table avec la scalabilité automatique activée](#AutoScaling.Console.NewTable) + [Activation de la scalabilité automatique de DynamoDB sur des tables existantes](#AutoScaling.Console.ExistingTable) + [Affichage des activités de scalabilité automatique sur la console](#AutoScaling.Console.ViewingActivities) + [Modification ou désactivation des paramètres de scalabilité automatique de DynamoDB](#AutoScaling.Console.Modifying) ## Avant de commencer : octroi d’autorisations utilisateur pour la scalabilité automatique de DynamoDB Dans Gestion des identités et des accès AWS (IAM), la politique AWS gérée `DynamoDBFullAccess` fournit les autorisations requises pour utiliser la console DynamoDB. Toutefois, pour la scalabilité automatique de DynamoDB, les utilisateurs doivent disposer d’autorisations supplémentaires. **Important** Pour supprimer une table pour laquelle l’autoscaling est activé, des autorisations `application-autoscaling:*` sont nécessaires. La politique AWS gérée `DynamoDBFullAccess` inclut de telles autorisations. **Pour configurer un utilisateur pour l'accès à la console DynamoDB et le dimensionnement automatique de DynamoDB, créez un rôle et ajoutez la politique d'accès à ce rôle. AmazonDynamo DBFull** Attribuez ensuite le rôle à un utilisateur. ## Création d’une table avec la scalabilité automatique activée **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 à un service 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*. **Pour créer une table avec la scalabilité automatique activée** 1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Choisissez **Créer un tableau**. 1. Sur la page **Créer une table**, saisissez le **Nom de la table** et les détails de la clé primaire. 1. Si vous choisissez **Paramètres par défaut**, l’autoscaling est activé dans la nouvelle table. Sinon, choisissez **Personnaliser les paramètres** et procédez comme suit pour définir les paramètres personnalisés de la table : 1. Pour la **Classe Table**, conservez la sélection par défaut de **DynamoDB Standard**. 1. Pour les **Paramètres de capacité de lecture/écriture**, conservez la sélection par défaut **Provisionné**, puis procédez comme suit : 1. Pour la **Capacité de lecture**, assurez-vous que l’**Autoscaling** est défini sur **Activé**. 1. Pour la **Capacité d’écriture**, assurez-vous que l’**Autoscaling** est défini sur **Activé**. 1. Pour la **Capacité de lecture** et la **Capacité d’écriture**, définissez votre politique de mise à l’échelle souhaitée pour la table et, éventuellement, tous les index secondaires globaux de la table. + **Unités de capacité minimum**- Saisissez votre limite inférieure pour la plage de scalabilité automatique. + **Unités de capacité maximum** - Saisissez votre limite supérieure pour la plage de scalabilité automatique. + **Utilisation cible** - Saisissez votre pourcentage d’utilisation cible pour la table. **Note** Si vous créez un index secondaire global pour la nouvelle table, la capacité de l’index au moment de la création sera la même que celle de votre table de base. Vous pouvez modifier la capacité de l’index dans les paramètres de la table après avoir créé la table. 1. Choisissez **Créer un tableau**. Cela crée votre table avec les paramètres d’autoscaling que vous avez spécifiés. ## Activation de la scalabilité automatique de DynamoDB sur des tables existantes **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, veuillez consulter [Rôles liés à un service pour scalabilité automatique d’application](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). **Pour activer la scalabilité automatique de DynamoDB pour une table existante** 1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Tables**. 1. Choisissez la table sur laquelle vous souhaitez activer l’autoscaling, puis procédez comme suit : 1. Choisissez l’onglet **Paramètres supplémentaires**. 1. Dans la section **Capacité de lecture/écriture**, sélectionnez **Modifier**. 1. Dans la section **Mode de capacité**, sélectionnez **Alloué**. 1. Dans la section **Table capacity** (Capacité de la table), définissez **Auto scaling** (Scalabilité automatique) sur **On** (Activé) pour **Read capacity** (Capacité de lecture), **Write capacity** (Capacité d’écriture), ou les deux. Pour chacun de ces éléments, définissez votre politique de mise à l’échelle souhaitée pour la table et, éventuellement, tous les index secondaires globaux de la table. + **Unités de capacité minimum**- Saisissez votre limite inférieure pour la plage de scalabilité automatique. + **Unités de capacité maximum** - Saisissez votre limite supérieure pour la plage de scalabilité automatique. + **Utilisation cible** - Saisissez votre pourcentage d’utilisation cible pour la table. + **Utilisez les mêmes paramètres de read/write capacité pour tous les index secondaires globaux** : choisissez si les index secondaires globaux doivent utiliser la même politique de dimensionnement automatique que la table de base. **Note** Pour de meilleures performances, nous vous recommandons d'activer **Utiliser les mêmes paramètres read/write de capacité pour tous les index secondaires globaux**. Cette option permet à la scalabilité automatique de DynamoDB de mettre à l’échelle de manière uniforme tous les index secondaires globaux sur la table de base. Cela inclut les index secondaires globaux existants et tous les index que vous créerez ultérieurement pour cette table. Lorsque cette option est activée, vous ne pouvez pas définir de politique de mise à l’échelle sur un index secondaire global individuel. 1. Lorsque les paramètres vous conviennent, choisissez **Enregistrer**. ## Affichage des activités de scalabilité automatique sur la console A mesure que votre application génère du trafic de lecture et d’écriture vers votre table, la scalabilité automatique de DynamoDB modifie de manière dynamique les paramètres de débit de la table. Amazon CloudWatch assure le suivi de la capacité allouée et consommée, des événements limités, de la latence et d'autres indicateurs pour toutes vos tables DynamoDB et vos index secondaires. Pour afficher ces métriques dans la console DynamoDB, choisissez la table avec laquelle vous souhaitez travailler et sélectionnez l’onglet **Contrôler**. Pour créer une vue personnalisable des statistiques du tableau, sélectionnez **Afficher tout dans CloudWatch**. ## Modification ou désactivation des paramètres de scalabilité automatique de DynamoDB Vous pouvez utiliser le AWS Management Console pour modifier les paramètres de dimensionnement automatique de DynamoDB. Pour ce faire, accédez à l’onglet **Paramètres supplémentaires** pour votre table et sélectionnez **Modifier** dans la section **Capacité de lecture/écriture**. Pour plus d’informations sur ces paramètres, consultez la page [Activation de la scalabilité automatique de DynamoDB sur des tables existantes](#AutoScaling.Console.ExistingTable). # 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 ``` # Utilisation du AWS SDK pour configurer le dimensionnement automatique sur les tables Amazon DynamoDB En plus d'utiliser le AWS Management Console et le AWS Command Line Interface (AWS CLI), vous pouvez écrire des applications qui interagissent avec le dimensionnement automatique d'Amazon DynamoDB. Cette section deux programmes Java que vous pouvez utiliser pour tester cette fonctionnalité : + `EnableDynamoDBAutoscaling.java` + `DisableDynamoDBAutoscaling.java` ## Activation de la scalabilité automatique d’application pour une table Le programme suivant présente un exemple de configuration d’une politique de scalabilité automatique pour une table DynamoDB (`TestTable`). Voici son mode d’action : + Le programme enregistre les unités de capacité d’écriture en tant que cible évolutive pour `TestTable`. La plage acceptée pour cette métrique est comprise entre 5 et 10 unités de capacité d’écriture. + Une fois la cible évolutive créée, le programme construit une configuration de suivi cible. 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. + Le programme crée ensuite la politique de dimensionnement en fonction de la configuration de suivi cible. **Note** Lorsque vous supprimez manuellement une table ou une réplique de table globale, vous ne supprimez pas automatiquement les cibles évolutives, les politiques de dimensionnement ou les CloudWatch alarmes associées. ------ #### [ Java v2 ] ``` import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.applicationautoscaling.ApplicationAutoScalingClient; import software.amazon.awssdk.services.applicationautoscaling.model.ApplicationAutoScalingException; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsResponse; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesResponse; import software.amazon.awssdk.services.applicationautoscaling.model.PolicyType; import software.amazon.awssdk.services.applicationautoscaling.model.PredefinedMetricSpecification; import software.amazon.awssdk.services.applicationautoscaling.model.PutScalingPolicyRequest; import software.amazon.awssdk.services.applicationautoscaling.model.RegisterScalableTargetRequest; import software.amazon.awssdk.services.applicationautoscaling.model.ScalingPolicy; import software.amazon.awssdk.services.applicationautoscaling.model.ServiceNamespace; import software.amazon.awssdk.services.applicationautoscaling.model.ScalableDimension; import software.amazon.awssdk.services.applicationautoscaling.model.MetricType; import software.amazon.awssdk.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration; import java.util.List; /** * Before running this Java V2 code example, set up your development environment, including your credentials. * * For more information, see the following documentation topic: * * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html */ public class EnableDynamoDBAutoscaling { public static void main(String[] args) { final String usage = """ Usage: \s Where: tableId - The table Id value (for example, table/Music). roleARN - The ARN of the role that has ApplicationAutoScaling permissions. policyName - The name of the policy to create. """; if (args.length != 3) { System.out.println(usage); System.exit(1); } System.out.println("This example registers an Amazon DynamoDB table, which is the resource to scale."); String tableId = args[0]; String roleARN = args[1]; String policyName = args[2]; ServiceNamespace ns = ServiceNamespace.DYNAMODB; ScalableDimension tableWCUs = ScalableDimension.DYNAMODB_TABLE_WRITE_CAPACITY_UNITS; ApplicationAutoScalingClient appAutoScalingClient = ApplicationAutoScalingClient.builder() .region(Region.US_EAST_1) .build(); registerScalableTarget(appAutoScalingClient, tableId, roleARN, ns, tableWCUs); verifyTarget(appAutoScalingClient, tableId, ns, tableWCUs); configureScalingPolicy(appAutoScalingClient, tableId, ns, tableWCUs, policyName); } public static void registerScalableTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, String roleARN, ServiceNamespace ns, ScalableDimension tableWCUs) { try { RegisterScalableTargetRequest targetRequest = RegisterScalableTargetRequest.builder() .serviceNamespace(ns) .scalableDimension(tableWCUs) .resourceId(tableId) .roleARN(roleARN) .minCapacity(5) .maxCapacity(10) .build(); appAutoScalingClient.registerScalableTarget(targetRequest); System.out.println("You have registered " + tableId); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } // Verify that the target was created. public static void verifyTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalableTargetsRequest dscRequest = DescribeScalableTargetsRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceIds(tableId) .build(); DescribeScalableTargetsResponse response = appAutoScalingClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } // Configure a scaling policy. public static void configureScalingPolicy(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs, String policyName) { // Check if the policy exists before creating a new one. DescribeScalingPoliciesResponse describeScalingPoliciesResponse = appAutoScalingClient.describeScalingPolicies(DescribeScalingPoliciesRequest.builder() .serviceNamespace(ns) .resourceId(tableId) .scalableDimension(tableWCUs) .build()); if (!describeScalingPoliciesResponse.scalingPolicies().isEmpty()) { // If policies exist, consider updating an existing policy instead of creating a new one. System.out.println("Policy already exists. Consider updating it instead."); List polList = describeScalingPoliciesResponse.scalingPolicies(); for (ScalingPolicy pol : polList) { System.out.println("Policy name:" +pol.policyName()); } } else { // If no policies exist, proceed with creating a new policy. PredefinedMetricSpecification specification = PredefinedMetricSpecification.builder() .predefinedMetricType(MetricType.DYNAMO_DB_WRITE_CAPACITY_UTILIZATION) .build(); TargetTrackingScalingPolicyConfiguration policyConfiguration = TargetTrackingScalingPolicyConfiguration.builder() .predefinedMetricSpecification(specification) .targetValue(50.0) .scaleInCooldown(60) .scaleOutCooldown(60) .build(); PutScalingPolicyRequest putScalingPolicyRequest = PutScalingPolicyRequest.builder() .targetTrackingScalingPolicyConfiguration(policyConfiguration) .serviceNamespace(ns) .scalableDimension(tableWCUs) .resourceId(tableId) .policyName(policyName) .policyType(PolicyType.TARGET_TRACKING_SCALING) .build(); try { appAutoScalingClient.putScalingPolicy(putScalingPolicyRequest); System.out.println("You have successfully created a scaling policy for an Application Auto Scaling scalable target"); } catch (ApplicationAutoScalingException e) { System.err.println("Error: " + e.awsErrorDetails().errorMessage()); } } } } ``` ------ #### [ Java v1 ] Le programme requiert que vous fournissiez un Amazon Resource Name (ARN) pour un rôle lié à un service de scalabilité automatique d’application valide. (Par exemple : `arn:aws:iam::122517410325:role/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable`.) Dans le programme suivant, remplacez `SERVICE_ROLE_ARN_GOES_HERE` par l’ARN réel. ``` package com.amazonaws.codesamples.autoscaling; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClientBuilder; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult; import com.amazonaws.services.applicationautoscaling.model.MetricType; import com.amazonaws.services.applicationautoscaling.model.PolicyType; import com.amazonaws.services.applicationautoscaling.model.PredefinedMetricSpecification; import com.amazonaws.services.applicationautoscaling.model.PutScalingPolicyRequest; import com.amazonaws.services.applicationautoscaling.model.RegisterScalableTargetRequest; import com.amazonaws.services.applicationautoscaling.model.ScalableDimension; import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace; import com.amazonaws.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration; public class EnableDynamoDBAutoscaling { static AWSApplicationAutoScalingClient aaClient = (AWSApplicationAutoScalingClient) AWSApplicationAutoScalingClientBuilder .standard().build(); public static void main(String args[]) { ServiceNamespace ns = ServiceNamespace.Dynamodb; ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits; String resourceID = "table/TestTable"; // Define the scalable target RegisterScalableTargetRequest rstRequest = new RegisterScalableTargetRequest() .withServiceNamespace(ns) .withResourceId(resourceID) .withScalableDimension(tableWCUs) .withMinCapacity(5) .withMaxCapacity(10) .withRoleARN("SERVICE_ROLE_ARN_GOES_HERE"); try { aaClient.registerScalableTarget(rstRequest); } catch (Exception e) { System.err.println("Unable to register scalable target: "); System.err.println(e.getMessage()); } // Verify that the target was created DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceIds(resourceID); try { DescribeScalableTargetsResult dsaResult = aaClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(dsaResult); System.out.println(); } catch (Exception e) { System.err.println("Unable to describe scalable target: "); System.err.println(e.getMessage()); } System.out.println(); // Configure a scaling policy TargetTrackingScalingPolicyConfiguration targetTrackingScalingPolicyConfiguration = new TargetTrackingScalingPolicyConfiguration() .withPredefinedMetricSpecification( new PredefinedMetricSpecification() .withPredefinedMetricType(MetricType.DynamoDBWriteCapacityUtilization)) .withTargetValue(50.0) .withScaleInCooldown(60) .withScaleOutCooldown(60); // Create the scaling policy, based on your configuration PutScalingPolicyRequest pspRequest = new PutScalingPolicyRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID) .withPolicyName("MyScalingPolicy") .withPolicyType(PolicyType.TargetTrackingScaling) .withTargetTrackingScalingPolicyConfiguration(targetTrackingScalingPolicyConfiguration); try { aaClient.putScalingPolicy(pspRequest); } catch (Exception e) { System.err.println("Unable to put scaling policy: "); System.err.println(e.getMessage()); } // Verify that the scaling policy was created DescribeScalingPoliciesRequest dspRequest = new DescribeScalingPoliciesRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { DescribeScalingPoliciesResult dspResult = aaClient.describeScalingPolicies(dspRequest); System.out.println("DescribeScalingPolicies result: "); System.out.println(dspResult); } catch (Exception e) { e.printStackTrace(); System.err.println("Unable to describe scaling policy: "); System.err.println(e.getMessage()); } } } ``` ------ ## Désactivation de la scalabilité automatique d’application pour une table Le programme suivant inverse le processus précédent. Il supprime la politique Auto Scaling, puis désinscrit la cible évolutive. ------ #### [ Java v2 ] ``` import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.applicationautoscaling.ApplicationAutoScalingClient; import software.amazon.awssdk.services.applicationautoscaling.model.ApplicationAutoScalingException; import software.amazon.awssdk.services.applicationautoscaling.model.DeleteScalingPolicyRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DeregisterScalableTargetRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalableTargetsResponse; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import software.amazon.awssdk.services.applicationautoscaling.model.DescribeScalingPoliciesResponse; import software.amazon.awssdk.services.applicationautoscaling.model.ScalableDimension; import software.amazon.awssdk.services.applicationautoscaling.model.ServiceNamespace; /** * Before running this Java V2 code example, set up your development environment, including your credentials. * * For more information, see the following documentation topic: * * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html */ public class DisableDynamoDBAutoscaling { public static void main(String[] args) { final String usage = """ Usage: \s Where: tableId - The table Id value (for example, table/Music).\s policyName - The name of the policy (for example, $Music5-scaling-policy). """; if (args.length != 2) { System.out.println(usage); System.exit(1); } ApplicationAutoScalingClient appAutoScalingClient = ApplicationAutoScalingClient.builder() .region(Region.US_EAST_1) .build(); ServiceNamespace ns = ServiceNamespace.DYNAMODB; ScalableDimension tableWCUs = ScalableDimension.DYNAMODB_TABLE_WRITE_CAPACITY_UNITS; String tableId = args[0]; String policyName = args[1]; deletePolicy(appAutoScalingClient, policyName, tableWCUs, ns, tableId); verifyScalingPolicies(appAutoScalingClient, tableId, ns, tableWCUs); deregisterScalableTarget(appAutoScalingClient, tableId, ns, tableWCUs); verifyTarget(appAutoScalingClient, tableId, ns, tableWCUs); } public static void deletePolicy(ApplicationAutoScalingClient appAutoScalingClient, String policyName, ScalableDimension tableWCUs, ServiceNamespace ns, String tableId) { try { DeleteScalingPolicyRequest delSPRequest = DeleteScalingPolicyRequest.builder() .policyName(policyName) .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); appAutoScalingClient.deleteScalingPolicy(delSPRequest); System.out.println(policyName +" was deleted successfully."); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } // Verify that the scaling policy was deleted public static void verifyScalingPolicies(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalingPoliciesRequest dscRequest = DescribeScalingPoliciesRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); DescribeScalingPoliciesResponse response = appAutoScalingClient.describeScalingPolicies(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } public static void deregisterScalableTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { try { DeregisterScalableTargetRequest targetRequest = DeregisterScalableTargetRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceId(tableId) .build(); appAutoScalingClient.deregisterScalableTarget(targetRequest); System.out.println("The scalable target was deregistered."); } catch (ApplicationAutoScalingException e) { System.err.println(e.awsErrorDetails().errorMessage()); } } public static void verifyTarget(ApplicationAutoScalingClient appAutoScalingClient, String tableId, ServiceNamespace ns, ScalableDimension tableWCUs) { DescribeScalableTargetsRequest dscRequest = DescribeScalableTargetsRequest.builder() .scalableDimension(tableWCUs) .serviceNamespace(ns) .resourceIds(tableId) .build(); DescribeScalableTargetsResponse response = appAutoScalingClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(response); } } ``` ------ #### [ Java v1 ] ``` package com.amazonaws.codesamples.autoscaling; import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient; import com.amazonaws.services.applicationautoscaling.model.DeleteScalingPolicyRequest; import com.amazonaws.services.applicationautoscaling.model.DeregisterScalableTargetRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest; import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult; import com.amazonaws.services.applicationautoscaling.model.ScalableDimension; import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace; public class DisableDynamoDBAutoscaling { static AWSApplicationAutoScalingClient aaClient = new AWSApplicationAutoScalingClient(); public static void main(String args[]) { ServiceNamespace ns = ServiceNamespace.Dynamodb; ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits; String resourceID = "table/TestTable"; // Delete the scaling policy DeleteScalingPolicyRequest delSPRequest = new DeleteScalingPolicyRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID) .withPolicyName("MyScalingPolicy"); try { aaClient.deleteScalingPolicy(delSPRequest); } catch (Exception e) { System.err.println("Unable to delete scaling policy: "); System.err.println(e.getMessage()); } // Verify that the scaling policy was deleted DescribeScalingPoliciesRequest descSPRequest = new DescribeScalingPoliciesRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { DescribeScalingPoliciesResult dspResult = aaClient.describeScalingPolicies(descSPRequest); System.out.println("DescribeScalingPolicies result: "); System.out.println(dspResult); } catch (Exception e) { e.printStackTrace(); System.err.println("Unable to describe scaling policy: "); System.err.println(e.getMessage()); } System.out.println(); // Remove the scalable target DeregisterScalableTargetRequest delSTRequest = new DeregisterScalableTargetRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceId(resourceID); try { aaClient.deregisterScalableTarget(delSTRequest); } catch (Exception e) { System.err.println("Unable to deregister scalable target: "); System.err.println(e.getMessage()); } // Verify that the scalable target was removed DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest() .withServiceNamespace(ns) .withScalableDimension(tableWCUs) .withResourceIds(resourceID); try { DescribeScalableTargetsResult dsaResult = aaClient.describeScalableTargets(dscRequest); System.out.println("DescribeScalableTargets result: "); System.out.println(dsaResult); System.out.println(); } catch (Exception e) { System.err.println("Unable to describe scalable target: "); System.err.println(e.getMessage()); } } } ``` ------