Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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.