

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.

# Résolution des problèmes liés à Amazon Keyspaces (pour Apache Cassandra)
<a name="troubleshooting"></a>

Ce guide décrit les étapes de résolution des problèmes pour différents scénarios liés à l'utilisation d'Amazon Keyspaces (pour Apache Cassandra). Il contient des informations sur la résolution des erreurs générales, des problèmes de connexion, des problèmes de gestion des capacités et des erreurs du langage de définition des données (DDL).
+ **Erreurs générales** 
  + Résolution des exceptions de haut niveau telles que `NoNodeAvailableException``NoHostAvailableException`, et. `AllNodesFailedException` 
  + Isoler les erreurs sous-jacentes des exceptions du pilote Java. 
  + Implémentation de politiques de nouvelle tentative et configuration correcte des connexions. 
+ **Problèmes de connexion** 
  + Résolution des erreurs lors de la connexion aux points de terminaison Amazon Keyspaces à l'aide `cqlsh` de pilotes clients Apache Cassandra. 
  + Résolution des problèmes liés aux connexions aux points de terminaison VPC, aux connexions Cassandra-stress et aux erreurs de configuration IAM.
  + Gestion des pertes de connexion lors des importations de données.
+ **Erreurs liées à la gestion des capacités** 
  + Reconnaissance et résolution des erreurs de capacité insuffisante liées aux tables, aux partitions et aux connexions.
  + Surveillance des statistiques Amazon Keyspaces pertinentes dans Amazon CloudWatch Logs. 
  + Optimisation des connexions et du débit pour améliorer les performances.
+ **Erreurs liées au langage de définition des données (DDL)** 
  + Résolution des erreurs lors de la création, de l'accès ou de la restauration des espaces clés et des tables.
  + Gestion des défaillances liées aux paramètres personnalisés de durée de vie (TTL), aux limites de colonnes et aux suppressions de plages.
  + Considérations relatives aux lourdes charges de travail de suppression. 

Pour obtenir des conseils de résolution des problèmes spécifiques à l'accès IAM, consultez[Résolution des problèmes d'identité et d'accès à Amazon Keyspaces](security_iam_troubleshoot.md). Pour plus d'informations sur les meilleures pratiques en matière de sécurité, consultez[Bonnes pratiques en matière de sécurité pour Amazon Keyspaces](best-practices-security.md).

**Topics**
+ [Erreurs générales](troubleshooting.general.md)
+ [Erreurs de connexion](troubleshooting.connecting.md)
+ [Erreurs liées à la gestion des capacités](troubleshooting.serverless.md)
+ [Erreurs de langage de définition des données](troubleshooting.cql.md)

# Résolution des erreurs générales dans Amazon Keyspaces
<a name="troubleshooting.general"></a>

Vous recevez des erreurs générales ? Voici quelques problèmes courants et comment les résoudre.

## Erreurs générales
<a name="troubleshooting-general"></a>

Vous êtes confronté à l'une des exceptions de premier niveau suivantes, qui peut se produire pour de nombreuses raisons différentes.
+ `NoNodeAvailableException`
+ `NoHostAvailableException`
+ `AllNodesFailedException`

Ces exceptions sont générées par le pilote client et peuvent se produire soit lorsque vous établissez la connexion de contrôle, soit lorsque vous effectuez des read/write/prepare/execute/batch demandes. 

Lorsque l'erreur se produit alors que vous établissez la connexion de contrôle, cela signifie que tous les points de contact spécifiés dans votre application sont inaccessibles. Lorsque l'erreur se produit lors de l'exécution des read/write/prepare/execute requêtes, cela indique que toutes les tentatives pour cette demande ont été épuisées. Chaque nouvelle tentative est tentée sur un nœud différent lorsque vous utilisez la politique de nouvelle tentative par défaut. 

### Comment isoler l'erreur sous-jacente des exceptions du pilote Java de haut niveau
<a name="troubleshooting-general-isolation"></a>

