Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Tutorial: Daten in Amazon Keyspaces laden mit DSBulk
Dieses step-by-step Tutorial führt Sie durch die Migration von Daten von Apache Cassandra zu Amazon Keyspaces mithilfe des DataStax Bulk Loaders (DSBulk), der auf verfügbar ist. [GitHub](https://github.com/datastax/dsbulk.git) DSBulk Die Verwendung ist nützlich, um Datensätze für akademische Zwecke oder Testzwecke auf Amazon Keyspaces hochzuladen. Weitere Informationen zur Migration von Produktionsworkloads finden Sie unter. [Offline-Migrationsprozess: Apache Cassandra zu Amazon Keyspaces](migrating-offline.md) In diesem Tutorial führen Sie die folgenden Schritte aus.
Voraussetzungen — Richten Sie ein AWS Konto mit Anmeldeinformationen ein, erstellen Sie eine JKS-Trust-Store-Datei für das Zertifikat, konfigurieren Sie `cqlsh` es, laden Sie es herunter und installieren Sie DSBulk es und konfigurieren Sie eine `application.conf` Datei.
1. **Quell-CSV und Zieltabelle erstellen** — Bereiten Sie eine CSV-Datei als Quelldaten vor und erstellen Sie den Zielschlüsselraum und die Zieltabelle in Amazon Keyspaces.
1. **Daten vorbereiten** — Randomisieren Sie die Daten in der CSV-Datei und analysieren Sie sie, um die durchschnittliche und maximale Zeilengröße zu ermitteln.
1. **Durchsatzkapazität festlegen** — Berechnen Sie die erforderlichen Schreibkapazitätseinheiten (WCUs) auf der Grundlage der Datengröße und der gewünschten Ladezeit und konfigurieren Sie die bereitgestellte Kapazität der Tabelle.
1. ** DSBulk Einstellungen konfigurieren** — Erstellen Sie eine DSBulk Konfigurationsdatei mit Einstellungen wie Authentifizierung, SSL/TLS, Konsistenzstufe und Größe des Verbindungspools.
1. **Den DSBulk Ladebefehl ausführen** — Führen Sie den Befehl DSBulk load aus, um die Daten aus der CSV-Datei in die Amazon Keyspaces-Tabelle hochzuladen und den Fortschritt zu überwachen.
**Topics**
+ [Voraussetzungen: Schritte, die Sie ausführen müssen, bevor Sie Daten hochladen können mit DSBulk](dsbulk-upload-prequs.md)
+ [Schritt 1: Erstellen Sie die Quell-CSV-Datei und eine Zieltabelle für den Datenupload mit DSBulk](dsbulk-upload-source.md)
+ [Schritt 2: Bereiten Sie die Daten für den Upload vor mit DSBulk](dsbulk-upload-prepare-data.md)
+ [Schritt 3: Stellen Sie die Durchsatzkapazität für die Zieltabelle ein](dsbulk-upload-capacity.md)
+ [Schritt 4: Konfigurieren Sie die `DSBulk` Einstellungen, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen](dsbulk-upload-config.md)
+ [Schritt 5: Führen Sie den DSBulk `load` Befehl aus, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen](dsbulk-upload-run.md)
# Voraussetzungen: Schritte, die Sie ausführen müssen, bevor Sie Daten hochladen können mit DSBulk
Sie müssen die folgenden Aufgaben erledigen, bevor Sie mit diesem Tutorial beginnen können.
1. Falls Sie dies noch nicht getan haben, registrieren Sie sich für ein AWS Konto, indem Sie den Schritten unter folgen[Einrichten AWS Identity and Access Management](accessing.md#SettingUp.IAM).
1. Erstellen Sie Anmeldeinformationen, indem Sie den Schritten unter folgen[AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
1. Erstellen Sie eine JKS-Trust-Store-Datei.
1. Laden Sie die folgenden digitalen Zertifikate herunter und speichern Sie die Dateien lokal oder in Ihrem Home-Verzeichnis.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (optional — aus Gründen der Abwärtskompatibilität)
Um die Zertifikate herunterzuladen, können Sie die folgenden Befehle verwenden.
```
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
```
**Anmerkung**
Amazon Keyspaces verwendete zuvor TLS-Zertifikate, die in der Starfield Class 2 CA verankert waren. AWS migriert alle AWS-Regionen auf Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden. Während dieser Umstellung sollten Sie die Clients so konfigurieren, dass sie sowohl Amazon Root CAs 1—4 als auch Starfield Root vertrauen, um die Kompatibilität in allen Regionen sicherzustellen.
1. Konvertieren Sie die digitalen Zertifikate in TrustStore-Dateien und fügen Sie sie dem Keystore hinzu.
```
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
```
Im letzten Schritt müssen Sie ein Passwort für den Keystore erstellen und jedem Zertifikat vertrauen. Der interaktive Befehl sieht so aus.
```
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. Richten Sie die Cassandra Query Language Shell (cqlsh) -Verbindung ein und bestätigen Sie, dass Sie eine Verbindung zu Amazon Keyspaces herstellen können, indem Sie die Schritte unter befolgen. [Verwenden`cqlsh`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md)
1. Downloaden und installieren. DSBulk
**Anmerkung**
Die in diesem Tutorial gezeigte Version ist möglicherweise nicht die neueste verfügbare Version. Suchen Sie vor dem Herunterladen DSBulk auf der [DataStax Bulk Loader-Downloadseite](https://downloads.datastax.com/#bulk-loader) nach der neuesten Version und aktualisieren Sie die Versionsnummer in den folgenden Befehlen entsprechend.
1. Zum Herunterladen DSBulk können Sie den folgenden Code verwenden.
```
curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz
```
1. Entpacken Sie dann die TAR-Datei und fügen Sie DSBulk sie zu Ihrer hinzu, `PATH` wie im folgenden Beispiel gezeigt.
```
tar -zxvf dsbulk-1.8.0.tar.gz
# add the DSBulk directory to the path
export PATH=$PATH:./dsbulk-1.8.0/bin
```
1. Erstellen Sie eine `application.conf` Datei, um die Einstellungen zu speichern, von denen verwendet werden soll DSBulk. Sie können das folgende Beispiel unter speichern`./dsbulk_keyspaces.conf`. `localhost`Ersetzen Sie es durch den Kontaktpunkt Ihres lokalen Cassandra-Clusters, wenn Sie sich nicht auf dem lokalen Knoten befinden, z. B. den DNS-Namen oder die IP-Adresse. Notieren Sie sich den Dateinamen und den Pfad, da Sie dies später im `dsbulk load` Befehl angeben müssen.
```
datastax-java-driver {
basic.contact-points = [ "localhost"]
advanced.auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-1
}
}
```
1. Um die SigV4-Unterstützung zu aktivieren, laden Sie die schattierte `jar` Datei von herunter [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)und platzieren Sie sie in dem DSBulk `lib` Ordner, wie im folgenden Beispiel gezeigt.
```
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
```
# Schritt 1: Erstellen Sie die Quell-CSV-Datei und eine Zieltabelle für den Datenupload mit DSBulk
Für dieses Tutorial verwenden wir eine Datei mit kommagetrennten Werten (CSV) mit dem Namen `keyspaces_sample_table.csv` als Quelldatei für die Datenmigration. Die mitgelieferte Beispieldatei enthält einige Datenzeilen für eine Tabelle mit dem Namen. `book_awards`
1. Erstellen Sie die Quelldatei. Sie können eine der folgenden Optionen wählen:
+ Laden Sie die CSV-Beispieldatei (`keyspaces_sample_table.csv`) herunter, die in der folgenden Archivdatei [samplemigration.zip](samples/samplemigration.zip) enthalten ist. Entpacken Sie das Archiv und notieren Sie sich den Pfad zu`keyspaces_sample_table.csv`.
+ Um eine CSV-Datei mit Ihren eigenen Daten zu füllen, die in einer Apache Cassandra-Datenbank gespeichert sind, können Sie die CSV-Quelldatei `dsbulk unload` wie im folgenden Beispiel gezeigt auffüllen.
```
dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv
```
Stellen Sie sicher, dass die von Ihnen erstellte CSV-Datei die folgenden Anforderungen erfüllt:
+ Die erste Zeile enthält die Spaltennamen.
+ Die Spaltennamen in der CSV-Quelldatei stimmen mit den Spaltennamen in der Zieltabelle überein.
+ Die Daten sind durch ein Komma getrennt.
+ Alle Datenwerte sind gültige Amazon Keyspaces-Datentypen. Siehe [Datentypen](cql.elements.md#cql.data-types).
1. Erstellen Sie den Zielschlüsselraum und die Zieltabelle in Amazon Keyspaces.
1. Connect zu Amazon Keyspaces her`cqlsh`, indem Sie den Service-Endpunkt, den Benutzernamen und das Passwort im folgenden Beispiel durch Ihre eigenen Werte ersetzen.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Erstellen Sie einen neuen Schlüsselraum mit dem Namen, `catalog` wie im folgenden Beispiel gezeigt.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Wenn der neue Schlüsselraum den Status verfügbar hat, verwenden Sie den folgenden Code, um die Zieltabelle zu erstellen. `book_awards` Weitere Informationen zur asynchronen Ressourcenerstellung und zur Überprüfung, ob eine Ressource verfügbar ist, finden Sie unter. [Überprüfen Sie den Status der Schlüsselraumerstellung in 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)
);
```
Wenn Apache Cassandra Ihre ursprüngliche Datenquelle ist, besteht eine einfache Möglichkeit, die Amazon Keyspaces-Zieltabelle mit passenden Headern zu erstellen, darin, die `CREATE TABLE` Anweisung aus der Quelltabelle zu generieren, wie in der folgenden Anweisung gezeigt.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
Erstellen Sie dann die Zieltabelle in Amazon Keyspaces mit den Spaltennamen und Datentypen, die der Beschreibung aus der Cassandra-Quelltabelle entsprechen.
# Schritt 2: Bereiten Sie die Daten für den Upload vor mit DSBulk
Die Vorbereitung der Quelldaten für eine effiziente Übertragung erfolgt in zwei Schritten. Zunächst randomisieren Sie die Daten. Im zweiten Schritt analysieren Sie die Daten, um die geeigneten `dsbulk` Parameterwerte und erforderlichen Tabelleneinstellungen zu ermitteln.
**Randomisieren Sie die Daten**
Der `dsbulk` Befehl liest und schreibt Daten in derselben Reihenfolge, in der sie in der CSV-Datei erscheinen. Wenn Sie den `dsbulk` Befehl verwenden, um die Quelldatei zu erstellen, werden die Daten in schlüsselsortierter Reihenfolge in die CSV-Datei geschrieben. Intern partitioniert Amazon Keyspaces Daten mithilfe von Partitionsschlüsseln. Amazon Keyspaces verfügt zwar über eine integrierte Logik, die beim Lastenausgleich von Anfragen für denselben Partitionsschlüssel hilft, das Laden der Daten ist jedoch schneller und effizienter, wenn Sie die Reihenfolge nach dem Zufallsprinzip festlegen. Dies liegt daran, dass Sie den integrierten Lastenausgleich nutzen können, der auftritt, wenn Amazon Keyspaces auf verschiedene Partitionen schreibt.
Um die Schreibvorgänge gleichmäßig auf die Partitionen zu verteilen, müssen Sie die Daten in der Quelldatei randomisieren. [Sie können dafür eine Anwendung schreiben oder ein Open-Source-Tool wie Shuf verwenden.](https://en.wikipedia.org/wiki/Shuf) Shuf ist auf Linux-Distributionen, auf macOS (durch Installation von Coreutils in [Homebrew](https://brew.sh)) und unter Windows (mithilfe des Windows Subsystems for Linux (WSL)) kostenlos verfügbar. Ein zusätzlicher Schritt ist erforderlich, um zu verhindern, dass die Kopfzeile mit den Spaltennamen in diesem Schritt gemischt wird.
Um die Quelldatei nach dem Zufallsprinzip zu sortieren und gleichzeitig die Kopfzeile beizubehalten, geben Sie den folgenden Code ein.
```
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 schreibt die Daten in eine neue CSV-Datei mit dem Namen um. `keyspace.table.csv` Sie können die `keyspaces_sample_table.csv` Datei jetzt löschen — Sie benötigen sie nicht mehr.
**Analysieren Sie die Daten**
Ermitteln Sie die durchschnittliche und maximale Zeilengröße, indem Sie die Daten analysieren.
Sie tun dies aus den folgenden Gründen:
+ Die durchschnittliche Zeilengröße hilft bei der Schätzung der Gesamtmenge der zu übertragenden Daten.
+ Sie benötigen die durchschnittliche Zeilengröße, um die für den Datenupload benötigte Schreibkapazität bereitzustellen.
+ Sie können sicherstellen, dass jede Zeile weniger als 1 MB groß ist. Dies ist die maximale Zeilengröße in Amazon Keyspaces.
**Anmerkung**
Dieses Kontingent bezieht sich auf die Zeilengröße, nicht auf die Partitionsgröße. Im Gegensatz zu Apache Cassandra-Partitionen können Amazon Keyspaces-Partitionen praktisch unbegrenzt groß sein. Partitionsschlüssel und Clusterspalten benötigen zusätzlichen Speicherplatz für Metadaten, den Sie zur Rohgröße der Zeilen hinzufügen müssen. Weitere Informationen finden Sie unter [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md).
Der folgende Code verwendet [AWK](https://en.wikipedia.org/wiki/AWK), um eine CSV-Datei zu analysieren und die durchschnittliche und maximale Zeilengröße zu drucken.
```
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
```
Die Ausführung dieses Codes führt zu der folgenden Ausgabe.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Stellen Sie sicher, dass Ihre maximale Zeilengröße 1 MB nicht überschreitet. Ist dies der Fall, müssen Sie die Zeile aufteilen oder die Daten komprimieren, um die Zeilengröße unter 1 MB zu bringen. Im nächsten Schritt dieses Tutorials verwenden Sie die durchschnittliche Zeilengröße, um die Schreibkapazität für die Tabelle bereitzustellen.
# Schritt 3: Stellen Sie die Durchsatzkapazität für die Zieltabelle ein
Dieses Tutorial zeigt Ihnen, wie Sie das Laden von Daten innerhalb eines bestimmten Zeitbereichs einstellen können. DSBulk Da Sie im Voraus wissen, wie viele Lese- und Schreibvorgänge Sie durchführen, sollten Sie den Modus für bereitgestellte Kapazität verwenden. Nachdem Sie die Datenübertragung abgeschlossen haben, sollten Sie den Kapazitätsmodus der Tabelle so einstellen, dass er den Datenverkehrsmustern Ihrer Anwendung entspricht. Weitere Informationen zur Kapazitätsverwaltung finden Sie unter[Verwaltung serverloser Ressourcen in Amazon Keyspaces (für Apache Cassandra)](serverless_resource_management.md).
Im Modus „Bereitgestellte Kapazität“ geben Sie im Voraus an, wie viel Lese- und Schreibkapazität Sie für Ihre Tabelle bereitstellen möchten. Die Schreibkapazität wird stündlich abgerechnet und in Schreibkapazitätseinheiten () gemessen. WCUs Jede WCU bietet ausreichend Schreibkapazität, um das Schreiben von 1 KB Daten pro Sekunde zu unterstützen. Wenn Sie die Daten laden, muss die Schreibrate unter dem in der Zieltabelle festgelegten Höchstwert WCUs (Parameter:`write_capacity_units`) liegen.
Standardmäßig können Sie bis WCUs zu 40.000 für eine Tabelle und 80.000 für alle WCUs Tabellen in Ihrem Konto bereitstellen. Wenn Sie zusätzliche Kapazität benötigen, können Sie in der [Service Quotas-Konsole eine Erhöhung des Kontingents](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas) beantragen. Weitere Informationen zu Kontingenten finden Sie unter [Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md).
**Berechnen Sie die durchschnittliche Anzahl der für eine Einfügung WCUs erforderlichen**
Für das Einfügen von 1 KB Daten pro Sekunde ist 1 WCU erforderlich. Wenn Ihre CSV-Datei 360.000 Zeilen hat und Sie alle Daten in einer Stunde laden möchten, müssen Sie 100 Zeilen pro Sekunde schreiben (360.000 Zeilen/60 Minuten/ 60 Sekunden = 100 Zeilen pro Sekunde). Wenn jede Zeile bis zu 1 KB Daten enthält, müssen Sie 100 Zeilen pro Sekunde für Ihre Tabelle bereitstellen, WCUs um 100 Zeilen pro Sekunde einzufügen. Wenn jede Zeile 1,5 KB Daten enthält, benötigen Sie zwei, WCUs um eine Zeile pro Sekunde einzufügen. Um 100 Zeilen pro Sekunde einzufügen, müssen Sie daher 200 bereitstellen WCUs.
Um zu ermitteln, wie viele Zeilen WCUs Sie pro Sekunde einfügen müssen, teilen Sie die durchschnittliche Zeilengröße in Byte durch 1024 und runden Sie auf die nächste ganze Zahl auf.
Wenn die durchschnittliche Zeilengröße beispielsweise 3000 Byte beträgt, benötigen Sie drei, WCUs um eine Zeile pro Sekunde einzufügen.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Berechnen Sie die Ladezeit und Kapazität der Daten**
Da Sie nun die durchschnittliche Größe und Anzahl der Zeilen in Ihrer CSV-Datei kennen, können Sie berechnen, wie viele WCUs Sie benötigen, um die Daten in einem bestimmten Zeitraum zu laden, und die ungefähre Zeit, die zum Laden aller Daten in Ihrer CSV-Datei benötigt wird, mithilfe verschiedener WCU-Einstellungen berechnen.
Wenn beispielsweise jede Zeile in Ihrer Datei 1 KB groß ist und Sie 1.000.000 Zeilen in Ihrer CSV-Datei haben, müssen Sie für diese Stunde mindestens 278 Zeilen für Ihre Tabelle bereitstellen, WCUs um die Daten in einer Stunde zu laden.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Konfigurieren Sie die Einstellungen für die bereitgestellte Kapazität**
Sie können die Schreibkapazitätseinstellungen einer Tabelle festlegen, wenn Sie die Tabelle erstellen oder den `ALTER TABLE` Befehl verwenden. Im Folgenden finden Sie die Syntax für das Ändern der bereitgestellten Kapazitätseinstellungen einer Tabelle mit dem `ALTER TABLE` Befehl.
```
ALTER TABLE catalog.book_awards WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Die vollständige Sprachreferenz finden Sie unter [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) und. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
# Schritt 4: Konfigurieren Sie die `DSBulk` Einstellungen, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen
In diesem Abschnitt werden die Schritte beschrieben, die DSBulk zur Konfiguration des Daten-Uploads auf Amazon Keyspaces erforderlich sind. Sie konfigurieren DSBulk mithilfe einer Konfigurationsdatei. Sie geben die Konfigurationsdatei direkt von der Befehlszeile aus an.
1. Erstellen Sie eine DSBulk Konfigurationsdatei für die Migration zu Amazon Keyspaces. In diesem Beispiel verwenden wir den Dateinamen`dsbulk_keyspaces.conf`. Geben Sie die folgenden Einstellungen in der DSBulk Konfigurationsdatei an.
1. *`PlainTextAuthProvider`*— Erstellen Sie den Authentifizierungsanbieter mit der `PlainTextAuthProvider` Klasse. `ServiceUserName`und `ServicePassword` sollte mit dem Benutzernamen und dem Passwort übereinstimmen, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, indem Sie die Schritte unter [Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.md) ausführen.
1. *`local-datacenter`*— Setzen Sie den Wert für `local-datacenter` auf den AWS-Region , zu dem Sie eine Verbindung herstellen. Wenn die Anwendung beispielsweise eine Verbindung herstellt`cassandra.us-east-1.amazonaws.com`, stellen Sie das lokale Rechenzentrum auf ein`us-east-1`. Alle verfügbaren AWS-Regionen Informationen finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md). Um Replikate zu vermeiden, legen Sie den Wert `slow-replica-avoidance` auf `false` fest.
1. *`SSLEngineFactory`*— Um SSL/TLS zu konfigurieren, initialisieren Sie das, `SSLEngineFactory` indem Sie der Konfigurationsdatei einen Abschnitt mit einer einzigen Zeile hinzufügen, in der die Klasse mit angegeben wird. `class = DefaultSslEngineFactory` Geben Sie den Pfad `cassandra_truststore.jks` und das Passwort an, die Sie zuvor erstellt haben.
1. *`consistency`*— Stellen Sie die Konsistenzstufe auf ein`LOCAL QUORUM`. Andere Schreibkonsistenzstufen werden nicht unterstützt. Weitere Informationen finden Sie unter[Unterstützte Lese- und Schreibkonsistenzstufen von Apache Cassandra und damit verbundene Kosten](consistency.md).
1. Die Anzahl der Verbindungen pro Pool ist im Java-Treiber konfigurierbar. Stellen Sie in diesem Beispiel `advanced.connection.pool.local.size` den Wert 3 ein.
Im Folgenden finden Sie die vollständige Beispielkonfigurationsdatei.
```
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. Überprüfen Sie die Parameter für den DSBulk `load` Befehl.
1. *`executor.maxPerSecond`*— Die maximale Anzahl von Zeilen, die der Ladebefehl pro Sekunde gleichzeitig zu verarbeiten versucht. Wenn sie nicht gesetzt ist, ist diese Einstellung mit -1 deaktiviert.
Wird auf der `executor.maxPerSecond` Grundlage der Anzahl festgelegt WCUs , die Sie für die Zieltabelle bereitgestellt haben. Der `executor.maxPerSecond` Wert des `load` Befehls ist kein Limit, sondern ein Zieldurchschnitt. Das bedeutet, dass er die von Ihnen festgelegte Zahl überschreiten kann (und tut dies häufig auch). Um Bursts zu berücksichtigen und sicherzustellen, dass genügend Kapazität zur Bearbeitung der Datenladeanforderungen vorhanden ist, sollten Sie einen Wert von 90% der Schreibkapazität der Tabelle festlegen`executor.maxPerSecond`.
```
executor.maxPerSecond = WCUs * .90
```
In diesem Tutorial haben wir den Wert 5 `executor.maxPerSecond` eingestellt.
**Anmerkung**
Wenn Sie DSBulk 1.6.0 oder höher verwenden, können Sie `dsbulk.engine.maxConcurrentQueries` stattdessen verwenden.
1. Konfigurieren Sie diese zusätzlichen Parameter für den DSBulk `load` Befehl.
+ *`batch-mode`*— Dieser Parameter weist das System an, Operationen nach Partitionsschlüsseln zu gruppieren. Wir empfehlen, den Batch-Modus zu deaktivieren, da dies zu Hotkey-Szenarien und Ursachen führen kann`WriteThrottleEvents`.
+ *`driver.advanced.retry-policy-max-retries`*— Dies bestimmt, wie oft eine fehlgeschlagene Abfrage wiederholt werden muss. Wenn diese Option nicht gesetzt ist, ist die Standardeinstellung 10. Sie können diesen Wert nach Bedarf anpassen.
+ *`driver.basic.request.timeout`*— Die Zeit in Minuten, in der das System auf die Rückgabe einer Abfrage wartet. Wenn diese Option nicht gesetzt ist, ist die Standardeinstellung „5 Minuten“. Sie können diesen Wert nach Bedarf anpassen.
# Schritt 5: Führen Sie den DSBulk `load` Befehl aus, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen
Im letzten Schritt dieses Tutorials laden Sie die Daten in Amazon Keyspaces hoch.
Führen Sie die folgenden Schritte DSBulk `load` aus, um den Befehl auszuführen.
1. Führen Sie den folgenden Code aus, um die Daten aus Ihrer CSV-Datei in Ihre Amazon Keyspaces-Tabelle hochzuladen. Achten Sie darauf, den Pfad zur Anwendungskonfigurationsdatei zu aktualisieren, die Sie zuvor erstellt haben.
```
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. Die Ausgabe enthält den Speicherort einer Protokolldatei, in der erfolgreiche und erfolglose Vorgänge aufgeführt sind. Die Datei wird im folgenden Verzeichnis gespeichert.
```
Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911
```
1. Die Einträge in der Protokolldatei werden Metriken enthalten, wie im folgenden Beispiel. Stellen Sie sicher, dass die Anzahl der Zeilen mit der Anzahl der Zeilen in Ihrer CSV-Datei übereinstimmt.
```
total | failed | rows/s | p50ms | p99ms | p999ms
200 | 0 | 200 | 21.63 | 21.89 | 21.89
```
**Wichtig**
Nachdem Sie Ihre Daten übertragen haben, passen Sie die Einstellungen für den Kapazitätsmodus Ihrer Zieltabelle an die regulären Datenverkehrsmuster Ihrer Anwendung an. Es fallen Gebühren zum Stundensatz für Ihre bereitgestellte Kapazität an, bis Sie diese ändern. Weitere Informationen finden Sie unter [read/write Kapazitätsmodi in Amazon Keyspaces konfigurieren](ReadWriteCapacityMode.md).