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