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.
# Comment sélectionner le bon outil pour le téléchargement groupé ou la migration de données vers Amazon Keyspaces
Dans cette section, vous pouvez passer en revue les différents outils que vous pouvez utiliser pour télécharger ou migrer des données en masse vers Amazon Keyspaces, et apprendre à sélectionner l'outil approprié en fonction de vos besoins. En outre, cette section fournit une vue d'ensemble et des cas d'utilisation des step-by-step didacticiels disponibles qui montrent comment importer des données dans Amazon Keyspaces.
Pour passer en revue les stratégies disponibles pour migrer les charges de travail d'Apache Cassandra vers Amazon Keyspaces, consultez. [Créez un plan de migration pour migrer d'Apache Cassandra vers Amazon Keyspaces](migrating-cassandra.md)
+ **Outils de migration**
+ Grâce au [calculateur de prix pour Amazon Keyspaces (pour Apache Cassandra)](https://aws-samples.github.io/sample-pricing-calculator-for-keyspaces/#cassandra) disponible sur Github, vous pouvez estimer vos coûts mensuels pour Amazon Keyspaces en fonction de votre charge de travail Apache Cassandra existante. Entrez les statistiques issues de la sortie de statut de votre outil de nœud Cassandra et de la configuration sans serveur prévue pour Amazon Keyspaces afin de comparer les coûts directs entre les deux solutions. Notez que ce calculateur se concentre uniquement sur les coûts opérationnels d'Amazon Keyspaces par rapport à votre déploiement Cassandra existant. Il n'inclut pas les facteurs liés au coût total de possession (TCO) tels que la maintenance de l'infrastructure, les frais d'exploitation ou les coûts de support pour Cassandra.
+ Proxy **ZDM Dual Write pour la migration vers Amazon Keyspaces — Le proxy** ZDM Dual Write disponible [sur](https://github.com/aws-samples/amazon-keyspaces-examples/blob/main/migration/online/zdm-proxy/README.md) Github prend en charge la migration sans interruption d'Apache Cassandra vers Amazon Keyspaces.
+ **CQLReplicator**— CQLReplicator est un utilitaire open source disponible sur [Github](https://github.com/aws-samples/cql-replicator) qui vous aide à migrer des données d'Apache Cassandra vers Amazon Keyspaces en temps quasi réel.
Pour de plus amples informations, veuillez consulter [Migrez les données en utilisant CQLReplicator](migration-hybrid-cql-rep.md).
+ Pour en savoir plus sur l'utilisation d'Amazon Managed Streaming pour Apache Kafka afin de mettre en œuvre un processus de [migration en ligne](migrating-online.md) avec des écritures doubles, consultez les [instructions relatives à la migration continue des données d'Apache Cassandra vers Amazon Keyspaces](https://aws.amazon.com/solutions/guidance/continuous-data-migration-from-apache-cassandra-to-amazon-keyspaces/).
+ Pour les migrations de grande envergure, pensez à utiliser un outil d'extraction, de transformation et de chargement (ETL). Vous pouvez l'utiliser AWS Glue pour effectuer rapidement et efficacement des migrations de transformation de données. Pour de plus amples informations, veuillez consulter [Processus de migration hors ligne : Apache Cassandra vers Amazon Keyspaces](migrating-offline.md).
+ Pour savoir comment utiliser le connecteur Apache Cassandra Spark pour écrire des données sur Amazon Keyspaces, consultez. [Tutoriel : Intégrer à Apache Spark pour importer ou exporter des données](spark-integrating.md)
+ Commencez rapidement à charger des données dans Amazon Keyspaces à l'aide de la `COPY FROM` commande cqlsh. cqlsh est inclus dans Apache Cassandra et convient parfaitement au chargement de petits ensembles de données ou de données de test. Pour step-by-step obtenir des instructions, voir[Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de cqlsh](bulk-upload.md).
+ Vous pouvez également utiliser le DataStax Bulk Loader pour Apache Cassandra pour charger des données dans Amazon Keyspaces à l'aide `dsbulk` de la commande. DSBulk[fournit des fonctionnalités d'importation plus robustes que cqlsh et est disponible depuis 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).
Considérations générales relatives aux téléchargements de données vers Amazon Keyspaces
+ **Divisez le téléchargement des données en composants plus petits.**
Tenez compte des unités de migration suivantes et de leur empreinte potentielle en termes de taille des données brutes. Le téléchargement de petites quantités de données en une ou plusieurs phases peut contribuer à simplifier votre migration.
+ **Par cluster** : migrez toutes vos données Cassandra en une seule fois. Cette approche peut convenir aux petits clusters.
+ **Par espace de touches ou par table** : divisez votre migration en groupes d'espaces de touches ou de tables. Cette approche peut vous aider à migrer les données par étapes en fonction de vos besoins pour chaque charge de travail.
+ **Par données** — Envisagez de migrer les données pour un groupe spécifique d'utilisateurs ou de produits, afin de réduire encore davantage la taille des données.
+ **Priorisez les données à télécharger en premier en fonction de la simplicité.**
Déterminez si vous avez des données qui pourraient d'abord être migrées plus facilement, par exemple des données qui ne changent pas à des moments précis, des données provenant de traitements par lots effectués la nuit, des données non utilisées pendant les heures hors ligne ou des données provenant d'applications internes.
**Topics**
+ [Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de cqlsh](bulk-upload.md)
+ [Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de DSBulk](dsbulk-upload.md)
# 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.
# Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de DSBulk
Ce step-by-step didacticiel vous explique comment migrer des données d'Apache Cassandra vers Amazon Keyspaces à l'aide du DataStax Bulk Loader () DSBulk disponible sur. [GitHub](https://github.com/datastax/dsbulk.git) L'utilisation DSBulk est utile pour télécharger des ensembles de données sur Amazon Keyspaces à des fins académiques ou de test. Pour plus d'informations sur la migration des charges de travail de production, consultez[Processus de migration hors ligne : Apache Cassandra vers Amazon Keyspaces](migrating-offline.md). Dans ce didacticiel, vous devez suivre 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, configurez`cqlsh`, téléchargez et installez DSBulk, et configurez un `application.conf` fichier.
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 DSBulk les paramètres** : créez un fichier de DSBulk configuration avec des paramètres tels que l'authentification, le protocole SSL/TLS, le niveau de cohérence et la taille du pool de connexions.
1. **Exécuter la DSBulk commande** de DSBulk chargement : exécutez la commande de chargement pour télécharger les données du fichier CSV vers le tableau Amazon Keyspaces et suivre la progression.
**Topics**
+ [Conditions préalables : étapes à suivre avant de pouvoir télécharger des données avec DSBulk](dsbulk-upload-prequs.md)
+ [Étape 1 : Créez le fichier CSV source et une table cible pour le téléchargement des données à l'aide de DSBulk](dsbulk-upload-source.md)
+ [Étape 2 : Préparez les données à télécharger à l'aide de DSBulk](dsbulk-upload-prepare-data.md)
+ [Étape 3 : définir la capacité de débit pour la table cible](dsbulk-upload-capacity.md)
+ [Étape 4 : configurer `DSBulk` les paramètres pour télécharger les données du fichier CSV vers la table cible](dsbulk-upload-config.md)
+ [Étape 5 : Exécuter la DSBulk `load` commande pour télécharger les données du fichier CSV vers la table cible](dsbulk-upload-run.md)
# Conditions préalables : étapes à suivre avant de pouvoir télécharger des données avec DSBulk
Vous devez effectuer les tâches suivantes avant de pouvoir commencer ce didacticiel.
1. Si ce n'est pas déjà fait, créez un AWS compte 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 en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
1. Créez un fichier JKS Trust Store.
1. Téléchargez les certificats numériques suivants et enregistrez les fichiers localement ou dans votre répertoire personnel.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (en option, pour une rétrocompatibilité)
Pour télécharger les certificats, vous pouvez utiliser les commandes suivantes.
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**Note**
Amazon Keyspaces utilisait auparavant des certificats TLS ancrés à l'autorité de certification Starfield Class 2. AWS migre le tout Régions AWS vers des certificats émis dans le cadre d'Amazon Trust Services (Amazon Root CAs 1—4). Au cours de cette transition, configurez les clients pour qu'ils fassent confiance à la fois à Amazon Root CAs 1-4 et à la racine Starfield afin de garantir la compatibilité entre toutes les régions.
1. Convertissez les certificats numériques en fichiers TrustStore et ajoutez-les au keystore.
```
openssl x509 -outform der -in AmazonRootCA1.pem -out temp_file.der
keytool -import -alias amazon-root-ca-1 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA2.pem -out temp_file.der
keytool -import -alias amazon-root-ca-2 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA3.pem -out temp_file.der
keytool -import -alias amazon-root-ca-3 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA4.pem -out temp_file.der
keytool -import -alias amazon-root-ca-4 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in sf-class2-root.crt -out temp_file.der
keytool -import -alias cassandra -keystore cassandra_truststore.jks -file temp_file.der
```
Dans la dernière étape, vous devez créer un mot de passe pour le keystore et faire confiance à chaque certificat. La commande interactive ressemble à ceci.
```
Enter keystore password:
Re-enter new password:
Owner: CN=Amazon Root CA 1, O=Amazon, C=US
Issuer: CN=Amazon Root CA 1, O=Amazon, C=US
Serial number: 66c9fcf99bf8c0a39e2f0788a43e696365bca
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sun Jan 17 00:00:00 UTC 2038
Certificate fingerprints:
SHA1: 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16
SHA256: 8E:CD:E6:88:4F:3D:87:B1:12:5B:A3:1A:C3:FC:B1:3D:70:16:DE:7F:57:CC:90:4F:E1:CB:97:C6:AE:98:19:6E
Signature algorithm name: SHA256withRSA
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 84 18 CC 85 34 EC BC 0C 94 94 2E 08 59 9C C7 B2 ....4.......Y...
0010: 10 4E 0A 08 .N..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 2, O=Amazon, C=US
Issuer: CN=Amazon Root CA 2, O=Amazon, C=US
Serial number: 66c9fd29635869f0a0fe58678f85b26bb8a37
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A
SHA256: 1B:A5:B2:AA:8C:65:40:1A:82:96:01:18:F8:0B:EC:4F:62:30:4D:83:CE:C4:71:3A:19:C3:9C:01:1E:A4:6D:B4
Signature algorithm name: SHA384withRSA
Subject Public Key Algorithm: 4096-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: B0 0C F0 4C 30 F4 05 58 02 48 FD 33 E5 52 AF 4B ...L0..X.H.3.R.K
0010: 84 E3 66 52 ..fR
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 3, O=Amazon, C=US
Issuer: CN=Amazon Root CA 3, O=Amazon, C=US
Serial number: 66c9fd5749736663f3b0b9ad9e89e7603f24a
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E
SHA256: 18:CE:6C:FE:7B:F1:4E:60:B2:E3:47:B8:DF:E8:68:CB:31:D0:2E:BB:3A:DA:27:15:69:F5:03:43:B4:6D:B3:A4
Signature algorithm name: SHA256withECDSA
Subject Public Key Algorithm: 256-bit EC (secp256r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: AB B6 DB D7 06 9E 37 AC 30 86 07 91 70 C7 9C C4 ......7.0...p...
0010: 19 B1 78 C0 ..x.
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 4, O=Amazon, C=US
Issuer: CN=Amazon Root CA 4, O=Amazon, C=US
Serial number: 66c9fd7c1bb104c2943e5717b7b2cc81ac10e
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE
SHA256: E3:5D:28:41:9E:D0:20:25:CF:A6:90:38:CD:62:39:62:45:8D:A5:C6:95:FB:DE:A3:C2:2B:0B:FB:25:89:70:92
Signature algorithm name: SHA384withECDSA
Subject Public Key Algorithm: 384-bit EC (secp384r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: D3 EC C7 3A 65 6E CC E1 DA 76 9A 56 FB 9C F3 86 ...:en...v.V....
0010: 6D 57 E5 81 mW..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Issuer: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Serial number: 0
Valid from: Tue Jun 29 17:39:16 UTC 2004 until: Thu Jun 29 17:39:16 UTC 2034
Certificate fingerprints:
SHA1: AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A
SHA256: 14:65:FA:20:53:97:B8:76:FA:A6:F0:A9:95:8E:55:90:E4:0F:CC:7F:AA:4F:B7:C2:C8:67:75:21:FB:5F:B6:58
Signature algorithm name: SHA1withRSA (weak)
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.35 Criticality=false
AuthorityKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
[OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US]
SerialNumber: [ 00]
]
#2: ObjectId: 2.5.29.19 Criticality=false
BasicConstraints:[
CA:true
PathLen:2147483647
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
]
Warning:
The input uses the SHA1withRSA signature algorithm which is considered a security risk. This algorithm will be disabled in a future update.
Trust this certificate? [no]: yes
Certificate was added to keystore
```
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)
1. Téléchargez et installez DSBulk.
**Note**
La version présentée dans ce didacticiel n'est peut-être pas la dernière version disponible. Avant de procéder au téléchargement DSBulk, consultez la [page de téléchargement de DataStax Bulk Loader](https://downloads.datastax.com/#bulk-loader) pour obtenir la dernière version et mettez à jour le numéro de version dans les commandes suivantes en conséquence.
1. Pour le télécharger DSBulk, vous pouvez utiliser le code suivant.
```
curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz
```
1. Décompressez ensuite le fichier tar et ajoutez-le DSBulk à votre fichier `PATH` comme indiqué dans l'exemple suivant.
```
tar -zxvf dsbulk-1.8.0.tar.gz
# add the DSBulk directory to the path
export PATH=$PATH:./dsbulk-1.8.0/bin
```
1. Créez un `application.conf` fichier pour stocker les paramètres à utiliser par DSBulk. Vous pouvez enregistrer l'exemple suivant sous le nom`./dsbulk_keyspaces.conf`. `localhost`Remplacez-le par le point de contact de votre cluster Cassandra local si vous n'êtes pas sur le nœud local, par exemple le nom DNS ou l'adresse IP. Prenez note du nom et du chemin du fichier, car vous devrez le spécifier ultérieurement dans la `dsbulk load` commande.
```
datastax-java-driver {
basic.contact-points = [ "localhost"]
advanced.auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-1
}
}
```
1. Pour activer le support SigV4, téléchargez le `jar` fichier ombré depuis [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)et placez-le dans le DSBulk `lib` dossier comme indiqué dans l'exemple suivant.
```
curl -O -L https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/download/4.0.6-shaded-v2/aws-sigv4-auth-cassandra-java-driver-plugin-4.0.6-shaded.jar
```
# Étape 1 : Créez le fichier CSV source et une table cible pour le téléchargement des données à l'aide de DSBulk
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 en utilisant `dsbulk unload` comme indiqué dans l'exemple suivant.
```
dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv
```
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. Une fois que le nouveau keyspace est devenu disponible, utilisez le code suivant pour créer la table `book_awards` cible. Pour en savoir plus sur la création de ressources asynchrones et sur la façon de vérifier si une ressource est disponible, consultez. [Vérifiez le statut de création des espaces de touches dans Amazon Keyspaces](keyspaces-create.md)
```
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éparez les données à télécharger à l'aide de DSBulk
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. Dans la deuxième étape, vous analysez les données pour déterminer les valeurs de `dsbulk` paramètres appropriées et les paramètres de table requis.
**Randomiser les données**
La `dsbulk` commande lit et écrit les données dans l'ordre dans lequel elles apparaissent dans le fichier CSV. Si vous utilisez la `dsbulk` 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}
```
Assurez-vous que la taille maximale de votre ligne ne dépasse pas 1 Mo. Si c'est le cas, vous devez diviser la ligne ou compresser les données pour ramener la taille de la ligne en dessous de 1 Mo. Dans l'étape suivante de ce didacticiel, vous allez utiliser la taille de ligne moyenne pour allouer la capacité d'écriture de la table.
# Étape 3 : définir la capacité de débit pour la table cible
Ce didacticiel explique comment régler le chargement DSBulk 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 `ALTER TABLE` commande. Voici la syntaxe permettant de modifier les paramètres de capacité provisionnée d'une table à l'aide de la `ALTER TABLE` commande.
```
ALTER TABLE catalog.book_awards 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 [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) et[ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Étape 4 : configurer `DSBulk` les paramètres pour télécharger les données du fichier CSV vers la table cible
Cette section décrit les étapes nécessaires à la configuration du DSBulk téléchargement des données vers Amazon Keyspaces. Vous configurez à DSBulk l'aide d'un fichier de configuration. Vous spécifiez le fichier de configuration directement depuis la ligne de commande.
1. Créez un fichier DSBulk de configuration pour la migration vers Amazon Keyspaces. Dans cet exemple, nous utilisons le nom du fichier. `dsbulk_keyspaces.conf` Spécifiez les paramètres suivants dans le fichier DSBulk de configuration.
1. *`PlainTextAuthProvider`*— Créez le fournisseur d'authentification avec la `PlainTextAuthProvider` classe. `ServiceUserName`et `ServicePassword` doivent correspondre au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes décrites dans. [Créez des informations d'identification pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.md)
1. *`local-datacenter`*— Définissez la valeur de Région AWS celle `local-datacenter` à laquelle vous vous connectez. Par exemple, si l'application se connecte à`cassandra.us-east-1.amazonaws.com`, définissez le centre de données local sur`us-east-1`. Pour toutes les options disponibles Régions AWS, voir[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md). Pour éviter les répliques, définissez sur`slow-replica-avoidance`. `false`
1. *`SSLEngineFactory`*— Pour configurer SSL/TLS, initialisez-le `SSLEngineFactory` en ajoutant une section dans le fichier de configuration avec une seule ligne qui spécifie la classe avec. `class = DefaultSslEngineFactory` Indiquez le chemin d'accès `cassandra_truststore.jks` et le mot de passe que vous avez créés précédemment.
1. *`consistency`*— Réglez le niveau de cohérence sur`LOCAL QUORUM`. Les autres niveaux de cohérence d'écriture ne sont pas pris en charge. Pour plus d'informations, consultez[Niveaux de cohérence en lecture et écriture pris en charge par Apache Cassandra et coûts associés](consistency.md).
1. Le nombre de connexions par pool est configurable dans le pilote Java. Pour cet exemple, définissez `advanced.connection.pool.local.size` sur 3.
L'exemple de fichier de configuration complet est le suivant.
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-1.amazonaws.com:9142"]
advanced.auth-provider {
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-1"
slow-replica-avoidance = false
}
basic.request {
consistency = LOCAL_QUORUM
default-idempotence = true
}
advanced.ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
advanced.connection.pool.local.size = 3
}
```
1. Vérifiez les paramètres de la DSBulk `load` commande.
1. *`executor.maxPerSecond`*— Le nombre maximum de lignes que la commande de chargement tente de traiter simultanément par seconde. S'il n'est pas défini, ce paramètre est désactivé avec -1.
`executor.maxPerSecond`Défini en fonction du nombre de ceux WCUs que vous avez provisionnés dans la table de destination cible. La `executor.maxPerSecond` `load` 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 % `executor.maxPerSecond` de la capacité d'écriture de la table.
```
executor.maxPerSecond = WCUs * .90
```
Dans ce didacticiel, nous avons défini `executor.maxPerSecond` la valeur 5.
**Note**
Si vous utilisez la DSBulk version 1.6.0 ou supérieure, vous pouvez utiliser à la `dsbulk.engine.maxConcurrentQueries` place.
1. Configurez ces paramètres supplémentaires pour la DSBulk `load` commande.
+ *`batch-mode`*— Ce paramètre indique au système de regrouper les opérations par clé de partition. Nous vous recommandons de désactiver le mode batch, car cela peut entraîner des scénarios de raccourcis clavier et des causes`WriteThrottleEvents`.
+ *`driver.advanced.retry-policy-max-retries`*— Cela détermine le nombre de tentatives à nouveau pour une requête qui a échoué. S'il n'est pas défini, la valeur par défaut est 10. Vous pouvez ajuster cette valeur selon vos besoins.
+ *`driver.basic.request.timeout`*— Durée en minutes pendant laquelle le système attend le retour d'une requête. S'il n'est pas défini, la valeur par défaut est « 5 minutes ». Vous pouvez ajuster cette valeur selon vos besoins.
# Étape 5 : Exécuter la DSBulk `load` commande pour télécharger les données du fichier CSV vers la table cible
Dans la dernière étape de ce didacticiel, vous téléchargerez les données dans Amazon Keyspaces.
Pour exécuter la DSBulk `load` commande, procédez comme suit.
1. Exécutez le code suivant pour télécharger les données de votre fichier csv dans votre tableau Amazon Keyspaces. Assurez-vous de mettre à jour le chemin du fichier de configuration de l'application que vous avez créé précédemment.
```
dsbulk load -f ./dsbulk_keyspaces.conf --connector.csv.url keyspace.table.csv -header true --batch.mode DISABLED --executor.maxPerSecond 5 --driver.basic.request.timeout "5 minutes" --driver.advanced.retry-policy.max-retries 10 -k catalog -t book_awards
```
1. La sortie inclut l'emplacement d'un fichier journal détaillant les opérations réussies et infructueuses. Le fichier est stocké dans le répertoire suivant.
```
Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911
```
1. Les entrées du fichier journal incluront des métriques, comme dans l'exemple suivant. Vérifiez que le nombre de lignes correspond au nombre de lignes de votre fichier csv.
```
total | failed | rows/s | p50ms | p99ms | p999ms
200 | 0 | 200 | 21.63 | 21.89 | 21.89
```
**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. Pour de plus amples informations, veuillez consulter [Configurer les modes de read/write capacité dans Amazon Keyspaces](ReadWriteCapacityMode.md).