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