Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengelola sumber daya tanpa server di Amazon Keyspaces (untuk Apache Cassandra)
Amazon Keyspaces (untuk Apache Cassandra) bersifat nirserver. Alih-alih menerapkan, mengelola, dan memelihara penyimpanan dan menghitung sumber daya untuk beban kerja Anda melalui node dalam klaster, Amazon Keyspaces mengalokasikan sumber daya penyimpanan dan throughput langsung ke tabel. read/write
Amazon Keyspaces menyediakan penyimpanan secara otomatis berdasarkan data yang disimpan dalam tabel Anda. Ini menskalakan penyimpanan ke atas dan ke bawah saat Anda menulis, memperbarui, dan menghapus data, dan Anda hanya membayar untuk penyimpanan yang Anda gunakan. Data direplikasi di beberapa [Availability Zone](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) untuk ketersediaan tinggi. Amazon Keyspaces memonitor ukuran tabel Anda secara terus menerus untuk menentukan biaya penyimpanan Anda. Untuk informasi selengkapnya tentang cara Amazon Keyspaces menghitung ukuran data yang dapat ditagih, lihat. [Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md)
Bab ini mencakup aspek-aspek kunci manajemen sumber daya di Amazon Keyspaces.
+ **Perkirakan ukuran baris** — Untuk memperkirakan ukuran baris yang dikodekan di Amazon Keyspaces, pertimbangkan faktor-faktor seperti metadata kunci partisi, metadata kolom pengelompokan, pengidentifikasi kolom, tipe data, dan metadata baris. Ukuran baris yang dikodekan ini digunakan untuk penagihan, manajemen kuota, dan perencanaan kapasitas throughput yang disediakan.
+ **Perkirakan konsumsi kapasitas** — Bagian ini mencakup contoh cara memperkirakan konsumsi kapasitas baca dan tulis untuk skenario umum seperti kueri rentang, kueri batas, pemindaian tabel, transaksi ringan, kolom statis, dan tabel Multi-wilayah. Anda dapat menggunakan Amazon CloudWatch untuk memantau pemanfaatan kapasitas aktual. Untuk informasi lebih lanjut tentang pemantauan dengan CloudWatch, lihat[Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md).
+ **Mengkonfigurasi mode read/write kapasitas** - Anda dapat memilih antara dua mode kapasitas untuk memproses membaca dan menulis di tabel Anda:
+ **Mode sesuai permintaan (default)** - Bayar per permintaan untuk throughput baca dan tulis. Amazon Keyspaces dapat secara instan meningkatkan kapasitas hingga tingkat lalu lintas yang dicapai sebelumnya.
+ **Mode yang disediakan** - Tentukan jumlah unit kapasitas baca dan tulis yang diperlukan terlebih dahulu. Mode ini membantu mempertahankan kinerja throughput yang dapat diprediksi.
+ **Kelola kapasitas throughput dengan penskalaan otomatis** — Untuk tabel yang disediakan, Anda dapat mengaktifkan penskalaan otomatis untuk menyesuaikan kapasitas throughput secara otomatis berdasarkan lalu lintas aplikasi aktual. Amazon Keyspaces menggunakan pelacakan target untuk menambah atau mengurangi kapasitas yang disediakan, menjaga pemanfaatan pada target yang Anda tentukan.
+ **Gunakan kapasitas burst secara efektif** — Amazon Keyspaces menyediakan kapasitas burst dengan memesan sebagian throughput yang tidak digunakan untuk menangani lonjakan lalu lintas. Fleksibilitas ini memungkinkan ledakan aktivitas sesekali di luar throughput yang Anda berikan.
Untuk memecahkan masalah kesalahan kapasitas, lihat. [Kesalahan kapasitas tanpa server](troubleshooting.serverless.md#troubleshooting-serverless)
**Topics**
+ [Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md)
+ [Perkirakan konsumsi kapasitas throughput baca dan tulis di Amazon Keyspaces](capacity-examples.md)
+ [Konfigurasikan mode read/write kapasitas di Amazon Keyspaces](ReadWriteCapacityMode.md)
+ [Kelola kapasitas throughput secara otomatis dengan penskalaan otomatis Amazon Keyspaces](autoscaling.md)
+ [Gunakan kapasitas burst secara efektif di Amazon Keyspaces](throughput-bursting.md)
# Perkirakan ukuran baris di Amazon Keyspaces
Amazon Keyspaces menyediakan penyimpanan terkelola penuh yang menawarkan kinerja baca dan tulis milidetik satu digit dan menyimpan data secara tahan lama di beberapa Availability Zone. AWS Amazon Keyspaces melampirkan metadata ke semua baris dan kolom kunci utama untuk mendukung akses data yang efisien dan ketersediaan tinggi.
Topik ini memberikan detail tentang cara memperkirakan ukuran baris yang dikodekan di Amazon Keyspaces. Ukuran baris yang dikodekan digunakan saat menghitung tagihan dan penggunaan kuota Anda. Anda juga dapat menggunakan ukuran baris yang dikodekan saat memperkirakan persyaratan kapasitas throughput yang disediakan untuk tabel.
Untuk menghitung ukuran baris yang dikodekan di Amazon Keyspaces, Anda dapat menggunakan panduan berikut.
**Topics**
+ [Perkirakan ukuran kolom yang dikodekan](#calculating-row-size-columns)
+ [Perkirakan ukuran nilai data yang dikodekan berdasarkan tipe data](#calculating-row-size-data-types)
+ [Pertimbangkan dampak fitur Amazon Keyspaces pada ukuran baris](#calculating-row-size-features)
+ [Pilih rumus yang tepat untuk menghitung ukuran baris yang dikodekan](#calculating-row-size-formula)
+ [Contoh perhitungan ukuran baris](#calculating-row-size-example)
## Perkirakan ukuran kolom yang dikodekan
Bagian ini menunjukkan cara memperkirakan ukuran kolom yang dikodekan di Amazon Keyspaces.
+ **Kolom** reguler — Untuk kolom reguler, yang merupakan kolom yang bukan kunci utama, kolom pengelompokan, atau `STATIC` kolom, gunakan ukuran mentah data sel berdasarkan [tipe data](cql.elements.md#cql.data-types) dan tambahkan metadata yang diperlukan. Tipe data dan beberapa perbedaan utama dalam cara Amazon Keyspaces menyimpan nilai tipe data dan metadata tercantum di bagian berikutnya.
+ **Kolom kunci partisi** - Tombol partisi dapat berisi hingga 2048 byte data. Setiap kolom kunci dalam kunci partisi membutuhkan hingga 3 byte metadata. Saat menghitung ukuran baris Anda, Anda harus menganggap setiap kolom kunci partisi menggunakan metadata 3 byte penuh.
+ **Kolom pengelompokan** - Kolom pengelompokan dapat menyimpan hingga 850 byte data. Selain ukuran nilai data, setiap kolom pengelompokan membutuhkan hingga 20% dari ukuran nilai data untuk metadata. Saat menghitung ukuran baris Anda, Anda harus menambahkan 1 byte metadata untuk setiap 5 byte nilai data kolom pengelompokan.
**catatan**
Untuk mendukung kueri yang efisien dan pengindeksan bawaan, Amazon Keyspaces menyimpan nilai data dari setiap kunci partisi dan kolom kunci pengelompokan dua kali.
+ **Nama kolom** - Ruang yang diperlukan untuk setiap nama kolom disimpan menggunakan pengidentifikasi kolom dan ditambahkan ke setiap nilai data yang disimpan di kolom. Nilai penyimpanan pengenal kolom tergantung pada jumlah keseluruhan kolom dalam tabel Anda:
+ 1—62 kolom: 1 byte
+ 63—124 kolom: 2 byte
+ 125—186 kolom: 3 byte
Untuk setiap tambahan 62 kolom tambahkan 1 byte. Perhatikan bahwa di Amazon Keyspaces, hingga 225 kolom reguler dapat dimodifikasi dengan satu `INSERT` atau pernyataan. `UPDATE` Untuk informasi selengkapnya, lihat [Kuota layanan Amazon Keyspaces](quotas.md#table).
## Perkirakan ukuran nilai data yang dikodekan berdasarkan tipe data
Bagian ini menunjukkan cara memperkirakan ukuran yang dikodekan dari berbagai tipe data di Amazon Keyspaces.
+ **Jenis string** — Cassandra`ASCII`,`TEXT`, dan tipe data `VARCHAR` string semuanya disimpan di Amazon Keyspaces menggunakan Unicode dengan pengkodean biner UTF-8. Ukuran string di Amazon Keyspaces sama dengan jumlah byte yang dikodekan UTF-8.
+ **Tipe numerik** — Cassandra`INT`,`BIGINT`,`SMALLINT`,`TINYINT`,, dan tipe `VARINT` data disimpan di Amazon Keyspaces sebagai nilai data dengan panjang variabel, dengan hingga 38 digit signifikan. Angka nol di depan dan di belakang dipangkas. Ukuran salah satu tipe data ini kira-kira 1 byte per dua digit signifikan\$11 byte.
+ **Tipe gumpalan** — A `BLOB` di Amazon Keyspaces disimpan dengan panjang byte mentah nilai.
+ **Jenis Boolean** — Ukuran nilai atau `Boolean` `Null` nilai adalah 1 byte.
+ **Tipe koleksi** — Kolom yang menyimpan tipe data koleksi seperti `LIST` atau `MAP` membutuhkan 3 byte metadata, terlepas dari isinya. Ukuran a `LIST` or `MAP` is (id kolom) \$1 jumlah (ukuran elemen bersarang) \$1 (3 byte). Ukuran kosong `LIST` atau `MAP` adalah (kolom id) \$1 (3 byte). Setiap individu `LIST` atau `MAP` elemen juga membutuhkan 1 byte metadata.
+ **Tipe yang ditentukan pengguna** — [Tipe yang ditentukan pengguna (UDT)](udts.md) membutuhkan 3 byte untuk metadata, terlepas dari isinya. Untuk setiap elemen UDT, Amazon Keyspaces memerlukan tambahan 1 byte metadata.
Untuk menghitung ukuran UDT yang dikodekan, mulailah dengan `field name` dan `field value` untuk bidang UDT:
+ **nama bidang** - Setiap nama bidang UDT tingkat atas disimpan menggunakan pengenal. Nilai penyimpanan pengenal tergantung pada jumlah keseluruhan bidang di UDT tingkat atas Anda, dan dapat bervariasi antara 1 dan 3 byte:
+ 1—62 bidang: 1 byte
+ 63—124 bidang: 2 byte
+ 125— bidang maks: 3 byte
+ **nilai bidang** - Byte yang diperlukan untuk menyimpan nilai bidang UDT tingkat atas bergantung pada tipe data yang disimpan:
+ **Jenis data skalar** — Byte yang diperlukan untuk penyimpanan sama dengan tipe data yang sama yang disimpan dalam kolom biasa.
+ **UDT Beku** — Untuk setiap UDT bersarang beku, UDT bersarang memiliki ukuran yang sama seperti pada protokol biner CQL. Untuk UDT bersarang, 4 byte disimpan untuk setiap bidang (termasuk bidang kosong) dan nilai bidang yang disimpan adalah format serialisasi protokol biner CQL dari nilai bidang.
+ **Koleksi beku**:
+ **LIST** dan **SET** — Untuk frozen bersarang `LIST` atau`SET`, 4 byte disimpan untuk setiap elemen koleksi ditambah format serialisasi protokol biner CQL dari nilai koleksi.
+ **MAP** - Untuk beku bersarang`MAP`, setiap pasangan nilai kunci memiliki persyaratan penyimpanan berikut:
+ Untuk setiap kunci mengalokasikan 4 byte, lalu tambahkan format serialisasi protokol biner CQL dari kunci.
+ Untuk setiap nilai mengalokasikan 4 byte, kemudian tambahkan format serialisasi protokol biner CQL dari nilai.
+ **Kata kunci FROZEN** — Untuk koleksi beku yang bersarang di dalam koleksi beku, Amazon Keyspaces tidak memerlukan byte tambahan untuk meta data.
+ **Kata kunci STATIS** - data `STATIC` kolom tidak dihitung terhadap ukuran baris maksimum 1 MB. Untuk menghitung ukuran data kolom statis, lihat[Hitung ukuran kolom statis per partisi logis di Amazon Keyspaces](static-columns-estimate.md).
## Pertimbangkan dampak fitur Amazon Keyspaces pada ukuran baris
Bagian ini menunjukkan bagaimana fitur di Amazon Keyspaces memengaruhi ukuran baris yang dikodekan.
+ **Client-side timestamps** — Client-side timestamps disimpan untuk setiap kolom di setiap baris saat fitur dihidupkan. Stempel waktu ini memakan waktu sekitar 20-40 byte (tergantung pada data Anda), dan berkontribusi pada biaya penyimpanan dan throughput untuk baris tersebut. Untuk informasi selengkapnya tentang stempel waktu sisi klien, lihat. [Stempel waktu sisi klien di Amazon Keyspaces](client-side-timestamps.md)
+ **Time to Live (TTL)** — Metadata TTL memakan waktu sekitar 8 byte untuk satu baris saat fitur dihidupkan. Selain itu, metadata TTL disimpan untuk setiap kolom dari setiap baris. Metadata TTL membutuhkan sekitar 8 byte untuk setiap kolom yang menyimpan tipe data skalar atau koleksi beku. Jika kolom menyimpan tipe data koleksi yang tidak dibekukan, untuk setiap elemen koleksi TTL memerlukan sekitar 8 byte tambahan untuk metadata. Untuk kolom yang menyimpan tipe data koleksi saat TTL diaktifkan, Anda dapat menggunakan rumus berikut.
```
total encoded size of column = (column id) + sum (nested elements + collection metadata (1 byte) + TTL metadata (8 bytes)) + collection column metadata (3 bytes)
```
Metadata TTL berkontribusi pada biaya penyimpanan dan throughput untuk baris. Untuk informasi lebih lanjut tentang TTL, lihat[Data kedaluwarsa dengan Time to Live (TTL) untuk Amazon Keyspaces (untuk Apache Cassandra)](TTL.md).
## Pilih rumus yang tepat untuk menghitung ukuran baris yang dikodekan
Bagian ini menunjukkan rumus berbeda yang dapat Anda gunakan untuk memperkirakan penyimpanan atau persyaratan throughput kapasitas untuk deretan data di Amazon Keyspaces.
Ukuran total deretan data yang dikodekan dapat diperkirakan berdasarkan salah satu rumus berikut, berdasarkan tujuan Anda:
+ **Kapasitas throughput** — Untuk memperkirakan ukuran baris yang dikodekan untuk menilai unit read/write permintaan yang diperlukan (): RRUs/WRUs) or read/write capacity units (RCUs/WCUs
```
total encoded size of row = partition key columns + clustering columns + regular columns
```
+ **Ukuran penyimpanan** — Untuk memperkirakan ukuran baris yang dikodekan untuk memprediksi`BillableTableSizeInBytes`, tambahkan metadata yang diperlukan untuk penyimpanan baris:
```
total encoded size of row = partition key columns + clustering columns + regular columns + row metadata (100 bytes)
```
**penting**
Semua metadata kolom, misalnya id kolom, metadata kunci partisi, metadata kolom pengelompokan, serta stempel waktu sisi klien, TTL, dan metadata baris dihitung menuju ukuran baris maksimum 1 MB.
## Contoh perhitungan ukuran baris
Perhatikan contoh berikut dari tabel di mana semua kolom adalah tipe integer. Tabel ini memiliki dua kolom kunci partisi, dua kolom pengelompokan, dan satu kolom reguler. Karena tabel ini memiliki lima kolom, ruang yang diperlukan untuk pengenal nama kolom adalah 1 byte.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dalam contoh ini, kita menghitung ukuran data ketika kita menulis baris ke tabel seperti yang ditunjukkan dalam pernyataan berikut:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1) values(1,2,3,4,5);
```
Untuk memperkirakan total byte yang diperlukan oleh operasi penulisan ini, Anda dapat menggunakan langkah-langkah berikut.
1. Hitung ukuran kolom kunci partisi dengan menambahkan byte untuk tipe data yang disimpan di kolom dan byte metadata. Ulangi ini untuk semua kolom kunci partisi.
1. Hitung ukuran kolom pertama dari kunci partisi (pk\$1col1):
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Hitung ukuran kolom kedua dari kunci partisi (pk\$1col2):
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Tambahkan kedua kolom untuk mendapatkan ukuran estimasi total kolom kunci partisi:
```
8 bytes + 8 bytes = 16 bytes for the partition key columns
```
1. Hitung ukuran kolom pengelompokan dengan menambahkan byte untuk tipe data yang disimpan di kolom dan byte metadata. Ulangi ini untuk semua kolom pengelompokan.
1. Hitung ukuran kolom pertama kolom pengelompokan (ck\$1col1):
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Hitung ukuran kolom kedua dari kolom pengelompokan (ck\$1col2):
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Tambahkan kedua kolom untuk mendapatkan perkiraan ukuran total kolom pengelompokan:
```
6 bytes + 6 bytes = 12 bytes for the clustering columns
```
1. Tambahkan ukuran kolom reguler. Dalam contoh ini kita hanya memiliki satu kolom yang menyimpan integer digit tunggal, yang membutuhkan 2 byte dengan 1 byte untuk id kolom.
1. Akhirnya, untuk mendapatkan total ukuran baris yang dikodekan, tambahkan byte untuk semua kolom. Untuk memperkirakan ukuran penyimpanan yang dapat ditagih, tambahkan 100 byte tambahan untuk metadata baris:
```
16 bytes for the partition key columns + 12 bytes for clustering columns + 3 bytes for the regular column + 100 bytes for row metadata = 131 bytes.
```
Untuk mempelajari cara memantau sumber daya tanpa server dengan Amazon CloudWatch, lihat. [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md)
# Perkirakan konsumsi kapasitas throughput baca dan tulis di Amazon Keyspaces
Saat Anda membaca atau menulis data di Amazon Keyspaces, jumlah unit read/write permintaan (RRUs/WRUs) or read/write capacity units (RCUs/WCUs) yang dikonsumsi kueri bergantung pada jumlah total data yang harus diproses Amazon Keyspaces untuk menjalankan kueri. Dalam beberapa kasus, data yang dikembalikan ke klien dapat menjadi bagian dari data yang harus dibaca Amazon Keyspaces untuk memproses kueri. Untuk penulisan bersyarat, Amazon Keyspaces menggunakan kapasitas tulis meskipun pemeriksaan bersyarat gagal.
Untuk memperkirakan jumlah total data yang diproses untuk permintaan, Anda harus mempertimbangkan ukuran baris yang dikodekan dan jumlah total baris. Topik ini mencakup beberapa contoh skenario umum dan pola akses untuk menunjukkan bagaimana Amazon Keyspaces memproses kueri dan bagaimana hal itu memengaruhi konsumsi kapasitas. Anda dapat mengikuti contoh untuk memperkirakan persyaratan kapasitas tabel Anda dan menggunakan Amazon CloudWatch untuk mengamati konsumsi kapasitas baca dan tulis untuk kasus penggunaan ini.
Untuk informasi tentang cara menghitung ukuran baris yang dikodekan di Amazon Keyspaces, lihat. [Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md)
**Topics**
+ [Perkirakan konsumsi kapasitas kueri rentang di Amazon Keyspaces](range_queries.md)
+ [Perkirakan konsumsi kapasitas baca kueri batas](limit_queries.md)
+ [Perkirakan konsumsi kapasitas baca pemindaian tabel](table_scans.md)
+ [Perkirakan konsumsi kapasitas transaksi ringan di Amazon Keyspaces](lightweight_transactions.md)
+ [Perkirakan konsumsi kapasitas untuk kolom statis di Amazon Keyspaces](static-columns.md)
+ [Memperkirakan dan menyediakan kapasitas untuk tabel Multi-wilayah di Amazon Keyspaces](tables-multi-region-capacity.md)
+ [Perkirakan konsumsi kapasitas baca dan tulis dengan Amazon CloudWatch di Amazon Keyspaces](estimate_consumption_cw.md)
# Perkirakan konsumsi kapasitas kueri rentang di Amazon Keyspaces
Untuk melihat konsumsi kapasitas baca dari kueri rentang, kami menggunakan tabel contoh berikut yang menggunakan mode kapasitas sesuai permintaan.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 50 |
a | b | 1 | a | b | 60 | value_1
a | b | 1 | a | b | 70 |
```
Sekarang jalankan query berikut pada tabel ini.
```
SELECT * FROM amazon_keyspaces.example_table_1 WHERE pk1='a' AND pk2='b' AND pk3=1 AND ck1='a' AND ck2='b' AND ck3 > 50 AND ck3 < 70;
```
Anda menerima set hasil berikut dari kueri dan operasi baca yang dilakukan oleh Amazon Keyspaces menggunakan 2 RRUs dalam `LOCAL_QUORUM` mode konsistensi.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 60 | value_1
```
Amazon Keyspaces menggunakan 2 RRUs untuk mengevaluasi baris dengan nilai `ck3=60` dan `ck3=70` untuk memproses kueri. Namun, Amazon Keyspaces hanya mengembalikan baris di mana `WHERE` kondisi yang ditentukan dalam kueri adalah true, yang merupakan baris dengan nilai. `ck3=60` Untuk mengevaluasi rentang yang ditentukan dalam kueri, Amazon Keyspaces membaca baris yang cocok dengan batas atas rentang, dalam hal ini`ck3 = 70`, tetapi tidak mengembalikan baris itu dalam hasilnya. Konsumsi kapasitas baca didasarkan pada data yang dibaca saat memproses kueri, bukan pada data yang dikembalikan.
# Perkirakan konsumsi kapasitas baca kueri batas
Saat memproses kueri yang menggunakan `LIMIT` klausa, Amazon Keyspaces membaca baris hingga ukuran halaman maksimum saat mencoba mencocokkan kondisi yang ditentukan dalam kueri. Jika Amazon Keyspaces tidak dapat menemukan data pencocokan yang memadai yang memenuhi `LIMIT` nilai pada halaman pertama, satu atau beberapa panggilan berhalaman mungkin diperlukan. Untuk melanjutkan pembacaan di halaman berikutnya, Anda dapat menggunakan token pagination. Ukuran halaman default adalah 1MB. Untuk mengurangi kapasitas baca saat menggunakan `LIMIT` klausa, Anda dapat mengurangi ukuran halaman. Untuk informasi lebih lanjut tentang pagination, lihat[Hasil paginasi di Amazon Keyspaces](paginating-results.md).
Sebagai contoh, mari kita lihat query berikut.
```
SELECT * FROM my_table WHERE partition_key=1234 LIMIT 1;
```
Jika Anda tidak mengatur ukuran halaman, Amazon Keyspaces membaca 1MB data meskipun hanya mengembalikan 1 baris kepada Anda. Untuk hanya memiliki Amazon Keyspaces membaca satu baris, Anda dapat mengatur ukuran halaman ke 1 untuk kueri ini. Dalam hal ini, Amazon Keyspaces hanya akan membaca satu baris asalkan Anda tidak memiliki baris kedaluwarsa berdasarkan Time-to-live pengaturan atau stempel waktu sisi klien.
`PAGE SIZE`Parameter menentukan berapa banyak baris Amazon Keyspaces memindai dari disk untuk setiap permintaan, bukan berapa banyak baris Amazon Keyspaces kembali ke klien. Amazon Keyspaces menerapkan filter yang Anda berikan, misalnya ketidaksetaraan pada kolom non-kunci atau `LIMIT` setelah memindai data pada disk. Jika Anda tidak secara eksplisit menyetel, `PAGE SIZE` Amazon Keyspaces membaca hingga 1MB data sebelum menerapkan filter. Misalnya, jika Anda menggunakan `LIMIT 1` tanpa menentukan`PAGE SIZE`, Amazon Keyspaces dapat membaca ribuan baris dari disk sebelum menerapkan klausa batas dan hanya mengembalikan satu baris.
Untuk menghindari pembacaan berlebihan, kurangi `PAGE SIZE` yang mengurangi jumlah baris pindaian Amazon Keyspaces untuk setiap pengambilan. Misalnya, jika Anda menentukan `LIMIT 5` dalam kueri Anda, setel `PAGE SIZE` ke nilai antara 5 - 10 sehingga Amazon Keyspaces hanya memindai 5 - 10 baris pada setiap panggilan paginasi. Anda dapat memodifikasi nomor ini untuk mengurangi jumlah pengambilan. Untuk batas yang lebih besar dari ukuran halaman, Amazon Keyspaces mempertahankan jumlah hasil total dengan status pagination. Dalam kasus 10.000 baris, Amazon Keyspaces dapat mengambil hasil ini dalam dua halaman masing-masing 5.000 baris. `LIMIT` Batas 1MB adalah batas atas untuk setiap set ukuran halaman.
# Perkirakan konsumsi kapasitas baca pemindaian tabel
Kueri yang menghasilkan pemindaian tabel lengkap, misalnya kueri menggunakan `ALLOW FILTERING` opsi, adalah contoh lain dari kueri yang memproses lebih banyak pembacaan daripada apa yang mereka kembalikan sebagai hasil. Dan konsumsi kapasitas baca didasarkan pada data yang dibaca, bukan data yang dikembalikan.
Untuk contoh pemindaian tabel kami menggunakan tabel contoh berikut dalam mode kapasitas sesuai permintaan.
```
pk | ck | value
---+----+---------
pk | 10 |
pk | 20 | value_1
pk | 30 |
```
Amazon Keyspaces membuat tabel dalam mode kapasitas sesuai permintaan dengan empat partisi secara default. Dalam tabel contoh ini, semua data disimpan dalam satu partisi dan tiga partisi sisanya kosong.
Sekarang jalankan query berikut di atas meja.
```
SELECT * from amazon_keyspaces.example_table_2;
```
Kueri ini menghasilkan operasi pemindaian tabel di mana Amazon Keyspaces memindai keempat partisi tabel dan menggunakan 6 dalam mode konsistensi. RRUs `LOCAL_QUORUM` Pertama, Amazon Keyspaces mengkonsumsi 3 RRUs untuk membaca tiga baris dengan. `pk=‘pk’` Kemudian, Amazon Keyspaces menggunakan 3 tambahan RRUs untuk memindai tiga partisi kosong tabel. Karena kueri ini menghasilkan pemindaian tabel, Amazon Keyspaces memindai semua partisi dalam tabel, termasuk partisi tanpa data.
# Perkirakan konsumsi kapasitas transaksi ringan di Amazon Keyspaces
Transaksi ringan (LWT) memungkinkan Anda melakukan operasi penulisan bersyarat terhadap data tabel Anda. Operasi pembaruan bersyarat berguna saat memasukkan, memperbarui, dan menghapus catatan berdasarkan kondisi yang mengevaluasi keadaan saat ini.
Di Amazon Keyspaces, semua operasi penulisan memerlukan konsistensi LOCAL\$1QUORUM dan tidak ada biaya tambahan untuk menggunakannya. LWTs Perbedaannya LWTs adalah ketika pemeriksaan kondisi LWT masuk, `FALSE` Amazon Keyspaces menggunakan unit kapasitas tulis (WCUs) atau unit permintaan tulis (). WRUs Jumlah yang WCUs/WRUs dikonsumsi tergantung pada ukuran baris.
Misalnya, jika ukuran baris adalah 2 KB, penulisan bersyarat yang gagal mengkonsumsi dua WCUs/. WRUs Jika baris saat ini tidak ada dalam tabel, operasi menggunakan satu WCUs/WRUs.
Untuk menentukan jumlah permintaan yang mengakibatkan kegagalan pemeriksaan kondisi, Anda dapat memantau `ConditionalCheckFailed` metrik di CloudWatch.
## Perkirakan biaya LWT untuk tabel dengan Time to Live (TTL)
LWTs dapat memerlukan unit kapasitas baca tambahan (RCUs) atau unit permintaan baca (RRUs) untuk tabel yang dikonfigurasi dengan TTL yang tidak menggunakan stempel waktu sisi klien. Saat menggunakan `IF EXISTS` atau `IF NOT EXISTS` kata kunci hasil pemeriksaan kondisi`FALSE`, unit kapasitas berikut dikonsumsi:
+ RCUs/RRUs – If the row exists, the RCUs/RRUsdikonsumsi didasarkan pada ukuran baris yang ada.
+ RCUs/RRUs – If the row doesn't exist, a single RCU/RRUdikonsumsi.
Jika kondisi yang dievaluasi menghasilkan operasi penulisan WCUs/WRUs yang sukses, dikonsumsi berdasarkan ukuran baris baru.
# Perkirakan konsumsi kapasitas untuk kolom statis di Amazon Keyspaces
Dalam tabel Amazon Keyspaces dengan kolom pengelompokan, Anda dapat menggunakan `STATIC` kata kunci untuk membuat kolom statis. Nilai yang disimpan dalam kolom statis dibagi antara semua baris dalam partisi logis. Saat Anda memperbarui nilai kolom ini, Amazon Keyspaces menerapkan perubahan secara otomatis ke semua baris di partisi.
Bagian ini menjelaskan cara menghitung ukuran data yang dikodekan saat Anda menulis ke kolom statis. Proses ini ditangani secara terpisah dari proses yang menulis data ke kolom nonstatis baris. Selain kuota ukuran untuk data statis, operasi baca dan tulis pada kolom statis juga memengaruhi pengukuran dan kapasitas throughput untuk tabel secara independen. Untuk perbedaan fungsional dengan Apache Cassandra saat menggunakan kolom statis dan hasil baca rentang paginasi, lihat. [Paginasi](functional-differences.md#functional-differences.paging)
**Topics**
+ [Hitung ukuran kolom statis per partisi logis di Amazon Keyspaces](static-columns-estimate.md)
+ [Perkirakan persyaratan throughput kapasitas untuk read/write operasi pada data statis di Amazon Keyspaces](static-columns-metering.md)
# Hitung ukuran kolom statis per partisi logis di Amazon Keyspaces
Bagian ini memberikan detail tentang cara memperkirakan ukuran kolom statis yang dikodekan di Amazon Keyspaces. Ukuran yang dikodekan digunakan saat Anda menghitung tagihan dan penggunaan kuota Anda. Anda juga harus menggunakan ukuran yang dikodekan saat menghitung persyaratan kapasitas throughput yang disediakan untuk tabel. Untuk menghitung ukuran kolom statis yang dikodekan di Amazon Keyspaces, Anda dapat menggunakan panduan berikut.
+ Kunci partisi dapat berisi hingga 2048 byte data. Setiap kolom kunci dalam kunci partisi membutuhkan hingga 3 byte metadata. Byte metadata ini dihitung terhadap kuota ukuran data statis Anda sebesar 1 MB per partisi. Saat menghitung ukuran data statis Anda, Anda harus berasumsi bahwa setiap kolom kunci partisi menggunakan metadata 3 byte penuh.
+ Gunakan ukuran mentah dari nilai data kolom statis berdasarkan tipe data. Untuk informasi selengkapnya tentang jenis data, lihat [Jenis Data](cql.elements.md#cql.data-types).
+ Tambahkan 104 byte ke ukuran data statis untuk metadata.
+ Kolom pengelompokan dan kolom kunci nonprimer reguler tidak dihitung terhadap ukuran data statis. Untuk mempelajari cara memperkirakan ukuran data nonstatis dalam baris, lihat[Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md).
Ukuran total dikodekan dari kolom statis didasarkan pada rumus berikut:
```
partition key columns + static columns + metadata = total encoded size of static data
```
Perhatikan contoh berikut dari tabel di mana semua kolom adalah tipe integer. Tabel ini memiliki dua kolom kunci partisi, dua kolom pengelompokan, satu kolom reguler, dan satu kolom statis.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dalam contoh ini, kami menghitung ukuran data statis dari pernyataan berikut:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6);
```
Untuk memperkirakan total byte yang diperlukan oleh operasi penulisan ini, Anda dapat menggunakan langkah-langkah berikut.
1. Hitung ukuran kolom kunci partisi dengan menambahkan byte untuk tipe data yang disimpan di kolom dan byte metadata. Ulangi ini untuk semua kolom kunci partisi.
1. Hitung ukuran kolom pertama dari kunci partisi (pk\$1col1):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Hitung ukuran kolom kedua dari kunci partisi (pk\$1col2):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Tambahkan kedua kolom untuk mendapatkan ukuran estimasi total kolom kunci partisi:
```
7 bytes + 7 bytes = 14 bytes for the partition key columns
```
1. Tambahkan ukuran kolom statis. Dalam contoh ini, kita hanya memiliki satu kolom statis yang menyimpan integer (yang membutuhkan 4 byte).
1. Terakhir, untuk mendapatkan ukuran total yang dikodekan dari data kolom statis, tambahkan byte untuk kolom kunci utama dan kolom statis, dan tambahkan 104 byte tambahan untuk metadata:
```
14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes.
```
Anda juga dapat memperbarui data statis dan nonstatis dengan pernyataan yang sama. Untuk memperkirakan ukuran total operasi tulis, Anda harus terlebih dahulu menghitung ukuran pembaruan data nonstatis. Kemudian hitung ukuran pembaruan baris seperti yang ditunjukkan pada contoh di[Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md), dan tambahkan hasilnya.
Dalam hal ini, Anda dapat menulis total 2 MB—1 MB adalah kuota ukuran baris maksimum, dan 1 MB adalah kuota untuk ukuran data statis maksimum per partisi logis.
Untuk menghitung ukuran total pembaruan data statis dan nonstatis dalam pernyataan yang sama, Anda dapat menggunakan rumus berikut:
```
(partition key columns + static columns + metadata = total encoded size of static data) + (partition key columns + clustering columns + regular columns + row metadata = total encoded size of row)
= total encoded size of data written
```
Perhatikan contoh berikut dari tabel di mana semua kolom adalah tipe integer. Tabel ini memiliki dua kolom kunci partisi, dua kolom pengelompokan, satu kolom reguler, dan satu kolom statis.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
Dalam contoh ini, kita menghitung ukuran data ketika kita menulis baris ke tabel, seperti yang ditunjukkan dalam pernyataan berikut:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7);
```
Untuk memperkirakan total byte yang diperlukan oleh operasi penulisan ini, Anda dapat menggunakan langkah-langkah berikut.
1. Hitung total ukuran data statis yang dikodekan seperti yang ditunjukkan sebelumnya. Dalam contoh ini, itu 122 byte.
1. Tambahkan ukuran total ukuran baris yang dikodekan berdasarkan pembaruan data nonstatis, mengikuti langkah-langkah di. [Perkirakan ukuran baris di Amazon Keyspaces](calculating-row-size.md) Dalam contoh ini, ukuran total pembaruan baris adalah 134 byte.
```
122 bytes for static data + 134 bytes for nonstatic data = 256 bytes.
```
# Perkirakan persyaratan throughput kapasitas untuk read/write operasi pada data statis di Amazon Keyspaces
Data statis dikaitkan dengan partisi logis di Cassandra, bukan baris individual. Partisi logis di Amazon Keyspaces dapat hampir tidak terikat ukurannya dengan menjangkau beberapa partisi penyimpanan fisik. Akibatnya, Amazon Keyspaces meteran menulis operasi pada data statis dan nonstatis secara terpisah. Selanjutnya, menulis yang mencakup data statis dan nonstatis memerlukan operasi tambahan yang mendasari untuk memberikan konsistensi data.
Jika Anda melakukan operasi penulisan campuran dari data statis dan nonstatis, ini menghasilkan dua operasi tulis terpisah—satu untuk nonstatis dan satu untuk data statis. Ini berlaku untuk mode kapasitas sesuai permintaan dan yang disediakan. read/write
Contoh berikut memberikan detail tentang cara memperkirakan unit kapasitas baca (RCUs) dan unit kapasitas tulis () yang diperlukan saat Anda menghitung persyaratan kapasitas throughput yang disediakan untuk tabel di Amazon Keyspaces yang memiliki kolom statis. WCUs Anda dapat memperkirakan berapa banyak kapasitas yang dibutuhkan tabel Anda untuk memproses penulisan yang mencakup data statis dan nonstatis dengan menggunakan rumus berikut:
```
2 x WCUs required for nonstatic data + 2 x WCUs required for static data
```
Misalnya, jika aplikasi Anda menulis 27 KBs data per detik dan setiap penulisan menyertakan 25,5 KBs data nonstatis dan 1,5 KBs data statis, maka tabel Anda memerlukan 56 WCUs (2 x 26 WCUs \$1 2 x 2 WCUs).
Amazon Keyspaces mengukur pembacaan data statis dan nonstatis sama dengan pembacaan beberapa baris. Akibatnya, harga pembacaan data statis dan nonstatis dalam operasi yang sama didasarkan pada ukuran agregat data yang diproses untuk melakukan pembacaan.
Untuk mempelajari cara memantau sumber daya tanpa server dengan Amazon CloudWatch, lihat. [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md)
# Memperkirakan dan menyediakan kapasitas untuk tabel Multi-wilayah di Amazon Keyspaces
Anda dapat mengonfigurasi kapasitas throughput tabel Multi-wilayah dengan salah satu dari dua cara:
+ Mode kapasitas sesuai permintaan, diukur dalam unit permintaan tulis () WRUs
+ Mode kapasitas yang disediakan dengan penskalaan otomatis, diukur dalam satuan kapasitas tulis () WCUs
Anda dapat menggunakan mode kapasitas yang disediakan dengan penskalaan otomatis atau mode kapasitas sesuai permintaan untuk membantu memastikan bahwa tabel Multi-wilayah memiliki kapasitas yang cukup untuk melakukan penulisan yang direplikasi ke semua. Wilayah AWS
**catatan**
Mengubah mode kapasitas tabel di salah satu Wilayah mengubah mode kapasitas untuk semua replika.
Secara default, Amazon Keyspaces menggunakan mode sesuai permintaan untuk tabel Multi-wilayah. Dengan mode on-demand, Anda tidak perlu menentukan berapa banyak throughput baca dan tulis yang Anda harapkan untuk dilakukan aplikasi Anda. Amazon Keyspaces langsung mengakomodasi beban kerja Anda saat mereka naik atau turun ke tingkat lalu lintas yang dicapai sebelumnya. Jika tingkat lalu lintas beban kerja mencapai puncak baru, Amazon Keyspaces beradaptasi dengan cepat untuk mengakomodasi beban kerja.
Jika Anda memilih mode kapasitas yang disediakan untuk tabel, Anda harus mengonfigurasi jumlah unit kapasitas baca (RCUs) dan menulis unit kapasitas (WCUs) per detik yang dibutuhkan aplikasi Anda.
Untuk merencanakan kebutuhan kapasitas throughput tabel Multi-wilayah, Anda harus terlebih dahulu memperkirakan jumlah WCUs per detik yang dibutuhkan untuk setiap Wilayah. Kemudian Anda menambahkan penulisan dari semua Wilayah tempat tabel Anda direplikasi, dan menggunakan jumlah untuk menyediakan kapasitas untuk setiap Wilayah. Hal ini diperlukan karena setiap penulisan yang dilakukan di satu Wilayah juga harus diulang di setiap replika Region.
Jika tabel tidak memiliki kapasitas yang cukup untuk menangani penulisan dari semua Wilayah, pengecualian kapasitas akan terjadi. Selain itu, waktu tunggu replikasi antar-regional akan meningkat.
Misalnya, jika Anda memiliki tabel Multi-wilayah di mana Anda mengharapkan 5 penulisan per detik di AS Timur (Virginia N.), 10 menulis per detik di AS Timur (Ohio), dan 5 menulis per detik di Eropa (Irlandia), Anda harus mengharapkan tabel mengkonsumsi 20 WCUs di setiap Wilayah: AS Timur (Virginia N.), AS Timur (Ohio), dan Eropa (Irlandia). Itu berarti bahwa dalam contoh ini, Anda perlu menyediakan 20 WCUs untuk setiap replika tabel. Anda dapat memantau konsumsi kapasitas tabel Anda menggunakan Amazon CloudWatch. Untuk informasi selengkapnya, lihat [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md).
Setiap penulisan ditagih sebagai 1 WCU, jadi Anda akan melihat total 60 WCUs tagihan dalam contoh ini. Untuk informasi selengkapnya tentang harga, lihat harga [Amazon Keyspaces (untuk Apache Cassandra](https://aws.amazon.com/keyspaces/pricing)).
Untuk informasi selengkapnya tentang kapasitas yang disediakan dengan penskalaan otomatis Amazon Keyspaces, lihat. [Kelola kapasitas throughput secara otomatis dengan penskalaan otomatis Amazon Keyspaces](autoscaling.md)
**catatan**
Jika tabel berjalan dalam mode kapasitas yang disediakan dengan penskalaan otomatis, kapasitas tulis yang disediakan diizinkan untuk mengambang dalam pengaturan penskalaan otomatis tersebut untuk setiap Wilayah.
# Perkirakan konsumsi kapasitas baca dan tulis dengan Amazon CloudWatch di Amazon Keyspaces
Untuk memperkirakan dan memantau konsumsi kapasitas baca dan tulis, Anda dapat menggunakan CloudWatch dasbor. Untuk informasi selengkapnya tentang metrik yang tersedia untuk Amazon Keyspaces, lihat. [Metrik dan dimensi Amazon Keyspaces](metrics-dimensions.md)
Untuk memantau unit kapasitas baca dan tulis yang dikonsumsi oleh pernyataan tertentu dengan CloudWatch, Anda dapat mengikuti langkah-langkah ini.
1. Buat tabel baru dengan data sampel
1. Konfigurasikan CloudWatch dasbor Amazon Keyspaces untuk tabel. Untuk memulai, Anda dapat menggunakan template dasbor yang tersedia di [Github](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates).
1. Jalankan pernyataan CQL, misalnya menggunakan `ALLOW FILTERING` opsi, dan periksa unit kapasitas baca yang dikonsumsi untuk pemindaian tabel lengkap di dasbor.
# 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).
# Kelola kapasitas throughput secara otomatis dengan penskalaan otomatis Amazon Keyspaces
Banyak beban kerja basis data yang memiliki sifat berhubungan dengan siklus atau sulit untuk diprediksi. Misalnya, pertimbangkan aplikasi jaringan sosial yang sebagian besar penggunanya aktif selama waktu siang hari. Basis data harus mampu menangani aktivitas siang hari, tetapi tidak perlu untuk tingkat throughput yang sama pada malam hari.
Contoh lainnya mungkin berupa aplikasi game seluler baru yang mengalami adopsi cepat. Jika permainan menjadi sangat populer, itu bisa melebihi sumber daya database yang tersedia, yang akan menghasilkan kinerja yang lambat dan pelanggan yang tidak bahagia. Beban kerja semacam ini kerap perlu dinaikkan atau dikurangi skala sumber daya basis datanya secara manual guna merespons berbagai tingkat penggunaan.
Amazon Keyspaces (untuk Apache Cassandra) membantu Anda menyediakan kapasitas throughput secara efisien untuk beban kerja variabel dengan menyesuaikan kapasitas throughput secara otomatis sebagai respons terhadap lalu lintas aplikasi yang sebenarnya. Amazon Keyspaces menggunakan layanan Application Auto Scaling untuk menambah dan mengurangi kapasitas baca dan tulis tabel atas nama Anda. Untuk informasi selengkapnya tentang Application Auto Scaling, lihat Panduan Pengguna [Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/).
**catatan**
Untuk memulai penskalaan otomatis Amazon Keyspaces dengan cepat, lihat. [Mengonfigurasi dan memperbarui kebijakan penskalaan otomatis Amazon Keyspaces](autoscaling.configure.md)
## Cara kerja penskalaan otomatis Amazon Keyspaces
Diagram berikut memberikan ikhtisar tingkat tinggi tentang cara penskalaan otomatis Amazon Keyspaces mengelola kapasitas throughput untuk sebuah tabel.
![\[Diagram yang menunjukkan berbagai layanan yang terlibat saat pengguna membuat perubahan pada tabel Amazon Keyspaces. Layanannya adalah Amazon CloudWatch, Amazon SNS, dan Application Auto Scaling, yang mengeluarkan pernyataan ALTER TABLE untuk mengubah kapasitas berdasarkan penggunaan baca atau tulis pengguna.\]](http://docs.aws.amazon.com/id_id/keyspaces/latest/devguide/images/keyspaces_auto-scaling.png)
Untuk mengaktifkan penskalaan otomatis untuk tabel, Anda membuat kebijakan *penskalaan.* Kebijakan penskalaan menentukan apakah Anda ingin menskalakan kapasitas baca atau kapasitas tulis (atau keduanya), dan pengaturan unit kapasitas minimum dan maksimum yang disediakan untuk tabel.
Kebijakan penskalaan juga mendefinisikan pemanfaatan *target*. Pemanfaatan target adalah rasio unit kapasitas yang dikonsumsi terhadap unit kapasitas yang disediakan pada suatu titik waktu, dinyatakan sebagai persentase. Penskalaan otomatis menggunakan algoritme *pelacakan target* untuk menyesuaikan throughput tabel yang disediakan ke atas atau ke bawah sebagai respons terhadap beban kerja aktual. Hal ini dilakukan agar pemanfaatan kapasitas aktual tetap pada atau dekat target pemanfaatan Anda.
Anda dapat mengatur nilai pemanfaatan target penskalaan otomatis antara 20 dan 90 persen untuk kapasitas baca dan tulis Anda. Tingkat pemanfaatan target default adalah 70 persen. Anda dapat menetapkan target pemanfaatan menjadi persentase yang lebih rendah jika lalu lintas Anda berubah dengan cepat dan Anda ingin kapasitas untuk mulai meningkatkan lebih cepat. Anda juga dapat menetapkan tingkat pemanfaatan target ke tingkat yang lebih tinggi jika lalu lintas aplikasi Anda berubah lebih lambat dan Anda ingin mengurangi biaya throughput.
Untuk informasi selengkapnya tentang kebijakan penskalaan, lihat [Kebijakan penskalaan pelacakan target untuk Application Auto](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) Scaling di Panduan Pengguna [https://docs.aws.amazon.com/autoscaling/application/userguide/](https://docs.aws.amazon.com/autoscaling/application/userguide/).
Saat Anda membuat kebijakan penskalaan, Amazon Keyspaces membuat dua pasang alarm CloudWatch Amazon atas nama Anda. Setiap pasangan mewakili batas atas dan bawah Anda untuk pengaturan throughput yang disediakan dan dikonsumsi. CloudWatch Alarm ini dipicu ketika penggunaan tabel yang sebenarnya menyimpang dari penggunaan target Anda untuk jangka waktu yang berkelanjutan. Untuk mempelajari lebih lanjut tentang Amazon CloudWatch, lihat [Panduan CloudWatch Pengguna Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
Ketika salah satu CloudWatch alarm dipicu, Amazon Simple Notification Service (Amazon SNS) mengirimkan pemberitahuan kepada Anda (jika Anda telah mengaktifkannya). CloudWatch Alarm kemudian memanggil Application Auto Scaling untuk mengevaluasi kebijakan penskalaan Anda. Hal ini pada gilirannya mengeluarkan permintaan Alter Table ke Amazon Keyspaces untuk menyesuaikan kapasitas yang disediakan tabel ke atas atau ke bawah sebagaimana mestinya. Untuk mempelajari lebih lanjut tentang notifikasi Amazon SNS, lihat [Menyiapkan notifikasi Amazon SNS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html).
Amazon Keyspaces memproses permintaan Alter Table dengan meningkatkan (atau mengurangi) kapasitas throughput yang disediakan tabel sehingga mendekati pemanfaatan target Anda.
**catatan**
Penskalaan otomatis Amazon Keyspaces memodifikasi setelan throughput yang disediakan hanya jika beban kerja sebenarnya tetap meningkat (atau tertekan) selama beberapa menit. Algoritma pelacakan target berusaha untuk menjaga pemanfaatan target pada atau mendekati nilai yang Anda pilih dalam jangka panjang. Lonjakan aktivitas yang mendadak dan berdurasi singkat diakomodasi oleh kapasitas lonjakan bawaan tabel.
## Cara kerja penskalaan otomatis untuk tabel Multi-wilayah
Untuk memastikan bahwa selalu ada kapasitas baca dan tulis yang cukup untuk semua replika tabel di semua Wilayah AWS tabel Multi-wilayah dalam mode kapasitas yang disediakan, sebaiknya Anda mengonfigurasi penskalaan otomatis Amazon Keyspaces.
Saat Anda menggunakan tabel Multi-wilayah dalam mode yang disediakan dengan penskalaan otomatis, Anda tidak dapat menonaktifkan penskalaan otomatis untuk satu replika tabel. Tetapi Anda dapat menyesuaikan pengaturan penskalaan otomatis baca tabel untuk Wilayah yang berbeda. Misalnya, Anda dapat menentukan kapasitas baca yang berbeda dan membaca pengaturan penskalaan otomatis untuk setiap Wilayah tempat tabel direplikasi.
Pengaturan penskalaan otomatis baca yang Anda konfigurasikan untuk replika tabel di Wilayah tertentu menimpa pengaturan penskalaan otomatis umum tabel. Kapasitas tulis, bagaimanapun, harus tetap disinkronkan di semua replika tabel untuk memastikan bahwa ada kapasitas yang cukup untuk mereplikasi penulisan di semua Wilayah.
Penskalaan otomatis Amazon Keyspaces secara independen memperbarui kapasitas tabel yang disediakan di masing-masing Wilayah AWS berdasarkan penggunaan di Wilayah tersebut. Akibatnya, kapasitas yang disediakan di setiap Wilayah untuk tabel Multi-wilayah mungkin berbeda saat penskalaan otomatis aktif.
Anda dapat mengonfigurasi pengaturan penskalaan otomatis tabel Multi-wilayah dan replika menggunakan konsol Amazon Keyspaces, API, atau CQL. AWS CLI Untuk informasi selengkapnya tentang cara membuat dan memperbarui pengaturan penskalaan otomatis untuk tabel Multi-wilayah, lihat. [Memperbarui kapasitas yang disediakan dan pengaturan penskalaan otomatis untuk tabel Multi-wilayah di Amazon Keyspaces](tables-mrr-autoscaling.md)
**catatan**
Jika Anda menggunakan penskalaan otomatis untuk tabel Multi-wilayah, Anda harus selalu menggunakan operasi Amazon Keyspaces API untuk mengonfigurasi pengaturan penskalaan otomatis. Jika Anda menggunakan operasi Application Auto Scaling API secara langsung untuk mengonfigurasi pengaturan penskalaan otomatis, Anda tidak memiliki kemampuan untuk menentukan tabel Wilayah AWS Multi-wilayah. Hal ini dapat mengakibatkan konfigurasi yang tidak didukung.
## Catatan penggunaan
Sebelum Anda mulai menggunakan penskalaan otomatis Amazon Keyspaces, Anda harus mengetahui hal berikut:
+ Penskalaan otomatis Amazon Keyspaces tidak tersedia di Wilayah Timur Tengah (UEA).
+ Penskalaan otomatis Amazon Keyspaces dapat meningkatkan kapasitas baca atau kapasitas tulis sesering yang diperlukan, sesuai dengan kebijakan penskalaan Anda. Semua kuota Amazon Keyspaces tetap berlaku, seperti yang dijelaskan dalam. [Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md)
+ Penskalaan otomatis Amazon Keyspaces tidak mencegah Anda memodifikasi setelan throughput yang disediakan secara manual. Penyesuaian manual ini tidak memengaruhi CloudWatch alarm yang ada yang melekat pada kebijakan penskalaan.
+ Jika Anda menggunakan konsol untuk membuat tabel dengan kapasitas throughput yang disediakan, penskalaan otomatis Amazon Keyspaces diaktifkan secara default. Anda dapat mengubah pengaturan penskalaan otomatis Anda kapan saja. Untuk informasi selengkapnya, lihat [Matikan penskalaan otomatis Amazon Keyspaces untuk tabel](autoscaling.turnoff.md).
+ Jika Anda menggunakan CloudFormation untuk membuat kebijakan penskalaan, Anda harus mengelola kebijakan penskalaan CloudFormation agar tumpukan disinkronkan dengan templat tumpukan. Jika Anda mengubah kebijakan penskalaan dari Amazon Keyspaces, kebijakan tersebut akan ditimpa dengan nilai asli dari CloudFormation templat tumpukan saat tumpukan disetel ulang.
+ Jika Anda menggunakannya CloudTrail untuk memantau penskalaan otomatis Amazon Keyspaces, Anda mungkin melihat peringatan untuk panggilan yang dilakukan oleh Application Auto Scaling sebagai bagian dari proses validasi konfigurasinya. Anda dapat memfilter peringatan ini dengan menggunakan `invokedBy` bidang, yang berisi pemeriksaan `application-autoscaling.amazonaws.com` validasi ini.
# Mengonfigurasi dan memperbarui kebijakan penskalaan otomatis Amazon Keyspaces
Anda dapat menggunakan konsol, CQL, atau AWS Command Line Interface (AWS CLI) untuk mengonfigurasi penskalaan otomatis Amazon Keyspaces untuk tabel baru dan yang sudah ada. Anda juga dapat memodifikasi pengaturan penskalaan otomatis atau menonaktifkan penskalaan otomatis.
Untuk fitur yang lebih canggih seperti menyetel waktu cooldown scale-in dan scale-out, sebaiknya gunakan CQL atau untuk AWS CLI mengelola kebijakan penskalaan Amazon Keyspaces.
**Topics**
+ [Konfigurasikan izin untuk penskalaan otomatis Amazon Keyspaces](autoscaling.permissions.md)
+ [Buat tabel baru dengan penskalaan otomatis](autoscaling.createTable.md)
+ [Konfigurasikan penskalaan otomatis pada tabel yang ada](autoscaling.configureTable.md)
+ [Lihat konfigurasi penskalaan otomatis Amazon Keyspaces tabel Anda](autoscaling.viewPolicy.md)
+ [Matikan penskalaan otomatis Amazon Keyspaces untuk tabel](autoscaling.turnoff.md)
+ [Melihat aktivitas penskalaan otomatis untuk tabel Amazon Keyspaces di Amazon CloudWatch](autoscaling.activity.md)
# Konfigurasikan izin untuk penskalaan otomatis Amazon Keyspaces
Untuk memulai, konfirmasikan bahwa prinsipal memiliki izin yang sesuai untuk membuat dan mengelola pengaturan penskalaan otomatis. Di AWS Identity and Access Management (IAM), kebijakan AWS terkelola `AmazonKeyspacesFullAccess` diperlukan untuk mengelola kebijakan penskalaan Amazon Keyspaces.
**penting**
`application-autoscaling:*`izin diperlukan untuk menonaktifkan penskalaan otomatis di atas meja. Anda harus mematikan penskalaan otomatis untuk tabel sebelum Anda dapat menghapusnya.
Untuk menyiapkan pengguna atau peran IAM untuk akses konsol Amazon Keyspaces dan penskalaan otomatis Amazon Keyspaces, tambahkan kebijakan berikut.
**Untuk melampirkan `AmazonKeyspacesFullAccess` kebijakan**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Di dasbor konsol IAM, pilih **Pengguna**, lalu pilih pengguna atau peran IAM Anda dari daftar.
1. Di halaman **Ringkasan**, pilih **Tambahkan izin**.
1. Pilih **Lampirkan kebijakan yang sudah ada secara langsung**.
1. Dari daftar kebijakan, pilih **AmazonKeyspacesFullAccess**, lalu pilih **Berikutnya: Tinjau**.
1. Pilih **Tambahkan izin**.
# Buat tabel baru dengan penskalaan otomatis
Saat membuat tabel Amazon Keyspaces baru, Anda dapat secara otomatis mengaktifkan penskalaan otomatis untuk kapasitas tulis atau baca tabel. Hal ini memungkinkan Amazon Keyspaces menghubungi Application Auto Scaling atas nama Anda untuk mendaftarkan tabel sebagai target yang dapat diskalakan dan menyesuaikan kapasitas tulis atau baca yang disediakan.
Untuk informasi selengkapnya tentang cara membuat tabel Multi-wilayah dan mengonfigurasi pengaturan penskalaan otomatis yang berbeda untuk replika tabel, lihat. [Buat tabel Multi-wilayah dalam mode yang disediakan dengan penskalaan otomatis di Amazon Keyspaces](tables-mrr-create-provisioned.md)
**catatan**
Penskalaan otomatis Amazon Keyspaces memerlukan keberadaan peran terkait layanan (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) yang melakukan tindakan penskalaan otomatis atas nama Anda. Peran ini dibuat secara otomatis untuk Anda. Untuk informasi selengkapnya, lihat [Menggunakan peran terkait layanan untuk Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Buat tabel baru dengan penskalaan otomatis diaktifkan 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 **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**, pilih **Disediakan.**
1. Di bagian **Baca kapasitas**, konfirmasikan bahwa **Skala dipilih secara otomatis**.
Pada langkah ini, Anda memilih unit kapasitas baca minimum dan maksimum untuk tabel, serta pemanfaatan target.
+ **Unit kapasitas minimum** — Masukkan nilai untuk tingkat throughput minimum yang harus selalu siap didukung oleh tabel. Nilai harus antara 1 dan kuota throughput maksimum per detik untuk akun Anda (40.000 secara default).
+ **Unit kapasitas maksimum** — Masukkan jumlah maksimum throughput yang ingin Anda sediakan untuk tabel. Nilai harus antara 1 dan kuota throughput maksimum per detik untuk akun Anda (40.000 secara default).
+ **Target pemanfaatan** — Masukkan tingkat pemanfaatan target antara 20% dan 90%. Ketika lalu lintas melebihi tingkat pemanfaatan target yang ditentukan, kapasitas secara otomatis ditingkatkan. Ketika lalu lintas jatuh di bawah target yang ditentukan, secara otomatis diperkecil lagi.
**catatan**
Untuk mempelajari lebih lanjut tentang kuota default untuk akun Anda dan cara meningkatkannya, lihat[Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md).
1. Di bagian **Tulis kapasitas**, pilih pengaturan yang sama seperti yang ditentukan pada langkah sebelumnya untuk kapasitas baca, atau konfigurasikan nilai kapasitas secara manual.
1. Pilih **Buat tabel**. Tabel Anda dibuat dengan parameter penskalaan otomatis yang ditentukan.
------
#### [ Cassandra Query Language (CQL) ]
**Buat tabel baru dengan penskalaan otomatis Amazon Keyspaces menggunakan CQL**
Untuk mengonfigurasi pengaturan penskalaan otomatis untuk tabel secara terprogram, Anda menggunakan `AUTOSCALING_SETTINGS` pernyataan yang berisi parameter untuk penskalaan otomatis Amazon Keyspaces. Parameter menentukan kondisi yang mengarahkan Amazon Keyspaces untuk menyesuaikan throughput yang disediakan tabel Anda, dan tindakan opsional tambahan apa yang harus diambil. Dalam contoh ini, Anda menentukan pengaturan penskalaan otomatis untuk *mytable*.
Kebijakan tersebut berisi elemen berikut:
+ `AUTOSCALING_SETTINGS`— Menentukan apakah Amazon Keyspaces diizinkan untuk menyesuaikan kapasitas throughput atas nama Anda. Nilai-nilai berikut diperlukan:
+ `provisioned_write_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `provisioned_read_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `scaling_policy`— Amazon Keyspaces mendukung kebijakan pelacakan target. Untuk menentukan kebijakan pelacakan target, Anda mengonfigurasi parameter berikut.
+ `target_value`— Penskalaan otomatis Amazon Keyspaces memastikan bahwa rasio kapasitas yang dikonsumsi terhadap kapasitas yang disediakan tetap pada atau mendekati nilai ini. Anda mendefinisikan `target_value` sebagai persentase.
+ `disableScaleIn`: (Opsional) A `boolean` yang menentukan `scale-in` apakah dinonaktifkan atau diaktifkan untuk tabel. Parameter ini dinonaktifkan secara default. Untuk menghidupkan`scale-in`, atur `boolean` nilainya ke`FALSE`. Ini berarti bahwa kapasitas secara otomatis diperkecil untuk tabel atas nama Anda.
+ `scale_out_cooldown`— Aktivitas scale-out meningkatkan throughput yang disediakan dari tabel Anda. Untuk menambahkan periode cooldown untuk aktivitas scale-out, tentukan nilai, dalam detik, untuk. `scale_out_cooldown` Jika Anda tidak menentukan nilai, nilai defaultnya adalah 0. Untuk informasi selengkapnya tentang pelacakan target dan periode cooldown, lihat [Kebijakan Penskalaan Pelacakan Target di Panduan Pengguna *Application Auto Scaling*](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
+ `scale_in_cooldown`— Aktivitas scale-in mengurangi throughput yang disediakan dari tabel Anda. Untuk menambahkan periode cooldown untuk aktivitas penskalaan, tentukan nilai, dalam detik, untuk. `scale_in_cooldown` Jika Anda tidak menentukan nilai, nilai defaultnya adalah 0. Untuk informasi selengkapnya tentang pelacakan target dan periode cooldown, lihat [Kebijakan Penskalaan Pelacakan Target di Panduan Pengguna *Application Auto Scaling*](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
**catatan**
Untuk lebih memahami cara kerja `target_value`, misalkan Anda memiliki sebuah tabel dengan pengaturan throughput yang disediakan sebanyak 200 unit kapasitas tulis. Anda memutuskan untuk membuat kebijakan penskalaan untuk tabel ini, dengan `target_value` sebesar 70 persen.
Sekarang anggaplah Anda mulai mendorong lalu lintas tulis ke tabel sehingga throughput tulis aktual adalah sebesar 150 unit kapasitas. consumed-to-provisionedRasionya sekarang (150/200), atau 75 persen. Rasio ini melebihi target Anda, jadi penskalaan otomatis meningkatkan kapasitas tulis yang disediakan menjadi 215 sehingga rasionya (150/215), atau 69,77 persen—sedekat mungkin dengan Anda, tetapi tidak melebihi itu. `target_value`
Untuk *mytable*, Anda mengatur `TargetValue` kapasitas baca dan tulis hingga 50 persen. Penskalaan otomatis Amazon Keyspaces menyesuaikan throughput yang disediakan tabel dalam kisaran 5-10 unit kapasitas sehingga rasionya tetap pada atau mendekati 50 persen. consumed-to-provisioned Untuk kapasitas baca, Anda mengatur nilai untuk `ScaleOutCooldown` dan `ScaleInCooldown` ke 60 detik.
Anda dapat menggunakan pernyataan berikut untuk membuat tabel Amazon Keyspaces baru dengan penskalaan otomatis diaktifkan.
```
CREATE TABLE mykeyspace.mytable(pk int, ck int, PRIMARY KEY (pk, ck))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Buat tabel baru dengan penskalaan otomatis Amazon Keyspaces menggunakan AWS CLI**
Untuk mengonfigurasi pengaturan penskalaan otomatis untuk tabel secara terprogram, Anda menggunakan `autoScalingSpecification` tindakan yang menentukan parameter untuk penskalaan otomatis Amazon Keyspaces. Parameter menentukan kondisi yang mengarahkan Amazon Keyspaces untuk menyesuaikan throughput yang disediakan tabel Anda, dan tindakan opsional tambahan apa yang harus diambil. Dalam contoh ini, Anda menentukan pengaturan penskalaan otomatis untuk *mytable*.
Kebijakan tersebut berisi elemen berikut:
+ `autoScalingSpecification`— Menentukan apakah Amazon Keyspaces diizinkan untuk menyesuaikan throughput kapasitas atas nama Anda. Anda dapat mengaktifkan penskalaan otomatis untuk membaca dan untuk kapasitas tulis secara terpisah. Maka Anda harus menentukan parameter berikut untuk`autoScalingSpecification`:
+ `writeCapacityAutoScaling`— Unit kapasitas tulis maksimum dan minimum.
+ `readCapacityAutoScaling`— Unit kapasitas baca maksimum dan minimum.
+ `scalingPolicy`— Amazon Keyspaces mendukung kebijakan pelacakan target. Untuk menentukan kebijakan pelacakan target, Anda mengonfigurasi parameter berikut.
+ `targetValue`— Penskalaan otomatis Amazon Keyspaces memastikan bahwa rasio kapasitas yang dikonsumsi terhadap kapasitas yang disediakan tetap pada atau mendekati nilai ini. Anda mendefinisikan `targetValue` sebagai persentase.
+ `disableScaleIn`: (Opsional) A `boolean` yang menentukan `scale-in` apakah dinonaktifkan atau diaktifkan untuk tabel. Parameter ini dinonaktifkan secara default. Untuk menghidupkan`scale-in`, atur `boolean` nilainya ke`FALSE`. Ini berarti bahwa kapasitas secara otomatis diperkecil untuk tabel atas nama Anda.
+ `scaleOutCooldown`— Aktivitas scale-out meningkatkan throughput yang disediakan dari tabel Anda. Untuk menambahkan periode cooldown untuk aktivitas scale-out, tentukan nilai, dalam detik, untuk. `ScaleOutCooldown` Nilai default-nya adalah 0. Untuk informasi selengkapnya tentang pelacakan target dan periode cooldown, lihat [Kebijakan Penskalaan Pelacakan Target di Panduan Pengguna *Application Auto Scaling*](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
+ `scaleInCooldown`— Aktivitas scale-in mengurangi throughput yang disediakan dari tabel Anda. Untuk menambahkan periode cooldown untuk aktivitas penskalaan, tentukan nilai, dalam detik, untuk. `ScaleInCooldown` Nilai default-nya adalah 0. Untuk informasi selengkapnya tentang pelacakan target dan periode cooldown, lihat [Kebijakan Penskalaan Pelacakan Target di Panduan Pengguna *Application Auto Scaling*](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
**catatan**
Untuk lebih memahami cara kerja `TargetValue`, misalkan Anda memiliki sebuah tabel dengan pengaturan throughput yang disediakan sebanyak 200 unit kapasitas tulis. Anda memutuskan untuk membuat kebijakan penskalaan untuk tabel ini, dengan `TargetValue` sebesar 70 persen.
Sekarang anggaplah Anda mulai mendorong lalu lintas tulis ke tabel sehingga throughput tulis aktual adalah sebesar 150 unit kapasitas. consumed-to-provisionedRasionya sekarang (150/200), atau 75 persen. Rasio ini melebihi target Anda, jadi penskalaan otomatis meningkatkan kapasitas tulis yang disediakan menjadi 215 sehingga rasionya (150/215), atau 69,77 persen—sedekat mungkin dengan Anda, tetapi tidak melebihi itu. `TargetValue`
Untuk *mytable*, Anda mengatur `TargetValue` kapasitas baca dan tulis hingga 50 persen. Penskalaan otomatis Amazon Keyspaces menyesuaikan throughput yang disediakan tabel dalam kisaran 5-10 unit kapasitas sehingga rasionya tetap pada atau mendekati 50 persen. consumed-to-provisioned Untuk kapasitas baca, Anda mengatur nilai untuk `ScaleOutCooldown` dan `ScaleInCooldown` ke 60 detik.
Saat membuat tabel dengan pengaturan penskalaan otomatis yang kompleks, akan sangat membantu untuk memuat pengaturan penskalaan otomatis dari file JSON. Untuk contoh berikut, Anda dapat men-download contoh file JSON dari [auto-scaling.zip](samples/auto-scaling.zip) dan ekstrak`auto-scaling.json`, mencatat path ke file. Dalam contoh ini, file JSON terletak di direktori saat ini. Untuk opsi jalur file yang berbeda, lihat [Cara memuat parameter dari file](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
```
aws keyspaces create-table --keyspace-name mykeyspace --table-name mytable
\ --schema-definition 'allColumns=[{name=pk,type=int},{name=ck,type=int}],partitionKeys=[{name=pk},{name=ck}]'
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Konfigurasikan penskalaan otomatis pada tabel yang ada
Anda dapat memperbarui tabel Amazon Keyspaces yang ada untuk mengaktifkan penskalaan otomatis untuk kapasitas tulis atau baca tabel. Jika Anda memperbarui tabel yang saat ini dalam mode kapasitas sesuai permintaan, Anda harus terlebih dahulu mengubah mode kapasitas tabel ke mode kapasitas yang disediakan.
Untuk informasi selengkapnya tentang cara memperbarui pengaturan penskalaan otomatis untuk tabel Multi-wilayah, lihat. [Memperbarui kapasitas yang disediakan dan pengaturan penskalaan otomatis untuk tabel Multi-wilayah di Amazon Keyspaces](tables-mrr-autoscaling.md)
Penskalaan otomatis Amazon Keyspaces memerlukan keberadaan peran terkait layanan (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) yang melakukan tindakan penskalaan otomatis atas nama Anda. Peran ini dibuat secara otomatis untuk Anda. Untuk informasi selengkapnya, lihat [Menggunakan peran terkait layanan untuk Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Konfigurasikan penskalaan otomatis Amazon Keyspaces untuk tabel yang ada**
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. Pilih tabel yang ingin Anda kerjakan, dan buka tab **Kapasitas**.
1. Di bagian **Pengaturan kapasitas**, pilih **Edit**.
1. Di bawah **mode Kapasitas**, pastikan tabel menggunakan mode kapasitas **yang disediakan**.
1. Pilih **Skala secara otomatis** dan lihat langkah 6 [Buat tabel baru dengan penskalaan otomatis](autoscaling.createTable.md) untuk mengedit kapasitas baca dan tulis.
1. Saat pengaturan penskalaan otomatis ditentukan, pilih **Simpan**.
------
#### [ Cassandra Query Language (CQL) ]
**Konfigurasikan tabel yang ada dengan penskalaan otomatis Amazon Keyspaces menggunakan CQL**
Anda dapat menggunakan `ALTER TABLE` pernyataan untuk tabel Amazon Keyspaces yang ada untuk mengonfigurasi penskalaan otomatis untuk kapasitas tulis atau baca tabel. Jika Anda memperbarui tabel yang saat ini dalam mode kapasitas sesuai permintaan, Anda harus menyetel `capacity_mode` ke provisioned. Jika tabel Anda sudah dalam mode kapasitas yang disediakan, bidang ini dapat dihilangkan.
Dalam contoh berikut, pernyataan memperbarui tabel *mytable*, yang dalam mode kapasitas sesuai permintaan. Pernyataan tersebut mengubah mode kapasitas tabel menjadi mode yang disediakan dengan penskalaan otomatis diaktifkan.
Kapasitas tulis dikonfigurasi dalam kisaran 5-10 unit kapasitas dengan nilai target 50%. Kapasitas baca juga dikonfigurasi dalam kisaran 5-10 unit kapasitas dengan nilai target 50%. Untuk kapasitas baca, Anda mengatur nilai untuk `scale_out_cooldown` dan `scale_in_cooldown` ke 60 detik.
```
ALTER TABLE mykeyspace.mytable
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Konfigurasikan tabel yang ada dengan penskalaan otomatis Amazon Keyspaces menggunakan AWS CLI**
Untuk tabel Amazon Keyspaces yang ada, Anda dapat mengaktifkan penskalaan otomatis untuk kapasitas tulis atau baca tabel menggunakan operasi. `UpdateTable`
Anda dapat menggunakan perintah berikut untuk mengaktifkan penskalaan otomatis Amazon Keyspaces untuk tabel yang ada. Pengaturan penskalaan otomatis untuk tabel dimuat dari file JSON. Untuk contoh berikut, Anda dapat men-download contoh file JSON dari [auto-scaling.zip](samples/auto-scaling.zip) dan ekstrak`auto-scaling.json`, mencatat path ke file. Dalam contoh ini, file JSON terletak di direktori saat ini. Untuk opsi jalur file yang berbeda, lihat [Cara memuat parameter dari file](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
Untuk informasi selengkapnya tentang pengaturan penskalaan otomatis yang digunakan dalam contoh berikut, lihat[Buat tabel baru dengan penskalaan otomatis](autoscaling.createTable.md).
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Lihat konfigurasi penskalaan otomatis Amazon Keyspaces tabel Anda
Anda dapat menggunakan konsol, CQL, atau AWS CLI untuk melihat dan memperbarui pengaturan penskalaan otomatis Amazon Keyspaces dari sebuah tabel.
------
#### [ Console ]
****
**Lihat pengaturan penskalaan otomatis menggunakan konsol**
1. Pilih tabel yang ingin Anda lihat dan buka tab **Kapasitas**.
1. Di bagian **Pengaturan kapasitas**, pilih **Edit**. Anda sekarang dapat mengubah pengaturan di bagian Kapasitas **Baca atau Kapasitas** **Tulis**. Untuk informasi selengkapnya tentang pengaturan ini, lihat [Buat tabel baru dengan penskalaan otomatis](autoscaling.createTable.md).
------
#### [ Cassandra Query Language (CQL) ]
**Melihat kebijakan penskalaan otomatis Amazon Keyspaces tabel Anda menggunakan CQL**
Untuk melihat detail konfigurasi penskalaan otomatis tabel, gunakan perintah berikut.
```
SELECT * FROM system_schema_mcs.autoscaling WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Output untuk perintah ini terlihat seperti ini.
```
keyspace_name | table_name | provisioned_read_capacity_autoscaling_update | provisioned_write_capacity_autoscaling_update
---------------+------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 60, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 60}}} | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 0, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 0}}}
```
------
#### [ CLI ]
**Melihat kebijakan penskalaan otomatis Amazon Keyspaces tabel Anda menggunakan AWS CLI**
Untuk melihat konfigurasi penskalaan otomatis tabel, Anda dapat menggunakan `get-table-auto-scaling-settings` operasi. Perintah CLI berikut adalah contohnya.
```
aws keyspaces get-table-auto-scaling-settings --keyspace-name mykeyspace --table-name mytable
```
Output untuk perintah ini terlihat seperti ini.
```
{
"keyspaceName": "mykeyspace",
"tableName": "mytable",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
"autoScalingSpecification": {
"writeCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 0,
"scaleOutCooldown": 0,
"targetValue": 50.0
}
}
},
"readCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 60,
"scaleOutCooldown": 60,
"targetValue": 50.0
}
}
}
}
}
```
------
# Matikan penskalaan otomatis Amazon Keyspaces untuk tabel
Anda dapat menonaktifkan penskalaan otomatis Amazon Keyspaces untuk tabel Anda kapan saja. Jika Anda tidak perlu lagi menskalakan kapasitas baca atau tulis tabel Anda, Anda harus mempertimbangkan untuk mematikan penskalaan otomatis sehingga Amazon Keyspaces tidak terus memodifikasi pengaturan kapasitas baca atau tulis tabel Anda. Anda dapat memperbarui tabel menggunakan konsol, CQL, atau file. AWS CLI
Mematikan penskalaan otomatis juga menghapus CloudWatch alarm yang dibuat atas nama Anda.
Untuk menghapus peran terkait layanan yang digunakan oleh Application Auto Scaling untuk mengakses tabel Amazon Keyspaces, ikuti langkah-langkahnya. [Menghapus peran terkait layanan untuk Amazon Keyspaces](using-service-linked-roles-app-auto-scaling.md#delete-service-linked-role-app-auto-scaling)
**catatan**
Untuk menghapus peran terkait layanan yang digunakan Application Auto Scaling, Anda harus menonaktifkan penskalaan otomatis pada semua tabel di akun. Wilayah AWS
------
#### [ Console ]
**Matikan penskalaan otomatis Amazon Keyspaces untuk tabel Anda menggunakan konsol**
**Menggunakan konsol Amazon Keyspaces**
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. Pilih tabel yang ingin Anda perbarui dan buka tab **Kapasitas**.
1. Di bagian **Pengaturan kapasitas**, pilih **Edit**.
1. Untuk menonaktifkan penskalaan otomatis Amazon Keyspaces, kosongkan kotak centang **Skala secara otomatis**. Menonaktifkan penskalaan otomatis membatalkan pendaftaran tabel sebagai target yang dapat diskalakan dengan Application Auto Scaling.
------
#### [ Cassandra Query Language (CQL) ]
**Matikan penskalaan otomatis Amazon Keyspaces untuk tabel Anda menggunakan CQL**
Pernyataan berikut mematikan penskalaan otomatis untuk kapasitas tulis tabel *mytable*.
```
ALTER TABLE mykeyspace.mytable
WITH AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'autoscaling_disabled': true
}
};
```
------
#### [ CLI ]
**Matikan penskalaan otomatis Amazon Keyspaces untuk tabel Anda menggunakan AWS CLI**
Perintah berikut mematikan penskalaan otomatis untuk kapasitas baca tabel. Ini juga menghapus CloudWatch alarm yang dibuat atas nama Anda.
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --auto-scaling-specification readCapacityAutoScaling={autoScalingDisabled=true}
```
------
# Melihat aktivitas penskalaan otomatis untuk tabel Amazon Keyspaces di Amazon CloudWatch
Anda dapat memantau cara penskalaan otomatis Amazon Keyspaces menggunakan sumber daya dengan menggunakan Amazon CloudWatch, yang menghasilkan metrik tentang penggunaan dan kinerja Anda. Ikuti langkah-langkah di [Panduan Application Auto Scaling Pengguna](https://docs.aws.amazon.com/autoscaling/application/userguide/monitoring-cloudwatch.html) untuk membuat CloudWatch dasbor.
# Gunakan kapasitas burst secara efektif di Amazon Keyspaces
*Amazon Keyspaces memberikan beberapa fleksibilitas dalam penyediaan throughput per partisi Anda dengan menyediakan kapasitas burst.* Kapan pun Anda tidak sepenuhnya menggunakan throughput partisi, Amazon Keyspaces menyimpan sebagian dari kapasitas yang tidak terpakai itu untuk semburan throughput *nanti guna menangani* lonjakan penggunaan.
Amazon Keyspaces saat ini mempertahankan hingga 5 menit (300 detik) kapasitas baca dan tulis yang tidak digunakan. Selama ledakan aktivitas baca atau tulis sesekali, unit kapasitas ekstra ini dapat dikonsumsi dengan cepat—bahkan lebih cepat daripada kapasitas throughput yang disediakan per detik yang telah Anda tetapkan untuk tabel Anda.
Amazon Keyspaces juga dapat menggunakan kapasitas burst untuk pemeliharaan latar belakang dan tugas lainnya tanpa pemberitahuan sebelumnya.
Perhatikan bahwa detail kapasitas lonjakan mungkin berubah di masa mendatang.