Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Konfigurasikan mode read/write kapasitas di Amazon Keyspaces
Amazon Keyspaces memiliki dua mode read/write kapasitas untuk memproses membaca dan menulis di tabel Anda:
+ Sesuai permintaan (default)
+ Disediakan
Mode read/write kapasitas yang Anda pilih mengontrol bagaimana Anda dikenakan biaya untuk throughput baca dan tulis dan bagaimana kapasitas throughput tabel dikelola.
**Topics**
+ [Konfigurasikan mode kapasitas sesuai permintaan](ReadWriteCapacityMode.OnDemand.md)
+ [Konfigurasikan mode kapasitas yang disediakan](ReadWriteCapacityMode.Provisioned.md)
+ [Melihat mode kapasitas tabel di Amazon Keyspaces](ReadWriteCapacityMode.ProvisionedThroughput.ManagingCapacity.md)
+ [Ubah mode kapasitas tabel di Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
+ [Mengonfigurasikan prapenghangatan untuk tabel di Amazon Keyspaces](warm-throughput.md)
# Konfigurasikan mode kapasitas sesuai permintaan
Amazon Keyspaces (untuk Apache Cassandra) mode kapasitas *sesuai permintaan* adalah opsi penagihan fleksibel yang mampu melayani ribuan permintaan per detik tanpa perencanaan kapasitas. Opsi ini menawarkan pay-per-request harga untuk permintaan baca dan tulis sehingga Anda hanya membayar untuk apa yang Anda gunakan.
Saat Anda memilih mode sesuai permintaan, Amazon Keyspaces dapat menskalakan kapasitas throughput untuk tabel Anda hingga tingkat lalu lintas yang sebelumnya dicapai secara instan, dan kemudian mundur saat lalu lintas aplikasi menurun. Jika tingkat lalu lintas beban kerja mencapai puncak baru, layanan beradaptasi dengan cepat untuk meningkatkan kapasitas throughput untuk meja Anda. Anda dapat mengaktifkan mode kapasitas sesuai permintaan untuk tabel baru dan yang sudah ada.
Mode on-demand adalah pilihan yang baik jika salah satu dari berikut ini benar:
+ Anda membuat tabel baru dengan beban kerja yang tidak diketahui.
+ Anda memiliki lalu lintas aplikasi yang tidak dapat diprediksi.
+ Anda lebih menyukai kemudahan membayar hanya sesuai penggunaan.
Untuk memulai mode on-demand, Anda dapat membuat tabel baru atau memperbarui tabel yang ada untuk menggunakan mode kapasitas sesuai permintaan menggunakan konsol atau dengan beberapa baris kode Cassandra Query Language (CQL). Untuk informasi selengkapnya, lihat [Tabel](cql.ddl.table.md).
**Topics**
+ [Unit permintaan baca dan unit permintaan tulis](#ReadWriteCapacityMode.requests)
+ [Properti lalu lintas puncak dan penskalaan](#ReadWriteCapacityMode.PeakTraffic)
+ [Throughput awal untuk mode kapasitas sesuai permintaan](#ReadWriteCapacityMode.InitialThroughput)
## Unit permintaan baca dan unit permintaan tulis
Dengan tabel mode kapasitas sesuai permintaan, Anda tidak perlu menentukan berapa banyak throughput baca dan tulis yang Anda harapkan untuk digunakan aplikasi Anda sebelumnya. Amazon Keyspaces menagih Anda untuk membaca dan menulis yang Anda lakukan di tabel Anda dalam hal unit permintaan baca (RRUs) dan unit permintaan tulis (WRUs).
+ Satu *RRU* mewakili satu permintaan `LOCAL_QUORUM` baca, atau dua permintaan ` LOCAL_ONE` baca, untuk satu baris hingga 4 KB. Jika Anda perlu membaca baris yang lebih besar dari 4 KB, operasi baca menggunakan tambahan RRUs. Jumlah total yang RRUs dibutuhkan tergantung pada ukuran baris, dan apakah Anda ingin menggunakan `LOCAL_QUORUM` atau `LOCAL_ONE` membaca konsistensi. Misalnya, membaca baris 8 KB membutuhkan 2 RRUs menggunakan konsistensi `LOCAL_QUORUM` baca, dan 1 RRU jika Anda memilih konsistensi `LOCAL_ONE` baca.
+ Satu *WRU* mewakili satu tulis untuk satu baris dengan ukuran hingga 1 KB. Semua penulisan menggunakan `LOCAL_QUORUM` konsistensi, dan tidak ada biaya tambahan untuk menggunakan transaksi ringan (LWTs). Jika Anda perlu menulis baris yang lebih besar dari 1 KB, operasi tulis menggunakan tambahan WRUs. Jumlah total yang WRUs dibutuhkan tergantung pada ukuran baris. Misalnya, jika ukuran baris Anda adalah 2 KB, Anda memerlukan 2 WRUs untuk melakukan satu permintaan tulis.
Untuk informasi tentang tingkat konsistensi yang didukung, lihat[Mendukung Apache Cassandra membaca dan menulis tingkat konsistensi dan biaya terkait](consistency.md).
## Properti lalu lintas puncak dan penskalaan
Tabel Amazon Keyspaces yang menggunakan mode kapasitas sesuai permintaan secara otomatis beradaptasi dengan volume lalu lintas aplikasi Anda. Mode kapasitas sesuai permintaan secara instan mengakomodasi hingga dua kali lipat lalu lintas puncak sebelumnya pada sebuah tabel. Misalnya, pola lalu lintas aplikasi Anda mungkin bervariasi antara 5.000 dan 10.000 `LOCAL_QUORUM` pembacaan per detik, di mana 10.000 pembacaan per detik adalah puncak lalu lintas sebelumnya.
Dengan pola ini, mode kapasitas sesuai permintaan langsung mengakomodasi lalu lintas berkelanjutan hingga 20.000 pembacaan per detik. Jika aplikasi Anda mempertahankan lalu lintas 20.000 pembacaan per detik, puncak itu menjadi puncak baru Anda sebelumnya, memungkinkan lalu lintas berikutnya mencapai hingga 40.000 pembacaan per detik.
Jika Anda membutuhkan lebih dari dua kali lipat puncak sebelumnya di atas meja, Amazon Keyspaces secara otomatis mengalokasikan lebih banyak kapasitas saat volume lalu lintas Anda meningkat. Ini membantu memastikan bahwa tabel Anda memiliki kapasitas throughput yang cukup untuk memproses permintaan tambahan. Namun, Anda mungkin mengamati kesalahan kapasitas throughput yang tidak mencukupi jika Anda melebihi dua kali lipat puncak sebelumnya dalam 30 menit.
Misalnya, misalkan pola lalu lintas aplikasi Anda bervariasi antara 5.000 dan 10.000 pembacaan yang sangat konsisten per detik, di mana 20.000 pembacaan per detik adalah puncak lalu lintas yang dicapai sebelumnya. Dalam hal ini, layanan merekomendasikan agar Anda menempatkan pertumbuhan lalu lintas Anda setidaknya selama 30 menit sebelum mengemudi hingga 40.000 pembacaan per detik.
Untuk mempelajari cara memperkirakan konsumsi kapasitas baca dan tulis tabel, lihat[Perkirakan konsumsi kapasitas throughput baca dan tulis di Amazon Keyspaces](capacity-examples.md).
Untuk mempelajari lebih lanjut tentang kuota default untuk akun Anda dan cara meningkatkannya, lihat[Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md).
## Throughput awal untuk mode kapasitas sesuai permintaan
Jika Anda membuat tabel baru dengan mode kapasitas sesuai permintaan diaktifkan atau mengalihkan tabel yang ada ke mode kapasitas sesuai permintaan untuk pertama kalinya, tabel memiliki pengaturan puncak sebelumnya berikut, meskipun sebelumnya tidak melayani lalu lintas menggunakan mode kapasitas sesuai permintaan:
+ **Tabel yang baru dibuat dengan mode kapasitas sesuai permintaan:** Puncak sebelumnya adalah 2.000 WRUs dan RRUs 6.000. Anda dapat berkendara hingga menggandakan puncak sebelumnya dengan segera. Melakukan hal ini memungkinkan tabel on-demand yang baru dibuat untuk melayani hingga 4.000 WRUs dan 12.000. RRUs
+ **Tabel yang ada beralih ke mode kapasitas sesuai permintaan:** Puncak sebelumnya adalah setengah dari sebelumnya WCUs dan RCUs disediakan untuk tabel atau pengaturan untuk tabel yang baru dibuat dengan mode kapasitas sesuai permintaan, mana yang lebih tinggi.
# Konfigurasikan mode kapasitas yang disediakan
Jika Anda memilih mode kapasitas *throughput yang disediakan*, Anda menentukan jumlah pembacaan dan penulisan per detik yang diperlukan untuk aplikasi Anda. Ini membantu Anda mengelola penggunaan Amazon Keyspaces agar tetap pada atau di bawah tingkat permintaan yang ditentukan untuk mempertahankan prediktabilitas. Untuk mempelajari lebih lanjut tentang penskalaan otomatis untuk throughput yang disediakan, lihat. [Kelola kapasitas throughput secara otomatis dengan penskalaan otomatis Amazon Keyspaces](autoscaling.md)
Mode kapasitas throughput yang disediakan adalah pilihan yang baik jika salah satu dari berikut ini benar:
+ Anda memiliki lalu lintas aplikasi yang dapat diprediksi.
+ Anda menjalankan aplikasi yang lalu lintasnya konsisten atau naik secara bertahap.
+ Anda dapat memperkirakan persyaratan kapasitas.
## Unit kapasitas baca dan unit kapasitas tulis
Untuk tabel mode kapasitas throughput yang disediakan, Anda menentukan kapasitas throughput dalam hal unit kapasitas baca (RCUs) dan unit kapasitas tulis (): WCUs
+ Satu *RCU* mewakili satu `LOCAL_QUORUM` pembacaan per detik, atau dua `LOCAL_ONE` pembacaan per detik, untuk satu baris hingga 4 KB. Jika Anda perlu membaca baris yang lebih besar dari 4 KB, operasi baca menggunakan tambahan RCUs.
Jumlah total yang RCUs dibutuhkan tergantung pada ukuran baris, dan apakah Anda ingin `LOCAL_QUORUM` atau `LOCAL_ONE` membaca. Misalnya, jika ukuran baris Anda adalah 8 KB, Anda memerlukan 2 RCUs untuk mempertahankan satu `LOCAL_QUORUM` pembacaan per detik, dan 1 RCU jika Anda memilih `LOCAL_ONE` pembacaan.
+ Satu *WCU* mewakili satu tulis per detik untuk satu baris dengan ukuran hingga 1 KB. Semua penulisan menggunakan `LOCAL_QUORUM` konsistensi, dan tidak ada biaya tambahan untuk menggunakan transaksi ringan (LWTs). Jika Anda perlu menulis baris yang lebih besar dari 1 KB, operasi tulis menggunakan tambahan WCUs.
Jumlah total yang WCUs dibutuhkan tergantung pada ukuran baris. Misalnya, jika ukuran baris Anda adalah 2 KB, Anda memerlukan 2 WCUs untuk mempertahankan satu permintaan tulis per detik. Untuk informasi lebih lanjut tentang cara memperkirakan konsumsi kapasitas baca dan tulis tabel, lihat[Perkirakan konsumsi kapasitas throughput baca dan tulis di Amazon Keyspaces](capacity-examples.md).
Jika aplikasi Anda membaca atau menulis baris yang lebih besar (hingga ukuran baris maksimum Amazon Keyspaces sebesar 1 MB), aplikasi akan menghabiskan lebih banyak unit kapasitas. Untuk mempelajari lebih lanjut tentang cara memperkirakan ukuran baris, lihat[Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md). Misalnya, Anda membuat tabel yang disediakan dengan 6 RCUs dan 6. WCUs Dengan pengaturan ini, aplikasi Anda dapat melakukan hal berikut:
+ Lakukan `LOCAL_QUORUM` pembacaan hingga 24 KB per detik (4 KB × 6 RCUs).
+ Lakukan `LOCAL_ONE` pembacaan hingga 48 KB per detik (throughput baca dua kali lebih banyak).
+ Tulis hingga 6 KB per detik (1 KB × 6 WCUs).
*Throughput yang disediakan* adalah jumlah maksimum kapasitas throughput yang dapat dikonsumsi aplikasi dari sebuah tabel. Jika aplikasi Anda melebihi kapasitas throughput yang disediakan, Anda mungkin melihat kesalahan kapasitas yang tidak mencukupi.
Misalnya, permintaan baca yang tidak memiliki kapasitas throughput yang cukup gagal dengan `Read_Timeout` pengecualian dan diposting ke `ReadThrottleEvents` metrik. Permintaan tulis yang tidak memiliki kapasitas throughput yang cukup gagal dengan `Write_Timeout` pengecualian dan diposting ke `WriteThrottleEvents` metrik.
Anda dapat menggunakan Amazon CloudWatch untuk memantau metrik throughput yang disediakan dan aktual serta peristiwa kapasitas yang tidak mencukupi. Untuk informasi selengkapnya tentang metrik ini, lihat [Metrik dan dimensi Amazon Keyspaces](metrics-dimensions.md).
**catatan**
Kesalahan berulang karena kapasitas yang tidak mencukupi dapat menyebabkan pengecualian khusus driver sisi klien, misalnya driver DataStax Java gagal dengan file. `NoHostAvailableException`
Untuk mengubah pengaturan kapasitas throughput untuk tabel, Anda dapat menggunakan Konsol Manajemen AWS atau `ALTER TABLE` pernyataan menggunakan CQL, untuk informasi selengkapnya lihat. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
Untuk mempelajari lebih lanjut tentang kuota default untuk akun Anda dan cara meningkatkannya, lihat[Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md).
# Melihat mode kapasitas tabel di Amazon Keyspaces
Anda dapat menanyakan tabel sistem di ruang kunci sistem Amazon Keyspaces untuk meninjau informasi mode kapasitas tentang tabel. Anda juga dapat melihat apakah tabel menggunakan mode kapasitas throughput sesuai permintaan atau disediakan. Jika tabel dikonfigurasi dengan mode kapasitas throughput yang disediakan, Anda dapat melihat kapasitas throughput yang disediakan untuk tabel.
Anda juga dapat menggunakan AWS CLI untuk melihat mode kapasitas tabel.
Untuk mengubah throughput tabel yang disediakan, lihat. [Ubah mode kapasitas tabel di Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
------
#### [ Cassandra Query Language (CQL) ]
**Contoh**
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'mykeyspace' and table_name = 'mytable';
```
Tabel yang dikonfigurasi dengan mode kapasitas sesuai permintaan mengembalikan yang berikut ini.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579551547603",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Tabel yang dikonfigurasi dengan mode kapasitas throughput yang disediakan mengembalikan yang berikut ini.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579048006000",
"read_capacity_units":"5000",
"throughput_mode":"PROVISIONED",
"write_capacity_units":"6000"
}
}
```
`last_update_to_pay_per_request_timestamp`Nilai diukur dalam milidetik.
------
#### [ CLI ]
Melihat mode kapasitas throughput tabel menggunakan AWS CLI
```
aws keyspaces get-table --keyspace-name myKeyspace --table-name myTable
```
Output dari perintah dapat terlihat mirip dengan ini untuk tabel dalam mode kapasitas yang disediakan.
```
"capacitySpecification": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 4000,
"writeCapacityUnits": 2000
}
```
Output untuk tabel dalam mode on-demand terlihat seperti ini.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Ubah mode kapasitas tabel di Amazon Keyspaces
Saat Anda mengalihkan tabel dari mode kapasitas yang disediakan ke mode kapasitas sesuai permintaan, Amazon Keyspaces membuat beberapa perubahan pada struktur tabel dan partisi Anda. Proses ini dapat memakan waktu beberapa menit. Selama periode switching, tabel Anda memberikan throughput yang konsisten dengan jumlah WCU dan RCU yang telah disediakan sebelumnya.
Saat Anda beralih dari mode kapasitas sesuai permintaan kembali ke mode kapasitas yang disediakan, tabel Anda memberikan throughput yang konsisten dengan puncak sebelumnya yang dicapai saat tabel diatur ke mode kapasitas sesuai permintaan.
Periode tunggu berikut berlaku saat Anda beralih mode kapasitas:
+ Anda dapat mengganti tabel yang baru dibuat dalam mode sesuai permintaan ke mode kapasitas yang disediakan kapan saja. Namun, Anda hanya dapat mengubahnya kembali ke mode sesuai permintaan 24 jam setelah stempel waktu pembuatan tabel.
+ Anda dapat mengganti tabel yang ada dalam mode sesuai permintaan ke mode kapasitas yang disediakan kapan saja. Namun, Anda dapat mengubah mode kapasitas dari yang disediakan ke sesuai permintaan hanya sekali dalam periode 24 jam.
------
#### [ Cassandra Query Language (CQL) ]
**Ubah mode kapasitas throughput tabel menggunakan CQL**
1. Untuk mengubah mode kapasitas tabel untuk `PROVIOSIONED` Anda harus mengkonfigurasi kapasitas baca dan menulis unit kapasitas berdasarkan beban kerja Anda nilai puncak yang diharapkan. pernyataan berikut adalah contoh dari ini. Anda juga dapat menjalankan pernyataan ini untuk menyesuaikan kapasitas baca atau unit kapasitas tulis tabel.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 6000, 'write_capacity_units': 3000}};
```
Untuk mengonfigurasi mode kapasitas yang disediakan dengan auto-scaling, lihat. [Konfigurasikan penskalaan otomatis pada tabel yang ada](autoscaling.configureTable.md)
1. Untuk mengubah mode kapasitas tabel ke mode on-demand, atur mode throughput ke. `PAY_PER_REQUEST` Pernyataan berikut adalah contohnya.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PAY_PER_REQUEST'}};
```
1. Anda dapat menggunakan pernyataan berikut untuk mengonfirmasi mode kapasitas tabel.
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'catalog' and table_name = 'book_awards';
```
Tabel yang dikonfigurasi dengan mode kapasitas sesuai permintaan mengembalikan yang berikut ini.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1727952499092",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
`last_update_to_pay_per_request_timestamp`Nilai diukur dalam milidetik.
------
#### [ CLI ]
**Ubah mode kapasitas throughput tabel menggunakan AWS CLI**
1. Untuk mengubah mode kapasitas tabel, `PROVIOSIONED` Anda harus mengonfigurasi kapasitas baca dan unit kapasitas tulis berdasarkan nilai puncak yang diharapkan dari beban kerja Anda. Perintah berikut adalah contohnya. Anda juga dapat menjalankan perintah ini untuk menyesuaikan kapasitas baca atau unit kapasitas tulis tabel.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=6000,writeCapacityUnits=3000
```
Untuk mengonfigurasi mode kapasitas yang disediakan dengan auto-scaling, lihat. [Konfigurasikan penskalaan otomatis pada tabel yang ada](autoscaling.configureTable.md)
1. Untuk mengubah mode kapasitas tabel ke mode on-demand, Anda mengatur mode throughput ke. `PAY_PER_REQUEST` Pernyataan berikut adalah contohnya.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PAY_PER_REQUEST
```
1. Anda dapat menggunakan perintah berikut untuk meninjau mode kapasitas yang dikonfigurasi untuk tabel.
```
aws keyspaces get-table --keyspace-name catalog --table-name book_awards
```
Output untuk tabel dalam mode on-demand terlihat seperti ini.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Mengonfigurasikan prapenghangatan untuk tabel di Amazon Keyspaces
Amazon Keyspaces secara otomatis menskalakan partisi penyimpanan berdasarkan throughput sesuai permintaan atau yang disediakan, tetapi untuk tabel baru atau puncak throughput mendadak, diperlukan waktu lebih lama untuk mengalokasikan partisi penyimpanan yang diperlukan. *Untuk memastikan bahwa tabel baru atau yang sudah ada memiliki kapasitas yang cukup untuk mendukung throughput puncak yang diantisipasi, Anda dapat secara manual mengatur nilai *throughput hangat* tertentu untuk pra-pemanasan tabel Anda.*
*Throughput hangat* mengacu pada jumlah operasi baca dan tulis yang dapat didukung oleh tabel Amazon Keyspaces Anda secara instan. Nilai-nilai ini tersedia secara default untuk semua tabel baru dan yang sudah ada. Jika Anda menggunakan mode sesuai permintaan, atau jika Anda memperbarui throughput yang disediakan, Amazon Keyspaces memastikan bahwa aplikasi Anda dapat mengeluarkan permintaan hingga nilai tersebut secara instan.
Amazon Keyspaces secara otomatis menyesuaikan nilai throughput hangat saat penggunaan Anda meningkat. Untuk menyesuaikan kapasitas throughput untuk peristiwa puncak yang akan datang, misalnya saat Anda memigrasikan data dari database lain, yang mungkin memerlukan pemuatan terabyte data dalam waktu singkat, Anda dapat meningkatkan nilai throughput hangat tabel secara manual. Ini berguna untuk peristiwa puncak yang direncanakan di mana tingkat permintaan mungkin meningkat 10x, 100x, atau lebih. Pertama, menilai apakah throughput hangat saat ini cukup untuk menangani lalu lintas yang diharapkan. [Kemudian, jika Anda perlu melakukan pra-pemanasan tabel untuk beban kerja puncak yang direncanakan, Anda dapat meningkatkan nilai throughput hangat secara manual tanpa mengubah pengaturan throughput atau mode kapasitas Anda.](ReadWriteCapacityMode.md)
Anda dapat melakukan pra-pemanasan tabel untuk operasi baca, operasi tulis, atau keduanya. Anda dapat meningkatkan nilai ini untuk tabel Single-region baru dan yang sudah ada serta tabel Multi-region dan pengaturan throughput hangat yang Anda tetapkan berlaku secara otomatis ke semua replika tabel Multi-wilayah. Tidak ada batasan jumlah tabel Amazon Keyspaces yang dapat Anda hangatkan kapan saja. Waktu untuk menyelesaikan pra-pemanasan tergantung pada nilai yang Anda tetapkan dan ukuran tabel. Anda dapat mengirimkan permintaan pra-hangat secara simultan dan permintaan ini tidak mengganggu operasi tabel apa pun. Anda dapat melakukan pra-pemanasan tabel hingga batas kuota tabel untuk akun Anda di Wilayah tersebut. Gunakan [konsol Service Quotas untuk memeriksa kuota](https://console.aws.amazon.com/servicequotas) Anda saat ini dan meningkatkannya jika diperlukan.
Nilai throughput hangat yang disesuaikan Amazon Keyspaces berdasarkan penggunaan sesuai permintaan atau kapasitas yang disediakan tersedia secara default untuk semua tabel tanpa biaya tambahan. Namun, jika Anda secara manual meningkatkan nilai throughput hangat default ke tabel pra-hangat untuk peristiwa lalu lintas puncak, biaya tambahan akan berlaku. Untuk informasi selengkapnya, lihat [harga Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/).
Berikut adalah beberapa skenario dan praktik terbaik yang mungkin Anda pertimbangkan saat melakukan pra-pemanasan tabel Amazon Keyspaces.
## Throughput hangat dan pola akses yang tidak merata
Sebuah tabel mungkin memiliki throughput hangat 30.000 unit baca per detik dan 10.000 unit tulis per detik, tetapi Anda masih dapat mengalami kapasitas melebihi peristiwa saat membaca atau menulis sebelum mencapai nilai tersebut. Ini kemungkinan karena partisi panas. Meskipun Amazon Keyspaces dapat terus melakukan penskalaan untuk mendukung throughput yang hampir tidak terbatas, setiap partisi individu dibatasi hingga 1.000 unit tulis per detik dan 3.000 unit baca per detik. Jika aplikasi Anda mengarahkan terlalu banyak lalu lintas ke sebagian kecil partisi tabel, kapasitas melebihi peristiwa dapat terjadi bahkan sebelum Anda mencapai nilai throughput hangat tabel. Sebaiknya ikuti [praktik terbaik Amazon Keyspaces](bp-partition-key-design.md) untuk memastikan skalabilitas yang mulus dan menghindari partisi panas.
## Throughput hangat untuk tabel yang disediakan
Pertimbangkan tabel yang disediakan yang memiliki throughput hangat 30.000 unit baca per detik dan 10.000 unit tulis per detik tetapi saat ini memiliki throughput yang disediakan 4.000 dan 8.000. RCUs WCUs Anda dapat langsung menskalakan throughput yang disediakan tabel hingga 30.000 RCUs atau 10.000 WCUs dengan memperbarui pengaturan throughput yang disediakan. Saat Anda meningkatkan throughput yang disediakan di luar nilai-nilai ini, throughput hangat menyesuaikan secara otomatis ke nilai baru yang lebih tinggi, karena Anda telah menetapkan throughput puncak baru. Misalnya, jika Anda menyetel throughput yang disediakan ke 50.000 RCU, throughput hangat meningkat menjadi 50.000 unit baca per detik.
```
"ProvisionedThroughput":
{
"ReadCapacityUnits": 4000,
"WriteCapacityUnits": 8000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```
## Throughput hangat untuk meja sesuai permintaan
Tabel on-demand baru dimulai dengan throughput hangat 12.000 unit baca per detik dan 4.000 unit tulis per detik. Meja Anda dapat langsung mengakomodasi lalu lintas berkelanjutan hingga level ini. Jika permintaan Anda melebihi 12.000 unit baca per detik atau 4.000 unit tulis per detik, throughput hangat menyesuaikan secara otomatis ke nilai yang lebih tinggi.
```
"WarmThroughput":
{
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000
}
```
## Praktik terbaik untuk tabel Amazon Keyspaces pra-pemanasan
Ikuti praktik terbaik ini saat menerapkan pra-pemanasan untuk tabel Amazon Keyspaces Anda:
Memperkirakan kapasitas yang dibutuhkan secara akurat
Karena pra-pemanasan menimbulkan biaya satu kali, hitung dengan cermat throughput yang dibutuhkan berdasarkan beban kerja yang diharapkan untuk menghindari penyediaan berlebih.
Pertimbangkan skema tabel
Tabel dengan baris yang lebih besar mungkin memerlukan lebih banyak partisi untuk throughput yang sama. Faktor ukuran baris rata-rata Anda saat memperkirakan persyaratan pra-pemanasan.
Pantau kinerja meja
Setelah pemanasan awal, gunakan CloudWatch metrik untuk memverifikasi bahwa tabel Anda menangani beban seperti yang diharapkan. Untuk informasi selengkapnya, lihat [Pantau kinerja tabel pra-pemanasan menggunakan Amazon CloudWatch](monitor-prewarming-cloudwatch.md).
Kelola kuota
Jika aplikasi Anda memerlukan throughput yang lebih tinggi daripada kuota default yang diizinkan (40.000 RCUs/WCUs atau 2.000 partisi), kuota permintaan meningkat jauh sebelum peristiwa lalu lintas tinggi Anda. Untuk meminta peningkatan kuota, gunakan konsol [Service Quotas](https://console.aws.amazon.com/servicequotas).
Optimalkan biaya
Untuk peristiwa lalu lintas tinggi sementara, pertimbangkan untuk menggunakan pra-pemanasan alih-alih beralih ke mode yang disediakan dengan kapasitas tinggi, karena mungkin lebih hemat biaya untuk acara berdurasi pendek. Untuk informasi selengkapnya tentang harga, lihat harga [Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/).
**catatan**
Pantau metrik kinerja aplikasi Anda selama fase pengujian untuk memvalidasi bahwa konfigurasi pra-pemanasan mendukung persyaratan beban kerja Anda secara memadai.
**Topics**
+ [Throughput hangat dan pola akses yang tidak merata](#warm-throughput-scenarios-uneven)
+ [Throughput hangat untuk tabel yang disediakan](#warm-throughput-scenarios-provisioned)
+ [Throughput hangat untuk meja sesuai permintaan](#warm-throughput-scenarios-ondemand)
+ [Praktik terbaik untuk tabel Amazon Keyspaces pra-pemanasan](#prewarming-best-practices)
+ [Membuat tabel Amazon Keyspaces baru dengan throughput hangat yang lebih tinggi](create-table-warm-throughput.md)
+ [Meningkatkan throughput hangat tabel Amazon Keyspaces yang ada](update-warm-throughput.md)
+ [Lihat throughput hangat dari tabel Amazon Keyspaces](view-warm-throughput.md)
+ [Pantau kinerja tabel pra-pemanasan menggunakan Amazon CloudWatch](monitor-prewarming-cloudwatch.md)
# Membuat tabel Amazon Keyspaces baru dengan throughput hangat yang lebih tinggi
Anda dapat menyesuaikan nilai throughput hangat saat membuat tabel Amazon Keyspaces menggunakan konsol, CQL, atau tabel. AWS CLI
------
#### [ Console ]
**Cara membuat tabel baru dengan pengaturan throughput hangat**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Tabel**, lalu pilih **Buat tabel**.
1. Pada halaman **Buat tabel** di bagian **Rincian tabel**, pilih ruang kunci dan berikan nama untuk tabel baru.
1. Di bagian **Kolom**, buat skema untuk tabel Anda.
1. Di bagian **kunci Primer**, tentukan kunci utama tabel dan pilih kolom pengelompokan opsional.
1. Di bagian **Pengaturan tabel**, pilih **Sesuaikan pengaturan**.
1. Lanjutkan untuk **membaca/menulis pengaturan kapasitas**.
1. Untuk **mode Kapasitas**, Anda dapat memilih **On-Demand** atau **Provisioned**.
1. Di bagian **Pra-pemanasan untuk tabel**, Anda dapat meningkatkan nilai untuk **unit Baca per detik** dan **Tulis unit per detik** sesuai kebutuhan untuk mempersiapkan tabel Anda untuk menangani peristiwa puncak yang direncanakan.
Nilai throughput hangat yang disesuaikan Amazon Keyspaces berdasarkan penggunaan sesuai permintaan atau kapasitas yang disediakan tersedia secara default untuk semua tabel tanpa biaya tambahan. Perhatikan bahwa jika Anda secara manual meningkatkan nilai throughput hangat default untuk menghangatkan tabel untuk peristiwa lalu lintas puncak, biaya tambahan akan berlaku.
1. Konfigurasikan fitur tabel opsional lainnya sesuai kebutuhan. Kemudian pilih **Buat tabel**.
------
#### [ Cassandra Query Language (CQL) ]
+ Buat tabel dengan throughput hangat menggunakan salah satu metode berikut:
+ Untuk mode yang disediakan, buat tabel dan tentukan kapasitas puncak yang diharapkan untuk membaca dan menulis menggunakan sintaks CQL berikut:
```
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))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 20000,
'write_capacity_units': 10000
},
'warm_throughput': {
'read_units_per_second': 40000,
'write_units_per_second': 20000
}
};
```
+ Untuk mode sesuai permintaan, buat tabel dan tentukan kapasitas puncak yang diharapkan untuk membaca dan menulis menggunakan sintaks CQL berikut:
```
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))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PAY_PER_REQUEST'
},
'warm_throughput': {
'read_units_per_second': 40000,
'write_units_per_second': 20000
}
};
```
Untuk mengonfirmasi pengaturan kapasitas tabel, lihat[Lihat throughput hangat dari tabel Amazon Keyspaces](view-warm-throughput.md).
------
#### [ CLI ]
1. Buat tabel dengan throughput hangat menggunakan salah satu metode berikut menggunakan AWS CLI
+ Buat tabel baru dalam mode yang disediakan dan tentukan nilai kapasitas puncak yang diharapkan untuk membaca dan menulis untuk tabel baru. Pernyataan berikut adalah contoh dari ini.
```
aws keyspaces create-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=20000,writeCapacityUnits=10000 \
--warm-throughput-specification readUnitsPerSecond=40000,writeUnitsPerSecond=20000
```
+ Buat tabel baru dalam mode sesuai permintaan dan tentukan nilai kapasitas puncak yang diharapkan untuk membaca dan menulis untuk tabel baru. Pernyataan berikut adalah contoh dari ini.
```
aws keyspaces create-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},{name=category,type=text},{name=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
--warmThroughputSpecification readUnitsPerSecond=40000,writeUnitsPerSecond=20000
```
1. Output dari perintah mengembalikan ARN dari tabel seperti yang ditunjukkan pada contoh berikut.
```
{
"resourceArn": "arn:aws::cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards>"
}
```
Untuk mengonfirmasi pengaturan kapasitas tabel, lihat[Lihat throughput hangat dari tabel Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**Buat tabel baru menggunakan SDK for Java.**
+ Buat tabel baru dalam mode yang disediakan dan tentukan nilai kapasitas puncak yang diharapkan untuk membaca dan menulis untuk tabel baru. Contoh kode berikut adalah contoh dari ini.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class PreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Define schema
List columns = Arrays.asList(
ColumnDefinition.builder().name("year").type("int").build(),
ColumnDefinition.builder().name("award").type("text").build(),
ColumnDefinition.builder().name("rank").type("int").build(),
ColumnDefinition.builder().name("category").type("text").build(),
ColumnDefinition.builder().name("book_title").type("text").build(),
ColumnDefinition.builder().name("author").type("text").build(),
ColumnDefinition.builder().name("publisher").type("text").build()
);
List partitionKeys = Arrays.asList(
PartitionKey.builder().name("year").build(),
PartitionKey.builder().name("award").build()
);
List clusteringKeys = Arrays.asList(
ClusteringKey.builder().name("category").orderBy("ASC").build(),
ClusteringKey.builder().name("rank").orderBy("ASC").build()
);
SchemaDefinition schema = SchemaDefinition.builder()
.allColumns(columns)
.partitionKeys(partitionKeys)
.clusteringKeys(clusteringKeys)
.build();
// Define capacity specification
CapacitySpecification capacitySpec = CapacitySpecification.builder()
.throughputMode(ThroughputMode.PROVISIONED)
.readCapacityUnits(20000)
.writeCapacityUnits(10000)
.build();
// Define warm throughput specification
WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
.readUnitsPerSecond(40000L)
.writeUnitsPerSecond(20000L)
.build();
// Create table with PreWarming
CreateTableRequest request = CreateTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.schemaDefinition(schema)
.capacitySpecification(capacitySpec)
.warmThroughputSpecification(warmThroughput)
.build();
CreateTableResponse response = keyspacesClient.createTable(request);
System.out.println("Table created with ARN: " + response.resourceArn());
}
}
```
------
# Meningkatkan throughput hangat tabel Amazon Keyspaces yang ada
Anda dapat meningkatkan nilai throughput hangat tabel Amazon Keyspaces saat ini menggunakan konsol, CQL, atau. AWS CLI
------
#### [ Console ]
**Cara meningkatkan pengaturan pra-hangat tabel menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Tabel**, lalu pilih tabel yang ingin Anda perbarui.
1. Pada tab **Kapasitas** tabel, lanjutkan ke **Pra-pemanasan untuk tabel**.
1. Di bagian **Pra-pemanasan untuk tabel**, pilih **Edit**.
1. Pada halaman **Edit pra-pemanasan untuk tabel**, Anda dapat memperbarui nilai untuk **unit Baca per detik** dan untuk **unit Tulis per detik**.
1. Pilih **Simpan perubahan**. Tabel Anda diperbarui dengan pengaturan pra-pemanasan yang ditentukan.
------
#### [ Cassandra Query Language (CQL) ]
**Tingkatkan pengaturan throughput hangat dari tabel menggunakan CQL**
+ Gunakan `ALTER TABLE` pernyataan untuk meningkatkan throughput hangat dari sebuah tabel. Pernyataan berikut adalah contoh dari ini.
```
ALTER TABLE catalog.book_awards
WITH CUSTOM_PROPERTIES = {
'warm_throughput': {
'read_units_per_second': 60000,
'write_units_per_second': 30000
}
};
```
Untuk mengonfirmasi pengaturan kapasitas tabel yang diperbarui, lihat[Lihat throughput hangat dari tabel Amazon Keyspaces](view-warm-throughput.md).
------
#### [ CLI ]
**Tingkatkan pengaturan pra-pemanasan tabel menggunakan AWS CLI**
+ Untuk meningkatkan throughput hangat tabel, Anda dapat menggunakan perintah. `update-table` Pernyataan berikut adalah contoh dari ini.
```
aws keyspaces update-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--warmThroughputSpecification readUnitsPerSecond=60000,writeUnitsPerSecond=30000
```
Untuk mengonfirmasi pengaturan kapasitas tabel yang diperbarui, lihat[Lihat throughput hangat dari tabel Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**Perbarui pengaturan pra-pemanasan tabel menggunakan SDK for Java.**
+ Perbarui pengaturan throughput hangat untuk sebuah tabel. Contoh kode berikut adalah contoh dari ini.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class UpdatePreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Define new warm throughput specification
WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
.readUnitsPerSecond(60000L)
.writeUnitsPerSecond(30000L)
.build();
// Update table with new PreWarming settings
UpdateTableRequest request = UpdateTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.warmThroughputSpecification(warmThroughput)
.build();
UpdateTableResponse response = keyspacesClient.updateTable(request);
System.out.println("Table update requested: " + response.resourceArn());
}
}
```
------
# Lihat throughput hangat dari tabel Amazon Keyspaces
Anda dapat melihat nilai throughput hangat tabel Amazon Keyspaces saat ini menggunakan konsol, CQL, atau. AWS CLI
------
#### [ Console ]
**Cara melihat pengaturan pra-pemanasan tabel Anda menggunakan konsol.**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Tabel**, lalu pilih tabel yang ingin Anda tinjau.
1. Pada tab **Kapasitas** tabel, lanjutkan ke **Pra-pemanasan untuk tabel**.
------
#### [ Cassandra Query Language (CQL) ]
**Melihat pengaturan throughput hangat dari tabel menggunakan CQL**
+ Untuk melihat pengaturan hangat-throughput tabel, Anda dapat menggunakan pernyataan CQL berikut.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name='catalog' and table_name='book_awards';
// Output:
...
custom_properties
----------------------------------------------------------------------------------
{
'warm_throughput':
{
'read_units_per_second': '40000',
'write_units_per_second': '20000',
'status': 'AVAILABLE'
}
}
...
```
------
#### [ CLI ]
**Melihat pengaturan throughput hangat dari tabel menggunakan AWS CLI**
+ Anda dapat melihat pengaturan hangat-throughput tabel menggunakan `get-table` perintah seperti yang ditunjukkan pada contoh berikut.
```
aws keyspaces get-table \
--keyspace-name 'catalog' \
--table-name 'book_awards'
```
Berikut ini menunjukkan contoh output dari `get-table` perintah untuk tabel Single-region dalam mode yang disediakan.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
... Existing Fields ...,
"capacitySpecificationSummary": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 20000,
"writeCapacityUnits": 10000
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
Berikut ini menunjukkan contoh output untuk tabel Single-region dalam mode on-demand.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards_ondemand",
... Existing Fields ...,
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST"
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
------
#### [ Java ]
**Baca pengaturan pra-pemanasan tabel menggunakan SDK for Java.**
+ Baca nilai throughput hangat dari tabel menggunakan. `get-table` Contoh kode berikut adalah contoh dari ini.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class GetTableWithPreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Get table details including PreWarming specification
GetTableRequest request = GetTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.build();
GetTableResponse response = keyspacesClient.getTable(request);
// Access PreWarming details
if (response.warmThroughputSpecification() != null) {
WarmThroughputSpecificationSummary warmThroughputSummary = response.warmThroughputSpecification();
System.out.println("PreWarming Status: " + warmThroughputSummary.status());
System.out.println("Read Units: " + warmThroughputSummary.readUnitsPerSecond());
System.out.println("Write Units: " + warmThroughputSummary.writeUnitsPerSecond());
// Check if PreWarming is active
if (warmThroughputSummary.status().equals("AVAILABLE")) {
System.out.println("Table is fully pre-warmed and ready for high throughput");
} else if (warmThroughputSummary.status().equals("UPDATING")) {
System.out.println("Table PreWarming is currently being updated");
}
} else {
System.out.println("Table does not have PreWarming enabled");
}
}
}
```
------
# Pantau kinerja tabel pra-pemanasan menggunakan Amazon CloudWatch
Amazon Keyspaces pra-pemanasan tidak memperkenalkan CloudWatch metrik baru, tetapi Anda dapat memantau kinerja tabel pra-pemanasan menggunakan metrik Amazon Keyspaces yang ada:
SuccessfulRequestLatency
Pantau metrik ini untuk memverifikasi bahwa tabel pra-pemanasan menangani permintaan dengan latensi yang diharapkan.
WriteThrottleEvents dan ReadThrottleEvents
Metrik ini harus tetap rendah untuk tabel pra-pemanasan yang benar. Jika Anda melihat kesalahan kapasitas yang tidak mencukupi meskipun pra-pemanasan, Anda mungkin perlu menyesuaikan nilai throughput hangat Anda.
ConsumedReadCapacityUnits dan ConsumedWriteCapacityUnits
Metrik ini menunjukkan konsumsi kapasitas aktual, yang dapat membantu memvalidasi jika konfigurasi pra-pemanasan Anda sesuai.
ProvisionedReadCapacityUnits dan ProvisionedWriteCapacityUnits
Untuk tabel yang disediakan, metrik ini menunjukkan kapasitas yang saat ini dialokasikan.
Metrik ini dapat dilihat di CloudWatch konsol atau ditanyakan menggunakan API. CloudWatch Lihat informasi yang lebih lengkap di [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md).