Ces erreurs générales peuvent être causées soit par des problèmes de connexion, soit lors de l'exécution d'read/write/prepare/executeopérations. Des défaillances transitoires sont prévisibles dans les systèmes distribués et doivent être traitées en réessayant la demande. Le pilote Java ne réessaie pas automatiquement en cas d'erreur de connexion. Il est donc recommandé de mettre en œuvre la politique de nouvelle tentative lors de l'établissement de la connexion du pilote dans votre application. Pour un aperçu détaillé des meilleures pratiques en matière de connexion, voir[Optimisation des connexions client-pilote pour l'environnement sans serveur](connections.md).

Par défaut, le pilote Java définit la valeur false `idempotence` pour toutes les demandes, ce qui signifie qu'il ne réessaie pas automatiquement les read/write/prepare demandes qui ont échoué. `idempotence`Pour configurer `true` et demander au pilote de réessayer les demandes ayant échoué, vous pouvez le faire de différentes manières. Voici un exemple de la façon dont vous pouvez définir l'idempotence par programmation pour une seule requête dans votre application Java.

```
Statement s = new SimpleStatement("SELECT * FROM my_table WHERE id = 1");
s.setIdempotent(true);
```

Vous pouvez également définir l'idempotence par défaut pour l'ensemble de votre application Java par programmation, comme indiqué dans l'exemple suivant.

```
// Make all statements idempotent by default:
cluster.getConfiguration().getQueryOptions().setDefaultIdempotence(true);
//Set the default idempotency to true in your Cassandra configuration
basic.request.default-idempotence = true
```

Une autre recommandation consiste à créer une politique de nouvelle tentative au niveau de l'application. Dans ce cas, l'application doit intercepter la demande `NoNodeAvailableException` et réessayer. Nous recommandons 10 tentatives avec un retard exponentiel commençant à 10 ms et allant jusqu'à 100 ms avec un temps total de 1 seconde pour toutes les tentatives.

[Une autre option consiste à appliquer la politique de nouvelles tentatives exponentielles d'Amazon Keyspaces lors de l'établissement de la connexion au pilote Java disponible sur Github.](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers/blob/main/src/main/java/com/aws/ssa/keyspaces/retry/AmazonKeyspacesExponentialRetryPolicy.java)

Vérifiez que vous avez établi des connexions à plusieurs nœuds lorsque vous utilisez la politique de nouvelle tentative par défaut. Vous pouvez le faire à l'aide de la requête suivante dans Amazon Keyspaces.

```
SELECT * FROM system.peers;
```

Si la réponse à cette requête est vide, cela indique que vous travaillez avec un seul nœud pour Amazon Keyspaces. Si vous utilisez la politique de nouvelle tentative par défaut, il n'y aura aucune nouvelle tentative car la nouvelle tentative par défaut a toujours lieu sur un autre nœud. Pour en savoir plus sur l'établissement de connexions via des points de terminaison VPC, consultez. [Comment configurer les connexions via les points de terminaison VPC dans Amazon Keyspaces](connections.md#connections.VPCendpoints)

Pour un step-by-step didacticiel expliquant comment établir une connexion à Amazon Keyspaces à l'aide du pilote Cassandra Datastax 4.x, consultez. [Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java 4.x pour Apache Cassandra et du plugin d'authentification SigV4](using_java_driver.md#java_tutorial.SigV4)

# Résolution des erreurs de connexion dans Amazon Keyspaces
<a name="troubleshooting.connecting"></a>

Vous rencontrez des difficultés pour vous connecter ? Voici quelques problèmes courants et comment les résoudre.

## Erreurs de connexion à un point de terminaison Amazon Keyspaces
<a name="troubleshooting-connecting"></a>

Les échecs de connexion et les erreurs de connexion peuvent entraîner des messages d'erreur différents. La section suivante couvre les scénarios les plus courants. 

**Topics**
+ [Je ne parviens pas à me connecter à Amazon Keyspaces avec cqlsh](#troubleshooting.connection.cqlsh)
+ [Je ne parviens pas à me connecter à Amazon Keyspaces à l'aide d'un pilote client Cassandra](#troubleshooting.connection.driver)

### Je ne parviens pas à me connecter à Amazon Keyspaces avec cqlsh
<a name="troubleshooting.connection.cqlsh"></a>

**Vous essayez de vous connecter à un point de terminaison Amazon Keyspaces à l'aide de cqlsh et la connexion échoue avec un. `Connection error`**

Si vous essayez de vous connecter à une table Amazon Keyspaces et que cqlsh n'est pas correctement configuré, la connexion échoue. La section suivante fournit des exemples des problèmes de configuration les plus courants qui entraînent des erreurs de connexion lorsque vous essayez d'établir une connexion à l'aide de cqlsh.

**Note**  
Si vous essayez de vous connecter à Amazon Keyspaces depuis un VPC, des autorisations supplémentaires sont requises. Pour configurer correctement une connexion à l'aide de points de terminaison VPC, suivez les étapes décrites dans le. [Tutoriel : Connectez-vous à Amazon Keyspaces à l'aide d'un point de terminaison VPC d'interface](vpc-endpoints-tutorial.md) 

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais une erreur de connexion s'affiche. `timed out`**

Cela peut être le cas si vous n'avez pas fourni le port correct, ce qui entraîne l'erreur suivante.

```
#  cqlsh cassandra.us-east-1.amazonaws.com 9140 -u "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.199': error(None, "Tried connecting to [('3.234.248.199', 9140)]. Last error: timed out")})
```

Pour résoudre ce problème, vérifiez que vous utilisez le port 9142 pour la connexion.

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `Name or service not known`**

Cela peut être le cas si vous avez utilisé un point de terminaison mal orthographié ou qui n'existe pas. Dans l'exemple suivant, le nom du point de terminaison est mal orthographié.

```
#  cqlsh cassandra.us-east-1.amazon.com 9142 -u "USERNAME" -p "PASSWORD" --ssl
Traceback (most recent call last):
  File "/usr/bin/cqlsh.py", line 2458, in >module>
    main(*read_options(sys.argv[1:], os.environ))
  File "/usr/bin/cqlsh.py", line 2436, in main
    encoding=options.encoding)
  File "/usr/bin/cqlsh.py", line 484, in __init__
    load_balancing_policy=WhiteListRoundRobinPolicy([self.hostname]),
  File "/usr/share/cassandra/lib/cassandra-driver-internal-only-3.11.0-bb96859b.zip/cassandra-driver-3.11.0-bb96859b/cassandra/policies.py", line 417, in __init__
socket.gaierror: [Errno -2] Name or service not known
```

Pour résoudre ce problème lorsque vous utilisez des points de terminaison publics pour vous connecter, sélectionnez un point de [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md) terminaison disponible et vérifiez que le nom du point de terminaison ne contient aucune erreur. Si vous utilisez des points de terminaison VPC pour vous connecter, vérifiez que les informations du point de terminaison VPC sont correctes dans votre configuration cqlsh.

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `OperationTimedOut`**

Amazon Keyspaces exige que le protocole SSL soit activé pour les connexions afin de garantir une sécurité renforcée. Le paramètre SSL est peut-être absent si le message d'erreur suivant s'affiche.

```
# cqlsh cassandra.us-east-1.amazonaws.com -u "USERNAME" -p "PASSWORD"
Connection error: ('Unable to connect to any servers', {'3.234.248.192': OperationTimedOut('errors=Timed out creating connection (5 seconds), last_host=None',)})
#
```

Pour résoudre ce problème, ajoutez l'indicateur suivant à la commande de connexion cqlsh.

```
--ssl
```

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh et vous recevez un message d'erreur. `SSL transport factory requires a valid certfile to be specified`**

Dans ce cas, le chemin d'accès au SSL/TLS certificat est manquant, ce qui entraîne l'erreur suivante.

```
# cat .cassandra/cqlshrc
[connection]
port = 9142
factory = cqlshlib.ssl.ssl_transport_factory
#


# cqlsh cassandra.us-east-1.amazonaws.com -u "USERNAME" -p "PASSWORD" --ssl
Validation is enabled; SSL transport factory requires a valid certfile to be specified. Please provide path to the certfile in [ssl] section as 'certfile' option in /root/.cassandra/cqlshrc (or use [certfiles] section) or set SSL_CERTFILE environment variable.
#
```

Pour résoudre ce problème, ajoutez le chemin du fichier de certificat sur votre ordinateur. Pour de plus amples informations, veuillez consulter [Comment configurer manuellement les `cqlsh` connexions pour le protocole TLS](programmatic.cqlsh.md#encrypt_using_tls).

```
certfile =  path_to_file/keyspaces-bundle.pem
```

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `No such file or directory`**

Cela peut être le cas si le chemin d'accès au fichier de certificat sur votre ordinateur est incorrect, ce qui entraîne l'erreur suivante.

```
# cat .cassandra/cqlshrc
[connection]
port = 9142
factory = cqlshlib.ssl.ssl_transport_factory

[ssl]
validate = true
certfile = /root/wrong_path/keyspaces-bundle.pem
#



# cqlsh cassandra.us-east-1.amazonaws.com -u "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.192': IOError(2, 'No such file or directory')})
#
```

Pour résoudre ce problème, vérifiez que le chemin d'accès au fichier de certificat sur votre ordinateur est correct. Pour de plus amples informations, veuillez consulter [Comment configurer manuellement les `cqlsh` connexions pour le protocole TLS](programmatic.cqlsh.md#encrypt_using_tls).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `[X509] PEM lib`**

Cela peut être le cas si le `pem` fichier de certificat SSL/TLS n'est pas valide, ce qui entraîne l'erreur suivante.

```
# cqlsh cassandra.us-east-1.amazonaws.com -u "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.241': error(185090057, u"Tried connecting to [('3.234.248.241', 9142)]. Last error: [X509] PEM lib (_ssl.c:3063)")})
#
```

Pour résoudre ce problème, assurez-vous d'avoir téléchargé les certificats numériques requis. Pour de plus amples informations, veuillez consulter [Comment configurer manuellement les `cqlsh` connexions pour le protocole TLS](programmatic.cqlsh.md#encrypt_using_tls).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais vous recevez une erreur SSL. `unknown`**

Cela peut être le cas si le `pem` fichier de certificat SSL/TLS est vide, ce qui entraîne l'erreur suivante.

```
# cqlsh cassandra.us-east-1.amazonaws.com -u "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.220': error(0, u"Tried connecting to [('3.234.248.220', 9142)]. Last error: unknown error (_ssl.c:3063)")})
#
```

Pour résoudre ce problème, assurez-vous d'avoir téléchargé les certificats numériques requis. Vous pouvez le confirmer en suivant les étapes décrites dans la rubrique suivante[Comment configurer manuellement les `cqlsh` connexions pour le protocole TLS](programmatic.cqlsh.md#encrypt_using_tls).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `SSL: CERTIFICATE_VERIFY_FAILED`**

Cela peut être le cas si le fichier de certificat SSL/TLS n'a pas pu être vérifié, ce qui entraîne l'erreur suivante.

```
Connection error: ('Unable to connect to any servers', {'3.234.248.223': error(1, u"Tried connecting to [('3.234.248.223', 9142)]. Last error: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:727)")})
```

Pour résoudre ce problème, assurez-vous d'avoir téléchargé les certificats numériques requis. Vous pouvez le confirmer en suivant les étapes décrites dans la rubrique suivante[Comment configurer manuellement les `cqlsh` connexions pour le protocole TLS](programmatic.cqlsh.md#encrypt_using_tls).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `Last error: timed out`**

Cela peut être le cas si vous n'avez pas configuré de règle sortante pour Amazon Keyspaces dans votre groupe de sécurité Amazon EC2, ce qui entraîne l'erreur suivante.

```
# cqlsh cassandra.us-east-1.amazonaws.com 9142 -u  "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.206': error(None, "Tried connecting to [('3.234.248.206', 9142)]. Last error: timed out")})
#
```

Pour confirmer que ce problème est dû à la configuration de l'instance Amazon EC2 et non`cqlsh`, vous pouvez essayer de vous connecter à votre espace de touches en utilisant, par exemple AWS CLI, la commande suivante.

```
aws keyspaces list-tables --keyspace-name 'my_keyspace'
```

Si cette commande expire également, l'instance Amazon EC2 n'est pas correctement configurée.

Pour vérifier que vous disposez des autorisations suffisantes pour accéder à Amazon Keyspaces, vous pouvez utiliser le AWS CloudShell pour vous connecter à. `cqlsh` Si ces connexions sont établies, vous devez configurer l'instance Amazon EC2.

Pour résoudre ce problème, vérifiez que votre instance Amazon EC2 dispose d'une règle sortante qui autorise le trafic vers Amazon Keyspaces. Si ce n'est pas le cas, vous devez créer un nouveau groupe de sécurité pour l'instance EC2 et ajouter une règle autorisant le trafic sortant vers les ressources Amazon Keyspaces. **Pour mettre à jour la règle de trafic sortant afin d'autoriser le trafic vers Amazon Keyspaces, **choisissez** CQLSH/CASSANDRA dans le menu déroulant Type.** 

Après avoir créé le nouveau groupe de sécurité avec la règle de trafic sortant, vous devez l'ajouter à l'instance. Sélectionnez l'instance, puis sélectionnez **Actions**, **Sécurité**, puis **Modifier les groupes de sécurité**. Ajoutez le nouveau groupe de sécurité avec la règle sortante, mais assurez-vous que le groupe par défaut reste également disponible.

Pour plus d'informations sur la façon d'afficher et de modifier les règles de sortie EC2, consultez la section [Ajouter des règles à un groupe de sécurité dans le guide de l'utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `Unauthorized`**

Cela peut être le cas si vous ne disposez pas des autorisations Amazon Keyspaces dans la politique utilisateur d'IAM, ce qui entraîne l'erreur suivante.

```
# cqlsh cassandra.us-east-1.amazonaws.com 9142 -u  "testuser-at-12345678910" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.241': AuthenticationFailed('Failed to authenticate to 3.234.248.241: Error from server: code=2100 [Unauthorized] message="User arn:aws:iam::12345678910:user/testuser has no permissions."',)})
#
```

Pour résoudre ce problème, assurez-vous que l'utilisateur IAM `testuser-at-12345678910` est autorisé à accéder à Amazon Keyspaces. Pour des exemples de politiques IAM qui accordent l'accès à Amazon Keyspaces, consultez. [Exemples de politiques basées sur l'identité d'Amazon Keyspaces](security_iam_id-based-policy-examples.md)

Pour obtenir des conseils de résolution des problèmes spécifiques à l'accès IAM, consultez[Résolution des problèmes d'identité et d'accès à Amazon Keyspaces](security_iam_troubleshoot.md).

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de cqlsh, mais un message d'erreur s'affiche. `Bad credentials`**

Cela peut être le cas si le nom d'utilisateur ou le mot de passe est incorrect, ce qui entraîne l'erreur suivante.

```
# cqlsh cassandra.us-east-1.amazonaws.com 9142 -u  "USERNAME" -p "PASSWORD" --ssl
Connection error: ('Unable to connect to any servers', {'3.234.248.248': AuthenticationFailed('Failed to authenticate to 3.234.248.248: Error from server: code=0100 [Bad credentials] message="Provided username USERNAME and/or password are incorrect"',)})
#
```

Pour résoudre ce problème, vérifiez que le code *USERNAME* et le mot de passe correspondent *PASSWORD* au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré des informations d'identification [spécifiques au service](programmatic.credentials.ssc.md).

**Important**  
Si vous continuez à voir des erreurs lorsque vous essayez de vous connecter à cqlsh, réexécutez la commande avec l'`--debug`option et incluez le résultat détaillé lors de la prise de contact. Support

### Je ne parviens pas à me connecter à Amazon Keyspaces à l'aide d'un pilote client Cassandra
<a name="troubleshooting.connection.driver"></a>

Les sections suivantes présentent les erreurs les plus courantes lors de la connexion avec un pilote client Cassandra.

**Vous essayez de vous connecter à une table Amazon Keyspaces à l'aide du pilote DataStax Java, mais un message d'`NodeUnavailableException`erreur s'affiche.**

Si la connexion sur laquelle la demande est tentée est interrompue, cela entraîne l'erreur suivante.

```
[com.datastax.oss.driver.api.core.NodeUnavailableException: No connection was available to Node(endPoint=vpce-22ff22f2f22222fff-aa1bb234.cassandra.us-west-2.vpce.amazonaws.com/11.1.1111.222:9142, hostId=1a23456b-c77d-8888-9d99-146cb22d6ef6, hashCode=123ca4567)]
```

Pour résoudre ce problème, trouvez la valeur du rythme cardiaque et abaissez-la à 30 secondes si elle est supérieure.

```
advanced.heartbeat.interval = 30 seconds
```

Recherchez ensuite le délai d'expiration associé et assurez-vous que la valeur est définie sur au moins 5 secondes.

```
advanced.connection.init-query-timeout = 5 seconds
```

**Vous essayez de vous connecter à une table Amazon Keyspaces à l'aide d'un pilote et du plugin SigV4, mais un message d'erreur s'affiche. `AttributeError`**

Si les informations d'identification ne sont pas correctement configurées, l'erreur suivante se produit.

```
cassandra.cluster.NoHostAvailable: (‘Unable to connect to any servers’,
 {‘44.234.22.154:9142’: AttributeError(“‘NoneType’ object has no attribute ‘access_key’“)})
```

Pour résoudre ce problème, vérifiez que vous transmettez les informations d'identification associées à votre utilisateur ou rôle IAM lorsque vous utilisez le plug-in SigV4. Le plug-in SigV4 nécessite les informations d'identification suivantes.
+ `AWS_ACCESS_KEY_ID`— Spécifie une clé d' AWS accès associée à un utilisateur ou à un rôle IAM. 
+ `AWS_SECRET_ACCESS_KEY`— Spécifie la clé secrète associée à la clé d'accès. Il s’agit du « mot de passe » de la clé d’accès.

Pour en savoir plus sur les clés d'accès et le plug-in SigV4, consultez[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).

**Vous essayez de vous connecter à une table Amazon Keyspaces à l'aide d'un pilote, mais un message d'erreur s'affiche. `PartialCredentialsError`**

Si ce `AWS_SECRET_ACCESS_KEY` n'est pas le cas, cela peut entraîner l'erreur suivante.

```
cassandra.cluster.NoHostAvailable: (‘Unable to connect to any servers’, {‘44.234.22.153:9142’: 
 PartialCredentialsError(‘Partial credentials found in config-file, missing: aws_secret_access_key’)})
```

Pour résoudre ce problème, vérifiez que vous passez à la fois le `AWS_ACCESS_KEY_ID` et le `AWS_SECRET_ACCESS_KEY` lorsque vous utilisez le plug-in SigV4. Pour en savoir plus sur les clés d'accès et le plug-in SigV4, consultez[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).

**Vous essayez de vous connecter à une table Amazon Keyspaces à l'aide d'un pilote, mais un message d'`Invalid signature`erreur s'affiche.**

Cela peut être le cas si l'un des composants requis pour la signature est incorrect ou n'est pas correctement défini pour la session.
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`

L'erreur suivante est un exemple de clé d'accès non valide.

```
cassandra.cluster.NoHostAvailable: (‘Unable to connect to any servers’, {‘11.234.11.234:9142’: 
 AuthenticationFailed(‘Failed to authenticate to 11.234.11.234:9142: Error from server: code=0100 
 [Bad credentials] message=“Authentication failure: Invalid signature”’)})
```

Pour résoudre ce problème, vérifiez que les clés d'accès Région AWS ont été correctement configurées pour que le plugin SigV4 puisse accéder à Amazon Keyspaces. Pour en savoir plus sur les clés d'accès et le plug-in SigV4, consultez[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).

#### La connexion de mon point de terminaison VPC ne fonctionne pas correctement
<a name="troubleshooting.connection.vpce"></a>

**Vous essayez de vous connecter à Amazon Keyspaces via des points de terminaison VPC, mais vous recevez des erreurs de mappage de jetons ou vous rencontrez un faible débit.**

Cela peut être le cas si la connexion du point de terminaison VPC n'est pas correctement configurée.

Pour résoudre ces problèmes, vérifiez les détails de configuration suivants. Pour suivre un step-by-step didacticiel afin d'apprendre à configurer une connexion via des points de terminaison VPC d'interface pour Amazon Keyspaces, consultez. [Tutoriel : Connectez-vous à Amazon Keyspaces à l'aide d'un point de terminaison VPC d'interface](vpc-endpoints-tutorial.md)

1. Vérifiez que l'entité IAM utilisée pour se connecter à Amazon Keyspaces read/write a accès à la table utilisateur et dispose d'un accès en lecture aux tables système, comme indiqué dans l'exemple suivant.

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[
         {
            "Effect":"Allow",
            "Action":[
               "cassandra:Select",
               "cassandra:Modify"
            ],
            "Resource":[
               "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
               "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
            ]
         }
      ]
   }
   ```

1. Vérifiez que l'entité IAM utilisée pour se connecter à Amazon Keyspaces dispose des autorisations de lecture requises pour accéder aux informations du point de terminaison VPC sur votre instance Amazon EC2, comme indiqué dans l'exemple suivant.

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[
         {
            "Sid":"ListVPCEndpoints",
            "Effect":"Allow",
            "Action":[
               "ec2:DescribeNetworkInterfaces",
               "ec2:DescribeVpcEndpoints"
            ],
            "Resource":"*"
         }
      ]
   }
   ```
**Note**  
Les politiques gérées `AmazonKeyspacesFullAccess` incluent `AmazonKeyspacesReadOnlyAccess_v2` les autorisations requises pour permettre à Amazon Keyspaces d'accéder à l'instance Amazon EC2 afin de lire les informations sur les points de terminaison VPC d'interface disponibles.

   Pour plus d'informations sur les points de terminaison VPC, voir [Utilisation des points de terminaison VPC d'interface pour Amazon Keyspaces](vpc-endpoints.md#using-interface-vpc-endpoints)

1. Vérifiez que la configuration SSL du pilote Java définit la validation du nom d'hôte sur false, comme indiqué dans cet exemple.

   ```
   hostname-validation = false
   ```

   Pour plus d'informations sur la configuration du pilote, consultez[Étape 2 : Configuration du pilote](using_java_driver.md#java_tutorial.driverconfiguration).

1. Pour confirmer que le point de terminaison du VPC a été correctement configuré, vous pouvez exécuter l'instruction suivante depuis votre *VPC*.
**Note**  
Vous ne pouvez pas utiliser votre environnement de développement local ou l'éditeur CQL d'Amazon Keyspaces pour confirmer cette configuration, car ils utilisent le point de terminaison public.

   ```
   SELECT peer FROM system.peers;
   ```

   La sortie doit ressembler à cet exemple et renvoyer entre 2 et 6 nœuds avec des IPv4 adresses privées lors de la connexion depuis un IPv4 réseau, en fonction de la configuration et AWS de la région de votre VPC.

   ```
   peer
   ---------------
    192.0.2.0.15
    192.0.2.0.24
    192.0.2.0.13
    192.0.2.0.7
    192.0.2.0.8
   
   (5 rows)
   ```

#### Je ne parviens pas à me connecter en utilisant `cassandra-stress`
<a name="troubleshooting.connection.cassandra-stress"></a>

**Vous essayez de vous connecter à Amazon Keyspaces à l'aide de la `cassandra-stress` commande, mais un `SSL context` message d'erreur s'affiche.**

Cela se produit si vous essayez de vous connecter à Amazon Keyspaces, mais que le TrustStore n'est pas correctement configuré. Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients.

Dans ce cas, le message d'erreur suivant s'affiche.

```
Error creating the initializing the SSL Context
```

Pour résoudre ce problème, suivez les instructions pour configurer un TrustStore comme indiqué dans cette rubrique[Avant de commencer](using_java_driver.md#using_java_driver.BeforeYouBegin).

Une fois le TrustStore configuré, vous devriez pouvoir vous connecter à l'aide de la commande suivante.

```
./cassandra-stress user profile=./profile.yaml n=100 "ops(insert=1,select=1)" cl=LOCAL_QUORUM -node "cassandra.eu-north-1.amazonaws.com" -port native=9142 -transport ssl-alg="PKIX" truststore="./cassandra_truststore.jks" truststore-password="trustStore_pw" -mode native cql3 user="user_name" password="password"
```

#### Je ne parviens pas à me connecter à l'aide des identités IAM
<a name="troubleshooting.connection.IAM"></a>

**Vous essayez de vous connecter à une table Amazon Keyspaces à l'aide d'une identité IAM, mais vous recevez un message d'erreur. `Unauthorized`**

Cela se produit si vous essayez de vous connecter à une table Amazon Keyspaces en utilisant une identité IAM (par exemple, un utilisateur IAM) sans mettre en œuvre la politique et sans donner au préalable à l'utilisateur les autorisations requises. 

Dans ce cas, le message d'erreur suivant s'affiche.

```
Connection error: ('Unable to connect to any servers', {'3.234.248.202': AuthenticationFailed('Failed to authenticate to 3.234.248.202: 
Error from server: code=2100 [Unauthorized] message="User arn:aws:iam::1234567890123:user/testuser has no permissions."',)})
```

Pour résoudre ce problème, vérifiez les autorisations de l'utilisateur IAM. Pour se connecter à un pilote standard, l'utilisateur doit au moins avoir `SELECT` accès aux tables du système, car la plupart des pilotes lisent le système keyspaces/tables lorsqu'ils établissent la connexion. 

Par exemple, les politiques IAM qui accordent l'accès au système Amazon Keyspaces et aux tables utilisateur, voir. [Accès aux tables Amazon Keyspaces](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table)

Pour consulter la section de résolution des problèmes spécifique à IAM, consultez[Résolution des problèmes d'identité et d'accès à Amazon Keyspaces](security_iam_troubleshoot.md).

#### J'essaie d'importer des données avec cqlsh et la connexion à ma table Amazon Keyspaces est perdue
<a name="troubleshooting.connection.import"></a>

**Vous essayez de télécharger des données sur Amazon Keyspaces avec cqlsh, mais vous recevez des erreurs de connexion.**

La connexion à Amazon Keyspaces échoue lorsque le client cqlsh a reçu trois erreurs consécutives de tout type de la part du serveur. Le client cqlsh échoue avec le message suivant. 

```
Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100
```

Pour résoudre cette erreur, vous devez vous assurer que les données à importer correspondent au schéma de table dans Amazon Keyspaces. Vérifiez le fichier d'importation pour détecter les erreurs d'analyse. Vous pouvez essayer d'utiliser une seule ligne de données en utilisant une instruction INSERT pour isoler l'erreur.

Le client tente automatiquement de rétablir la connexion.

# Résolution des erreurs de gestion des capacités dans Amazon Keyspaces
<a name="troubleshooting.serverless"></a>

Vous rencontrez des problèmes avec la capacité sans serveur ? Voici quelques problèmes courants et comment les résoudre.

## Erreurs de capacité sans serveur
<a name="troubleshooting-serverless"></a>

Cette section explique comment reconnaître les erreurs liées à la gestion des capacités sans serveur et comment les résoudre. Par exemple, vous pouvez observer des événements de capacité insuffisante lorsque votre application dépasse la capacité de débit allouée. 

Apache Cassandra étant un logiciel basé sur des clusters conçu pour fonctionner sur un parc de nœuds, il ne contient aucun message d'exception lié aux fonctionnalités sans serveur telles que la capacité de débit. La plupart des pilotes ne comprennent que les codes d'erreur disponibles dans Apache Cassandra. Amazon Keyspaces utilise donc le même ensemble de codes d'erreur pour garantir la compatibilité. 

Pour associer les erreurs de Cassandra aux événements de capacité sous-jacents, vous pouvez utiliser Amazon CloudWatch pour surveiller les indicateurs Amazon Keyspaces pertinents. Les événements d'insuffisance de capacité qui entraînent des erreurs côté client peuvent être classés dans les trois groupes suivants en fonction de la ressource à l'origine de l'événement : 
+ **Tableau** — Si vous choisissez le mode Capacité **allouée** pour une table et que votre application dépasse le débit alloué, vous pouvez observer des erreurs de capacité insuffisante. Pour de plus amples informations, veuillez consulter [Configurer les modes de read/write capacité dans Amazon Keyspaces](ReadWriteCapacityMode.md).
+ **Partition** — Vous pouvez rencontrer des événements de capacité insuffisante si le trafic sur une partition donnée dépasse 3 000 ou 1 000 RCUs . WCUs Nous recommandons de répartir le trafic de manière uniforme sur les partitions comme meilleure pratique. Pour de plus amples informations, veuillez consulter [Bonnes pratiques de modélisation des données : recommandations pour la conception de modèles de données](data-modeling.md).
+ **Connexion** : le débit risque d'être insuffisant si vous dépassez le quota du nombre maximal d'opérations par seconde et par connexion. Pour augmenter le débit, vous pouvez augmenter le nombre de connexions par défaut lors de la configuration de la connexion avec le pilote.

  Pour savoir comment configurer les connexions pour Amazon Keyspaces, consultez. [Comment configurer les connexions dans Amazon Keyspaces](connections.md#connections.howtoconfigure) Pour plus d'informations sur l'optimisation des connexions via les points de terminaison VPC, consultez. [Comment configurer les connexions via les points de terminaison VPC dans Amazon Keyspaces](connections.md#connections.VPCendpoints)

Pour déterminer quelle ressource est à l'origine de l'événement de capacité insuffisante qui renvoie l'erreur côté client, vous pouvez consulter le tableau de bord dans la console Amazon Keyspaces. Par défaut, la console fournit une vue agrégée des CloudWatch mesures relatives à la capacité et au trafic les plus courantes dans la section **Capacité et mesures associées** de l'onglet **Capacité** du tableau. 

Pour créer votre propre tableau de bord à l'aide d'Amazon CloudWatch, consultez les statistiques Amazon Keyspaces suivantes. 
+ `PerConnectionRequestRateExceeded`— Demandes adressées à Amazon Keyspaces qui dépassent le quota du taux de demandes par connexion. Chaque connexion client à Amazon Keyspaces peut prendre en charge jusqu’à 3 000 demandes CQL par seconde. Vous pouvez effectuer plus de 3 000 demandes par seconde en créant plusieurs connexions.
+ `ReadThrottleEvents`— Demandes adressées à Amazon Keyspaces qui dépassent la capacité de lecture d'une table.
+ `StoragePartitionThroughputCapacityExceeded`— Demandes adressées à une partition de stockage Amazon Keyspaces qui dépassent la capacité de débit de la partition. Les partitions de stockage Amazon Keyspaces peuvent supporter jusqu'à 1 000 WCU/WRU par seconde et 3 000 RCU/RRU par seconde. Pour atténuer ces exceptions, nous vous recommandons de revoir votre modèle de données afin de répartir le read/write trafic sur un plus grand nombre de partitions.
+ `WriteThrottleEvents`— Demandes adressées à Amazon Keyspaces qui dépassent la capacité d'écriture d'une table.

Pour en savoir plus CloudWatch, consultez[Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md). Pour obtenir la liste de toutes les CloudWatch statistiques disponibles pour Amazon Keyspaces, consultez. [Statistiques et dimensions d'Amazon Keyspaces](metrics-dimensions.md) 

**Note**  
[Pour commencer à utiliser un tableau de bord personnalisé qui affiche toutes les statistiques fréquemment observées pour Amazon Keyspaces, vous pouvez utiliser un CloudWatch modèle prédéfini disponible GitHub dans le AWS référentiel d'exemples.](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates)

**Topics**
+ [Erreurs côté du client](#troubleshooting.serverless.clientside)
+ [Erreurs de délai d'écriture lors de l'importation des données](#troubleshooting.serverless.writetimeout)
+ [Taille de rangement du keyspace ou de la table](#troubleshooting.serverless.storagesize)

### Je reçois des erreurs de capacité `NoHostAvailable` insuffisante de la part de mon pilote client
<a name="troubleshooting.serverless.clientside"></a>

**Vous voyez `Read_Timeout` des `Write_Timeout` exceptions pour une table.**

Les tentatives répétées d'écriture ou de lecture dans une table Amazon Keyspaces dont la capacité est insuffisante peuvent entraîner des erreurs côté client spécifiques au pilote.

 CloudWatch À utiliser pour surveiller vos indicateurs de débit provisionnés et réels, ainsi que les événements de capacité insuffisante pour le tableau. 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. Pour plus d’informations sur ces métriques, consultez [Statistiques et dimensions d'Amazon Keyspaces](metrics-dimensions.md).

Pour résoudre ces problèmes, envisagez l'une des options suivantes.
+ Augmentez le *débit provisionné* pour la table, qui correspond à la capacité de débit maximale qu'une application peut consommer. Pour de plus amples informations, veuillez consulter [Unités de capacité en lecture et unités de capacité en écriture](ReadWriteCapacityMode.Provisioned.md#ReadWriteCapacityMode.Provisioned.Units).
+ Laissez le service gérer la capacité de débit en votre nom grâce à la mise à l'échelle automatique. Pour de plus amples informations, veuillez consulter [Gérez automatiquement la capacité de débit grâce au dimensionnement automatique d'Amazon Keyspaces](autoscaling.md).
+ Choisissez le mode de capacité **à la demande** pour le tableau. Pour de plus amples informations, veuillez consulter [Configuration du mode capacité à la demande](ReadWriteCapacityMode.OnDemand.md).

Si vous devez augmenter le quota de capacité par défaut de votre compte, consultez[Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).

**Des erreurs liées au dépassement de la capacité de partition s'affichent.**

Lorsque le message d'erreur s'affiche, `StoragePartitionThroughputCapacityExceeded` la capacité de la partition est temporairement dépassée. Cela peut être géré automatiquement par la capacité adaptative ou la capacité à la demande. Nous vous recommandons de revoir votre modèle de données afin de répartir read/write le trafic sur un plus grand nombre de partitions afin d'atténuer ces erreurs. Les partitions de stockage Amazon Keyspaces peuvent supporter jusqu'à 1 000 WCU/WRU par seconde et 3 000 RCU/RRU par seconde. Pour en savoir plus sur la manière d'améliorer votre modèle de données afin de répartir le read/write trafic sur un plus grand nombre de partitions, consultez[Bonnes pratiques de modélisation des données : recommandations pour la conception de modèles de données](data-modeling.md).

`Write_Timeout`les exceptions peuvent également être causées par un taux élevé d'opérations d'écriture simultanées qui incluent des données statiques et non statiques dans la même partition logique. Si le trafic est censé exécuter plusieurs opérations d'écriture simultanées incluant des données statiques et non statiques au sein de la même partition logique, nous recommandons d'écrire les données statiques et non statiques séparément. L'écriture séparée des données permet également d'optimiser les coûts de débit.

**Vous constatez des erreurs liées au dépassement du taux de demandes de connexion.**

Cela est `PerConnectionRequestRateExceeded` dû à l'une des causes suivantes.
+ Il se peut que le nombre de connexions configurées par session ne soit pas suffisant.
+ Il se peut que vous obteniez moins de connexions que vos homologues disponibles, car les autorisations de point de terminaison VPC ne sont pas correctement configurées. Pour plus d'informations sur les politiques relatives aux points de terminaison VPC, consultez. [Utilisation des points de terminaison VPC d'interface pour Amazon Keyspaces](vpc-endpoints.md#using-interface-vpc-endpoints)
+ Si vous utilisez un pilote 4.x, vérifiez si la validation du nom d'hôte est activée. Le pilote active la vérification du nom d'hôte TLS par défaut. Cette configuration fait apparaître Amazon Keyspaces sous la forme d'un cluster à nœud unique pour le pilote. Nous vous recommandons de désactiver la vérification du nom d'hôte.

Nous vous recommandons de suivre les meilleures pratiques suivantes pour optimiser vos connexions et votre débit :
+ **Configurez le réglage du débit des requêtes CQL.**

  Amazon Keyspaces prend en charge jusqu'à 3 000 requêtes CQL par connexion TCP et par seconde, mais le nombre de connexions qu'un pilote peut établir est illimité. 

  La plupart des pilotes Cassandra open source établissent un pool de connexions avec Cassandra et équilibrent la charge des requêtes sur ce pool de connexions. Amazon Keyspaces expose 9 adresses IP homologues aux conducteurs. Le comportement par défaut de la plupart des pilotes consiste à établir une connexion unique à chaque adresse IP homologue. Par conséquent, le débit maximal de requêtes CQL d'un pilote utilisant les paramètres par défaut sera de 27 000 requêtes CQL par seconde. 

  Pour augmenter ce nombre, nous vous recommandons d'augmenter le nombre de connexions par adresse IP que votre pilote gère dans son pool de connexions. Par exemple, si vous définissez le nombre maximum de connexions par adresse IP sur 2, vous doublerez le débit maximal de votre pilote pour le porter à 54 000 requêtes CQL par seconde. 
+ **Optimisez vos connexions à nœud unique.**

  Par défaut, la plupart des pilotes Cassandra open source établissent une ou plusieurs connexions à chaque adresse IP indiquée dans le `system.peers` tableau lors de l'établissement d'une session. Cependant, certaines configurations peuvent conduire un pilote à se connecter à une seule adresse IP Amazon Keyspaces. Cela peut se produire si le pilote tente de valider le nom d'hôte SSL des nœuds homologues (par exemple, les pilotes DataStax Java) ou lorsqu'il se connecte via un point de terminaison VPC.

  Pour bénéficier de la même disponibilité et des mêmes performances qu'un pilote connecté à plusieurs adresses IP, nous vous recommandons de procéder comme suit :
  + Augmentez le nombre de connexions par IP à 9 ou plus en fonction du débit client souhaité.
  + Créez une politique de nouvelles tentatives personnalisée qui garantit que les nouvelles tentatives sont exécutées sur le même nœud. Pour plus d’informations, veuillez consulter la rubrique 

    [Comment configurer la politique de nouvelles tentatives pour les connexions dans Amazon Keyspaces](connections.md#connections.retry-policies).
  + Si vous utilisez des points de terminaison VPC, accordez à l'entité IAM utilisée pour se connecter à Amazon Keyspaces l'autorisation d'interroger votre VPC pour obtenir les informations relatives au point de terminaison et à l'interface réseau. Cela améliore l'équilibrage de charge et augmente read/write le débit. Pour de plus amples informations, veuillez consulter [Remplissage des entrées de `system.peers` table avec les informations de point de terminaison VPC de l'interface](vpc-endpoints.md#system_peers). 

### Je reçois des erreurs de délai d'écriture lors de l'importation des données
<a name="troubleshooting.serverless.writetimeout"></a>

**Vous recevez une erreur de temporisation lorsque vous chargez des données à l'aide de la `cqlsh` `COPY` commande.**

```
Failed to import 1 rows: WriteTimeout - Error from server: code=1100 [Coordinator node timed out waiting for replica nodes' responses]
 message="Operation timed out - received only 0 responses." info={'received_responses': 0, 'required_responses': 2, 'write_type': 'SIMPLE', 'consistency': 
 'LOCAL_QUORUM'}, will retry later, attempt 1 of 100
```

Amazon Keyspaces utilise les `WriteTimeout` exceptions `ReadTimeout` et pour indiquer lorsqu'une demande d'écriture échoue en raison d'une capacité de débit insuffisante. Pour aider à diagnostiquer les exceptions de capacité insuffisante, Amazon Keyspaces publie les statistiques suivantes sur Amazon. CloudWatch
+ `WriteThrottleEvents`
+ `ReadThrottledEvents`
+ `StoragePartitionThroughputCapacityExceeded`

Pour résoudre les erreurs liées à une capacité insuffisante lors du chargement de données, réduisez le taux d'écriture par travailleur ou le taux d'ingestion total, puis réessayez de télécharger les lignes. Pour de plus amples informations, veuillez consulter [Étape 4 : Configuration des `cqlsh COPY FROM` paramètres](bulk-upload-config.md). Pour une option de téléchargement de données plus robuste, pensez à utiliser DSBulk, qui est disponible dans le [GitHub référentiel](https://github.com/datastax/dsbulk). Pour step-by-step obtenir des instructions, voir[Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de DSBulk](dsbulk-upload.md).

### Je ne vois pas la taille de stockage réelle d'un keyspace ou d'une table
<a name="troubleshooting.serverless.storagesize"></a>

**Vous ne pouvez pas voir la taille de stockage réelle du keyspace ou de la table.**

Pour en savoir plus sur la taille de rangement de votre table, consultez[Évaluer les coûts au niveau de la table](CostOptimization_TableLevelCostAnalysis.md). Vous pouvez également estimer la taille de stockage en commençant par calculer la taille des lignes dans un tableau. Des instructions détaillées pour le calcul de la taille des lignes sont disponibles sur[Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md).

# Résolution des erreurs linguistiques liées à la définition des données dans Amazon Keyspaces
<a name="troubleshooting.cql"></a>

Vous rencontrez des difficultés pour créer des ressources ? Voici quelques problèmes courants et comment les résoudre.

## Erreurs de langage de définition des données
<a name="troubleshooting-cql"></a>

Amazon Keyspaces exécute des opérations de langage de définition de données (DDL) de manière asynchrone, par exemple en créant et en supprimant des espaces clés et des tables. Si une application essaie d'utiliser la ressource avant qu'elle ne soit prête, l'opération échoue.

Vous pouvez surveiller l'état de création de nouveaux espaces de touches et de nouvelles tables dans le AWS Management Console, ce qui indique lorsqu'un espace de touches ou une table est en attente ou actif. Vous pouvez également surveiller l'état de création d'un nouvel espace de touches ou d'une nouvelle table par programmation en interrogeant la table du schéma du système. Un espace de touches ou une table devient visible dans le schéma du système lorsqu'il est prêt à être utilisé. 

**Note**  
Pour optimiser la création d'espaces clés à l'aide de cet utilitaire CloudFormation, vous pouvez utiliser cet utilitaire pour convertir des scripts CQL en CloudFormation modèles. L'outil est disponible dans le [GitHub référentiel](https://github.com/aws/amazon-keyspaces-cql-to-cfn-converter).

**Topics**
+ [Erreurs de création de Keyspace](#troubleshooting.cql.keyspace)
+ [Erreurs de création de table](#troubleshooting.cql.table)
+ [J'essaie de restaurer une table en utilisant Amazon Keyspaces point-in-time Recovery (PITR), mais la restauration échoue](#troubleshooting.cql.pitr)
+ [J'essaie de l'utiliser INSERT/UPDATE pour modifier les paramètres personnalisés Time to Live (TTL), mais l'opération échoue](#troubleshooting.cql.ttl)
+ [Colonnes dépassées](#troubleshooting.cql.upload)
+ [Erreur de suppression de plage](#troubleshooting.cql.rangedelete)

### J'ai créé un nouvel espace de touches, mais je ne parviens pas à le voir ou à y accéder
<a name="troubleshooting.cql.keyspace"></a>

**Vous recevez des erreurs de la part de votre application qui tente d'accéder à un nouvel espace de touches.**

Si vous essayez d'accéder à un espace de touches Amazon Keyspaces récemment créé mais toujours en cours de création asynchrone, vous recevrez un message d'erreur. L'erreur suivante en est un exemple.

```
InvalidRequest: Error from server: code=2200 [Invalid query] message="unconfigured keyspace mykeyspace"
```

Le modèle de conception recommandé pour vérifier qu'un nouvel espace de touches est prêt à être utilisé consiste à interroger les tables de schéma du système Amazon Keyspaces (system\$1schema\$1mcs.\$1). 

Pour de plus amples informations, veuillez consulter [Vérifiez le statut de création des espaces de touches dans Amazon Keyspaces](keyspaces-create.md).

### J'ai créé une nouvelle table, mais je ne parviens pas à la consulter ou à y accéder
<a name="troubleshooting.cql.table"></a>

**Vous recevez des erreurs de la part de votre application qui tente d'accéder à une nouvelle table.**

Si vous essayez d'accéder à une table Amazon Keyspaces récemment créée mais toujours en cours de création asynchrone, vous recevrez un message d'erreur. Par exemple, une tentative d'interrogation d'une table qui n'est pas encore disponible échoue avec une `unconfigured table` erreur. 

```
InvalidRequest: Error from server: code=2200 [Invalid query] message="unconfigured table mykeyspace.mytable"
```

La tentative d'affichage de la table avec `sync_table()` échoue avec un`KeyError`.

```
KeyError: 'mytable'
```

Le modèle de conception recommandé pour vérifier qu'une nouvelle table est prête à être utilisée consiste à interroger les tables du schéma du système Amazon Keyspaces (system\$1schema\$1mcs.\$1). 

Il s'agit de l'exemple de sortie d'une table en cours de création.

```
user-at-123@cqlsh:system_schema_mcs> select table_name,status from system_schema_mcs.tables where keyspace_name='example_keyspace' and table_name='example_table';

table_name | status

------------+----------

example_table | CREATING

(1 rows)
```

Il s'agit de l'exemple de sortie d'une table active.

```
user-at-123@cqlsh:system_schema_mcs> select table_name,status from system_schema_mcs.tables where keyspace_name='example_keyspace' and table_name='example_table';

table_name | status

------------+----------

example_table | ACTIVE

(1 rows)
```

Pour de plus amples informations, veuillez consulter [Vérifiez l'état de création des tables dans Amazon Keyspaces](tables-create.md).

### J'essaie de restaurer une table en utilisant Amazon Keyspaces point-in-time Recovery (PITR), mais la restauration échoue
<a name="troubleshooting.cql.pitr"></a>

Si vous essayez de restaurer une table Amazon Keyspaces avec point-in-time restauration (PITR) et que le processus de restauration commence mais ne se termine pas correctement, vous n'avez peut-être pas configuré toutes les autorisations requises pour le processus de restauration pour cette table en particulier. 

Outre les autorisations des utilisateurs, Amazon Keyspaces peut avoir besoin d'autorisations pour effectuer des actions au nom de votre principal pendant le processus de restauration. C'est le cas si la table est chiffrée à l'aide d'une clé gérée par le client ou si vous utilisez des politiques IAM qui limitent le trafic entrant. 

Par exemple, si vous utilisez des clés de condition dans votre politique IAM pour restreindre le trafic source à des points de terminaison ou à des plages d'adresses IP spécifiques, l'opération de restauration échoue. Pour permettre à Amazon Keyspaces d'effectuer l'opération de restauration des tables pour le compte de votre principal, vous devez ajouter une clé de condition `aws:ViaAWSService` globale dans la politique IAM.

Pour plus d'informations sur les autorisations de restauration de tables, consultez[Configurer les autorisations IAM de la table de restauration pour Amazon Keyspaces PITR](howitworks_restore_permissions.md).

### J'essaie de l'utiliser INSERT/UPDATE pour modifier les paramètres personnalisés Time to Live (TTL), mais l'opération échoue
<a name="troubleshooting.cql.ttl"></a>

Si vous essayez d'insérer ou de mettre à jour une valeur TTL personnalisée, l'opération risque d'échouer avec l'erreur suivante. 

```
TTL is not yet supported.
```

Pour spécifier des valeurs TTL personnalisées pour les lignes ou les colonnes à l'aide `UPDATE` des opérations `INSERT` OR, vous devez d'abord activer le TTL pour la table. Vous pouvez activer le TTL pour un tableau à l'aide de la propriété `ttl` personnalisée.

Pour plus d'informations sur l'activation des paramètres TTL personnalisés pour les tables, consultez[Mettre à jour le tableau avec Time to Live (TTL) personnalisé](TTL-how-to-enable-custom-alter.md).

### J'essaie de télécharger des données dans ma table Amazon Keyspaces et je reçois un message d'erreur indiquant que le nombre de colonnes est dépassé
<a name="troubleshooting.cql.upload"></a>

**Vous téléchargez des données et vous avez dépassé le nombre de colonnes pouvant être mises à jour simultanément.**

Cette erreur se produit lorsque le schéma de votre table dépasse la taille maximale de 350 Ko. Pour de plus amples informations, veuillez consulter [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).

### J'essaie de supprimer des données de ma table Amazon Keyspaces et la suppression échoue pour la plage
<a name="troubleshooting.cql.rangedelete"></a>

**Vous essayez de supprimer des données par clé de partition et vous recevez un message d'erreur de suppression de plage.**

Cette erreur se produit lorsque vous essayez de supprimer plus de 1 000 lignes en une seule opération de suppression. 

```
Range delete requests are limited by the amount of items that can be deleted in a single range.
```

Pour de plus amples informations, veuillez consulter [Supprimer une plage](functional-differences.md#functional-differences.range-delete).

Pour supprimer plus de 1 000 lignes au sein d'une même partition, considérez les options suivantes.
+ Supprimer par partition — Si la majorité des partitions comportent moins de 1 000 lignes, vous pouvez essayer de supprimer les données par partition. Si les partitions contiennent plus de 1 000 lignes, essayez plutôt de les supprimer par la colonne de clustering.
+ Supprimer par colonne de clustering : si votre modèle contient plusieurs colonnes de clustering, vous pouvez utiliser la hiérarchie des colonnes pour supprimer plusieurs lignes. Les colonnes de clustering sont une structure imbriquée et vous pouvez supprimer de nombreuses lignes en agissant sur la colonne de niveau supérieur.
+ Supprimer par ligne individuelle — Vous pouvez parcourir les lignes par itération et supprimer chaque ligne à l'aide de sa clé primaire complète (colonnes de partition et colonnes de clustering).
+ Il est recommandé de diviser vos lignes sur des partitions. Dans Amazon Keyspaces, nous vous recommandons de répartir votre débit sur des partitions de table. Cela répartit les données et l'accès de manière uniforme sur les ressources physiques, ce qui permet d'obtenir le meilleur débit. Pour de plus amples informations, veuillez consulter [Bonnes pratiques de modélisation des données : recommandations pour la conception de modèles de données](data-modeling.md).

Tenez également compte des recommandations suivantes lorsque vous planifiez des opérations de suppression pour des charges de travail importantes.
+ Avec Amazon Keyspaces, les partitions peuvent contenir un nombre de lignes pratiquement illimité. Cela vous permet de dimensionner des partitions « plus larges » que le guide Cassandra traditionnel de 100 Mo. Il n'est pas rare que les séries chronologiques ou les registres augmentent de plus d'un gigaoctet de données au fil du temps.
+ Avec Amazon Keyspaces, il n'y a aucune stratégie de compactage ni aucune pierre angulaire à prendre en compte lorsque vous devez effectuer des opérations de suppression pour des charges de travail importantes. Vous pouvez supprimer autant de données que vous le souhaitez sans affecter les performances de lecture.