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