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