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