Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Cara memilih alat yang tepat untuk mengunggah massal atau memigrasi data ke Amazon Keyspaces
Di bagian ini, Anda dapat meninjau berbagai alat yang dapat Anda gunakan untuk mengunggah atau memigrasi data secara massal ke Amazon Keyspaces, dan mempelajari cara memilih alat yang benar berdasarkan kebutuhan Anda. Selain itu, bagian ini memberikan ikhtisar dan kasus penggunaan untuk step-by-step tutorial yang tersedia yang menunjukkan cara mengimpor data ke Amazon Keyspaces.
Untuk meninjau strategi yang tersedia untuk memigrasikan beban kerja dari Apache Cassandra ke Amazon Keyspaces, lihat. [Buat rencana migrasi untuk migrasi dari Apache Cassandra ke Amazon Keyspaces](migrating-cassandra.md)
+ **Alat migrasi**
+ Dengan [kalkulator harga untuk Amazon Keyspaces (untuk Apache Cassandra)](https://aws-samples.github.io/sample-pricing-calculator-for-keyspaces/#cassandra) yang tersedia di Github, Anda dapat memperkirakan biaya bulanan Anda untuk Amazon Keyspaces berdasarkan beban kerja Apache Cassandra yang ada. Masukkan metrik dari keluaran status nodetool Cassandra Anda dan konfigurasi tanpa server yang dimaksudkan untuk Amazon Keyspaces untuk membandingkan biaya langsung antara kedua solusi. Perhatikan bahwa kalkulator ini hanya berfokus pada biaya operasional Amazon Keyspaces dibandingkan dengan penerapan Cassandra yang ada. Ini tidak termasuk faktor biaya kepemilikan total (TCO) seperti pemeliharaan infrastruktur, overhead operasional, atau biaya dukungan untuk Cassandra.
+ **ZDM Dual Write Proxy untuk Migrasi Keyspaces Amazon - ZDM Dual Write Proxy tersedia di Github mendukung migrasi** [zero-downtime dari Apache Cassandra](https://github.com/aws-samples/amazon-keyspaces-examples/blob/main/migration/online/zdm-proxy/README.md) ke Amazon Keyspaces.
+ **CQLReplicator**— CQLReplicator adalah utilitas open source yang tersedia di [Github](https://github.com/aws-samples/cql-replicator) yang membantu Anda memigrasikan data dari Apache Cassandra ke Amazon Keyspaces dalam waktu dekat.
Untuk informasi selengkapnya, lihat [Migrasi data menggunakan CQLReplicator](migration-hybrid-cql-rep.md).
+ Untuk mempelajari selengkapnya tentang cara menggunakan Amazon Managed Streaming for Apache Kafka guna menerapkan proses migrasi [online](migrating-online.md) dengan penulisan ganda, [lihat Panduan migrasi data berkelanjutan dari Apache Cassandra](https://aws.amazon.com/solutions/guidance/continuous-data-migration-from-apache-cassandra-to-amazon-keyspaces/) ke Amazon Keyspaces.
+ Untuk migrasi besar, pertimbangkan untuk menggunakan alat ekstrak, transformasi, dan muat (ETL). Anda dapat menggunakannya AWS Glue untuk melakukan migrasi transformasi data dengan cepat dan efektif. Untuk informasi selengkapnya, lihat [Proses migrasi offline: Apache Cassandra ke Amazon Keyspaces](migrating-offline.md).
+ Untuk mempelajari cara menggunakan konektor Apache Cassandra Spark untuk menulis data ke Amazon Keyspaces, lihat. [Tutorial: Integrasikan dengan Apache Spark untuk mengimpor atau mengekspor data](spark-integrating.md)
+ Mulailah dengan cepat dengan memuat data ke Amazon Keyspaces dengan menggunakan `COPY FROM` perintah cqlsh. cqlsh disertakan dengan Apache Cassandra dan paling cocok untuk memuat kumpulan data kecil atau data uji. Untuk step-by-step instruksi, lihat[Tutorial: Memuat data ke Amazon Keyspaces menggunakan cqlsh](bulk-upload.md).
+ Anda juga dapat menggunakan DataStax Bulk Loader untuk Apache Cassandra untuk memuat data ke Amazon Keyspaces menggunakan perintah. `dsbulk` DSBulk[menyediakan kemampuan impor yang lebih kuat daripada cqlsh dan tersedia dari repositori. GitHub ](https://github.com/datastax/dsbulk) Untuk step-by-step instruksi, lihat[Tutorial: Memuat data ke Amazon Keyspaces menggunakan DSBulk](dsbulk-upload.md).
Pertimbangan umum untuk upload data ke Amazon Keyspaces
+ **Pecah unggahan data menjadi komponen yang lebih kecil.**
Pertimbangkan unit migrasi berikut dan jejak potensialnya dalam hal ukuran data mentah. Mengunggah data dalam jumlah yang lebih kecil dalam satu atau beberapa fase dapat membantu menyederhanakan migrasi Anda.
+ **Berdasarkan cluster** — Migrasikan semua data Cassandra Anda sekaligus. Pendekatan ini mungkin baik-baik saja untuk kelompok yang lebih kecil.
+ **Berdasarkan ruang kunci atau tabel** — Pecah migrasi Anda ke dalam grup ruang kunci atau tabel. Pendekatan ini dapat membantu Anda memigrasikan data secara bertahap berdasarkan kebutuhan Anda untuk setiap beban kerja.
+ **Berdasarkan data** — Pertimbangkan untuk memigrasikan data untuk grup pengguna atau produk tertentu, untuk menurunkan ukuran data.
+ **Prioritaskan data apa yang akan diunggah terlebih dahulu berdasarkan kesederhanaan.**
Pertimbangkan jika Anda memiliki data yang dapat dimigrasikan terlebih dahulu dengan lebih mudah—misalnya, data yang tidak berubah selama waktu tertentu, data dari pekerjaan batch malam hari, data yang tidak digunakan selama jam offline, atau data dari aplikasi internal.
**Topics**
+ [Tutorial: Memuat data ke Amazon Keyspaces menggunakan cqlsh](bulk-upload.md)
+ [Tutorial: Memuat data ke Amazon Keyspaces menggunakan DSBulk](dsbulk-upload.md)
# 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.
# Tutorial: Memuat data ke Amazon Keyspaces menggunakan DSBulk
step-by-stepTutorial ini memandu Anda melalui migrasi data dari Apache Cassandra ke Amazon Keyspaces menggunakan Bulk Loader () DataStax yang tersedia di. DSBulk [GitHub](https://github.com/datastax/dsbulk.git) Penggunaan DSBulk berguna untuk mengunggah kumpulan data 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 menyelesaikan langkah-langkah berikut.
Prasyarat - Siapkan AWS akun dengan kredensyal, buat file penyimpanan kepercayaan JKS untuk sertifikat, konfigurasikan, unduh dan instal, dan konfigurasikan `cqlsh` file. DSBulk `application.conf`
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. **Konfigurasi DSBulk pengaturan** — Buat file DSBulk konfigurasi dengan pengaturan seperti otentikasi, SSL/TLS, tingkat konsistensi, dan ukuran kumpulan koneksi.
1. **Jalankan perintah DSBulk load** - Jalankan perintah DSBulk load untuk mengunggah data dari file CSV ke tabel Amazon Keyspaces, dan pantau progres.
**Topics**
+ [Prasyarat: Langkah-langkah yang harus Anda selesaikan sebelum dapat mengunggah data DSBulk](dsbulk-upload-prequs.md)
+ [Langkah 1: Buat file CSV sumber dan tabel target untuk upload data menggunakan DSBulk](dsbulk-upload-source.md)
+ [Langkah 2: Siapkan data untuk diunggah menggunakan DSBulk](dsbulk-upload-prepare-data.md)
+ [Langkah 3: Atur kapasitas throughput untuk tabel target](dsbulk-upload-capacity.md)
+ [Langkah 4: Konfigurasikan `DSBulk` pengaturan untuk mengunggah data dari file CSV ke tabel target](dsbulk-upload-config.md)
+ [Langkah 5: Jalankan DSBulk `load` perintah untuk mengunggah data dari file CSV ke tabel target](dsbulk-upload-run.md)
# Prasyarat: Langkah-langkah yang harus Anda selesaikan sebelum dapat mengunggah data DSBulk
Anda harus menyelesaikan tugas-tugas berikut sebelum Anda dapat memulai tutorial ini.
1. Jika Anda belum melakukannya, daftar AWS akun dengan mengikuti langkah-langkah di[Menyiapkan AWS Identity and Access Management](accessing.md#SettingUp.IAM).
1. Buat kredensi dengan mengikuti langkah-langkah di. [Membuat dan mengonfigurasi AWS kredensional untuk Amazon Keyspaces](access.credentials.md)
1. Buat file penyimpanan kepercayaan JKS.
1. Unduh sertifikat digital berikut dan simpan file secara lokal atau di direktori home Anda.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opsional - untuk kompatibilitas mundur)
Untuk mengunduh sertifikat, Anda dapat menggunakan perintah berikut.
```
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
```
**catatan**
Amazon Keyspaces sebelumnya menggunakan sertifikat TLS yang ditambatkan ke Starfield Class 2 CA. AWS memigrasikan semua Wilayah AWS ke sertifikat yang dikeluarkan di bawah Amazon Trust Services (Amazon Root CAs 1-4). Selama transisi ini, konfigurasikan klien untuk mempercayai Amazon Root CAs 1-4 dan root Starfield untuk memastikan kompatibilitas di semua Wilayah.
1. Ubah sertifikat digital menjadi file TrustStore dan tambahkan ke keystore.
```
openssl x509 -outform der -in AmazonRootCA1.pem -out temp_file.der
keytool -import -alias amazon-root-ca-1 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA2.pem -out temp_file.der
keytool -import -alias amazon-root-ca-2 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA3.pem -out temp_file.der
keytool -import -alias amazon-root-ca-3 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA4.pem -out temp_file.der
keytool -import -alias amazon-root-ca-4 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in sf-class2-root.crt -out temp_file.der
keytool -import -alias cassandra -keystore cassandra_truststore.jks -file temp_file.der
```
Pada langkah terakhir, Anda perlu membuat kata sandi untuk keystore dan mempercayai setiap sertifikat. Perintah interaktif terlihat seperti ini.
```
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. 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)
1. Unduh dan instal DSBulk.
**catatan**
Versi yang ditampilkan dalam tutorial ini mungkin bukan versi terbaru yang tersedia. Sebelum Anda mengunduh DSBulk, periksa [halaman unduhan DataStax Bulk Loader](https://downloads.datastax.com/#bulk-loader) untuk versi terbaru, dan perbarui nomor versi dalam perintah berikut.
1. Untuk mengunduh DSBulk, Anda dapat menggunakan kode berikut.
```
curl -OL https://downloads.datastax.com/dsbulk/dsbulk-1.8.0.tar.gz
```
1. Kemudian buka paket file tar dan tambahkan DSBulk ke Anda `PATH` seperti yang ditunjukkan pada contoh berikut.
```
tar -zxvf dsbulk-1.8.0.tar.gz
# add the DSBulk directory to the path
export PATH=$PATH:./dsbulk-1.8.0/bin
```
1. Buat `application.conf` file untuk menyimpan pengaturan yang akan digunakan oleh DSBulk. Anda dapat menyimpan contoh berikut sebagai`./dsbulk_keyspaces.conf`. Ganti `localhost` dengan titik kontak cluster Cassandra lokal Anda jika Anda tidak berada di node lokal, misalnya nama DNS atau alamat IP. Perhatikan nama file dan jalur, karena Anda akan perlu menentukan ini nanti dalam `dsbulk load` perintah.
```
datastax-java-driver {
basic.contact-points = [ "localhost"]
advanced.auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-1
}
}
```
1. Untuk mengaktifkan dukungan SiGv4, unduh `jar` file yang diarsir dari [GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/releases/)dan letakkan di DSBulk `lib` folder seperti yang ditunjukkan pada contoh berikut.
```
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
```
# Langkah 1: Buat file CSV sumber dan tabel target untuk upload data menggunakan DSBulk
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 `dsbulk unload` seperti yang ditunjukkan pada contoh berikut.
```
dsbulk unload -k mykeyspace -t mytable -f ./my_application.conf > keyspaces_sample_table.csv
```
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. Setelah keyspace baru memiliki status yang tersedia, gunakan kode berikut untuk membuat tabel `book_awards` target. Untuk mempelajari lebih lanjut tentang pembuatan sumber daya asinkron dan cara memeriksa apakah sumber daya tersedia, lihat. [Periksa status pembuatan keyspace di 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)
);
```
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 untuk diunggah menggunakan DSBulk
Mempersiapkan data sumber untuk transfer yang efisien adalah proses dua langkah. Pertama, Anda mengacak data. Pada langkah kedua, Anda menganalisis data untuk menentukan nilai `dsbulk` parameter yang sesuai dan pengaturan tabel yang diperlukan.
**Mengacak data**
`dsbulk`Perintah membaca dan menulis data dalam urutan yang sama seperti yang muncul di file CSV. Jika Anda menggunakan `dsbulk` 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 bernama. `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}
```
Pastikan ukuran baris maksimum Anda tidak melebihi 1 MB. Jika ya, Anda harus memecah baris atau mengompres data untuk membawa ukuran baris di bawah 1 MB. Pada langkah berikutnya dari tutorial ini, Anda menggunakan ukuran baris rata-rata untuk menyediakan kapasitas tulis untuk tabel.
# Langkah 3: Atur kapasitas throughput untuk tabel target
Tutorial ini menunjukkan cara menyetel DSBulk 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 menyisipkan 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 muat 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 `ALTER TABLE` perintah. Berikut ini adalah sintaks untuk mengubah pengaturan kapasitas disediakan tabel dengan perintah. `ALTER TABLE`
```
ALTER TABLE catalog.book_awards WITH custom_properties={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 100, 'write_capacity_units': 278}} ;
```
Untuk referensi bahasa lengkap, lihat [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) dan[ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).
# Langkah 4: Konfigurasikan `DSBulk` pengaturan untuk mengunggah data dari file CSV ke tabel target
Bagian ini menguraikan langkah-langkah yang diperlukan DSBulk untuk mengonfigurasi pengunggahan data ke Amazon Keyspaces. Anda mengkonfigurasi DSBulk dengan menggunakan file konfigurasi. Anda menentukan file konfigurasi langsung dari baris perintah.
1. Buat file DSBulk konfigurasi untuk migrasi ke Amazon Keyspaces, dalam contoh ini kita menggunakan nama file. `dsbulk_keyspaces.conf` Tentukan pengaturan berikut dalam file DSBulk konfigurasi.
1. *`PlainTextAuthProvider`*— Buat penyedia otentikasi dengan `PlainTextAuthProvider` kelas. `ServiceUserName`dan `ServicePassword` harus cocok dengan nama pengguna dan kata sandi yang Anda peroleh saat Anda membuat kredensyal khusus layanan dengan mengikuti langkah-langkah di. [Buat kredensi untuk akses terprogram ke Amazon Keyspaces](programmatic.credentials.md)
1. *`local-datacenter`*— Tetapkan nilai `local-datacenter` untuk Wilayah AWS yang Anda sambungkan. Misalnya, jika aplikasi terhubung ke`cassandra.us-east-1.amazonaws.com`, maka atur pusat data lokal ke`us-east-1`. Untuk semua yang tersedia Wilayah AWS, lihat[Titik akhir layanan untuk Amazon Keyspaces](programmatic.endpoints.md). Untuk menghindari replika, atur `slow-replica-avoidance` ke`false`.
1. *`SSLEngineFactory`*— Untuk mengkonfigurasi SSL/TLS, inisialisasi `SSLEngineFactory` dengan menambahkan bagian dalam file konfigurasi dengan satu baris yang menentukan kelas dengan. `class = DefaultSslEngineFactory` Berikan jalur ke `cassandra_truststore.jks` dan kata sandi yang Anda buat sebelumnya.
1. *`consistency`*— Tetapkan tingkat konsistensi ke`LOCAL QUORUM`. Tingkat konsistensi penulisan lainnya tidak didukung, untuk informasi lebih lanjut lihat[Mendukung Apache Cassandra membaca dan menulis tingkat konsistensi dan biaya terkait](consistency.md).
1. Jumlah koneksi per pool dapat dikonfigurasi di driver Java. Untuk contoh ini, atur `advanced.connection.pool.local.size` ke 3.
Berikut ini adalah file konfigurasi sampel lengkap.
```
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. Tinjau parameter untuk DSBulk `load` perintah.
1. *`executor.maxPerSecond`*— Jumlah maksimum baris yang coba diproses oleh perintah load secara bersamaan per detik. Jika tidak disetel, pengaturan ini dinonaktifkan dengan -1.
Tetapkan `executor.maxPerSecond` berdasarkan jumlah WCUs yang Anda berikan ke tabel tujuan target. `executor.maxPerSecond``load`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 `executor.maxPerSecond` ke 90% dari kapasitas tulis tabel.
```
executor.maxPerSecond = WCUs * .90
```
Dalam tutorial ini, kita mengatur `executor.maxPerSecond` ke 5.
**catatan**
Jika Anda menggunakan DSBulk 1.6.0 atau lebih tinggi, Anda dapat menggunakannya `dsbulk.engine.maxConcurrentQueries` sebagai gantinya.
1. Konfigurasikan parameter tambahan ini untuk DSBulk `load` perintah.
+ *`batch-mode`*— Parameter ini memberitahu sistem untuk mengelompokkan operasi dengan kunci partisi. Kami merekomendasikan untuk menonaktifkan mode batch, karena dapat menghasilkan skenario dan penyebab hot key`WriteThrottleEvents`.
+ *`driver.advanced.retry-policy-max-retries`*— Ini menentukan berapa kali untuk mencoba lagi kueri yang gagal. Jika tidak disetel, defaultnya adalah 10. Anda dapat menyesuaikan nilai ini sesuai kebutuhan.
+ *`driver.basic.request.timeout`*— Waktu dalam hitungan menit sistem menunggu kueri kembali. Jika tidak disetel, defaultnya adalah “5 menit”. Anda dapat menyesuaikan nilai ini sesuai kebutuhan.
# Langkah 5: Jalankan DSBulk `load` perintah untuk mengunggah data dari file CSV ke tabel target
Pada langkah terakhir tutorial ini, Anda mengunggah data ke Amazon Keyspaces.
Untuk menjalankan DSBulk `load` perintah, selesaikan langkah-langkah berikut.
1. Jalankan kode berikut untuk mengunggah data dari file csv Anda ke tabel Amazon Keyspaces Anda. Pastikan untuk memperbarui jalur ke file konfigurasi aplikasi yang Anda buat sebelumnya.
```
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. Outputnya mencakup lokasi file log yang merinci operasi yang berhasil dan tidak berhasil. File disimpan di direktori berikut.
```
Operation directory: /home/user_name/logs/UNLOAD_20210308-202317-801911
```
1. Entri file log akan menyertakan metrik, seperti pada contoh berikut. Periksa untuk memastikan bahwa jumlah baris konsisten dengan jumlah baris dalam file csv Anda.
```
total | failed | rows/s | p50ms | p99ms | p999ms
200 | 0 | 200 | 21.63 | 21.89 | 21.89
```
**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. Lihat informasi yang lebih lengkap di [Konfigurasikan mode read/write kapasitas di Amazon Keyspaces](ReadWriteCapacityMode.md).