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.
# Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de cqlsh
Ce didacticiel vous guide tout au long du processus de migration des données d'Apache Cassandra vers Amazon Keyspaces à l'aide de la commande. `cqlsh COPY FROM` La `cqlsh COPY FROM` commande est utile pour télécharger rapidement et facilement de petits ensembles de données sur Amazon Keyspaces à des fins académiques ou de test. Pour plus d'informations sur la façon de migrer les charges de travail de production, consultez[Processus de migration hors ligne : Apache Cassandra vers Amazon Keyspaces](migrating-offline.md). Dans ce didacticiel, vous allez effectuer les étapes suivantes :
Conditions préalables : configurez un AWS compte avec des informations d'identification, créez un fichier JKS Trust Store pour le certificat et configurez-le pour vous connecter `cqlsh` à Amazon Keyspaces.
1. **Créer un fichier CSV source et une table cible** : préparez un fichier CSV en tant que données source et créez le keyspace et le tableau cibles dans Amazon Keyspaces.
1. **Préparation des données** : répartissez les données du fichier CSV de manière aléatoire et analysez-les pour déterminer les tailles de ligne moyennes et maximales.
1. **Définissez la capacité de débit** : calculez les unités de capacité d'écriture requises (WCUs) en fonction de la taille des données et du temps de chargement souhaité, puis configurez la capacité allouée à la table.
1. **Configurer les paramètres cqlsh** : déterminez les valeurs optimales pour des `cqlsh COPY FROM` paramètres tels que`INGESTRATE`, `NUMPROCESSES``MAXBATCHSIZE`, et pour répartir la charge `CHUNKSIZE` de travail de manière uniforme.
1. **Exécuter la `cqlsh COPY FROM` commande** : exécutez la `cqlsh COPY FROM` commande pour télécharger les données du fichier CSV vers le tableau Amazon Keyspaces et suivre la progression.
Dépannage — Résolvez les problèmes courants tels que les demandes non valides, les erreurs d'analyseur, les erreurs de capacité et les erreurs cqlsh lors du processus de téléchargement des données.
**Topics**
+ [Conditions préalables : étapes à suivre avant de pouvoir télécharger des données à l'aide de `cqlsh COPY FROM`](bulk-upload-prequs.md)
+ [Étape 1 : Création du fichier CSV source et d'une table cible pour le téléchargement des données](bulk-upload-source.md)
+ [Étape 2 : Préparation des données sources pour un téléchargement de données réussi](bulk-upload-prepare-data.md)
+ [Étape 3 : définir la capacité de débit de la table](bulk-upload-capacity.md)
+ [Étape 4 : Configuration des `cqlsh COPY FROM` paramètres](bulk-upload-config.md)
+ [Étape 5 : Exécuter la `cqlsh COPY FROM` commande pour télécharger les données du fichier CSV vers la table cible](bulk-upload-run.md)
+ [Résolution des problèmes](bulk-upload-troubleshooting.md)
# Conditions préalables : étapes à suivre avant de pouvoir télécharger des données à l'aide de `cqlsh COPY FROM`
Vous devez effectuer les tâches suivantes avant de pouvoir commencer ce didacticiel.
1. Si ce n'est pas déjà fait, inscrivez-vous Compte AWS en suivant les étapes indiquées sur[Con Gestion des identités et des accès AWS figuration](accessing.md#SettingUp.IAM).
1. Créez des informations d'identification spécifiques au service en suivant les étapes décrites dans. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Configurez la connexion au shell Cassandra Query Language (cqlsh) et confirmez que vous pouvez vous connecter à Amazon Keyspaces en suivant les étapes indiquées sur. [Utilisation `cqlsh` pour se connecter à Amazon Keyspaces](programmatic.cqlsh.md)
# Étape 1 : Création du fichier CSV source et d'une table cible pour le téléchargement des données
Pour ce didacticiel, nous utilisons un fichier de valeurs séparées par des virgules (CSV) dont le `keyspaces_sample_table.csv` nom est le fichier source pour la migration des données. Le fichier d'exemple fourni contient quelques lignes de données pour une table portant le nom`book_awards`.
1. Créez le fichier source. Vous pouvez choisir l’une des options suivantes :
+ Téléchargez l'exemple de fichier CSV (`keyspaces_sample_table.csv`) contenu dans le fichier d'archive [samplemigration.zip](samples/samplemigration.zip) suivant. Décompressez l'archive et notez le chemin vers`keyspaces_sample_table.csv`.
+ Pour remplir un fichier CSV avec vos propres données stockées dans une base de données Apache Cassandra, vous pouvez remplir le fichier CSV source à l'aide de l'`cqlsh``COPY TO`instruction illustrée dans l'exemple suivant.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true";
```
Assurez-vous que le fichier CSV que vous créez répond aux exigences suivantes :
+ La première ligne contient les noms des colonnes.
+ Les noms des colonnes du fichier CSV source correspondent aux noms des colonnes de la table cible.
+ Les données sont délimitées par une virgule.
+ Toutes les valeurs de données sont des types de données Amazon Keyspaces valides. Consultez [Types de données](cql.elements.md#cql.data-types).
1. Créez le keyspace et le tableau cibles dans Amazon Keyspaces.
1. Connectez-vous à Amazon Keyspaces en utilisant`cqlsh`, en remplaçant le point de terminaison du service, le nom d'utilisateur et le mot de passe dans l'exemple suivant par vos propres valeurs.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Créez un nouvel espace de touches avec le `catalog` nom indiqué dans l'exemple suivant.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Lorsque le nouvel espace de touches est disponible, utilisez le code suivant pour créer la table `book_awards` cible.
```
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)
);
```
Si Apache Cassandra est votre source de données d'origine, un moyen simple de créer la table cible Amazon Keyspaces avec les en-têtes correspondants consiste à générer `CREATE TABLE` l'instruction à partir de la table source, comme indiqué dans l'instruction suivante.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
Créez ensuite la table cible dans Amazon Keyspaces avec les noms des colonnes et les types de données correspondant à la description de la table source de Cassandra.
# Étape 2 : Préparation des données sources pour un téléchargement de données réussi
La préparation des données sources pour un transfert efficace est un processus en deux étapes. Tout d'abord, vous répartissez les données de manière aléatoire. Au cours de la deuxième étape, vous analysez les données pour déterminer les valeurs de `cqlsh` paramètres appropriées et les paramètres de table requis afin de garantir le succès du téléchargement des données.
**Randomiser les données**
La `cqlsh COPY FROM` commande lit et écrit les données dans l'ordre dans lequel elles apparaissent dans le fichier CSV. Si vous utilisez la `cqlsh COPY TO` commande pour créer le fichier source, les données sont écrites dans un ordre trié par clé dans le fichier CSV. En interne, Amazon Keyspaces partitionne les données à l'aide de clés de partition. Bien qu'Amazon Keyspaces intègre une logique permettant d'équilibrer la charge des demandes pour la même clé de partition, le chargement des données est plus rapide et plus efficace si vous répartissez la commande de manière aléatoire. En effet, vous pouvez tirer parti de l'équilibrage de charge intégré qui se produit lorsque Amazon Keyspaces écrit sur différentes partitions.
Pour répartir uniformément les écritures sur les partitions, vous devez répartir les données de manière aléatoire dans le fichier source. Vous pouvez écrire une application pour cela ou utiliser un outil open source, tel que [Shuf](https://en.wikipedia.org/wiki/Shuf). Shuf est disponible gratuitement sur les distributions Linux, sur macOS (en installant coreutils dans [homebrew](https://brew.sh)) et sur Windows (en utilisant le sous-système Windows pour Linux (WSL)). Une étape supplémentaire est nécessaire pour éviter que la ligne d'en-tête contenant les noms des colonnes ne soit modifiée au cours de cette étape.
Pour randomiser le fichier source tout en préservant l'en-tête, entrez le code suivant.
```
tail -n +2 keyspaces_sample_table.csv | shuf -o keyspace.table.csv && (head -1 keyspaces_sample_table.csv && cat keyspace.table.csv ) > keyspace.table.csv1 && mv keyspace.table.csv1 keyspace.table.csv
```
Shuf réécrit les données dans un nouveau fichier CSV appelé. `keyspace.table.csv` Vous pouvez désormais supprimer le `keyspaces_sample_table.csv` fichier, vous n'en avez plus besoin.
**Analyser les données**
Déterminez la taille moyenne et maximale des lignes en analysant les données.
Vous le faites pour les raisons suivantes :
+ La taille moyenne des lignes permet d'estimer la quantité totale de données à transférer.
+ Vous avez besoin de la taille de ligne moyenne pour fournir la capacité d'écriture nécessaire au téléchargement des données.
+ Vous pouvez vous assurer que la taille de chaque ligne est inférieure à 1 Mo, ce qui correspond à la taille de ligne maximale dans Amazon Keyspaces.
**Note**
Ce quota fait référence à la taille des lignes et non à la taille de la partition. Contrairement aux partitions Apache Cassandra, les partitions Amazon Keyspaces peuvent être de taille pratiquement indépendante. Les clés de partition et les colonnes de clustering nécessitent un espace de stockage supplémentaire pour les métadonnées, que vous devez ajouter à la taille brute des lignes. Pour de plus amples informations, veuillez consulter [Estimer la taille des lignes dans Amazon Keyspaces](calculating-row-size.md).
Le code suivant utilise [AWK](https://en.wikipedia.org/wiki/AWK) pour analyser un fichier CSV et imprimer la taille de ligne moyenne et maximale.
```
awk -F, 'BEGIN {samp=10000;max=-1;}{if(NR>1){len=length($0);t+=len;avg=t/NR;max=(len>max ? len : max)}}NR==samp{exit}END{printf("{lines: %d, average: %d bytes, max: %d bytes}\n",NR,avg,max);}' keyspace.table.csv
```
L'exécution de ce code génère le résultat suivant.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Vous utiliserez la taille de ligne moyenne à l'étape suivante de ce didacticiel pour configurer la capacité d'écriture de la table.
# Étape 3 : définir la capacité de débit de la table
Ce didacticiel explique comment régler cqlsh pour charger des données dans un intervalle de temps défini. Comme vous savez à l'avance combien de lectures et d'écritures vous devez effectuer, utilisez le mode capacité provisionnée. Une fois le transfert de données terminé, vous devez définir le mode de capacité de la table en fonction des modèles de trafic de votre application. Pour en savoir plus sur la gestion des capacités, voir[Gestion des ressources sans serveur dans Amazon Keyspaces (pour Apache Cassandra)](serverless_resource_management.md).
Avec le mode capacité provisionnée, vous spécifiez à l'avance la capacité de lecture et d'écriture que vous souhaitez allouer à votre table. La capacité d'écriture est facturée à l'heure et mesurée en unités de capacité d'écriture ()WCUs. Chaque WCU possède une capacité d'écriture suffisante pour prendre en charge l'écriture de 1 Ko de données par seconde. Lorsque vous chargez les données, le taux d'écriture doit être inférieur au maximum WCUs (paramètre :`write_capacity_units`) défini sur la table cible.
Par défaut, vous pouvez provisionner jusqu'à 40 000 tables WCUs pour une table et 80 000 pour WCUs toutes les tables de votre compte. Si vous avez besoin de capacités supplémentaires, vous pouvez demander une augmentation de quota dans la console [Service Quotas](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas). Pour plus d’informations sur les quotas, consultez [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md).
**Calculez le nombre moyen de WCUs caractères requis pour un encart**
L'insertion de 1 Ko de données par seconde nécessite 1 WCU. Si votre fichier CSV comporte 360 000 lignes et que vous souhaitez charger toutes les données en 1 heure, vous devez écrire 100 lignes par seconde (360 000 lignes/60 minutes/60 secondes = 100 lignes par seconde). Si chaque ligne contient jusqu'à 1 Ko de données, pour insérer 100 lignes par seconde, vous devez fournir 100 lignes WCUs à votre table. Si chaque ligne contient 1,5 Ko de données, il vous en faut deux WCUs pour insérer une ligne par seconde. Par conséquent, pour insérer 100 lignes par seconde, vous devez en prévoir 200 WCUs.
Pour déterminer le nombre de WCUs lignes à insérer par seconde, divisez la taille moyenne des lignes en octets par 1024 et arrondissez au nombre entier le plus proche.
Par exemple, si la taille moyenne des lignes est de 3 000 octets, il vous en faut trois WCUs pour insérer une ligne par seconde.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Calculer le temps et la capacité de chargement des données**
Maintenant que vous connaissez la taille moyenne et le nombre de lignes de votre fichier CSV, vous pouvez calculer le nombre WCUs de lignes nécessaires pour charger les données dans un laps de temps donné, ainsi que le temps approximatif nécessaire pour charger toutes les données de votre fichier CSV en utilisant différents paramètres WCU.
Par exemple, si chaque ligne de votre fichier fait 1 Ko et que votre fichier CSV contient 1 000 000 de lignes, pour charger les données en 1 heure, vous devez affecter au moins 278 lignes WCUs à votre table pour cette heure.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Configuration des paramètres de capacité provisionnée**
Vous pouvez définir les paramètres de capacité d'écriture d'une table lorsque vous créez la table ou à l'aide de la commande `ALTER TABLE` CQL. Voici la syntaxe permettant de modifier les paramètres de capacité provisionnée d'une table à l'aide de l'instruction `ALTER TABLE` CQL.
```
ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Pour la référence linguistique complète, voir[ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Étape 4 : Configuration des `cqlsh COPY FROM` paramètres
Cette section explique comment déterminer les valeurs des paramètres pour`cqlsh COPY FROM`. La `cqlsh COPY FROM` commande lit le fichier CSV que vous avez préparé précédemment et insère les données dans Amazon Keyspaces à l'aide de CQL. La commande divise les lignes et répartit les `INSERT` opérations entre un ensemble de travailleurs. Chaque collaborateur établit une connexion avec Amazon Keyspaces et envoie des `INSERT` demandes via ce canal.
La `cqlsh COPY` commande n'a pas de logique interne permettant de répartir le travail de manière égale entre ses employés. Cependant, vous pouvez le configurer manuellement pour vous assurer que le travail est réparti de manière uniforme. Commencez par passer en revue les principaux paramètres cqlsh suivants :
+ **DÉLIMITEUR** — Si vous avez utilisé un délimiteur autre qu'une virgule, vous pouvez définir ce paramètre, dont la valeur par défaut est une virgule.
+ **INGESTRATE** — Nombre cible de lignes à `cqlsh COPY FROM` traiter par seconde. S'il n'est pas défini, la valeur par défaut est de 100 000.
+ **NUMPROCESSES** — Le nombre de processus enfants créés par cqlsh pour les tâches. `COPY FROM` Le maximum pour ce paramètre est de 16, la valeur par défaut `num_cores - 1` `num_cores` étant le nombre de cœurs de traitement sur l'hôte exécutant cqlsh.
+ **MAXBATCHSIZE — La taille** du lot détermine le nombre maximal de lignes insérées dans la table de destination en un seul lot. S'il n'est pas défini, cqlsh utilise des lots de 20 lignes insérées.
+ **CHUNKSIZE** — Taille de l'unité de travail transmise à l'enfant travailleur. Par défaut, il est défini sur 5 000.
+ **MAXATTEMPTS** — Le nombre maximum de fois où il est possible de réessayer un worker chunk ayant échoué. Une fois le nombre maximal de tentatives atteint, les enregistrements ayant échoué sont écrits dans un nouveau fichier CSV que vous pourrez réexécuter ultérieurement après avoir examiné l'échec.
`INGESTRATE`Défini en fonction du nombre de ceux WCUs que vous avez provisionnés dans la table de destination cible. La `INGESTRATE` `cqlsh COPY FROM` commande n'est pas une limite, c'est une moyenne cible. Cela signifie qu'il peut (et c'est souvent le cas) dépasser le nombre que vous avez défini. Pour tenir compte des rafales et vous assurer que la capacité est suffisante pour traiter les demandes de chargement de données, définissez 90 % `INGESTRATE` de la capacité d'écriture de la table.
```
INGESTRATE = WCUs * .90
```
Définissez ensuite le `NUMPROCESSES` paramètre sur une valeur inférieure d'un au nombre de cœurs de votre système. Pour connaître le nombre de cœurs de votre système, vous pouvez exécuter le code suivant.
```
python -c "import multiprocessing; print(multiprocessing.cpu_count())"
```
Pour ce didacticiel, nous utilisons la valeur suivante.
```
NUMPROCESSES = 4
```
Chaque processus crée un travailleur, et chaque travailleur établit une connexion à Amazon Keyspaces. Amazon Keyspaces peut prendre en charge jusqu'à 3 000 demandes CQL par seconde à chaque connexion. Cela signifie que vous devez vous assurer que chaque travailleur traite moins de 3 000 demandes par seconde.
Comme c'est le cas`INGESTRATE`, les travailleurs dépassent souvent le nombre que vous avez défini et ne sont pas limités par les secondes d'horloge. Par conséquent, pour tenir compte des rafales, définissez vos paramètres cqlsh de manière à ce que chaque travailleur traite 2 500 demandes par seconde. Pour calculer la quantité de travail distribuée à un travailleur, suivez les directives suivantes.
+ Divisez `INGESTRATE` par`NUMPROCESSES`.
+ Si`INGESTRATE`/`NUMPROCESSES`> 2 500, abaissez le `INGESTRATE` pour que cette formule soit vraie.
```
INGESTRATE / NUMPROCESSES <= 2,500
```
Avant de configurer les paramètres pour optimiser le téléchargement de nos exemples de données, examinons les paramètres `cqlsh` par défaut et voyons comment leur utilisation influe sur le processus de téléchargement des données. Dans la `cqlsh COPY FROM` mesure où il est utilisé `CHUNKSIZE` pour créer des parties du travail (`INSERT`déclarations) à distribuer aux travailleurs, le travail n'est pas automatiquement distribué de manière uniforme. Certains travailleurs peuvent rester inactifs, selon le `INGESTRATE` réglage.
Pour répartir le travail de manière égale entre les travailleurs et maintenir chaque travailleur au taux optimal de 2 500 demandes par seconde, vous devez définir `CHUNKSIZE``MAXBATCHSIZE`, et `INGESTRATE` en modifiant les paramètres d'entrée. Pour optimiser l'utilisation du trafic réseau pendant le chargement des données, choisissez une valeur proche de la valeur maximale de 30. `MAXBATCHSIZE` En passant `CHUNKSIZE` à 100 et `MAXBATCHSIZE` à 25, les 10 000 rangées sont réparties uniformément entre les quatre travailleurs (10 000/ 2500 = 4).
L'exemple de code suivant illustre cela.
```
INGESTRATE = 10,000
NUMPROCESSES = 4
CHUNKSIZE = 100
MAXBATCHSIZE. = 25
Work Distribution:
Connection 1 / Worker 1 : 2,500 Requests per second
Connection 2 / Worker 2 : 2,500 Requests per second
Connection 3 / Worker 3 : 2,500 Requests per second
Connection 4 / Worker 4 : 2,500 Requests per second
```
En résumé, utilisez les formules suivantes lors de la définition `cqlsh COPY FROM` des paramètres :
+ **INGESTRATE** = write\$1capacity\$1units \$1 .90
+ **NUMPROCESSES** = num\$1cores -1 (par défaut)
+ **INGESTRATE/NUMPROCESSES** = 2 500 (Cette déclaration doit être vraie.)
+ **MAXBATCHSIZE** = 30 (20 par défaut). Amazon Keyspaces accepte des lots allant jusqu'à 30.)
+ **CHUNKSIZE** = (INGESTRATE/ NUMPROCESSES)/MAXBATCHSIZE
Maintenant que vous avez calculé `NUMPROCESSES``INGESTRATE`, et`CHUNKSIZE`, vous êtes prêt à charger vos données.
# Étape 5 : Exécuter la `cqlsh COPY FROM` commande pour télécharger les données du fichier CSV vers la table cible
Pour exécuter la `cqlsh COPY FROM` commande, procédez comme suit.
1. Connectez-vous à Amazon Keyspaces à l'aide de cqlsh.
1. Choisissez votre keyspace à l'aide du code suivant.
```
USE catalog;
```
1. Définissez la cohérence d'écriture sur`LOCAL_QUORUM`. Pour garantir la durabilité des données, Amazon Keyspaces n'autorise aucun autre paramètre de cohérence d'écriture. Consultez le code suivant.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Préparez votre `cqlsh COPY FROM` syntaxe à l'aide de l'exemple de code suivant.
```
COPY book_awards FROM './keyspace.table.csv' WITH HEADER=true
AND INGESTRATE=calculated ingestrate
AND NUMPROCESSES=calculated numprocess
AND MAXBATCHSIZE=20
AND CHUNKSIZE=calculated chunksize;
```
1. Exécutez l'instruction préparée à l'étape précédente. cqlsh renvoie tous les paramètres que vous avez configurés.
1. Assurez-vous que les paramètres correspondent à ce que vous avez saisi. Consultez l'exemple suivant.
```
Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'}
Using 15 child processes
```
1. Vérifiez le nombre de lignes transférées et le taux moyen actuel, comme indiqué dans l'exemple suivant.
```
Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s
```
1. Lorsque cqlsh a fini de télécharger les données, consultez le résumé des statistiques de chargement des données (nombre de fichiers lus, temps d'exécution et lignes ignorées) comme indiqué dans l'exemple suivant.
```
15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped).
```
Dans cette dernière étape du didacticiel, vous avez chargé les données sur Amazon Keyspaces.
**Important**
Maintenant que vous avez transféré vos données, ajustez les paramètres du mode capacité de votre table cible pour qu'ils correspondent aux modèles de trafic habituels de votre application. Vous êtes facturé au taux horaire pour votre capacité provisionnée jusqu'à ce que vous la modifiiez.
# Résolution des problèmes
Une fois le téléchargement des données terminé, vérifiez si des lignes ont été ignorées. Pour ce faire, accédez au répertoire source du fichier CSV source et recherchez un fichier portant le nom suivant.
```
import_yourcsvfilename.err.timestamp.csv
```
cqlsh écrit toutes les lignes de données ignorées dans un fichier portant ce nom. Si le fichier existe dans votre répertoire source et contient des données, ces lignes n'ont pas été chargées sur Amazon Keyspaces. Pour réessayer ces lignes, vérifiez d'abord si des erreurs se sont produites lors du téléchargement et ajustez les données en conséquence. Pour réessayer ces lignes, vous pouvez relancer le processus.
**Erreurs courantes**
Les raisons les plus courantes pour lesquelles les lignes ne sont pas chargées sont les erreurs de capacité et les erreurs d'analyse.
**Erreurs de demande non valides lors du chargement de données sur Amazon Keyspaces**
Dans l'exemple suivant, la table source contient une colonne de compteur, qui génère des appels par lots enregistrés à partir de la commande cqlsh`COPY`. Les appels groupés enregistrés ne sont pas pris en charge par Amazon Keyspaces.
```
Failed to import 10 rows: InvalidRequest - Error from server: code=2200 [Invalid query] message=“Only UNLOGGED Batches are supported at this time.“, will retry later, attempt 22 of 25
```
Pour résoudre cette erreur, utilisez DSBulk pour migrer les données. Pour de plus amples informations, veuillez consulter [Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de DSBulk](dsbulk-upload.md).
**Erreurs de l'analyseur lors du chargement de données sur Amazon Keyspaces**
L'exemple suivant montre une ligne ignorée en raison d'un`ParseError`.
```
Failed to import 1 rows: ParseError - Invalid ... –
```
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 à l'aide d'une `INSERT` instruction pour isoler l'erreur.
**Erreurs de capacité lors du chargement de données sur Amazon Keyspaces**
```
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 liées à une capacité insuffisante, Amazon Keyspaces publie `WriteThrottleEvents` des `ReadThrottledEvents` statistiques sur Amazon. CloudWatch Pour de plus amples informations, veuillez consulter [Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md).
**erreurs cqlsh lors du chargement de données sur Amazon Keyspaces**
Pour résoudre les erreurs cqlsh, réexécutez la commande défaillante avec l'indicateur. `--debug`
Lorsque vous utilisez une version incompatible de cqlsh, le message d'erreur suivant s'affiche.
```
AttributeError: 'NoneType' object has no attribute 'is_up'
Failed to import 3 rows: AttributeError - 'NoneType' object has no attribute 'is_up', given up after 1 attempts
```
Vérifiez que la version correcte de cqlsh est installée en exécutant la commande suivante.
```
cqlsh --version
```
Vous devriez voir quelque chose comme la sortie suivante.
```
cqlsh 5.0.1
```
Si vous utilisez Windows, remplacez toutes les instances de `cqlsh` par`cqlsh.bat`. Par exemple, pour vérifier la version de cqlsh sous Windows, exécutez la commande suivante.
```
cqlsh.bat --version
```
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.