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.
# So wählen Sie das richtige Tool für den Massen-Upload oder die Migration von Daten zu Amazon Keyspaces
In diesem Abschnitt können Sie sich mit den verschiedenen Tools vertraut machen, mit denen Sie Daten massenweise auf Amazon Keyspaces hochladen oder migrieren können, und erfahren, wie Sie das richtige Tool für Ihre Bedürfnisse auswählen können. Darüber hinaus bietet dieser Abschnitt einen Überblick und Anwendungsfälle für die verfügbaren step-by-step Tutorials, die zeigen, wie Daten in Amazon Keyspaces importiert werden.
Informationen zu den verfügbaren Strategien für die Migration von Workloads von Apache Cassandra zu Amazon Keyspaces finden Sie unter. [Erstellen Sie einen Migrationsplan für die Migration von Apache Cassandra zu Amazon Keyspaces](migrating-cassandra.md)
+ **Tools für die Migration**
+ Mit dem [Preisrechner für Amazon Keyspaces (für Apache Cassandra)](https://aws-samples.github.io/sample-pricing-calculator-for-keyspaces/#cassandra), der auf Github verfügbar ist, können Sie Ihre monatlichen Kosten für Amazon Keyspaces auf der Grundlage Ihrer vorhandenen Apache Cassandra-Arbeitslast schätzen. Geben Sie Metriken aus Ihrer Cassandra-Nodetool-Statusausgabe und der geplanten serverlosen Konfiguration für Amazon Keyspaces ein, um die direkten Kosten zwischen den beiden Lösungen zu vergleichen. Beachten Sie, dass sich dieser Rechner nur auf die Betriebskosten von Amazon Keyspaces im Vergleich zu Ihrer bestehenden Cassandra-Bereitstellung konzentriert. Dabei sind die Gesamtbetriebskosten (TCO) wie Infrastrukturwartung, Betriebskosten oder Supportkosten für Cassandra nicht berücksichtigt.
+ **ZDM Dual Write Proxy für die Amazon Keyspaces-Migration** — Der auf [Github](https://github.com/aws-samples/amazon-keyspaces-examples/blob/main/migration/online/zdm-proxy/README.md) verfügbare ZDM Dual Write Proxy unterstützt die Migration ohne Ausfallzeiten von Apache Cassandra zu Amazon Keyspaces.
+ **CQLReplicator**— CQLReplicator ist ein auf [Github](https://github.com/aws-samples/cql-replicator) verfügbares Open-Source-Hilfsprogramm, mit dem Sie Daten nahezu in Echtzeit von Apache Cassandra zu Amazon Keyspaces migrieren können.
Weitere Informationen finden Sie unter [Migrieren Sie Daten mit CQLReplicator](migration-hybrid-cql-rep.md).
+ Weitere Informationen zur Verwendung von Amazon Managed Streaming for Apache Kafka zur Implementierung eines [Online-Migrationsprozesses](migrating-online.md) mit Dual-Writes finden Sie unter [Anleitung für die kontinuierliche Datenmigration von Apache Cassandra zu](https://aws.amazon.com/solutions/guidance/continuous-data-migration-from-apache-cassandra-to-amazon-keyspaces/) Amazon Keyspaces.
+ Für umfangreiche Migrationen sollten Sie die Verwendung eines ETL-Tool (Extract, Transform and Load) in Betracht ziehen. Sie können es verwenden AWS Glue , um Datentransformationsmigrationen schnell und effektiv durchzuführen. Weitere Informationen finden Sie unter [Offline-Migrationsprozess: Apache Cassandra zu Amazon Keyspaces](migrating-offline.md).
+ Informationen zur Verwendung des Apache Cassandra Spark-Connectors zum Schreiben von Daten in Amazon Keyspaces finden Sie unter. [Tutorial: Integrieren Sie Apache Spark, um Daten zu importieren oder zu exportieren](spark-integrating.md)
+ Beginnen Sie schnell mit dem Laden von Daten in Amazon Keyspaces mithilfe des `COPY FROM` Befehls cqlsh. cqlsh ist in Apache Cassandra enthalten und eignet sich am besten zum Laden kleiner Datensätze oder Testdaten. [Tutorial: Daten mit cqlsh in Amazon Keyspaces laden](bulk-upload.md)Eine Anleitung finden Sie step-by-step unter.
+ Sie können auch den DataStax Bulk Loader für Apache Cassandra verwenden, um Daten mit dem Befehl in Amazon Keyspaces zu laden. `dsbulk` DSBulk[bietet robustere Importfunktionen als cqlsh und ist im Repository verfügbar. GitHub ](https://github.com/datastax/dsbulk) step-by-stepEine Anleitung dazu finden Sie unter. [Tutorial: Daten in Amazon Keyspaces laden mit DSBulk](dsbulk-upload.md)
Allgemeine Überlegungen zu Datenuploads auf Amazon Keyspaces
+ **Teilen Sie den Datenupload in kleinere Komponenten auf.**
Betrachten Sie die folgenden Migrationseinheiten und ihren potenziellen Platzbedarf in Bezug auf die Rohdatengröße. Das Hochladen kleinerer Datenmengen in einer oder mehreren Phasen kann dazu beitragen, Ihre Migration zu vereinfachen.
+ **Nach Clustern** — Migrieren Sie alle Ihre Cassandra-Daten auf einmal. Dieser Ansatz kann für kleinere Cluster in Ordnung sein.
+ **Nach Schlüsselraum oder Tabelle** — Teilen Sie Ihre Migration in Gruppen von Schlüsselräumen oder Tabellen auf. Dieser Ansatz kann Ihnen dabei helfen, Daten in Phasen zu migrieren, die Ihren Anforderungen für jeden Workload entsprechen.
+ **Nach Daten** — Erwägen Sie die Migration von Daten für eine bestimmte Gruppe von Benutzern oder Produkten, um die Datenmenge noch weiter zu reduzieren.
+ **Priorisieren Sie anhand der Einfachheit, welche Daten zuerst hochgeladen werden sollen.**
Überlegen Sie, ob Sie Daten haben, die zunächst einfacher migriert werden könnten, z. B. Daten, die sich zu bestimmten Zeiten nicht ändern, Daten aus nächtlichen Batch-Jobs, Daten, die während der Offline-Zeiten nicht verwendet werden, oder Daten aus internen Apps.
**Topics**
+ [Tutorial: Daten mit cqlsh in Amazon Keyspaces laden](bulk-upload.md)
+ [Tutorial: Daten in Amazon Keyspaces laden mit DSBulk](dsbulk-upload.md)
# Tutorial: Daten mit cqlsh in Amazon Keyspaces laden
Dieses Tutorial führt Sie durch den Prozess der Migration von Daten von Apache Cassandra zu Amazon Keyspaces mithilfe des Befehls. `cqlsh COPY FROM` Der `cqlsh COPY FROM` Befehl ist nützlich, um schnell und einfach kleine 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 durch:
Voraussetzungen — Richten Sie ein AWS Konto mit Anmeldeinformationen ein, erstellen Sie eine JKS-Trust-Store-Datei für das Zertifikat und konfigurieren Sie die Verbindung `cqlsh` zu Amazon Keyspaces.
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. **Cqlsh-Parameter konfigurieren** — Ermitteln Sie optimale Werte für `cqlsh COPY FROM` Parameter wie`INGESTRATE`,, und `NUMPROCESSES``MAXBATCHSIZE`, um die Arbeitslast gleichmäßig `CHUNKSIZE` zu verteilen.
1. **`cqlsh COPY FROM`Befehl ausführen** — Führen Sie den `cqlsh COPY FROM` Befehl aus, um die Daten aus der CSV-Datei in die Amazon Keyspaces-Tabelle hochzuladen, und überwachen Sie den Fortschritt.
Fehlerbehebung — Beheben Sie häufig auftretende Probleme wie ungültige Anfragen, Parserfehler, Kapazitätsfehler und Cqlsh-Fehler beim Hochladen von Daten.
**Topics**
+ [Voraussetzungen: Schritte, die Sie ausführen müssen, bevor Sie Daten hochladen können mit `cqlsh COPY FROM`](bulk-upload-prequs.md)
+ [Schritt 1: Erstellen Sie die CSV-Quelldatei und eine Zieltabelle für den Datenupload](bulk-upload-source.md)
+ [Schritt 2: Bereiten Sie die Quelldaten für einen erfolgreichen Datenupload vor](bulk-upload-prepare-data.md)
+ [Schritt 3: Stellen Sie die Durchsatzkapazität für die Tabelle ein](bulk-upload-capacity.md)
+ [Schritt 4: `cqlsh COPY FROM` Einstellungen konfigurieren](bulk-upload-config.md)
+ [Schritt 5: Führen Sie den `cqlsh COPY FROM` Befehl aus, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen](bulk-upload-run.md)
+ [Fehlerbehebung](bulk-upload-troubleshooting.md)
# Voraussetzungen: Schritte, die Sie ausführen müssen, bevor Sie Daten hochladen können mit `cqlsh COPY FROM`
Sie müssen die folgenden Aufgaben erledigen, bevor Sie mit diesem Tutorial beginnen können.
1. Falls Sie dies noch nicht getan haben, melden Sie sich für eine an, AWS-Konto indem Sie den Schritten unter folgen[Einrichten AWS Identity and Access Management](accessing.md#SettingUp.IAM).
1. Erstellen Sie dienstspezifische Anmeldeinformationen, indem Sie die Schritte unter [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) befolgen.
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)
# Schritt 1: Erstellen Sie die CSV-Quelldatei und eine Zieltabelle für den Datenupload
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 mit der `cqlsh` `COPY TO` Anweisung füllen, wie im folgenden Beispiel gezeigt.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true";
```
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 verfügbar ist, verwenden Sie den folgenden Code, um die Zieltabelle zu erstellen. `book_awards`
```
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 Quelldaten für einen erfolgreichen Datenupload vor
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 `cqlsh` Parameterwerte und erforderlichen Tabelleneinstellungen zu ermitteln, um sicherzustellen, dass der Datenupload erfolgreich ist.
**Randomisieren Sie die Daten**
`cqlsh COPY FROM`Mit dem Befehl werden Daten in derselben Reihenfolge gelesen und geschrieben, in der sie in der CSV-Datei erscheinen. Wenn Sie den `cqlsh COPY TO` 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}
```
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 Tabelle ein
Dieses Tutorial zeigt Ihnen, wie Sie cqlsh so einstellen, dass Daten innerhalb eines festgelegten Zeitbereichs geladen werden. 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 verfügt über 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` CQL-Befehl verwenden. Im Folgenden finden Sie die Syntax für die Änderung der bereitgestellten Kapazitätseinstellungen einer Tabelle mit der `ALTER TABLE` CQL-Anweisung.
```
ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Die vollständige Sprachreferenz finden Sie unter. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
# Schritt 4: `cqlsh COPY FROM` Einstellungen konfigurieren
In diesem Abschnitt wird beschrieben, wie Sie die Parameterwerte für ermitteln`cqlsh COPY FROM`. Der `cqlsh COPY FROM` Befehl liest die CSV-Datei, die Sie zuvor vorbereitet haben, und fügt die Daten mithilfe von CQL in Amazon Keyspaces ein. Der Befehl teilt die Zeilen auf und verteilt die `INSERT` Operationen auf eine Gruppe von Arbeitern. Jeder Mitarbeiter stellt eine Verbindung zu Amazon Keyspaces her und sendet `INSERT` Anfragen über diesen Kanal.
Der `cqlsh COPY` Befehl hat keine interne Logik, um die Arbeit gleichmäßig auf die Mitarbeiter zu verteilen. Sie können ihn jedoch manuell konfigurieren, um sicherzustellen, dass die Arbeit gleichmäßig verteilt wird. Überprüfen Sie zunächst die folgenden wichtigen Cqlsh-Parameter:
+ **DELIMITER** — Wenn Sie ein anderes Trennzeichen als ein Komma verwendet haben, können Sie diesen Parameter festlegen, der standardmäßig auf Komma gesetzt ist.
+ **INGESTRATE** — Die Zielanzahl von Zeilen, die pro Sekunde verarbeitet werden sollen. `cqlsh COPY FROM` Wenn sie nicht gesetzt ist, ist sie standardmäßig auf 100.000 eingestellt.
+ **NUMPROCESSES** — Die Anzahl der untergeordneten Worker-Prozesse, die cqlsh für Aufgaben erstellt. `COPY FROM` Das Maximum für diese Einstellung ist 16, die Standardeinstellung ist dabei die Anzahl der Prozessorkerne auf dem Host`num_cores - 1`, auf dem cqlsh ausgeführt `num_cores` wird.
+ **MAXBATCHSIZE** — Die Batchgröße bestimmt die maximale Anzahl von Zeilen, die in einem einzigen Batch in die Zieltabelle eingefügt werden. Falls nicht gesetzt, verwendet cqlsh Stapel von 20 eingefügten Zeilen.
+ **CHUNKSIZE — Die Größe** der Arbeitseinheit, die an den untergeordneten Arbeiter weitergegeben wird. Standardmäßig ist sie auf 5.000 festgelegt.
+ **MAXATTEMPTS** — Die maximale Anzahl von Wiederholungen für einen fehlgeschlagenen Worker-Chunk. Wenn der maximale Versuch erreicht ist, werden die fehlgeschlagenen Datensätze in eine neue CSV-Datei geschrieben, die Sie später erneut ausführen können, nachdem Sie den Fehler untersucht haben.
Dieser Wert `INGESTRATE` basiert auf der Anzahl der WCUs Dateien, die Sie in der Zieltabelle bereitgestellt haben. Der `INGESTRATE` Wert des `cqlsh COPY FROM` 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`INGESTRATE`.
```
INGESTRATE = WCUs * .90
```
Stellen Sie als Nächstes den `NUMPROCESSES` Parameter so ein, dass er um eins kleiner ist als die Anzahl der Kerne in Ihrem System. Um herauszufinden, wie viele Kerne Ihr System hat, können Sie den folgenden Code ausführen.
```
python -c "import multiprocessing; print(multiprocessing.cpu_count())"
```
Für dieses Tutorial verwenden wir den folgenden Wert.
```
NUMPROCESSES = 4
```
Jeder Prozess erstellt einen Worker, und jeder Worker stellt eine Verbindung zu Amazon Keyspaces her. Amazon Keyspaces kann bei jeder Verbindung bis zu 3.000 CQL-Anfragen pro Sekunde unterstützen. Das bedeutet, dass Sie sicherstellen müssen, dass jeder Mitarbeiter weniger als 3.000 Anfragen pro Sekunde verarbeitet.
Wie bei der `INGESTRATE` anderen Methode überschreiten die Mitarbeiter häufig die von Ihnen festgelegte Anzahl und sind nicht durch Taktsekunden begrenzt. Um Bursts zu berücksichtigen, sollten Sie Ihre cqlsh-Parameter daher so einstellen, dass jeder Worker 2.500 Anfragen pro Sekunde verarbeitet. Verwenden Sie die folgende Richtlinie, um den Arbeitsaufwand zu berechnen, der auf eine Arbeitskraft verteilt wird.
+ Dividiere `INGESTRATE` durch`NUMPROCESSES`.
+ Wenn`INGESTRATE`/`NUMPROCESSES`> 2.500, verringern Sie den Wert, `INGESTRATE` damit diese Formel wahr wird.
```
INGESTRATE / NUMPROCESSES <= 2,500
```
Bevor Sie die Einstellungen zur Optimierung des Uploads unserer Beispieldaten konfigurieren, sollten wir uns zunächst die `cqlsh` Standardeinstellungen ansehen und herausfinden, wie sich ihre Verwendung auf den Daten-Upload-Prozess auswirkt. Da der `cqlsh COPY FROM` verwendet wird`CHUNKSIZE`, um Arbeitsblöcke (`INSERT`Kontoauszüge) zu erstellen, um sie an die Mitarbeiter zu verteilen, wird die Arbeit nicht automatisch gleichmäßig verteilt. Je nach Einstellung können einige Mitarbeiter untätig sitzen. `INGESTRATE`
Um die Arbeit gleichmäßig auf die Mitarbeiter zu verteilen und dafür zu sorgen, dass für jeden Mitarbeiter die optimale Rate von 2.500 Anfragen pro Sekunde erreicht wird`CHUNKSIZE`, müssen Sie`MAXBATCHSIZE`, und `INGESTRATE` durch Ändern der Eingabeparameter festlegen. Um die Auslastung des Netzwerkverkehrs während des Datenladens zu optimieren, wählen Sie einen Wert`MAXBATCHSIZE`, der dem Höchstwert von 30 nahe kommt. Wenn `CHUNKSIZE` Sie den Wert auf 100 und `MAXBATCHSIZE` auf 25 ändern, werden die 10.000 Zeilen gleichmäßig auf die vier Mitarbeiter verteilt (10.000/2500 = 4).
Das folgende Codebeispiel veranschaulicht dies.
```
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
```
Zusammenfassend lässt sich sagen, dass Sie beim Einstellen von `cqlsh COPY FROM` Parametern die folgenden Formeln verwenden:
+ **INGESTRATE** = write\$1capacity\$1units \$1 .90
+ **NUMPROCESSES** = num\$1cores -1 (Standard)
+ **INGESTRATE//NUMPROCESSES = 2.500** (Dies muss eine wahre Aussage sein.)
+ **MAXBATCHSIZE** = 30 (Der Standardwert ist 20. Amazon Keyspaces akzeptiert Batches von bis zu 30.)
+ **CHUNKSIZE = (INGESTRATE**//NUMPROCESSES)/MAXBATCHSIZE
Nachdem Sie, und `CHUNKSIZE` berechnet haben, sind Sie `NUMPROCESSES` bereit`INGESTRATE`, Ihre Daten zu laden.
# Schritt 5: Führen Sie den `cqlsh COPY FROM` Befehl aus, um Daten aus der CSV-Datei in die Zieltabelle hochzuladen
Führen Sie die folgenden Schritte `cqlsh COPY FROM` aus, um den Befehl auszuführen.
1. Stellen Sie mithilfe von cqlsh eine Connect zu Amazon Keyspaces her.
1. Wählen Sie Ihren Keyspace mit dem folgenden Code aus.
```
USE catalog;
```
1. Stellen Sie die Schreibkonsistenz auf ein. `LOCAL_QUORUM` Um die Datenbeständigkeit zu gewährleisten, erlaubt Amazon Keyspaces keine anderen Einstellungen für die Schreibkonsistenz. Sehen Sie sich den folgenden Code an.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Bereiten Sie Ihre `cqlsh COPY FROM` Syntax anhand des folgenden Codebeispiels vor.
```
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. Führen Sie die im vorherigen Schritt vorbereitete Anweisung aus. cqlsh gibt alle Einstellungen zurück, die Sie konfiguriert haben.
1. Stellen Sie sicher, dass die Einstellungen mit Ihrer Eingabe übereinstimmen. Sehen Sie sich das folgende Beispiel an.
```
Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'}
Using 15 child processes
```
1. Überprüfen Sie die Anzahl der übertragenen Zeilen und die aktuelle Durchschnittsrate, wie im folgenden Beispiel gezeigt.
```
Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s
```
1. Wenn cqlsh das Hochladen der Daten abgeschlossen hat, überprüfen Sie die Zusammenfassung der Datenladestatistiken (Anzahl der gelesenen Dateien, Laufzeit und übersprungene Zeilen), wie im folgenden Beispiel gezeigt.
```
15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped).
```
In diesem letzten Schritt des Tutorials haben Sie die Daten auf Amazon Keyspaces hochgeladen.
**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.
# Fehlerbehebung
Überprüfen Sie nach Abschluss des Datenuploads, ob Zeilen übersprungen wurden. Navigieren Sie dazu zum Quellverzeichnis der CSV-Quelldatei und suchen Sie nach einer Datei mit dem folgenden Namen.
```
import_yourcsvfilename.err.timestamp.csv
```
cqlsh schreibt alle übersprungenen Datenzeilen in eine Datei mit diesem Namen. Wenn die Datei in Ihrem Quellverzeichnis vorhanden ist und Daten enthält, wurden diese Zeilen nicht in Amazon Keyspaces hochgeladen. Um diese Zeilen erneut zu versuchen, überprüfen Sie zunächst, ob beim Upload Fehler aufgetreten sind, und passen Sie die Daten entsprechend an. Um diese Zeilen erneut zu versuchen, können Sie den Vorgang erneut ausführen.
**Häufige Fehler**
Die häufigsten Gründe, warum Zeilen nicht geladen werden, sind Kapazitätsfehler und Analysefehler.
**Ungültige Anforderungsfehler beim Hochladen von Daten zu Amazon Keyspaces**
Im folgenden Beispiel enthält die Quelltabelle eine Zählerspalte, die zu protokollierten Batch-Aufrufen des Befehls `COPY` cqlsh führt. Protokollierte Batch-Aufrufe werden von Amazon Keyspaces nicht unterstützt.
```
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
```
Um diesen Fehler zu beheben, verwenden Sie, DSBulk um die Daten zu migrieren. Weitere Informationen finden Sie unter [Tutorial: Daten in Amazon Keyspaces laden mit DSBulk](dsbulk-upload.md).
**Parser-Fehler beim Hochladen von Daten zu Amazon Keyspaces**
Das folgende Beispiel zeigt eine übersprungene Zeile aufgrund von a. `ParseError`
```
Failed to import 1 rows: ParseError - Invalid ... –
```
Um diesen Fehler zu beheben, müssen Sie sicherstellen, dass die zu importierenden Daten dem Tabellenschema in Amazon Keyspaces entsprechen. Überprüfen Sie die Importdatei auf Analysefehler. Sie können versuchen, mithilfe einer `INSERT` Anweisung eine einzelne Datenzeile zu verwenden, um den Fehler zu isolieren.
**Kapazitätsfehler beim Hochladen von Daten auf 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 verwendet die `WriteTimeout` Ausnahmen `ReadTimeout` und, um anzuzeigen, wenn eine Schreibanforderung aufgrund unzureichender Durchsatzkapazität fehlschlägt. Um bei der Diagnose von Ausnahmen bei unzureichender Kapazität zu helfen, veröffentlicht `WriteThrottleEvents` Amazon Keyspaces `ReadThrottledEvents` Statistiken in Amazon CloudWatch. Weitere Informationen finden Sie unter [Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
**cqlsh-Fehler beim Hochladen von Daten zu Amazon Keyspaces**
Um Cqlsh-Fehler zu beheben, führen Sie den fehlgeschlagenen Befehl erneut mit der Markierung aus. `--debug`
Wenn Sie eine inkompatible Version von cqlsh verwenden, wird der folgende Fehler angezeigt.
```
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
```
Vergewissern Sie sich, dass die richtige Version von cqlsh installiert ist, indem Sie den folgenden Befehl ausführen.
```
cqlsh --version
```
Sie sollten etwa das Folgende als Ausgabe sehen.
```
cqlsh 5.0.1
```
Wenn Sie Windows verwenden, ersetzen Sie alle Instanzen von `cqlsh` durch`cqlsh.bat`. Um beispielsweise die Version von cqlsh in Windows zu überprüfen, führen Sie den folgenden Befehl aus.
```
cqlsh.bat --version
```
Die Verbindung zu Amazon Keyspaces schlägt fehl, nachdem der cqlsh-Client drei aufeinanderfolgende Fehler beliebiger Art vom Server empfangen hat. Der Cqlsh-Client schlägt mit der folgenden Meldung fehl.
```
Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100
```
Um diesen Fehler zu beheben, müssen Sie sicherstellen, dass die zu importierenden Daten dem Tabellenschema in Amazon Keyspaces entsprechen. Überprüfen Sie die Importdatei auf Analysefehler. Sie können versuchen, eine einzelne Datenzeile zu verwenden, indem Sie eine INSERT-Anweisung verwenden, um den Fehler zu isolieren.
Der Client versucht automatisch, die Verbindung wiederherzustellen.
# 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).