Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Integrasikan dengan Apache Spark untuk mengimpor atau mengekspor data
Apache Spark adalah mesin open-source untuk analisis data skala besar. Apache Spark memungkinkan Anda melakukan analitik pada data yang disimpan di Amazon Keyspaces dengan lebih efisien. Anda juga dapat menggunakan Amazon Keyspaces untuk menyediakan aplikasi dengan akses single-digit-millisecond baca yang konsisten ke data analitik dari Spark. Konektor Spark Cassandra sumber terbuka menyederhanakan membaca dan menulis data antara Amazon Keyspaces dan Spark.
Dukungan Amazon Keyspaces untuk Spark Cassandra Connector menyederhanakan menjalankan beban kerja Cassandra di pipeline analitik berbasis Spark dengan menggunakan layanan database yang dikelola sepenuhnya dan tanpa server. Dengan Amazon Keyspaces, Anda tidak perlu khawatir tentang Spark bersaing untuk sumber daya infrastruktur dasar yang sama dengan tabel Anda. Tabel Amazon Keyspaces menskalakan naik dan turun secara otomatis berdasarkan lalu lintas aplikasi Anda.
Tutorial berikut memandu Anda melalui langkah-langkah dan praktik terbaik yang diperlukan untuk membaca dan menulis data ke Amazon Keyspaces menggunakan Spark Cassandra Connector. Tutorial ini menunjukkan cara memigrasikan data ke Amazon Keyspaces dengan memuat data dari file dengan Spark Cassandra Connector dan menulisnya ke tabel Amazon Keyspaces. Kemudian, tutorial menunjukkan cara membaca data kembali dari Amazon Keyspaces menggunakan Spark Cassandra Connector. Anda akan melakukan ini untuk menjalankan beban kerja Cassandra di pipeline analitik berbasis Spark.
**Topics**
+ [Prasyarat untuk membuat koneksi ke Amazon Keyspaces dengan Spark Cassandra Connector](spark-tutorial-prerequisites.md)
+ [Langkah 1: Konfigurasikan Amazon Keyspaces untuk integrasi dengan Apache Cassandra Spark Connector](spark-tutorial-step1.md)
+ [Langkah 2: Konfigurasikan Konektor Spark Apache Cassandra](spark-tutorial-step2.md)
+ [Langkah 3: Buat file konfigurasi aplikasi](spark-tutorial-step3.md)
+ [Langkah 4: Siapkan data sumber dan tabel target di Amazon Keyspaces](spark-tutorial-step4.md)
+ [Langkah 5: Tulis dan baca data Amazon Keyspaces menggunakan Apache Cassandra Spark Connector](spark-tutorial-step5.md)
+ [Memecahkan masalah kesalahan umum saat menggunakan Konektor Spark Cassandra dengan Amazon Keyspaces](spark-tutorial-step6.md)
# Prasyarat untuk membuat koneksi ke Amazon Keyspaces dengan Spark Cassandra Connector
Sebelum Anda terhubung ke Amazon Keyspaces dengan Spark Cassandra Connector, Anda perlu memastikan bahwa Anda telah menginstal yang berikut ini. Kompatibilitas Amazon Keyspaces dengan Spark Cassandra Connector telah diuji dengan versi yang direkomendasikan berikut:
+ Java versi 8
+ Scala 2.12
+ Percikan 3.4
+ Konektor Cassandra 2.5 dan lebih tinggi
+ Pengemudi Cassandra 4.12
1. Untuk menginstal Scala, ikuti instruksi di[https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html).
1. Untuk menginstal Spark 3.4.1, ikuti contoh ini.
```
curl -o spark-3.4.1-bin-hadoop3.tgz -k https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz
# now to untar
tar -zxvf spark-3.4.1-bin-hadoop3.tgz
# set this variable.
export SPARK_HOME=$PWD/spark-3.4.1-bin-hadoop3
```
```
# Langkah 1: Konfigurasikan Amazon Keyspaces untuk integrasi dengan Apache Cassandra Spark Connector
Pada langkah ini, Anda mengonfirmasi bahwa partisi untuk akun Anda kompatibel dengan Apache Spark Connector dan mengatur izin IAM yang diperlukan. Praktik terbaik berikut membantu Anda menyediakan read/write kapasitas yang cukup untuk tabel.
1. Konfirmasikan bahwa `Murmur3Partitioner` partisi adalah partisi default untuk akun Anda. Partisi ini kompatibel dengan Konektor Spark Cassandra. Untuk informasi lebih lanjut tentang partisi dan cara mengubahnya, lihat. [Bekerja dengan partisi di Amazon Keyspaces](working-with-partitioners.md)
1. Siapkan izin IAM Anda untuk Amazon Keyspaces, menggunakan titik akhir VPC antarmuka, dengan Apache Spark.
+ Tetapkan read/write akses ke tabel pengguna dan baca akses ke tabel sistem seperti yang ditunjukkan dalam contoh kebijakan IAM yang tercantum di bawah ini.
+ [Mengisi tabel system.peers dengan titik akhir VPC antarmuka yang tersedia diperlukan untuk klien yang mengakses Amazon Keyspaces dengan Spark over VPC endpoint.](https://docs.aws.amazon.com/keyspaces/latest/devguide/vpc-endpoints.html)
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Select",
"cassandra:Modify"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
},
{
"Sid":"ListVPCEndpoints",
"Effect":"Allow",
"Action":[
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints"
],
"Resource":"*"
}
]
}
```
1. Pertimbangkan praktik terbaik berikut untuk mengonfigurasi kapasitas throughput baca/tulis yang memadai untuk tabel Amazon Keyspaces Anda guna mendukung lalu lintas dari Spark Cassandra Connector.
+ Mulai gunakan kapasitas sesuai permintaan untuk membantu Anda menguji skenario.
+ Untuk mengoptimalkan biaya throughput tabel untuk lingkungan produksi, gunakan pembatas laju untuk lalu lintas dari konektor, dan konfigurasikan tabel Anda untuk menggunakan kapasitas yang disediakan dengan penskalaan otomatis. Untuk informasi selengkapnya, lihat [Kelola kapasitas throughput secara otomatis dengan penskalaan otomatis Amazon Keyspaces](autoscaling.md).
+ Anda dapat menggunakan pembatas tarif tetap yang disertakan dengan driver Cassandra. [Ada beberapa [pembatas tarif yang disesuaikan dengan Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers) di repo sampel.AWS](https://github.com/aws-samples)
+ Untuk informasi selengkapnya tentang manajemen kapasitas, lihat[Konfigurasikan mode read/write kapasitas di Amazon Keyspaces](ReadWriteCapacityMode.md).
# Langkah 2: Konfigurasikan Konektor Spark Apache Cassandra
Apache Spark adalah platform komputasi tujuan umum yang dapat Anda konfigurasi dengan berbagai cara. Untuk mengonfigurasi Spark dan Spark Cassandra Connector untuk integrasi dengan Amazon Keyspaces, kami sarankan Anda memulai dengan pengaturan konfigurasi minimum yang dijelaskan di bagian berikut, dan kemudian meningkatkannya nanti sesuai dengan beban kerja Anda.
+ **Buat ukuran partisi Spark lebih kecil dari 8 MBs.**
Dalam Spark, *partisi* mewakili potongan atom data yang dapat dijalankan secara paralel. Saat Anda menulis data ke Amazon Keyspaces dengan Spark Cassandra Connector, semakin kecil partisi Spark, semakin kecil jumlah catatan yang akan ditulis tugas. Jika tugas Spark mengalami beberapa kesalahan, tugas gagal setelah jumlah percobaan ulang yang ditentukan habis. Untuk menghindari memutar ulang tugas besar dan memproses ulang banyak data, jaga agar ukuran partisi Spark tetap kecil.
+ **Gunakan jumlah penulisan bersamaan yang rendah per eksekutor dengan sejumlah besar percobaan ulang.**
Amazon Keyspaces mengembalikan kesalahan kapasitas yang tidak mencukupi kembali ke driver Cassandra sebagai batas waktu operasi. Anda tidak dapat mengatasi batas waktu yang disebabkan oleh kapasitas yang tidak mencukupi dengan mengubah durasi batas waktu yang dikonfigurasi karena Konektor Spark Cassandra mencoba ulang permintaan secara transparan menggunakan. `MultipleRetryPolicy` Untuk memastikan bahwa percobaan ulang tidak membanjiri kumpulan koneksi pengemudi, gunakan jumlah penulisan bersamaan yang rendah per eksekutor dengan sejumlah besar percobaan ulang. Cuplikan kode berikut adalah contohnya.
```
spark.cassandra.query.retry.count = 500
spark.cassandra.output.concurrent.writes = 3
```
+ **Memecah total throughput dan mendistribusikannya di beberapa sesi Cassandra.**
+ Konektor Cassandra Spark membuat satu sesi untuk setiap pelaksana Spark. Pikirkan sesi ini sebagai unit skala untuk menentukan throughput yang diperlukan dan jumlah koneksi yang diperlukan.
+ Saat menentukan jumlah core per eksekutor dan jumlah core per tugas, mulailah rendah dan tingkatkan sesuai kebutuhan.
+ Atur kegagalan tugas Spark untuk memungkinkan pemrosesan jika terjadi kesalahan sementara. Setelah Anda terbiasa dengan karakteristik dan persyaratan lalu lintas aplikasi Anda, kami sarankan pengaturan `spark.task.maxFailures` ke nilai terbatas.
+ Misalnya, konfigurasi berikut dapat menangani dua tugas bersamaan per pelaksana, per sesi:
```
spark.executor.instances = configurable -> number of executors for the session.
spark.executor.cores = 2 -> Number of cores per executor.
spark.task.cpus = 1 -> Number of cores per task.
spark.task.maxFailures = -1
```
+ **Matikan batching.**
+ Kami menyarankan Anda mematikan batching untuk meningkatkan pola akses acak. Cuplikan kode berikut adalah contohnya.
```
spark.cassandra.output.batch.size.rows = 1 (Default = None)
spark.cassandra.output.batch.grouping.key = none (Default = Partition)
spark.cassandra.output.batch.grouping.buffer.size = 100 (Default = 1000)
```
+ **Setel `SPARK_LOCAL_DIRS` ke disk lokal yang cepat dengan ruang yang cukup.**
+ Secara default, Spark menyimpan file keluaran peta dan kumpulan data terdistribusi yang tangguh () RDDs ke folder. `/tmp ` Bergantung pada konfigurasi host Spark Anda, ini dapat mengakibatkan *tidak ada ruang tersisa pada kesalahan gaya perangkat*.
+ Untuk mengatur variabel `SPARK_LOCAL_DIRS` lingkungan ke direktori yang disebut`/example/spark-dir`, Anda dapat menggunakan perintah berikut.
```
export SPARK_LOCAL_DIRS=/example/spark-dir
```
# Langkah 3: Buat file konfigurasi aplikasi
Untuk menggunakan Konektor Spark Cassandra open-source dengan Amazon Keyspaces, Anda perlu menyediakan file konfigurasi aplikasi yang berisi pengaturan yang diperlukan untuk terhubung dengan driver Java. DataStax Anda dapat menggunakan kredensyal khusus layanan atau plugin SiGv4 untuk terhubung.
Jika Anda belum melakukannya, Anda perlu mengonversi sertifikat digital yang digunakan untuk membuat koneksi TLS menjadi file TrustStore. Anda dapat mengikuti langkah-langkah rinci di [Sebelum Anda mulai](using_java_driver.md#using_java_driver.BeforeYouBegin) dari tutorial koneksi driver Java. Catat jalur file dan kata sandi TrustStore karena Anda memerlukan informasi ini saat membuat file konfigurasi aplikasi.
## Connect dengan otentikasi SiGv4
Bagian ini menunjukkan contoh `application.conf` file yang dapat Anda gunakan saat menghubungkan dengan AWS kredensyal dan plugin SigV4. Jika Anda belum melakukannya, Anda perlu membuat kunci akses IAM Anda (ID kunci akses dan kunci akses rahasia) dan menyimpannya di file AWS konfigurasi Anda atau sebagai variabel lingkungan. Untuk petunjuk mendetail, lihat [Kredensional yang diperlukan oleh, AWS SDK AWS CLI, atau plugin Amazon Keyspaces SigV4 untuk driver klien Cassandra](SigV4_credentials.md).
Dalam contoh berikut, ganti path file ke file TrustStore Anda, dan ganti kata sandi.
```
datastax-java-driver {
basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
basic.load-balancing-policy {
class = DefaultLoadBalancingPolicy
local-datacenter = us-east-1
slow-replica-avoidance = false
}
basic.request {
consistency = LOCAL_QUORUM
}
advanced {
auth-provider = {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-1
}
ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "path_to_file/cassandra_truststore.jks"
truststore-password = "password"
hostname-validation=false
}
}
advanced.connection.pool.local.size = 3
}
```
Perbarui dan simpan file konfigurasi ini sebagai`/home/user1/application.conf`. Contoh berikut menggunakan jalur ini.
## Connect dengan kredensi khusus layanan
Bagian ini menunjukkan contoh `application.conf` file yang dapat Anda gunakan saat menghubungkan dengan kredensyal khusus layanan. Jika Anda belum melakukannya, Anda perlu membuat kredensyal khusus layanan untuk Amazon Keyspaces. Untuk petunjuk mendetail, lihat [Buat kredensil khusus layanan untuk akses terprogram ke Amazon Keyspaces](programmatic.credentials.ssc.md).
Dalam contoh berikut, ganti `username` dan `password` dengan kredensyal Anda sendiri. Juga, ganti jalur file ke file TrustStore Anda, dan ganti kata sandi.
```
datastax-java-driver {
basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
basic.load-balancing-policy {
class = DefaultLoadBalancingPolicy
local-datacenter = us-east-1
}
basic.request {
consistency = LOCAL_QUORUM
}
advanced {
auth-provider = {
class = PlainTextAuthProvider
username = "username"
password = "password"
aws-region = "us-east-1"
}
ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "path_to_file/cassandra_truststore.jks"
truststore-password = "password"
hostname-validation=false
}
metadata = {
schema {
token-map.enabled = true
}
}
}
}
```
Perbarui dan simpan file konfigurasi ini `/home/user1/application.conf` untuk digunakan dengan contoh kode.
## Connect dengan tarif tetap
Untuk memaksa laju tetap per pelaksana Spark, Anda dapat menentukan throttler permintaan. Throttler permintaan ini membatasi tingkat permintaan per detik. Konektor Spark Cassandra menyebarkan sesi Cassandra per eksekutor. Menggunakan rumus berikut dapat membantu Anda mencapai throughput yang konsisten terhadap tabel.
```
max-request-per-second * numberOfExecutors = total throughput against a table
```
Anda dapat menambahkan contoh ini ke file konfigurasi aplikasi yang Anda buat sebelumnya.
```
datastax-java-driver {
advanced.throttler {
class = RateLimitingRequestThrottler
max-requests-per-second = 3000
max-queue-size = 30000
drain-interval = 1 millisecond
}
}
```
# Langkah 4: Siapkan data sumber dan tabel target di Amazon Keyspaces
Pada langkah ini, Anda membuat file sumber dengan data sampel dan tabel Amazon Keyspaces.
1. Buat file sumber. Anda dapat memilih salah satu opsi berikut:
+ Untuk tutorial ini, Anda 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. 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`.
+ Jika Anda ingin mengikuti file CSV Anda sendiri untuk menulis data ke Amazon Keyspaces, pastikan datanya diacak. Data yang dibaca langsung dari database atau diekspor ke file datar biasanya diurutkan oleh partisi dan kunci primer. Mengimpor data yang dipesan ke Amazon Keyspaces dapat menyebabkannya ditulis ke segmen yang lebih kecil dari partisi Amazon Keyspaces, yang menghasilkan distribusi lalu lintas yang tidak merata. Hal ini dapat menyebabkan kinerja lebih lambat dan tingkat kesalahan yang lebih tinggi.
Sebaliknya, pengacakan data membantu memanfaatkan kemampuan penyeimbangan beban bawaan Amazon Keyspaces dengan mendistribusikan lalu lintas di seluruh partisi secara lebih merata. Ada berbagai alat yang dapat Anda gunakan untuk mengacak data. Untuk contoh yang menggunakan alat sumber terbuka [Shuf](https://en.wikipedia.org/wiki/Shuf), lihat [Langkah 2: Siapkan data untuk diunggah menggunakan DSBulk](dsbulk-upload-prepare-data.md) di tutorial migrasi data. Berikut ini adalah contoh yang menunjukkan cara mengacak data sebagai `DataFrame` file.
```
import org.apache.spark.sql.functions.randval
shuffledDF = dataframe.orderBy(rand())
```
1. Buat keyspace target dan tabel di Amazon Keyspaces.
1. Connect ke Amazon Keyspaces menggunakan file. `cqlsh-expansion` Untuk petunjuk `cqlsh-expansion` penginstalan, lihat[Menggunakan untuk terhubung `cqlsh-expansion` ke Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
Ganti titik akhir layanan dalam contoh berikut dengan nilai Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --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)
);
```
# Langkah 5: Tulis dan baca data Amazon Keyspaces menggunakan Apache Cassandra Spark Connector
Pada langkah ini, Anda mulai dengan memuat data dari file sampel ke dalam `DataFrame` dengan Spark Cassandra Connector. Selanjutnya, Anda menulis data dari tabel `DataFrame` Amazon Keyspaces Anda. Anda juga dapat menggunakan bagian ini secara independen, misalnya, untuk memigrasikan data ke tabel Amazon Keyspaces. Akhirnya, Anda membaca data dari tabel Anda ke dalam `DataFrame` menggunakan Spark Cassandra Connector. Anda juga dapat menggunakan bagian ini secara independen, misalnya, untuk membaca data dari tabel Amazon Keyspaces untuk melakukan analisis data dengan Apache Spark.
1. Mulai Spark Shell seperti yang ditunjukkan pada contoh berikut. Perhatikan bahwa contoh ini menggunakan otentikasi SiGv4.
```
./spark-shell --files application.conf --conf spark.cassandra.connection.config.profile.path=application.conf --packages software.aws.mcs:aws-sigv4-auth-cassandra-java-driver-plugin:4.0.5,com.datastax.spark:spark-cassandra-connector_2.12:3.1.0 --conf spark.sql.extensions=com.datastax.spark.connector.CassandraSparkExtensions
```
1. Impor Konektor Spark Cassandra dengan kode berikut.
```
import org.apache.spark.sql.cassandra._
```
1. Untuk membaca data dari file CSV dan menyimpannya di a`DataFrame`, Anda dapat menggunakan contoh kode berikut.
```
var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv")
```
Anda dapat menampilkan hasilnya dengan perintah berikut.
```
scala> df.show();
```
Outputnya akan terlihat mirip dengan ini.
```
+----------------+----+-----------+----+------------------+--------------------+-------------+
| award|year| category|rank| author| book_title| publisher|
+----------------+----+-----------+----+------------------+--------------------+-------------+
|Kwesi Manu Prize|2020| Fiction| 1| Akua Mansa| Where did you go?|SomePublisher|
|Kwesi Manu Prize|2020| Fiction| 2| John Stiles| Yesterday|Example Books|
|Kwesi Manu Prize|2020| Fiction| 3| Nikki Wolf|Moving to the Cha...| AnyPublisher|
| Wolf|2020|Non-Fiction| 1| Wang Xiulan| History of Ideas|Example Books|
| Wolf|2020|Non-Fiction| 2|Ana Carolina Silva| Science Today|SomePublisher|
| Wolf|2020|Non-Fiction| 3| Shirley Rodriguez|The Future of Sea...| AnyPublisher|
| Richard Roe|2020| Fiction| 1| Alejandro Rosalez| Long Summer|SomePublisher|
| Richard Roe|2020| Fiction| 2| Arnav Desai| The Key|Example Books|
| Richard Roe|2020| Fiction| 3| Mateo Jackson| Inside the Whale| AnyPublisher|
+----------------+----+-----------+----+------------------+--------------------+-------------+
```
Anda dapat mengkonfirmasi skema data dalam `DataFrame` seperti yang ditunjukkan pada contoh berikut.
```
scala> df.printSchema
```
Outputnya akan terlihat seperti ini.
```
root
|-- award: string (nullable = true)
|-- year: integer (nullable = true)
|-- category: string (nullable = true)
|-- rank: integer (nullable = true)
|-- author: string (nullable = true)
|-- book_title: string (nullable = true)
|-- publisher: string (nullable = true)
```
1. Gunakan perintah berikut untuk menulis data di `DataFrame` tabel Amazon Keyspaces.
```
df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save()
```
1. Untuk mengonfirmasi bahwa data telah disimpan, Anda dapat membacanya kembali ke kerangka data, seperti yang ditunjukkan pada contoh berikut.
```
var newDf = spark.read.cassandraFormat("book_awards", "catalog").load()
```
Kemudian Anda dapat menampilkan data yang sekarang terkandung dalam kerangka data.
```
scala> newDf.show()
```
Output dari perintah itu akan terlihat seperti ini.
```
+--------------------+------------------+----------------+-----------+-------------+----+----+
| book_title| author| award| category| publisher|rank|year|
+--------------------+------------------+----------------+-----------+-------------+----+----+
| Long Summer| Alejandro Rosalez| Richard Roe| Fiction|SomePublisher| 1|2020|
| History of Ideas| Wang Xiulan| Wolf|Non-Fiction|Example Books| 1|2020|
| Where did you go?| Akua Mansa|Kwesi Manu Prize| Fiction|SomePublisher| 1|2020|
| Inside the Whale| Mateo Jackson| Richard Roe| Fiction| AnyPublisher| 3|2020|
| Yesterday| John Stiles|Kwesi Manu Prize| Fiction|Example Books| 2|2020|
|Moving to the Cha...| Nikki Wolf|Kwesi Manu Prize| Fiction| AnyPublisher| 3|2020|
|The Future of Sea...| Shirley Rodriguez| Wolf|Non-Fiction| AnyPublisher| 3|2020|
| Science Today|Ana Carolina Silva| Wolf|Non-Fiction|SomePublisher| 2|2020|
| The Key| Arnav Desai| Richard Roe| Fiction|Example Books| 2|2020|
+--------------------+------------------+----------------+-----------+-------------+----+----+
```
# Memecahkan masalah kesalahan umum saat menggunakan Konektor Spark Cassandra dengan Amazon Keyspaces
Jika Anda menggunakan Amazon Virtual Private Cloud dan Anda terhubung ke Amazon Keyspaces, kesalahan paling umum yang dialami saat menggunakan konektor Spark disebabkan oleh masalah konfigurasi berikut.
+ Pengguna atau peran IAM yang digunakan dalam VPC tidak memiliki izin yang diperlukan untuk mengakses tabel `system.peers` di Amazon Keyspaces. Untuk informasi selengkapnya, lihat [Mengisi entri `system.peers` tabel dengan informasi titik akhir VPC antarmuka](vpc-endpoints.md#system_peers).
+ Pengguna atau peran IAM tidak memiliki read/write izin yang diperlukan untuk tabel pengguna dan membaca akses ke tabel sistem di Amazon Keyspaces. Untuk informasi selengkapnya, lihat [Langkah 1: Konfigurasikan Amazon Keyspaces untuk integrasi dengan Apache Cassandra Spark Connector](spark-tutorial-step1.md).
+ Konfigurasi driver Java tidak menonaktifkan verifikasi nama host saat membuat koneksi SSL/TLS. Sebagai contoh, lihat [Langkah 2: Konfigurasikan driver](using_java_driver.md#java_tutorial.driverconfiguration).
Untuk langkah-langkah pemecahan masalah koneksi yang mendetail, lihat. [Koneksi titik akhir VPC saya tidak berfungsi dengan baik](troubleshooting.connecting.md#troubleshooting.connection.vpce)
Selain itu, Anda dapat menggunakan CloudWatch metrik Amazon untuk membantu Anda memecahkan masalah dengan konfigurasi Spark Cassandra Connector di Amazon Keyspaces. Untuk mempelajari selengkapnya tentang menggunakan Amazon Keyspaces dengan CloudWatch, lihat. [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md)
Bagian berikut menjelaskan metrik yang paling berguna untuk diamati saat Anda menggunakan Konektor Spark Cassandra.
**PerConnectionRequestRateExceeded**
Amazon Keyspaces memiliki kuota 3.000 permintaan per detik, per koneksi. Setiap pelaksana Spark membuat koneksi dengan Amazon Keyspaces. Menjalankan beberapa percobaan ulang dapat menghabiskan kuota tingkat permintaan per koneksi Anda. Jika Anda melebihi kuota ini, Amazon Keyspaces memancarkan `PerConnectionRequestRateExceeded` metrik dalam. CloudWatch
Jika Anda melihat PerConnectionRequestRateExceeded peristiwa hadir bersama dengan kesalahan sistem atau pengguna lainnya, kemungkinan Spark menjalankan beberapa percobaan ulang di luar jumlah permintaan yang dialokasikan per koneksi.
Jika Anda melihat `PerConnectionRequestRateExceeded` peristiwa tanpa kesalahan lain, maka Anda mungkin perlu meningkatkan jumlah koneksi di pengaturan driver Anda untuk memungkinkan lebih banyak throughput, atau Anda mungkin perlu meningkatkan jumlah pelaksana dalam pekerjaan Spark Anda.
**StoragePartitionThroughputCapacityExceeded**
Amazon Keyspaces memiliki kuota 1.000 WCUs atau WRUs per detik/3.000 atau per detik RCUs , per partisi. RRUs Jika Anda melihat `StoragePartitionThroughputCapacityExceeded` CloudWatch peristiwa, itu bisa menunjukkan bahwa data tidak diacak saat dimuat. Untuk contoh cara mengacak data, lihat[Langkah 4: Siapkan data sumber dan tabel target di Amazon Keyspaces](spark-tutorial-step4.md).
## Kesalahan dan peringatan umum
Jika Anda menggunakan Amazon Virtual Private Cloud dan Anda terhubung ke Amazon Keyspaces, driver Cassandra mungkin mengeluarkan pesan peringatan tentang node kontrol itu sendiri di tabel. `system.peers` Untuk informasi selengkapnya, lihat [Kesalahan dan peringatan umum](vpc-endpoints.md#vpc_troubleshooting). Anda dapat dengan aman mengabaikan peringatan ini.