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 des ressources sans serveur dans Amazon Keyspaces (pour Apache Cassandra)
Amazon Keyspaces (pour Apache Cassandra) est sans serveur. Au lieu de déployer, de gérer et de maintenir les ressources de stockage et de calcul pour votre charge de travail via les nœuds d'un cluster, Amazon Keyspaces alloue les ressources de stockage et de read/write débit directement aux tables.
Amazon Keyspaces provisionne le stockage automatiquement en fonction des données stockées dans vos tables. Il augmente ou diminue le stockage au fur et à mesure que vous écrivez, mettez à jour et supprimez des données, et vous ne payez que pour le stockage que vous utilisez. Les données sont répliquées sur plusieurs [zones de disponibilité](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) pour une haute disponibilité. Amazon Keyspaces surveille en permanence la taille de vos tables afin de déterminer vos frais de stockage. Pour plus d'informations sur la façon dont Amazon Keyspaces calcule la taille facturable des données, consultez. [Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md)
Ce chapitre couvre les principaux aspects de la gestion des ressources dans Amazon Keyspaces.
+ **Estimation de la taille des lignes** : pour estimer la taille codée des lignes dans Amazon Keyspaces, prenez en compte des facteurs tels que les métadonnées des clés de partition, les métadonnées des colonnes en cluster, les identifiants de colonne, les types de données et les métadonnées des lignes. Cette taille de ligne codée est utilisée pour la facturation, la gestion des quotas et la planification de la capacité de débit provisionnée.
+ **Estimation de la consommation de capacité** — Cette section présente des exemples d'estimation de la consommation de capacité de lecture et d'écriture pour des scénarios courants tels que les requêtes par plage, les requêtes de limite, les analyses de tables, les transactions légères, les colonnes statiques et les tables multirégionales. Vous pouvez utiliser Amazon CloudWatch pour surveiller l'utilisation réelle de la capacité. Pour plus d'informations sur la surveillance avec CloudWatch, consultez[Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
+ **Configuration des modes de read/write capacité** : vous pouvez choisir entre deux modes de capacité pour traiter les lectures et les écritures sur vos tables :
+ **Mode à la demande (par défaut)** — Payez par demande pour le débit de lecture et d'écriture. Amazon Keyspaces peut augmenter instantanément la capacité jusqu'à n'importe quel niveau de trafic atteint précédemment.
+ **Mode provisionné** — Spécifiez à l'avance le nombre requis d'unités de capacité de lecture et d'écriture. Ce mode permet de maintenir des performances de débit prévisibles.
+ **Gérez la capacité de débit grâce au dimensionnement automatique** : pour les tables provisionnées, vous pouvez activer le dimensionnement automatique afin d'ajuster automatiquement la capacité de débit en fonction du trafic réel des applications. Amazon Keyspaces utilise le suivi des cibles pour augmenter ou diminuer la capacité allouée, tout en maintenant le taux d'utilisation à l'objectif que vous avez spécifié.
+ **Utilisation efficace de la capacité en rafale** : Amazon Keyspaces fournit une capacité en rafale en réservant une partie du débit inutilisé à la gestion des pics de trafic. Cette flexibilité permet des pics d'activité occasionnels au-delà de votre débit provisionné.
Pour résoudre les problèmes de capacité, voir[Erreurs de capacité sans serveur](troubleshooting.serverless.md#troubleshooting-serverless).
**Topics**
+ [Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md)
+ [Estimez la consommation de capacité du débit de lecture et d'écriture dans Amazon Keyspaces](capacity-examples.md)
+ [Configurer les modes de read/write capacité dans Amazon Keyspaces](ReadWriteCapacityMode.md)
+ [Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces](autoscaling.md)
+ [Utilisez efficacement la capacité de pointe dans Amazon Keyspaces](throughput-bursting.md)
# Estimer la taille des lignes dans Amazon Keyspaces
Amazon Keyspaces fournit un stockage entièrement géré qui offre des performances de lecture et d'écriture à un chiffre en millisecondes et stocke les données de manière durable dans plusieurs zones de disponibilité. AWS Amazon Keyspaces associe des métadonnées à toutes les lignes et à toutes les colonnes clés primaires afin de garantir un accès efficace aux données et une haute disponibilité.
Cette rubrique explique comment estimer la taille codée des lignes dans Amazon Keyspaces. La taille de ligne codée est utilisée lors du calcul de votre facture et de votre quota d'utilisation. Vous pouvez également utiliser la taille de ligne codée lors de l'estimation des exigences de capacité de débit allouées pour les tables.
Pour calculer la taille codée des lignes dans Amazon Keyspaces, vous pouvez suivre les directives suivantes.
**Topics**
+ [Estimer la taille codée des colonnes](#calculating-row-size-columns)
+ [Estimer la taille codée des valeurs de données en fonction du type de données](#calculating-row-size-data-types)
+ [Tenez compte de l'impact des fonctionnalités d'Amazon Keyspaces sur la taille des lignes](#calculating-row-size-features)
+ [Choisissez la bonne formule pour calculer la taille codée d'une ligne](#calculating-row-size-formula)
+ [Exemple de calcul de la taille des lignes](#calculating-row-size-example)
## Estimer la taille codée des colonnes
Cette section explique comment estimer la taille codée des colonnes dans Amazon Keyspaces.
+ **Colonnes normales** : pour les colonnes ordinaires, qui ne sont pas des clés primaires, les colonnes de clustering ou les `STATIC` colonnes, utilisez la taille brute des données de cellule en fonction du [type de données](cql.elements.md#cql.data-types) et ajoutez les métadonnées requises. Les types de données et certaines des principales différences dans la façon dont Amazon Keyspaces stocke les valeurs des types de données et les métadonnées sont répertoriés dans la section suivante.
+ **Colonnes de clé** de partition : les clés de partition peuvent contenir jusqu'à 2 048 octets de données. Chaque colonne clé de la clé de partition nécessite jusqu'à 3 octets de métadonnées. Lorsque vous calculez la taille de votre ligne, vous devez partir du principe que chaque colonne de clé de partition utilise les 3 octets complets de métadonnées.
+ **Colonnes de clustering** : les colonnes de clustering peuvent stocker jusqu'à 850 octets de données. Outre la taille de la valeur des données, chaque colonne de clustering nécessite jusqu'à 20 % de la taille de la valeur des données pour les métadonnées. Lorsque vous calculez la taille de votre ligne, vous devez ajouter 1 octet de métadonnées pour chaque valeur de 5 octets de données de colonne de clustering.
**Note**
Pour permettre des requêtes efficaces et une indexation intégrée, Amazon Keyspaces stocke deux fois la valeur des données de chaque clé de partition et de chaque colonne de clé de clustering.
+ **Noms de colonne** — L'espace requis pour chaque nom de colonne est stocké à l'aide d'un identifiant de colonne et ajouté à chaque valeur de données stockée dans la colonne. La valeur de stockage de l'identifiant de colonne dépend du nombre total de colonnes de votre table :
+ 1 à 62 colonnes : 1 octet
+ 63 à 124 colonnes : 2 octets
+ 125 à 186 colonnes : 3 octets
Pour chaque 62 colonnes supplémentaires, ajoutez 1 octet. Notez que dans Amazon Keyspaces, jusqu'à 225 colonnes normales peuvent être modifiées à l'aide d'une seule instruction `INSERT` ou `UPDATE` d'une seule instruction. Pour de plus amples informations, veuillez consulter [Quotas de service Amazon Keyspaces](quotas.md#table).
## Estimer la taille codée des valeurs de données en fonction du type de données
Cette section explique comment estimer la taille codée de différents types de données dans Amazon Keyspaces.
+ **Types de chaînes** : les types de données Cassandra `ASCII` et `VARCHAR` string sont tous stockés dans Amazon Keyspaces en Unicode avec un codage binaire UTF-8. `TEXT` La taille d'une chaîne dans Amazon Keyspaces est égale au nombre d'octets codés en UTF-8.
+ **Types numériques** : Cassandra`INT`,, `BIGINT` `SMALLINT``TINYINT`, et les types de `VARINT` données sont stockés dans Amazon Keyspaces sous forme de valeurs de données de longueur variable, avec un maximum de 38 chiffres significatifs. Les zéros de début et de fin sont tronqués. La taille de chacun de ces types de données est d'environ 1 octet pour deux chiffres significatifs \$1 1 octet.
+ **Type de blob** — `BLOB` Dans Amazon Keyspaces, le code A est stocké avec la longueur d'octet brute de la valeur.
+ **Type booléen** — La taille d'une `Boolean` valeur ou d'une `Null` valeur est de 1 octet.
+ **Types de collections** : colonne qui stocke des types de données de collection tels que `LIST` ou `MAP` nécessitant 3 octets de métadonnées, quel que soit leur contenu. La taille d'un `LIST` or `MAP` est (identifiant de colonne) \$1 somme (taille des éléments imbriqués) \$1 (3 octets). La taille d'un `LIST` or vide `MAP` est (identifiant de colonne) \$1 (3 octets). Chaque individu `LIST` ou `MAP` élément nécessite également 1 octet de métadonnées.
+ **Types définis par l'utilisateur** — Un [type défini par l'utilisateur (UDT)](udts.md) nécessite 3 octets pour les métadonnées, quel que soit son contenu. Pour chaque élément UDT, Amazon Keyspaces a besoin d'un octet supplémentaire de métadonnées.
Pour calculer la taille codée d'un UDT, commencez par le `field name` et `field value` pour les champs d'un UDT :
+ **nom de champ** — Chaque nom de champ de l'UDT de niveau supérieur est stocké à l'aide d'un identifiant. La valeur de stockage de l'identifiant dépend du nombre total de champs dans votre UDT de premier niveau et peut varier entre 1 et 3 octets :
+ 1 à 62 champs : 1 octet
+ 63 à 124 champs : 2 octets
+ 125 — nombre maximum de champs : 3 octets
+ **valeur du champ** — Les octets nécessaires pour stocker les valeurs de champ de l'UDT de niveau supérieur dépendent du type de données stocké :
+ **Type de données scalaire** — Les octets requis pour le stockage sont les mêmes que pour le même type de données stocké dans une colonne normale.
+ **UDT figé** — Pour chaque UDT imbriqué figé, l'UDT imbriqué a la même taille que dans le protocole binaire CQL. Pour un UDT imbriqué, 4 octets sont stockés pour chaque champ (y compris les champs vides) et la valeur du champ stocké est le format de sérialisation du protocole binaire CQL de la valeur du champ.
+ **Collections Frozen** :
+ **LIST** et **SET** — Dans le cas d'un `LIST` or figé imbriqué`SET`, 4 octets sont stockés pour chaque élément de la collection, plus le format de sérialisation du protocole binaire CQL de la valeur de la collection.
+ **MAP** — Pour une paire figée imbriquée`MAP`, chaque paire clé-valeur a les exigences de stockage suivantes :
+ Pour chaque clé, allouez 4 octets, puis ajoutez le format de sérialisation du protocole binaire CQL de la clé.
+ Pour chaque valeur, allouez 4 octets, puis ajoutez le format de sérialisation du protocole binaire CQL de la valeur.
+ **Mot-clé FROZEN** : pour les collections figées imbriquées dans des collections figées, Amazon Keyspaces ne nécessite aucun octet supplémentaire pour les métadonnées.
+ **Mot-clé STATIC** : les données des `STATIC` colonnes ne sont pas prises en compte dans la taille de ligne maximale de 1 Mo. Pour calculer la taille des données des colonnes statiques, consultez[Calculez la taille de colonne statique par partition logique dans Amazon Keyspaces](static-columns-estimate.md).
## Tenez compte de l'impact des fonctionnalités d'Amazon Keyspaces sur la taille des lignes
Cette section explique l'impact des fonctionnalités d'Amazon Keyspaces sur la taille codée d'une ligne.
+ **Horodatages côté client — Les horodatages** côté client sont stockés pour chaque colonne de chaque ligne lorsque la fonctionnalité est activée. Ces horodatages occupent environ 20 à 40 octets (selon vos données) et contribuent au coût de stockage et de débit de la ligne. Pour plus d'informations sur les horodatages côté client, consultez. [Horodatages côté client dans Amazon Keyspaces](client-side-timestamps.md)
+ **Durée de vie (TTL)** : les métadonnées TTL occupent environ 8 octets par ligne lorsque la fonctionnalité est activée. De plus, les métadonnées TTL sont stockées pour chaque colonne de chaque ligne. Les métadonnées TTL occupent environ 8 octets pour chaque colonne stockant un type de données scalaire ou une collection figée. Si la colonne stocke un type de données de collection qui n'est pas figé, le TTL nécessite environ 8 octets supplémentaires pour les métadonnées pour chaque élément de la collection. Pour une colonne qui stocke un type de données de collecte lorsque le TTL est activé, vous pouvez utiliser la formule suivante.
```
total encoded size of column = (column id) + sum (nested elements + collection metadata (1 byte) + TTL metadata (8 bytes)) + collection column metadata (3 bytes)
```
Les métadonnées TTL contribuent au coût de stockage et de débit de la ligne. Pour plus d’informations sur TTL, consultez [Expirer les données avec Time to Live (TTL) pour Amazon Keyspaces (pour Apache Cassandra)](TTL.md).
## Choisissez la bonne formule pour calculer la taille codée d'une ligne
Cette section présente les différentes formules que vous pouvez utiliser pour estimer les exigences de stockage ou de capacité de débit pour une ligne de données dans Amazon Keyspaces.
La taille totale codée d'une ligne de données peut être estimée à l'aide de l'une des formules suivantes, en fonction de votre objectif :
+ **Capacité de débit** — Pour estimer la taille codée d'une ligne afin d'évaluer les unités de read/write demande requises (RRUs/WRUs) or read/write capacity units (RCUs/WCUs) :
```
total encoded size of row = partition key columns + clustering columns + regular columns
```
+ **Taille de stockage** : pour estimer la taille codée d'une ligne afin de la prévoir`BillableTableSizeInBytes`, ajoutez les métadonnées requises pour le stockage de la ligne :
```
total encoded size of row = partition key columns + clustering columns + regular columns + row metadata (100 bytes)
```
**Important**
Toutes les métadonnées de colonne, par exemple les identifiants de colonne, les métadonnées des clés de partition, les métadonnées des colonnes de clustering, ainsi que les horodatages côté client, le TTL et les métadonnées de ligne sont prises en compte dans la taille de ligne maximale de 1 Mo.
## Exemple de calcul de la taille des lignes
Prenons l'exemple suivant d'une table où toutes les colonnes sont de type entier. La table comporte deux colonnes de clé de partition, deux colonnes de clustering et une colonne normale. Comme ce tableau comporte cinq colonnes, l'espace requis pour l'identifiant du nom de colonne est de 1 octet.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dans cet exemple, nous calculons la taille des données lorsque nous écrivons une ligne dans le tableau, comme indiqué dans l'instruction suivante :
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1) values(1,2,3,4,5);
```
Pour estimer le nombre total d'octets requis par cette opération d'écriture, vous pouvez suivre les étapes suivantes.
1. Calculez la taille d'une colonne de clé de partition en ajoutant les octets correspondant au type de données stocké dans la colonne et les octets de métadonnées. Répétez cette opération pour toutes les colonnes clés de partition.
1. Calculez la taille de la première colonne de la clé de partition (pk\$1col1) :
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Calculez la taille de la deuxième colonne de la clé de partition (pk\$1col2) :
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Ajoutez les deux colonnes pour obtenir la taille totale estimée des colonnes clés de partition :
```
8 bytes + 8 bytes = 16 bytes for the partition key columns
```
1. Calculez la taille de la colonne de clustering en ajoutant les octets correspondant au type de données stocké dans la colonne et les octets de métadonnées. Répétez cette opération pour toutes les colonnes de clustering.
1. Calculez la taille de la première colonne de la colonne de clustering (ck\$1col1) :
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Calculez la taille de la deuxième colonne de la colonne de clustering (ck\$1col2) :
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Ajoutez les deux colonnes pour obtenir la taille totale estimée des colonnes de clustering :
```
6 bytes + 6 bytes = 12 bytes for the clustering columns
```
1. Ajoutez la taille des colonnes normales. Dans cet exemple, nous n'avons qu'une seule colonne qui stocke un entier à un chiffre, ce qui nécessite 2 octets dont 1 octet pour l'identifiant de colonne.
1. Enfin, pour obtenir la taille totale des lignes codées, additionnez les octets de toutes les colonnes. Pour estimer la taille facturable du stockage, ajoutez les 100 octets supplémentaires pour les métadonnées des lignes :
```
16 bytes for the partition key columns + 12 bytes for clustering columns + 3 bytes for the regular column + 100 bytes for row metadata = 131 bytes.
```
Pour savoir comment surveiller les ressources sans serveur avec Amazon CloudWatch, consultez[Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
# Estimez la consommation de capacité du débit de lecture et d'écriture dans Amazon Keyspaces
Lorsque vous lisez ou écrivez des données dans Amazon Keyspaces, le nombre d'unités de read/write demande (RRUs/WRUs) or read/write capacity units (RCUs/WCUs) consommées par votre requête dépend de la quantité totale de données qu'Amazon Keyspaces doit traiter pour exécuter la requête. Dans certains cas, les données renvoyées au client peuvent être un sous-ensemble des données qu'Amazon Keyspaces a dû lire pour traiter la requête. Pour les écritures conditionnelles, Amazon Keyspaces consomme de la capacité d'écriture même si le contrôle conditionnel échoue.
Pour estimer la quantité totale de données traitées pour une demande, vous devez tenir compte de la taille codée d'une ligne et du nombre total de lignes. Cette rubrique présente quelques exemples de scénarios et de modèles d'accès courants pour montrer comment Amazon Keyspaces traite les requêtes et comment cela affecte la consommation de capacité. Vous pouvez suivre les exemples pour estimer les besoins en capacité de vos tables et utiliser Amazon CloudWatch pour observer la consommation de capacité de lecture et d'écriture pour ces cas d'utilisation.
Pour plus d'informations sur le calcul de la taille codée des lignes dans Amazon Keyspaces, consultez. [Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md)
**Topics**
+ [Estimez la consommation de capacité des requêtes de plage dans Amazon Keyspaces](range_queries.md)
+ [Estimer la consommation de capacité de lecture des requêtes limitées](limit_queries.md)
+ [Estimez la consommation de capacité de lecture des scans de tables](table_scans.md)
+ [Estimez la consommation de capacité des transactions légères dans Amazon Keyspaces](lightweight_transactions.md)
+ [Estimation de la consommation de capacité pour les colonnes statiques dans Amazon Keyspaces](static-columns.md)
+ [Estimer et provisionner la capacité d'une table multirégionale dans Amazon Keyspaces](tables-multi-region-capacity.md)
+ [Estimez la consommation de capacité de lecture et d'écriture avec Amazon CloudWatch dans Amazon Keyspaces](estimate_consumption_cw.md)
# Estimez la consommation de capacité des requêtes de plage dans Amazon Keyspaces
Pour examiner la consommation de capacité de lecture d'une requête de plage, nous utilisons le tableau d'exemple suivant qui utilise le mode capacité à la demande.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 50 |
a | b | 1 | a | b | 60 | value_1
a | b | 1 | a | b | 70 |
```
Exécutez maintenant la requête suivante sur cette table.
```
SELECT * FROM amazon_keyspaces.example_table_1 WHERE pk1='a' AND pk2='b' AND pk3=1 AND ck1='a' AND ck2='b' AND ck3 > 50 AND ck3 < 70;
```
Vous recevez le jeu de résultats suivant à partir de la requête et l'opération de lecture effectuée par Amazon Keyspaces en consomme 2 RRUs en mode `LOCAL_QUORUM` cohérence.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 60 | value_1
```
Amazon Keyspaces en consomme 2 RRUs pour évaluer les lignes contenant les valeurs `ck3=60` et `ck3=70` pour traiter la requête. Cependant, Amazon Keyspaces renvoie uniquement la ligne pour laquelle la `WHERE` condition spécifiée dans la requête est vraie, c'est-à-dire la ligne contenant une valeur. `ck3=60` Pour évaluer la plage spécifiée dans la requête, Amazon Keyspaces lit la ligne correspondant à la limite supérieure de la plage, dans ce cas`ck3 = 70`, mais ne renvoie pas cette ligne dans le résultat. La consommation de capacité de lecture est basée sur les données lues lors du traitement de la requête, et non sur les données renvoyées.
# Estimer la consommation de capacité de lecture des requêtes limitées
Lors du traitement d'une requête qui utilise la `LIMIT` clause, Amazon Keyspaces lit les lignes jusqu'à la taille de page maximale en essayant de répondre à la condition spécifiée dans la requête. Si Amazon Keyspaces ne trouve pas suffisamment de données correspondantes correspondant à la `LIMIT` valeur de la première page, un ou plusieurs appels paginés peuvent être nécessaires. Pour poursuivre les lectures sur la page suivante, vous pouvez utiliser un jeton de pagination. La taille de page par défaut est de 1 Mo. Pour réduire la capacité de lecture lorsque vous utilisez `LIMIT` des clauses, vous pouvez réduire la taille de page. Pour plus d'informations sur la pagination, consultez[Paginer les résultats dans Amazon Keyspaces](paginating-results.md).
À titre d'exemple, examinons la requête suivante.
```
SELECT * FROM my_table WHERE partition_key=1234 LIMIT 1;
```
Si vous ne définissez pas le format de page, Amazon Keyspaces lit 1 Mo de données même s'il ne vous renvoie qu'une seule ligne. Pour qu'Amazon Keyspaces ne lise qu'une seule ligne, vous pouvez définir le format de page sur 1 pour cette requête. Dans ce cas, Amazon Keyspaces ne lira qu'une seule ligne, à condition qu'aucune ligne n'ait expiré en fonction des Time-to-live paramètres ou des horodatages côté client.
Le `PAGE SIZE` paramètre détermine le nombre de lignes qu'Amazon Keyspaces analyse depuis le disque pour chaque demande, et non le nombre de lignes renvoyées par Amazon Keyspaces au client. Amazon Keyspaces applique les filtres que vous fournissez, par exemple l'inégalité sur les colonnes non clés ou `LIMIT` après avoir scanné les données sur le disque. Si vous ne le définissez pas explicitement`PAGE SIZE`, Amazon Keyspaces lit jusqu'à 1 Mo de données avant d'appliquer des filtres. Par exemple, si vous utilisez `LIMIT 1` sans spécifier le`PAGE SIZE`, Amazon Keyspaces peut lire des milliers de lignes depuis le disque avant d'appliquer la clause limite et de ne renvoyer qu'une seule ligne.
Pour éviter de trop lire, réduisez le `PAGE SIZE` nombre de lignes qu'Amazon Keyspaces analyse à chaque lecture. Par exemple, si vous le `PAGE SIZE` définissez `LIMIT 5` dans votre requête, définissez une valeur comprise entre 5 et 10 afin qu'Amazon Keyspaces ne scanne que 5 à 10 lignes par appel paginé. Vous pouvez modifier ce nombre pour réduire le nombre d'extractions. Pour les limites supérieures à la taille de page, Amazon Keyspaces conserve le nombre total de résultats avec l'état de pagination. Dans le cas d'un fichier `LIMIT` de 10 000 lignes, Amazon Keyspaces peut récupérer ces résultats sur deux pages de 5 000 lignes chacune. La limite de 1 Mo est la limite supérieure de toute taille de page définie.
# Estimez la consommation de capacité de lecture des scans de tables
Les requêtes qui aboutissent à une analyse complète de la table, par exemple les requêtes utilisant l'`ALLOW FILTERING`option, sont un autre exemple de requêtes qui traitent plus de lectures que ce qu'elles renvoient sous forme de résultats. Et la consommation de capacité de lecture est basée sur les données lues, et non sur les données renvoyées.
Pour l'exemple de numérisation de tables, nous utilisons l'exemple de tableau suivant en mode capacité à la demande.
```
pk | ck | value
---+----+---------
pk | 10 |
pk | 20 | value_1
pk | 30 |
```
Amazon Keyspaces crée une table en mode capacité à la demande avec quatre partitions par défaut. Dans cet exemple de tableau, toutes les données sont stockées dans une partition et les trois partitions restantes sont vides.
Exécutez maintenant la requête suivante sur la table.
```
SELECT * from amazon_keyspaces.example_table_2;
```
Cette requête entraîne une opération d'analyse de table au cours de laquelle Amazon Keyspaces analyse les quatre partitions de la table et en consomme 6 RRUs en mode `LOCAL_QUORUM` cohérence. Tout d'abord, Amazon Keyspaces en consomme 3 RRUs pour lire les trois lignes avec. `pk=‘pk’` Ensuite, Amazon Keyspaces consomme les 3 unités supplémentaires RRUs pour scanner les trois partitions vides de la table. Comme cette requête entraîne une analyse de table, Amazon Keyspaces analyse toutes les partitions de la table, y compris les partitions sans données.
# Estimez la consommation de capacité des transactions légères dans Amazon Keyspaces
Les transactions légères (LWT) vous permettent d'effectuer des opérations d'écriture conditionnelle sur les données de votre table. Les opérations de mise à jour conditionnelle sont utiles lors de l'insertion, de la mise à jour et de la suppression d'enregistrements en fonction de conditions évaluant l'état actuel.
Dans Amazon Keyspaces, toutes les opérations d'écriture nécessitent la cohérence LOCAL\$1QUORUM et leur utilisation est gratuite. LWTs La différence réside dans le fait que lorsqu'une vérification de l'état LWT aboutit`FALSE`, Amazon Keyspaces consomme des unités de capacité d'écriture WCUs () ou des unités de demande d'écriture (). LWTs WRUs Le nombre de lignes WCUs/WRUs consommées dépend de la taille de la ligne.
Par exemple, si la taille de la ligne est de 2 Ko, l'écriture conditionnelle échouée consomme deux WCUs/WRUs. Si la ligne n'existe pas actuellement dans la table, l'opération en consomme un WCUs/WRUs.
Pour déterminer le nombre de demandes ayant entraîné des échecs de vérification des conditions, vous pouvez surveiller la `ConditionalCheckFailed` métrique dans CloudWatch.
## Estimez les coûts LWT pour les tables avec Time to Live (TTL)
LWTs peut nécessiter des unités de capacité de lecture (RCUs) ou des unités de demande de lecture (RRUs) supplémentaires pour les tables configurées avec TTL qui n'utilisent pas d'horodatage côté client. Lorsque la vérification de l'`IF EXISTS`état de nos `IF NOT EXISTS` mots clés est utilisée`FALSE`, les unités de capacité suivantes sont consommées :
+ RCUs/RRUs – If the row exists, the RCUs/RRUsconsommés sont basés sur la taille de la ligne existante.
+ RCUs/RRUs – If the row doesn't exist, a single RCU/RRUest consommé.
Si la condition évaluée aboutit à une opération d'écriture réussie, WCUs/WRUs ils sont consommés en fonction de la taille de la nouvelle ligne.
# Estimation de la consommation de capacité pour les colonnes statiques dans Amazon Keyspaces
Dans un tableau Amazon Keyspaces avec des colonnes de regroupement, vous pouvez utiliser le `STATIC` mot clé pour créer une colonne statique. La valeur stockée dans une colonne statique est partagée entre toutes les lignes d'une partition logique. Lorsque vous mettez à jour la valeur de cette colonne, Amazon Keyspaces applique la modification automatiquement à toutes les lignes de la partition.
Cette section explique comment calculer la taille codée des données lorsque vous écrivez dans des colonnes statiques. Ce processus est géré séparément du processus qui écrit des données dans les colonnes non statiques d'une ligne. Outre les quotas de taille pour les données statiques, les opérations de lecture et d'écriture sur des colonnes statiques affectent également la capacité de mesure et de débit des tables indépendamment. Pour les différences fonctionnelles avec Apache Cassandra lors de l'utilisation de colonnes statiques et de résultats de lecture par plage paginée, voir. [Pagination](functional-differences.md#functional-differences.paging)
**Topics**
+ [Calculez la taille de colonne statique par partition logique dans Amazon Keyspaces](static-columns-estimate.md)
+ [Estimez les exigences de capacité et de débit pour les read/write opérations sur des données statiques dans Amazon Keyspaces](static-columns-metering.md)
# Calculez la taille de colonne statique par partition logique dans Amazon Keyspaces
Cette section explique comment estimer la taille codée des colonnes statiques dans Amazon Keyspaces. La taille codée est utilisée lorsque vous calculez votre facture et votre quota d'utilisation. Vous devez également utiliser la taille codée lorsque vous calculez les exigences de capacité de débit allouées pour les tables. Pour calculer la taille codée des colonnes statiques dans Amazon Keyspaces, vous pouvez suivre les directives suivantes.
+ Les clés de partition peuvent contenir jusqu'à 2 048 octets de données. Chaque colonne clé de la clé de partition nécessite jusqu'à 3 octets de métadonnées. Ces octets de métadonnées sont pris en compte dans votre quota de taille de données statiques de 1 Mo par partition. Lorsque vous calculez la taille de vos données statiques, vous devez partir du principe que chaque colonne de clé de partition utilise les 3 octets complets de métadonnées.
+ Utilisez la taille brute des valeurs de données des colonnes statiques en fonction du type de données. Pour plus d’informations sur les types de données, consultez [Types de données](cql.elements.md#cql.data-types),
+ Ajoutez 104 octets à la taille des données statiques pour les métadonnées.
+ Les colonnes de clustering et les colonnes clés ordinaires non primaires ne sont pas prises en compte dans la taille des données statiques. Pour savoir comment estimer la taille des données non statiques au sein des lignes, consultez[Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md).
La taille totale codée d'une colonne statique est basée sur la formule suivante :
```
partition key columns + static columns + metadata = total encoded size of static data
```
Prenons l'exemple suivant d'une table où toutes les colonnes sont de type entier. La table comporte deux colonnes de clé de partition, deux colonnes de clustering, une colonne normale et une colonne statique.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dans cet exemple, nous calculons la taille des données statiques de l'instruction suivante :
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6);
```
Pour estimer le nombre total d'octets requis par cette opération d'écriture, vous pouvez suivre les étapes suivantes.
1. Calculez la taille d'une colonne de clé de partition en ajoutant les octets correspondant au type de données stocké dans la colonne et les octets de métadonnées. Répétez cette opération pour toutes les colonnes clés de partition.
1. Calculez la taille de la première colonne de la clé de partition (pk\$1col1) :
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Calculez la taille de la deuxième colonne de la clé de partition (pk\$1col2) :
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Ajoutez les deux colonnes pour obtenir la taille totale estimée des colonnes clés de partition :
```
7 bytes + 7 bytes = 14 bytes for the partition key columns
```
1. Ajoutez la taille des colonnes statiques. Dans cet exemple, nous n'avons qu'une seule colonne statique qui stocke un entier (ce qui nécessite 4 octets).
1. Enfin, pour obtenir la taille totale codée des données des colonnes statiques, additionnez les octets pour les colonnes clés primaires et les colonnes statiques, puis ajoutez les 104 octets supplémentaires pour les métadonnées :
```
14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes.
```
Vous pouvez également mettre à jour les données statiques et non statiques avec la même instruction. Pour estimer la taille totale de l'opération d'écriture, vous devez d'abord calculer la taille de la mise à jour des données non statiques. Calculez ensuite la taille de la mise à jour de la ligne comme indiqué dans l'exemple sur[Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md), et ajoutez les résultats.
Dans ce cas, vous pouvez écrire un total de 2 Mo : 1 Mo est le quota de taille de ligne maximum, et 1 Mo est le quota de taille de données statique maximale par partition logique.
Pour calculer la taille totale d'une mise à jour de données statiques et non statiques dans la même instruction, vous pouvez utiliser la formule suivante :
```
(partition key columns + static columns + metadata = total encoded size of static data) + (partition key columns + clustering columns + regular columns + row metadata = total encoded size of row)
= total encoded size of data written
```
Prenons l'exemple suivant d'une table où toutes les colonnes sont de type entier. La table comporte deux colonnes de clé de partition, deux colonnes de clustering, une colonne normale et une colonne statique.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dans cet exemple, nous calculons la taille des données lorsque nous écrivons une ligne dans le tableau, comme indiqué dans l'instruction suivante :
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7);
```
Pour estimer le nombre total d'octets requis par cette opération d'écriture, vous pouvez suivre les étapes suivantes.
1. Calculez la taille totale codée des données statiques comme indiqué précédemment. Dans cet exemple, il s'agit de 122 octets.
1. Ajoutez la taille de la taille totale codée de la ligne en fonction de la mise à jour des données non statiques, en suivant les étapes décrites dans[Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md). Dans cet exemple, la taille totale de la mise à jour des lignes est de 134 octets.
```
122 bytes for static data + 134 bytes for nonstatic data = 256 bytes.
```
# Estimez les exigences de capacité et de débit pour les read/write opérations sur des données statiques dans Amazon Keyspaces
Les données statiques sont associées à des partitions logiques dans Cassandra, et non à des lignes individuelles. Les partitions logiques d'Amazon Keyspaces peuvent avoir une taille pratiquement indépendante en s'étendant sur plusieurs partitions de stockage physiques. Par conséquent, les compteurs Amazon Keyspaces écrivent les opérations sur les données statiques et non statiques séparément. En outre, les écritures qui incluent à la fois des données statiques et non statiques nécessitent des opérations sous-jacentes supplémentaires pour assurer la cohérence des données.
Si vous effectuez une opération d'écriture mixte de données statiques et non statiques, cela entraîne deux opérations d'écriture distinctes, l'une pour les données non statiques et l'autre pour les données statiques. Cela s'applique à la fois aux modes de capacité à la demande et aux modes read/write de capacité provisionnée.
L'exemple suivant explique comment estimer les unités de capacité de lecture (RCUs) et d'écriture requises (WCUs) lorsque vous calculez les exigences de capacité de débit allouée pour les tables d'Amazon Keyspaces comportant des colonnes statiques. Vous pouvez estimer la capacité dont votre table a besoin pour traiter les écritures incluant à la fois des données statiques et non statiques à l'aide de la formule suivante :
```
2 x WCUs required for nonstatic data + 2 x WCUs required for static data
```
Par exemple, si votre application écrit 27 % KBs de données par seconde et que chaque écriture inclut 25,5 % KBs de données non statiques et 1,5 % KBs de données statiques, votre table en nécessite 56 WCUs (2 x 26 WCUs \$1 2 x 2 WCUs).
Amazon Keyspaces mesure les lectures de données statiques et non statiques de la même manière que les lectures de plusieurs lignes. Par conséquent, le prix de lecture de données statiques et non statiques au cours d'une même opération est basé sur la taille agrégée des données traitées pour effectuer la lecture.
Pour savoir comment surveiller les ressources sans serveur avec Amazon CloudWatch, consultez[Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
# Estimer et provisionner la capacité d'une table multirégionale dans Amazon Keyspaces
Vous pouvez configurer la capacité de débit d'une table multirégionale de deux manières :
+ Mode de capacité à la demande, mesuré en unités de demande d'écriture (WRUs)
+ Mode de capacité provisionnée avec mise à l'échelle automatique, mesurée en unités de capacité d'écriture () WCUs
Vous pouvez utiliser le mode capacité provisionnée avec mise à l'échelle automatique ou le mode capacité à la demande pour garantir qu'une table multirégionale dispose d'une capacité suffisante pour effectuer des écritures répliquées pour toutes les tables. Régions AWS
**Note**
La modification du mode de capacité de la table dans l'une des régions modifie le mode de capacité de toutes les répliques.
Par défaut, Amazon Keyspaces utilise le mode à la demande pour les tables multirégionales. Avec le mode à la demande, vous n'avez pas besoin de spécifier le débit de lecture et d'écriture que vous souhaitez que votre application exécute. Amazon Keyspaces s'adapte instantanément à vos charges de travail au fur et à mesure qu'elles augmentent ou diminuent pour atteindre un niveau de trafic atteint précédemment. Si le niveau de trafic d'une charge de travail atteint un nouveau pic, Amazon Keyspaces s'adapte rapidement pour s'adapter à la charge de travail.
Si vous choisissez le mode de capacité provisionnée pour une table, vous devez configurer le nombre d'unités de capacité de lecture (RCUs) et d'unités de capacité d'écriture (WCUs) par seconde dont votre application a besoin.
Pour planifier les besoins en capacité de débit d'une table multirégionale, vous devez d'abord estimer le nombre de unités WCUs par seconde nécessaires pour chaque région. Vous ajoutez ensuite les écritures provenant de toutes les régions dans lesquelles votre table est répliquée, et vous utilisez la somme pour allouer de la capacité à chaque région. Cela est nécessaire car chaque écriture effectuée dans une région doit également être répétée dans chaque région de réplication.
Si la table ne dispose pas d'une capacité suffisante pour gérer les écritures provenant de toutes les régions, des exceptions de capacité se produiront. En outre, les temps d'attente pour la réplication interrégionale augmenteront.
Par exemple, si vous avez une table multirégionale dans laquelle vous attendez 5 écritures par seconde dans l'est des États-Unis (Virginie du Nord), 10 écritures par seconde dans l'est des États-Unis (Ohio) et 5 écritures par seconde en Europe (Irlande), vous devez vous attendre à ce que la table en consomme 20 WCUs dans chaque région : États-Unis est (Virginie du Nord), États-Unis est (Ohio) et Europe (Irlande). Cela signifie que dans cet exemple, vous devez en prévoir 20 WCUs pour chacune des répliques de la table. Vous pouvez surveiller la consommation de capacité de votre table à l'aide d'Amazon CloudWatch. Pour de plus amples informations, veuillez consulter [Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
Chaque écriture est facturée comme 1 WCU, vous verrez donc un total de 60 unités WCUs facturées dans cet exemple. Pour plus d'informations sur les tarifs, consultez les tarifs [d'Amazon Keyspaces (pour Apache Cassandra](https://aws.amazon.com/keyspaces/pricing)).
Pour plus d'informations sur la capacité allouée avec le dimensionnement [Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces](autoscaling.md) automatique d'Amazon Keyspaces, consultez.
**Note**
Si une table s'exécute en mode capacité allouée avec mise à l'échelle automatique, la capacité d'écriture allouée est autorisée à flotter dans les limites de ces paramètres de dimensionnement automatique pour chaque région.
# Estimez la consommation de capacité de lecture et d'écriture avec Amazon CloudWatch dans Amazon Keyspaces
Pour estimer et surveiller la consommation de capacité de lecture et d'écriture, vous pouvez utiliser un CloudWatch tableau de bord. Pour plus d'informations sur les statistiques disponibles pour Amazon Keyspaces, consultez. [Statistiques et dimensions d'Amazon Keyspaces](metrics-dimensions.md)
Pour surveiller les unités de capacité de lecture et d'écriture consommées par une instruction spécifique avec CloudWatch, vous pouvez suivre ces étapes.
1. Création d'une nouvelle table avec des exemples de données
1. Configurez un tableau de bord Amazon Keyspaces pour le CloudWatch tableau. Pour commencer, vous pouvez utiliser un modèle de tableau de bord disponible sur [Github](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates).
1. Exécutez l'instruction CQL, par exemple à l'aide de l'`ALLOW FILTERING`option, et vérifiez les unités de capacité de lecture consommées pour l'analyse complète du tableau dans le tableau de bord.
# Configurer les modes de read/write capacité dans Amazon Keyspaces
Amazon Keyspaces propose deux modes de read/write capacité pour traiter les lectures et les écritures sur vos tables :
+ À la demande (par défaut)
+ Alloué
Le mode read/write de capacité que vous choisissez contrôle la façon dont vous êtes facturé pour le débit de lecture et d'écriture et la façon dont la capacité de débit des tables est gérée.
**Topics**
+ [Configuration du mode capacité à la demande](ReadWriteCapacityMode.OnDemand.md)
+ [Configuration du mode de capacité provisionnée](ReadWriteCapacityMode.Provisioned.md)
+ [Afficher le mode de capacité d'une table dans Amazon Keyspaces](ReadWriteCapacityMode.ProvisionedThroughput.ManagingCapacity.md)
+ [Modifier le mode de capacité d'une table dans Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
+ [Configuration du préchauffage des tables dans Amazon Keyspaces](warm-throughput.md)
# Configuration du mode capacité à la demande
Le mode de capacité à la *demande* d'Amazon Keyspaces (pour Apache Cassandra) est une option de facturation flexible capable de traiter des milliers de demandes par seconde sans planification des capacités. Cette option propose une pay-per-request tarification pour les demandes de lecture et d'écriture afin que vous ne payiez que pour ce que vous utilisez.
Lorsque vous choisissez le mode à la demande, Amazon Keyspaces peut augmenter instantanément la capacité de débit de votre table jusqu'à n'importe quel niveau de trafic précédemment atteint, puis redescendre à la baisse lorsque le trafic des applications diminue. Si le niveau de trafic d'une charge globale atteint un nouveau pic, le service s'adapte rapidement pour augmenter la capacité de débit de votre table. Vous pouvez activer le mode de capacité à la demande pour les tables nouvelles et existantes.
Le mode à la demande est une bonne option si l'une des conditions suivantes est remplie :
+ Vous créez de nouvelles tables avec des charges de travail inconnues.
+ Vous avez un trafic imprévisible au niveau de l’application.
+ Vous préférez ne payer qu’à l’utilisation.
Pour démarrer avec le mode à la demande, vous pouvez créer une nouvelle table ou mettre à jour une table existante pour utiliser le mode capacité à la demande à l'aide de la console ou avec quelques lignes de code CQL (Cassandra Query Language). Pour de plus amples informations, veuillez consulter [Tables](cql.ddl.table.md).
**Topics**
+ [Unités de demande de lecture et unités de demande d’écriture](#ReadWriteCapacityMode.requests)
+ [Trafic de pointe et propriétés de scalabilité](#ReadWriteCapacityMode.PeakTraffic)
+ [Débit initial pour le mode de capacité à la demande](#ReadWriteCapacityMode.InitialThroughput)
## Unités de demande de lecture et unités de demande d’écriture
Avec les tables du mode de capacité à la demande, vous n'avez pas besoin de spécifier à l'avance le débit de lecture et d'écriture que vous comptez utiliser par votre application. Amazon Keyspaces vous facture les lectures et les écritures que vous effectuez sur vos tables en termes d'unités de demande de lecture (RRUs) et d'unités de demande d'écriture (WRUs).
+ Une *RRU* représente une `LOCAL_QUORUM` ou deux demandes de ` LOCAL_ONE` lecture pour une ligne d'une taille maximale de 4 Ko. Si vous devez lire une ligne de plus de 4 Ko, l'opération de lecture utilise des éléments supplémentaires RRUs. Le nombre total de lignes RRUs requises dépend de la taille de la ligne et de la cohérence que vous souhaitez utiliser `LOCAL_QUORUM` ou `LOCAL_ONE` lire. Par exemple, la lecture d'une ligne de 8 Ko nécessite 2 lignes RRUs utilisant la cohérence de `LOCAL_QUORUM` lecture et 1 RRU si vous choisissez la cohérence de `LOCAL_ONE` lecture.
+ Un *WRU* représente une écriture pour une ligne d'une taille maximale de 1 Ko. Toutes les écritures utilisent `LOCAL_QUORUM` la cohérence, et l'utilisation de transactions légères (LWTs) est gratuite. Si vous devez écrire une ligne supérieure à 1 Ko, l'opération d'écriture utilise des éléments supplémentaires WRUs. Le nombre total de lignes WRUs requises dépend de la taille de la ligne. Par exemple, si la taille de votre ligne est de 2 Ko, vous en avez besoin WRUs de 2 pour exécuter une demande d'écriture.
Pour de plus amples informations sur les niveaux de cohérence pris en charge, veuillez consulter [Niveaux de cohérence en lecture et écriture pris en charge par Apache Cassandra et coûts associés](consistency.md).
## Trafic de pointe et propriétés de scalabilité
Les tables Amazon Keyspaces qui utilisent le mode capacité à la demande s'adaptent automatiquement au volume de trafic de votre application. Le mode de capacité à la demande peut gérer jusqu’à deux fois le trafic de pointe précédent d’une table. Par exemple, le modèle de trafic de votre application peut varier entre 5 000 et 10 000 lectures de `LOCAL_QUORUM` par seconde, 10 000 lectures par seconde étant le pic de trafic précédent.
Avec ce modèle, le mode de capacité à la demande prend instantanément en charge un trafic soutenu pouvant atteindre 20 000 lectures par seconde. Si votre application présente un trafic de 20 000 lectures par seconde, ce pic devient votre nouvelle capacité de pointe précédente, permettant ainsi au trafic futur d'atteindre jusqu'à 40 000 lectures par seconde.
Si vous avez besoin de plus du double de votre pic précédent sur une table, Amazon Keyspaces alloue automatiquement plus de capacité à mesure que votre volume de trafic augmente. Cela permet de s'assurer que votre table dispose d'une capacité de débit suffisante pour traiter les demandes supplémentaires. Toutefois, vous pouvez observer des erreurs de capacité de débit insuffisante si vous dépassez le double de votre pic précédent en 30 minutes.
Par exemple, supposons que le modèle de trafic de votre application varie entre 5 000 et 10 000 lectures fortement cohérentes par seconde, où 20 000 lectures par seconde correspondent au pic de trafic atteint précédemment. Dans ce cas, le service vous recommande d'espacer votre croissance de trafic sur au moins 30 minutes avant de conduire jusqu'à 40 000 lectures par seconde.
Pour savoir comment estimer la consommation de capacité de lecture et d'écriture d'une table, voir[Estimez la consommation de capacité du débit de lecture et d'écriture dans Amazon Keyspaces](capacity-examples.md).
Pour en savoir plus sur les quotas par défaut de votre compte et sur la façon de les augmenter, reportez-vous à la section [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).
## Débit initial pour le mode de capacité à la demande
Si vous créez une table avec un mode de capacité à la demande ou basculez une table existante vers le mode de capacité à la demande pour la première fois, la table possède les paramètres suivants du trafic de pointe précédent, même si la table n'a pas encore opéré de trafic en mode de capacité à la demande :
+ **Table nouvellement créée avec mode capacité à la demande :** le pic précédent était de 2 000 WRUs et 6 000 RRUs. Vous pouvez poursuivre jusqu'à doubler le pic précédent immédiatement. Cela permet aux tables à la demande nouvellement créées de servir jusqu'à 4 000 ou WRUs 12 000 personnes RRUs.
+ **Table existante passée en mode capacité à la demande :** le pic précédent correspond à la moitié du pic précédent WCUs et RCUs a été provisionné pour la table ou pour les paramètres d'une table nouvellement créée avec le mode capacité à la demande, selon le montant le plus élevé.
# Configuration du mode de capacité provisionnée
Si vous choisissez le mode de capacité de *débit alloué* vous spécifiez le nombre de lectures et d'écritures par seconde requis pour votre application. Cela vous permet de gérer votre utilisation d'Amazon Keyspaces afin de rester au niveau ou en dessous d'un taux de demandes défini afin de garantir la prévisibilité. Pour en savoir plus sur la mise à l'échelle automatique du débit alloué, reportez-vous à la section [Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces](autoscaling.md).
Le mode de capacité de débit alloué est une bonne option si l'une des conditions suivantes est vraie :
+ Votre application présente un niveau de trafic prévisible.
+ Vous exécutez des applications dont le trafic est constant ou évolue progressivement.
+ Vous pouvez prévoir les besoins en capacité.
## Unités de capacité en lecture et unités de capacité en écriture
Pour les tables du mode de capacité de débit provisionnée, vous spécifiez la capacité de débit en termes d'unités de capacité de lecture (RCUs) et d'unités de capacité d'écriture () : WCUs
+ Un *RCU* représente une lecture de `LOCAL_QUORUM` par seconde ou deux lectures de `LOCAL_ONE` par seconde, pour une ligne d'une taille maximale de 4 Ko. Si vous devez lire une ligne de plus de 4 Ko, l'opération de lecture utilise des éléments supplémentaires RCUs.
Le nombre total de lignes RCUs requises dépend de la taille de la ligne et de votre volonté `LOCAL_QUORUM` ou de votre `LOCAL_ONE` lecture. Par exemple, si la taille de votre ligne est de 8 Ko, vous en avez besoin RCUs de 2 pour supporter une `LOCAL_QUORUM` lecture par seconde et d'une RCU si vous choisissez des `LOCAL_ONE` lectures.
+ Une *WCU* représente une écriture par seconde pour une ligne d'une taille maximale de 1 Ko. Toutes les écritures utilisent `LOCAL_QUORUM` la cohérence, et l'utilisation de transactions légères (LWTs) est gratuite. Si vous devez écrire une ligne supérieure à 1 Ko, l'opération d'écriture utilise des éléments supplémentaires WCUs.
Le nombre total de lignes WCUs requises dépend de la taille de la ligne. Par exemple, si la taille de votre ligne est de 2 Ko, vous en avez besoin WCUs de 2 pour gérer une demande d'écriture par seconde. Pour plus d'informations sur la façon d'estimer la consommation de capacité de lecture et d'écriture d'une table, consultez[Estimez la consommation de capacité du débit de lecture et d'écriture dans Amazon Keyspaces](capacity-examples.md).
Si votre application lit ou écrit des lignes plus grandes (jusqu'à la taille de ligne maximale d'Amazon Keyspaces de 1 Mo), elle consomme davantage d'unités de capacité. Pour en savoir plus sur l'estimation de la taille des lignes, consultez[Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md). Supposons, par exemple, que vous créiez une table provisionnée avec 6 RCUs et 6 WCUs. Avec ces paramètres, votre application pourrait effectuer les opérations suivantes :
+ Effectuez des `LOCAL_QUORUM` lectures allant jusqu'à 24 Ko par seconde (4 Ko × 6 RCUs).
+ Effectuez des lectures de `LOCAL_ONE` allant jusqu'à 48 Ko par seconde (deux fois plus de débit de lecture).
+ Écrivez jusqu'à 6 Ko par seconde (1 Ko × 6 WCUs).
Le *Débit alloué* est la quantité maximum de capacité qu'une application peut consommer à partir d'une table. Si votre application dépasse votre capacité de débit alloué, vous pouvez observer des erreurs de capacité insuffisante.
Par exemple, une demande de lecture dont la capacité de débit est insuffisante échoue avec une `Read_Timeout` exception et est publiée dans la `ReadThrottleEvents` métrique. Une demande d'écriture dont la capacité de débit est insuffisante échoue avec une `Write_Timeout` exception et est publiée dans la `WriteThrottleEvents` métrique.
Vous pouvez utiliser Amazon CloudWatch pour surveiller vos indicateurs de débit provisionnés et réels ainsi que les événements de capacité insuffisante. Pour plus d’informations sur ces métriques, consultez [Statistiques et dimensions d'Amazon Keyspaces](metrics-dimensions.md).
**Note**
Des erreurs répétées dues à une capacité insuffisante peuvent entraîner des exceptions spécifiques au pilote côté client, par exemple si le pilote DataStax Java échoue avec un. `NoHostAvailableException`
Pour modifier les paramètres de capacité de débit des tables, vous pouvez utiliser l'instruction AWS Management Console ou l'`ALTER TABLE`instruction à l'aide de CQL. Pour plus d'informations, voir. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
Pour en savoir plus sur les quotas par défaut de votre compte et sur la façon de les augmenter, reportez-vous à la section [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).
# Afficher le mode de capacité d'une table dans Amazon Keyspaces
Vous pouvez interroger la table système dans l'espace de touches du système Amazon Keyspaces pour consulter les informations relatives au mode capacité relatives à une table. Vous pouvez également voir si une table utilise le mode de capacité de débit à la demande ou allouée. Si la table est configurée avec le mode de capacité de débit alloué, vous pouvez voir la capacité de débit alloué pour la table.
Vous pouvez également utiliser le AWS CLI pour afficher le mode de capacité d'une table.
Pour modifier le débit provisionné d'une table, consultez. [Modifier le mode de capacité d'une table dans Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
------
#### [ Cassandra Query Language (CQL) ]
**Exemple**
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'mykeyspace' and table_name = 'mytable';
```
Une table configurée avec le mode de capacité à la demande renvoie ce qui suit.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579551547603",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Une table configurée avec le mode de capacité de débit alloué renvoie ce qui suit.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579048006000",
"read_capacity_units":"5000",
"throughput_mode":"PROVISIONED",
"write_capacity_units":"6000"
}
}
```
La valeur `last_update_to_pay_per_request_timestamp` est mesurée en millisecondes.
------
#### [ CLI ]
Affichez le mode de capacité de débit d'une table à l'aide du AWS CLI
```
aws keyspaces get-table --keyspace-name myKeyspace --table-name myTable
```
La sortie de la commande peut ressembler à ceci pour une table en mode capacité provisionnée.
```
"capacitySpecification": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 4000,
"writeCapacityUnits": 2000
}
```
La sortie d'une table en mode à la demande ressemble à ceci.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Modifier le mode de capacité d'une table dans Amazon Keyspaces
Lorsque vous passez d'une table du mode capacité allouée au mode capacité à la demande, Amazon Keyspaces apporte plusieurs modifications à la structure de votre table et de vos partitions. Ce processus peut prendre plusieurs minutes. Pendant la période de commutation, votre table fournit un débit compatible avec les montants WCU et RCU précédemment alloués.
Si vous passez du mode de capacité à la demande au mode de capacité allouée, votre table fournit un débit correspondant au trafic de pointe précédent atteint lorsque la table était en mode de capacité à la demande.
Les périodes d'attente suivantes s'appliquent lorsque vous changez de mode de capacité :
+ Vous pouvez à tout moment faire passer une table nouvellement créée en mode à la demande en mode capacité provisionnée. Cependant, vous ne pouvez revenir en mode à la demande que 24 heures après l'horodatage de création de la table.
+ Vous pouvez à tout moment faire passer une table existante en mode à la demande en mode capacité provisionnée. Toutefois, vous ne pouvez passer du mode provisionné au mode à la demande qu'une seule fois par période de 24 heures.
------
#### [ Cassandra Query Language (CQL) ]
**Modifier le mode de capacité de débit d'une table à l'aide de CQL**
1. Pour modifier le mode de capacité d'une table, `PROVIOSIONED` vous devez configurer les unités de capacité de lecture et de capacité d'écriture en fonction des valeurs maximales attendues de votre charge de travail. L'énoncé suivant en est un exemple. Vous pouvez également exécuter cette instruction pour ajuster la capacité de lecture ou les unités de capacité d'écriture de la table.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 6000, 'write_capacity_units': 3000}};
```
Pour configurer le mode de capacité provisionnée avec auto-scaling, consultez. [Configurer le dimensionnement automatique sur une table existante](autoscaling.configureTable.md)
1. Pour passer du mode de capacité d'une table au mode à la demande, définissez le mode de débit sur`PAY_PER_REQUEST`. La déclaration suivante en est un exemple.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PAY_PER_REQUEST'}};
```
1. Vous pouvez utiliser l'instruction suivante pour confirmer le mode de capacité de la table.
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'catalog' and table_name = 'book_awards';
```
Une table configurée avec le mode de capacité à la demande renvoie ce qui suit.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1727952499092",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
La valeur `last_update_to_pay_per_request_timestamp` est mesurée en millisecondes.
------
#### [ CLI ]
**Modifiez le mode de capacité de débit d'une table à l'aide du AWS CLI**
1. Pour changer le mode de capacité de la table, `PROVIOSIONED` vous devez configurer les unités de capacité de lecture et de capacité d'écriture en fonction des valeurs maximales attendues de votre charge de travail. La commande suivante en est un exemple. Vous pouvez également exécuter cette commande pour ajuster la capacité de lecture ou les unités de capacité d'écriture de la table.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=6000,writeCapacityUnits=3000
```
Pour configurer le mode de capacité provisionnée avec auto-scaling, consultez. [Configurer le dimensionnement automatique sur une table existante](autoscaling.configureTable.md)
1. Pour passer du mode de capacité d'une table au mode à la demande, vous devez définir le mode de débit sur`PAY_PER_REQUEST`. La déclaration suivante en est un exemple.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PAY_PER_REQUEST
```
1. Vous pouvez utiliser la commande suivante pour vérifier le mode de capacité configuré pour une table.
```
aws keyspaces get-table --keyspace-name catalog --table-name book_awards
```
La sortie d'une table en mode à la demande ressemble à ceci.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Configuration du préchauffage des tables dans Amazon Keyspaces
Amazon Keyspaces adapte automatiquement les partitions de stockage en fonction du débit à la demande ou provisionné, mais en cas de nouvelles tables ou de pics de débit soudains, l'allocation des partitions de stockage requises peut prendre plus de temps. Pour vous assurer qu'une table nouvelle ou existante dispose d'une capacité suffisante pour supporter le pic de débit prévu, vous pouvez définir manuellement des valeurs de *débit de chauffage spécifiques pour *préchauffer** votre table.
Le *débit chaud* fait référence au nombre d'opérations de lecture et d'écriture que votre table Amazon Keyspaces peut prendre en charge instantanément. Ces valeurs sont disponibles par défaut pour toutes les tables nouvelles et existantes. Si vous utilisez le mode à la demande ou si vous mettez à jour votre débit provisionné, Amazon Keyspaces garantit que votre application est en mesure d'émettre des demandes allant jusqu'à ces valeurs instantanément.
Amazon Keyspaces ajuste automatiquement les valeurs de débit à chaud à mesure que votre utilisation augmente. Pour ajuster la capacité de débit en fonction des pics à venir, par exemple lorsque vous migrez des données depuis une autre base de données, ce qui peut nécessiter le chargement de téraoctets de données en peu de temps, vous pouvez augmenter manuellement les valeurs de débit à chaud de vos tables. Cela est utile pour les pics planifiés où les taux de demandes peuvent augmenter de 10, 100 fois ou plus. Tout d'abord, déterminez si le débit chaud actuel est suffisant pour gérer le trafic attendu. [Ensuite, si vous devez préchauffer la table en fonction de la charge de travail maximale prévue, vous pouvez augmenter manuellement la valeur du débit à chaud sans modifier vos paramètres de débit ou votre mode de capacité.](ReadWriteCapacityMode.md)
Vous pouvez préchauffer les tables pour les opérations de lecture, les opérations d'écriture ou les deux. Vous pouvez augmenter cette valeur pour les tables à région unique et les tables multirégions nouvelles et existantes, et les paramètres de débit à chaud que vous définissez s'appliquent automatiquement à toutes les répliques des tables multirégions. Le nombre de tables Amazon Keyspaces que vous pouvez préchauffer à tout moment est illimité. Le temps nécessaire pour terminer le préchauffage dépend des valeurs que vous avez définies et de la taille de la table. Vous pouvez soumettre des demandes de préchauffage simultanées et ces demandes n'interfèrent avec aucune opération de table. Vous pouvez préchauffer votre table jusqu'au quota de table autorisé pour votre compte dans cette région. Utilisez la [console Service Quotas](https://console.aws.amazon.com/servicequotas) pour vérifier vos quotas actuels et les augmenter si nécessaire.
Les valeurs de débit à chaud qu'Amazon Keyspaces ajuste en fonction de votre utilisation à la demande ou de la capacité allouée sont disponibles par défaut pour toutes les tables sans frais supplémentaires. Toutefois, si vous augmentez manuellement les valeurs de débit de préchauffage par défaut pour préchauffer les tables en cas de pic de trafic, des frais supplémentaires s'appliquent. Pour plus d'informations, consultez les [tarifs d'Amazon Keyspaces.](https://aws.amazon.com/keyspaces/pricing/)
Voici quelques scénarios et bonnes pratiques à prendre en compte lors du préchauffage des tables Amazon Keyspaces.
## Débit chaud et modèles d’accès inégaux
Une table peut avoir un débit élevé de 30 000 unités de lecture par seconde et de 10 000 unités d'écriture par seconde, mais vous pouvez tout de même rencontrer des événements de dépassement de capacité lors des lectures ou des écritures avant d'atteindre ces valeurs. Cela est probablement dû à une partition chaude. Même si Amazon Keyspaces peut continuer à évoluer pour prendre en charge un débit pratiquement illimité, chaque partition individuelle est limitée à 1 000 unités d'écriture par seconde et à 3 000 unités de lecture par seconde. Si votre application génère trop de trafic vers une petite partie des partitions de la table, des événements de dépassement de capacité peuvent se produire avant même que vous n'atteigniez les valeurs de débit maximal de la table. Nous vous recommandons de suivre les [bonnes pratiques d'Amazon Keyspaces](bp-partition-key-design.md) afin de garantir une évolutivité sans faille et d'éviter les partitions chaudes.
## Débit chaud pour une table provisionnée
Prenons l'exemple d'une table provisionnée dont le débit maximal est de 30 000 unités de lecture par seconde et de 10 000 unités d'écriture par seconde, mais dont le débit est actuellement de 4 000 et 8 000. RCUs WCUs Vous pouvez instantanément augmenter le débit provisionné de la table jusqu'à 30 000 RCUs ou 10 000 WCUs en mettant à jour vos paramètres de débit provisionné. Lorsque vous augmentez le débit provisionné au-delà de ces valeurs, le débit chaud s'ajuste automatiquement aux nouvelles valeurs supérieures, car vous avez établi un nouveau débit de pointe. Par exemple, si vous définissez le débit provisionné à 50 000 RCU, le débit à chaud augmente à 50 000 unités de lecture par seconde.
```
"ProvisionedThroughput":
{
"ReadCapacityUnits": 4000,
"WriteCapacityUnits": 8000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```
## Débit chaud pour une table à la demande
Une nouvelle table à la demande utilise au début un débit chaud de 12 000 unités de lecture par seconde et de 4 000 unités d’écriture par seconde. Votre table peut instantanément accueillir un trafic soutenu jusqu’à ces niveaux. Lorsque vos demandes dépassent 12 000 unités de lecture par seconde ou 4 000 unités d'écriture par seconde, le débit chaud s'ajuste automatiquement aux valeurs les plus élevées.
```
"WarmThroughput":
{
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000
}
```
## Bonnes pratiques pour préchauffer les tables Amazon Keyspaces
Suivez ces bonnes pratiques lors de la mise en œuvre du préchauffage pour vos tables Amazon Keyspaces :
Estimez avec précision la capacité requise
Comme le préchauffage entraîne un coût unique, calculez soigneusement le débit nécessaire en fonction de la charge de travail attendue afin d'éviter le surprovisionnement.
Tenez compte du schéma de la table
Les tables comportant des lignes plus grandes peuvent nécessiter davantage de partitions pour le même débit. Tenez compte de la taille moyenne de vos rangées lors de l'estimation des besoins de préchauffage.
Surveillez les performances des tables
Après le préchauffage, utilisez CloudWatch des métriques pour vérifier que votre table supporte la charge comme prévu. Pour de plus amples informations, veuillez consulter [Surveillez les performances d'une table préchauffée à l'aide d'Amazon CloudWatch](monitor-prewarming-cloudwatch.md).
Gérer les quotas
Si votre application nécessite un débit supérieur à celui autorisé par les quotas par défaut (40 000 RCUs/WCUs ou 2 000 partitions), le quota de demandes augmente bien avant l'événement à fort trafic. Pour demander une augmentation d’un quota, vous pouvez utiliser la [console Service Quotas](https://console.aws.amazon.com/servicequotas).
Optimisez les coûts
Pour les événements temporaires à fort trafic, pensez à utiliser le préchauffage plutôt que de passer en mode provisionné à haute capacité, car cela peut être plus rentable pour les événements de courte durée. Pour plus d'informations sur les tarifs, consultez les tarifs [d'Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/).
**Note**
Surveillez les indicateurs de performance de votre application pendant la phase de test pour vérifier que votre configuration de préchauffage répond correctement aux exigences de votre charge de travail.
**Topics**
+ [Débit chaud et modèles d’accès inégaux](#warm-throughput-scenarios-uneven)
+ [Débit chaud pour une table provisionnée](#warm-throughput-scenarios-provisioned)
+ [Débit chaud pour une table à la demande](#warm-throughput-scenarios-ondemand)
+ [Bonnes pratiques pour préchauffer les tables Amazon Keyspaces](#prewarming-best-practices)
+ [Création d’une nouvelle table Amazon Keyspaces avec un débit chaud supérieur](create-table-warm-throughput.md)
+ [Augmentation du débit chaud de votre table Amazon Keyspaces existante](update-warm-throughput.md)
+ [Afficher le débit à chaud d'une table Amazon Keyspaces](view-warm-throughput.md)
+ [Surveillez les performances d'une table préchauffée à l'aide d'Amazon CloudWatch](monitor-prewarming-cloudwatch.md)
# Création d’une nouvelle table Amazon Keyspaces avec un débit chaud supérieur
Vous pouvez ajuster les valeurs du débit chaud lorsque vous créez votre table Amazon Keyspaces à l'aide de la console, du CQL ou du. AWS CLI
------
#### [ Console ]
**Comment créer une nouvelle table avec des paramètres de débit à chaud**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le panneau de navigation, choisissez **Tables**, puis **Create table (Créer une table)**.
1. Sur la page **Créer une table** dans la section **Détails de la table**, sélectionnez un espace de touche et donnez un nom à la nouvelle table.
1. Dans la section **Colonnes**, créez le schéma de votre table.
1. Dans la section **Clé primaire**, définissez la clé primaire de la table et sélectionnez les colonnes de clustering facultatives.
1. Dans la section **Paramètres du tableau**, choisissez **Personnaliser les paramètres**.
1. Continuez jusqu'à **Paramètres de capacité en lecture/écriture**.
1. Pour le **mode Capacité**, vous pouvez choisir entre **On-Demand** ou **Provisioned.**
1. Dans la section **Préchauffage des tables**, vous pouvez augmenter les valeurs des **unités de lecture par seconde** et des **unités d'écriture par seconde selon** les besoins pour préparer votre table à gérer les pics planifiés.
Les valeurs de débit à chaud qu'Amazon Keyspaces ajuste en fonction de votre utilisation à la demande ou de la capacité allouée sont disponibles par défaut pour toutes les tables sans frais supplémentaires. Notez que si vous augmentez manuellement les valeurs de débit de chauffage par défaut pour préchauffer la table en cas de pic de trafic, des frais supplémentaires s'appliquent.
1. Configurez les autres fonctionnalités facultatives du tableau selon vos besoins. Choisissez ensuite **Créer une table**.
------
#### [ Cassandra Query Language (CQL) ]
+ Créez une table avec un débit à chaud à l'aide de l'une des méthodes suivantes :
+ Pour le mode provisionné, créez une table et spécifiez la capacité maximale attendue pour les lectures et les écritures à l'aide de la syntaxe CQL suivante :
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 20000,
'write_capacity_units': 10000
},
'warm_throughput': {
'read_units_per_second': 40000,
'write_units_per_second': 20000
}
};
```
+ Pour le mode à la demande, créez une table et spécifiez la capacité maximale attendue pour les lectures et les écritures à l'aide de la syntaxe CQL suivante :
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PAY_PER_REQUEST'
},
'warm_throughput': {
'read_units_per_second': 40000,
'write_units_per_second': 20000
}
};
```
Pour confirmer les paramètres de capacité du tableau, voir[Afficher le débit à chaud d'une table Amazon Keyspaces](view-warm-throughput.md).
------
#### [ CLI ]
1. Créez une table avec un débit à chaud en utilisant l'une des méthodes suivantes à l'aide du AWS CLI
+ Créez une nouvelle table en mode provisionné et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. La déclaration suivante en est un exemple.
```
aws keyspaces create-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=20000,writeCapacityUnits=10000 \
--warm-throughput-specification readUnitsPerSecond=40000,writeUnitsPerSecond=20000
```
+ Créez une nouvelle table en mode à la demande et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. La déclaration suivante en est un exemple.
```
aws keyspaces create-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
--warmThroughputSpecification readUnitsPerSecond=40000,writeUnitsPerSecond=20000
```
1. La sortie de la commande renvoie l'ARN de la table, comme indiqué dans l'exemple suivant.
```
{
"resourceArn": "arn:aws::cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards>"
}
```
Pour confirmer les paramètres de capacité du tableau, voir[Afficher le débit à chaud d'une table Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**Créez une nouvelle table à l'aide du SDK for Java.**
+ Créez une nouvelle table en mode provisionné et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. L'exemple de code suivant en est un exemple.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class PreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Define schema
List columns = Arrays.asList(
ColumnDefinition.builder().name("year").type("int").build(),
ColumnDefinition.builder().name("award").type("text").build(),
ColumnDefinition.builder().name("rank").type("int").build(),
ColumnDefinition.builder().name("category").type("text").build(),
ColumnDefinition.builder().name("book_title").type("text").build(),
ColumnDefinition.builder().name("author").type("text").build(),
ColumnDefinition.builder().name("publisher").type("text").build()
);
List partitionKeys = Arrays.asList(
PartitionKey.builder().name("year").build(),
PartitionKey.builder().name("award").build()
);
List clusteringKeys = Arrays.asList(
ClusteringKey.builder().name("category").orderBy("ASC").build(),
ClusteringKey.builder().name("rank").orderBy("ASC").build()
);
SchemaDefinition schema = SchemaDefinition.builder()
.allColumns(columns)
.partitionKeys(partitionKeys)
.clusteringKeys(clusteringKeys)
.build();
// Define capacity specification
CapacitySpecification capacitySpec = CapacitySpecification.builder()
.throughputMode(ThroughputMode.PROVISIONED)
.readCapacityUnits(20000)
.writeCapacityUnits(10000)
.build();
// Define warm throughput specification
WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
.readUnitsPerSecond(40000L)
.writeUnitsPerSecond(20000L)
.build();
// Create table with PreWarming
CreateTableRequest request = CreateTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.schemaDefinition(schema)
.capacitySpecification(capacitySpec)
.warmThroughputSpecification(warmThroughput)
.build();
CreateTableResponse response = keyspacesClient.createTable(request);
System.out.println("Table created with ARN: " + response.resourceArn());
}
}
```
------
# Augmentation du débit chaud de votre table Amazon Keyspaces existante
Vous pouvez augmenter les valeurs de débit à chaud actuelles de votre table Amazon Keyspaces à l'aide de la console, du CQL ou du. AWS CLI
------
#### [ Console ]
**Comment augmenter les paramètres de préchauffage d'une table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Tables**, puis choisissez la table que vous souhaitez mettre à jour.
1. Dans l'onglet **Capacité** du tableau, passez à **Préchauffage pour les tables**.
1. Dans la section **Préchauffage des tables**, choisissez **Modifier**.
1. Sur la page **Modifier le préchauffage pour les tables**, vous pouvez mettre à jour les valeurs des **unités de lecture par seconde** et des **unités d'écriture par seconde**.
1. Sélectionnez **Enregistrer les modifications**. Votre table est en train d'être mise à jour avec les paramètres de préchauffage spécifiés.
------
#### [ Cassandra Query Language (CQL) ]
**Augmenter les paramètres de débit à chaud d'une table à l'aide de CQL**
+ Utilisez l'`ALTER TABLE`instruction pour augmenter le débit de chaleur d'une table. La déclaration suivante en est un exemple.
```
ALTER TABLE catalog.book_awards
WITH CUSTOM_PROPERTIES = {
'warm_throughput': {
'read_units_per_second': 60000,
'write_units_per_second': 30000
}
};
```
Pour confirmer les paramètres de capacité mis à jour du tableau, voir[Afficher le débit à chaud d'une table Amazon Keyspaces](view-warm-throughput.md).
------
#### [ CLI ]
**Augmentez les réglages de préchauffage d'une table à l'aide du AWS CLI**
+ Pour augmenter le débit de chauffage de la table, vous pouvez utiliser la commande. `update-table` La déclaration suivante en est un exemple.
```
aws keyspaces update-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--warmThroughputSpecification readUnitsPerSecond=60000,writeUnitsPerSecond=30000
```
Pour confirmer les paramètres de capacité mis à jour du tableau, voir[Afficher le débit à chaud d'une table Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**Mettez à jour les paramètres de préchauffage d'une table à l'aide du SDK for Java.**
+ Mettez à jour les paramètres de débit de chaleur d'une table. L'exemple de code suivant en est un exemple.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class UpdatePreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Define new warm throughput specification
WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
.readUnitsPerSecond(60000L)
.writeUnitsPerSecond(30000L)
.build();
// Update table with new PreWarming settings
UpdateTableRequest request = UpdateTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.warmThroughputSpecification(warmThroughput)
.build();
UpdateTableResponse response = keyspacesClient.updateTable(request);
System.out.println("Table update requested: " + response.resourceArn());
}
}
```
------
# Afficher le débit à chaud d'une table Amazon Keyspaces
Vous pouvez consulter les valeurs de débit à chaud actuelles de votre table Amazon Keyspaces à l'aide de la console, du CQL ou du. AWS CLI
------
#### [ Console ]
**Comment consulter les paramètres de préchauffage de votre table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Tables**, puis sélectionnez le tableau que vous souhaitez consulter.
1. Dans l'onglet **Capacité** du tableau, passez à **Préchauffage pour les tables**.
------
#### [ Cassandra Query Language (CQL) ]
**Afficher les paramètres de débit à chaud d'une table à l'aide de CQL**
+ Pour afficher les paramètres de débit à chaud d'une table, vous pouvez utiliser l'instruction CQL suivante.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name='catalog' and table_name='book_awards';
// Output:
...
custom_properties
----------------------------------------------------------------------------------
{
'warm_throughput':
{
'read_units_per_second': '40000',
'write_units_per_second': '20000',
'status': 'AVAILABLE'
}
}
...
```
------
#### [ CLI ]
**Consultez les paramètres de débit de chaleur d'une table à l'aide du AWS CLI**
+ Vous pouvez afficher les paramètres de débit à chaud d'une table à l'aide de la `get-table` commande, comme indiqué dans l'exemple suivant.
```
aws keyspaces get-table \
--keyspace-name 'catalog' \
--table-name 'book_awards'
```
Voici un exemple de sortie de la `get-table` commande pour une table à région unique en mode provisionné.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
... Existing Fields ...,
"capacitySpecificationSummary": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 20000,
"writeCapacityUnits": 10000
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
Voici un exemple de sortie pour une table à région unique en mode à la demande.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards_ondemand",
... Existing Fields ...,
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST"
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
------
#### [ Java ]
**Lisez les paramètres de préchauffage d'une table à l'aide du SDK for Java.**
+ Lisez les valeurs de débit à chaud d'une table à l'aide de. `get-table` L'exemple de code suivant en est un exemple.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class GetTableWithPreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Get table details including PreWarming specification
GetTableRequest request = GetTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.build();
GetTableResponse response = keyspacesClient.getTable(request);
// Access PreWarming details
if (response.warmThroughputSpecification() != null) {
WarmThroughputSpecificationSummary warmThroughputSummary = response.warmThroughputSpecification();
System.out.println("PreWarming Status: " + warmThroughputSummary.status());
System.out.println("Read Units: " + warmThroughputSummary.readUnitsPerSecond());
System.out.println("Write Units: " + warmThroughputSummary.writeUnitsPerSecond());
// Check if PreWarming is active
if (warmThroughputSummary.status().equals("AVAILABLE")) {
System.out.println("Table is fully pre-warmed and ready for high throughput");
} else if (warmThroughputSummary.status().equals("UPDATING")) {
System.out.println("Table PreWarming is currently being updated");
}
} else {
System.out.println("Table does not have PreWarming enabled");
}
}
}
```
------
# Surveillez les performances d'une table préchauffée à l'aide d'Amazon CloudWatch
Le préchauffage d'Amazon Keyspaces n'introduit pas de nouvelles CloudWatch statistiques, mais vous pouvez surveiller les performances des tables préchauffées à l'aide des statistiques Amazon Keyspaces existantes :
SuccessfulRequestLatency
Surveillez cette métrique pour vérifier que la table préchauffée traite les demandes avec la latence attendue.
WriteThrottleEvents et ReadThrottleEvents
Ces paramètres doivent rester faibles pour une table correctement préchauffée. Si vous constatez des erreurs de capacité insuffisantes malgré le préchauffage, vous devrez peut-être ajuster vos valeurs de débit de chauffage.
ConsumedReadCapacityUnits et ConsumedWriteCapacityUnits
Ces mesures indiquent la consommation réelle de capacité, ce qui peut aider à valider si votre configuration de préchauffage est appropriée.
ProvisionedReadCapacityUnits et ProvisionedWriteCapacityUnits
Pour les tables provisionnées, ces mesures indiquent la capacité actuellement allouée.
Ces métriques peuvent être consultées dans la CloudWatch console ou demandées à l'aide de l'API. CloudWatch Pour de plus amples informations, veuillez consulter [Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
# Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces
De nombreuses charges de travail de base de données sont cycliques par nature et 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.
Un autre exemple : supposons que vous ayez une nouvelles application de jeux pour appareils mobiles qui 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 Keyspaces (pour Apache Cassandra) vous aide à fournir une capacité de débit efficace pour des charges de travail variables en ajustant automatiquement la capacité de débit en réponse au trafic réel des applications. Amazon Keyspaces utilise le service Application Auto Scaling pour augmenter et diminuer la capacité de lecture et d'écriture d'une table en votre nom. Pour plus d'informations sur Application Auto Scaling, consultez le [Guide de l'utilisateur d'Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/).
**Note**
Pour démarrer rapidement avec le dimensionnement automatique d'Amazon Keyspaces, consultez. [Configurer et mettre à jour les politiques de dimensionnement automatique d'Amazon Keyspaces](autoscaling.configure.md)
## Comment fonctionne le dimensionnement automatique d'Amazon Keyspaces
Le schéma suivant fournit une vue d'ensemble détaillée de la façon dont le dimensionnement automatique d'Amazon Keyspaces gère la capacité de débit d'une table.
![\[Schéma illustrant les différents services concernés lorsqu'un utilisateur modifie une table Amazon Keyspaces. Les services sont Amazon CloudWatch, Amazon SNS et Application Auto Scaling, qui émet l'instruction ALTER TABLE pour modifier la capacité en fonction de l'utilisation en lecture ou en écriture des utilisateurs.\]](http://docs.aws.amazon.com/fr_fr/keyspaces/latest/devguide/images/keyspaces_auto-scaling.png)
Pour activer la mise à l'échelle automatique d'une table , vous devez créer une *stratégie de mise à l'échelle*. La stratégie de mise à l’échelle permet de spécifier si vous souhaitez mettre à l’échelle la capacité en lecture ou en écriture (ou les deux), ainsi que les paramètres d’unité de capacité allouée minimum et maximum pour la table.
La stratégie de mise à l'échelle définit également une *utilisation cible*. L’utilisation cible correspond au ratio unités de capacité consommées/unités de capacité allouées à un point dans le temps, exprimé sous forme de pourcentage. La mise à l'échelle automatique utilise un algorithme de *suivi de cible* pour ajuster le débit alloué de la table vers le haut ou vers le bas en réponse aux charges de travail réelles. L'utilisation réelle de la capacité reste ainsi proche de votre utilisation cible.
Vous pouvez également définir les valeurs d'utilisation cibles de la mise à l'échelle automatique entre 20 % et 90 % pour votre capacité de lecture et d'écriture. Le taux d'utilisation cible par défaut est de 70 %. Vous pouvez définir l'utilisation cible à un pourcentage inférieur si votre trafic change rapidement et si vous souhaitez que la capacité commence à augmenter plus tôt. Vous pouvez également définir le taux d'utilisation cible sur un taux plus élevé si le trafic de votre application change plus lentement et que vous souhaitez réduire le coût du débit.
Pour plus d'informations sur les politiques de dimensionnement, consultez la section [Politiques de dimensionnement du suivi des cibles pour Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le [https://docs.aws.amazon.com/autoscaling/application/userguide/](https://docs.aws.amazon.com/autoscaling/application/userguide/).
Lorsque vous créez une politique de dimensionnement, Amazon Keyspaces crée deux paires d' CloudWatch alarmes Amazon en votre nom. Chaque paire représente vos limites supérieure et inférieure pour les paramètres de débit alloué. 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. Pour en savoir plus sur Amazon CloudWatch, consultez le [guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
Lorsque l'une des CloudWatch alarmes est déclenchée, Amazon Simple Notification Service (Amazon SNS) vous envoie une notification (si vous l'avez activée). L' CloudWatch alarme appelle ensuite Application Auto Scaling pour évaluer votre politique de dimensionnement. Cela envoie ensuite une demande Alter Table à Amazon Keyspaces pour ajuster la capacité allouée à la table à la hausse ou à la baisse, selon le cas. Pour en savoir plus sur les notifications Amazon SNS, consultez [Configuration des notifications Amazon SNS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html).
Amazon Keyspaces traite la demande Alter Table en augmentant (ou en diminuant) la capacité de débit allouée à la table afin qu'elle se rapproche de votre objectif d'utilisation.
**Note**
Le scalage automatique d'Amazon Keyspaces modifie les paramètres de débit provisionnés uniquement lorsque la charge de travail réelle reste élevée (ou diminuée) pendant une période prolongée de plusieurs minutes. L'algorithme de suivi cherche à garder l'utilisation cible au niveau ou 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.
## Comment fonctionne la mise à l'échelle automatique pour les tables multirégionales
Pour garantir que la capacité de lecture et d'écriture est toujours suffisante pour toutes les répliques de table dans Régions AWS l'ensemble d'une table multirégionale en mode capacité allouée, nous vous recommandons de configurer le dimensionnement automatique d'Amazon Keyspaces.
Lorsque vous utilisez une table multirégionale en mode provisionné avec mise à l'échelle automatique, vous ne pouvez pas désactiver la mise à l'échelle automatique pour une seule réplique de table. Mais vous pouvez ajuster les paramètres de mise à l'échelle automatique de lecture du tableau pour différentes régions. Par exemple, vous pouvez spécifier des paramètres de capacité de lecture et de mise à l'échelle automatique de lecture différents pour chaque région dans laquelle la table est répliquée.
Les paramètres de redimensionnement automatique en lecture que vous configurez pour une réplique de table dans une région spécifiée remplacent les paramètres généraux de mise à l'échelle automatique de la table. La capacité d'écriture doit toutefois rester synchronisée entre toutes les répliques de tables afin de garantir une capacité suffisante pour répliquer les écritures dans toutes les régions.
Amazon Keyspaces auto scaling met à jour indépendamment la capacité allouée de la table dans chacune en Région AWS fonction de l'utilisation dans cette région. Par conséquent, la capacité allouée dans chaque région pour une table multirégionale peut être différente lorsque le dimensionnement automatique est activé.
Vous pouvez configurer les paramètres de dimensionnement automatique d'une table multirégionale et de ses répliques à l'aide de la console Amazon Keyspaces, de l'API ou du CQL. AWS CLI Pour plus d'informations sur la création et la mise à jour des paramètres de mise à l'échelle automatique pour les tables multirégionales, consultez[Mettre à jour les paramètres de capacité allouée et de dimensionnement automatique pour une table multirégionale dans Amazon Keyspaces](tables-mrr-autoscaling.md).
**Note**
Si vous utilisez le dimensionnement automatique pour les tables multirégionales, vous devez toujours utiliser les opérations de l'API Amazon Keyspaces pour configurer les paramètres de dimensionnement automatique. Si vous utilisez directement les opérations de l'API Application Auto Scaling pour configurer les paramètres de dimensionnement automatique, vous n'êtes pas en mesure Régions AWS de spécifier le tableau multirégional. Cela peut entraîner des configurations non prises en charge.
## Notes d’utilisation
Avant de commencer à utiliser le dimensionnement automatique d'Amazon Keyspaces, vous devez prendre en compte les points suivants :
+ Le dimensionnement automatique d'Amazon Keyspaces n'est pas disponible dans la région Moyen-Orient (Émirats arabes unis).
+ Le dimensionnement automatique d'Amazon Keyspaces peut augmenter la capacité de lecture ou d'écriture aussi souvent que nécessaire, conformément à votre politique de dimensionnement. Tous les quotas Amazon Keyspaces restent en vigueur, comme décrit dans. [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md)
+ Le dimensionnement automatique d'Amazon Keyspaces ne vous empêche pas de modifier manuellement les paramètres de débit provisionnés. Ces ajustements manuels n'affectent pas les CloudWatch alarmes existantes associées à la politique de dimensionnement.
+ Si vous utilisez la console pour créer une table avec une capacité de débit allouée, le dimensionnement automatique d'Amazon Keyspaces est activé par défaut. Vous pouvez modifier vos paramètres de mise à l'échelle automatique à tout moment. Pour de plus amples informations, veuillez consulter [Désactiver la mise à l'échelle automatique d'Amazon Keyspaces pour un tableau](autoscaling.turnoff.md).
+ Si vous utilisez CloudFormation pour créer des politiques de dimensionnement, vous devez gérer les politiques de dimensionnement de CloudFormation manière à ce que la pile soit synchronisée avec le modèle de pile. Si vous modifiez les politiques de dimensionnement d'Amazon Keyspaces, elles seront remplacées par les valeurs d'origine du modèle de pile lorsque la CloudFormation pile sera réinitialisée.
+ Si vous surveillez le dimensionnement automatique CloudTrail d'Amazon Keyspaces, vous pouvez recevoir des alertes concernant les appels effectués par Application Auto Scaling dans le cadre de son processus de validation de configuration. Vous pouvez filtrer ces alertes en utilisant le `invokedBy` champ qui contient `application-autoscaling.amazonaws.com` ces contrôles de validation.
# Configurer et mettre à jour les politiques de dimensionnement automatique d'Amazon Keyspaces
Vous pouvez utiliser la console, le CQL ou le AWS Command Line Interface (AWS CLI) pour configurer le dimensionnement automatique d'Amazon Keyspaces pour les tables nouvelles et existantes. Vous pouvez également modifier les paramètres de mise à l'échelle automatique ou désactiver la mise à l'échelle automatique.
Pour des fonctionnalités plus avancées, telles que la définition des temps de recharge de mise à l'échelle initiale et inférieure, nous vous recommandons d'utiliser CQL ou le pour gérer les politiques de dimensionnement d' AWS CLI Amazon Keyspaces.
**Topics**
+ [Configurer les autorisations pour le dimensionnement automatique d'Amazon Keyspaces](autoscaling.permissions.md)
+ [Création d'un nouveau tableau avec mise à l'échelle automatique](autoscaling.createTable.md)
+ [Configurer le dimensionnement automatique sur une table existante](autoscaling.configureTable.md)
+ [Afficher la configuration de mise à l'échelle automatique d'Amazon Keyspaces de votre table](autoscaling.viewPolicy.md)
+ [Désactiver la mise à l'échelle automatique d'Amazon Keyspaces pour un tableau](autoscaling.turnoff.md)
+ [Afficher l'activité de mise à l'échelle automatique d'une table Amazon Keyspaces dans Amazon CloudWatch](autoscaling.activity.md)
# Configurer les autorisations pour le dimensionnement automatique d'Amazon Keyspaces
Pour commencer, vérifiez que le principal dispose des autorisations appropriées pour créer et gérer les paramètres de dimensionnement automatique. Dans Gestion des identités et des accès AWS (IAM), la politique AWS gérée `AmazonKeyspacesFullAccess` est requise pour gérer les politiques de dimensionnement d'Amazon Keyspaces.
**Important**
Les autorisations `application-autoscaling:*` sont nécessaires pour désactiver la mise à l'échelle automatique sur une table. Vous devez désactiver la mise à l'échelle automatique pour une table avant de pouvoir la supprimer.
Pour configurer un utilisateur ou un rôle IAM pour l'accès à la console Amazon Keyspaces et le dimensionnement automatique d'Amazon Keyspaces, ajoutez la politique suivante.
**Pour joindre la `AmazonKeyspacesFullAccess` politique**
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Sur le tableau de bord de la console IAM, choisissez **Utilisateurs**, puis choisissez votre utilisateur ou votre rôle IAM dans la liste.
1. Sur la page **Récapitulatif**, choisissez **Ajouter des autorisations**.
1. Choisissez **Attacher directement les stratégies existantes**.
1. Dans la liste des politiques, choisissez **AmazonKeyspacesFullAccess**, puis cliquez sur **Suivant : Réviser**.
1. Choisissez **Ajouter des autorisations**.
# Création d'un nouveau tableau avec mise à l'échelle automatique
Lorsque vous créez une nouvelle table Amazon Keyspaces, vous pouvez activer automatiquement le dimensionnement automatique en fonction de la capacité d'écriture ou de lecture de la table. Cela permet à Amazon Keyspaces de contacter Application Auto Scaling en votre nom pour enregistrer la table en tant que cible évolutive et ajuster la capacité d'écriture ou de lecture allouée.
Pour plus d'informations sur la façon de créer une table multirégionale et de configurer différents paramètres de mise à l'échelle automatique pour les répliques de tables, consultez. [Création d'une table multirégionale en mode provisionné avec mise à l'échelle automatique dans Amazon Keyspaces](tables-mrr-create-provisioned.md)
**Note**
Le dimensionnement automatique d'Amazon Keyspaces nécessite la présence d'un rôle lié à un service (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) qui exécute des actions de dimensionnement automatique en votre nom. Ce rôle est créé automatiquement pour vous. Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Créez un nouveau tableau avec la mise à l'échelle automatique activée à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le panneau de navigation, choisissez **Tables**, puis **Create table (Créer une table)**.
1. Sur la page **Créer une table** dans la section **Détails de la table**, sélectionnez un espace de touche et donnez un nom à la nouvelle table.
1. Dans la section **Colonnes**, créez le schéma de votre table.
1. Dans la section **Clé primaire**, définissez la clé primaire de la table et sélectionnez les colonnes de clustering facultatives.
1. Dans la section **Paramètres du tableau**, choisissez **Personnaliser les paramètres**.
1. Continuez jusqu'à **Paramètres de capacité en lecture/écriture**.
1. Pour le **Mode de capacité**, choisissez **Provisioned (Alloué)**.
1. Dans la section **Capacité de lecture** confirmez que l'option **Mettre à l'échelle automatiquement** est sélectionnée.
Dans cette étape, vous sélectionnez les unités de capacité de lecture minimale et maximale pour la table, ainsi que l'utilisation cible.
+ **Unités de capacité minimale** : entrez la valeur du niveau de débit minimal que le tableau doit toujours être prêt à prendre en charge. La valeur doit être comprise entre 1 et le quota par seconde du débit maximal pour votre compte (40 000 par défaut).
+ **Unités de capacité maximale** : entrez le débit maximal que vous souhaitez allouer pour le tableau. La valeur doit être comprise entre 1 et le quota par seconde du débit maximal pour votre compte (40 000 par défaut).
+ **Utilisation cible** — Entrez un taux d'utilisation cible compris entre 20 % et 90 %. Lorsque le trafic dépasse le taux d'utilisation cible défini, la capacité est automatiquement mise à l'échelle. Lorsque le trafic tombe en dessous de la cible définie, il est automatiquement réduit de nouveau.
**Note**
Pour en savoir plus sur les quotas par défaut de votre compte et sur la façon de les augmenter, reportez-vous à la section [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).
1. Dans la section **Capacité d'écriture**, choisissez les mêmes paramètres que ceux définis à l'étape précédente pour la capacité de lecture ou configurez les valeurs de capacité manuellement.
1. Choisissez **Créer un tableau**. Votre table est créée avec les paramètres de mise à l'échelle automatique spécifiés.
------
#### [ Cassandra Query Language (CQL) ]
**Créez une nouvelle table avec la mise à l'échelle automatique d'Amazon Keyspaces à l'aide de CQL**
Pour configurer les paramètres de mise à l'échelle automatique d'une table par programmation, vous devez utiliser l'`AUTOSCALING_SETTINGS`instruction qui contient les paramètres de mise à l'échelle automatique d'Amazon Keyspaces. Les paramètres définissent les conditions qui obligent Amazon Keyspaces à ajuster le débit provisionné de votre table, ainsi que les actions facultatives supplémentaires à effectuer. Dans cet exemple, vous définissez les paramètres de mise à l'échelle automatique pour *mytable.*
Cette politique contient les éléments suivants :
+ `AUTOSCALING_SETTINGS`— Spécifie si Amazon Keyspaces est autorisé à ajuster la capacité de débit en votre nom. Les valeurs suivantes sont obligatoires :
+ `provisioned_write_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `provisioned_read_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `scaling_policy`— Amazon Keyspaces soutient la politique de suivi des cibles. Pour définir la politique de suivi des cibles, vous devez configurer les paramètres suivants.
+ `target_value`— La mise à l'échelle automatique d'Amazon Keyspaces garantit que le rapport entre la capacité consommée et la capacité allouée reste égal ou proche de cette valeur. Vous définissez `target_value` en tant que pourcentage.
+ `disableScaleIn`: (Facultatif) Un `boolean` qui indique si la table `scale-in` est désactivée ou activée. Ce paramètre est désactivé par défaut. Pour l'activer`scale-in`, définissez la `boolean` valeur sur`FALSE`. Cela signifie que la capacité est automatiquement réduite pour une table en votre nom.
+ `scale_out_cooldown`— Une activité de scale-out augmente le débit provisionné de votre table. Pour ajouter un temps de stabilisation pour les activités de montée en charge, spécifiez une valeur, en secondes, pour `scale_out_cooldown`. Si vous ne spécifiez aucune valeur, la valeur par défaut est 0. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*.
+ `scale_in_cooldown`— Une activité de scale-in réduit le débit provisionné de votre table. Pour ajouter un temps de stabilisation pour les activités de mise à l'échelle, spécifiez une valeur, en secondes, pour `scale_in_cooldown`. Si vous ne spécifiez aucune valeur, la valeur par défaut est 0. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*.
**Note**
Pour mieux comprendre le fonctionnement de `target_value`, 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 `target_value` 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 étant supérieur à votre objectif, l'autoscaling augmente la capacité d'écriture allouée à 215, de sorte que le ratio soit (150/ 215), soit 69,77 %, le plus proche `target_value` possible de la vôtre, sans toutefois le dépasser.
Pour *mytable*, vous avez défini `TargetValue` une capacité de lecture et d'écriture de 50 %. Le dimensionnement automatique d'Amazon Keyspaces ajuste le débit provisionné de la table dans une fourchette de 5 à 10 unités de capacité afin que le consumed-to-provisioned ratio reste égal ou proche de 50 %. Pour la capacité de lecture, vous définissez les valeurs `ScaleInCooldown` pour `ScaleOutCooldown` et sur 60 secondes.
Vous pouvez utiliser l'instruction suivante pour créer une nouvelle table Amazon Keyspaces avec la mise à l'échelle automatique activée.
```
CREATE TABLE mykeyspace.mytable(pk int, ck int, PRIMARY KEY (pk, ck))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Créez un nouveau tableau avec le dimensionnement automatique d'Amazon Keyspaces à l'aide du AWS CLI**
Pour configurer les paramètres de dimensionnement automatique d'une table par programmation, vous devez utiliser l'`autoScalingSpecification`action qui définit les paramètres du dimensionnement automatique d'Amazon Keyspaces. Les paramètres définissent les conditions qui obligent Amazon Keyspaces à ajuster le débit provisionné de votre table, ainsi que les actions facultatives supplémentaires à effectuer. Dans cet exemple, vous définissez les paramètres de mise à l'échelle automatique pour *mytable.*
Cette politique contient les éléments suivants :
+ `autoScalingSpecification`— Spécifie si Amazon Keyspaces est autorisé à ajuster le débit de capacité en votre nom. Vous pouvez activer la mise à l'échelle automatique pour la capacité de lecture et pour la capacité d'écriture séparément. Vous devez ensuite définir les paramètres suivants pour `autoScalingSpecification` :
+ `writeCapacityAutoScaling`— Les unités de capacité d'écriture maximale et minimale.
+ `readCapacityAutoScaling`— Les unités de capacité de lecture maximale et minimale.
+ `scalingPolicy`— Amazon Keyspaces soutient la politique de suivi des cibles. Pour définir la politique de suivi des cibles, vous devez configurer les paramètres suivants.
+ `targetValue`— La mise à l'échelle automatique d'Amazon Keyspaces garantit que le rapport entre la capacité consommée et la capacité allouée reste égal ou proche de cette valeur. Vous définissez `targetValue` en tant que pourcentage.
+ `disableScaleIn`: (Facultatif) Un `boolean` qui indique si la table `scale-in` est désactivée ou activée. Ce paramètre est désactivé par défaut. Pour l'activer`scale-in`, définissez la `boolean` valeur sur`FALSE`. Cela signifie que la capacité est automatiquement réduite pour une table en votre nom.
+ `scaleOutCooldown`— Une activité de scale-out augmente le débit provisionné de votre table. Pour ajouter un temps de stabilisation pour les activités de montée en charge, spécifiez une valeur, en secondes, pour `ScaleOutCooldown`. La valeur par défaut est 0. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*.
+ `scaleInCooldown`— Une activité de scale-in réduit le débit provisionné de votre table. Pour ajouter un temps de stabilisation pour les activités de mise à l'échelle, spécifiez une valeur, en secondes, pour `ScaleInCooldown`. La valeur par défaut est 0. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*.
**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 étant supérieur à votre objectif, l'autoscaling augmente la capacité d'écriture allouée à 215, de sorte que le ratio soit (150/ 215), soit 69,77 %, le plus proche `TargetValue` possible de la vôtre, sans toutefois le dépasser.
Pour *mytable*, vous avez défini `TargetValue` une capacité de lecture et d'écriture de 50 %. Le dimensionnement automatique d'Amazon Keyspaces ajuste le débit provisionné de la table dans une fourchette de 5 à 10 unités de capacité afin que le consumed-to-provisioned ratio reste égal ou proche de 50 %. Pour la capacité de lecture, vous définissez les valeurs `ScaleInCooldown` pour `ScaleOutCooldown` et sur 60 secondes.
Lorsque vous créez des tables avec des paramètres de mise à l'échelle automatique complexes, il est utile de charger les paramètres de mise à l'échelle automatique à partir d'un fichier JSON. Dans l'exemple suivant, vous pouvez télécharger le fichier JSON d'exemple depuis [auto-scaling.zip](samples/auto-scaling.zip) et l'extraire `auto-scaling.json` en prenant note du chemin d'accès au fichier. Dans cet exemple, le fichier JSON se trouve dans le répertoire actuel. Pour connaître les différentes options de chemin de fichier, consultez [Comment charger des paramètres à partir d'un fichier](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
```
aws keyspaces create-table --keyspace-name mykeyspace --table-name mytable
\ --schema-definition 'allColumns=[{name=pk,type=int},{name=ck,type=int}],partitionKeys=[{name=pk},{name=ck}]'
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Configurer le dimensionnement automatique sur une table existante
Vous pouvez mettre à jour une table Amazon Keyspaces existante pour activer le dimensionnement automatique en fonction de la capacité d'écriture ou de lecture de la table. Si vous mettez à jour une table qui est actuellement en mode capacité à la demande, vous devez d'abord changer le mode capacité de la table en mode capacité provisionnée.
Pour plus d'informations sur la mise à jour des paramètres de mise à l'échelle automatique pour une table multirégionale, consultez[Mettre à jour les paramètres de capacité allouée et de dimensionnement automatique pour une table multirégionale dans Amazon Keyspaces](tables-mrr-autoscaling.md).
Le dimensionnement automatique d'Amazon Keyspaces nécessite la présence d'un rôle lié à un service (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) qui exécute des actions de dimensionnement automatique en votre nom. Ce rôle est créé automatiquement pour vous. Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Configurer le dimensionnement automatique d'Amazon Keyspaces pour une table existante**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Choisissez la table avec laquelle vous souhaitez travailler, puis accédez à l'onglet **Capacité**.
1. Dans la section **Paramètres de capacité**, choisissez **Modifier**.
1. En **mode Capacité**, assurez-vous que la table utilise le mode Capacité **provisionnée**.
1. Sélectionnez **Mettre à l'échelle automatiquement** et consultez l'étape 6 dans [Création d'un nouveau tableau avec mise à l'échelle automatique](autoscaling.createTable.md) pour modifier la capacité de lecture et d'écriture.
1. Lorsque les paramètres de mise à l'échelle automatique sont définis, choisissez **Enregistrer**.
------
#### [ Cassandra Query Language (CQL) ]
**Configurer une table existante avec le dimensionnement automatique d'Amazon Keyspaces à l'aide de CQL**
Vous pouvez utiliser l'`ALTER TABLE`instruction d'une table Amazon Keyspaces existante pour configurer le dimensionnement automatique en fonction de la capacité d'écriture ou de lecture de la table. Si vous mettez à jour une table qui est actuellement en mode capacité à la demande, vous devez la `capacity_mode` définir sur provisionnée. Si votre table est déjà en mode capacité provisionnée, ce champ peut être omis.
Dans l'exemple suivant, l'instruction met à jour la table *mytable*, qui est en mode capacité à la demande. L'instruction change le mode de capacité de la table en mode provisionné avec le dimensionnement automatique activé.
La capacité d'écriture est configurée dans une plage de 5 à 10 unités de capacité avec une valeur cible de 50 %. La capacité de lecture est également configurée dans une plage de 5 à 10 unités de capacité avec une valeur cible de 50 %. Pour la capacité de lecture, vous définissez les valeurs `scale_in_cooldown` pour `scale_out_cooldown` et sur 60 secondes.
```
ALTER TABLE mykeyspace.mytable
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Configurez une table existante avec le dimensionnement automatique d'Amazon Keyspaces à l'aide du AWS CLI**
Pour une table Amazon Keyspaces existante, vous pouvez activer le dimensionnement automatique pour la capacité d'écriture ou de lecture de la table à l'`UpdateTable`aide de cette opération.
Vous pouvez utiliser la commande suivante pour activer le dimensionnement automatique d'Amazon Keyspaces pour une table existante. Les paramètres de mise à l'échelle automatique de la table sont chargés à partir d'un fichier JSON. Dans l'exemple suivant, vous pouvez télécharger le fichier JSON d'exemple depuis [auto-scaling.zip](samples/auto-scaling.zip) et l'extraire `auto-scaling.json` en prenant note du chemin d'accès au fichier. Dans cet exemple, le fichier JSON se trouve dans le répertoire actuel. Pour connaître les différentes options de chemin de fichier, consultez [Comment charger des paramètres à partir d'un fichier](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
Pour plus d'informations sur les paramètres de mise à l'échelle automatique utilisés dans l'exemple suivant, consultez[Création d'un nouveau tableau avec mise à l'échelle automatique](autoscaling.createTable.md).
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Afficher la configuration de mise à l'échelle automatique d'Amazon Keyspaces de votre table
Vous pouvez utiliser la console, le CQL ou le AWS CLI pour afficher et mettre à jour les paramètres de mise à l'échelle automatique d'une table Amazon Keyspaces.
------
#### [ Console ]
****
**Afficher les paramètres de mise à l'échelle automatique à l'aide de la console**
1. Choisissez le tableau que vous souhaitez consulter et accédez à l'onglet **Capacité**.
1. Dans la section **Paramètres de capacité**, choisissez **Modifier**. Vous pouvez désormais modifier les paramètres dans les sections **Capacité de lecture** ou **Capacité d'écriture**. Pour plus d’informations sur ces paramètres, consultez la page [Création d'un nouveau tableau avec mise à l'échelle automatique](autoscaling.createTable.md).
------
#### [ Cassandra Query Language (CQL) ]
**Consultez la politique de dimensionnement automatique d'Amazon Keyspaces de votre table à l'aide de CQL**
Pour afficher les détails de la configuration de mise à l'échelle automatique d'une table, utilisez la commande suivante.
```
SELECT * FROM system_schema_mcs.autoscaling WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
La sortie de cette commande ressemble à ceci :
```
keyspace_name | table_name | provisioned_read_capacity_autoscaling_update | provisioned_write_capacity_autoscaling_update
---------------+------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 60, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 60}}} | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 0, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 0}}}
```
------
#### [ CLI ]
**Consultez la politique de dimensionnement automatique d'Amazon Keyspaces de votre table à l'aide du AWS CLI**
Pour afficher la configuration de mise à l'échelle automatique d'une table, vous pouvez utiliser l'`get-table-auto-scaling-settings`opération. La commande CLI suivante en est un exemple.
```
aws keyspaces get-table-auto-scaling-settings --keyspace-name mykeyspace --table-name mytable
```
La sortie de cette commande ressemble à ceci :
```
{
"keyspaceName": "mykeyspace",
"tableName": "mytable",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
"autoScalingSpecification": {
"writeCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 0,
"scaleOutCooldown": 0,
"targetValue": 50.0
}
}
},
"readCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 60,
"scaleOutCooldown": 60,
"targetValue": 50.0
}
}
}
}
}
```
------
# Désactiver la mise à l'échelle automatique d'Amazon Keyspaces pour un tableau
Vous pouvez désactiver le dimensionnement automatique d'Amazon Keyspaces pour votre table à tout moment. Si vous n'avez plus besoin de redimensionner la capacité de lecture ou d'écriture de votre tableau, vous devriez envisager de désactiver le dimensionnement automatique afin qu'Amazon Keyspaces ne continue pas à modifier les paramètres de capacité de lecture ou d'écriture de votre tableau. Vous pouvez mettre à jour le tableau à l'aide de la console, du CQL ou du AWS CLI.
La désactivation de la mise à l'échelle automatique supprime également les CloudWatch alarmes créées en votre nom.
Pour supprimer le rôle lié à un service utilisé par Application Auto Scaling pour accéder à votre table Amazon Keyspaces, suivez les étapes décrites dans. [Supprimer un rôle lié à un service pour Amazon Keyspaces](using-service-linked-roles-app-auto-scaling.md#delete-service-linked-role-app-auto-scaling)
**Note**
Pour supprimer le rôle lié à un service utilisé par Application Auto Scaling, vous devez désactiver le dimensionnement automatique sur toutes les tables du compte. Régions AWS
------
#### [ Console ]
**Désactiver le redimensionnement automatique d'Amazon Keyspaces pour votre table à l'aide de la console**
**Utilisation de la console Amazon Keyspaces**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Choisissez le tableau que vous souhaitez mettre à jour et accédez à l'onglet **Capacité**.
1. Dans la section **Paramètres de capacité**, choisissez **Modifier**.
1. Pour désactiver le dimensionnement automatique d'Amazon Keyspaces, décochez la case **Scale automatically**. La désactivation du dimensionnement automatique annule l'enregistrement de la table en tant que cible évolutive avec Application Auto Scaling.
------
#### [ Cassandra Query Language (CQL) ]
**Désactiver la mise à l'échelle automatique d'Amazon Keyspaces pour votre table à l'aide de CQL**
L'instruction suivante désactive la mise à l'échelle automatique de la capacité d'écriture de la table *mytable.*
```
ALTER TABLE mykeyspace.mytable
WITH AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'autoscaling_disabled': true
}
};
```
------
#### [ CLI ]
**Désactivez le redimensionnement automatique d'Amazon Keyspaces pour votre tableau à l'aide du AWS CLI**
La commande suivante désactive le dimensionnement automatique en fonction de la capacité de lecture de la table. Il supprime également les CloudWatch alarmes créées en votre nom.
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --auto-scaling-specification readCapacityAutoScaling={autoScalingDisabled=true}
```
------
# Afficher l'activité de mise à l'échelle automatique d'une table Amazon Keyspaces dans Amazon CloudWatch
Vous pouvez surveiller la manière dont le dimensionnement automatique d'Amazon Keyspaces utilise les ressources en utilisant Amazon CloudWatch, qui génère des statistiques relatives à votre utilisation et à vos performances. Suivez les étapes du [guide de l'Application Auto Scaling utilisateur](https://docs.aws.amazon.com/autoscaling/application/userguide/monitoring-cloudwatch.html) pour créer un CloudWatch tableau de bord.
# Utilisez efficacement la capacité de pointe dans Amazon Keyspaces
*Amazon Keyspaces offre une certaine flexibilité dans le provisionnement du débit par partition en fournissant une capacité de pointe.* Lorsque vous n'utilisez pas pleinement le débit d'une partition, Amazon Keyspaces réserve une partie de cette capacité inutilisée pour des pics de débit *ultérieurs* afin de gérer les pics d'utilisation.
Amazon Keyspaces conserve actuellement jusqu'à 5 minutes (300 secondes) de capacité de lecture et d'écriture inutilisée. Lors d'une vague occasionnelle d'activité de lecture ou d'écriture, ces unités de capacité supplémentaire peuvent être consommées rapidement, même plus rapidement que la capacité de débit allouée par seconde que vous avez définie pour votre table.
Amazon Keyspaces peut également consommer de la capacité en rafale pour la maintenance en arrière-plan et d'autres tâches sans préavis.
Notez que ces informations relatives à la capacité de transmission en mode rafale sont susceptibles d’évoluer.