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