Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Memuat data ke Amazon Keyspaces menggunakan cqlsh
Tutorial ini memandu Anda melalui proses migrasi data dari Apache Cassandra ke Amazon Keyspaces menggunakan perintah. `cqlsh COPY FROM` `cqlsh COPY FROM`Perintah ini berguna untuk mengunggah kumpulan data kecil dengan cepat dan mudah ke Amazon Keyspaces untuk tujuan akademis atau pengujian. Untuk informasi selengkapnya tentang cara memigrasikan beban kerja produksi, lihat. [Proses migrasi offline: Apache Cassandra ke Amazon Keyspaces](migrating-offline.md) Dalam tutorial ini, Anda akan menyelesaikan langkah-langkah berikut:
Prasyarat - Siapkan AWS akun dengan kredensyal, buat file penyimpanan kepercayaan JKS untuk sertifikat, dan konfigurasikan untuk terhubung ke Amazon Keyspaces. `cqlsh`
1. **Buat CSV sumber dan tabel target** — Siapkan file CSV sebagai data sumber dan buat ruang kunci dan tabel target di Amazon Keyspaces.
1. **Siapkan data** — Acak data dalam file CSV dan analisis untuk menentukan ukuran baris rata-rata dan maksimum.
1. **Mengatur kapasitas throughput** — Hitung unit kapasitas tulis yang diperlukan (WCUs) berdasarkan ukuran data dan waktu muat yang diinginkan, dan konfigurasikan kapasitas yang disediakan tabel.
1. **Konfigurasikan parameter cqlsh** — Tentukan nilai optimal untuk `cqlsh COPY FROM` parameter seperti`INGESTRATE`,, `NUMPROCESSES``MAXBATCHSIZE`, dan `CHUNKSIZE` untuk mendistribusikan beban kerja secara merata.
1. **Jalankan `cqlsh COPY FROM` perintah** — Jalankan `cqlsh COPY FROM` perintah untuk mengunggah data dari file CSV ke tabel Amazon Keyspaces, dan pantau progres.
Pemecahan masalah — Mengatasi masalah umum seperti permintaan tidak valid, kesalahan parser, kesalahan kapasitas, dan kesalahan cqlsh selama proses pengunggahan data.
**Topics**
+ [Prasyarat: Langkah-langkah yang harus diselesaikan sebelum Anda dapat mengunggah data menggunakan `cqlsh COPY FROM`](bulk-upload-prequs.md)
+ [Langkah 1: Buat file CSV sumber dan tabel target untuk unggahan data](bulk-upload-source.md)
+ [Langkah 2: Siapkan data sumber untuk mengunggah data yang berhasil](bulk-upload-prepare-data.md)
+ [Langkah 3: Atur kapasitas throughput untuk tabel](bulk-upload-capacity.md)
+ [Langkah 4: Konfigurasikan `cqlsh COPY FROM` pengaturan](bulk-upload-config.md)
+ [Langkah 5: Jalankan `cqlsh COPY FROM` perintah untuk mengunggah data dari file CSV ke tabel target](bulk-upload-run.md)
+ [Pemecahan masalah](bulk-upload-troubleshooting.md)
# Prasyarat: Langkah-langkah yang harus diselesaikan sebelum Anda dapat mengunggah data menggunakan `cqlsh COPY FROM`
Anda harus menyelesaikan tugas-tugas berikut sebelum Anda dapat memulai tutorial ini.
1. Jika Anda belum melakukannya, daftar Akun AWS dengan mengikuti langkah-langkah di[Menyiapkan AWS Identity and Access Management](accessing.md#SettingUp.IAM).
1. Buat kredensil khusus layanan dengan mengikuti langkah-langkah di. [Buat kredensil khusus layanan untuk akses terprogram ke Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Siapkan koneksi shell Cassandra Query Language (cqlsh) dan konfirmasikan bahwa Anda dapat terhubung ke Amazon Keyspaces dengan mengikuti langkah-langkah di. [Menggunakan `cqlsh` untuk terhubung ke Amazon Keyspaces](programmatic.cqlsh.md)
# Langkah 1: Buat file CSV sumber dan tabel target untuk unggahan data
Untuk tutorial ini, kita menggunakan file nilai dipisahkan koma (CSV) dengan nama `keyspaces_sample_table.csv` sebagai file sumber untuk migrasi data. File sampel yang disediakan berisi beberapa baris data untuk tabel dengan nama`book_awards`.
1. Buat file sumber. Anda dapat memilih salah satu opsi berikut:
+ Download contoh file CSV (`keyspaces_sample_table.csv`) yang terkandung dalam file arsip berikut [samplemigration.zip](samples/samplemigration.zip). Buka zip arsip dan catat jalur ke`keyspaces_sample_table.csv`.
+ Untuk mengisi file CSV dengan data Anda sendiri yang disimpan dalam database Apache Cassandra, Anda dapat mengisi file CSV sumber dengan menggunakan `cqlsh` `COPY TO` pernyataan seperti yang ditunjukkan pada contoh berikut.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "COPY mykeyspace.mytable TO 'keyspaces_sample_table.csv' WITH HEADER=true";
```
Pastikan file CSV yang Anda buat memenuhi persyaratan berikut:
+ Baris pertama berisi nama kolom.
+ Nama kolom dalam file CSV sumber cocok dengan nama kolom di tabel target.
+ Data dibatasi dengan koma.
+ Semua nilai data adalah tipe data Amazon Keyspaces yang valid. Lihat [Jenis Data](cql.elements.md#cql.data-types).
1. Buat keyspace target dan tabel di Amazon Keyspaces.
1. Connect ke Amazon Keyspaces menggunakan`cqlsh`, mengganti endpoint layanan, nama pengguna, dan kata sandi dalam contoh berikut dengan nilai Anda sendiri.
```
cqlsh cassandra.us-east-1.amazonaws.com 9142 -u "111122223333" -p "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" --ssl
```
1. Buat keyspace baru dengan nama `catalog` seperti yang ditunjukkan pada contoh berikut.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Ketika keyspace baru tersedia, gunakan kode berikut untuk membuat tabel `book_awards` target.
```
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)
);
```
Jika Apache Cassandra adalah sumber data asli Anda, cara sederhana untuk membuat tabel target Amazon Keyspaces dengan header yang cocok adalah dengan menghasilkan `CREATE TABLE` pernyataan dari tabel sumber, seperti yang ditunjukkan dalam pernyataan berikut.
```
cqlsh localhost 9042 -u "username" -p "password" --execute "DESCRIBE TABLE mykeyspace.mytable;"
```
Kemudian buat tabel target di Amazon Keyspaces dengan nama kolom dan tipe data yang cocok dengan deskripsi dari tabel sumber Cassandra.
# Langkah 2: Siapkan data sumber untuk mengunggah data yang berhasil
Mempersiapkan data sumber untuk transfer yang efisien adalah proses dua langkah. Pertama, Anda mengacak data. Pada langkah kedua, Anda menganalisis data untuk menentukan nilai `cqlsh` parameter yang sesuai dan pengaturan tabel yang diperlukan untuk memastikan bahwa unggahan data berhasil.
**Acak data**
`cqlsh COPY FROM`Perintah membaca dan menulis data dalam urutan yang sama seperti yang muncul di file CSV. Jika Anda menggunakan `cqlsh COPY TO` perintah untuk membuat file sumber, data ditulis dalam urutan kunci yang diurutkan di CSV. Secara internal, Amazon Keyspaces mempartisi data menggunakan tombol partisi. Meskipun Amazon Keyspaces memiliki logika bawaan untuk membantu memuat permintaan keseimbangan untuk kunci partisi yang sama, memuat data lebih cepat dan lebih efisien jika Anda mengacak urutan. Ini karena Anda dapat memanfaatkan penyeimbangan beban bawaan yang terjadi saat Amazon Keyspaces menulis ke partisi yang berbeda.
Untuk menyebarkan tulisan di seluruh partisi secara merata, Anda harus mengacak data dalam file sumber. Anda dapat menulis aplikasi untuk melakukan ini atau menggunakan alat sumber terbuka, seperti [Shuf](https://en.wikipedia.org/wiki/Shuf). Shuf tersedia secara bebas di distribusi Linux, di macOS (dengan menginstal coreutils di [homebrew](https://brew.sh)), dan di Windows (dengan menggunakan Windows Subsystem for Linux (WSL)). Satu langkah tambahan diperlukan untuk mencegah baris header dengan nama kolom diacak pada langkah ini.
Untuk mengacak file sumber sambil mempertahankan header, masukkan kode berikut.
```
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 menulis ulang data ke file CSV baru yang disebut. `keyspace.table.csv` Anda sekarang dapat menghapus `keyspaces_sample_table.csv` file — Anda tidak lagi membutuhkannya.
**Menganalisis data**
Tentukan ukuran baris rata-rata dan maksimum dengan menganalisis data.
Anda melakukan ini karena alasan berikut:
+ Ukuran baris rata-rata membantu memperkirakan jumlah total data yang akan ditransfer.
+ Anda memerlukan ukuran baris rata-rata untuk menyediakan kapasitas tulis yang diperlukan untuk unggahan data.
+ Anda dapat memastikan bahwa setiap baris berukuran kurang dari 1 MB, yang merupakan ukuran baris maksimum di Amazon Keyspaces.
**catatan**
Kuota ini mengacu pada ukuran baris, bukan ukuran partisi. Tidak seperti partisi Apache Cassandra, partisi Amazon Keyspaces hampir tidak terikat ukurannya. Kunci partisi dan kolom pengelompokan memerlukan penyimpanan tambahan untuk metadata, yang harus Anda tambahkan ke ukuran baris mentah. Untuk informasi selengkapnya, lihat [Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md).
Kode berikut menggunakan [AWK](https://en.wikipedia.org/wiki/AWK) untuk menganalisis file CSV dan mencetak ukuran baris rata-rata dan maksimum.
```
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
```
Menjalankan kode ini menghasilkan output berikut.
```
using 10,000 samples:
{lines: 10000, avg: 123 bytes, max: 225 bytes}
```
Anda menggunakan ukuran baris rata-rata pada langkah berikutnya dari tutorial ini untuk menyediakan kapasitas tulis untuk tabel.
# Langkah 3: Atur kapasitas throughput untuk tabel
Tutorial ini menunjukkan cara menyetel cqlsh untuk memuat data dalam rentang waktu yang ditetapkan. Karena Anda tahu berapa banyak membaca dan menulis yang Anda lakukan sebelumnya, gunakan mode kapasitas yang disediakan. Setelah Anda menyelesaikan transfer data, Anda harus mengatur mode kapasitas tabel agar sesuai dengan pola lalu lintas aplikasi Anda. Untuk mempelajari lebih lanjut tentang manajemen kapasitas, lihat[Mengelola sumber daya tanpa server di Amazon Keyspaces (untuk Apache Cassandra)](serverless_resource_management.md).
Dengan mode kapasitas yang disediakan, Anda menentukan berapa banyak kapasitas baca dan tulis yang ingin Anda berikan ke tabel Anda sebelumnya. Kapasitas tulis ditagih per jam dan diukur dalam satuan kapasitas tulis (). WCUs Setiap WCU memiliki kapasitas tulis yang cukup untuk mendukung penulisan 1 KB data per detik. Saat Anda memuat data, laju penulisan harus berada di bawah maks WCUs (parameter:`write_capacity_units`) yang ditetapkan pada tabel target.
Secara default, Anda dapat menyediakan hingga 40.000 WCUs ke tabel dan 80.000 WCUs di semua tabel di akun Anda. Jika Anda membutuhkan kapasitas tambahan, Anda dapat meminta peningkatan kuota di konsol [Service](https://console.aws.amazon.com/servicequotas/home#!/services/cassandra/quotas) Quotas. Untuk informasi lebih lanjut tentang kuota, lihat[Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md).
**Hitung jumlah rata-rata yang WCUs diperlukan untuk sisipan**
Memasukkan 1 KB data per detik membutuhkan 1 WCU. Jika file CSV Anda memiliki 360.000 baris dan Anda ingin memuat semua data dalam 1 jam, Anda harus menulis 100 baris per detik (360.000 baris/ 60 menit/60 detik = 100 baris per detik). Jika setiap baris memiliki data hingga 1 KB, untuk memasukkan 100 baris per detik, Anda harus menyediakan 100 WCUs ke tabel Anda. Jika setiap baris memiliki 1,5 KB data, Anda perlu dua WCUs untuk memasukkan satu baris per detik. Oleh karena itu, untuk memasukkan 100 baris per detik, Anda harus menyediakan 200 WCUs.
Untuk menentukan berapa banyak yang WCUs Anda butuhkan untuk memasukkan satu baris per detik, bagi ukuran baris rata-rata dalam byte dengan 1024 dan bulatkan ke seluruh nomor terdekat.
Misalnya, jika ukuran baris rata-rata adalah 3000 byte, Anda perlu tiga WCUs untuk memasukkan satu baris per detik.
```
ROUNDUP(3000 / 1024) = ROUNDUP(2.93) = 3 WCUs
```
**Hitung waktu dan kapasitas pemuatan data**
Sekarang setelah Anda mengetahui ukuran rata-rata dan jumlah baris dalam file CSV Anda, Anda dapat menghitung berapa banyak yang WCUs Anda butuhkan untuk memuat data dalam jumlah waktu tertentu, dan perkiraan waktu yang diperlukan untuk memuat semua data dalam file CSV Anda menggunakan pengaturan WCU yang berbeda.
Misalnya, jika setiap baris dalam file Anda adalah 1 KB dan Anda memiliki 1.000.000 baris dalam file CSV Anda, untuk memuat data dalam 1 jam, Anda harus menyediakan setidaknya 278 WCUs ke tabel Anda selama jam itu.
```
1,000,000 rows * 1 KBs = 1,000,000 KBs
1,000,000 KBs / 3600 seconds =277.8 KBs / second = 278 WCUs
```
**Konfigurasikan pengaturan kapasitas yang disediakan**
Anda dapat mengatur pengaturan kapasitas tulis tabel saat Anda membuat tabel atau dengan menggunakan perintah `ALTER TABLE` CQL. Berikut ini adalah sintaks untuk mengubah pengaturan kapasitas disediakan tabel dengan pernyataan CQL. `ALTER TABLE`
```
ALTER TABLE mykeyspace.mytable WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Untuk referensi bahasa selengkapnya, lihat[ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Langkah 4: Konfigurasikan `cqlsh COPY FROM` pengaturan
Bagian ini menguraikan cara menentukan nilai parameter untuk`cqlsh COPY FROM`. `cqlsh COPY FROM`Perintah membaca file CSV yang Anda siapkan sebelumnya dan menyisipkan data ke Amazon Keyspaces menggunakan CQL. Perintah membagi baris dan mendistribusikan `INSERT` operasi di antara satu set pekerja. Setiap pekerja membuat koneksi dengan Amazon Keyspaces dan `INSERT` mengirimkan permintaan di sepanjang saluran ini.
`cqlsh COPY`Perintah tidak memiliki logika internal untuk mendistribusikan pekerjaan secara merata di antara para pekerjanya. Namun, Anda dapat mengonfigurasinya secara manual untuk memastikan bahwa pekerjaan didistribusikan secara merata. Mulailah dengan meninjau parameter cqlsh kunci ini:
+ **DELIMITER** — Jika Anda menggunakan pembatas selain koma, Anda dapat mengatur parameter ini, yang defaultnya koma.
+ **INGESTRATE** — Jumlah target baris yang `cqlsh COPY FROM` mencoba memproses per detik. Jika tidak disetel, defaultnya menjadi 100.000.
+ **NUMPROCESSS** — Jumlah proses pekerja anak yang dibuat cqlsh untuk tugas. `COPY FROM` Maksimum untuk pengaturan ini adalah 16, defaultnya adalah`num_cores - 1`, di mana `num_cores` jumlah inti pemrosesan pada host yang menjalankan cqlsh.
+ **MAXBATCHSIZE — Ukuran** batch menentukan jumlah maksimal baris yang dimasukkan ke dalam tabel tujuan dalam satu batch. Jika tidak disetel, cqlsh menggunakan batch 20 baris yang disisipkan.
+ **CHUNKSIZE** — Ukuran unit kerja yang diteruskan ke pekerja anak. Secara default, ini diatur ke 5.000.
+ **MAKSIMAL** — Jumlah maksimum kali untuk mencoba kembali potongan pekerja yang gagal. Setelah upaya maksimum tercapai, catatan yang gagal ditulis ke file CSV baru yang dapat Anda jalankan lagi nanti setelah menyelidiki kegagalan.
Tetapkan `INGESTRATE` berdasarkan jumlah WCUs yang Anda berikan ke tabel tujuan target. `INGESTRATE``cqlsh COPY FROM`Perintah bukanlah batas—ini adalah rata-rata target. Ini berarti dapat (dan sering) meledak di atas angka yang Anda tetapkan. Untuk memungkinkan ledakan dan memastikan bahwa kapasitas yang cukup tersedia untuk menangani permintaan pemuatan data, atur `INGESTRATE` ke 90% dari kapasitas tulis tabel.
```
INGESTRATE = WCUs * .90
```
Selanjutnya, atur `NUMPROCESSES` parameter menjadi sama dengan satu kurang dari jumlah core pada sistem Anda. Untuk mengetahui berapa jumlah core sistem Anda, Anda dapat menjalankan kode berikut.
```
python -c "import multiprocessing; print(multiprocessing.cpu_count())"
```
Untuk tutorial ini, kami menggunakan nilai berikut.
```
NUMPROCESSES = 4
```
Setiap proses membuat pekerja, dan setiap pekerja membuat koneksi ke Amazon Keyspaces. Amazon Keyspaces dapat mendukung hingga 3.000 permintaan CQL per detik pada setiap koneksi. Ini berarti Anda harus memastikan bahwa setiap pekerja memproses kurang dari 3.000 permintaan per detik.
Seperti halnya`INGESTRATE`, pekerja sering meledak di atas angka yang Anda tetapkan dan tidak dibatasi oleh detik jam. Oleh karena itu, untuk memperhitungkan semburan, atur parameter cqlsh Anda untuk menargetkan setiap pekerja untuk memproses 2.500 permintaan per detik. Untuk menghitung jumlah pekerjaan yang didistribusikan kepada pekerja, gunakan pedoman berikut.
+ Bagilah `INGESTRATE` dengan`NUMPROCESSES`.
+ Jika`INGESTRATE`/`NUMPROCESSES`> 2.500, turunkan `INGESTRATE` untuk membuat rumus ini benar.
```
INGESTRATE / NUMPROCESSES <= 2,500
```
Sebelum Anda mengonfigurasi pengaturan untuk mengoptimalkan unggahan data sampel kami, mari tinjau pengaturan `cqlsh` default dan lihat bagaimana penggunaannya memengaruhi proses pengunggahan data. Karena `cqlsh COPY FROM` menggunakan `CHUNKSIZE` untuk membuat potongan pekerjaan (`INSERT`pernyataan) untuk didistribusikan kepada pekerja, pekerjaan tidak secara otomatis didistribusikan secara merata. Beberapa pekerja mungkin duduk diam, tergantung pada `INGESTRATE` pengaturannya.
Untuk mendistribusikan pekerjaan secara merata di antara para pekerja dan menjaga setiap pekerja pada tingkat optimal 2.500 permintaan per detik, Anda harus mengatur `CHUNKSIZE``MAXBATCHSIZE`,, dan `INGESTRATE` dengan mengubah parameter input. Untuk mengoptimalkan pemanfaatan lalu lintas jaringan selama pemuatan data, pilih nilai `MAXBATCHSIZE` yang mendekati nilai maksimum 30. Dengan mengubah `CHUNKSIZE` ke 100 dan `MAXBATCHSIZE` ke 25, 10.000 baris tersebar merata di antara empat pekerja (10.000/2500 = 4).
Contoh kode berikut menggambarkan hal ini.
```
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
```
Untuk meringkas, gunakan rumus berikut saat mengatur `cqlsh COPY FROM` parameter:
+ **INGESTRATE** = write\$1capacity\$1units \$1 .90
+ **NUMPROCESSS** = num\$1cores -1 (default)
+ **INGESTRATE/NUMPROCESSS** = 2,500 (Ini harus menjadi pernyataan yang benar.)
+ **MAXBATCHSIZE** = 30 (Default ke 20. Amazon Keyspaces menerima batch hingga 30.)
+ **CHUNKSIZE** = (MENELAN/NUMPROCESSS)/MAXBATCHSIZE
Sekarang Anda telah menghitung`NUMPROCESSES`,,`INGESTRATE`, dan`CHUNKSIZE`, Anda siap untuk memuat data Anda.
# Langkah 5: Jalankan `cqlsh COPY FROM` perintah untuk mengunggah data dari file CSV ke tabel target
Untuk menjalankan `cqlsh COPY FROM` perintah, selesaikan langkah-langkah berikut.
1. Connect ke Amazon Keyspaces menggunakan cqlsh.
1. Pilih ruang kunci Anda dengan kode berikut.
```
USE catalog;
```
1. Tetapkan konsistensi tulis ke`LOCAL_QUORUM`. Untuk memastikan daya tahan data, Amazon Keyspaces tidak mengizinkan pengaturan konsistensi tulis lainnya. Lihat kode berikut.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Siapkan `cqlsh COPY FROM` sintaks Anda menggunakan contoh kode berikut.
```
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. Jalankan pernyataan yang disiapkan pada langkah sebelumnya. cqlsh menggemakan kembali semua pengaturan yang telah Anda konfigurasi.
1. Pastikan pengaturan sesuai dengan input Anda. Lihat contoh berikut ini.
```
Reading options from the command line: {'chunksize': '120', 'header': 'true', 'ingestrate': '36000', 'numprocesses': '15', 'maxbatchsize': '20'}
Using 15 child processes
```
1. Tinjau jumlah baris yang ditransfer dan tingkat rata-rata saat ini, seperti yang ditunjukkan pada contoh berikut.
```
Processed: 57834 rows; Rate: 6561 rows/s; Avg. rate: 31751 rows/s
```
1. Ketika cqlsh selesai mengunggah data, tinjau ringkasan statistik pemuatan data (jumlah file yang dibaca, runtime, dan baris yang dilewati) seperti yang ditunjukkan pada contoh berikut.
```
15556824 rows imported from 1 files in 8 minutes and 8.321 seconds (0 skipped).
```
Pada langkah terakhir tutorial ini, Anda telah mengunggah data ke Amazon Keyspaces.
**penting**
Sekarang setelah Anda mentransfer data Anda, sesuaikan pengaturan mode kapasitas tabel target Anda agar sesuai dengan pola lalu lintas reguler aplikasi Anda. Anda dikenakan biaya pada tarif per jam untuk kapasitas yang Anda berikan sampai Anda mengubahnya.
# Pemecahan masalah
Setelah pengunggahan data selesai, periksa untuk melihat apakah baris dilewati. Untuk melakukannya, navigasikan ke direktori sumber file CSV sumber dan cari file dengan nama berikut.
```
import_yourcsvfilename.err.timestamp.csv
```
cqlsh menulis setiap baris data yang dilewati ke dalam file dengan nama itu. Jika file ada di direktori sumber Anda dan memiliki data di dalamnya, baris ini tidak diunggah ke Amazon Keyspaces. Untuk mencoba lagi baris ini, pertama-tama periksa kesalahan yang ditemui selama pengunggahan dan sesuaikan data yang sesuai. Untuk mencoba lagi baris ini, Anda dapat menjalankan kembali prosesnya.
**Kesalahan umum**
Alasan paling umum mengapa baris tidak dimuat adalah kesalahan kapasitas dan kesalahan penguraian.
**Kesalahan permintaan tidak valid saat mengunggah data ke Amazon Keyspaces**
Dalam contoh berikut, tabel sumber berisi kolom penghitung, yang menghasilkan panggilan batch yang dicatat dari perintah cqlsh`COPY`. Panggilan batch yang dicatat tidak didukung oleh Amazon Keyspaces.
```
Failed to import 10 rows: InvalidRequest - Error from server: code=2200 [Invalid query] message=“Only UNLOGGED Batches are supported at this time.“, will retry later, attempt 22 of 25
```
Untuk mengatasi kesalahan ini, gunakan DSBulk untuk memigrasikan data. Untuk informasi selengkapnya, lihat [Tutorial: Memuat data ke Amazon Keyspaces menggunakan DSBulk](dsbulk-upload.md).
**Kesalahan parser saat mengunggah data ke Amazon Keyspaces**
Contoh berikut menunjukkan baris yang dilewati karena a`ParseError`.
```
Failed to import 1 rows: ParseError - Invalid ... –
```
Untuk mengatasi kesalahan ini, Anda perlu memastikan bahwa data yang akan diimpor cocok dengan skema tabel di Amazon Keyspaces. Tinjau file impor untuk kesalahan penguraian. Anda dapat mencoba menggunakan satu baris data menggunakan `INSERT` pernyataan untuk mengisolasi kesalahan.
**Kesalahan kapasitas saat mengunggah data ke 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 menggunakan `WriteTimeout` pengecualian `ReadTimeout` dan untuk menunjukkan kapan permintaan tulis gagal karena kapasitas throughput yang tidak mencukupi. Untuk membantu mendiagnosis pengecualian kapasitas yang tidak mencukupi, Amazon Keyspaces `WriteThrottleEvents` menerbitkan dan `ReadThrottledEvents` metrik di Amazon. CloudWatch Untuk informasi selengkapnya, lihat [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md).
**kesalahan cqlsh saat mengunggah data ke Amazon Keyspaces**
Untuk membantu memecahkan masalah kesalahan cqlsh, jalankan kembali perintah yang gagal dengan bendera. `--debug`
Saat menggunakan versi cqlsh yang tidak kompatibel, Anda melihat kesalahan berikut.
```
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
```
Konfirmasikan bahwa versi cqlsh yang benar diinstal dengan menjalankan perintah berikut.
```
cqlsh --version
```
Anda akan melihat sesuatu seperti berikut untuk output.
```
cqlsh 5.0.1
```
Jika Anda menggunakan Windows, ganti semua instance `cqlsh` dengan`cqlsh.bat`. Misalnya, untuk memeriksa versi cqlsh di Windows, jalankan perintah berikut.
```
cqlsh.bat --version
```
Koneksi ke Amazon Keyspaces gagal setelah klien cqlsh menerima tiga kesalahan berturut-turut dari jenis apa pun dari server. Klien cqlsh gagal dengan pesan berikut.
```
Failed to import 1 rows: NoHostAvailable - , will retry later, attempt 3 of 100
```
Untuk mengatasi kesalahan ini, Anda perlu memastikan bahwa data yang akan diimpor cocok dengan skema tabel di Amazon Keyspaces. Tinjau file impor untuk kesalahan penguraian. Anda dapat mencoba menggunakan satu baris data dengan menggunakan pernyataan INSERT untuk mengisolasi kesalahan.
Klien secara otomatis mencoba membangun kembali koneksi.