Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bekerja dengan ElastiCache
Di bagian ini Anda dapat menemukan detail tentang cara mengelola berbagai komponen ElastiCache implementasi Anda.
**Topics**
+ [Melakukan snapshot dan pemulihan](backups.md)
+ [Versi mesin dan peningkatan di ElastiCache](engine-versions.md)
+ [ElastiCache praktik terbaik dan strategi caching](BestPractices.md)
+ [Mengelola cluster berbasis node Anda di ElastiCache](manage-self-designed-cluster.md)
+ [Menghubungkan EC2 instance dan ElastiCache cache secara otomatis](compute-connection.md)
+ [Penskalaan ElastiCache](Scaling.md)
+ [Memulai dengan filter Bloom](BloomFilters.md)
+ [Memulai dengan Watch in Serverless](ServerlessWatch.md)
+ [Memulai dengan Pencarian Vektor](vector-search.md)
+ [Memulai dengan JSON untuk Valkey dan Redis OSS](json-gs.md)
+ [Menandai sumber daya Anda ElastiCache](Tagging-Resources.md)
+ [Menggunakan Lensa Amazon ElastiCache Well-Architected](WellArchitechtedLens.md)
+ [Langkah-langkah pemecahan masalah umum dan praktik terbaik dengan ElastiCache](wwe-troubleshooting.md)
# Melakukan snapshot dan pemulihan
Amazon ElastiCache cache yang menjalankan Valkey, Redis OSS, atau Serverless Memcached dapat mencadangkan data mereka dengan membuat snapshot. Anda dapat menggunakan cadangan untuk memulihkan cache atau melakukan seeding data ke cache baru. Cadangan terdiri dari metadata cache, beserta semua data dalam cache. Semua cadangan ditulis ke Amazon Simple Storage Service (Amazon S3), yang menyediakan penyimpanan durabel. Kapan saja, Anda dapat memulihkan data Anda dengan membuat cache Valkey, Redis OSS, atau Memcached Tanpa Server baru dan mengisinya dengan data dari cadangan. Dengan ElastiCache, Anda dapat mengelola backup menggunakan Konsol Manajemen AWS, the AWS Command Line Interface(AWS CLI), dan API. ElastiCache
Jika Anda ingin menghapus cache dan perlu mempertahankan datanya, Anda dapat mengambil tindakan pencegahan tambahan. Untuk melakukannya, buat cadangan manual terlebih dahulu, pastikan bahwa statusnya *tersedia*, lalu hapus cache. Dengan melakukannya, Anda dapat memastikan bahwa jika cadangan gagal, Anda masih memiliki data cache yang tersedia. Anda dapat mencoba lagi membuat cadangan, dengan mengikuti praktik terbaik yang diuraikan sebelumnya.
**Topics**
+ [Batasan pencadangan](#backups-constraints)
+ [Dampak kinerja pencadangan cluster berbasis node](#backups-performance)
+ [Menjadwalkan pencadangan otomatis](backups-automatic.md)
+ [Membuat cadangan manual](backups-manual.md)
+ [Membuat cadangan akhir](backups-final.md)
+ [Menjelaskan cadangan](backups-describing.md)
+ [Menyalin cadangan](backups-copying.md)
+ [Mengekspor cadangan](backups-exporting.md)
+ [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md)
+ [Menghapus cadangan](backups-deleting.md)
+ [Memberikan tag pada cadangan](backups-tagging.md)
+ [Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal](backups-seeding-redis.md)
## Batasan pencadangan
Pertimbangkan batasan berikut saat merencanakan atau membuat cadangan:
+ Backup dan restore didukung hanya untuk cache yang berjalan di Valkey, Redis OSS atau Serverless Memcached.
+ Untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan), pencadangan dan pemulihan tidak didukung pada node. `cache.t1.micro` Semua jenis simpul cache lain didukung.
+ Untuk cluster Valkey atau Redis OSS (mode cluster enabled), backup dan restore didukung untuk semua jenis node.
+ Selama periode 24 jam yang berdekatan, Anda dapat membuat tidak lebih dari 24 cadangan manual per cache tanpa server. Untuk cluster berbasis node Valkey dan Redis OSS, Anda dapat membuat tidak lebih dari 20 backup manual per node di cluster.
+ Valkey atau Redis OSS (mode cluster diaktifkan) hanya mendukung pengambilan cadangan pada tingkat cluster (untuk API atau CLI, tingkat grup replikasi). Valkey atau Redis OSS (mode cluster diaktifkan) tidak mendukung pengambilan cadangan pada tingkat pecahan (untuk API atau CLI, tingkat grup node).
+ Selama proses pencadangan, Anda tidak dapat menjalankan operasi API atau CLI lainnya di cache tanpa server. Anda dapat menjalankan operasi API atau CLI pada cluster berbasis node selama pencadangan.
+ Jika Anda menggunakan cache Valkey atau Redis OSS dengan tiering data, Anda tidak dapat mengekspor cadangan ke Amazon S3.
+ Anda dapat memulihkan cadangan klaster yang menggunakan jenis simpul r6gd hanya untuk klaster yang menggunakan jenis simpul r6gd.
## Dampak kinerja pencadangan cluster berbasis node
Pencadangan di cache nirserver bersifat transparan untuk aplikasi tanpa adanya dampak performa. Namun, saat membuat cadangan untuk cluster berbasis node, mungkin ada beberapa dampak kinerja tergantung pada memori cadangan yang tersedia. Cadangan untuk cluster berbasis node tidak tersedia untuk Memcached tetapi tersedia ElastiCache untuk Redis OSS. ElastiCache
Berikut ini adalah pedoman untuk meningkatkan kinerja cadangan untuk cluster berbasis node.
+ Mengatur `reserved-memory-percent` parameter — Untuk mengurangi paging yang berlebihan, kami sarankan Anda mengatur parameter. *reserved-memory-percent* Parameter ini mencegah Valkey dan Redis OSS mengkonsumsi semua memori node yang tersedia, dan dapat membantu mengurangi jumlah paging. Anda mungkin juga melihat peningkatan performa hanya menggunakan simpul yang lebih besar. Untuk informasi selengkapnya tentang *memori cadangan* dan *reserved-memory-percent*parameter, lihat. [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md)
+ Buat cadangan dari replika baca - Jika Anda menjalankan Valkey atau Redis OSS dalam grup node dengan lebih dari satu node, Anda dapat mengambil cadangan dari node utama atau salah satu replika baca. Karena sumber daya sistem yang diperlukan selama BGSAVE, sebaiknya buat cadangan dari salah satu replika baca. Saat cadangan sedang dibuat dari replika, simpul primer tetap tidak terpengaruh oleh kebutuhan sumber daya BGSAVE. Simpul primer dapat terus melayani permintaan tanpa menjadi lambat.
Untuk melakukannya, lihat [Membuat cadangan manual (Konsol)](backups-manual.md#backups-manual-CON) dan di bidang **Nama Klaster** di jendela **Buat Cadangan**, pilih replika, bukan simpul primer default.
Jika Anda menghapus grup replikasi dan meminta cadangan akhir, ElastiCache selalu ambil cadangan dari simpul utama. Ini memastikan bahwa Anda menangkap data Valkey atau Redis OSS terbaru, sebelum grup replikasi dihapus.
# Menjadwalkan pencadangan otomatis
Anda dapat mengaktifkan pencadangan otomatis untuk cache tanpa server Valkey atau Redis OSS atau cluster berbasis node. Saat pencadangan otomatis diaktifkan, ElastiCache buat cadangan cache setiap hari. Tidak ada dampak pada cache dan perubahan terjadi seketika. Pencadangan otomatis dapat membantu mencegah kehilangan data. Jika terjadi kegagalan, Anda dapat membuat cache baru, memulihkan data Anda dari cadangan terakhir. Hasilnya adalah cache dengan proses warm start, yang dimuat di awal dengan data Anda dan siap digunakan. Untuk informasi selengkapnya, lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Anda dapat mengaktifkan pencadangan otomatis untuk cache Tanpa Server Memcached apa pun. Saat pencadangan otomatis diaktifkan, ElastiCache buat cadangan cache setiap hari. Tidak ada dampak pada cache dan perubahan terjadi seketika. Pencadangan otomatis dapat membantu mencegah kehilangan data. Jika terjadi kegagalan, Anda dapat membuat cache baru, memulihkan data Anda dari cadangan terakhir. Hasilnya adalah cache dengan proses warm start, yang dimuat di awal dengan data Anda dan siap digunakan. Untuk informasi selengkapnya, lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Saat Anda menjadwalkan cadangan otomatis, Anda harus merencanakan pengaturan berikut:
+ **Waktu mulai Backup** — Waktu hari ketika ElastiCache mulai membuat cadangan. Anda dapat mengatur periode pencadangan setiap saat pada waktu yang paling sesuai. Jika Anda tidak menentukan jendela cadangan, ElastiCache tetapkan satu secara otomatis.
+ **Batas retensi cadangan** – Jumlah hari cadangan dipertahankan di Amazon S3. Contohnya, jika Anda menetapkan batas retensi ke 5, cadangan yang diambil hari ini akan dipertahankan selama 5 hari. Jika batas retensi berakhir, cadangan akan dihapus secara otomatis.
Batas retensi cadangan maksimum adalah 35 hari. Jika batas retensi cadangan ditetapkan ke 0, cadangan otomatis akan dinonaktifkan untuk cache.
Ketika Anda menjadwalkan backup otomatis, ElastiCache akan mulai membuat backup. Anda dapat mengatur periode pencadangan setiap saat pada waktu yang paling sesuai. Jika Anda tidak menentukan jendela cadangan, ElastiCache tetapkan satu secara otomatis.
Anda dapat mengaktifkan atau menonaktifkan pencadangan otomatis saat membuat cache baru atau memperbarui cache yang ada, dengan menggunakan ElastiCache konsol,AWS CLI, atau API. ElastiCache **Untuk Valkey dan Redis OSS, ini dilakukan dengan mencentang kotak **Aktifkan Pencadangan Otomatis** di bagian **Advanced Valkey Settings atau Advanced Redis OSS Settings**.** Untuk Memcached, ini dilakukan dengan mencentang kotak **Aktifkan Pencadangan Otomatis** di bagian Pengaturan Memcached **Lanjutan**.
# Membuat cadangan manual
Selain cadangan otomatis, Anda dapat membuat cadangan *manual* kapan saja. Tidak seperti cadangan otomatis, yang secara otomatis dihapus setelah berakhirnya periode retensi yang ditentukan, cadangan manual tidak memiliki periode retensi yang jika berakhir, akan membuat cadangan manual dihapus secara otomatis. Bahkan jika Anda menghapus cache, setiap cadangan manual dari cache akan dipertahankan. Jika Anda tidak ingin lagi menyimpan cadangan manual, Anda harus menghapusnya sendiri secara eksplisit.
Selain membuat cadangan manual secara langsung, Anda dapat membuat cadangan manual dengan salah satu cara berikut:
+ [Menyalin cadangan](backups-copying.md). Tidak menjadi masalah apakah cadangan sumber dibuat secara otomatis atau manual.
+ [Membuat cadangan akhir](backups-final.md). Buat cadangan segera sebelum menghapus klaster atau simpul.
Anda dapat membuat cadangan manual cache menggunakan Konsol Manajemen AWS,AWS CLI, atau ElastiCache API.
Anda dapat membuat cadangan manual dari replika yang mengaktifkan mode cluster, dan mode cluster dinonaktifkan.
## Membuat cadangan manual (Konsol)
**Untuk membuat cadangan dari cache (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cache **Valkey, cache** **Redis OSS, atau cache **Memcached****, tergantung pada preferensi Anda.
1. Pilih kotak di sebelah kiri nama cache yang ingin Anda cadangkan.
1. Pilih **Cadangkan**.
1. Di dialog **Buat Cadangan**, ketik nama untuk cadangan Anda di kotak **Nama Cadangan**. Sebaiknya berikan nama yang menunjukkan klaster yang dicadangkan serta tanggal dan waktu cadangan dibuat.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
1. Pilih **Buat Cadangan**.
Status klaster berubah menjadi *snapshotting*.
## Membuat cadangan manual (AWS CLI)
**Pencadangan manual cache tanpa server dengan AWS CLI**
Untuk membuat cadangan manual cache menggunakan AWS CLI, gunakan `create-serverless-snapshot`AWS CLI operasi dengan parameter berikut:
+ `--serverless-cache-name` – Nama cache nirserver yang Anda cadangkan.
+ `--serverless-cache-snapshot-name` – Nama snapshot yang akan dibuat.
Untuk Linux, macOS, atau Unix:
+
```
aws elasticache create-serverless-snapshot \
--serverless-cache-name CacheName \
--serverless-cache-snapshot-name bkup-20231127
```
Untuk Windows:
+
```
aws elasticache create-serverless-snapshot ^
--serverless-cache-name CacheName ^
--serverless-cache-snapshot-name bkup-20231127
```
**Pencadangan manual dari cluster berbasis node dengan AWS CLI**
Untuk membuat cadangan manual dari cluster berbasis node menggunakan AWS CLI, gunakan `create-snapshot`AWS CLI operasi dengan parameter berikut:
+ `--cache-cluster-id`
+ Jika cluster yang Anda cadangkan tidak memiliki node replika, `--cache-cluster-id` adalah nama cluster yang Anda cadangkan, misalnya. *mycluster*
+ Jika klaster yang Anda cadangkan memiliki satu atau beberapa simpul replika, `--cache-cluster-id` adalah nama simpul di klaster yang dapat Anda gunakan untuk cadangan. Misalnya, namanya mungkin*mycluster-002*.
Gunakan parameter ini hanya saat mencadangkan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan).
+ `--replication-group-id`— Nama cluster Valkey atau Redis OSS (mode cluster enabled) (CLI/API: grup replikasi) untuk digunakan sebagai sumber cadangan. Gunakan parameter ini saat mencadangkan cluster Valkey atau Redis OSS (mode cluster enabled).
+ `--snapshot-name` – Nama snapshot yang akan dibuat.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
### Contoh 1: Mencadangkan cluster Valkey atau Redis OSS (Cluster Mode Disabled) yang tidak memiliki node replika
AWS CLI Operasi berikut membuat cadangan `bkup-20150515` dari cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) `myNonClusteredRedis` yang tidak memiliki replika baca.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-snapshot \
--cache-cluster-id myNonClusteredRedis \
--snapshot-name bkup-20150515
```
Untuk Windows:
```
aws elasticache create-snapshot ^
--cache-cluster-id myNonClusteredRedis ^
--snapshot-name bkup-20150515
```
### Contoh 2: Mencadangkan cluster Valkey atau Redis OSS (Cluster Mode Disabled) dengan node replika
AWS CLI Operasi berikut membuat cadangan `bkup-20150515` dari cluster Valkey atau Redis OSS (mode cluster dinonaktifkan). `myNonClusteredRedis` Cadangan ini memiliki satu atau beberapa replika baca.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-snapshot \
--cache-cluster-id myNonClusteredRedis-001 \
--snapshot-name bkup-20150515
```
Untuk Windows:
```
aws elasticache create-snapshot ^
--cache-cluster-id myNonClusteredRedis-001 ^
--snapshot-name bkup-20150515
```
**Contoh Output: Mencadangkan Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dengan Node Replika**
Output dari operasi ini akan terlihat seperti berikut.
```
{
"Snapshot": {
"Engine": "redis",
"CacheParameterGroupName": "default.redis6.x",
"VpcId": "vpc-91280df6",
"CacheClusterId": "myNonClusteredRedis-001",
"SnapshotRetentionLimit": 0,
"NumCacheNodes": 1,
"SnapshotName": "bkup-20150515",
"CacheClusterCreateTime": "2017-01-12T18:59:48.048Z",
"AutoMinorVersionUpgrade": true,
"PreferredAvailabilityZone": "us-east-1c",
"SnapshotStatus": "creating",
"SnapshotSource": "manual",
"SnapshotWindow": "08:30-09:30",
"EngineVersion": "6.0",
"NodeSnapshots": [
{
"CacheSize": "",
"CacheNodeId": "0001",
"CacheNodeCreateTime": "2017-01-12T18:59:48.048Z"
}
],
"CacheSubnetGroupName": "default",
"Port": 6379,
"PreferredMaintenanceWindow": "wed:07:30-wed:08:30",
"CacheNodeType": "cache.m3.2xlarge",
"DataTiering": "disabled"
}
}
```
### Contoh 3: Mencadangkan cluster untuk Valkey atau Redis OSS (Mode Cluster Diaktifkan)
AWS CLI Operasi berikut membuat cadangan `bkup-20150515` dari cluster Valkey atau Redis OSS (mode cluster enabled). `myClusteredRedis` Perhatikan penggunaan `--replication-group-id`, bukan `--cache-cluster-id` untuk mengidentifikasi sumber. Perhatikan juga bahwa ElastiCache mengambil cadangan menggunakan node replika saat ada, dan akan default ke node utama jika node replika tidak tersedia.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-snapshot \
--replication-group-id myClusteredRedis \
--snapshot-name bkup-20150515
```
Untuk Windows:
```
aws elasticache create-snapshot ^
--replication-group-id myClusteredRedis ^
--snapshot-name bkup-20150515
```
**Contoh Output: Mencadangkan Cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Output dari operasi ini akan terlihat seperti berikut.
```
{
"Snapshot": {
"Engine": "redis",
"CacheParameterGroupName": "default.redis6.x.cluster.on",
"VpcId": "vpc-91280df6",
"NodeSnapshots": [
{
"CacheSize": "",
"NodeGroupId": "0001"
},
{
"CacheSize": "",
"NodeGroupId": "0002"
}
],
"NumNodeGroups": 2,
"SnapshotName": "bkup-20150515",
"ReplicationGroupId": "myClusteredRedis",
"AutoMinorVersionUpgrade": true,
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotStatus": "creating",
"SnapshotSource": "manual",
"SnapshotWindow": "10:00-11:00",
"EngineVersion": "6.0",
"CacheSubnetGroupName": "default",
"ReplicationGroupDescription": "2 shards 2 nodes each",
"Port": 6379,
"PreferredMaintenanceWindow": "sat:03:30-sat:04:30",
"CacheNodeType": "cache.r3.large",
"DataTiering": "disabled"
}
}
```
### Topik terkait
Untuk informasi selengkapnya, lihat [create-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-snapshot.html) dalam *Referensi Perintah AWS CLI*.
## Membuat cadangan menggunakan CloudFormation
Anda dapat menggunakan CloudFormation untuk membuat cadangan ElastiCache Redis OSS atau Valkey cache Anda, menggunakan properti atau. `AWS::ElastiCache::ServerlessCache` `AWS::ElastiCache::ReplicationGroup`
**Menggunakan sumber `AWS::ElastiCache::ServerlessCache` daya**
Gunakan ini untuk membuat cadangan menggunakan AWS::ElastiCache::ServerlessCache sumber daya:
```
Resources:
iotCatalog:
Type: AWS::ElastiCache::ServerlessCache
Properties:
...
ServerlessCacheName: "your-cache-name"
Engine: "redis"
CacheUsageLimits
```
**Menggunakan sumber AWS::ElastiCache::ReplicationGroup daya**
Gunakan sumber `AWS::ElastiCache::ReplicationGroup` daya:
```
Resources:
iotCatalog:
Type: AWS::ElastiCache::ReplicationGroup
Properties:
...
ReplicationGroupDescription: "Description of your replication group"
Engine: "redis"
CacheNodeType
NumCacheClusters
AutomaticFailoverEnabled
AtRestEncryptionEnabled
```
# Membuat cadangan akhir
Anda dapat membuat cadangan akhir menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API.
## Membuat cadangan akhir (konsol)
Anda dapat membuat cadangan akhir saat menghapus cache tanpa server Valkey, Memcached, atau Redis OSS, atau cluster berbasis node Valkey atau Redis OSS, dengan menggunakan konsol. ElastiCache
Untuk membuat cadangan akhir saat menghapus cache, pada kotak dialog hapus pilih **Ya** di bawah **Buat cadangan** dan beri nama cadangan.
**Topik terkait**
+ [Menggunakan Konsol Manajemen AWS](Clusters.Delete.md#Clusters.Delete.CON)
+ [Menghapus Grup Replikasi (Konsol)](Replication.DeletingRepGroup.md#Replication.DeletingRepGroup.CON)
## Membuat cadangan akhir (AWS CLI)
Anda dapat membuat cadangan akhir saat menghapus cache menggunakan file.AWS CLI
**Topics**
+ [Saat menghapus cache Valkey, cache tanpa server Memcached, atau cache Redis OSS](#w2aac24b7c29b7b1b7)
+ [Saat menghapus cluster Valkey atau Redis OSS tanpa replika baca](#w2aac24b7c29b7b1b9)
+ [Saat menghapus cluster Valkey atau Redis OSS dengan replika baca](#w2aac24b7c29b7b1c11)
### Saat menghapus cache Valkey, cache tanpa server Memcached, atau cache Redis OSS
Untuk membuat cadangan akhir, gunakan `delete-serverless-cache`AWS CLI operasi dengan parameter berikut.
+ `--serverless-cache-name` – Nama cache yang dihapus.
+ `--final-snapshot-name` – Nama cadangan.
Kode berikut membuat cadangan akhir `bkup-20231127-final` saat menghapus cache `myserverlesscache`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-serverless-cache \
--serverless-cache-name myserverlesscache \
--final-snapshot-name bkup-20231127-final
```
Untuk Windows:
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name myserverlesscache ^
--final-snapshot-name bkup-20231127-final
```
Untuk informasi selengkapnya, lihat [delete-serverless-cache](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-serverless-cache.html) dalam *AWS CLI Referensi Perintah*.
### Saat menghapus cluster Valkey atau Redis OSS tanpa replika baca
Untuk membuat cadangan akhir untuk cluster berbasis node tanpa replika baca, gunakan `delete-cache-cluster`AWS CLI operasi dengan parameter berikut.
+ `--cache-cluster-id` – Nama klaster yang dihapus.
+ `--final-snapshot-identifier` – Nama cadangan.
Kode berikut membuat cadangan akhir `bkup-20150515-final` saat menghapus klaster `myRedisCluster`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id myRedisCluster \
--final-snapshot-identifier bkup-20150515-final
```
Untuk Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id myRedisCluster ^
--final-snapshot-identifier bkup-20150515-final
```
Untuk informasi selengkapnya, lihat [delete-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html) dalam *AWS CLI Referensi Perintah*.
### Saat menghapus cluster Valkey atau Redis OSS dengan replika baca
Untuk membuat cadangan akhir saat menghapus grup replikasi, gunakan `delete-replication-group`AWS CLI operasi, dengan parameter berikut:
+ `--replication-group-id` – Nama grup replikasi yang dihapus.
+ `--final-snapshot-identifier` – Nama cadangan akhir.
Kode berikut membuat cadangan akhir `bkup-20150515-final` saat menghapus grup replikasi `myReplGroup`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-replication-group \
--replication-group-id myReplGroup \
--final-snapshot-identifier bkup-20150515-final
```
Untuk Windows:
```
aws elasticache delete-replication-group ^
--replication-group-id myReplGroup ^
--final-snapshot-identifier bkup-20150515-final
```
Untuk informasi selengkapnya, lihat [delete-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-replication-group.html) dalam *AWS CLI Referensi Perintah*.
# Menjelaskan cadangan
Prosedur berikut menunjukkan cara menampilkan daftar cadangan Anda. Jika ingin, Anda juga dapat melihat detail cadangan tertentu.
## Mendeskripsikan cadangan (Konsol)
**Untuk menampilkan cadangan menggunakan Konsol Manajemen AWS**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih **Cadangan**.
1. Untuk melihat detail cadangan tertentu, pilih kotak di sebelah kiri nama cadangan.
## Menjelaskan cadangan nirserver (AWS CLI)
Untuk menampilkan daftar cadangan nirserver, dan detail tentang cadangan tertentu (opsional), gunakan operasi CLI `describe-serverless-cache-snapshots`.
**Contoh**
Operasi berikut menggunakan parameter `--max-records` untuk menampilkan hingga 20 cadangan yang terkait dengan akun Anda. Menghilangkan parameter `--max-records` akan menampilkan hingga 50 cadangan.
```
aws elasticache describe-serverless-cache-snapshots --max-records 20
```
Operasi berikut menggunakan parameter `--serverless-cache-name` untuk hanya menampilkan cadangan yang terkait dengan cache `my-cache`.
```
aws elasticache describe-serverless-cache-snapshots --serverless-cache-name my-cache
```
Operasi berikut menggunakan parameter `--serverless-cache-snapshot-name` untuk menampilkan detail cadangan `my-backup`.
```
aws elasticache describe-serverless-cache-snapshots --serverless-cache-snapshot-name my-backup
```
Untuk informasi selengkapnya, lihat [describe-serverless-cache-snapshots](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-serverless-cache-snapshots.html)di Referensi AWS CLI Perintah.
## Menjelaskan backup cluster berbasis node ()AWS CLI
Untuk menampilkan daftar backup cluster berbasis node dan rincian opsional tentang cadangan tertentu, gunakan operasi CLI. `describe-snapshots`
**Contoh**
Operasi berikut menggunakan parameter `--max-records` untuk menampilkan hingga 20 cadangan yang terkait dengan akun Anda. Menghilangkan parameter `--max-records` akan menampilkan hingga 50 cadangan.
```
aws elasticache describe-snapshots --max-records 20
```
Operasi berikut menggunakan parameter `--cache-cluster-id` untuk menampilkan hanya cadangan yang terkait dengan klaster `my-cluster`.
```
aws elasticache describe-snapshots --cache-cluster-id my-cluster
```
Operasi berikut menggunakan parameter `--snapshot-name` untuk menampilkan detail cadangan `my-backup`.
```
aws elasticache describe-snapshots --snapshot-name my-backup
```
Untuk informasi selengkapnya, lihat [deskripsi-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-snapshots.html) di Referensi Perintah.AWS CLI
# Menyalin cadangan
Anda dapat membuat salinan cadangan apa pun, baik dibuat secara otomatis maupun manual. Anda juga dapat mengekspor cadangan Anda sehingga Anda dapat mengaksesnya dari luar ElastiCache. Untuk panduan tentang cara mengekspor cadangan, lihat [Mengekspor cadangan](backups-exporting.md).
Langkah-langkah berikut menunjukkan cara menyalin cadangan.
## Menyalin cadangan (Konsol)
**Untuk menyalin cadangan (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar cadangan Anda, dari panel navigasi sebelah kiri, pilih **Cadangan**.
1. Dari daftar cadangan, pilih kotak di sebelah kiri nama cadangan yang ingin Anda salin.
1. Pilih **Tindakan** lalu **Salin**.
1. Pada kotak **Nama cadangan baru**, ketikkan nama untuk cadangan baru Anda.
1. Pilih **Salin**.
## Menyalin cadangan nirserver (AWS CLI)
Untuk menyalin cadangan cache nirserver, gunakan operasi `copy-serverless-cache-snapshot`.
**Parameter**
+ `--source-serverless-cache-snapshot-name` – Nama cadangan yang akan disalin.
+ `--target-serverless-cache-snapshot-name` – Nama salinan cadangan.
Contoh berikut membuat salinan dari cadangan otomatis.
Untuk Linux, macOS, atau Unix:
```
aws elasticache copy-serverless-cache-snapshot \
--source-serverless-cache-snapshot-name automatic.my-cache-2023-11-27-03-15 \
--target-serverless-cache-snapshot-name my-backup-copy
```
Untuk Windows:
```
aws elasticache copy-serverless-cache-snapshot ^
--source-serverless-cache-snapshot-name automatic.my-cache-2023-11-27-03-15 ^
--target-serverless-cache-snapshot-name my-backup-copy
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-serverless-cache-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-serverless-cache-snapshot.html) di *AWS CLI*.
## Menyalin backup cluster berbasis node ()AWS CLI
Untuk menyalin cadangan cluster berbasis node, gunakan operasi. `copy-snapshot`
**Parameter**
+ `--source-snapshot-name` – Nama cadangan yang akan disalin.
+ `--target-snapshot-name` – Nama salinan cadangan.
+ `--target-bucket` – Dikhususkan untuk mengekspor cadangan. Jangan menggunakan parameter ini saat membuat salinan cadangan. Untuk informasi selengkapnya, lihat [Mengekspor cadangan](backups-exporting.md).
Contoh berikut membuat salinan dari cadangan otomatis.
Untuk Linux, macOS, atau Unix:
```
aws elasticache copy-snapshot \
--source-snapshot-name automatic.my-redis-primary-2014-03-27-03-15 \
--target-snapshot-name amzn-s3-demo-bucket
```
Untuk Windows:
```
aws elasticache copy-snapshot ^
--source-snapshot-name automatic.my-redis-primary-2014-03-27-03-15 ^
--target-snapshot-name amzn-s3-demo-bucket
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-snapshot.html) di *AWS CLI*.
# Mengekspor cadangan
Amazon ElastiCache mendukung ekspor cadangan Redis OSS Anda ElastiCache ke bucket Amazon Simple Storage Service (Amazon S3), yang memberi Anda akses ke sana dari luar. ElastiCache Anda dapat mengekspor cadangan menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API.
Mengekspor cadangan dapat membantu jika Anda perlu meluncurkan cluster di AWS Wilayah lain. Anda dapat mengekspor data Anda dalam satu AWS Wilayah, menyalin file.rdb ke AWS Wilayah baru, dan kemudian menggunakan file.rdb itu untuk menyemai cache baru alih-alih menunggu cluster baru diisi melalui penggunaan. Untuk informasi tentang melakukan seeding klaster baru, lihat [Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal](backups-seeding-redis.md). Alasan lain Anda mungkin ingin mengekspor data cache Anda adalah dengan menggunakan file.rdb untuk pemrosesan offline.
**penting**
ElastiCache Cadangan dan ember Amazon S3 yang ingin Anda salin harus berada di Wilayah yang sama AWS.
Meskipun cadangan disalin ke bucket Amazon S3 dalam keadaan terenkripsi, sebaiknya jangan memberi orang lain akses ke bucket Amazon S3 tempat Anda ingin menyimpan cadangan Anda.
Mengekspor cadangan ke Amazon S3 tidak didukung untuk klaster yang menggunakan tingkatan data. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
Mengekspor cadangan tersedia untuk: cluster Valkey berbasis node, cluster Redis OSS berbasis node, dan cache tanpa server Valkey, Memcached, dan Redis OSS. Mengekspor cadangan tidak tersedia untuk cluster Memcached berbasis node.
Sebelum Anda dapat mengekspor cadangan ke bucket Amazon S3, Anda harus memiliki bucket Amazon S3 di Wilayah AWS yang sama dengan cadangan. Berikan ElastiCache akses ke ember. Dua langkah pertama menunjukkan cara melakukannya.
## Buat bucket Amazon S3.
Langkah-langkah berikut menggunakan konsol Amazon S3 untuk membuat bucket Amazon S3 tempat Anda mengekspor dan menyimpan cadangan. ElastiCache
**Untuk membuat bucket Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih **Buat Bucket**.
1. Di **Buat Bucket - Pilih Nama Bucket dan Wilayah**, lakukan hal berikut:
1. Di **Nama Bucket**, ketikkan nama untuk bucket Amazon S3 Anda.
Nama bucket Amazon S3 Anda harus sesuai dengan persyaratan DNS. Jika tidak, tidak ElastiCache dapat mengakses file cadangan Anda. Aturan untuk kesesuaian DNS adalah:
+ Nama harus minimal 3 dan tidak lebih dari 63 karakter.
+ Nama harus serangkaian satu atau beberapa label yang dipisahkan oleh titik (.) dengan setiap label:
+ Dimulai dengan huruf kecil atau angka.
+ Diakhiri dengan huruf kecil atau angka.
+ Hanya berisi huruf kecil, angka, dan tanda hubung.
+ Nama tidak dapat diformat sebagai alamat IP (misalnya, 192.0.2.0).
1. Dari daftar **Wilayah**, pilih AWS Wilayah untuk bucket Amazon S3 Anda.AWS Wilayah ini harus AWS Wilayah yang sama dengan ElastiCache cadangan yang ingin Anda ekspor.
1. Pilih **Buat**.
Untuk informasi selengkapnya tentang cara membuat bucket Amazon S3, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html) dalam *Panduan Pengguna Amazon Simple Storage Service*.
## Berikan ElastiCache akses ke bucket Amazon S3 Anda
ElastiCache Agar dapat menyalin snapshot ke bucket Amazon S3, Anda harus memperbarui kebijakan bucket IAM untuk ElastiCache memberikan akses ke bucket.
**Awas**
Meskipun cadangan yang disalin ke bucket Amazon S3 sudah terenkripsi, data Anda dapat diakses oleh siapa saja dengan akses ke bucket Amazon S3 Anda. Oleh karena itu, sebaiknya siapkan kebijakan IAM untuk mencegah akses tidak sah ke bucket Amazon S3 ini. Untuk informasi selengkapnya, lihat [Mengelola akses](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html) dalam *Panduan Pengguna Amazon S3*.
Untuk membuat izin yang tepat di bucket Amazon S3, lakukan langkah-langkah yang dijelaskan sebagai berikut.
**Untuk memberikan ElastiCache akses ke bucket S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih nama bucket Amazon S3 tempat cadangan akan disalin. Bucket tersebut harus berupa bucket S3 yang Anda buat di [Buat bucket Amazon S3.](#backups-exporting-create-s3-bucket).
1. Pilih tab **Izin** dan di bagian **Izin**, pilih **Daftar kontrol akses (ACL)**, lalu pilih **Edit**.
1. Tambahkan ID Kanonis penerima izin `540804c33a284a299d2547575ce1010f2312ef3da9b3a053c8bc45bf233e4353` dengan opsi berikut:
+ **Objek: Daftar, Tulis**
+ **Bucket ACL: Baca, Tulis**
**catatan**
Untuk GovCloud Wilayah PDT, Id Kanonik adalah. `40fa568277ad703bd160f66ae4f83fc9dfdfd06c2f1b5060ca22442ac3ef8be6`
Untuk GovCloud Wilayah OSU, Id Kanonik adalah. `c54286759d2a83da9c480405349819c993557275cf37d820d514b42da6893f5c`
1. Pilih **Simpan**.
## Ekspor ElastiCache cadangan
Sekarang Anda telah membuat bucket S3 dan memberikan ElastiCache izin untuk mengaksesnya. Selanjutnya, Anda dapat menggunakan ElastiCache konsol,AWS CLI, atau ElastiCache API untuk mengekspor snapshot Anda ke sana.
Berikut adalah contoh tampilan kebijakan yang sudah diperbarui.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399484",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
}
]
}
```
------
Untuk Wilayah keikutsertaan, berikut ini adalah contoh seperti apa kebijakan IAM yang diperbarui untuk bucket S3. (Contoh ini menggunakan Wilayah Asia Pasifik (Hong Kong).)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399483",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
},
{
"Sid": "Stmt15399484",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
}
]
}
```
------
### Mengekspor ElastiCache cadangan (Konsol)
Langkah-langkah berikut menggunakan ElastiCache konsol untuk mengekspor cadangan ke bucket Amazon S3 sehingga Anda dapat mengaksesnya dari luar. ElastiCache Bucket Amazon S3 harus berada di AWS Wilayah yang sama dengan cadangan. ElastiCache
**Untuk mengekspor ElastiCache cadangan ke bucket Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar cadangan Anda, dari panel navigasi sebelah kiri, pilih **Cadangan**.
1. Dari daftar cadangan, pilih kotak di sebelah kiri nama cadangan yang ingin Anda ekspor.
1. Pilih **Salin**.
1. Di **Buat Salinan Cadangan?**, lakukan hal berikut:
1. Di kotak **Nama cadangan baru**, ketikkan nama untuk cadangan baru Anda.
Nama itu harus di antara 1 dan 1.000 karakter serta dapat dienkode ke UTF-8.
ElastiCache menambahkan pengidentifikasi instance dan nilai `.rdb` yang Anda masukkan di sini. Misalnya, jika Anda memasukkan `my-exported-backup`, ElastiCache membuat `my-exported-backup-0001.rdb`.
1. Dari daftar **Lokasi S3 Target**, pilih nama bucket Amazon S3 yang menjadi tujuan Anda menyalin cadangan (bucket yang telah Anda buat di [Buat bucket Amazon S3.](#backups-exporting-create-s3-bucket)).
**Lokasi Target S3** harus berupa bucket Amazon S3 di Wilayah AWS cadangan dengan izin berikut agar proses ekspor berhasil.
+ Akses objek – **Baca** dan **Tulis**.
+ Akses izin – **Baca**.
Untuk informasi selengkapnya, lihat [Berikan ElastiCache akses ke bucket Amazon S3 Anda](#backups-exporting-grant-access).
1. Pilih **Salin**.
**catatan**
Jika bucket S3 Anda tidak memiliki izin yang diperlukan untuk mengekspor cadangan ElastiCache ke sana, Anda menerima salah satu pesan galat berikut. Kembali ke [Berikan ElastiCache akses ke bucket Amazon S3 Anda](#backups-exporting-grant-access) untuk menambahkan izin yang ditentukan dan mencoba mengekspor cadangan Anda kembali.
ElastiCache belum diberikan izin BACA %s pada Bucket S3.
**Solusi:** Tambahkan izin Baca pada bucket.
ElastiCache belum diberikan izin WRITE %s pada Bucket S3.
**Solusi:** Tambahkan izin Tulis pada bucket.
ElastiCache belum diberikan izin READ\$1ACP %s pada Bucket S3.
**Solusi:** Tambahkan **Baca** untuk akses Izin pada bucket.
Jika Anda ingin menyalin cadangan Anda ke AWS Wilayah lain, gunakan Amazon S3 untuk menyalinnya. Untuk informasi selengkapnya, lihat [Menyalin objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/MakingaCopyofanObject.html) dalam *Panduan Pengguna Amazon Simple Storage*.
### Mengekspor cadangan ElastiCache tanpa server ()AWS CLI
**Mengekspor cadangan cache nirserver**
Ekspor cadangan ke bucket Amazon S3 menggunakan operasi CLI `export-serverless-cache-snapshot` dengan parameter berikut:
**Parameter**
+ `--serverless-cache-snapshot-name` – Nama cadangan yang akan disalin.
+ `--s3-bucket-name` – Nama bucket Amazon S3 tempat tujuan Anda mengekspor cadangan. Salinan cadangan dibuat dalam bucket yang ditentukan.
`--s3-bucket-name`Harus berupa bucket Amazon S3 di AWS Wilayah cadangan dengan izin berikut agar proses ekspor berhasil.
+ Akses objek – **Baca** dan **Tulis**.
+ Akses izin – **Baca**.
Operasi berikut menyalin cadangan ke my-s3-bucket.
Untuk Linux, macOS, atau Unix:
```
aws elasticache export-serverless-cache-snapshot \
--serverless-cache-snapshot-name automatic.my-redis-2023-11-27 \
--s3-bucket-name my-s3-bucket
```
Untuk Windows:
```
aws elasticache export-serverless-cache-snapshot ^
--serverless-cache-snapshot-name automatic.my-redis-2023-11-27 ^
--s3-bucket-name my-s3-bucket
```
### Mengekspor cadangan ElastiCache cluster berbasis node ()AWS CLI
**Mengekspor cadangan cluster berbasis node**
Ekspor cadangan ke bucket Amazon S3 menggunakan operasi CLI `copy-snapshot` dengan parameter berikut:
**Parameter**
+ `--source-snapshot-name` – Nama cadangan yang akan disalin.
+ `--target-snapshot-name` – Nama salinan cadangan.
Nama tersebut harus berisi antara 1 dan 1.000 karakter serta dienkode dengan UTF-8.
ElastiCache menambahkan pengidentifikasi instance dan nilai `.rdb` yang Anda masukkan di sini. Misalnya, jika Anda memasukkan `my-exported-backup`, ElastiCache membuat `my-exported-backup-0001.rdb`.
+ `--target-bucket` – Nama bucket Amazon S3 tempat tujuan Anda mengekspor cadangan. Salinan cadangan dibuat dalam bucket yang ditentukan.
`--target-bucket`Harus berupa bucket Amazon S3 di AWS Wilayah cadangan dengan izin berikut agar proses ekspor berhasil.
+ Akses objek – **Baca** dan **Tulis**.
+ Akses izin – **Baca**.
Untuk informasi selengkapnya, lihat [Berikan ElastiCache akses ke bucket Amazon S3 Anda](#backups-exporting-grant-access).
Operasi berikut menyalin cadangan ke my-s3-bucket.
Untuk Linux, macOS, atau Unix:
```
aws elasticache copy-snapshot \
--source-snapshot-name automatic.my-redis-primary-2016-06-27-03-15 \
--target-snapshot-name my-exported-backup \
--target-bucket my-s3-bucket
```
Untuk Windows:
```
aws elasticache copy-snapshot ^
--source-snapshot-name automatic.my-redis-primary-2016-06-27-03-15 ^
--target-snapshot-name my-exported-backup ^
--target-bucket my-s3-bucket
```
# Melakukan pemulihan dari cadangan ke dalam cache baru
Anda dapat memulihkan cadangan yang ada dari Valkey ke cache Valkey baru atau cluster berbasis node, dan mengembalikan cadangan Redis OSS yang ada ke cache Redis OSS baru atau cluster berbasis node. Anda juga dapat memulihkan cadangan cache tanpa server Memcached yang ada ke cache tanpa server Memcached yang baru.
## Memulihkan cadangan ke dalam cache nirserver (Konsol)
**catatan**
ElastiCache Tanpa server mendukung file RDB yang kompatibel dengan Valkey 7.2 ke atas, dan versi Redis OSS antara 5.0 dan versi terbaru yang tersedia.
**Untuk memulihkan cadangan ke cache nirserver (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih **Cadangan**.
1. Dalam daftar cadangan, pilih kotak di sebelah kiri nama cadangan yang ingin Anda pulihkan.
1. Pilih **Tindakan**, lalu pilih **Pulihkan**.
1. Masukkan nama untuk cache nirserver baru dan deskripsi opsional.
1. Klik **Buat** untuk membuat cache baru dan mengimpor data dari cadangan Anda.
## Memulihkan cadangan ke dalam cluster berbasis node (Konsol)
**Untuk memulihkan cadangan ke cluster berbasis node (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih **Cadangan**.
1. Di daftar cadangan, pilih kotak di sebelah kiri nama cadangan yang ingin Anda pulihkan.
1. Pilih **Tindakan**, lalu pilih **Pulihkan**.
1. Pilih **cache berbasis Node** dan sesuaikan pengaturan cluster, seperti jenis node, ukuran, jumlah pecahan, replika, penempatan AZ, dan pengaturan keamanan.
1. Pilih **Buat** untuk membuat cluster berbasis node baru dan mengimpor data dari cadangan Anda.
## Memulihkan cadangan ke dalam cache nirserver (AWS CLI)
**catatan**
ElastiCache Tanpa server mendukung file RDB yang kompatibel dengan Valkey 7.2 ke atas, dan versi Redis OSS antara 5.0 dan versi terbaru yang tersedia.
**Untuk memulihkan cadangan ke cache nirserver baru (AWS CLI)**
AWS CLI Contoh berikut membuat cache baru menggunakan `create-serverless-cache` dan mengimpor data dari cadangan.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
--snapshot-arns-to-restore Snapshot-ARN
```
Untuk Windows:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis ^
--snapshot-arns-to-restore Snapshot-ARN
```
# Menghapus cadangan
Cadangan otomatis akan dihapus secara otomatis jika batas retensinya berakhir. Jika Anda menghapus klaster, semua cadangan otomatis juga dihapus. Jika Anda menghapus grup replikasi, semua cadangan otomatis dari klaster di grup tersebut juga dihapus.
ElastiCache menyediakan operasi penghapusan API yang memungkinkan Anda menghapus cadangan kapan saja, terlepas dari apakah cadangan dibuat secara otomatis atau manual. Karena cadangan manual tidak memiliki batas retensi, penghapusan manual adalah satu-satunya cara untuk menghapusnya.
Anda dapat menghapus cadangan menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API.
## Menghapus cadangan (Konsol)
Prosedur berikut menghapus cadangan menggunakan ElastiCache konsol.
**Untuk menghapus cadangan**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Cadangan**.
Layar Cadangan muncul dengan daftar cadangan Anda.
1. Pilih kotak di sebelah kiri nama cadangan yang ingin Anda hapus.
1. Pilih **Hapus**.
1. Jika Anda ingin menghapus cadangan ini, pilih **Hapus** di layar konfirmasi **Hapus Cadangan**. Status berubah menjadi *menghapus*.
## Menghapus cadangan nirserver (AWS CLI)
Gunakan AWS CLI operasi delete-snapshot dengan parameter berikut untuk menghapus cadangan tanpa server.
+ `--serverless-cache-snapshot-name` – Nama cadangan yang akan dihapus.
Kode berikut menghapus cadangan `myBackup`.
```
aws elasticache delete-serverless-cache-snapshot --serverless-cache-snapshot-name myBackup
```
Untuk informasi selengkapnya, lihat [delete-serverless-cache-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-serverless-cache-snapshot.html) dalam *AWS CLI Referensi Perintah*.
## Menghapus backup cluster berbasis node ()AWS CLI
Gunakan AWS CLI operasi delete-snapshot dengan parameter berikut untuk menghapus cadangan cluster berbasis node.
+ `--snapshot-name` – Nama cadangan yang akan dihapus.
Kode berikut menghapus cadangan `myBackup`.
```
aws elasticache delete-snapshot --snapshot-name myBackup
```
Untuk informasi selengkapnya, lihat [delete-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-snapshot.html) dalam *Referensi Perintah AWS CLI*.
# Memberikan tag pada cadangan
Anda dapat memberikan metadata Anda sendiri ke setiap cadangan dalam bentuk tag. Tag memungkinkan Anda mengategorikan cadangan dengan berbagai cara, misalnya, berdasarkan tujuan, pemilik, atau lingkungan. Hal ini berguna ketika Anda memiliki banyak sumber daya dengan jenis yang sama—Anda dapat dengan cepat mengidentifikasi sumber daya tertentu berdasarkan tag yang telah Anda tetapkan. Untuk informasi selengkapnya, lihat [Sumber daya yang dapat Anda beri tag](Tagging-Resources.md#Tagging-your-resources).
Tag alokasi biaya adalah sarana untuk melacak biaya Anda di beberapa AWS layanan dengan mengelompokkan pengeluaran Anda pada faktur berdasarkan nilai tag. Untuk mempelajari selengkapnya tentang tag alokasi biaya, lihat [Menggunakan tag alokasi biaya](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
Dengan menggunakan ElastiCache konsol, ElastiCache API AWS CLI, atau Anda dapat menambahkan, membuat daftar, memodifikasi, menghapus, atau menyalin tag alokasi biaya pada cadangan Anda. Lihat informasi yang lebih lengkap di [Memantau biaya dengan tag alokasi biaya](Tagging.md).
# Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal
Saat Anda membuat cluster berbasis node Valkey atau Redis OSS baru, Anda dapat menyemai dengan data dari file cadangan Valkey atau Redis OSS.rdb. Penyemaian cluster berguna jika saat ini Anda mengelola instance Valkey atau Redis OSS di luar ElastiCache dan ingin mengisi cluster berbasis node Redis OSS baru ElastiCache Anda dengan data Valkey atau Redis OSS Anda yang ada.
Untuk menyemai klaster berbasis node Valkey atau Redis OSS baru dari cadangan Valkey atau Redis OSS yang dibuat di Amazon, lihat. ElastiCache [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md)
Saat Anda menggunakan file Valkey atau Redis OSS.rdb untuk menyemai cluster berbasis node baru, Anda dapat melakukan hal berikut:
+ Tingkatkan dari cluster non-partisi ke cluster berbasis node Valkey atau Redis OSS (mode cluster diaktifkan) yang menjalankan Redis OSS versi 3.2.4.
+ Tentukan sejumlah pecahan (disebut grup simpul di API dan CLI) di cluster berbasis node baru. Jumlah ini bisa berbeda dari jumlah pecahan di cluster berbasis node yang digunakan untuk membuat file cadangan.
+ Tentukan jenis node yang berbeda untuk cluster berbasis node baru—lebih besar atau lebih kecil dari yang digunakan di cluster yang membuat cadangan. Jika Anda menskalakan ke tipe node yang lebih kecil, pastikan bahwa tipe node baru memiliki memori yang cukup untuk data Anda dan overhead Valkey atau Redis OSS. Untuk informasi selengkapnya, lihat [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md).
+ Bagikan kunci Anda di slot cluster Valkey atau Redis OSS (mode cluster diaktifkan) baru secara berbeda dari pada cluster yang digunakan untuk membuat file cadangan.
**catatan**
Anda tidak dapat menyemai klaster Valkey atau Redis OSS (mode cluster dinonaktifkan) dari file.rdb yang dibuat dari cluster Valkey atau Redis OSS (mode cluster enabled).
**penting**
Anda harus memastikan bahwa data cadangan Valkey atau Redis OSS Anda tidak melebihi sumber daya node. Misalnya, Anda tidak dapat mengunggah file.rdb dengan 5 GB data Valkey atau Redis OSS ke node cache.m3.medium yang memiliki memori 2,9 GB.
Jika cadangan terlalu besar, klaster yang dihasilkan akan memiliki status `restore-failed`. Jika hal ini terjadi, Anda harus menghapus klaster tersebut dan memulai dari awal.
Untuk daftar lengkap jenis dan spesifikasi node, lihat [Parameter spesifik tipe node Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific) serta [fitur dan detail ElastiCache produk Amazon](https://aws.amazon.com/elasticache/details/).
Anda dapat mengenkripsi file Valkey atau Redis OSS.rdb dengan enkripsi sisi server Amazon S3 (SSE-S3) saja. Untuk informasi selengkapnya, lihat [Melindungi data menggunakan enkripsi sisi server](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html).
Berikut ini, Anda dapat menemukan topik yang memandu Anda melalui migrasi cluster Anda dari luar ElastiCache untuk Valkey atau Redis OSS ke ElastiCache Redis OSS.
**Topics**
+ [Langkah 1: Buat cadangan Valkey atau Redis OSS](#backups-seeding-redis-create-backup)
+ [Langkah 2: Buat folder dan bucket Amazon S3](#backups-seeding-redis-create-s3-bucket)
+ [Langkah 3: Unggah cadangan Anda ke Amazon S3](#backups-seeding-redis-upload)
+ [Langkah 4: Berikan akses ElastiCache baca ke file.rdb](#backups-seeding-redis-grant-access)
**Topics**
+ [Langkah 1: Buat cadangan Valkey atau Redis OSS](#backups-seeding-redis-create-backup)
+ [Langkah 2: Buat folder dan bucket Amazon S3](#backups-seeding-redis-create-s3-bucket)
+ [Langkah 3: Unggah cadangan Anda ke Amazon S3](#backups-seeding-redis-upload)
+ [Langkah 4: Berikan akses ElastiCache baca ke file.rdb](#backups-seeding-redis-grant-access)
## Langkah 1: Buat cadangan Valkey atau Redis OSS
**Untuk membuat cadangan Valkey atau Redis OSS untuk menyemai instans Redis OSS Anda ElastiCache**
1. Connect ke instans Valkey atau Redis OSS yang ada.
1. Jalankan salah satu `BGSAVE` atau `SAVE` operasi untuk membuat cadangan. Catat tempat file .rdb Anda berada.
`BGSAVE` bersifat asinkron dan tidak memblokir klien lain saat melakukan pemrosesan. Untuk informasi lebih lanjut, lihat [BGSAVE di situs](https://valkey.io/commands/bgsave) web Valkey.
`SAVE` bersifat sinkron dan memblokir proses lainnya hingga selesai. Untuk informasi lebih lanjut, lihat [SIMPAN](https://valkey.io/commands/save) di situs web Valkey.
Untuk informasi tambahan tentang membuat cadangan, lihat [Persistence di situs](https://valkey.io/topics/persistence) web Valkey.
## Langkah 2: Buat folder dan bucket Amazon S3
Saat Anda telah membuat file cadangan, Anda perlu mengunggahnya ke folder dalam bucket Amazon S3. Untuk melakukannya, Anda harus memiliki bucket Amazon S3 dan folder dalam bucket tersebut terlebih dahulu. Jika Anda sudah memiliki bucket Amazon S3 dan folder dengan izin yang sesuai, Anda dapat melanjutkan ke [Langkah 3: Unggah cadangan Anda ke Amazon S3](#backups-seeding-redis-upload).
**Untuk membuat bucket Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Ikuti petunjuk untuk membuat bucket Amazon S3 di [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) dalam *Panduan Pengguna Amazon Simple Storage Service*.
Nama bucket Amazon S3 Anda harus sesuai dengan persyaratan DNS. Jika tidak, tidak ElastiCache dapat mengakses file cadangan Anda. Aturan untuk kesesuaian DNS adalah:
+ Nama harus minimal 3 dan tidak lebih dari 63 karakter.
+ Nama harus serangkaian satu atau beberapa label yang dipisahkan oleh titik (.) dengan setiap label:
+ Dimulai dengan huruf kecil atau angka.
+ Diakhiri dengan huruf kecil atau angka.
+ Hanya berisi huruf kecil, angka, dan tanda hubung.
+ Nama tidak dapat diformat sebagai alamat IP (misalnya, 192.0.2.0).
Anda harus membuat bucket Amazon S3 di AWS Wilayah yang sama dengan cluster Redis OSS baru ElastiCache Anda. Pendekatan ini memastikan bahwa kecepatan transfer data tertinggi saat ElastiCache membaca file.rdb Anda dari Amazon S3.
**catatan**
Untuk menjaga data Anda seaman mungkin, buat izin di bucket Amazon S3 Anda seketat mungkin. Pada saat yang sama, izin masih perlu mengizinkan bucket dan isinya digunakan untuk menyemai klaster Valkey atau Redis OSS baru Anda.
**Untuk menambahkan folder ke bucket Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih nama bucket untuk mengunggah file .rdb Anda.
1. Pilih **Buat folder**.
1. Masukkan nama untuk folder baru Anda.
1. Pilih **Simpan**.
Catat nama dari bucket dan folder.
## Langkah 3: Unggah cadangan Anda ke Amazon S3
Sekarang, unggah file .rdb yang Anda buat di [Langkah 1: Buat cadangan Valkey atau Redis OSS](#backups-seeding-redis-create-backup). Anda mengunggahnya ke bucket Amazon S3 dan folder yang Anda buat di [Langkah 2: Buat folder dan bucket Amazon S3](#backups-seeding-redis-create-s3-bucket). Untuk informasi selengkapnya tentang tugas ini, lihat [Menambahkan Objek ke Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html). Di antara langkah 2 dan 3, pilih nama folder yang Anda buat.
**Untuk mengunggah file .rdb Anda ke folder Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih nama bucket Amazon S3 yang Anda buat di Langkah 2.
1. Pilih nama folder yang Anda buat di Langkah 2.
1. Pilih **Unggah**.
1. Pilih **Tambahkan file**.
1. Telusuri untuk mencari file atau beberapa file yang ingin diunggah, lalu pilih file atau beberapa file tersebut. Untuk memilih beberapa file, tahan tombol Ctrl saat memilih setiap nama file.
1. Pilih **Buka**.
1. Konfirmasikan file atau beberapa file yang tercantum sudah benar dalam kotak dialog **Unggah**, lalu pilih **Unggah**.
Catat jalur ke file .rdb Anda. Misalnya, jika nama bucket Anda `myBucket` dan jalurnya adalah `myFolder/redis.rdb`, masukkan `myBucket/myFolder/redis.rdb`. Anda memerlukan jalur ini untuk melakukan seeding klaster baru dengan data dalam cadangan ini.
Untuk informasi tambahan, lihat [Pembatasan dan batasan bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) dalam *Panduan Pengguna Amazon Simple Storage Service*.
## Langkah 4: Berikan akses ElastiCache baca ke file.rdb
Sekarang, berikan akses ElastiCache baca ke file cadangan.rdb Anda. Anda memberikan ElastiCache akses ke file cadangan dengan cara yang berbeda tergantung apakah bucket Anda berada di AWS Wilayah default atau AWS Wilayah keikutsertaan.
AWS Wilayah yang diperkenalkan sebelum 20 Maret 2019, diaktifkan secara default. Anda dapat mulai bekerja di AWS Wilayah ini segera. Wilayah yang diperkenalkan setelah 20 Maret 2019, seperti Asia Pasifik (Hong Kong) dan Timur Tengah (Bahrain) dinonaktifkan secara default. Anda harus mengaktifkan, atau memilih, Wilayah ini sebelum dapat menggunakannya, seperti dijelaskan pada dalam [Mengelola Wilayah AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) dalam *Referensi Umum AWS*.
Pilih pendekatan Anda tergantung pada AWS Wilayah Anda:
+ Untuk Wilayah default, gunakan prosedur di [Berikan akses ElastiCache baca ke file.rdb di Wilayah default](#backups-seeding-redis-default-region).
+ Untuk Wilayah pilihan, gunakan prosedur di [Berikan akses ElastiCache baca ke file.rdb di Wilayah keikutsertaan](#backups-seeding-opt-in-region).
### Berikan akses ElastiCache baca ke file.rdb di Wilayah default
AWS Wilayah yang diperkenalkan sebelum 20 Maret 2019, diaktifkan secara default. Anda dapat mulai bekerja di AWS Wilayah ini segera. Wilayah yang diperkenalkan setelah 20 Maret 2019, seperti Asia Pasifik (Hong Kong) dan Timur Tengah (Bahrain) dinonaktifkan secara default. Anda harus mengaktifkan, atau memilih, Wilayah ini sebelum dapat menggunakannya, seperti dijelaskan pada dalam [Mengelola Wilayah AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) dalam *Referensi Umum AWS*.
**Untuk memberikan akses ElastiCache baca ke file cadangan di AWS Wilayah yang diaktifkan secara default**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih nama bucket S3 yang berisi file .rdb Anda.
1. Pilih nama folder yang berisi file .rdb Anda.
1. Pilih nama file cadangan .rdb Anda. Nama file yang dipilih muncul di atas tab di bagian atas halaman.
1. Pilih **Izin**.
1. Jika **aws-scs-s3-readonly** atau salah satu kanonik IDs dalam daftar berikut tidak terdaftar sebagai pengguna, lakukan hal berikut:
1. Di bawah **Akses untuk AWS akun lain**, pilih **Tambahkan penerima hibah**.
1. Di dalam kotak, tambahkan ID kanonik AWS Wilayah seperti yang ditunjukkan berikut:
+ AWS GovCloud (AS-Barat) Wilayah:
```
40fa568277ad703bd160f66ae4f83fc9dfdfd06c2f1b5060ca22442ac3ef8be6
```
**penting**
Cadangan harus ditempatkan di bucket S3 AWS GovCloud (US) agar Anda dapat mengunduhnya ke cluster Valkey atau Redis OSS di.AWS GovCloud (US)
+ AWS Wilayah diaktifkan secara default:
```
540804c33a284a299d2547575ce1010f2312ef3da9b3a053c8bc45bf233e4353
```
1. Tetapkan izin pada bucket dengan memilih **Ya** untuk berikut ini:
+ **Daftar/tulis objek**
+ **Baca/tulis izin ACL objek**
1. Pilih **Simpan**.
1. Pilih **Gambaran Umum**, lalu pilih **Unduh**.
### Berikan akses ElastiCache baca ke file.rdb di Wilayah keikutsertaan
AWS Wilayah yang diperkenalkan sebelum 20 Maret 2019, diaktifkan secara default. Anda dapat mulai bekerja di AWS Wilayah ini segera. Wilayah yang diperkenalkan setelah 20 Maret 2019, seperti Asia Pasifik (Hong Kong) dan Timur Tengah (Bahrain) dinonaktifkan secara default. Anda harus mengaktifkan, atau memilih, Wilayah ini sebelum dapat menggunakannya, seperti dijelaskan pada dalam [Mengelola Wilayah AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) dalam *Referensi Umum AWS*.
Sekarang, berikan akses ElastiCache baca ke file cadangan.rdb Anda.
**Untuk memberikan akses ElastiCache baca ke file cadangan**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih nama bucket S3 yang berisi file .rdb Anda.
1. Pilih nama folder yang berisi file .rdb Anda.
1. Pilih nama file cadangan .rdb Anda. Nama file yang dipilih muncul di atas tab di bagian atas halaman.
1. Pilih tab **Izin**.
1. Di bagian **Izin**, pilih **Kebijakan bucket**, lalu pilih **Edit**.
1. Memperbarui kebijakan untuk memberikan izin ElastiCache yang diperlukan untuk melakukan operasi:
+ Tambahkan `[ "Service" : "region-full-name.elasticache-snapshot.amazonaws.com" ]` ke `Principal`.
+ Menambahkan izin yang diperlukan berikut untuk mengekspor snapshot ke bucket Amazon S3:
+ `"s3:GetObject"`
+ `"s3:ListBucket"`
+ `"s3:GetBucketAcl"`
Berikut adalah contoh tampilan kebijakan yang sudah diperbarui.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399483",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketAcl"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/backup1.rdb",
"arn:aws:s3:::amzn-s3-demo-bucket/backup2.rdb"
]
}
]
}
```
------
1. Pilih **Simpan perubahan**.
### Benih ElastiCache cluster dengan data file.rdb
Sekarang Anda siap untuk membuat ElastiCache cluster dan menyemai dengan data dari file.rdb. Untuk membuat klaster, ikuti petunjuk di [Membuat cluster untuk Valkey atau Redis OSS](Clusters.Create.md) atau [Membuat grup replikasi Valkey atau Redis OSS dari awal](Replication.CreatingReplGroup.NoExistingCluster.md). Pastikan untuk memilih Valkey atau Redis OSS sebagai mesin cluster Anda.
Metode yang Anda gunakan untuk mengetahui ElastiCache di mana menemukan cadangan yang Anda unggah ke Amazon S3 bergantung pada metode yang Anda gunakan untuk membuat cluster:
**Benih ElastiCache untuk cluster Redis OSS atau grup replikasi dengan data file.rdb**
+ **Menggunakan ElastiCache konsol**
Saat memilih **Pengaturan klaster**, pilih **Pulihkan dari cadangan** sebagai metode pembuatan klaster Anda, lalu pilih **Cadangan lain** sebagai **Sumber** Anda di bagian **Sumber cadangan**. Di kotak **Lokasi S3 file RDB seed**, ketikkan jalur Amazon S3 untuk file tersebut. Jika Anda memiliki beberapa file .rdb, ketikkan jalur untuk setiap file dalam daftar yang dipisahkan koma. Jalur Amazon S3 terlihat seperti `myBucket/myFolder/myBackupFilename.rdb`.
+ **Menggunakan AWS CLI**
Jika Anda menggunakan operasi `create-cache-cluster` atau `create-replication-group`, gunakan parameter `--snapshot-arns` untuk menentukan ARN yang memenuhi syarat sepenuhnya untuk setiap file .rdb. Misalnya, `arn:aws:s3:::myBucket/myFolder/myBackupFilename.rdb`. ARN harus dapat diresolusi ke file cadangan yang Anda simpan di Amazon S3.
+ **Menggunakan ElastiCache API**
Jika Anda menggunakan operasi `CreateCacheCluster` atau `CreateReplicationGroup` ElastiCache API, gunakan parameter `SnapshotArns` untuk menentukan ARN yang sepenuhnya memenuhi syarat untuk setiap file.rdb. Misalnya, `arn:aws:s3:::myBucket/myFolder/myBackupFilename.rdb`. ARN harus dapat diresolusi ke file cadangan yang Anda simpan di Amazon S3.
**penting**
Saat menyemai cluster Valkey atau Redis OSS (mode cluster enabled), Anda harus mengonfigurasi setiap grup node (shard) di cluster atau grup replikasi baru. Gunakan parameter `--node-group-configuration` (API: `NodeGroupConfiguration`) untuk melakukannya. Untuk informasi selengkapnya, lihat berikut ini:
CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)dalam Referensi AWS CLI
API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)di Referensi ElastiCache API
Selama proses pembuatan cluster Anda, data dalam cadangan Valkey atau Redis OSS Anda ditulis ke cluster. Anda dapat memantau kemajuan dengan melihat pesan ElastiCache acara. Untuk melakukan ini, lihat ElastiCache konsol dan pilih **Acara Cache**. Anda juga dapat menggunakan antarmuka baris AWS ElastiCache perintah atau ElastiCache API untuk mendapatkan pesan acara. Lihat informasi yang lebih lengkap di [Melihat ElastiCache acara](ECEvents.Viewing.md).
# Versi mesin dan peningkatan di ElastiCache
Bagian ini mencakup mesin Valkey, Memcached, dan Redis OSS yang didukung dan cara meng-upgrade. Perhatikan bahwa semua fitur yang tersedia dengan Redis OSS 7.2 tersedia di Valkey 7.2 dan di atas secara default. Anda juga dapat meningkatkan dari beberapa yang ada ElastiCache untuk mesin Redis OSS ke mesin Valkey.
# Memutakhirkan versi mesin termasuk peningkatan mesin silang
**Valkey dan Redis OSS**
Dengan Valkey dan Redis OSS, Anda memulai upgrade versi ke cluster atau grup replikasi Anda dengan memodifikasinya menggunakan ElastiCache konsol, API AWS CLI, atau ElastiCache API dan menentukan versi engine yang lebih baru.
Anda juga dapat melakukan upgrade silang dari Redis OSS ke Valkey. Untuk informasi lebih lanjut tentang peningkatan silang, lihat[Cara meningkatkan dari Redis OSS ke Valkey](#VersionManagement.HowTo.cross-engine-upgrade).
**Topics**
+ [Cara meningkatkan dari Redis OSS ke Valkey](#VersionManagement.HowTo.cross-engine-upgrade)
+ [Menyelesaikan peningkatan mesin Valkey atau Redis OSS yang diblokir](#resolving-blocked-engine-upgrades)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/VersionManagement.HowTo.html)
**Memcache**
Dengan Memcached, untuk memulai upgrade versi ke cluster Anda, Anda memodifikasinya dan menentukan versi mesin yang lebih baru. Anda dapat melakukan ini dengan menggunakan ElastiCache konsol, the AWS CLI, atau ElastiCache API:
+ Untuk menggunakan Konsol Manajemen AWS, lihat —[Menggunakan ElastiCache Konsol Manajemen AWS](Clusters.Modify.md#Clusters.Modify.CON).
+ Untuk menggunakan AWS CLI, lihat[Menggunakan AWS CLI dengan ElastiCache](Clusters.Modify.md#Clusters.Modify.CLI).
+ Untuk menggunakan ElastiCache API, lihat[Menggunakan ElastiCache API](Clusters.Modify.md#Clusters.Modify.API).
## Cara meningkatkan dari Redis OSS ke Valkey
Valkey dirancang sebagai pengganti drop-in untuk Redis OSS 7. Anda dapat meningkatkan dari Redis OSS ke Valkey menggunakan Konsol, API, atau CLI, dengan menentukan mesin baru dan versi mesin utama. Alamat IP endpoint dan semua aspek lain dari aplikasi tidak akan diubah oleh upgrade. Saat memutakhirkan dari Redis OSS 5.0.6 dan yang lebih tinggi, Anda tidak akan mengalami downtime.
**catatan**
**AWS Persyaratan versi CLI untuk peningkatan Redis OSS ke Valkey:**
Untuk AWS CLI v1: Versi minimum yang diperlukan 1.35.2 (Versi saat ini: 1.40.22)
Untuk AWS CLI v2: Minimum yang diperlukan versi 2.18.2 (Versi saat ini: 2.27.22)
**catatan**
Saat memutakhirkan dari versi Redis OSS sebelumnya dari 5.0.6, Anda mungkin mengalami waktu failover 30 hingga 60 detik selama propagasi DNS.
Untuk memutakhirkan kluster simpul tunggal Redis OSS (mode cluster dinonaktifkan) yang ada ke mesin Valkey, ikuti langkah-langkah berikut:. [Membuat grup replikasi menggunakan klaster yang sudah ada](Replication.CreatingReplGroup.ExistingCluster.md) Setelah cluster node tunggal Redis OSS (mode cluster dinonaktifkan) ditambahkan ke grup replikasi, Anda dapat melakukan upgrade lintas mesin ke Valkey.
### Memutakhirkan grup replikasi dari Redis OSS ke Valkey
Jika Anda memiliki grup replikasi Redis OSS yang menggunakan grup parameter cache default, Anda dapat meningkatkan ke Valkey dengan menentukan versi mesin dan mesin baru dengan API. modify-replication-group
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id myReplGroup \
--engine valkey \
--engine-version 8.0
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id myReplGroup ^
--engine valkey ^
--engine-version 8.0
```
Jika Anda memiliki grup parameter cache kustom yang diterapkan ke grup replikasi Redis OSS yang ada yang ingin Anda tingkatkan, Anda juga harus melewati grup parameter cache Valkey kustom dalam permintaan. Grup parameter kustom Valkey input harus memiliki nilai parameter statis Redis OSS yang sama dengan grup parameter kustom Redis OSS yang ada.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id myReplGroup \
--engine valkey \
--engine-version 8.0 \
--cache-parameter-group-name myParamGroup
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id myReplGroup ^
--engine valkey ^
--engine-version 8.0 ^
--cache-parameter-group-name myParamGroup
```
### Memutakhirkan cache tanpa server Redis OSS ke Valkey dengan CLI
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-serverless-cache \
--serverless-cache-name myCluster \
--engine valkey \
--major-engine-version 8
```
Untuk Windows:
```
aws elasticache modify-serverless-cache ^
--serverless-cache-name myCluster ^
--engine valkey ^
--major-engine-version 8
```
### Meningkatkan Redis OSS ke Valkey dengan Konsol
**Upgrade dari Redis OSS 5 ke Valkey**
1. Pilih cache Redis OSS untuk meng-upgrade.
1. Jendela **Upgrade ke Valkey** akan muncul. Pilih tombol **Upgrade ke Valkey**.
1. Buka **Pengaturan cache**, lalu pilih **Versi mesin**. Versi terbaru dari Valkey direkomendasikan.
1. Jika cache ini tanpa server, maka Anda perlu memperbarui grup parameter. Pergi ke area **grup Parameter** **pengaturan Cache**, pilih grup parameter yang sesuai seperti *default.valkey8*.
1. Pilih **Upgrade**.
Cache ini sekarang akan terdaftar di area Valkey konsol.
**catatan**
Upgrade langsung dari Redis OSS 4 atau lebih rendah ke Valkey dapat mencakup waktu failover yang lebih lama dari 30 hingga 60 detik selama propagasi DNS.
### Cara menurunkan versi dari Valkey ke Redis OSS
Jika karena alasan apa pun Anda ingin mengembalikan cluster yang ditingkatkan, Amazon ElastiCache mendukung pengembalian cache Valkey 7.2 ke Redis OSS 7.1. Anda dapat melakukan rollback menggunakan langkah konsol, API, atau CLI yang sama dengan upgrade mesin dan menentukan Redis OSS 7.1 sebagai versi mesin target. Rollback menggunakan proses yang sama dengan upgrade. Alamat IP endpoint dan semua aspek lain dari aplikasi tidak akan diubah oleh rollback dan Anda tidak akan mengalami downtime.
Selain itu, Anda dapat memulihkan snapshot yang dibuat dari cache Valkey 7.2 Anda sebagai cache Redis OSS 7.1. Saat Anda memulihkan dari snapshot, Anda dapat menentukan Redis OSS 7.1 sebagai versi mesin target. Saat menggunakan opsi ini, cache baru akan dibuat dari snapshot. Memulihkan dari snapshot tidak berpengaruh pada cache Valkey tempat snapshot dibuat.
Persyaratan dan batasan berikut berlaku saat melakukan rollback:
+ ElastiCache hanya mendukung rolling back dari Valkey 7.2 ke Redis OSS 7.1. Ini benar bahkan jika Anda memutakhirkan ke Valkey 7.2 dari versi sebelumnya dari Redis OSS 7.1.
+ Setiap grup pengguna dan pengguna yang terkait dengan grup replikasi atau cache tanpa server yang digulung kembali harus dikonfigurasi dengan tipe mesin. `REDIS`
## Menyelesaikan peningkatan mesin Valkey atau Redis OSS yang diblokir
Seperti yang ditunjukkan pada tabel berikut, operasi peningkatan mesin Valkey atau Redis OSS Anda diblokir jika Anda memiliki operasi peningkatan skala yang tertunda.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/VersionManagement.HowTo.html)
**Untuk menyelesaikan upgrade mesin Valkey atau Redis OSS yang diblokir**
+ Lakukan salah satu tindakan berikut:
+ Jadwalkan operasi upgrade mesin Redis OSS atau Valkey Anda untuk jendela perawatan berikutnya dengan membersihkan kotak centang **Terapkan** segera.
Dengan CLI, gunakan `--no-apply-immediately`. Dengan API, gunakan `ApplyImmediately=false`.
+ Tunggu hingga jendela perawatan berikutnya (atau setelah) untuk melakukan operasi upgrade engine Redis OSS Anda.
+ Tambahkan operasi skala Redis OSS ke modifikasi cluster ini dengan kotak centang **Terapkan Segera** yang dipilih.
Dengan CLI, gunakan `--apply-immediately`. Dengan API, gunakan `ApplyImmediately=true`.
Pendekatan ini secara efektif membatalkan peningkatan mesin selama periode pemeliharaan berikutnya dengan melakukannya segera.
# ElastiCache Extended Support
Dengan ElastiCache Extended Support, Anda dapat terus menjalankan cache Anda pada versi mesin utama melewati akhir tanggal dukungan standar dengan biaya tambahan. Jika Anda tidak meningkatkan setelah akhir tanggal dukungan standar, Anda akan dikenakan biaya.
Extended Support menyediakan pembaruan dan dukungan teknis berikut:
+ Pembaruan keamanan untuk kritis dan tinggi CVEs untuk mesin cache dan cache Anda
+ Perbaikan bug dan tambalan untuk masalah kritis
+ Kemampuan untuk membuka kasus dukungan dan menerima bantuan pemecahan masalah dalam perjanjian tingkat ElastiCache layanan standar
Penawaran berbayar ini memberi Anda lebih banyak waktu untuk meningkatkan ke versi mesin utama yang didukung.
Misalnya, ElastiCache akhir tanggal dukungan standar untuk Redis OSS 4.0.10 adalah 31 Januari 2026. Jika Anda belum siap untuk secara manual meng-upgrade ke Valkey atau Redis OSS 6 atau lebih baru pada tanggal tersebut, secara otomatis ElastiCache akan mendaftarkan cache Anda di Extended Support dan Anda dapat terus menjalankan Redis OSS 4.0.10. Mulai hari pertama setiap bulan setelah dukungan standar berakhir, 1 Februari 2026, ElastiCache secara otomatis menagih Anda untuk Extended Support.
Extended Support tersedia hingga 3 tahun setelah akhir tanggal dukungan standar untuk versi mesin utama. Untuk Elasticache untuk Redis OSS versi 4 dan 5, itu akan menjadi 31 Januari 2029. Setelah tanggal ini, cache apa pun yang masih menjalankan Redis OSS versi 4 dan 5 akan secara otomatis ditingkatkan ke versi terbaru Valkey.
Setelah periode dukungan mesin berakhir, cache yang terus menjalankan versi lama itu akan secara otomatis beralih ke Extended Support. Anda akan diberi tahu sebelum tanggal mulai penetapan harga Extended Support sehingga Anda dapat meningkatkan instans Anda. Anda juga dapat secara eksplisit memilih keluar kapan saja dengan meningkatkan ke versi yang didukung.
Untuk informasi selengkapnya tentang akhir tanggal dukungan standar dan akhir tanggal Extended Support, lihat [ElastiCache versi untuk jadwal akhir hidup Redis OSS](engine-versions.md#deprecated-engine-versions) Valkey, Memcached, atau Redis OSS.
**Topics**
+ [ElastiCache Biaya Extended Support](extended-support-charges.md)
+ [Versi dengan ElastiCache Extended Support](extended-support-versions.md)
+ [ElastiCache dan tanggung jawab pelanggan dengan ElastiCache Extended Support](extended-support-responsibilities.md)
# ElastiCache Biaya Extended Support
Anda akan dikenakan biaya untuk semua mesin yang terdaftar di ElastiCache Extended Support mulai hari setelah akhir dukungan standar. Untuk ElastiCache akhir tanggal dukungan standar, lihat[Versi dengan ElastiCache Extended Support](extended-support-versions.md).
Biaya tambahan untuk ElastiCache Extended Support secara otomatis berhenti ketika Anda melakukan salah satu tindakan berikut:
+ Tingkatkan ke versi mesin yang tercakup dalam dukungan standar.
+ Hapus cache yang menjalankan versi utama melewati ElastiCache akhir tanggal dukungan standar.
Pengisian daya akan dimulai kembali jika versi mesin target Anda memasuki Extended Support di masa mendatang.
Misalnya, katakanlah ElastiCache versi 4 untuk Redis OSS memasuki Extended Support pada 1 Februari 2026, dan Anda memutakhirkan cache Anda di v4 ke v6 pada 1 Januari 2027. Anda hanya akan dikenakan biaya selama 11 bulan Extended Support, pada ElastiCache versi 4 untuk Redis OSS. Jika Anda terus menjalankan ElastiCache versi 6 untuk Redis OSS melewati akhir tanggal dukungan standar 31 Januari 2027, maka cache tersebut akan dikenakan biaya Extended Support lagi mulai 1 Februari 2027.
Anda dapat menghindari biaya untuk ElastiCacheExtended Support dengan ElastiCache mencegah membuat atau memulihkan cache melewati ElastiCache akhir tanggal dukungan standar.
Untuk informasi selengkapnya, lihat [ ElastiCache harga Amazon](https://aws.amazon.com/elasticache/pricing/).
# Versi dengan ElastiCache Extended Support
Redis Open Source Software (OSS) versi 4 dan 5 mencapai komunitas mereka End of Life masing-masing pada tahun 2020 dan 2022. Ini berarti tidak ada pembaruan lebih lanjut, perbaikan bug, atau patch keamanan yang dirilis oleh komunitas. Dukungan standar untuk ElastiCache Redis OSS versi 4 dan 5 ElastiCache akan berakhir pada 31 Januari 2026. Terus menggunakan versi Redis OSS yang tidak didukung dapat membuat data Anda rentan terhadap [Kerentanan Umum dan](https://nvd.nist.gov/vuln-metrics/cvss) Eksposur () yang diketahui. CVEs
Mulai 1 Februari 2026, ElastiCache cache yang masih berjalan pada Redis OSS versi 4 dan 5 akan secara otomatis terdaftar di Extended Support, untuk memberikan ketersediaan dan keamanan berkelanjutan. Meskipun Extended Support menawarkan fleksibilitas, kami merekomendasikan untuk memperlakukan akhir dari dukungan standar sebagai tonggak perencanaan untuk beban kerja produksi Anda. Kami sangat menyarankan Anda untuk meningkatkan cache Redis OSS v4 dan v5 Anda ke ElastiCache Valkey atau Redis OSS v6 atau yang lebih baru, sebelum akhir dukungan standar.
Tabel berikut merangkum ElastiCache akhir Amazon dari tanggal dukungan standar dan tanggal Extended Support.
**Dukungan yang diperpanjang dan jadwal Akhir Kehidupan**
| Versi Mesin Utama | Akhir dari Standard Support | Mulai dari Extended Support Y1 Premium | Mulai dari Extended Support Y2 Premium | Mulai dari Extended Support Y3 Premium | Akhir dari Extended Support dan versi EOL |
| --- | --- | --- | --- | --- | --- |
| Redis OSS v4 | 1/31/2026 | 2/1/2026 | 2/1/2027 | 2/1/2028 | 1/31/2029 |
| Redis OSS v5 | 1/31/2026 | 2/1/2026 | 2/1/2027 | 2/1/2028 | 1/31/2029 |
| Redis OSS v6 | 1/31/2027 | 2/1/2027 | 2/1/2028 | 2/1/2029 | 1/31/2030 |
Extended Support hanya akan ditawarkan untuk versi patch terbaru yang didukung dari setiap versi utama Redis OSS. Ketika Extended Support dimulai pada 1 Februari 2026, jika cluster Redis OSS v4 dan v5 Anda belum ada di versi patch terbaru, mereka akan secara otomatis ditingkatkan ke v4.0.10 untuk Redis OSS v4, dan v5.0.6 untuk Redis OSS v5, sebelum terdaftar di Extended Support. Ini memastikan bahwa Anda menerima pembaruan keamanan dan perbaikan bug melalui Extended Support. Anda tidak perlu mengambil tindakan apa pun untuk meningkatkan ke versi patch terbaru ini sebagai bagian dari transisi Extended Support.
# ElastiCache dan tanggung jawab pelanggan dengan ElastiCache Extended Support
Berikut ini adalah tanggung jawab Amazon ElastiCache, dan tanggung jawab Anda dengan ElastiCache Extended Support.
** ElastiCache Tanggung jawab Amazon**
Setelah ElastiCache akhir tanggal dukungan standar, Amazon ElastiCache akan menyediakan patch, perbaikan bug, dan upgrade untuk engine yang terdaftar di Extended Support. ElastiCache Ini akan terjadi hingga 3 tahun, atau sampai Anda berhenti menggunakan mesin di Extended Support, mana yang terjadi lebih dulu.
**Tanggung jawab Anda**
Anda bertanggung jawab untuk menerapkan patch, perbaikan bug, dan upgrade yang diberikan untuk cache di Extended Support. ElastiCache Amazon ElastiCache berhak mengubah, mengganti, atau menarik tambalan, perbaikan bug, dan peningkatan tersebut kapan saja. Jika tambalan diperlukan untuk mengatasi masalah keamanan atau stabilitas kritis, Amazon ElastiCache berhak memperbarui cache Anda dengan tambalan, atau mengharuskan Anda menginstal tambalan.
Anda juga bertanggung jawab untuk meningkatkan mesin Anda ke versi engine yang lebih baru sebelum ElastiCache akhir tanggal Extended Support. ElastiCache Akhir tanggal Extended Support biasanya 3 tahun setelah ElastiCache akhir tanggal dukungan standar.
Jika Anda tidak memutakhirkan mesin Anda, maka setelah tanggal Extended Support ElastiCache berakhir, Amazon ElastiCache akan mencoba meningkatkan mesin Anda ke versi mesin yang lebih baru yang didukung di bawah dukungan ElastiCache standar. Jika pemutakhiran gagal, Amazon ElastiCache berhak menghapus cache yang menjalankan mesin melewati ElastiCache akhir tanggal dukungan standar. Namun, sebelum melakukannya, Amazon ElastiCache akan menyimpan data Anda dari mesin itu.
# Manajemen Versi untuk ElastiCache
Kelola bagaimana Anda ingin memperbarui ElastiCache cache dan cluster berbasis node yang diperbarui untuk mesin Valkey, Memcached, dan Redis OSS.
## Manajemen versi untuk ElastiCache Cache Tanpa Server
Kelola jika dan kapan cache ElastiCache Tanpa Server ditingkatkan dan lakukan peningkatan versi berdasarkan persyaratan dan jadwal Anda sendiri.
ElastiCache Tanpa server secara otomatis menerapkan versi perangkat lunak minor dan patch terbaru ke cache Anda, tanpa dampak atau waktu henti apa pun ke aplikasi Anda. Anda tidak perlu melakukan tindakan apa pun.
Ketika versi utama baru tersedia, ElastiCache Serverless akan mengirimi Anda pemberitahuan di konsol dan acara di. EventBridge Anda dapat memilih untuk meningkatkan cache Anda ke versi utama terbaru dengan mengubah cache menggunakan Konsol, CLI, atau API, dan memilih versi mesin terbaru. Mirip dengan upgrade minor dan patch, upgrade versi mayor dilakukan tanpa downtime ke aplikasi Anda.
## Manajemen versi untuk cluster berbasis node ElastiCache
Saat bekerja dengan ElastiCache cluster berbasis node, Anda dapat mengontrol kapan perangkat lunak yang menyalakan cluster Anda ditingkatkan ke versi baru yang didukung oleh. ElastiCache Anda dapat mengontrol kapan harus meng-upgrade cache Anda ke versi mayor, minor, dan patch terbaru yang tersedia. Anda dapat memulai peningkatan versi mesin pada grup klaster atau replikasi Anda dengan mengubahnya dan menentukan versi mesin baru.
Anda dapat mengontrol jika dan kapan perangkat lunak yang sesuai dengan protokol yang mendukung klaster Anda ditingkatkan ke versi baru yang didukung oleh. ElastiCache Dengan tingkat kontrol ini, Anda dapat memelihara kompatibilitas dengan versi tertentu, menguji versi baru dengan aplikasi Anda sebelum di-deploy ke sistem produksi, dan melakukan peningkatan versi sesuai syarat dan waktu Anda sendiri.
Karena peningkatan versi mungkin menimbulkan beberapa risiko kompatibilitas, peningkatan tidak dilakukan secara otomatis. Anda sendiri yang harus memulai prosesnya.
**Cluster Valkey dan Redis OSS**
**catatan**
Jika klaster Valkey atau Redis OSS direplikasi di satu atau lebih Wilayah, versi mesin ditingkatkan untuk Wilayah sekunder dan kemudian untuk Wilayah utama.
ElastiCache untuk Redis OSS versi diidentifikasi dengan versi semantik yang terdiri dari komponen mayor dan minor. Misalnya, di Redis OSS 6.2, versi utama adalah 6, dan versi minor 2. Saat mengoperasikan cluster berbasis node, ElastiCache untuk Redis OSS juga mengekspos komponen patch, misalnya Redis OSS 6.2.1, dan versi patch adalah 1.
Versi utama adalah untuk perubahan API yang tidak kompatibel dan versi minor untuk fungsionalitas baru yang ditambahkan dengan cara yang kompatibel ke belakang. Versi patch adalah untuk perbaikan bug yang kompatibel ke belakang dan perubahan non-fungsional.
Dengan Valkey dan Redis OSS, Anda memulai upgrade versi engine ke cluster atau grup replikasi Anda dengan memodifikasinya dan menentukan versi mesin baru. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
**Memcache**
Dengan Memcached, untuk meningkatkan ke versi yang lebih baru Anda harus memodifikasi cluster Anda dan menentukan versi mesin baru yang ingin Anda gunakan. Peningkatan ke versi Memcached yang lebih baru merupakan proses destruktif – Data Anda akan hilang dan Anda akan memulai dengan cache "cold" atau kosong. Untuk informasi selengkapnya, lihat [Memodifikasi cluster ElastiCache](Clusters.Modify.md).
Anda harus menyadari bahwa persyaratan berikut ketika melakukan peningkatan dari versi lebih lama dari Memcached ke Memcached versi 1.4.33 atau yang lebih baru. `CreateCacheCluster` dan `ModifyCacheCluster` akan gagal dalam kondisi berikut:
+ Jika `slab_chunk_max > max_item_size`.
+ Jika `max_item_size modulo slab_chunk_max != 0`.
+ Jika `max_item_size > ((max_cache_memory - memcached_connections_overhead) / 4)`.
Nilai `(max_cache_memory - memcached_connections_overhead)` adalah memori simpul yang dapat digunakan untuk data. Untuk informasi selengkapnya, lihat [Overhead koneksi Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead).
## Mesin dan versi yang didukung
ElastiCache cache tanpa server mendukung ElastiCache versi 7.2 untuk Valkey dan di atasnya, ElastiCache versi 1.6 untuk Memcached dan di atasnya, dan 7.0 untuk Redis OSS dan di atasnya. ElastiCache
ElastiCache Cluster berbasis node mendukung ElastiCache versi 7.2 untuk Valkey dan di atasnya, ElastiCache versi 1.4.5 untuk Memcached dan di atasnya, dan 4.0.10 untuk Redis OSS dan di atasnya. ElastiCache
**Topics**
+ [Versi Valkey yang didukung](#supported-engine-versions.valkey)
+ [Valkey 8.2](#valkey-version-8.2)
+ [Valkey 8.1](#valkey-version-8.1)
+ [Valkey 8.0](#valkey-version-8)
+ [ElastiCache versi 7.2.6 untuk Valkey](#valkey-version-7.2.6)
### Versi Valkey yang didukung
Versi Valkey yang didukung di bawah ini. Perhatikan bahwa Valkey mendukung sebagian besar fitur yang tersedia di ElastiCache versi 7.2 untuk Redis OSS secara default.
+ Anda juga dapat meng-upgrade ElastiCache cluster Anda dengan versi lebih awal dari 5.0.6. Tindakan ini melibatkan proses yang sama tetapi mungkin mengalami waktu failover lebih lama selama penyebaran DNS (30 detik - 1 menit).
+ Dimulai dengan Redis OSS 7, ElastiCache mendukung peralihan antara Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan).
+ Proses upgrade mesin Amazon ElastiCache for Redis OSS dirancang untuk melakukan upaya terbaik untuk mempertahankan data Anda yang ada dan memerlukan replikasi Redis OSS yang berhasil.
+ Saat memutakhirkan mesin, ElastiCache akan menghentikan koneksi klien yang ada. [Untuk meminimalkan waktu henti selama peningkatan engine, kami sarankan Anda menerapkan [praktik terbaik untuk klien Redis OSS](BestPractices.Clients.redis.md) dengan percobaan ulang kesalahan dan backoff eksponensial dan praktik terbaik untuk meminimalkan waktu henti selama pemeliharaan.](BestPractices.MinimizeDowntime.md)
+ Anda tidak dapat memutakhirkan langsung dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan) saat Anda meningkatkan mesin Anda. Prosedur berikut menunjukkan kepada Anda cara meningkatkan dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan).
**Untuk meningkatkan dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan) versi mesin**
1. Buat cadangan cluster atau grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) Anda. Untuk informasi selengkapnya, lihat [Membuat cadangan manual](backups-manual.md).
1. Gunakan cadangan untuk membuat dan menyemai klaster Valkey atau Redis OSS (mode cluster enabled) dengan satu shard (grup node). Tentukan versi mesin baru dan aktifkan mode klaster saat membuat klaster atau grup replikasi. Untuk informasi selengkapnya, lihat [Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal](backups-seeding-redis.md).
1. Hapus cluster atau grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) lama. Untuk informasi selengkapnya, lihat [Menghapus cluster di ElastiCache](Clusters.Delete.md) atau [Menghapus grup replikasi](Replication.DeletingRepGroup.md).
1. Skala cluster atau grup replikasi Valkey atau Redis OSS (mode cluster enabled) baru ke jumlah pecahan (grup node) yang Anda butuhkan. Untuk informasi selengkapnya, lihat [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ Saat meningkatkan versi utama mesin, misalnya dari 5.0.6 ke 6.0, Anda juga harus memilih grup parameter baru yang kompatibel dengan versi mesin yang baru tersebut.
+ Untuk cluster dan cluster Redis OSS tunggal dengan multi-AZ dinonaktifkan, kami menyarankan agar memori yang cukup tersedia untuk Redis OSS seperti yang dijelaskan dalam. [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md) Dalam kasus ini, klaster primer tidak tersedia untuk melayani permintaan selama proses peningkatan.
+ Untuk kluster Redis OSS dengan Multi-AZ diaktifkan, kami juga menyarankan Anda menjadwalkan peningkatan mesin selama periode lalu lintas tulis masuk yang rendah. Saat memutakhirkan ke Redis OSS 5.0.6 atau lebih tinggi, klaster utama terus tersedia untuk permintaan layanan selama proses peningkatan.
Klaster dan grup replikasi dengan beberapa serpihan diproses dan di-patch sebagai berikut:
+ Semua serpihan diproses secara paralel. Hanya satu operasi peningkatan yang akan dilakukan pada satu serpihan kapan saja.
+ Di setiap serpihan, semua replika diproses sebelum primer diproses. Jika terdapat lebih sedikit replika dalam serpihan, primer dalam serpihan itu mungkin diproses sebelum replika di serpihan lainnya selesai diproses.
+ Di semua serpihan, simpul primer diproses secara berurutan. Hanya satu simpul primer yang ditingkatkan dalam satu waktu.
+ Jika enkripsi diaktifkan di klaster atau grup replikasi Anda saat ini, Anda tidak dapat melakukan peningkatan ke versi mesin yang tidak mendukung enkripsi, seperti dari 3.2.6 ke 3.2.10.
**Pertimbangan memcached**
Saat memutakhirkan cluster Memcached berbasis node, pertimbangkan hal berikut.
+ Manajemen versi mesin dirancang agar Anda dapat memiliki kontrol sebanyak mungkin terkait cara melakukan patching. Namun, ElastiCache berhak untuk menambal klaster Anda atas nama Anda jika terjadi kerentanan keamanan kritis dalam sistem atau perangkat lunak cache.
+ Karena mesin Memcached tidak mendukung persistensi, peningkatan versi mesin Memcached merupakan proses disruptif yang menghilangkan semua data cache di klaster.
### ElastiCache versi 8.2 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.2 (dibandingkan dengan ElastiCache Valkey 8.1):
+ Dukungan asli untuk [Pencarian Vektor](vector-search.md), memungkinkan Anda menyimpan, mengindeks, mencari, dan memperbarui miliaran penyematan vektor dimensi tinggi dalam memori dengan latensi serendah mikrodetik.
Untuk informasi lebih lanjut tentang Valkey, lihat [Valkey](https://valkey.io/).
Untuk informasi selengkapnya tentang rilis Valkey 8.2, memperkenalkan pencarian vektor, lihat Pencarian [Valkey](https://github.com/valkey-io/valkey-search).
### ElastiCache versi 8.1 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.1 (dibandingkan dengan ElastiCache Valkey 8.0):
+ Implementasi [tabel hash baru](https://valkey.io/blog/new-hash-table/) yang mengurangi overhead memori untuk menurunkan penggunaan memori sebanyak 20% untuk pola umum key/value .
+ Dukungan asli untuk [filter Bloom](https://valkey.io/topics/bloomfilters/), tipe data baru yang memungkinkan Anda melakukan pencarian menggunakan memori sebanyak 98% lebih sedikit dibandingkan dengan menggunakan tipe data Set.
+ Perintah baru [COMMANDLOG](https://valkey.io/commands/commandlog-get/) yang mencatat eksekusi lambat, permintaan besar, dan balasan besar.
+ Dukungan pembaruan bersyarat baru untuk perintah SET menggunakan argumen IFEQ.
+ Peningkatan kinerja, termasuk latensi hingga 45% lebih rendah untuk perintah ZRANK, kinerja hingga 12x lebih cepat untuk PFMERGE dan PFCOUNT, dan throughput hingga 514% lebih tinggi untuk BITCOUNT.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang rilis Valkey 8.1, lihat Catatan Rilis [Valkey 8.1](https://github.com/valkey-io/valkey/blob/8.1/00-RELEASENOTES)
### ElastiCache versi 8.0 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.0 (dibandingkan dengan ElastiCache Valkey 7.2.6):
+ Peningkatan efisiensi memori, memungkinkan pengguna untuk menyimpan hingga 20% lebih banyak data per node tanpa perubahan aplikasi apa pun.
+ Infrastruktur metrik per slot yang baru diperkenalkan untuk cluster berbasis node, memberikan visibilitas terperinci ke dalam kinerja dan penggunaan sumber daya slot individu.
+ ElastiCache Tanpa server untuk Valkey 8.0 dapat menggandakan permintaan per detik (RPS) yang didukung setiap 2-3 menit, mencapai 5M RPS per cache dari nol dalam waktu kurang dari 13 menit, dengan latensi baca p50 sub-milidetik yang konsisten.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang rilis Valkey 8, lihat Catatan Rilis [Valkey 8](https://github.com/valkey-io/valkey/blob/8.0/00-RELEASENOTES)
### ElastiCache versi 7.2.6 untuk Valkey
Pada 10 Oktober 2024, ElastiCache versi 7.2.6 untuk Valkey dirilis. Berikut adalah beberapa fitur baru yang diperkenalkan di 7.2 (dibandingkan dengan ElastiCache versi 7.1 untuk Redis OSS):
+ Pengoptimalan kinerja dan memori untuk berbagai tipe data: optimasi memori untuk daftar dan set tombol jenis, optimasi kecepatan untuk perintah set yang diurutkan, pengoptimalan kinerja untuk perintah dengan beberapa tombol dalam mode cluster, peningkatan pub/sub kinerja, optimasi kinerja untuk SCAN, SSCAN, HSCAN, perintah ZSCAN dan banyak optimasi kecil lainnya.
+ Opsi WITHSCORE baru untuk perintah ZRANK dan ZREVRANK
+ CLIENT NO-TOUCH bagi klien untuk menjalankan perintah tanpa mempengaruhi LRU/LFU kunci.
+ Perintah baru CLUSTER MYSHARDID yang mengembalikan ID Shard dari node untuk secara logis mengelompokkan node dalam modus cluster berdasarkan replikasi.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang ElastiCache versi 7.2 untuk rilis Valkey, lihat [Redis OSS 7.2.4 Catatan Rilis (ElastiCache versi 7.2](https://github.com/valkey-io/valkey/blob/d2c8a4b91e8c0e6aefd1f5bc0bf582cddbe046b7/00-RELEASENOTES) untuk Valkey mencakup semua perubahan dari versi 7.1 untuk Redis OSS hingga ElastiCache versi 7.2.4 untuk Redis OSS). ElastiCache [Catatan rilis Valkey 7.2](https://github.com/valkey-io/valkey/blob/7.2/00-RELEASENOTES) di Valkey on. GitHub
## ElastiCache versi 8.2 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.2 (dibandingkan dengan ElastiCache Valkey 8.1):
+ Dukungan asli untuk [Pencarian Vektor](vector-search.md), memungkinkan Anda menyimpan, mengindeks, mencari, dan memperbarui miliaran penyematan vektor dimensi tinggi dalam memori dengan latensi serendah mikrodetik.
Untuk informasi lebih lanjut tentang Valkey, lihat [Valkey](https://valkey.io/).
Untuk informasi selengkapnya tentang rilis Valkey 8.2, memperkenalkan pencarian vektor, lihat Pencarian [Valkey](https://github.com/valkey-io/valkey-search).
## ElastiCache versi 8.1 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.1 (dibandingkan dengan ElastiCache Valkey 8.0):
+ Implementasi [tabel hash baru](https://valkey.io/blog/new-hash-table/) yang mengurangi overhead memori untuk menurunkan penggunaan memori sebanyak 20% untuk pola umum key/value .
+ Dukungan asli untuk [filter Bloom](https://valkey.io/topics/bloomfilters/), tipe data baru yang memungkinkan Anda melakukan pencarian menggunakan memori sebanyak 98% lebih sedikit dibandingkan dengan menggunakan tipe data Set.
+ Perintah baru [COMMANDLOG](https://valkey.io/commands/commandlog-get/) yang mencatat eksekusi lambat, permintaan besar, dan balasan besar.
+ Dukungan pembaruan bersyarat baru untuk perintah SET menggunakan argumen IFEQ.
+ Peningkatan kinerja, termasuk latensi hingga 45% lebih rendah untuk perintah ZRANK, kinerja hingga 12x lebih cepat untuk PFMERGE dan PFCOUNT, dan throughput hingga 514% lebih tinggi untuk BITCOUNT.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang rilis Valkey 8.1, lihat Catatan Rilis [Valkey 8.1](https://github.com/valkey-io/valkey/blob/8.1/00-RELEASENOTES)
## ElastiCache versi 8.0 untuk Valkey
Berikut adalah beberapa fitur baru yang diperkenalkan di Valkey 8.0 (dibandingkan dengan ElastiCache Valkey 7.2.6):
+ Peningkatan efisiensi memori, memungkinkan pengguna untuk menyimpan hingga 20% lebih banyak data per node tanpa perubahan aplikasi apa pun.
+ Infrastruktur metrik per slot yang baru diperkenalkan untuk cluster berbasis node, memberikan visibilitas terperinci ke dalam kinerja dan penggunaan sumber daya slot individu.
+ ElastiCache Tanpa server untuk Valkey 8.0 dapat menggandakan permintaan per detik (RPS) yang didukung setiap 2-3 menit, mencapai 5M RPS per cache dari nol dalam waktu kurang dari 13 menit, dengan latensi baca p50 sub-milidetik yang konsisten.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang rilis Valkey 8, lihat Catatan Rilis [Valkey 8](https://github.com/valkey-io/valkey/blob/8.0/00-RELEASENOTES)
## ElastiCache versi 7.2.6 untuk Valkey
Pada 10 Oktober 2024, ElastiCache versi 7.2.6 untuk Valkey dirilis. Berikut adalah beberapa fitur baru yang diperkenalkan di 7.2 (dibandingkan dengan ElastiCache versi 7.1 untuk Redis OSS):
+ Pengoptimalan kinerja dan memori untuk berbagai tipe data: optimasi memori untuk daftar dan set tombol jenis, optimasi kecepatan untuk perintah set yang diurutkan, pengoptimalan kinerja untuk perintah dengan beberapa tombol dalam mode cluster, peningkatan pub/sub kinerja, optimasi kinerja untuk SCAN, SSCAN, HSCAN, perintah ZSCAN dan banyak optimasi kecil lainnya.
+ Opsi WITHSCORE baru untuk perintah ZRANK dan ZREVRANK
+ CLIENT NO-TOUCH bagi klien untuk menjalankan perintah tanpa mempengaruhi LRU/LFU kunci.
+ Perintah baru CLUSTER MYSHARDID yang mengembalikan ID Shard dari node untuk secara logis mengelompokkan node dalam modus cluster berdasarkan replikasi.
[Untuk informasi lebih lanjut tentang Valkey, lihat Valkey](https://valkey.io/)
Untuk informasi lebih lanjut tentang ElastiCache versi 7.2 untuk rilis Valkey, lihat [Redis OSS 7.2.4 Catatan Rilis (ElastiCache versi 7.2](https://github.com/valkey-io/valkey/blob/d2c8a4b91e8c0e6aefd1f5bc0bf582cddbe046b7/00-RELEASENOTES) untuk Valkey mencakup semua perubahan dari versi 7.1 untuk Redis OSS hingga ElastiCache versi 7.2.4 untuk Redis OSS). ElastiCache [Catatan rilis Valkey 7.2](https://github.com/valkey-io/valkey/blob/7.2/00-RELEASENOTES) di Valkey on. GitHub
## Versi mesin Redis OSS yang didukung
ElastiCache Cache tanpa server dan cluster berbasis node mendukung semua Redis OSS versi 7.1 dan sebelumnya.
+ [ElastiCache versi 7.1 untuk Redis OSS (ditingkatkan)](#redis-version-7.1)
**Topics**
+ [ElastiCache versi 7.1 untuk Redis OSS (ditingkatkan)](#redis-version-7.1)
+ [ElastiCache versi 7.0 untuk Redis OSS (ditingkatkan)](#redis-version-7.0)
+ [ElastiCache versi 6.2 untuk Redis OSS (ditingkatkan)](#redis-version-6.2)
+ [ElastiCache versi 6.0 untuk Redis OSS (ditingkatkan)](#redis-version-6.0)
+ [ElastiCache versi 5.0.6 untuk Redis OSS (ditingkatkan)](#redis-version-5-0.6)
+ [ElastiCache versi 5.0.5 untuk Redis OSS (usang, gunakan versi 5.0.6)](#redis-version-5-0.5)
+ [ElastiCache versi 5.0.4 untuk Redis OSS (usang, gunakan versi 5.0.6)](#redis-version-5-0.4)
+ [ElastiCache versi 5.0.3 untuk Redis OSS (usang, gunakan versi 5.0.6)](#redis-version-5-0.3)
+ [ElastiCache versi 5.0.0 untuk Redis OSS (usang, gunakan versi 5.0.6)](#redis-version-5-0)
+ [ElastiCache versi 4.0.10 untuk Redis OSS (ditingkatkan)](#redis-version-4-0-10)
+ [Versi Lewat Masa Pakai (EOL) (3.x)](#redis-version-3-2-10-scheduled-eol)
+ [Versi Lewat Masa Pakai (EOL) (2.x)](#redis-version-2-x-eol)
### ElastiCache versi 7.1 untuk Redis OSS (ditingkatkan)
Rilis ini berisi peningkatan kinerja yang memungkinkan beban kerja mendorong throughput yang lebih tinggi dan latensi operasi yang lebih rendah. ElastiCache [versi 7.1 untuk Redis OSS memperkenalkan dua perangkat tambahan utama:](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/)
Kami memperluas fungsionalitas I/O thread yang disempurnakan untuk juga menangani logika lapisan presentasi. Dengan layer presentasi, yang kami maksud adalah thread Enhanced I/O yang sekarang tidak hanya membaca input klien, tetapi juga mengurai input ke dalam format perintah biner Redis OSS. Ini kemudian diteruskan ke thread utama untuk eksekusi yang memberikan peningkatan performa. Peningkatan pola akses memori Redis OSS. Langkah-langkah eksekusi dari banyak operasi struktur data disisipkan, untuk memastikan akses memori paralel dan mengurangi latensi akses memori. Saat berjalan ElastiCache di Graviton3 berbasis `R7g.4xlarge` atau lebih besar, pelanggan dapat mencapai lebih dari 1 juta permintaan per detik per node. Dengan peningkatan kinerja ElastiCache untuk Redis OSS v7.1, pelanggan dapat mencapai throughput hingga 100% lebih banyak dan latensi P99 50% lebih rendah dibandingkan dengan Redis OSS v7.0. ElastiCache Peningkatan ini diaktifkan pada ukuran simpul dengan setidaknya 8 inti fisik (`2xlarge` pada Graviton, dan `4xlarge` pada x86), terlepas dari jenis CPU dan tidak memerlukan perubahan klien.
**catatan**
ElastiCache v7.1 kompatibel dengan Redis OSS v7.0.
### ElastiCache versi 7.0 untuk Redis OSS (ditingkatkan)
ElastiCache untuk Redis OSS 7.0 menambahkan sejumlah perbaikan dan dukungan untuk fungsionalitas baru:
+ [Fungsi](https://valkey.io/topics/functions-intro/): ElastiCache untuk Redis OSS 7 menambahkan dukungan untuk Fungsi Redis OSS, dan memberikan pengalaman terkelola yang memungkinkan pengembang untuk mengeksekusi [skrip LUA](https://valkey.io/topics/eval-intro/) dengan logika aplikasi yang disimpan di ElastiCache cluster, tanpa mengharuskan klien untuk mengirim ulang skrip ke server dengan setiap koneksi.
+ [Perbaikan ACL](https://valkey.io/topics/acl/): Valkey dan Redis OSS 7 menambahkan dukungan untuk versi berikutnya dari Daftar Kontrol Akses (). ACLs Klien sekarang dapat menentukan beberapa set izin pada kunci atau ruang kunci tertentu di Valkey dan Redis OSS.
+ [Sharded Pub/Sub](https://valkey.io/topics/pubsub/): ElastiCache untuk Valkey dan Redis OSS 7 menambahkan dukungan untuk menjalankan Pub/Sub functionality in a sharded way when running ElastiCache in Cluster Mode Enabled (CME). Pub/Sub kemampuan memungkinkan penerbit mengeluarkan pesan ke sejumlah pelanggan di saluran. Saluran terikat pada pecahan di ElastiCache cluster, menghilangkan kebutuhan untuk menyebarkan informasi saluran di seluruh pecahan sehingga meningkatkan skalabilitas.
+ I/O Multiplexing yang disempurnakan: ElastiCache untuk Valkey dan Redis OSS 7 memperkenalkan multiplexing I/O yang disempurnakan, yang memberikan peningkatan throughput dan mengurangi latensi untuk beban kerja throughput tinggi yang memiliki banyak koneksi klien bersamaan ke sebuah cluster. ElastiCache Misalnya, saat menggunakan cluster node r6g.xlarge dan menjalankan 5200 klien bersamaan, Anda dapat mencapai hingga 72% peningkatan throughput (operasi baca dan tulis per detik) dan latensi P99 penurunan hingga 71%, dibandingkan dengan versi 6 untuk Redis OSS. ElastiCache
Untuk informasi lebih lanjut tentang Valkey, lihat [Valkey](https://valkey.io/). Untuk informasi lebih lanjut tentang rilis Redis OSS 7.0, lihat Catatan Rilis [Redis OSS 7.0 di Redis OSS](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES) pada. GitHub
### ElastiCache versi 6.2 untuk Redis OSS (ditingkatkan)
ElastiCache untuk Redis OSS 6.2 mencakup peningkatan kinerja untuk cluster berkemampuan TLS menggunakan tipe node x86 dengan 8 v CPUs atau lebih atau tipe node Graviton2 dengan 4 v atau lebih. CPUs Peningkatan ini meningkatkan throughput dan mengurangi waktu pembentukan koneksi klien dengan membongkar enkripsi ke v. CPUs Dengan Redis OSS 6.2, Anda juga dapat mengelola akses ke saluran Pub/Sub dengan aturan Access Control List (ACL).
Dengan versi ini, kami juga memperkenalkan dukungan untuk tiering data pada node cluster yang berisi SSD yang terpasang NVMe secara lokal. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
Mesin Redis OSS versi 6.2.6 juga memperkenalkan dukungan untuk format asli JavaScript Object Notation (JSON), cara sederhana dan tanpa skema untuk menyandikan kumpulan data kompleks di dalam cluster Redis OSS. Dengan dukungan JSON, Anda dapat memanfaatkan kinerja dan Redis OSS APIs untuk aplikasi yang beroperasi melalui JSON. Untuk informasi selengkapnya, lihat [Memulai dengan JSON](json-gs.md). Juga termasuk metrik terkait JSON, `JsonBasedCmds` dan`JsonBasedCmdsLatency`, yang dimasukkan ke dalam CloudWatch untuk memantau penggunaan tipe data ini. Untuk informasi selengkapnya, lihat [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md).
Anda menentukan versi mesin dengan menggunakan 6.2. ElastiCache akan secara otomatis memanggil versi patch pilihan Redis OSS 6.2 yang tersedia. Misalnya, saat Anda membuat/memodifikasi cluster, Anda mengatur `--engine-version` parameter ke 6.2. Cluster akan diluncurkan dengan versi patch pilihan Redis OSS 6.2 yang tersedia saat ini. creation/modification Menentukan engine versi 6.x di API akan menghasilkan versi minor terbaru dari Redis OSS 6.
Untuk kluster 6.0 yang ada, Anda dapat ikut serta dalam upgrade versi minor otomatis berikutnya dengan menyetel `AutoMinorVersionUpgrade` parameter ke `yes` dalam`CreateCacheCluster`,, `ModifyCacheCluster` atau. `CreateReplicationGroup` `ModifyReplicationGroup` APIs ElastiCache akan memutakhirkan versi minor dari cluster 6.0 Anda yang ada ke 6.2 menggunakan pembaruan layanan mandiri. Untuk informasi selengkapnya, lihat [Pembaruan layanan mandiri di Amazon ElastiCache](Self-Service-Updates.md).
Saat memanggil DescribeCacheEngineVersions API, nilai `EngineVersion` parameter akan disetel ke 6.2 dan versi mesin aktual dengan versi tambalan akan dikembalikan di `CacheEngineVersionDescription` bidang.
Untuk informasi lebih lanjut tentang rilis Redis OSS 6.2, lihat Catatan Rilis [Redis OSS 6.2 di Redis OSS](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES) pada. GitHub
### ElastiCache versi 6.0 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache memperkenalkan versi berikutnya ElastiCache untuk mesin Redis OSS, yang mencakup [Autentikasi Pengguna dengan Kontrol Akses Berbasis Peran](Clusters.RBAC.md), caching sisi klien, dan peningkatan operasional yang signifikan.
Dimulai dengan Redis OSS 6.0, ElastiCache akan menawarkan versi tunggal untuk setiap rilis minor Redis OSS, daripada menawarkan beberapa versi patch. ElastiCache akan secara otomatis mengelola versi patch dari cluster yang sedang berjalan, memastikan peningkatan kinerja dan keamanan yang ditingkatkan.
Anda juga dapat ikut serta dalam peningkatan versi auto minor berikutnya dengan menyetel `AutoMinorVersionUpgrade` parameter ke `yes` dan ElastiCache akan mengelola peningkatan versi minor, melalui pembaruan layanan mandiri. Untuk informasi selengkapnya, lihat [Pembaruan layanan di ElastiCache](Self-Service-Updates.md).
Anda menentukan versi mesin dengan menggunakan`6.0`. ElastiCache akan secara otomatis memanggil versi patch pilihan Redis OSS 6.0 yang tersedia. Misalnya, ketika Anda create/modify sebuah cluster, Anda mengatur `--engine-version` parameter ke 6.0. Cluster akan diluncurkan dengan versi patch pilihan Redis OSS 6.0 yang tersedia saat ini pada waktu pembuatan/modifikasi. Permintaan apa pun dengan nilai versi patch tertentu akan ditolak, pengecualian akan dikeluarkan dan proses akan gagal.
Saat memanggil DescribeCacheEngineVersions API, nilai `EngineVersion` parameter akan disetel ke 6.0 dan versi mesin aktual dengan versi tambalan akan dikembalikan di `CacheEngineVersionDescription` bidang.
Untuk informasi lebih lanjut tentang rilis Redis OSS 6.0, lihat Catatan Rilis [Redis OSS 6.0 di Redis OSS](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES) pada. GitHub
### ElastiCache versi 5.0.6 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache memperkenalkan versi berikutnya ElastiCache untuk mesin Redis OSS, yang mencakup perbaikan bug dan pembaruan kumulatif berikut:
+ Jaminan kestabilan mesin dalam kondisi khusus.
+ Peningkatan penanganan kesalahan Hyperloglog.
+ Peningkatan perintah handshake untuk replikasi yang andal.
+ Pelacakan pengiriman pesan yang konsisten melalui perintah `XCLAIM`.
+ Peningkatan manajemen bidang `LFU `dalam objek.
+ Manajemen transaksi yang ditingkatkan saat menggunakan `ZPOP`.
+ Kemampuan untuk mengganti nama perintah: Parameter yang disebut `rename-commands` yang memungkinkan Anda mengganti nama perintah Redis OSS yang berpotensi berbahaya atau mahal yang dapat menyebabkan kehilangan data yang tidak disengaja, seperti atau. `FLUSHALL` `FLUSHDB` Ini mirip dengan konfigurasi rename-command di open source Redis OSS. Namun, ElastiCache telah meningkatkan pengalaman dengan menyediakan alur kerja yang dikelola sepenuhnya. Perubahan nama perintah diterapkan segera, dan secara otomatis disebarkan ke semua simpul dalam klaster yang berisi daftar perintah. Tidak ada intervensi yang diperlukan di sisi Anda, seperti boot ulang simpul.
Contoh berikut menunjukkan cara mengubah grup parameter yang sudah ada. Yang termasuk di sini adalah parameter `rename-commands`, yang merupakan daftar dipisahkan spasi berisi perintah yang ingin diubah namanya:
```
aws elasticache modify-cache-parameter-group --cache-parameter-group-name custom_param_group
--parameter-name-values "ParameterName=rename-commands, ParameterValue='flushall restrictedflushall'" --region region
```
Pada contoh ini, parameter *rename-command* digunakan untuk mengubah nama perintah `flushall` menjadi `restrictedflushall`.
Untuk mengubah nama beberapa perintah, gunakan cara berikut:
```
aws elasticache modify-cache-parameter-group --cache-parameter-group-name custom_param_group
--parameter-name-values "ParameterName=rename-commands, ParameterValue='flushall restrictedflushall flushdb restrictedflushdb''" --region region
```
Untuk membalikkan perubahan apa pun, jalankan kembali perintah dan keluarkan semua nilai perubahan nama dari daftar `ParameterValue` yang ingin dipertahankan, seperti ditunjukkan berikut:
```
aws elasticache modify-cache-parameter-group --cache-parameter-group-name custom_param_group
--parameter-name-values "ParameterName=rename-commands, ParameterValue='flushall restrictedflushall'" --region region
```
Dalam hal ini, perintah `flushall` diubah namanya menjadi `restrictedflushall` dan perintah perubahan nama lainnya kembali ke nama perintah aslinya.
**catatan**
Saat mengubah nama perintah, Anda dibatasi pada batasan berikut:
Semua perintah ubah nama harus alfanumerik.
Panjang maksimum nama perintah baru adalah 20 karakter alfanumerik.
Ketika mengubah nama perintah, pastikan bahwa Anda memperbarui grup parameter yang terkait dengan klaster Anda.
Untuk mencegah penggunaan sebuah perintah sepenuhnya, gunakan kata kunci `blocked`, seperti yang ditunjukkan berikut ini:
```
aws elasticache modify-cache-parameter-group --cache-parameter-group-name custom_param_group
--parameter-name-values "ParameterName=rename-commands, ParameterValue='flushall blocked'" --region region
```
Untuk informasi selengkapnya tentang perubahan parameter dan daftar perintah apa yang memenuhi syarat untuk perubahan nama, lihat [Redis OSS 5.0.3 perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.5-0-3).
+ Redis OSS Streams: Ini memodelkan struktur data log yang memungkinkan produsen untuk menambahkan item baru secara real time. Fitur ini juga memungkinkan pelanggan menerima pesan baik dalam mode memblokir ataupun tidak memblokir. Aliran juga memungkinkan grup pelanggan, yang merepresentasikan sekelompok klien untuk secara kooperatif menggunakan bagian yang berbeda dari aliran pesan yang sama, mirip dengan [Apache Kafka](https://kafka.apache.org/documentation/). Untuk informasi selengkapnya, lihat [Streaming](https://valkey.io/topics/streams-intro).
+ Dukungan untuk keluarga perintah aliran, seperti `XADD`, `XRANGE` dan `XREAD`. Untuk informasi selengkapnya, lihat [Perintah Streams](https://valkey.io/commands/#stream).
+ Sejumlah parameter baru dan perubahan nama. Untuk informasi selengkapnya, lihat [Redis OSS 5.0.0 perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.5.0).
+ Metrik Redis OSS baru,. `StreamBasedCmds`
+ Waktu snapshot sedikit lebih cepat untuk node Redis OSS.
**penting**
ElastiCache telah melakukan back-porting dua perbaikan bug penting dari [Redis OSS](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES) open source versi 5.0.1. Perbaikan tersebut tercantum sebagai berikut:
PULIHKAN balasan yang tidak sesuai ketika kunci tertentu telah kedaluwarsa.
Perintah `XCLAIM` dapat berpotensi menghasilkan entri yang salah atau mengganggu sinkronisasi protokol.
Kedua perbaikan bug ini disertakan dalam ElastiCache untuk dukungan Redis OSS untuk mesin Redis OSS versi 5.0.0 dan dikonsumsi dalam pembaruan versi masa depan.
Untuk informasi lebih lanjut, lihat [Catatan Rilis Redis OSS 5.0.6](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES) di Redis OSS di. GitHub
### ElastiCache versi 5.0.5 untuk Redis OSS (usang, gunakan versi 5.0.6)
Amazon ElastiCache memperkenalkan versi berikutnya ElastiCache untuk mesin Redis OSS; Ini termasuk perubahan konfigurasi online untuk ElastiCache cluster auto-failover selama semua operasi yang direncanakan. Anda sekarang dapat menskalakan klaster Anda, meningkatkan versi mesin Redis OSS dan menerapkan patch dan pembaruan pemeliharaan saat cluster tetap online dan terus melayani permintaan yang masuk. Pembaruan ini juga menyertakan perbaikan bug.
Untuk informasi lebih lanjut, lihat [Catatan Rilis Redis OSS 5.0.5](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES) di Redis OSS di. GitHub
### ElastiCache versi 5.0.4 untuk Redis OSS (usang, gunakan versi 5.0.6)
Amazon ElastiCache memperkenalkan versi berikutnya dari mesin Redis OSS yang didukung oleh. ElastiCache Versi ini mencakup perbaikan berikut:
+ Jaminan kestabilan mesin dalam kondisi khusus.
+ Peningkatan penanganan kesalahan Hyperloglog.
+ Peningkatan perintah handshake untuk replikasi yang andal.
+ Pelacakan pengiriman pesan yang konsisten melalui perintah `XCLAIM`.
+ Peningkatan manajemen bidang `LFU `dalam objek.
+ Manajemen transaksi yang ditingkatkan saat menggunakan `ZPOP`.
Untuk informasi lebih lanjut, lihat [Catatan Rilis Redis OSS 5.0.4](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES) di Redis OSS di. GitHub
### ElastiCache versi 5.0.3 untuk Redis OSS (usang, gunakan versi 5.0.6)
Amazon ElastiCache memperkenalkan versi berikutnya ElastiCache untuk mesin Redis OSS, yang mencakup perbaikan bug.
### ElastiCache versi 5.0.0 untuk Redis OSS (usang, gunakan versi 5.0.6)
Amazon ElastiCache memperkenalkan versi utama berikutnya ElastiCache untuk mesin Redis OSS. ElastiCache versi 5.0.0 untuk Redis OSS membawa dukungan untuk perbaikan berikut:
+ Redis OSS Streams: Ini memodelkan struktur data log yang memungkinkan produsen untuk menambahkan item baru secara real time. Fitur ini juga memungkinkan pelanggan menerima pesan baik dalam mode memblokir ataupun tidak memblokir. Aliran juga memungkinkan grup pelanggan, yang merepresentasikan sekelompok klien untuk secara kooperatif menggunakan bagian yang berbeda dari aliran pesan yang sama, mirip dengan [Apache Kafka](https://kafka.apache.org/documentation/). Untuk informasi selengkapnya, lihat [Streaming](https://valkey.io/topics/streams-intro).
+ Dukungan untuk keluarga perintah aliran, seperti `XADD`, `XRANGE` dan `XREAD`. Untuk informasi selengkapnya, lihat [Perintah Streams](https://valkey.io/commands/#stream).
+ Sejumlah parameter baru dan perubahan nama. Untuk informasi selengkapnya, lihat [Redis OSS 5.0.0 perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.5.0).
+ Metrik Redis OSS baru,. `StreamBasedCmds`
+ Waktu snapshot sedikit lebih cepat untuk node Redis OSS.
### ElastiCache versi 4.0.10 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache memperkenalkan versi utama berikutnya ElastiCache untuk mesin Redis OSS. ElastiCache versi 4.0.10 untuk Redis OSS membawa dukungan untuk perbaikan berikut:
+ Baik pengubahan ukuran cluster online dan enkripsi dalam satu ElastiCache versi. Untuk informasi selengkapnya, lihat berikut ini:
+ [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ [Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online)
+ [Keamanan data di Amazon ElastiCache](encryption.md)
+ Sejumlah parameter baru. Untuk informasi selengkapnya, lihat [Redis OSS 4.0.10 perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.4-0-10).
+ Dukungan untuk keluarga perintah memori, seperti `MEMORY`. Untuk informasi selengkapnya, lihat [Perintah](https://valkey.io/commands) (cari di MEMO).
+ Dukungan untuk defragmentasi memori saat online sehingga memungkinkan pemanfaatan memori yang lebih efisien dan lebih banyak memori yang tersedia untuk data Anda.
+ Support untuk pembilasan dan penghapusan asinkron. ElastiCache untuk Redis OSS mendukung perintah seperti`UNLINK`, `FLUSHDB` dan `FLUSHALL` berjalan di utas yang berbeda dari utas utama. Melakukan hal ini membantu meningkatkan performa dan waktu respons untuk aplikasi Anda dengan membebaskan memori secara asinkron.
+ Metrik Redis OSS baru,. `ActiveDefragHits` Untuk informasi selengkapnya, lihat [Metrik untuk Redis](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CacheMetrics.Redis.html) OSS.
Redis OSS (mode cluster dinonaktifkan) pengguna yang menjalankan ElastiCache versi 3.2.10 untuk Redis OSS dapat menggunakan konsol untuk meng-upgrade cluster mereka melalui upgrade online.
**Membandingkan pengubahan ukuran ElastiCache cluster dan dukungan enkripsi**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/engine-versions.html)
### Versi Lewat Masa Pakai (EOL) (3.x)
#### ElastiCache versi 3.2.10 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache memperkenalkan versi utama berikutnya ElastiCache untuk mesin Redis OSS. ElastiCache versi 3.2.10 untuk Redis OSS (enchanced) memperkenalkan pengubahan ukuran cluster online untuk menambah atau menghapus pecahan dari cluster sambil terus melayani permintaan yang masuk. I/O ElastiCache untuk Redis OSS 3.2.10 pengguna memiliki semua fungsi versi Redis OSS sebelumnya kecuali kemampuan untuk mengenkripsi data mereka. Kemampuan ini saat ini hanya tersedia pada versi 3.2.6.
**Membandingkan ElastiCache versi 3.2.6 dan 3.2.10 untuk Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/engine-versions.html)
Untuk informasi selengkapnya, lihat berikut ini:
+ [Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online)
+ [Perubahan ukuran klaster online](best-practices-online-resharding.md)
#### ElastiCache versi 3.2.6 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache memperkenalkan versi utama berikutnya ElastiCache untuk mesin Redis OSS. ElastiCache versi 3.2.6 untuk pengguna Redis OSS memiliki akses ke semua fungsi versi Redis OSS sebelumnya, ditambah opsi untuk mengenkripsi data mereka. Untuk informasi selengkapnya, lihat berikut ini:
+ [ElastiCache enkripsi dalam transit (TLS)](in-transit-encryption.md)
+ [Enkripsi At-Rest di ElastiCache](at-rest-encryption.md)
+ [Validasi kepatuhan untuk Amazon ElastiCache](elasticache-compliance.md)
#### ElastiCache versi 3.2.4 untuk Redis OSS (ditingkatkan)
Amazon ElastiCache versi 3.2.4 memperkenalkan versi utama berikutnya ElastiCache untuk mesin Redis OSS. ElastiCache *3.2.4 pengguna memiliki semua fungsi versi Redis OSS sebelumnya yang tersedia bagi mereka, ditambah opsi untuk berjalan dalam mode cluster atau *mode non-cluster*.* Tabel berikut merangkum hal ini.
**Membandingkan Redis OSS 3.2.4 mode non-cluster dan mode cluster**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/engine-versions.html)
**Catatan:**
+ **Pembuatan partisi** – kemampuan untuk membagi data Anda pada 2 hingga 500 grup simpul (serpihan) dengan dukungan replikasi untuk setiap grup simpul.
+ **Pengindeksan geospasial** - Redis OSS 3.2.4 memperkenalkan dukungan untuk pengindeksan geospasial melalui enam perintah GEO. Untuk informasi lebih lanjut, lihat Redis OSS GEO\$1 dokumentasi [perintah Perintah: GEO](http://valkey.io/commands#geo) di halaman Perintah Valkey (difilter untuk GEO).
Untuk informasi tentang fitur tambahan Redis OSS 3, lihat Catatan rilis [Redis OSS 3.2 dan catatan rilis](https://github.com/redis/redis/blob/3.2/00-RELEASENOTES) [Redis](https://github.com/redis/redis/blob/3.0/00-RELEASENOTES) OSS 3.0.
Saat ini ElastiCache dikelola Valkey atau Redis OSS (mode cluster diaktifkan) tidak mendukung fitur Redis OSS 3.2 berikut:
+ Migrasi replika
+ Penyeimbangan kembali klaster
+ Lua debugger
ElastiCache menonaktifkan perintah manajemen Redis OSS 3.2 berikut:
+ `cluster meet`
+ `cluster replicate`
+ `cluster flushslots`
+ `cluster addslots`
+ `cluster delslots`
+ `cluster setslot`
+ `cluster saveconfig`
+ `cluster forget`
+ `cluster failover`
+ `cluster bumpepoch`
+ `cluster set-config-epoch`
+ `cluster reset`
Untuk informasi tentang parameter Redis OSS 3.2.4, lihat. [Redis OSS 3.2.4 perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.3-2-4)
### Versi Lewat Masa Pakai (EOL) (2.x)
#### ElastiCache versi 2.8.24 untuk Redis OSS (ditingkatkan)
Perbaikan Redis OSS ditambahkan sejak versi 2.8.23 termasuk perbaikan bug dan logging alamat akses memori yang buruk. Untuk informasi lebih lanjut, lihat catatan [rilis Redis OSS 2.8](https://github.com/redis/redis/blob/2.8/00-RELEASENOTES).
#### ElastiCache versi 2.8.23 untuk Redis OSS (ditingkatkan)
Perbaikan Redis OSS ditambahkan sejak versi 2.8.22 termasuk perbaikan bug. Untuk informasi lebih lanjut, lihat catatan [rilis Redis OSS 2.8](https://github.com/redis/redis/blob/2.8/00-RELEASENOTES). Rilis ini mencakup dukungan untuk parameter baru `close-on-slave-write` yang, jika diaktifkan, memutuskan klien yang mencoba menulis ke replika hanya-baca.
Untuk informasi selengkapnya tentang parameter Redis OSS 2.8.23, lihat [Redis OSS 2.8.23 (ditingkatkan) menambahkan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.2-8-23) di Panduan Pengguna. ElastiCache
#### ElastiCache versi 2.8.22 untuk Redis OSS (ditingkatkan)
Perbaikan Redis OSS ditambahkan sejak versi 2.8.21 meliputi yang berikut:
+ Dukungan untuk pencadangan dan sinkronisasi forkless, yang memungkinkan Anda mengalokasikan lebih sedikit memori untuk overhead cadangan dan lebih banyak untuk aplikasi Anda. Untuk informasi selengkapnya, lihat [Cara penerapan sinkronisasi dan pencadangan](Replication.Redis.Versions.md). Proses forkless dapat memengaruhi latensi dan throughput. Saat ada throughput operasi tulis yang tinggi, dan replika melakukan sinkronisasi ulang, operasi tulis dapat menjadi tidak terjangkau selama keseluruhan waktu sinkronisasi itu.
+ Jika ada failover, grup replikasi sekarang akan pulih lebih cepat karena replika melakukan sinkronisasi parsial dengan primer bukannya sinkronisasi penuh jika memungkinkan. Selain itu, primer dan replika tidak lagi menggunakan disk selama sinkronisasi, yang menyediakan keuntungan selanjutnya pada kecepatan.
+ Support untuk dua CloudWatch metrik baru.
+ `ReplicationBytes` – Jumlah byte yang dikirimkan klaster primer grup replikasi ke replika baca.
+ `SaveInProgress` – Nilai biner yang menunjukkan apakah ada proses simpan di latar belakang yang berjalan.
Untuk informasi selengkapnya, lihat [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md).
+ Sejumlah perbaikan bug penting dalam perilaku replikasi PSYNC. Untuk informasi lebih lanjut, lihat catatan [rilis Redis OSS 2.8](https://github.com/redis/redis/blob/2.8/00-RELEASENOTES).
+ Untuk mempertahankan kinerja replikasi yang ditingkatkan dalam grup replikasi multi-AZ dan untuk meningkatkan stabilitas klaster, ElastiCache non-replika tidak lagi didukung.
+ Untuk memperbaiki konsistensi data antara klaster primer dan replika dalam grup replikasi, replika tidak lagi mengosongkan kunci yang independen dari klaster primer.
+ Redis OSS variabel konfigurasi `appendonly` dan tidak `appendfsync` didukung pada Redis OSS versi 2.8.22 dan yang lebih baru.
+ Dalam situasi memori rendah, klien dengan buffer output yang besar mungkin terputus dari klaster replika. Jika terputus, klien perlu terhubung kembali. Situasi seperti itu kemungkinan besar terjadi untuk klien PUBSUB.
#### ElastiCache versi 2.8.21 untuk Redis OSS
Perbaikan Redis OSS ditambahkan sejak versi 2.8.19 mencakup sejumlah perbaikan bug. Untuk informasi lebih lanjut, lihat catatan [rilis Redis OSS 2.8](https://github.com/redis/redis/blob/2.8/00-RELEASENOTES).
#### ElastiCache versi 2.8.19 untuk Redis OSS
Perbaikan Redis OSS ditambahkan sejak versi 2.8.6 meliputi yang berikut:
+ Support untuk HyperLogLog. Untuk informasi selengkapnya, lihat [struktur data baru Redis OSS](http://antirez.com/news/75):. HyperLogLog
+ Jenis data sorted set sekarang memiliki dukungan untuk kueri kisaran leksikografis dengan perintah baru `ZRANGEBYLEX`, `ZLEXCOUNT`, dan `ZREMRANGEBYLEX`.
+ Untuk mencegah simpul primer mengirimkan data usang untuk simpul replika, master SYNC gagal jika proses turunan untuk menyimpan di latar belakang (`bgsave`) dibatalkan.
+ Support untuk *HyperLogLogBasedCommands* CloudWatchmetrik. Untuk informasi selengkapnya, lihat [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md).
#### ElastiCache versi 2.8.6 untuk Redis OSS
Perbaikan Redis OSS ditambahkan sejak versi 2.6.13 meliputi yang berikut:
+ Peningkatan ketahanan dan toleransi kesalahan untuk replika baca.
+ Dukungan untuk sinkronisasi ulang parsial.
+ Dukungan untuk jumlah minimum replika baca yang ditentukan pengguna yang harus tersedia setiap saat.
+ Dukungan penuh untuk pub/sub—memberi tahu klien tentang peristiwa di server.
+ Deteksi otomatis untuk kegagalan simpul primer dan failover dari simpul primer Anda ke simpul sekunder.
#### ElastiCache versi 2.6.13 untuk Redis OSS
ElastiCache versi 2.6.13 untuk Redis OSS adalah versi awal yang didukung Redis OSS. ElastiCache Multi-AZ tidak didukung pada ElastiCache versi 2.6.13 untuk Redis OSS.
## ElastiCache versi untuk jadwal akhir hidup Redis OSS
Bagian ini mendefinisikan tanggal akhir masa pakai (EOL) untuk versi utama yang lebih lama saat diumumkan. Hal ini membantu Anda mengambil keputusan terkait versi dan peningkatan pada masa mendatang.
**catatan**
ElastiCache versi dari 5.0.0 ke 5.0.5 untuk Redis OSS tidak digunakan lagi. Gunakan versi 5.0.6 atau yang lebih baru.
Tabel berikut menunjukkan jadwal [Extended Support](extended-support.md) ElastiCache untuk mesin Redis OSS.
**Jadwal Extended Support dan End of Life**
| Versi Mesin Utama | Akhir dari Standard Support | Mulai dari Extended Support Y1 Premium | Mulai dari Extended Support Y2 Premium | Mulai dari Extended Support Y3 Premium | Akhir dari Extended Support dan versi EOL |
| --- | --- | --- | --- | --- | --- |
| Redis OSS v4 | 1/31/2026 | 2/1/2026 | 2/1/2027 | 2/1/2028 | 1/31/2029 |
| Redis OSS v5 | 1/31/2026 | 2/1/2026 | 2/1/2027 | 2/1/2028 | 1/31/2029 |
| Redis OSS v6 | 1/31/2027 | 2/1/2027 | 2/1/2028 | 2/1/2029 | 1/31/2030 |
Tabel berikut merangkum setiap versi dan tanggal EOL yang diumumkan, serta versi target peningkatan yang direkomendasikan.
**EOL terdahulu**
| Versi Utama Sumber | Versi Minor Sumber | Target Peningkatan yang Disarankan | Tanggal EOL |
| --- | --- | --- | --- |
| Versi 3 | 3.2.4, 3.2.6, dan 3.2.10 | Versi 6.2 atau yang lebih baru Untuk Wilayah US-ISO-EAST -1, US-ISO-WEST -1, dan US-ISOB-EAST -1, kami merekomendasikan 5.0.6 atau lebih tinggi. | 31 Juli 2023 |
| Versi 2 | 2.8.24, 2.8.23, 2.8.22, 2.8.21, 2.8.19, 2.8.12, 2.8.6, 2.6.13 | Versi 6.2 atau yang lebih baru Untuk Wilayah US-ISO-EAST -1, US-ISO-WEST -1, dan US-ISOB-EAST -1, kami merekomendasikan 5.0.6 atau lebih tinggi. | 13 Januari 2023 |
## Didukung ElastiCache untuk versi Memcached
ElastiCache mendukung versi Memcached berikut dan meningkatkan ke versi yang lebih baru. Saat meningkatkan ke versi yang lebih baru, perhatikan kondisi yang jika tidak terpenuhi dapat menyebabkan peningkatan Anda gagal.
**Topics**
+ [ElastiCache versi 1.6.22 untuk Memcached](#memcached-version-1-6-22)
+ [ElastiCache versi 1.6.17 untuk Memcached](#memcached-version-1-6-17)
+ [ElastiCache versi 1.6.12 untuk Memcached](#memcached-version-1-6-12)
+ [ElastiCache versi 1.6.6 untuk Memcached](#memcached-version-1-6-6)
+ [ElastiCache versi 1.5.16 untuk Memcached](#memcached-version-1-5-16)
+ [ElastiCache versi 1.5.10 untuk Memcached](#memcached-version-1-5-10)
+ [ElastiCache versi 1.4.34 untuk Memcached](#memcached-version-1-4-34)
+ [ElastiCache versi 1.4.33 untuk Memcached](#memcached-version-1-4-33)
+ [ElastiCache versi 1.4.24 untuk Memcached](#memcached-version-1-4-24)
+ [ElastiCache versi 1.4.14 untuk Memcached](#memcached-version-1-4-14)
+ [ElastiCache versi 1.4.5 untuk Memcached](#memcached-version-1-4-5)
### ElastiCache versi 1.6.22 untuk Memcached
ElastiCache untuk Memcached versi 1.6.22 untuk Memcached menambahkan dukungan untuk Memcached versi 1.6.22. Ini tidak menyertakan fitur baru, tetapi mencakup perbaikan bug dan pembaruan kumulatif dari [Memcached 1.6.18](https://github.com/memcached/memcached/wiki/ReleaseNotes1618).
Untuk informasi lebih lanjut, lihat [ReleaseNotes1622](https://github.com/memcached/memcached/wiki/ReleaseNotes1622) di Memcached on. GitHub
### ElastiCache versi 1.6.17 untuk Memcached
ElastiCache untuk Memcached versi 1.6.17 untuk Memcached menambahkan dukungan untuk mesin Memcached versi 1.6.17. Ini tidak menyertakan fitur baru, tetapi mencakup perbaikan bug dan pembaruan kumulatif dari [Memcached 1.6.17](https://github.com/memcached/memcached/wiki/ReleaseNotes1617).
Untuk informasi lebih lanjut, lihat [ReleaseNotes1617](https://github.com/memcached/memcached/wiki/ReleaseNotes1617) di Memcached on. GitHub
### ElastiCache versi 1.6.12 untuk Memcached
ElastiCache untuk Memcached versi 1.6.12 untuk Memcached menambahkan dukungan untuk mesin Memcached 1.6.12 dan enkripsi dalam perjalanan. Ini juga mencakup perbaikan bug dan pembaruan kumulatif dari [Memcached 1.6.6.](https://github.com/memcached/memcached/wiki/ReleaseNotes166)
Untuk informasi lebih lanjut, lihat [ReleaseNotes1612](https://github.com/memcached/memcached/wiki/ReleaseNotes1612) di Memcached on. GitHub
### ElastiCache versi 1.6.6 untuk Memcached
ElastiCache untuk Memcached versi 1.6.6 untuk Memcached menambahkan dukungan untuk Memcached versi 1.6.6. [Ini tidak mencakup fitur baru, tetapi termasuk perbaikan bug dan pembaruan kumulatif dari Memcached 1.5.16.](https://github.com/memcached/memcached/wiki/ReleaseNotes1.5.16) ElastiCache [untuk Memcached tidak termasuk dukungan untuk Extstore.](https://memcached.org/extstore)
Untuk informasi lebih lanjut, lihat [ReleaseNotes166](https://github.com/memcached/memcached/wiki/ReleaseNotes166) di Memcached on. GitHub
### ElastiCache versi 1.5.16 untuk Memcached
ElastiCache versi 1.5.16 untuk Memcached menambahkan dukungan untuk Memcached versi 1.5.16. Dukungan ini tidak menyertakan fitur baru, tetapi mencakup perbaikan bug dan pembaruan kumulatif dari [Memcached 1.5.14](https://github.com/memcached/memcached/wiki/ReleaseNotes1514) dan [Memcached 1.5.15](https://github.com/memcached/memcached/wiki/ReleaseNotes1515).
Untuk informasi lebih lanjut, lihat [Memcached 1.5.16 Catatan Rilis](https://github.com/memcached/memcached/wiki/ReleaseNotes1516) di Memcached on. GitHub
### ElastiCache versi 1.5.10 untuk Memcached
ElastiCache versi 1.5.10 untuk Memcached mendukung fitur Memcached berikut:
+ Penyeimbangan ulang slab otomatis.
+ Pencarian tabel hash yang lebih cepat dengan algoritma `murmur3`.
+ Algoritma LRU tersegmentasi.
+ Perayap LRU untuk memori background-reclaim.
+ `--enable-seccomp`: Opsi waktu kompilasi.
Juga diperkenalkan parameter `no_modern` dan `inline_ascii_resp`. Untuk informasi selengkapnya, lihat [Perubahan parameter Memcached 1.5.10](ParameterGroups.Engine.md#ParameterGroups.Memcached.1-5-10).
Perbaikan memcached yang ditambahkan sejak ElastiCache versi 1.4.34 untuk Memcached meliputi yang berikut:
+ Perbaikan kumulatif, seperti multigets ASCII, CVE-2017-9951, dan batas perayapan untuk `metadumper`.
+ Manajemen koneksi yang lebih baik dengan menutup koneksi pada batas koneksi.
+ Peningkatan manajemen ukuran item untuk ukuran item di atas 1 MB.
+ Performa yang lebih baik dan perbaikan overhead memori dengan mengurangi persyaratan memori per-item sebanyak beberapa byte.
Untuk informasi lebih lanjut, lihat [Memcached 1.5.10 Catatan Rilis](https://github.com/memcached/memcached/wiki/ReleaseNotes1510) di Memcached pada. GitHub
### ElastiCache versi 1.4.34 untuk Memcached
ElastiCache versi 1.4.34 untuk Memcached tidak menambahkan fitur baru ke versi 1.4.33. Versi 1.4.34 adalah rilis perbaikan bug yang lebih besar dari rilis biasa.
Untuk informasi lebih lanjut, lihat [Memcached 1.4.34 Catatan Rilis](https://github.com/memcached/memcached/wiki/ReleaseNotes1434) di Memcached on. GitHub
### ElastiCache versi 1.4.33 untuk Memcached
Perbaikan ditambahkan sejak versi 1.4.24 termasuk yang berikut:
+ Kemampuan untuk membuang semua metadata untuk kelas slab tertentu, daftar kelas slab, atau semua kelas slab. Untuk informasi selengkapnya, lihat [Memcached 1.4.31 Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1431).
+ Peningkatan dukungan untuk item besar melebihi default 1 megabyte. Untuk informasi selengkapnya, lihat [Memcached 1.4.29 Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1429).
+ Kemampuan untuk menentukan berapa lama klien dapat idle sebelum diminta untuk menutup.
Kemampuan untuk secara dinamis meningkatkan jumlah memori yang tersedia untuk Memcached tanpa harus memulai ulang klaster. Untuk informasi selengkapnya, lihat [Memcached 1.4.27 Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1427).
+ Saat ini, pencatatan log dari `fetchers`, `mutations`, dan `evictions` didukung. Untuk informasi selengkapnya, lihat [Memcached 1.4.26 Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1426).
+ Memori yang sudah dibebaskan dapat diklaim kembali ke dalam pool global dan ditempatkan ulang ke kelas slab baru. Untuk informasi selengkapnya, lihat [Memcached 1.4.25 Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1425).
+ Beberapa perbaikan bug.
+ Beberapa perintah dan parameter baru. Untuk daftarnya, lihat [Parameter yang ditambahkan di Memcached 1.4.33](ParameterGroups.Engine.md#ParameterGroups.Memcached.1-4-33).
### ElastiCache versi 1.4.24 untuk Memcached
Perbaikan ditambahkan sejak versi 1.4.14 termasuk yang berikut:
+ Manajemen least recently used (LRU) menggunakan proses di latar belakang.
+ Menambahkan opsi untuk menggunakan *jenkins* atau *murmur3* sebagai algoritma hash Anda.
+ Beberapa perintah dan parameter baru. Untuk daftarnya, lihat [Parameter yang ditambahkan di Memcached 1.4.24](ParameterGroups.Engine.md#ParameterGroups.Memcached.1-4-24).
+ Beberapa perbaikan bug.
### ElastiCache versi 1.4.14 untuk Memcached
Perbaikan ditambahkan sejak versi 1.4.5 termasuk yang berikut:
+ Kemampuan penyeimbangan kembali slab yang ditingkatkan.
+ Peningkatan performa dan skalabilitas.
+ Memperkenalkan perintah *touch* untuk memperbarui waktu kedaluwarsa dari item yang sudah ada tanpa mengambilnya.
+ Penemuan otomatis—kemampuan program klien untuk menentukan secara otomatis semua simpul cache pada klaster, dan untuk memulai serta memelihara koneksi ke semua simpul ini.
### ElastiCache versi 1.4.5 untuk Memcached
ElastiCache versi 1.4.5 untuk Memcached adalah mesin awal dan versi yang didukung oleh Amazon ElastiCache untuk Memcached.
# Perilaku versi mesin utama dan perbedaan kompatibilitas dengan Valkey
Valkey 7.2.6 memiliki perbedaan kompatibilitas yang serupa dengan versi Redis OSS 7.2.4 sebelumnya. Untuk versi terbaru Valkey yang didukung, lihat[Mesin dan versi yang didukung](VersionManagement.md#supported-engine-versions).
[Untuk informasi lebih lanjut tentang rilis Valkey 7.2, lihat Catatan Rilis [Redis OSS 7.2.4 (Valkey 7.2 mencakup semua perubahan dari Redis OSS hingga versi 7.2.4) dan catatan rilis](https://github.com/valkey-io/valkey/blob/d2c8a4b91e8c0e6aefd1f5bc0bf582cddbe046b7/00-RELEASENOTES) Valkey 7.2 di Valkey pada.](https://github.com/valkey-io/valkey/blob/7.2/00-RELEASENOTES) GitHub
Berikut adalah perubahan perilaku yang berpotensi melanggar antara Valkey 7.2 dan Redis OSS 7.1 (atau 7.0):
+ Freeze time sampling terjadi selama eksekusi perintah dan dalam skrip.
+ Perintah aliran yang diblokir yang dirilis saat kunci tidak ada lagi membawa kode kesalahan yang berbeda (-NOGROUP atau -WRONGTYPE alih-alih -UNBLOCKED).
+ Pelacakan sisi klien untuk skrip sekarang melacak kunci yang dibaca oleh skrip, bukan kunci yang dideklarasikan oleh pemanggil EVAL /FCALL.
# Perilaku versi mesin utama dan perbedaan kompatibilitas dengan Redis OSS
**penting**
Halaman berikut disusun untuk menandakan semua perbedaan inkompatibilitas antarversi dan memberi tahu Anda tentang pertimbangan apa pun yang harus Anda buat saat meningkatkan ke versi yang lebih baru. Daftar ini termasuk masalah inkompatibilitas versi apa pun yang mungkin Anda temui saat melakukan peningkatan.
Anda dapat meng-upgrade langsung dari versi Redis OSS Anda saat ini ke versi Redis OSS terbaru yang tersedia, tanpa perlu upgrade berurutan. Misalnya, Anda dapat meng-upgrade langsung dari Redis OSS versi 3.0 ke versi 7.0.
Versi Redis OSS diidentifikasi dengan versi semantik yang terdiri dari komponen mayor, minor, dan patch. Misalnya, di Redis OSS 4.0.10, versi utama adalah 4, versi minor 0, dan versi patch adalah 10. Nilai-nilai ini umumnya bertambah berdasarkan konvensi berikut:
+ Versi utama adalah untuk perubahan API yang tidak kompatibel
+ Versi minor adalah untuk fungsionalitas baru yang ditambahkan dengan cara yang kompatibel ke belakang
+ Versi patch adalah untuk perbaikan bug yang kompatibel ke belakang dan perubahan non-fungsional
Kami menyarankan untuk selalu menggunakan versi patch terbaru dalam versi **mayor.minor** tertentu untuk mendapatkan peningkatan kinerja dan stabilitas terbaru. Dimulai dengan ElastiCache versi 6.0 untuk Redis OSS, ElastiCache akan menawarkan versi tunggal untuk setiap rilis minor Redis OSS daripada menawarkan beberapa versi patch. ElastiCacheakan secara otomatis mengelola versi patch dari cluster yang sedang berjalan, memastikan peningkatan kinerja dan keamanan yang ditingkatkan.
Kami juga merekomendasikan melakukan peningkatan secara berkala ke versi utama terbaru, karena sebagian besar perbaikan utama tidak kembali dipindahkan ke versi lama. Karena ElastiCache memperluas ketersediaan ke AWS wilayah baru, ElastiCache untuk Redis OSS mendukung dua versi **mayor.minor** terbaru pada waktu itu untuk wilayah baru. ****Misalnya, jika AWS wilayah baru diluncurkan dan versi mayor.minor terbaru untuk Redis OSS adalah **7.0 dan 6.2, ElastiCache akan mendukung Redis OSS ElastiCache versi 7.0** **dan 6.2** di wilayah baru.****AWS Karena versi mayor.minor yang lebih baru ElastiCache untuk Redis OSS dirilis, ElastiCache akan terus menambahkan dukungan untuk versi yang baru dirilis. Untuk mempelajari selengkapnya tentang memilih wilayah ElastiCache, lihat [Memilih wilayah dan zona ketersediaan](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/RegionsAndAZs.html#SupportedRegions).
Saat melakukan pemutakhiran yang mencakup versi mayor atau minor, harap pertimbangkan daftar berikut yang mencakup perilaku dan perubahan tidak kompatibel mundur yang dirilis dengan Redis OSS dari waktu ke waktu.
## Perilaku Redis OSS 7.0 dan perubahan yang tidak kompatibel ke belakang
Untuk daftar lengkap perubahan, lihat Catatan rilis [Redis OSS 7.0](https://raw.githubusercontent.com/redis/redis/7.0/00-RELEASENOTES).
+ `SCRIPT LOAD` dan `SCRIPT FLUSH` tidak lagi disebarkan ke replika. Jika Anda perlu memiliki beberapa daya tahan untuk skrip, kami sarankan Anda mempertimbangkan untuk menggunakan fungsi [Redis OSS](https://valkey.io/topics/functions-intro/).
+ Saluran Pubsub sekarang diblokir secara default untuk pengguna ACL baru.
+ Perintah `STRALGO` diganti dengan perintah `LCS`.
+ Format untuk `ACL GETUSER` telah berubah sehingga semua bidang menunjukkan pola string akses standar. Jika Anda menggunakan otomatisasi `ACL GETUSER`, Anda harus memverifikasi bahwa itu akan menangani salah satu format.
+ Kategori ACL untuk `SELECT`, `WAIT`, `ROLE`, `LASTSAVE`, `READONLY`, `READWRITE`, dan `ASKING` telah berubah.
+ Perintah `INFO` sekarang menunjukkan statistik perintah per sub-perintah, bukan di perintah kontainer tingkat atas.
+ Nilai pengembalian perintah `LPOP`, `RPOP`, `ZPOPMIN` dan `ZPOPMAX` telah berubah dalam kasus ekstrem tertentu. Jika Anda menggunakan perintah ini, Anda harus memeriksa catatan rilis dan mengevaluasi apakah Anda terpengaruh.
+ Perintah `SORT` dan `SORT_RO` sekarang memerlukan akses ke seluruh ruang kunci untuk menggunakan argumen `GET` dan `BY`.
## Redis OSS 6.2 perilaku dan perubahan mundur yang tidak kompatibel
Untuk daftar lengkap perubahan, lihat Catatan rilis [Redis OSS 6.2](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES).
+ Bendera ACL perintah `TIME`, `ECHO`, `ROLE`, dan `LASTSAVE` telah diubah. Hal ini dapat menyebabkan perintah yang sebelumnya diizinkan untuk ditolak dan sebaliknya.
**catatan**
Tak satu pun dari perintah ini akan mengubah atau memberikan akses ke data.
+ Saat memutakhirkan dari Redis OSS 6.0, urutan key/value pasangan yang dikembalikan dari respons peta ke skrip lua diubah. Jika skrip Anda menggunakan `redis.setresp()` atau mengembalikan peta (baru di Redis OSS 6.0), pertimbangkan implikasi bahwa skrip dapat rusak pada peningkatan.
## Perilaku Redis OSS 6.0 dan perubahan yang tidak kompatibel ke belakang
Untuk daftar lengkap perubahan, lihat Catatan rilis [Redis OSS 6.0](https://raw.githubusercontent.com/redis/redis/6.0/00-RELEASENOTES).
+ Jumlah maksimum basis data yang diizinkan telah dikurangi dari 1,2 juta menjadi 10 ribu. Nilai default-nya adalah 16, dan kami tidak menyarankan penggunaan nilai yang jauh lebih besar dari ini karena kami telah menemukan masalah performa dan memori.
+ Setel `AutoMinorVersionUpgrade` parameter ke ya, dan ElastiCache akan mengelola peningkatan versi minor melalui pembaruan layanan mandiri. Hal ini akan ditangani lewat saluran notifikasi pelanggan standar melalui kampanye pembaruan mandiri. Untuk informasi selengkapnya, lihat [Pembaruan layanan mandiri di ElastiCache](Self-Service-Updates.md).
## Perilaku Redis OSS 5.0 dan perubahan yang tidak kompatibel ke belakang
Untuk daftar lengkap perubahan, lihat Catatan [rilis Redis OSS 5.0](https://raw.githubusercontent.com/redis/redis/5.0/00-RELEASENOTES).
+ Skrip dengan direplikasi oleh efek bukannya mengeksekusi ulang skrip pada replika. Hal ini umumnya akan meningkatkan performa tetapi dapat meningkatkan jumlah data yang direplikasi antara primer dan replika. Ada opsi untuk kembali ke perilaku sebelumnya yang hanya tersedia di ElastiCache versi 5.0 untuk Redis OSS.
+ Jika Anda memutakhirkan dari Redis OSS 4.0, beberapa perintah dalam skrip LUA akan mengembalikan argumen dalam urutan yang berbeda dari yang mereka lakukan di versi sebelumnya. Dalam Redis OSS 4.0, Redis OSS akan memesan beberapa tanggapan secara leksografis untuk membuat respons deterministik, urutan ini tidak diterapkan ketika skrip direplikasi oleh efek.
+ Inn Redis OSS 5.0.3 dan yang lebih baru, ElastiCache untuk Redis OSS akan menurunkan beberapa pekerjaan IO ke inti latar belakang pada tipe instance dengan lebih dari 4. VCPUs Ini dapat mengubah karakteristik kinerja Redis OSS dan mengubah nilai beberapa metrik. Untuk informasi selengkapnya, lihat [Metrik Apa yang Harus Saya Pantau?](CacheMetrics.WhichShouldIMonitor.md) untuk memahami apakah Anda perlu mengubah metrik yang Anda lihat.
## Perilaku Redis OSS 4.0 dan perubahan yang tidak kompatibel ke belakang
Untuk daftar lengkap perubahan, lihat Catatan [rilis Redis OSS 4.0](https://raw.githubusercontent.com/redis/redis/4.0/00-RELEASENOTES).
+ Log lambat sekarang mencatat log dua argumen tambahan, nama klien dan alamat. Perubahan ini harus kompatibel dengan versi lama kecuali jika Anda secara eksplisit mengandalkan setiap entri log lambat yang berisi 3 nilai.
+ Perintah `CLUSTER NODES` sekarang mengembalikan format yang sedikit berbeda, yang tidak kompatibel dengan versi lama. Sebaiknya klien tidak menggunakan perintah ini untuk mempelajari simpul yang ada di klaster, dan sebagai gantinya harus menggunakan `CLUSTER SLOTS`.
## EOL terdahulu
### Perilaku Redis OSS 3.2 dan perubahan yang tidak kompatibel ke belakang
Untuk daftar lengkap perubahan, lihat Catatan [rilis Redis OSS 3.2](https://raw.githubusercontent.com/redis/redis/3.2/00-RELEASENOTES).
+ Tidak ada perubahan kompatibilitas untuk memanggil versi ini.
Untuk informasi selengkapnya, lihat [ElastiCache versi untuk jadwal akhir hidup Redis OSS](engine-versions.md#deprecated-engine-versions).
### Redis OSS 2.8 perilaku dan perubahan mundur yang tidak kompatibel
Untuk daftar lengkap perubahan, lihat Catatan rilis [Redis OSS 2.8](https://raw.githubusercontent.com/redis/redis/2.8/00-RELEASENOTES).
+ Mulai Redis OSS 2.8.22, Redis OSS AOF tidak lagi didukung untuk Redis OSS. ElastiCache Sebaiknya gunakan MemoryDB jika data perlu dipertahankan tahan lama.
+ Mulai dari Redis OSS 2.8.22, ElastiCache untuk Redis OSS tidak lagi mendukung melampirkan replika ke pendahuluan yang dihosting di dalamnya. ElastiCache Saat melakukan peningkatan, replika eksternal akan terputus dan tidak akan dapat terhubung kembali. Sebaiknya gunakan caching sisi klien, tersedia di Redis OSS 6.0 sebagai alternatif replika eksternal.
+ Perintah `TTL` dan `PTTL` sekarang mengembalikan -2 jika kunci tidak ada dan -1 jika ada tetapi tidak memiliki kedaluwarsa terkait. Redis OSS 2.6 dan versi sebelumnya digunakan untuk mengembalikan -1 untuk kedua kondisi.
+ `SORT` dengan `ALPHA` sekarang melakukan pengurutan berdasarkan lokal pengumpulan lokal jika tidak ada opsi `STORE` yang digunakan.
Lihat informasi yang lebih lengkap di [ElastiCache versi untuk jadwal akhir hidup Redis OSS](engine-versions.md#deprecated-engine-versions).
# Tingkatkan pertimbangan saat bekerja dengan cluster berbasis node
**catatan**
Pertimbangan berikut hanya berlaku saat memutakhirkan cluster berbasis node. Mereka tidak berlaku untuk Tanpa ElastiCache Server.
**Pertimbangan Valkey dan Redis OSS**
Saat memutakhirkan cluster Valkey atau Redis OSS berbasis node, pertimbangkan hal berikut.
+ Manajemen versi mesin dirancang agar Anda dapat memiliki kontrol sebanyak mungkin terkait cara melakukan patching. Namun, ElastiCache berhak untuk menambal klaster Anda atas nama Anda jika terjadi kerentanan keamanan kritis dalam sistem atau perangkat lunak cache.
+ Dimulai dengan ElastiCache versi 7.2 untuk Valkey dan ElastiCache versi 6.0 untuk Redis OSS, ElastiCache akan menawarkan versi tunggal untuk setiap rilis minor, daripada menawarkan beberapa versi patch.
+ Dimulai dengan mesin Redis OSS versi 5.0.6, Anda dapat meng-upgrade versi cluster Anda dengan downtime minimal. Klaster tersedia untuk operasi baca selama keseluruhan proses peningkatan dan tersedia untuk operasi tulis untuk sebagian besar durasi peningkatan, kecuali selama operasi failover yang berlangsung beberapa detik.
+ Anda juga dapat meng-upgrade ElastiCache cluster Anda dengan versi lebih awal dari 5.0.6. Tindakan ini melibatkan proses yang sama tetapi mungkin mengalami waktu failover lebih lama selama penyebaran DNS (30 detik - 1 menit).
+ Dimulai dengan Redis OSS 7, ElastiCache mendukung peralihan antara Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan).
+ Proses upgrade mesin Amazon ElastiCache for Redis OSS dirancang untuk melakukan upaya terbaik untuk mempertahankan data Anda yang ada dan memerlukan replikasi Redis OSS yang berhasil.
+ Saat memutakhirkan mesin, ElastiCache akan menghentikan koneksi klien yang ada. [Untuk meminimalkan waktu henti selama peningkatan engine, kami sarankan Anda menerapkan [praktik terbaik untuk klien Redis OSS](BestPractices.Clients.redis.md) dengan percobaan ulang kesalahan dan backoff eksponensial dan praktik terbaik untuk meminimalkan waktu henti selama pemeliharaan.](BestPractices.MinimizeDowntime.md)
+ Anda tidak dapat memutakhirkan langsung dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan) saat Anda meningkatkan mesin Anda. Prosedur berikut menunjukkan kepada Anda cara meningkatkan dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan).
**Untuk meningkatkan dari Valkey atau Redis OSS (mode cluster dinonaktifkan) ke Valkey atau Redis OSS (mode cluster diaktifkan) versi mesin**
1. Buat cadangan cluster atau grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) Anda. Untuk informasi selengkapnya, lihat [Membuat cadangan manual](backups-manual.md).
1. Gunakan cadangan untuk membuat dan menyemai klaster Valkey atau Redis OSS (mode cluster enabled) dengan satu shard (grup node). Tentukan versi mesin baru dan aktifkan mode klaster saat membuat klaster atau grup replikasi. Untuk informasi selengkapnya, lihat [Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal](backups-seeding-redis.md).
1. Hapus cluster atau grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) lama. Untuk informasi selengkapnya, lihat [Menghapus cluster di ElastiCache](Clusters.Delete.md) atau [Menghapus grup replikasi](Replication.DeletingRepGroup.md).
1. Skala cluster atau grup replikasi Valkey atau Redis OSS (mode cluster enabled) baru ke jumlah pecahan (grup node) yang Anda butuhkan. Untuk informasi selengkapnya, lihat [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ Saat meningkatkan versi utama mesin, misalnya dari 5.0.6 ke 6.0, Anda juga harus memilih grup parameter baru yang kompatibel dengan versi mesin yang baru tersebut.
+ Untuk cluster dan cluster Redis OSS tunggal dengan multi-AZ dinonaktifkan, kami menyarankan agar memori yang cukup tersedia untuk Redis OSS seperti yang dijelaskan dalam. [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md) Dalam kasus ini, klaster primer tidak tersedia untuk melayani permintaan selama proses peningkatan.
+ Untuk kluster Redis OSS dengan Multi-AZ diaktifkan, kami juga menyarankan Anda menjadwalkan peningkatan mesin selama periode lalu lintas tulis masuk yang rendah. Saat memutakhirkan ke Redis OSS 5.0.6 atau lebih tinggi, klaster utama terus tersedia untuk permintaan layanan selama proses peningkatan.
Klaster dan grup replikasi dengan beberapa serpihan diproses dan di-patch sebagai berikut:
+ Semua serpihan diproses secara paralel. Hanya satu operasi peningkatan yang akan dilakukan pada satu serpihan kapan saja.
+ Di setiap serpihan, semua replika diproses sebelum primer diproses. Jika terdapat lebih sedikit replika dalam serpihan, primer dalam serpihan itu mungkin diproses sebelum replika di serpihan lainnya selesai diproses.
+ Di semua serpihan, simpul primer diproses secara berurutan. Hanya satu simpul primer yang ditingkatkan dalam satu waktu.
+ Jika enkripsi diaktifkan di klaster atau grup replikasi Anda saat ini, Anda tidak dapat melakukan peningkatan ke versi mesin yang tidak mendukung enkripsi, seperti dari 3.2.6 ke 3.2.10.
**Pertimbangan memcache**
Saat memutakhirkan cluster Memcached berbasis node, pertimbangkan hal berikut.
+ Manajemen versi mesin dirancang agar Anda dapat memiliki kontrol sebanyak mungkin terkait cara melakukan patching. Namun, ElastiCache berhak untuk menambal klaster Anda atas nama Anda jika terjadi kerentanan keamanan kritis dalam sistem atau perangkat lunak cache.
+ Karena mesin Memcached tidak mendukung persistensi, peningkatan versi mesin Memcached merupakan proses disruptif yang menghilangkan semua data cache di klaster.
# ElastiCache praktik terbaik dan strategi caching
Di bawah ini Anda dapat menemukan praktik terbaik yang direkomendasikan untuk Amazon ElastiCache. Mengikuti langkah ini akan meningkatkan performa dan keandalan cache Anda.
**Topics**
+ [Praktik terbaik secara keseluruhan](WorkingWithRedis.md)
+ [Praktik Terbaik untuk menggunakan Read Replicas](ReadReplicas.md)
+ [Perintah Valkey, Memcached, dan Redis OSS yang didukung dan dibatasi](SupportedCommands.md)
+ [Konfigurasi dan batas Valkey dan Redis OSS](RedisConfiguration.md)
+ [IPv6 contoh klien untuk Valkey, Memcached, dan Redis OSS](network-type-best-practices.md)
+ [Praktik terbaik untuk klien (Valkey dan Redis OSS)](BestPractices.Clients.redis.md)
+ [Praktik terbaik untuk klien (Memcached)](BestPractices.Clients.memcached.md)
+ [TLS mengaktifkan cluster tumpukan ElastiCache ganda](#network-type-configuring-tls-enabled-dual-stack)
+ [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md)
+ [Praktik terbaik saat bekerja dengan cluster berbasis node Valkey dan Redis OSS](BestPractices.SelfDesigned.md)
+ [Strategi cache untuk Memcached](Strategies.md)
# Praktik terbaik secara keseluruhan
Di bawah ini Anda dapat menemukan informasi tentang praktik terbaik untuk menggunakan antarmuka Valkey, Memcached, dan Redis OSS di dalamnya. ElastiCache
+ **Gunakan konfigurasi berkemampuan mode cluster — Mode cluster diaktifkan memungkinkan** cache untuk menskalakan secara horizontal untuk mencapai penyimpanan dan throughput yang lebih tinggi daripada konfigurasi yang dinonaktifkan mode cluster. ElastiCache tanpa server hanya tersedia dalam konfigurasi yang diaktifkan mode cluster.
+ **Gunakan koneksi berumur panjang** – Pembuatan koneksi baru menghabiskan banyak daya komputasi, serta membutuhkan waktu dan sumber daya CPU dari cache. Gunakan kembali koneksi jika memungkinkan (misalnya dengan pooling koneksi) untuk menyebarkan beban ini melalui banyak perintah.
+ **Baca dari replika** - Jika Anda menggunakan ElastiCache tanpa server atau telah menyediakan replika baca (cluster berbasis simpul), arahkan pembacaan ke replika untuk mencapai skalabilitas yang lebih baik latensi yang lebih rendah. and/or Pembacaan dari replika pada akhirnya akan konsisten dengan yang primer.
Dalam klaster berbasis simpul, hindari mengarahkan permintaan baca ke satu replika baca karena pembacaan mungkin tidak tersedia sementara jika node gagal. Konfigurasikan klien Anda untuk mengarahkan permintaan baca ke setidaknya dua replika baca, atau arahkan permintaan baca ke replika tunggal dan primer.
Dalam ElastiCache tanpa server, membaca dari port replika (6380) akan mengarahkan pembacaan ke zona ketersediaan lokal klien jika memungkinkan, mengurangi latensi pengambilan. Hal ini akan secara otomatis melakukan fallback ke simpul lainnya selama kegagalan.
+ **Hindari perintah mahal** — Hindari menjalankan operasi komputasi dan I/O intensif, seperti perintah `KEYS` dan `SMEMBERS` perintah. Pendekatan ini disarankan karena operasi ini meningkatkan beban pada klaster dan memiliki dampak pada performa klaster. Sebagai gantinya, gunakan perintah `SCAN` dan `SSCAN`.
+ **Ikuti praktik terbaik Lua** – Hindari menjalankan skrip Lua terlalu lama, dan selalu nyatakan kunci yang digunakan dalam skrip Lua di depan. Pendekatan ini disarankan untuk menentukan bahwa skrip Lua tidak menggunakan perintah cross slot. Pastikan bahwa kunci yang digunakan dalam skrip Lua adalah milik slot yang sama.
+ **Gunakan pub/sub sharded** - Saat menggunakan Valkey atau Redis OSS untuk mendukung pub/sub beban kerja dengan throughput tinggi, kami sarankan Anda menggunakan [pub/sub sharded](https://valkey.io/topics/pubsub/) (tersedia dengan Valkey, dan dengan Redis OSS 7 atau lebih baru). Cluster yang diaktifkan mode cluster tradisional pub/sub menyiarkan pesan ke semua node di cluster, yang dapat menghasilkan high. `EngineCPUUtilization` Perhatikan bahwa dalam ElastiCache perintah tradisional pub/sub commands internally use sharded pub/sub tanpa server.
**Topics**
# Praktik Terbaik untuk menggunakan Read Replicas
Banyak aplikasi, seperti toko sesi, papan peringkat, dan mesin rekomendasi, memerlukan ketersediaan tinggi dan menangani operasi baca secara signifikan lebih banyak daripada operasi tulis. Aplikasi ini sering dapat mentolerir data yang sedikit basi (konsistensi akhirnya), yang berarti bahwa itu dapat diterima jika pengguna yang berbeda sejenak melihat versi yang sedikit berbeda dari data yang sama. Contoh:
+ Hasil kueri yang di-cache seringkali dapat mentolerir data yang sedikit basi, terutama untuk pola selain cache di mana sumber kebenarannya adalah eksternal.
+ Dalam papan peringkat game, penundaan beberapa detik dalam skor yang diperbarui seringkali tidak akan berdampak signifikan pada pengalaman pengguna.
+ Untuk penyimpanan sesi, beberapa penundaan kecil dalam menyebarkan data sesi di seluruh replika jarang memengaruhi fungsionalitas aplikasi.
+ Mesin rekomendasi biasanya menggunakan analisis data historis, sehingga konsistensi waktu nyata kurang penting.
Konsistensi akhirnya berarti bahwa semua node replika pada akhirnya akan mengembalikan data yang sama setelah proses replikasi selesai, biasanya dalam milidetik. Untuk kasus penggunaan seperti itu, menerapkan replika baca adalah strategi yang efektif untuk mengurangi latensi saat membaca dari instans Anda ElastiCache.
Menggunakan replika baca di Amazon ElastiCache dapat memberikan manfaat kinerja yang signifikan melalui:
**Peningkatan Skalabilitas Baca**
+ Mendistribusikan operasi baca di beberapa node replika
+ Offload membaca lalu lintas dari node utama
+ Mengurangi latensi baca dengan menyajikan permintaan dari replika yang lebih dekat secara geografis
**Kinerja Node Primer yang Dioptimalkan**
+ Mendedikasikan sumber daya node utama untuk menulis operasi
+ Mengurangi overhead koneksi pada node utama
+ Meningkatkan kinerja penulisan dan mempertahankan waktu respons yang lebih baik selama periode lalu lintas puncak
## Menggunakan Baca dari Replika di Tanpa Server ElastiCache
ElastiCache tanpa server menyediakan dua titik akhir yang berbeda, untuk persyaratan konsistensi yang berbeda. Kedua titik akhir menggunakan nama DNS yang sama tetapi port yang berbeda. Untuk menggunakan read-from-replica port, Anda harus mengotorisasi akses ke kedua port dari aplikasi klien Anda dengan [mengonfigurasi grup keamanan dan daftar kontrol akses jaringan VPC](set-up.md#elasticache-install-grant-access-VPN) Anda.
**Titik akhir primer (Port 6379)**
+ Gunakan untuk operasi yang membutuhkan konsistensi segera
+ Jaminan membaca up-to-date data terbanyak
+ Terbaik untuk transaksi kritis dan operasi tulis
+ Diperlukan untuk operasi menulis
+ Contoh: `test-12345.serverless.use1.cache.amazonaws.com:6379`
**Titik akhir yang dioptimalkan latensi (Port 6380)**
+ Dioptimalkan untuk operasi baca yang dapat mentolerir konsistensi akhirnya
+ Jika memungkinkan, ElastiCache tanpa server secara otomatis merutekan permintaan baca ke node replika di Availability Zone lokal klien. Optimalisasi ini memberikan latensi yang lebih rendah dengan menghindari latensi jaringan tambahan yang terjadi saat mengambil data dari node di zona ketersediaan yang berbeda.
+ ElastiCache tanpa server secara otomatis memilih node yang tersedia di zona lain jika node lokal tidak tersedia
+ Contoh: `test-12345.serverless.use1.cache.amazonaws.com:6380`
+ Klien seperti Glide dan Lettuce akan secara otomatis mendeteksi dan merutekan pembacaan ke titik akhir yang dioptimalkan latensi jika Anda memberikan konfigurasi replika baca dari. Jika klien Anda tidak mendukung konfigurasi routing (misalnya, valkey-java dan versi jedis yang lebih lama), Anda harus menentukan port dan konfigurasi klien yang tepat untuk membaca dari replika.
## Menghubungkan untuk membaca replika di ElastiCache Tanpa Server - Valkey dan Glide
Cuplikan kode berikut menunjukkan bagaimana Anda dapat mengonfigurasi baca dari replika untuk ElastiCache Tanpa Server di pustaka glide Valkey. Anda tidak perlu menentukan port untuk dibaca dari replika, tetapi Anda perlu mengonfigurasi konfigurasi perutean. `ReadFrom.PREFER_REPLICA`
```
package glide.examples;
import glide.api.GlideClusterClient;
import glide.api.logging.Logger;
import glide.api.models.configuration.GlideClusterClientConfiguration;
import glide.api.models.configuration.NodeAddress;
import glide.api.models.exceptions.ClosingException;
import glide.api.models.exceptions.ConnectionException;
import glide.api.models.exceptions.TimeoutException;
import glide.api.models.configuration.ReadFrom;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ClusterExample {
public static void main(String[] args) {
// Set logger configuration
Logger.setLoggerConfig(Logger.Level.INFO);
GlideClusterClient client = null;
try {
System.out.println("Connecting to Valkey Glide...");
// Configure the Glide Client
GlideClusterClientConfiguration config = GlideClusterClientConfiguration.builder()
.address(NodeAddress.builder()
.host("your-endpoint")
.port(6379)
.build())
.useTLS(true)
.readFrom(ReadFrom.PREFER_REPLICA)
.build();
// Create the GlideClusterClient
client = GlideClusterClient.createClient(config).get();
System.out.println("Connected successfully.");
// Perform SET operation
CompletableFuture setResponse = client.set("key", "value");
System.out.println("Set key 'key' to 'value': " + setResponse.get());
// Perform GET operation
CompletableFuture getResponse = client.get("key");
System.out.println("Get response for 'key': " + getResponse.get());
// Perform PING operation
CompletableFuture pingResponse = client.ping();
System.out.println("PING response: " + pingResponse.get());
} catch (ClosingException | ConnectionException | TimeoutException | ExecutionException e) {
System.err.println("An exception occurred: ");
e.printStackTrace();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
// Close the client connection
if (client != null) {
try {
client.close();
System.out.println("Client connection closed.");
} catch (ClosingException | ExecutionException e) {
System.err.println("Error closing client: " + e.getMessage());
}
}
}
}
}
```
# Perintah Valkey, Memcached, dan Redis OSS yang didukung dan dibatasi
## Perintah Valkey dan Redis OSS yang didukung
**Perintah Valkey dan Redis OSS yang didukung**
Perintah Valkey dan Redis OSS berikut didukung oleh cache tanpa server. Selain perintah ini, [Perintah Valkey dan Redis OSS yang didukungPerintah JSON](json-list-commands.md) ini juga didukung.
Untuk informasi tentang perintah Bloom Filter lihat [Perintah filter Bloom](BloomFilters.md#SupportedCommandsBloom)
**Perintah Bitmap**
+ `BITCOUNT`
Menghitung jumlah bit set (penghitungan populasi) dalam string.
[Pelajari selengkapnya](https://valkey.io/commands/bitcount/)
+ `BITFIELD`
Melakukan operasi bilangan bulat bitfield arbitrer pada string.
[Pelajari selengkapnya](https://valkey.io/commands/bitfield/)
+ `BITFIELD_RO`
Melakukan operasi bilangan bulat bitfield hanya-baca arbitrer pada string.
[Pelajari selengkapnya](https://valkey.io/commands/bitfield_ro/)
+ `BITOP`
Melakukan operasi bitwise pada beberapa string, dan menyimpan hasilnya.
[Pelajari selengkapnya](https://valkey.io/commands/bitop/)
+ `BITPOS`
Menemukan set pertama (1) atau menghapus (0) bit dalam string.
[Pelajari selengkapnya](https://valkey.io/commands/bitpos/)
+ `GETBIT`
Mengembalikan nilai bit dengan offset.
[Pelajari selengkapnya](https://valkey.io/commands/getbit/)
+ `SETBIT`
Menetapkan atau menghapus bit pada offset dari nilai string. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/setbit/)
**Perintah Manajemen Klaster**
+ `CLUSTER COUNTKEYSINSLOT`
Mengembalikan jumlah kunci dalam slot hash.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-countkeysinslot/)
+ `CLUSTER GETKEYSINSLOT`
Mengembalikan nama kunci dalam slot hash.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-getkeysinslot/)
+ `CLUSTER INFO`
Mengembalikan informasi tentang keadaan simpul. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-info/)
+ `CLUSTER KEYSLOT`
Mengembalikan slot hash untuk kunci.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-keyslot/)
+ `CLUSTER MYID`
Mengembalikan ID simpul. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-myid/)
+ `CLUSTER NODES`
Mengembalikan konfigurasi klaster untuk simpul. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-nodes/)
+ `CLUSTER REPLICAS`
Daftar simpul replika dari simpul utama. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-replicas/)
+ `CLUSTER SHARDS`
Mengembalikan pemetaan slot klaster ke serpihan. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-shards/)
+ `CLUSTER SLOTS`
Mengembalikan pemetaan slot klaster ke simpul. Dalam cache nirserver, mengembalikan status tentang "serpihan" virtual tunggal yang diekspos ke klien.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-slots/)
+ `CLUSTER SLOT-STATS`
Memungkinkan pelacakan metrik per slot untuk jumlah kunci, pemanfaatan CPU, byte jaringan masuk, dan byte keluar jaringan.
[Pelajari selengkapnya](https://valkey.io/commands/cluster-slot-stats/)
+ `READONLY`
Mengaktifkan kueri hanya-baca untuk koneksi ke node replika Valkey atau Redis OSS Cluster.
[Pelajari selengkapnya](https://valkey.io/commands/readonly/)
+ `READWRITE`
Mengaktifkan kueri baca-tulis untuk koneksi ke node replika Valkey atau Redis OSS Cluster.
[Pelajari selengkapnya](https://valkey.io/commands/readwrite/)
+ `SCRIPT SHOW`
Mengembalikan kode sumber asli dari script dalam cache script.
[Pelajari selengkapnya](https://valkey.io/commands/script-show/)
**Perintah Manajemen Koneksi**
+ `AUTH`
Mengautentikasi koneksi.
[Pelajari selengkapnya](https://valkey.io/commands/auth/)
+ `CLIENT GETNAME`
Mengembalikan nama koneksi.
[Pelajari selengkapnya](https://valkey.io/commands/client-getname/)
+ `CLIENT REPLY`
Menginstruksikan server apakah akan membalas perintah.
[Pelajari selengkapnya](https://valkey.io/commands/client-reply/)
+ `CLIENT SETNAME`
Menetapkan nama koneksi.
[Pelajari selengkapnya](https://valkey.io/commands/client-setname/)
+ `ECHO`
Mengembalikan string yang diberikan.
[Pelajari selengkapnya](https://valkey.io/commands/echo/)
+ `HELLO`
Jabat tangan dengan server Valkey atau Redis OSS.
[Pelajari selengkapnya](https://valkey.io/commands/hello/)
+ `PING`
Mengembalikan respon keaktifan server.
[Pelajari selengkapnya](https://valkey.io/commands/ping/)
+ `QUIT`
Menutup koneksi.
[Pelajari selengkapnya](https://valkey.io/commands/quit/)
+ `RESET`
Mereset koneksi.
[Pelajari selengkapnya](https://valkey.io/commands/reset/)
+ `SELECT`
Mengubah basis data yang dipilih.
[Pelajari selengkapnya](https://valkey.io/commands/select/)
**Perintah Generik**
+ `COPY`
Menyalin nilai kunci ke kunci baru.
[Pelajari selengkapnya](https://valkey.io/commands/copy/)
+ `DEL`
Menghapus satu atau beberapa tombol.
[Pelajari selengkapnya](https://valkey.io/commands/del/)
+ `DUMP`
Mengembalikan representasi terserialisasi dari nilai yang disimpan pada kunci.
[Pelajari selengkapnya](https://valkey.io/commands/dump/)
+ `EXISTS`
Menentukan apakah ada satu kunci atau lebih.
[Pelajari selengkapnya](https://valkey.io/commands/exists/)
+ `EXPIRE`
Menetapkan waktu kedaluwarsa kunci dalam hitungan detik.
[Pelajari selengkapnya](https://valkey.io/commands/expire/)
+ `EXPIREAT`
Menetapkan waktu kedaluwarsa kunci ke stempel waktu Unix.
[Pelajari selengkapnya](https://valkey.io/commands/expireat/)
+ `EXPIRETIME`
Mengembalikan waktu kedaluwarsa kunci sebagai stempel waktu Unix.
[Pelajari selengkapnya](https://valkey.io/commands/expiretime/)
+ `PERSIST`
Menghapus waktu kedaluwarsa kunci.
[Pelajari selengkapnya](https://valkey.io/commands/persist/)
+ `PEXPIRE`
Menetapkan waktu kedaluwarsa kunci dalam milidetik.
[Pelajari selengkapnya](https://valkey.io/commands/pexpire/)
+ `PEXPIREAT`
Menetapkan waktu kedaluwarsa kunci ke stempel waktu milidetik Unix.
[Pelajari selengkapnya](https://valkey.io/commands/pexpireat/)
+ `PEXPIRETIME`
Mengembalikan waktu kedaluwarsa kunci sebagai stempel waktu milidetik Unix.
[Pelajari selengkapnya](https://valkey.io/commands/pexpiretime/)
+ `PTTL`
Mengembalikan waktu kedaluwarsa dalam milidetik kunci.
[Pelajari selengkapnya](https://valkey.io/commands/pttl/)
+ `RANDOMKEY`
Mengembalikan nama kunci acak dari basis data.
[Pelajari selengkapnya](https://valkey.io/commands/randomkey/)
+ `RENAME`
Mengganti nama kunci dan menimpa tujuan.
[Pelajari selengkapnya](https://valkey.io/commands/rename/)
+ `RENAMENX`
Mengganti nama kunci hanya jika nama kunci target tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/renamenx/)
+ `RESTORE`
Membuat kunci dari representasi terserialisasi untuk sebuah nilai.
[Pelajari selengkapnya](https://valkey.io/commands/restore/)
+ `SCAN`
Melakukan iterasi pada nama kunci dalam basis data.
[Pelajari selengkapnya](https://valkey.io/commands/scan/)
+ `SORT`
Mengurutkan elemen dalam daftar, set, atau sorted set, secara opsional menyimpan hasilnya.
[Pelajari selengkapnya](https://valkey.io/commands/sort/)
+ `SORT_RO`
Mengembalikan elemen diurutkan dari daftar, set, atau sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/sort_ro/)
+ `TOUCH`
Mengembalikan jumlah kunci yang ada dari yang ditentukan setelah memperbarui waktu kunci tersebut terakhir diakses.
[Pelajari selengkapnya](https://valkey.io/commands/touch/)
+ `TTL`
Mengembalikan waktu kedaluwarsa dalam detik kunci.
[Pelajari selengkapnya](https://valkey.io/commands/ttl/)
+ `TYPE`
Menentukan jenis nilai yang disimpan pada kunci.
[Pelajari selengkapnya](https://valkey.io/commands/type/)
+ `UNLINK`
Menghapus satu kunci atau lebih secara asinkron.
[Pelajari selengkapnya](https://valkey.io/commands/unlink/)
**Perintah Geospasial**
+ `GEOADD`
Menambahkan satu atau beberapa anggota ke indeks geospasial. Kunci dibuat jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/geoadd/)
+ `GEODIST`
Mengembalikan jarak antara dua anggota indeks geospasial.
[Pelajari selengkapnya](https://valkey.io/commands/geodist/)
+ `GEOHASH`
Mengembalikan anggota dari indeks geospasial sebagai string geohash.
[Pelajari selengkapnya](https://valkey.io/commands/geohash/)
+ `GEOPOS`
Mengembalikan bujur dan lintang anggota dari indeks geospasial.
[Pelajari selengkapnya](https://valkey.io/commands/geopos/)
+ `GEORADIUS`
Meminta indeks geospasial untuk anggota dalam jarak dari koordinat, secara opsional menyimpan hasilnya.
[Pelajari selengkapnya](https://valkey.io/commands/georadius/)
+ `GEORADIUS_RO`
Mengembalikan anggota dari indeks geospasial yang berada dalam jarak dari koordinat.
[Pelajari selengkapnya](https://valkey.io/commands/georadius_ro/)
+ `GEORADIUSBYMEMBER`
Meminta indeks geospasial untuk anggota dalam jarak dari anggota, secara opsional menyimpan hasilnya.
[Pelajari selengkapnya](https://valkey.io/commands/georadiusbymember/)
+ `GEORADIUSBYMEMBER_RO`
Mengembalikan anggota dari indeks geospasial yang berada dalam jarak dari anggota.
[Pelajari selengkapnya](https://valkey.io/commands/georadiusbymember_ro/)
+ `GEOSEARCH`
Kueri indeks geospasial untuk anggota dalam area kotak atau lingkaran.
[Pelajari selengkapnya](https://valkey.io/commands/geosearch/)
+ `GEOSEARCHSTORE`
Kueri indeks geospasial untuk anggota dalam area kotak atau lingkaran, secara opsional menyimpan hasil.
[Pelajari selengkapnya](https://valkey.io/commands/geosearchstore/)
**Perintah Hash**
+ `HDEL`
Menghapus satu atau beberapa bidang dan nilainya dari hash. Menghapus hash jika tidak ada bidang yang tersisa.
[Pelajari selengkapnya](https://valkey.io/commands/hdel/)
+ `HEXISTS`
Menentukan apakah bidang ada dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hexists/)
+ `HGET`
Mengembalikan nilai bidang dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hget/)
+ `HGETALL`
Mengembalikan semua bidang dan nilai dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hgetall/)
+ `HINCRBY`
Menambah nilai bilangan bulat sebuah bidang dalam sebuah hash sebanyak satu angka. Menggunakan 0 sebagai nilai awal jika bidang tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/hincrby/)
+ `HINCRBYFLOAT`
Menambah nilai titik mengambang sebuah bidang sebanyak satu angka. Menggunakan 0 sebagai nilai awal jika bidang tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/hincrbyfloat/)
+ `HKEYS`
Mengembalikan semua bidang dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hkeys/)
+ `HLEN`
Mengembalikan jumlah bidang dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hlen/)
+ `HMGET`
Mengembalikan nilai-nilai dari semua bidang dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hmget/)
+ `HMSET`
Menetapkan nilai dari beberapa bidang.
[Pelajari selengkapnya](https://valkey.io/commands/hmset/)
+ `HRANDFIELD`
Mengembalikan satu atau beberapa bidang acak dari hash.
[Pelajari selengkapnya](https://valkey.io/commands/hrandfield/)
+ `HSCAN`
Melakukan iterasi pada bidang dan nilai hash.
[Pelajari selengkapnya](https://valkey.io/commands/hscan/)
+ `HSET`
Membuat atau mengubah nilai bidang dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hset/)
+ `HSETNX`
Menetapkan nilai bidang dalam hash hanya jika bidang tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/hsetnx/)
+ `HSTRLEN`
Mengembalikan panjang nilai bidang.
[Pelajari selengkapnya](https://valkey.io/commands/hstrlen/)
+ `HVALS`
Mengembalikan semua nilai dalam hash.
[Pelajari selengkapnya](https://valkey.io/commands/hvals/)
**HyperLogLog Commands**
+ `PFADD`
Menambahkan elemen ke HyperLogLog kunci. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/pfadd/)
+ `PFCOUNT`
Mengembalikan perkiraan kardinalitas himpunan yang diamati oleh HyperLogLog kunci (s).
[Pelajari selengkapnya](https://valkey.io/commands/pfcount/)
+ `PFMERGE`
Menggabungkan satu atau lebih HyperLogLog nilai ke dalam satu kunci.
[Pelajari selengkapnya](https://valkey.io/commands/pfmerge/)
**Perintah List**
+ `BLMOVE`
Memunculkan elemen dari daftar, mendorongnya ke daftar lain, dan mengembalikannya. Memblokir sampai elemen tersedia. Menghapus daftar jika elemen terakhir dipindahkan.
[Pelajari selengkapnya](https://valkey.io/commands/blmove/)
+ `BLMPOP`
Memunculkan elemen pertama dari salah satu dari beberapa daftar. Memblokir sampai elemen tersedia. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/blmpop/)
+ `BLPOP`
Menghapus dan mengembalikan elemen pertama dalam daftar. Memblokir sampai elemen tersedia. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/blpop/)
+ `BRPOP`
Menghapus dan mengembalikan elemen terakhir dalam daftar. Memblokir sampai elemen tersedia. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/brpop/)
+ `BRPOPLPUSH`
Memunculkan elemen dari daftar, mendorongnya ke daftar lain, dan mengembalikannya. Memblokir sampai elemen tersedia sebaliknya. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/brpoplpush/)
+ `LINDEX`
Mengembalikan elemen dari daftar dengan indeks.
[Pelajari selengkapnya](https://valkey.io/commands/lindex/)
+ `LINSERT`
Menyisipkan elemen sebelum atau sesudah elemen lain dalam daftar.
[Pelajari selengkapnya](https://valkey.io/commands/linsert/)
+ `LLEN`
Mengembalikan panjang daftar.
[Pelajari selengkapnya](https://valkey.io/commands/llen/)
+ `LMOVE`
Mengembalikan elemen setelah mem-popping elemen tersebut dari satu daftar dan mendorongnya ke yang lain. Menghapus daftar jika elemen terakhir dipindahkan.
[Pelajari selengkapnya](https://valkey.io/commands/lmove/)
+ `LMPOP`
Mengembalikan beberapa elemen dari daftar setelah menghapusnya. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/lmpop/)
+ `LPOP`
Mengembalikan elemen pertama dalam daftar setelah menghapusnya. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/lpop/)
+ `LPOS`
Mengembalikan indeks elemen yang cocok dalam daftar.
[Pelajari selengkapnya](https://valkey.io/commands/lpos/)
+ `LPUSH`
Menambahkan satu atau beberapa elemen ke awal daftar. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/lpush/)
+ `LPUSHX`
Menambahkan satu atau beberapa elemen ke daftar hanya jika daftar ada.
[Pelajari selengkapnya](https://valkey.io/commands/lpushx/)
+ `LRANGE`
Mengembalikan berbagai elemen dari daftar.
[Pelajari selengkapnya](https://valkey.io/commands/lrange/)
+ `LREM`
Menghapus elemen dari daftar. Menghapus daftar jika elemen terakhir telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/lrem/)
+ `LSET`
Menetapkan nilai elemen dalam daftar dengan indeksnya.
[Pelajari selengkapnya](https://valkey.io/commands/lset/)
+ `LTRIM`
Menghapus elemen dari kedua ujung daftar. Menghapus daftar jika semua elemen dipangkas.
[Pelajari selengkapnya](https://valkey.io/commands/ltrim/)
+ `RPOP`
Mengembalikan dan menghapus elemen terakhir dari daftar. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/rpop/)
+ `RPOPLPUSH`
Mengembalikan elemen terakhir dari daftar setelah menghapus dan mendorongnya ke daftar lain. Menghapus daftar jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/rpoplpush/)
+ `RPUSH`
Menambahkan satu atau beberapa elemen ke daftar. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/rpush/)
+ `RPUSHX`
Menambahkan elemen ke daftar hanya jika daftar ada.
[Pelajari selengkapnya](https://valkey.io/commands/rpushx/)
**Perintah Pub/Sub**
**catatan**
Perintah PUBSUB secara internal menggunakan PUBSUB serpihan, sehingga nama saluran akan dicampur.
+ `PUBLISH`
Memposting pesan ke saluran.
[Pelajari selengkapnya](https://valkey.io/commands/publish/)
+ `PUBSUB CHANNELS`
Mengembalikan saluran yang aktif.
[Pelajari selengkapnya](https://valkey.io/commands/pubsub-channels/)
+ `PUBSUB NUMSUB`
Mengembalikan jumlah pelanggan ke saluran.
[Pelajari selengkapnya](https://valkey.io/commands/pubsub-numsub/)
+ `PUBSUB SHARDCHANNELS`
Mengembalikan saluran serpihan aktif.
[Pelajari selengkapnya](https://valkey.io/commands/pubsub-shardchannels/)
+ `PUBSUB SHARDNUMSUB`
Mengembalikan jumlah pelanggan saluran serpihan.
[Pelajari selengkapnya](https://valkey.io/commands/pubsub-shardnumsub/)
+ `SPUBLISH`
Memposting pesan ke saluran serpihan
[Pelajari selengkapnya](https://valkey.io/commands/spublish/)
+ `SSUBSCRIBE`
Mendengarkan pesan yang dipublikasikan ke saluran serpihan.
[Pelajari selengkapnya](https://valkey.io/commands/ssubscribe/)
+ `SUBSCRIBE`
Mendengarkan pesan yang dipublikasikan ke saluran.
[Pelajari selengkapnya](https://valkey.io/commands/subscribe/)
+ `SUNSUBSCRIBE`
Berhenti mendengarkan pesan yang diposting ke saluran serpihan.
[Pelajari selengkapnya](https://valkey.io/commands/sunsubscribe/)
+ `UNSUBSCRIBE`
Berhenti mendengarkan pesan yang diposting ke saluran.
[Pelajari selengkapnya](https://valkey.io/commands/unsubscribe/)
**Perintah Scripting**
+ `EVAL`
Mengeksekusi skrip Lua sisi server.
[Pelajari selengkapnya](https://valkey.io/commands/eval/)
+ `EVAL_RO`
Mengeksekusi skrip Lua sisi server hanya-baca.
[Pelajari selengkapnya](https://valkey.io/commands/eval_ro/)
+ `EVALSHA`
Mengeksekusi skrip Lua sisi server dengan digest. SHA1
[Pelajari selengkapnya](https://valkey.io/commands/evalsha/)
+ `EVALSHA_RO`
Mengeksekusi skrip Lua sisi server read-only dengan digest. SHA1
[Pelajari selengkapnya](https://valkey.io/commands/evalsha_ro/)
+ `SCRIPT EXISTS`
Menentukan apakah skrip Lua sisi server ada di cache skrip.
[Pelajari selengkapnya](https://valkey.io/commands/script-exists/)
+ `SCRIPT FLUSH`
Saat ini cache skrip no-op dikelola oleh layanan.
[Pelajari selengkapnya](https://valkey.io/commands/script-flush/)
+ `SCRIPT LOAD`
Memuat skrip Lua sisi server ke cache skrip.
[Pelajari selengkapnya](https://valkey.io/commands/script-load/)
**Perintah Manajemen Server**
**catatan**
Saat menggunakan ElastiCache cluster berbasis node untuk Valkey dan Redis OSS, perintah flush harus dikirim ke setiap primer oleh klien untuk membersihkan semua kunci. ElastiCache Tanpa server untuk Valkey dan Redis OSS bekerja secara berbeda, karena mengabstraksi topologi cluster yang mendasarinya. Hasilnya adalah bahwa di ElastiCache Serverless, `FLUSHDB` dan `FLUSHALL` perintah akan selalu flush semua kunci di seluruh cluster. Untuk alasan ini, perintah flush tidak dapat dimasukkan dalam transaksi Tanpa Server.
+ `ACL CAT`
Daftar kategori ACL, atau perintah dalam kategori.
[Pelajari selengkapnya](https://valkey.io/commands/acl-cat/)
+ `ACL GENPASS`
Menghasilkan pseudorandom, kata sandi aman yang dapat digunakan untuk mengidentifikasi pengguna ACL.
[Pelajari selengkapnya](https://valkey.io/commands/acl-genpass/)
+ `ACL GETUSER`
Menampilkan daftar aturan ACL pengguna.
[Pelajari selengkapnya](https://valkey.io/commands/acl-getuser/)
+ `ACL LIST`
Membuang aturan efektif dalam format file ACL.
[Pelajari selengkapnya](https://valkey.io/commands/acl-list/)
+ `ACL USERS`
Menampilkan daftar semua pengguna ACL.
[Pelajari selengkapnya](https://valkey.io/commands/acl-users/)
+ `ACL WHOAMI`
Mengembalikan nama pengguna yang diautentikasi koneksi saat ini.
[Pelajari selengkapnya](https://valkey.io/commands/acl-whoami/)
+ `DBSIZE`
Mengembalikan jumlah kunci dalam basis data yang dipilih saat ini. Operasi ini tidak dijamin atom di semua slot.
[Pelajari selengkapnya](https://valkey.io/commands/dbsize/)
+ `COMMAND`
Mengembalikan informasi mendetail tentang semua perintah.
[Pelajari selengkapnya](https://valkey.io/commands/command/)
+ `COMMAND COUNT`
Mengembalikan hitungan perintah.
[Pelajari selengkapnya](https://valkey.io/commands/command-count/)
+ `COMMAND DOCS`
Mengembalikan informasi dokumenter tentang satu, beberapa, atau semua perintah.
[Pelajari selengkapnya](https://valkey.io/commands/command-docs/)
+ `COMMAND GETKEYS`
Mengekstrak nama kunci dari perintah arbitrer.
[Pelajari selengkapnya](https://valkey.io/commands/command-getkeys/)
+ `COMMAND GETKEYSANDFLAGS`
Mengekstrak nama kunci dan bendera akses untuk perintah arbitrer.
[Pelajari selengkapnya](https://valkey.io/commands/command-getkeysandflags/)
+ `COMMAND INFO`
Mengembalikan informasi tentang satu, beberapa, atau semua perintah.
[Pelajari selengkapnya](https://valkey.io/commands/command-info/)
+ `COMMAND LIST`
Mengembalikan daftar nama perintah.
[Pelajari selengkapnya](https://valkey.io/commands/command-list/)
+ `COMMANDLOG`
Sebuah wadah untuk perintah log perintah.
[Pelajari selengkapnya](https://valkey.io/commands/commandlog/)
+ `COMMANDLOG GET`
Mengembalikan entri log perintah yang ditentukan.
[Pelajari selengkapnya](https://valkey.io/commands/commandlog-get/)
+ `COMMANDLOG HELP`
Tampilkan teks bermanfaat tentang subperintah yang berbeda.
[Pelajari selengkapnya](https://valkey.io/commands/commandlog-help/)
+ `COMMANDLOG LEN`
Mengembalikan jumlah entri dalam jenis tertentu dari perintah log.
[Pelajari selengkapnya](https://valkey.io/commands/commandlog-len/)
+ `COMMANDLOG RESET`
Menghapus semua entri dari jenis log perintah yang ditentukan.
[Pelajari selengkapnya](https://valkey.io/commands/commandlog-reset/)
+ `FLUSHALL`
Menghapus semua kunci dari semua basis data. Operasi ini tidak dijamin atom di semua slot.
[Pelajari selengkapnya](https://valkey.io/commands/flushall/)
+ `FLUSHDB`
Menghapus semua kunci dari basis data saat ini. Operasi ini tidak dijamin atom di semua slot.
[Pelajari selengkapnya](https://valkey.io/commands/flushdb/)
+ `INFO`
Mengembalikan informasi dan statistik tentang server.
[Pelajari selengkapnya](https://valkey.io/commands/info/)
+ `LOLWUT`
Menampilkan seni komputer dan versi Valkey atau Redis OSS.
[Pelajari selengkapnya](https://valkey.io/commands/lolwut/)
+ `ROLE`
Mengembalikan peran replikasi.
[Pelajari selengkapnya](https://valkey.io/commands/role/)
+ `TIME`
Mengembalikan waktu server.
[Pelajari selengkapnya](https://valkey.io/commands/time/)
**Perintah Set**
+ `SADD`
Menambahkan satu atau beberapa anggota ke set. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/sadd/)
+ `SCARD`
Mengembalikan jumlah anggota dalam satu set.
[Pelajari selengkapnya](https://valkey.io/commands/scard/)
+ `SDIFF`
Mengembalikan perbedaan beberapa set.
[Pelajari selengkapnya](https://valkey.io/commands/sdiff/)
+ `SDIFFSTORE`
Menyimpan perbedaan beberapa set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/sdiffstore/)
+ `SINTER`
Mengembalikan potongan dari beberapa set.
[Pelajari selengkapnya](https://valkey.io/commands/sinter/)
+ `SINTERCARD`
Mengembalikan jumlah anggota potongan dari beberapa set.
[Pelajari selengkapnya](https://valkey.io/commands/sintercard/)
+ `SINTERSTORE`
Menyimpan potongan beberapa set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/sinterstore/)
+ `SISMEMBER`
Menentukan apakah anggota termasuk dalam set.
[Pelajari selengkapnya](https://valkey.io/commands/sismember/)
+ `SMEMBERS`
Mengembalikan semua anggota dari satu set.
[Pelajari selengkapnya](https://valkey.io/commands/smembers/)
+ `SMISMEMBER`
Menentukan apakah beberapa anggota termasuk dalam set.
[Pelajari selengkapnya](https://valkey.io/commands/smismember/)
+ `SMOVE`
Memindahkan anggota dari satu set ke set lainnya.
[Pelajari selengkapnya](https://valkey.io/commands/smove/)
+ `SPOP`
Mengembalikan satu atau beberapa anggota acak dari satu set setelah menghapusnya. Menghapus set jika anggota terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/spop/)
+ `SRANDMEMBER`
Mendapatkan satu atau beberapa anggota acak dari satu set
[Pelajari selengkapnya](https://valkey.io/commands/srandmember/)
+ `SREM`
Menghapus satu atau beberapa anggota dari satu set. Menghapus set jika anggota terakhir telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/srem/)
+ `SSCAN`
Melakukan iterasi pada anggota set.
[Pelajari selengkapnya](https://valkey.io/commands/sscan/)
+ `SUNION`
Mengembalikan gabungan dari beberapa set.
[Pelajari selengkapnya](https://valkey.io/commands/sunion/)
+ `SUNIONSTORE`
Menyimpan gabungan beberapa set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/sunionstore/)
**Perintah Sorted Set**
+ `BZMPOP`
Menghapus dan mengembalikan anggota berdasarkan skor dari satu atau beberapa sorted set. Memblokir sampai anggota tersedia. Menghapus sorted set jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/bzmpop/)
+ `BZPOPMAX`
Menghapus dan mengembalikan anggota dengan skor tertinggi dari satu atau beberapa sorted set. Memblokir sampai anggota tersedia. Menghapus sorted set jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/bzpopmax/)
+ `BZPOPMIN`
Menghapus dan mengembalikan anggota dengan skor terendah dari satu atau beberapa sorted set. Memblokir sampai anggota tersedia. Menghapus sorted set jika elemen terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/bzpopmin/)
+ `ZADD`
Menambahkan satu atau beberapa anggota ke sorted set, atau memperbarui skornya. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/zadd/)
+ `ZCARD`
Mengembalikan jumlah anggota dalam satu sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zcard/)
+ `ZCOUNT`
Mengembalikan jumlah anggota dalam satu sorted set yang memiliki skor dalam rentang.
[Pelajari selengkapnya](https://valkey.io/commands/zcount/)
+ `ZDIFF`
Mengembalikan perbedaan antara beberapa sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zdiff/)
+ `ZDIFFSTORE`
Menyimpan perbedaan beberapa sorted set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/zdiffstore/)
+ `ZINCRBY`
Menambah skor anggota dalam sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zincrby/)
+ `ZINTER`
Mengembalikan potongan dari beberapa sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zinter/)
+ `ZINTERCARD`
Mengembalikan jumlah anggota potongan dari beberapa sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zintercard/)
+ `ZINTERSTORE`
Menyimpan potongan beberapa sorted set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/zinterstore/)
+ `ZLEXCOUNT`
Mengembalikan jumlah anggota dalam sorted set dalam rentang leksikografis.
[Pelajari selengkapnya](https://valkey.io/commands/zlexcount/)
+ `ZMPOP`
Mengembalikan anggota dengan skor tertinggi atau terendah dari satu atau beberapa sorted set setelah menghapusnya. Menghapus sorted set jika anggota terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/zmpop/)
+ `ZMSCORE`
Mengembalikan skor dari satu atau beberapa anggota dalam satu sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zmscore/)
+ `ZPOPMAX`
Mengembalikan anggota dengan skor tertinggi dari satu sorted set setelah menghapusnya. Menghapus sorted set jika anggota terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/zpopmax/)
+ `ZPOPMIN`
Mengembalikan anggota dengan skor terendah dari satu sorted set setelah menghapusnya. Menghapus sorted set jika anggota terakhir di-popping.
[Pelajari selengkapnya](https://valkey.io/commands/zpopmin/)
+ `ZRANDMEMBER`
Mengembalikan satu atau beberapa anggota acak dari sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zrandmember/)
+ `ZRANGE`
Mengembalikan anggota dalam satu sorted set dalam rentang indeks.
[Pelajari selengkapnya](https://valkey.io/commands/zrange/)
+ `ZRANGEBYLEX`
Mengembalikan anggota dalam sorted set dalam rentang leksikografis.
[Pelajari selengkapnya](https://valkey.io/commands/zrangebylex/)
+ `ZRANGEBYSCORE`
Mengembalikan anggota dalam satu sorted set dalam rentang skor.
[Pelajari selengkapnya](https://valkey.io/commands/zrangebyscore/)
+ `ZRANGESTORE`
Menyimpan rentang anggota dari sorted set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/zrangestore/)
+ `ZRANK`
Mengembalikan indeks anggota dalam sorted set yang diurutkan berdasarkan skor naik.
[Pelajari selengkapnya](https://valkey.io/commands/zrank/)
+ `ZREM`
Menghapus satu atau beberapa anggota dari satu sorted set. Menghapus sorted set jika semua anggota telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/zrem/)
+ `ZREMRANGEBYLEX`
Menghapus anggota dalam sorted set dalam rentang leksikografis. Menghapus sorted set jika semua anggota telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/zremrangebylex/)
+ `ZREMRANGEBYRANK`
Menghapus anggota dalam satu sorted set dalam rentang indeks. Menghapus sorted set jika semua anggota telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/zremrangebyrank/)
+ `ZREMRANGEBYSCORE`
Menghapus anggota dalam satu sorted set dalam rentang skor. Menghapus sorted set jika semua anggota telah dihapus.
[Pelajari selengkapnya](https://valkey.io/commands/zremrangebyscore/)
+ `ZREVRANGE`
Mengembalikan anggota dalam satu sorted set dalam rentang indeks dalam urutan mundur.
[Pelajari selengkapnya](https://valkey.io/commands/zrevrange/)
+ `ZREVRANGEBYLEX`
Mengembalikan anggota dalam sorted set rentang leksikografis dalam urutan mundur.
[Pelajari selengkapnya](https://valkey.io/commands/zrevrangebylex/)
+ `ZREVRANGEBYSCORE`
Mengembalikan anggota dalam satu sorted set dalam rentang skor dalam urutan mundur.
[Pelajari selengkapnya](https://valkey.io/commands/zrevrangebyscore/)
+ `ZREVRANK`
Mengembalikan indeks anggota dalam sorted set yang diurutkan berdasarkan skor menurun.
[Pelajari selengkapnya](https://valkey.io/commands/zrevrank/)
+ `ZSCAN`
Melakukan iterasi atas anggota dan skor dari sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zscan/)
+ `ZSCORE`
Mengembalikan skor anggota dalam sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zscore/)
+ `ZUNION`
Mengembalikan gabungan dari beberapa sorted set.
[Pelajari selengkapnya](https://valkey.io/commands/zunion/)
+ `ZUNIONSTORE`
Menyimpan gabungan beberapa sorted set dalam kunci.
[Pelajari selengkapnya](https://valkey.io/commands/zunionstore/)
**Perintah Aliran**
+ `XACK`
Mengembalikan jumlah pesan yang berhasil diakui oleh anggota grup konsumen aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xack/)
+ `XADD`
Menambahkan pesan baru ke aliran. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/xadd/)
+ `XAUTOCLAIM`
Mengubah, atau memperoleh, kepemilikan pesan dalam grup konsumen, seolah-olah pesan yang telah dikirimkan berasal dari anggota grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xautoclaim/)
+ `XCLAIM`
Mengubah, atau memperoleh, kepemilikan pesan dalam grup konsumen, seolah-olah pesan yang telah terkirim anggota grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xclaim/)
+ `XDEL`
Mengembalikan jumlah pesan setelah menghapusnya dari aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xdel/)
+ `XGROUP CREATE`
Membuat grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xgroup-create/)
+ `XGROUP CREATECONSUMER`
Membuat konsumen dalam grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xgroup-createconsumer/)
+ `XGROUP DELCONSUMER`
Menghapus konsumen dari grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xgroup-delconsumer/)
+ `XGROUP DESTROY`
Menghancurkan grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xgroup-destroy/)
+ `XGROUP SETID`
Menetapkan ID terakhir yang dikirimkan dari grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xgroup-setid/)
+ `XINFO CONSUMERS`
Mengembalikan daftar konsumen dalam grup konsumen.
[Pelajari selengkapnya](https://valkey.io/commands/xinfo-consumers/)
+ `XINFO GROUPS`
Mengembalikan daftar grup konsumen dari aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xinfo-groups/)
+ `XINFO STREAM`
Mengembalikan informasi tentang aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xinfo-stream/)
+ `XLEN`
Mengembalikan jumlah pesan dalam aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xlen/)
+ `XPENDING`
Mengembalikan informasi dan entri dari daftar entri tertunda grup konsumen aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xpending/)
+ `XRANGE`
Mengembalikan pesan dari aliran dalam rentang IDs.
[Pelajari selengkapnya](https://valkey.io/commands/xrange/)
+ `XREAD`
Mengembalikan pesan dari beberapa aliran dengan IDs lebih besar dari yang diminta. Memblokir sampai pesan tersedia.
[Pelajari selengkapnya](https://valkey.io/commands/xread/)
+ `XREADGROUP`
Mengembalikan pesan baru atau historis dari aliran untuk konsumen dalam grup. Memblokir sampai pesan tersedia.
[Pelajari selengkapnya](https://valkey.io/commands/xreadgroup/)
+ `XREVRANGE`
Mengembalikan pesan dari aliran dalam rentang IDs dalam urutan terbalik.
[Pelajari selengkapnya](https://valkey.io/commands/xrevrange/)
+ `XTRIM`
Menghapus pesan dari awal aliran.
[Pelajari selengkapnya](https://valkey.io/commands/xtrim/)
**Perintah String**
+ `APPEND`
Menambahkan string ke nilai kunci. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/append/)
+ `DECR`
Mengurangi nilai bilangan bulat sebuah kunci sebanyak satu. Menggunakan 0 sebagai nilai awal jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/decr/)
+ `DECRBY`
Mengurangi angka dari nilai bilangan bulat sebuah kunci. Menggunakan 0 sebagai nilai awal jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/decrby/)
+ `GET`
Mengembalikan nilai string dari kunci.
[Pelajari selengkapnya](https://valkey.io/commands/get/)
+ `GETDEL`
Mengembalikan nilai string kunci setelah menghapus kunci.
[Pelajari selengkapnya](https://valkey.io/commands/getdel/)
+ `GETEX`
Mengembalikan nilai string kunci setelah mengatur waktu kedaluwarsa.
[Pelajari selengkapnya](https://valkey.io/commands/getex/)
+ `GETRANGE`
Mengembalikan substring dari string yang disimpan pada kunci.
[Pelajari selengkapnya](https://valkey.io/commands/getrange/)
+ `GETSET`
Mengembalikan nilai string sebelumnya dari kunci setelah mengaturnya ke nilai baru.
[Pelajari selengkapnya](https://valkey.io/commands/getset/)
+ `INCR`
Menambah nilai bilangan bulat sebuah kunci sebanyak satu. Menggunakan 0 sebagai nilai awal jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/incr/)
+ `INCRBY`
Menambah nilai bilangan bulat sebuah kunci sebanyak satu angka. Menggunakan 0 sebagai nilai awal jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/incrby/)
+ `INCRBYFLOAT`
Menambah nilai titik ambang dari bidang dengan angka. Menggunakan 0 sebagai nilai awal jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/incrbyfloat/)
+ `LCS`
Menemukan substring umum terpanjang.
[Pelajari selengkapnya](https://valkey.io/commands/lcs/)
+ `MGET`
Secara atom mengembalikan nilai string dari satu atau beberapa kunci.
[Pelajari selengkapnya](https://valkey.io/commands/mget/)
+ `MSET`
Secara atom membuat atau mengubah nilai string dari satu atau beberapa kunci.
[Pelajari selengkapnya](https://valkey.io/commands/mset/)
+ `MSETNX`
Secara atom mengubah nilai string dari satu atau beberapa kunci hanya ketika semua kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/msetnx/)
+ `PSETEX`
Menetapkan nilai string dan waktu kedaluwarsa kunci dalam milidetik. Kunci dibuat jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/psetex/)
+ `SET`
Menetapkan nilai string kunci, mengabaikan jenisnya. Kunci dibuat jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/set/)
+ `SETEX`
Menetapkan nilai string dan waktu kedaluwarsa kunci. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/setex/)
+ `SETNX`
Menetapkan nilai string kunci hanya jika kunci tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/setnx/)
+ `SETRANGE`
Menimpa bagian dari nilai string dengan yang lain dengan offset. Membuat kunci jika tidak ada.
[Pelajari selengkapnya](https://valkey.io/commands/setrange/)
+ `STRLEN`
Mengembalikan panjang nilai string.
[Pelajari selengkapnya](https://valkey.io/commands/strlen/)
+ `SUBSTR`
Mengembalikan substring dari nilai string.
[Pelajari selengkapnya](https://valkey.io/commands/substr/)
**Perintah Transaction**
+ `DISCARD`
Membuang transaksi.
[Pelajari selengkapnya](https://valkey.io/commands/discard/)
+ `EXEC`
Mengeksekusi semua perintah dalam transaksi.
[Pelajari selengkapnya](https://valkey.io/commands/exec/)
+ `MULTI`
Memulai transaksi.
[Pelajari selengkapnya](https://valkey.io/commands/multi/)
## Perintah Valkey dan Redis OSS yang dibatasi
Untuk memberikan pengalaman layanan terkelola, ElastiCache batasi akses ke perintah khusus mesin cache tertentu yang memerlukan hak istimewa lanjutan. Untuk cache yang menjalankan Redis OSS, perintah berikut tidak tersedia:
+ `acl setuser`
+ `acl load`
+ `acl save`
+ `acl deluser`
+ `bgrewriteaof`
+ `bgsave`
+ `cluster addslot`
+ `cluster addslotsrange`
+ `cluster bumpepoch`
+ `cluster delslot`
+ `cluster delslotsrange `
+ `cluster failover `
+ `cluster flushslots `
+ `cluster forget `
+ `cluster links`
+ `cluster meet`
+ `cluster setslot`
+ `config`
+ `debug`
+ `migrate`
+ `psync`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
Selain itu, perintah berikut tidak tersedia untuk cache nirserver:
+ `acl log`
+ `client caching`
+ `client getredir`
+ `client id`
+ `client info`
+ `client kill`
+ `client list`
+ `client no-evict`
+ `client pause`
+ `client tracking`
+ `client trackinginfo`
+ `client unblock`
+ `client unpause`
+ `cluster count-failure-reports`
+ `commandlog`
+ `commandlog get`
+ `commandlog help`
+ `commandlog len`
+ `commandlog reset`
+ `fcall`
+ `fcall_ro`
+ `function`
+ `function delete`
+ `function dump`
+ `function flush`
+ `function help`
+ `function kill`
+ `function list`
+ `function load`
+ `function restore`
+ `function stats`
+ `keys`
+ `lastsave`
+ `latency`
+ `latency doctor`
+ `latency graph`
+ `latency help`
+ `latency histogram`
+ `latency history`
+ `latency latest`
+ `latency reset`
+ `memory`
+ `memory doctor`
+ `memory help`
+ `memory malloc-stats`
+ `memory purge`
+ `memory stats`
+ `memory usage`
+ `monitor`
+ `move`
+ `object`
+ `object encoding`
+ `object freq`
+ `object help`
+ `object idletime`
+ `object refcount`
+ `pfdebug`
+ `pfselftest`
+ `psubscribe`
+ `pubsub numpat`
+ `punsubscribe`
+ `script kill`
+ `slowlog`
+ `slowlog get`
+ `slowlog help`
+ `slowlog len`
+ `slowlog reset`
+ `swapdb`
+ `wait`
## Perintah Memcached yang didukung
ElastiCache Tanpa server untuk Memcached mendukung semua [perintah memcached di sumber terbuka memcached 1.6 kecuali](https://github.com/memcached/memcached/wiki/Commands) untuk yang berikut ini:
+ Koneksi klien memerlukan TLS, akibatnya protokol UDP tidak didukung.
+ Protokol biner tidak didukung karena ini sudah secara resmi [dihentikan](https://github.com/memcached/memcached/wiki/ReleaseNotes160) di memcached 1.6.
+ Perintah `GET/GETS` dibatasi hingga 16KB untuk menghindari potensi serangan DoS ke server dengan mengambil sejumlah besar kunci.
+ Perintah `flush_all` yang tertunda akan ditolak dengan `CLIENT_ERROR`.
+ Perintah yang mengonfigurasi mesin atau mengungkapkan informasi internal tentang status mesin atau log tidak didukung, seperti:
+ Untuk perintah `STATS`, hanya `stats` dan `stats reset` yang didukung. Variasi lain akan mengembalikan `ERROR`
+ `lru / lru_crawler` - perubahan untuk pengaturan perayap LRU dan LRU
+ `watch` - memantau log server memcached
+ `verbosity` - mengonfigurasi tingkat log server
+ `me`- perintah meta debug (me) tidak didukung
# Konfigurasi dan batas Valkey dan Redis OSS
Mesin Valkey dan Redis OSS masing-masing menyediakan sejumlah parameter konfigurasi, beberapa di antaranya dapat dimodifikasi ElastiCache untuk Redis OSS dan beberapa di antaranya tidak dapat dimodifikasi untuk memberikan kinerja dan keandalan yang stabil.
## Cache nirserver
Untuk cache tanpa server, grup parameter tidak digunakan dan semua konfigurasi Valkey atau Redis OSS tidak dapat dimodifikasi. Parameter Valkey atau Redis OSS berikut tersedia:
****
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| acl-pubsub-default | `allchannels` | Izin saluran pubsub default untuk pengguna ACL di cache. |
| client-output-buffer-limit | `normal 0 0 0` `pubsub 32mb 8mb 60` | Klien normal tidak memiliki batas buffer. PUB/SUB klien akan terputus jika mereka melanggar backlog 32MiB, atau melanggar backlog 8MiB selama 60-an. |
| client-query-buffer-limit | 1 GiB | Ukuran maksimum buffer kueri klien tunggal. Selain itu, klien tidak dapat mengeluarkan permintaan dengan lebih dari 3.999 argumen. |
| cluster-allow-pubsubshard-when-down | yes | Hal ini memungkinkan cache melayani lalu lintas pubsub saat sebagian cache tidak aktif. |
| cluster-allow-reads-when-down | yes | Hal ini memungkinkan cache untuk melayani lalu lintas baca saat cache tidak aktif sebagian. |
| cluster-enabled | yes | Semua cache nirserver menggunakan mode klaster diaktifkan, yang memungkinkan cache untuk secara transparan mempartisi data di beberapa serpihan (shard) backend. Semua slot muncul bagi klien sebagai slot yang dimiliki oleh satu simpul virtual. |
| cluster-require-full-coverage | no | Ketika ruang kunci tidak aktif sebagian (yaitu setidaknya satu slot hash tidak dapat diakses), cache akan terus menerima kueri untuk bagian ruang kunci yang masih tercakup. Seluruh ruang kunci akan selalu "dicakup" oleh satu simpul virtual di cluster slots. |
| lua-time-limit | 5000 | Waktu eksekusi maksimum untuk skrip Lua, dalam milidetik, sebelum ElastiCache mengambil tindakan untuk menghentikan skrip. *Jika `lua-time-limit` terlampaui, semua perintah Valkey atau Redis OSS dapat mengembalikan kesalahan bentuk \$1\$1\$1\$1-BUSY.* Karena keadaan ini dapat menyebabkan gangguan dengan banyak operasi Valkey atau Redis OSS penting, pertama-tama ElastiCache akan mengeluarkan perintah *SCRIPT* KILL. Jika ini tidak berhasil, ElastiCache akan secara paksa restart Valkey atau Redis OSS. |
| maxclients | 65000 | Jumlah klien maksimum yang dapat dihubungkan ke cache sekaligus. Koneksi lebih lanjut yang dibuat mungkin berhasil dan mungkin gagal. |
| maxmemory-policy | volatile-lru | Item dengan set TTL diusir mengikuti estimasi least-recently-used (LRU) saat batas memori cache tercapai. |
| notify-keyspace-events | (string kosong) | Peristiwa ruang kunci saat ini tidak didukung pada cache nirserver. |
| port | Port primer: 6379 Port baca: 6380 | Cache nirserver menyatakan dua port dengan nama host yang sama. Port primer memungkinkan operasi tulis dan baca, sedangkan port baca memungkinkan operasi baca latensi rendah yang pada akhirnya konsisten menggunakan perintah READONLY. |
| proto-max-bulk-len | 512 MiB | Ukuran maksimum dari permintaan elemen tunggal. |
| timeout | 0 | Koneksi klien tidak terputus secara paksa pada waktu idle tertentu, tetapi koneksi klien mungkin terputus selama kondisi stabil untuk tujuan penyeimbangan beban. |
Selain itu, batasan berikut ini berlaku:
****
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| Ukuran per cache | 5.000 GiB | Jumlah maksimum data yang dapat disimpan per cache tanpa server. |
| Ukuran per slot | 32 GiB | Ukuran maksimum slot hash Valkey atau Redis OSS tunggal. Klien yang mencoba mengatur lebih banyak data daripada ini pada satu slot Valkey atau Redis OSS akan memicu kebijakan penggusuran pada slot, dan jika tidak ada kunci yang dapat diusir, akan menerima kesalahan kehabisan memori (). OOM |
| ECPU per cache | 15.000.000 ECPU/detik | ElastiCache Metrik Unit Pemrosesan (ECPU). Jumlah yang ECPUs dikonsumsi oleh permintaan Anda tergantung pada waktu vCPU yang dibutuhkan dan jumlah data yang ditransfer. |
| ECPU per slot | 30K - 90K ECPU/detik | Maksimal 30K ECPUs/second per slot atau 90K ECPUs/second saat menggunakan Read from Replica menggunakan koneksi READONLY. |
| Argumen per Permintaan | 3,999 | Jumlah maksimum argumen per permintaan. Klien yang mengirim lebih banyak argumen per permintaan akan menerima kesalahan. |
| Panjang nama kunci | 4 KiB | Ukuran maksimum untuk satu tombol Valkey atau Redis OSS atau nama saluran. Klien yang mereferensikan kunci yang lebih besar dari ukuran ini akan menghasilkan kesalahan. |
| Ukuran skrip Lua | 4 MiB | Ukuran maksimum skrip Valkey atau Redis OSS Lua tunggal. Percobaan memuat skrip Lua yang lebih besar dari ukuran ini akan menghasilkan kesalahan. |
## Cluster berbasis simpul
Untuk cluster berbasis node, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) nilai default parameter konfigurasi dan mana yang dapat dikonfigurasi. Nilai default umumnya direkomendasikan kecuali jika Anda memiliki kasus penggunaan khusus yang mengharuskan nilai default ini diganti.
# IPv6 contoh klien untuk Valkey, Memcached, dan Redis OSS
ElastiCache kompatibel dengan Valkey, Memcached, dan Redis OSS. Ini berarti bahwa klien yang mendukung IPv6 koneksi harus dapat terhubung ke IPv6 diaktifkan ElastiCache untuk cluster Memcached. Ada beberapa peringatan yang perlu diperhatikan saat berinteraksi dengan sumber daya yang IPv6 diaktifkan.
Anda dapat melihat [Praktik terbaik untuk posting blog klien Valkey dan Redis](https://aws.amazon.com/blogs/database/best-practices-redis-clients-and-amazon-elasticache-for-redis/) di Blog AWS Database untuk rekomendasi tentang mengkonfigurasi klien Valkey dan Redis OSS untuk sumber daya. ElastiCache
Berikut ini adalah praktik terbaik untuk berinteraksi dengan ElastiCache sumber daya yang IPv6 diaktifkan dengan pustaka klien sumber terbuka yang umum digunakan.
## Klien yang divalidasi dengan Valkey dan Redis OSS
ElastiCache kompatibel dengan Valkey dan Redis OSS open-source. Ini berarti bahwa klien Valkey dan open source Redis OSS yang mendukung IPv6 koneksi harus dapat terhubung ke IPv6 diaktifkan ElastiCache untuk cluster Redis OSS. Selain itu, beberapa klien Python dan Java yang paling populer telah diuji dan divalidasi secara khusus untuk bekerja dengan semua konfigurasi tipe jaringan yang didukung (IPv4 hanya, IPv6 hanya, dan Dual Stack)
Klien berikut secara khusus telah divalidasi untuk bekerja dengan semua konfigurasi jenis jaringan yang didukung untuk Valkey dan Redis OSS.
Klien yang Divalidasi:
+ [Redis Py ()](https://github.com/redis/redis-py) – [4.1.2](https://github.com/redis/redis-py/tree/v4.1.2)
+ [Lettuce](https://lettuce.io/) – [Versi: 6.1.6.RELEASE](https://github.com/lettuce-io/lettuce-core/tree/6.1.6.RELEASE)
+ [Jedis](https://github.com/redis/jedis) - [Versi: 3.6.0](https://github.com/redis/jedis/tree/jedis-3.6.0)
# Praktik terbaik untuk klien (Valkey dan Redis OSS)
Pelajari praktik terbaik untuk skenario umum dan ikuti contoh kode dari beberapa pustaka klien Valkey dan Redis OSS open source paling populer (redis-py,, dan Lettuce) PHPRedis, serta praktik terbaik untuk berinteraksi dengan ElastiCache sumber daya dengan pustaka klien Memcached open-source yang umum digunakan.
**Topics**
+ [Sejumlah besar koneksi (Valkey dan Redis OSS)](BestPractices.Clients.Redis.Connections.md)
+ [Penemuan klien cluster dan backoff eksponensial (Valkey dan Redis OSS)](BestPractices.Clients.Redis.Discovery.md)
+ [Konfigurasikan batas waktu sisi klien (Valkey dan Redis OSS)](BestPractices.Clients.Redis.ClientTimeout.md)
+ [Konfigurasikan batas waktu idle sisi server (Valkey dan Redis OSS)](BestPractices.Clients.Redis.ServerTimeout.md)
+ [Skrip Lua](BestPractices.Clients.Redis.LuaScripts.md)
+ [Menyimpan item komposit besar (Valkey dan Redis OSS)](BestPractices.Clients.Redis.LargeItems.md)
+ [Konfigurasi klien selada (Valkey dan Redis OSS)](BestPractices.Clients-lettuce.md)
+ [Mengkonfigurasi protokol pilihan untuk cluster tumpukan ganda (Valkey dan Redis OSS)](#network-type-configuring-dual-stack-redis)
# Sejumlah besar koneksi (Valkey dan Redis OSS)
Cache tanpa server dan individual ElastiCache untuk node Redis OSS mendukung hingga 65.000 koneksi klien bersamaan. Namun, untuk mengoptimalkan performa, kami menyarankan agar aplikasi klien tidak terus-menerus beroperasi pada tingkat koneksi tersebut. Valkey dan Redis OSS masing-masing memiliki proses single-threaded berdasarkan loop peristiwa di mana permintaan klien yang masuk ditangani secara berurutan. Artinya, waktu respons klien tertentu menjadi lebih lama seiring jumlah klien yang terhubung meningkat.
Anda dapat mengambil serangkaian tindakan berikut untuk menghindari hambatan koneksi pada server Valkey atau Redis OSS:
+ Lakukan operasi baca dari replika baca. Ini dapat dilakukan dengan menggunakan endpoint ElastiCache pembaca dalam mode cluster dinonaktifkan atau dengan menggunakan replika untuk membaca dalam mode cluster diaktifkan, termasuk cache tanpa server.
+ Distribusikan lalu lintas penulisan ke beberapa simpul primer. Anda dapat melakukannya dengan dua cara: Anda dapat menggunakan cluster Valkey atau Redis OSS multi-sharded dengan klien yang mampu mode cluster. Anda juga dapat menulis ke beberapa simpul primer dalam mode klaster dinonaktifkan dengan sharding sisi klien. Hal ini dilakukan secara otomatis dalam cache nirserver.
+ Gunakan pool koneksi jika tersedia di pustaka klien Anda.
Secara umum, membuat koneksi TCP adalah operasi komputasi yang mahal dibandingkan dengan perintah Valkey atau Redis OSS yang khas. Misalnya, menangani SET/GET permintaan adalah urutan besarnya lebih cepat saat menggunakan kembali koneksi yang ada. Menggunakan pool koneksi klien dengan ukuran terbatas akan mengurangi overhead manajemen koneksi. Hal ini juga membatasi jumlah koneksi masuk konkuren dari aplikasi klien.
Contoh kode berikut PHPRedis menunjukkan bahwa koneksi baru dibuat untuk setiap permintaan pengguna baru:
```
$redis = new Redis();
if ($redis->connect($HOST, $PORT) != TRUE) {
//ERROR: connection failed
return;
}
$redis->set($key, $value);
unset($redis);
$redis = NULL;
```
Kami membandingkan kode ini dalam satu loop pada instance Amazon Elastic Compute Cloud EC2 (Amazon) yang terhubung ke Graviton2 (m6g.2xlarge) untuk node Redis OSS. ElastiCache Kita menempatkan klien dan server di Zona Ketersediaan yang sama. Latensi rata-rata seluruh operasi adalah 2,82 milidetik.
Saat kami memperbarui kode serta menggunakan koneksi persisten dan pool koneksi, latensi rata-rata seluruh operasi adalah 0,21 milidetik:
```
$redis = new Redis();
if ($redis->pconnect($HOST, $PORT) != TRUE) {
// ERROR: connection failed
return;
}
$redis->set($key, $value);
unset($redis);
$redis = NULL;
```
Konfigurasi redis.ini yang diperlukan:
+ `redis.pconnect.pooling_enabled=1`
+ `redis.pconnect.connection_limit=10`
Kode berikut adalah contoh [pool koneksi Redis-Py](https://redis.readthedocs.io/en/stable/):
```
conn = Redis(connection_pool=redis.BlockingConnectionPool(host=HOST, max_connections=10))
conn.set(key, value)
```
Kode berikut adalah contoh [pool koneksi Lettuce](https://lettuce.io/core/release/reference/#_connection_pooling):
```
RedisClient client = RedisClient.create(RedisURI.create(HOST, PORT));
GenericObjectPool pool = ConnectionPoolSupport.createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig());
pool.setMaxTotal(10); // Configure max connections to 10
try (StatefulRedisConnection connection = pool.borrowObject()) {
RedisCommands syncCommands = connection.sync();
syncCommands.set(key, value);
}
```
# Penemuan klien cluster dan backoff eksponensial (Valkey dan Redis OSS)
Saat menghubungkan ke cluster ElastiCache Valkey atau Redis OSS dalam mode cluster diaktifkan, pustaka klien yang sesuai harus sadar cluster. Klien harus mendapatkan peta slot hash ke simpul yang sesuai di klaster untuk mengirim permintaan ke simpul yang tepat dan menghindari overhead performa penanganan pengalihan klaster. Akibatnya, klien harus menemukan daftar lengkap slot dan simpul yang dipetakan dalam dua situasi berbeda:
+ Klien diinisialisasi dan harus mengisi konfigurasi slot awal
+ Pengalihan MOVED diterima dari server, seperti dalam situasi failover ketika semua slot yang dilayani oleh simpul primer sebelumnya diambil alih oleh replika, atau melakukan resharding ketika slot dipindahkan dari simpul primer sumber ke simpul primer target
Penemuan klien biasanya dilakukan dengan mengeluarkan perintah CLUSTER SLOT atau CLUSTER NODE ke server Valkey atau Redis OSS. Sebaiknya gunakan metode CLUSTER SLOT karena metode ini mengembalikan set rentang slot dan simpul primer dan replika terkait ke klien. Metode ini tidak memerlukan parsing tambahan dari klien dan lebih efisien.
Tergantung topologi klaster, ukuran respons untuk perintah CLUSTER SLOT dapat bervariasi berdasarkan ukuran klaster. Klaster yang lebih besar dengan lebih banyak simpul menghasilkan respons yang lebih besar. Oleh karena itu, penting untuk memastikan bahwa jumlah klien yang melakukan penemuan topologi klaster tidak bertambah tanpa batas. Misalnya, ketika aplikasi klien diaktifkan atau kehilangan koneksi dari server dan harus melakukan penemuan klaster, satu kesalahan umumnya adalah bahwa aplikasi klien memicu beberapa permintaan koneksi ulang dan penemuan tanpa menambahkan backoff eksponensial saat mencoba lagi. Ini dapat membuat server Valkey atau Redis OSS tidak responsif untuk jangka waktu yang lama, dengan pemanfaatan CPU 100%. Pemadaman akan lebih lama jika setiap perintah CLUSTER SLOT harus memproses sejumlah besar simpul di bus klaster. Kami telah mengamati beberapa pemadaman klien di masa lalu karena perilaku ini di sejumlah bahasa yang berbeda termasuk Python redis-py-cluster () dan Java (Lettuce dan Redisson).
Dalam cache nirserver, banyak masalah secara otomatis dikurangi karena topologi klaster yang dinyatakan bersifat statis dan terdiri dari dua entri: titik akhir tulis dan titik akhir baca. Penemuan klaster juga secara otomatis tersebar di beberapa simpul saat menggunakan titik akhir cache. Namun, rekomendasi berikut masih berguna.
Untuk mengurangi dampak yang disebabkan oleh masuknya permintaan koneksi dan penemuan secara tiba-tiba, kami merekomendasikan hal berikut:
+ Menerapkan pool koneksi klien dengan ukuran terbatas untuk membatasi jumlah koneksi masuk konkuren dari aplikasi klien.
+ Ketika klien terputus dari server karena waktu habis, coba lagi dengan backoff eksponensial dengan jitter. Hal ini membantu menghindari banyak klien membebani server pada waktu yang sama.
+ Gunakan panduan dalam [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md) guna menemukan titik akhir klaster untuk melakukan penemuan klaster. Dengan begitu, Anda menyebarkan beban penemuan ke semua simpul di klaster (hingga 90), bukan memanfaatkan hanya beberapa simpul seed hardcode di klaster.
Berikut ini adalah beberapa contoh kode untuk logika percobaan ulang backoff eksponensial di redis-py,, dan Lettuce. PHPRedis
**Contoh logika backoff 1: redis-py**
redis-py memiliki mekanisme percobaan ulang bawaan yang mencoba ulang satu kali segera setelah kegagalan. Mekanisme ini dapat diaktifkan melalui `retry_on_timeout` argumen yang diberikan saat membuat objek [Redis OSS](https://redis.readthedocs.io/en/stable/examples/connection_examples.html#redis.Redis). Di sini kita mendemonstrasikan mekanisme percobaan ulang kustom dengan backoff eksponensial dan jitter. Kami telah mengirimkan permintaan tarik untuk mengimplementasikan backoff eksponensial secara native di [redis-py (\$11494)](https://github.com/andymccurdy/redis-py/pull/1494). Di masa depan, hal tersebut mungkin tidak perlu diimplementasikan secara manual.
```
def run_with_backoff(function, retries=5):
base_backoff = 0.1 # base 100ms backoff
max_backoff = 10 # sleep for maximum 10 seconds
tries = 0
while True:
try:
return function()
except (ConnectionError, TimeoutError):
if tries >= retries:
raise
backoff = min(max_backoff, base_backoff * (pow(2, tries) + random.random()))
print(f"sleeping for {backoff:.2f}s")
sleep(backoff)
tries += 1
```
Anda kemudian dapat menggunakan kode berikut untuk menetapkan nilai:
```
client = redis.Redis(connection_pool=redis.BlockingConnectionPool(host=HOST, max_connections=10))
res = run_with_backoff(lambda: client.set("key", "value"))
print(res)
```
Bergantung pada beban kerja Anda, Anda sebaiknya mengubah nilai backoff dasar dari 1 detik menjadi puluhan atau ratusan milidetik untuk beban kerja yang sensitif terhadap latensi.
**Contoh logika backoff 2: PHPRedis**
PHPRedis memiliki mekanisme coba ulang bawaan yang mencoba ulang maksimum (tidak dapat dikonfigurasi) sebanyak 10 kali. Ada penundaan yang dapat dikonfigurasi di antara percobaan (dengan jitter dari percobaan ulang kedua dan seterusnya). Untuk informasi selengkapnya, lihat [kode sampel](https://github.com/phpredis/phpredis/blob/b0b9dd78ef7c15af936144c1b17df1a9273d72ab/library.c#L335-L368) berikut. [Kami telah mengirimkan permintaan tarik untuk menerapkan backoff eksponensial secara native di [PHPredis (\$11986)](https://github.com/phpredis/phpredis/pull/1986) yang telah digabungkan dan didokumentasikan.](https://github.com/phpredis/phpredis/blob/develop/README.md#retry-and-backoff) Bagi mereka yang berada di rilis terbaru PHPRedis, tidak perlu mengimplementasikan secara manual tetapi kami telah menyertakan referensi di sini untuk mereka yang ada di versi sebelumnya. Untuk saat ini, berikut ini adalah contoh kode yang mengonfigurasi penundaan mekanisme percobaan ulang:
```
$timeout = 0.1; // 100 millisecond connection timeout
$retry_interval = 100; // 100 millisecond retry interval
$client = new Redis();
if($client->pconnect($HOST, $PORT, $timeout, NULL, $retry_interval) != TRUE) {
return; // ERROR: connection failed
}
$client->set($key, $value);
```
**Contoh logika backoff 3: Lettuce**
Lettuce memiliki mekanisme percobaan ulang bawaan berdasarkan strategi backoff eksponensial yang dijelaskan dalam postingan [Backoff Eksponensial dan Jitter](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/). Berikut ini adalah kutipan kode yang menunjukkan pendekatan jitter penuh:
```
public static void main(String[] args)
{
ClientResources resources = null;
RedisClient client = null;
try {
resources = DefaultClientResources.builder()
.reconnectDelay(Delay.fullJitter(
Duration.ofMillis(100), // minimum 100 millisecond delay
Duration.ofSeconds(5), // maximum 5 second delay
100, TimeUnit.MILLISECONDS) // 100 millisecond base
).build();
client = RedisClient.create(resources, RedisURI.create(HOST, PORT));
client.setOptions(ClientOptions.builder()
.socketOptions(SocketOptions.builder().connectTimeout(Duration.ofMillis(100)).build()) // 100 millisecond connection timeout
.timeoutOptions(TimeoutOptions.builder().fixedTimeout(Duration.ofSeconds(5)).build()) // 5 second command timeout
.build());
// use the connection pool from above example
} finally {
if (connection != null) {
connection.close();
}
if (client != null){
client.shutdown();
}
if (resources != null){
resources.shutdown();
}
}
}
```
# Konfigurasikan batas waktu sisi klien (Valkey dan Redis OSS)
**Mengkonfigurasi batas waktu sisi klien**
Konfigurasikan waktu habis sisi klien dengan tepat agar server memiliki cukup waktu untuk memproses permintaan dan menghasilkan respons. Hal ini juga membantunya melakukan gagal cepat (fail fast) jika koneksi ke server tidak dapat dibuat. Perintah Valkey atau Redis OSS tertentu bisa lebih mahal secara komputasi daripada yang lain. Misalnya, skrip Lua atau MULTI/EXEC transaksi yang berisi beberapa perintah yang harus dijalankan secara atom. Secara umum, waktu habis sisi klien yang lebih tinggi disarankan untuk menghindari waktu habis klien sebelum respons diterima dari server, termasuk yang berikut:
+ Menjalankan perintah di beberapa kunci
+ Menjalankan MULTI/EXEC transaksi atau skrip Lua yang terdiri dari beberapa perintah Valkey atau Redis OSS individual
+ Membaca nilai besar
+ Melakukan operasi pemblokiran seperti BLPOP
Dalam kasus operasi pemblokiran seperti BLPOP, praktik terbaiknya adalah dengan mengatur waktu habis perintah ke jumlah yang lebih rendah dari waktu habis soket.
Berikut ini adalah contoh kode untuk menerapkan batas waktu sisi klien di redis-py,, dan Lettuce. PHPRedis
**Contoh konfigurasi waktu habis 1: redis-py**
Berikut ini adalah contoh kode dengan redis-py:
```
# connect to Redis server with a 100 millisecond timeout
# give every Redis command a 2 second timeout
client = redis.Redis(connection_pool=redis.BlockingConnectionPool(host=HOST, max_connections=10,socket_connect_timeout=0.1,socket_timeout=2))
res = client.set("key", "value") # will timeout after 2 seconds
print(res) # if there is a connection error
res = client.blpop("list", timeout=1) # will timeout after 1 second
# less than the 2 second socket timeout
print(res)
```
**Contoh konfigurasi batas waktu 2: PHPRedis**
Berikut ini adalah contoh kode dengan PHPRedis:
```
// connect to Redis server with a 100ms timeout
// give every Redis command a 2s timeout
$client = new Redis();
$timeout = 0.1; // 100 millisecond connection timeout
$retry_interval = 100; // 100 millisecond retry interval
$client = new Redis();
if($client->pconnect($HOST, $PORT, 0.1, NULL, 100, $read_timeout=2) != TRUE){
return; // ERROR: connection failed
}
$client->set($key, $value);
$res = $client->set("key", "value"); // will timeout after 2 seconds
print "$res\n"; // if there is a connection error
$res = $client->blpop("list", 1); // will timeout after 1 second
print "$res\n"; // less than the 2 second socket timeout
```
**Contoh konfigurasi waktu habis 3: Lettuce**
Berikut ini adalah contoh kode dengan Lettuce:
```
// connect to Redis server and give every command a 2 second timeout
public static void main(String[] args)
{
RedisClient client = null;
StatefulRedisConnection connection = null;
try {
client = RedisClient.create(RedisURI.create(HOST, PORT));
client.setOptions(ClientOptions.builder()
.socketOptions(SocketOptions.builder().connectTimeout(Duration.ofMillis(100)).build()) // 100 millisecond connection timeout
.timeoutOptions(TimeoutOptions.builder().fixedTimeout(Duration.ofSeconds(2)).build()) // 2 second command timeout
.build());
// use the connection pool from above example
commands.set("key", "value"); // will timeout after 2 seconds
commands.blpop(1, "list"); // BLPOP with 1 second timeout
} finally {
if (connection != null) {
connection.close();
}
if (client != null){
client.shutdown();
}
}
}
```
# Konfigurasikan batas waktu idle sisi server (Valkey dan Redis OSS)
Kami telah mengamati kasus ketika aplikasi pelanggan memiliki klien idle terhubung dalam jumlah yang tinggi, tetapi tidak secara aktif mengirim perintah. Dalam skenario tersebut, Anda dapat menghabiskan total 65.000 koneksi dengan jumlah klien idle yang tinggi. Untuk menghindari skenario tersebut, konfigurasikan pengaturan waktu habis dengan sesuai di server melalui [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis). Hal ini memastikan bahwa server secara aktif memutus klien idle untuk menghindari peningkatan jumlah koneksi. Pengaturan ini tidak tersedia di cache nirserver.
# Skrip Lua
Valkey dan Redis OSS mendukung lebih dari 200 perintah, termasuk yang menjalankan skrip Lua. Namun, ketika datang ke skrip Lua, ada beberapa jebakan yang dapat mempengaruhi memori dan ketersediaan Valkey atau Redis OSS.
**Skrip Lua yang tidak diparameterisasi**
Setiap skrip Lua di-cache di server Valkey atau Redis OSS sebelum berjalan. Skrip Lua yang tidak diparameterisasi adalah unik, yang dapat menyebabkan server Valkey atau Redis OSS menyimpan sejumlah besar skrip Lua dan menghabiskan lebih banyak memori. Untuk memitigasi hal ini, pastikan bahwa semua skrip Lua diparameterisasi dan secara teratur melakukan SCRIPT FLUSH untuk membersihkan skrip Lua yang di-cache jika diperlukan.
Ketahuilah juga bahwa kunci harus disediakan. Jika nilai untuk parameter KEY tidak disediakan, skrip akan gagal. Misalnya, ini tidak akan berhasil:
```
serverless-test-lst4hg.serverless.use1.cache.amazonaws.com:6379> eval 'return "Hello World"' 0
(error) ERR Lua scripts without any input keys are not supported.
```
Ini akan berhasil:
```
serverless-test-lst4hg.serverless.use1.cache.amazonaws.com:6379> eval 'return redis.call("get", KEYS[1])' 1 mykey-2
"myvalue-2"
```
Contoh berikut menunjukkan cara menggunakan skrip yang diparameterisasi. Pertama, kita memiliki contoh pendekatan tanpa parameterisasi yang menghasilkan tiga skrip Lua yang di-cache yang berbeda dan tidak disarankan:
```
eval "return redis.call('set','key1','1')" 0
eval "return redis.call('set','key2','2')" 0
eval "return redis.call('set','key3','3')" 0
```
Sebagai gantinya, gunakan pola berikut untuk membuat skrip tunggal yang dapat menerima parameter yang diteruskan:
```
eval "return redis.call('set',KEYS[1],ARGV[1])" 1 key1 1
eval "return redis.call('set',KEYS[1],ARGV[1])" 1 key2 2
eval "return redis.call('set',KEYS[1],ARGV[1])" 1 key3 3
```
**Skrip Lua yang berjalan lama**
Skrip Lua dapat menjalankan beberapa perintah secara atom, sehingga bisa memakan waktu lebih lama untuk diselesaikan daripada perintah Valkey atau Redis OSS biasa. Jika skrip Lua hanya menjalankan operasi hanya-baca, Anda dapat menghentikannya di tengah proses. Namun, segera setelah skrip Lua melakukan operasi penulisan, prosesnya tidak dapat dihentikan dan harus dijalankan hingga selesai. Skrip Lua yang berjalan lama yang bermutasi dapat menyebabkan server Valkey atau Redis OSS tidak responsif untuk waktu yang lama. Untuk memitigasi masalah ini, hindari skrip Lua yang berjalan lama dan uji skrip di lingkungan praproduksi.
**Skrip Lua dengan penulisan stealth**
Ada beberapa cara skrip Lua dapat terus menulis data baru ke Valkey atau Redis OSS bahkan ketika Valkey atau Redis OSS selesai: `maxmemory`
+ Script dimulai ketika server Valkey atau Redis OSS di bawah ini`maxmemory`, dan berisi beberapa operasi tulis di dalamnya
+ Perintah tulis pertama skrip tidak menghabiskan memori (seperti DEL), yang diikuti oleh lebih banyak operasi tulis yang menghabiskan memori
+ Anda dapat mengurangi masalah ini dengan mengonfigurasi kebijakan penggusuran yang tepat di server Valkey atau Redis OSS selain. `noeviction` Hal ini memungkinkan Redis OSS untuk mengusir item dan membebaskan memori di antara skrip Lua.
# Menyimpan item komposit besar (Valkey dan Redis OSS)
Dalam beberapa skenario, aplikasi dapat menyimpan item komposit besar di Valkey atau Redis OSS (seperti dataset hash multi-GB). Ini bukan praktik yang direkomendasikan karena sering menyebabkan masalah kinerja di Valkey atau Redis OSS. Misalnya, klien dapat melakukan perintah HGETALL untuk mengambil seluruh koleksi hash multi GB. Hal ini dapat menghasilkan tekanan memori yang signifikan ke server Valkey atau Redis OSS buffering item besar dalam buffer output klien. Selain itu, untuk migrasi slot dalam mode cluster, ElastiCache tidak memigrasikan slot yang berisi item dengan ukuran serial yang lebih besar dari 256 MB.
Untuk mengatasi masalah item besar, kami memiliki rekomendasi berikut:
+ Pecah item komposit besar menjadi beberapa item yang lebih kecil. Misalnya, pisahkan koleksi hash besar menjadi bidang nilai kunci individual dengan skema nama kunci yang mencerminkan koleksi dengan tepat, seperti menggunakan awalan umum dalam nama kunci untuk mengidentifikasi kumpulan item. Jika Anda harus mengakses beberapa bidang dalam koleksi yang sama secara atomik, Anda dapat menggunakan perintah MGET untuk mengambil beberapa nilai kunci dalam perintah yang sama.
+ Jika Anda mengevaluasi semua opsi dan masih tidak dapat memecah set data koleksi besar, coba gunakan perintah yang beroperasi di subset data dalam koleksi, bukan seluruh koleksi. Hindari kasus penggunaan yang mengharuskan Anda mengambil seluruh koleksi multi-GB secara atomik dalam perintah yang sama. Salah satu contohnya adalah menggunakan perintah HGET atau HMGET, bukan HGETALL di koleksi hash.
# Konfigurasi klien selada (Valkey dan Redis OSS)
Bagian ini menjelaskan opsi konfigurasi Java dan Lettuce yang direkomendasikan, dan bagaimana penerapannya pada ElastiCache cluster.
Rekomendasi di bagian ini diuji dengan Lettuce versi 6.2.2.
**Topics**
+ [Contoh: Konfigurasi selada untuk mode cluster, TLS diaktifkan](BestPractices.Clients-lettuce-cme.md)
+ [Contoh: Konfigurasi selada untuk mode cluster dinonaktifkan, TLS diaktifkan](BestPractices.Clients-lettuce-cmd.md)
**TTL cache DNS Java**
Mesin virtual Java (JVM) menyimpan cache pencarian nama DNS. Ketika JVM menyelesaikan nama host ke alamat IP, itu menyimpan alamat IP untuk jangka waktu tertentu, yang dikenal sebagai (TTL). *time-to-live*
Pilihan nilai TTL merupakan kompromi antara latensi dan responsivitas terhadap perubahan. Dengan lebih pendek TTLs, penyelesai DNS melihat pembaruan di DNS cluster lebih cepat. Hal ini dapat membuat aplikasi Anda lebih cepat dalam merespons penggantian atau alur kerja lain yang dialami klaster Anda. Namun, jika TTL terlalu rendah, hal ini meningkatkan volume kueri, yang dapat meningkatkan latensi aplikasi Anda. Meskipun tidak ada nilai TTL yang benar, sebaiknya pertimbangkan lama waktu yang sesuai bagi Anda untuk menunggu perubahan berlaku saat menetapkan nilai TTL Anda.
Karena ElastiCache node menggunakan entri nama DNS yang mungkin berubah, kami sarankan Anda mengonfigurasi JVM Anda dengan TTL rendah 5 hingga 10 detik. Hal ini dapat memastikan bahwa ketika alamat IP simpul berubah, aplikasi Anda dapat menerima dan menggunakan alamat IP baru sumber daya dengan mengueri ulang DNS.
Pada beberapa konfigurasi Java, TTL default JVM diatur untuk tidak pernah menyegarkan entri DNS hingga JVM dimulai ulang.
Untuk detail tentang cara mengatur TTL JVM Anda, lihat [How to set the JVM TTL](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-jvm-ttl.html#how-to-set-the-jvm-ttl).
**Versi Lettuce**
Sebaiknya gunakan Lettuce versi 6.2.2 atau versi yang lebih baru.
**Titik akhir**
Saat Anda menggunakan klaster dengan mode klaster diaktifkan, atur `redisUri` ke titik akhir konfigurasi klaster. Pencarian DNS untuk URI ini menampilkan daftar semua simpul yang tersedia di klaster, dan diresolusi secara acak ke salah satu simpul selama inisialisasi klaster. Untuk detail selengkapnya tentang cara kerja penyegaran topologi, lihat *dynamicRefreshResources*nanti dalam topik ini.
**SocketOption**
Aktifkan [KeepAlive](https://lettuce.io/core/release/api/io/lettuce/core/SocketOptions.KeepAliveOptions.html). Mengaktifkan opsi ini akan mengurangi kebutuhan untuk menangani koneksi yang gagal selama runtime perintah.
Pastikan Anda menetapkan [Waktu habis koneksi](https://lettuce.io/core/release/api/io/lettuce/core/SocketOptions.Builder.html#connectTimeout-java.time.Duration-) berdasarkan persyaratan aplikasi dan beban kerja Anda. Untuk informasi selengkapnya, lihat bagian Waktu habis dalam topik ini.
**ClusterClientOption: Mode Cluster Opsi klien yang diaktifkan**
Aktifkan [AutoReconnect](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterClientOptions.Builder.html#autoReconnect-boolean-)saat koneksi terputus.
Atur [CommandTimeout](https://lettuce.io/core/release/api/io/lettuPrce/core/RedisURI.html#getTimeout--). Untuk detail selengkapnya, lihat bagian Waktu habis dalam topik ini.
Atur [nodeFilter](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterClientOptions.Builder.html#nodeFilter-java.util.function.Predicate-) untuk memfilter simpul yang gagal dari topologi. Lettuce menyimpan semua simpul yang ditemukan di output 'simpul klaster' (termasuk simpul dengan status PFAIL/FAIL) di 'partisi' klien (juga dikenal sebagai serpihan). Selama proses pembuatan topologi klaster, Lettuce mencoba terhubung ke semua simpul partisi. Perilaku Lettuce yang menambahkan simpul yang gagal ini dapat menyebabkan kesalahan koneksi (atau peringatan) ketika simpul diganti karena alasan apa pun.
Misalnya, setelah failover selesai dan klaster memulai proses pemulihan, sementara clusterTopology sedang diperbarui, peta simpul bus klaster memiliki periode waktu singkat ketika simpul yang nonaktif dicantumkan sebagai simpul FAIL, sebelum sepenuhnya dihapus dari topologi. Selama periode ini, klien Selada menganggapnya sebagai simpul yang sehat dan terus terhubung dengannya. Hal ini menyebabkan kegagalan setelah percobaan kembali habis.
Misalnya:
```
final ClusterClientOptions clusterClientOptions =
ClusterClientOptions.builder()
... // other options
.nodeFilter(it ->
! (it.is(RedisClusterNode.NodeFlag.FAIL)
|| it.is(RedisClusterNode.NodeFlag.EVENTUAL_FAIL)
|| it.is(RedisClusterNode.NodeFlag.HANDSHAKE)
|| it.is(RedisClusterNode.NodeFlag.NOADDR)))
.validateClusterNodeMembership(false)
.build();
redisClusterClient.setOptions(clusterClientOptions);
```
**catatan**
Pemfilteran node paling baik digunakan dengan DynamicRefreshSources set ke true. Sebaliknya, jika tampilan topologi diambil dari satu simpul seed yang bermasalah, yang melihat simpul primer dari serpihan tertentu sebagai simpul yang mengalami kegagalan, pemfilteran tersebut akan memfilter simpul primer ini, sehingga akan mengakibatkan slot tidak tercakup. Memiliki beberapa node benih (kapan DynamicRefreshSources benar) mengurangi kemungkinan masalah ini, karena setidaknya beberapa node benih harus memiliki tampilan topologi yang diperbarui setelah failover dengan primer yang baru dipromosikan.
**ClusterTopologyRefreshOptions: Opsi untuk mengontrol penyegaran topologi cluster dari klien Cluster Mode Enabled**
**catatan**
Klaster dengan mode klaster dinonaktifkan tidak mendukung perintah penemuan klaster dan tidak kompatibel dengan semua fungsionalitas penemuan topologi dinamis klien.
Mode cluster dinonaktifkan dengan ElastiCache tidak kompatibel dengan Lettuce. `MasterSlaveTopologyRefresh` Sebagai gantinya, untuk mode klaster dinonaktifkan, Anda dapat mengonfigurasi `StaticMasterReplicaTopologyProvider` dan menyediakan titik akhir baca dan tulis klaster.
Untuk informasi selengkapnya tentang menghubungkan ke klaster dengan mode klaster dinonaktifkan, lihat [Menemukan Titik Akhir Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.Redis).
Jika Anda ingin menggunakan fungsionalitas penemuan topologi dinamis Lettuce, Anda dapat membuat klaster dengan mode klaster diaktifkan dengan konfigurasi serpihan yang sama dengan klaster yang ada. Namun, untuk klaster dengan mode klaster diaktifkan, sebaiknya konfigurasi setidaknya 3 serpihan dengan minimal 1 replika untuk mendukung failover cepat.
Aktifkan [enablePeriodicRefresh](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.Builder.html#enablePeriodicRefresh-java.time.Duration-). Opsi ini memungkinkan pembaruan topologi klaster berkala sehingga klien memperbarui topologi klaster dalam interval refreshPeriod (default: 60 detik). Ketika opsi ini dinonaktifkan, klien memperbarui topologi klaster hanya ketika kesalahan terjadi ketika klien tersebut mencoba menjalankan perintah terhadap klaster.
Dengan mengaktifkan opsi ini, Anda dapat mengurangi latensi yang terkait dengan penyegaran topologi klaster dengan menambahkan pekerjaan ini ke tugas latar belakang. Saat penyegaran topologi dilakukan dalam pekerjaan latar belakang, prosesnya bisa agak lambat untuk klaster yang memiliki banyak simpul. Hal ini karena semua simpul sedang dikueri untuk mendapatkan tampilan klaster yang paling terbaru. Jika Anda menjalankan klaster dalam jumlah besar, Anda sebaiknya menambah periodenya.
Aktifkan [enableAllAdaptiveRefreshTriggers](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.Builder.html#enableAllAdaptiveRefreshTriggers--). Hal ini memungkinkan penyegaran topologi adaptif yang menggunakan semua [pemicu](https://lettuce.io/core/6.1.6.RELEASE/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.RefreshTrigger.html): MOVED\$1REDIRECT, ASK\$1REDIRECT, PERSISTENT\$1RECONNECTS, UNCOVERED\$1SLOT, UNKNOWN\$1NODE. Pemicu penyegaran adaptif memulai pembaruan tampilan topologi berdasarkan peristiwa yang terjadi selama operasi klaster Valkey atau Redis OSS. Mengaktifkan opsi ini akan membuat penyegaran topologi langsung dilakukan ketika salah satu pemicu sebelumnya terjadi. Penyegaran yang dipicu secara adaptif dibatasi lajunya menggunakan waktu habis karena peristiwa dapat terjadi dalam skala besar (waktu habis default di antara pembaruan: 30).
Aktifkan [closeStaleConnections](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.Builder.html#closeStaleConnections-boolean-). Hal ini memungkinkan penutupan koneksi yang sudah tidak berlaku saat menyegarkan topologi klaster. Itu hanya berlaku jika [ClusterTopologyRefreshOptions. isPeriodicRefreshEnabled ()](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.html#isPeriodicRefreshEnabled--) benar. Ketika diaktifkan, klien dapat menutup koneksi yang tidak berlaku dan membuat yang baru di latar belakang. Hal ini mengurangi kebutuhan untuk menangani koneksi yang gagal selama runtime perintah.
Aktifkan [dynamicRefreshResources](https://lettuce.io/core/release/api/io/lettuce/core/cluster/ClusterTopologyRefreshOptions.Builder.html#dynamicRefreshSources-boolean-). Kami merekomendasikan dynamicRefreshResources untuk mengaktifkan cluster kecil, dan menonaktifkannya untuk cluster besar. dynamicRefreshResourcesmemungkinkan menemukan node cluster dari node benih yang disediakan (misalnya, titik akhir konfigurasi cluster). Ia menggunakan semua simpul yang ditemukan sebagai sumber untuk menyegarkan topologi klaster.
Menggunakan dynamic refresh akan mengueri semua simpul yang ditemukan untuk topologi klaster dan mencoba memilih tampilan klaster yang paling akurat. Jika diatur ke false, hanya simpul seed awal yang digunakan sebagai sumber untuk penemuan topologi, dan jumlah klien diperoleh hanya untuk simpul seed awal. Saat dinonaktifkan, jika titik akhir konfigurasi klaster diresolusi ke simpul yang gagal, percobaan untuk menyegarkan tampilan klaster akan gagal dan menyebabkan pengecualian. Skenario ini dapat terjadi karena dibutuhkan beberapa waktu hingga entri simpul yang gagal dihapus dari titik akhir konfigurasi klaster. Oleh karena itu, titik akhir konfigurasi masih dapat diresolusi secara acak ke simpul yang gagal untuk waktu yang singkat.
Namun, ketika diaktifkan, kita menggunakan semua simpul klaster yang diterima dari tampilan klaster untuk mengueri tampilannya saat ini. Karena kita memfilter simpul yang gagal dari tampilan tersebut, penyegaran topologi akan berhasil. Namun, kapan dynamicRefreshSources benar, Lettuce menanyakan semua node untuk mendapatkan tampilan cluster, dan kemudian membandingkan hasilnya. Jadi, klaster dengan banyak simpul bisa menghabiskan banyak daya komputasi. Sebaiknya nonaktifkan fitur ini untuk klaster dengan banyak simpul.
```
final ClusterTopologyRefreshOptions topologyOptions =
ClusterTopologyRefreshOptions.builder()
.enableAllAdaptiveRefreshTriggers()
.enablePeriodicRefresh()
.dynamicRefreshSources(true)
.build();
```
**ClientResources**
Konfigurasikan [DnsResolver](https://lettuce.io/core/release/api/io/lettuce/core/resource/DefaultClientResources.Builder.html#dnsResolver-io.lettuce.core.resource.DnsResolver-)dengan [DirContextDnsResolver](https://lettuce.io/core/release/api/io/lettuce/core/resource/DirContextDnsResolver.html). DNS resolver didasarkan pada com.sun.jndi.dns Java. DnsContextFactory.
Konfigurasikan [reconnectDelay](https://lettuce.io/core/release/api/io/lettuce/core/resource/DefaultClientResources.Builder.html#reconnectDelay-io.lettuce.core.resource.Delay-) dengan backoff eksponensial dan jitter penuh. Lettuce memiliki mekanisme percobaan ulang bawaan berdasarkan strategi backoff eksponensial. Untuk detailnya, lihat [Exponential Backoff dan Jitter](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter) di Blog Arsitektur. AWS Untuk informasi lebih lanjut tentang pentingnya memiliki strategi backoff coba lagi, lihat bagian logika backoff dari [posting blog Praktik Terbaik di Blog](https://aws.amazon.com/blogs/database/best-practices-redis-clients-and-amazon-elasticache-for-redis/) Database. AWS
```
ClientResources clientResources = DefaultClientResources.builder()
.dnsResolver(new DirContextDnsResolver())
.reconnectDelay(
Delay.fullJitter(
Duration.ofMillis(100), // minimum 100 millisecond delay
Duration.ofSeconds(10), // maximum 10 second delay
100, TimeUnit.MILLISECONDS)) // 100 millisecond base
.build();
```
**Batas Waktu**
Gunakan nilai waktu habis koneksi yang lebih rendah daripada waktu habis perintah Anda. Lettuce menggunakan pembuatan lazy connection. Jadi, jika waktu habis koneksi lebih tinggi dari waktu habis perintah, Anda dapat mengalami periode kegagalan persisten setelah penyegaran topologi jika Lettuce mencoba terhubung ke simpul yang tidak berkondisi baik dan waktu habis perintah selalu terlampaui.
Gunakan waktu habis perintah dinamis untuk perintah yang berbeda-beda. Sebaiknya tetapkan waktu habis perintah berdasarkan durasi perintah yang diharapkan. Misalnya, gunakan waktu habis yang lebih lama untuk perintah yang mengulangi beberapa kunci, seperti skrip FLUSHDB, FLUSHALL, KEYS, SMEMBERS, atau Lua. Gunakan waktu habis yang lebih pendek untuk perintah kunci tunggal, seperti SET, GET, dan HSET.
**catatan**
Waktu habis yang dikonfigurasi dalam contoh berikut adalah untuk pengujian yang menjalankan perintah SET/GET dengan kunci dan nilai hingga 20 byte. Waktu pemrosesan bisa lebih lama jika perintahnya kompleks atau kunci dan nilainya lebih besar. Anda harus mengatur waktu habis berdasarkan kasus penggunaan aplikasi Anda.
```
private static final Duration META_COMMAND_TIMEOUT = Duration.ofMillis(1000);
private static final Duration DEFAULT_COMMAND_TIMEOUT = Duration.ofMillis(250);
// Socket connect timeout should be lower than command timeout for Lettuce
private static final Duration CONNECT_TIMEOUT = Duration.ofMillis(100);
SocketOptions socketOptions = SocketOptions.builder()
.connectTimeout(CONNECT_TIMEOUT)
.build();
class DynamicClusterTimeout extends TimeoutSource {
private static final Set META_COMMAND_TYPES = ImmutableSet.builder()
.add(CommandType.FLUSHDB)
.add(CommandType.FLUSHALL)
.add(CommandType.CLUSTER)
.add(CommandType.INFO)
.add(CommandType.KEYS)
.build();
private final Duration defaultCommandTimeout;
private final Duration metaCommandTimeout;
DynamicClusterTimeout(Duration defaultTimeout, Duration metaTimeout)
{
defaultCommandTimeout = defaultTimeout;
metaCommandTimeout = metaTimeout;
}
@Override
public long getTimeout(RedisCommand command) {
if (META_COMMAND_TYPES.contains(command.getType())) {
return metaCommandTimeout.toMillis();
}
return defaultCommandTimeout.toMillis();
}
}
// Use a dynamic timeout for commands, to avoid timeouts during
// cluster management and slow operations.
TimeoutOptions timeoutOptions = TimeoutOptions.builder()
.timeoutSource(
new DynamicClusterTimeout(DEFAULT_COMMAND_TIMEOUT, META_COMMAND_TIMEOUT))
.build();
```
# Contoh: Konfigurasi selada untuk mode cluster, TLS diaktifkan
**catatan**
Timeout dalam contoh berikut adalah untuk tes yang menjalankan SET/GET perintah dengan kunci dan nilai hingga 20 byte. Waktu pemrosesan bisa lebih lama jika perintahnya kompleks atau kunci dan nilainya lebih besar. Anda harus mengatur waktu habis berdasarkan kasus penggunaan aplikasi Anda.
```
// Set DNS cache TTL
public void setJVMProperties() {
java.security.Security.setProperty("networkaddress.cache.ttl", "10");
}
private static final Duration META_COMMAND_TIMEOUT = Duration.ofMillis(1000);
private static final Duration DEFAULT_COMMAND_TIMEOUT = Duration.ofMillis(250);
// Socket connect timeout should be lower than command timeout for Lettuce
private static final Duration CONNECT_TIMEOUT = Duration.ofMillis(100);
// Create RedisURI from the cluster configuration endpoint
clusterConfigurationEndpoint = // TODO: add your cluster configuration endpoint
final RedisURI redisUriCluster =
RedisURI.Builder.redis(clusterConfigurationEndpoint)
.withPort(6379)
.withSsl(true)
.build();
// Configure the client's resources
ClientResources clientResources = DefaultClientResources.builder()
.reconnectDelay(
Delay.fullJitter(
Duration.ofMillis(100), // minimum 100 millisecond delay
Duration.ofSeconds(10), // maximum 10 second delay
100, TimeUnit.MILLISECONDS)) // 100 millisecond base
.dnsResolver(new DirContextDnsResolver())
.build();
// Create a cluster client instance with the URI and resources
RedisClusterClient redisClusterClient =
RedisClusterClient.create(clientResources, redisUriCluster);
// Use a dynamic timeout for commands, to avoid timeouts during
// cluster management and slow operations.
class DynamicClusterTimeout extends TimeoutSource {
private static final Set META_COMMAND_TYPES = ImmutableSet.builder()
.add(CommandType.FLUSHDB)
.add(CommandType.FLUSHALL)
.add(CommandType.CLUSTER)
.add(CommandType.INFO)
.add(CommandType.KEYS)
.build();
private final Duration metaCommandTimeout;
private final Duration defaultCommandTimeout;
DynamicClusterTimeout(Duration defaultTimeout, Duration metaTimeout)
{
defaultCommandTimeout = defaultTimeout;
metaCommandTimeout = metaTimeout;
}
@Override
public long getTimeout(RedisCommand command) {
if (META_COMMAND_TYPES.contains(command.getType())) {
return metaCommandTimeout.toMillis();
}
return defaultCommandTimeout.toMillis();
}
}
TimeoutOptions timeoutOptions = TimeoutOptions.builder()
.timeoutSource(new DynamicClusterTimeout(DEFAULT_COMMAND_TIMEOUT, META_COMMAND_TIMEOUT))
.build();
// Configure the topology refreshment options
final ClusterTopologyRefreshOptions topologyOptions =
ClusterTopologyRefreshOptions.builder()
.enableAllAdaptiveRefreshTriggers()
.enablePeriodicRefresh()
.dynamicRefreshSources(true)
.build();
// Configure the socket options
final SocketOptions socketOptions =
SocketOptions.builder()
.connectTimeout(CONNECT_TIMEOUT)
.keepAlive(true)
.build();
// Configure the client's options
final ClusterClientOptions clusterClientOptions =
ClusterClientOptions.builder()
.topologyRefreshOptions(topologyOptions)
.socketOptions(socketOptions)
.autoReconnect(true)
.timeoutOptions(timeoutOptions)
.nodeFilter(it ->
! (it.is(RedisClusterNode.NodeFlag.FAIL)
|| it.is(RedisClusterNode.NodeFlag.EVENTUAL_FAIL)
|| it.is(RedisClusterNode.NodeFlag.NOADDR)))
.validateClusterNodeMembership(false)
.build();
redisClusterClient.setOptions(clusterClientOptions);
// Get a connection
final StatefulRedisClusterConnection connection =
redisClusterClient.connect();
// Get cluster sync/async commands
RedisAdvancedClusterCommands sync = connection.sync();
RedisAdvancedClusterAsyncCommands async = connection.async();
```
# Contoh: Konfigurasi selada untuk mode cluster dinonaktifkan, TLS diaktifkan
**catatan**
Timeout dalam contoh berikut adalah untuk tes yang menjalankan SET/GET perintah dengan kunci dan nilai hingga 20 byte. Waktu pemrosesan bisa lebih lama jika perintahnya kompleks atau kunci dan nilainya lebih besar. Anda harus mengatur waktu habis berdasarkan kasus penggunaan aplikasi Anda.
```
// Set DNS cache TTL
public void setJVMProperties() {
java.security.Security.setProperty("networkaddress.cache.ttl", "10");
}
private static final Duration META_COMMAND_TIMEOUT = Duration.ofMillis(1000);
private static final Duration DEFAULT_COMMAND_TIMEOUT = Duration.ofMillis(250);
// Socket connect timeout should be lower than command timeout for Lettuce
private static final Duration CONNECT_TIMEOUT = Duration.ofMillis(100);
// Create RedisURI from the primary/reader endpoint
clusterEndpoint = // TODO: add your node endpoint
RedisURI redisUriStandalone =
RedisURI.Builder.redis(clusterEndpoint).withPort(6379).withSsl(true).withDatabase(0).build();
ClientResources clientResources =
DefaultClientResources.builder()
.dnsResolver(new DirContextDnsResolver())
.reconnectDelay(
Delay.fullJitter(
Duration.ofMillis(100), // minimum 100 millisecond delay
Duration.ofSeconds(10), // maximum 10 second delay
100,
TimeUnit.MILLISECONDS)) // 100 millisecond base
.build();
// Use a dynamic timeout for commands, to avoid timeouts during
// slow operations.
class DynamicTimeout extends TimeoutSource {
private static final Set META_COMMAND_TYPES = ImmutableSet.builder()
.add(CommandType.FLUSHDB)
.add(CommandType.FLUSHALL)
.add(CommandType.INFO)
.add(CommandType.KEYS)
.build();
private final Duration metaCommandTimeout;
private final Duration defaultCommandTimeout;
DynamicTimeout(Duration defaultTimeout, Duration metaTimeout)
{
defaultCommandTimeout = defaultTimeout;
metaCommandTimeout = metaTimeout;
}
@Override
public long getTimeout(RedisCommand command) {
if (META_COMMAND_TYPES.contains(command.getType())) {
return metaCommandTimeout.toMillis();
}
return defaultCommandTimeout.toMillis();
}
}
TimeoutOptions timeoutOptions = TimeoutOptions.builder()
.timeoutSource(new DynamicTimeout(DEFAULT_COMMAND_TIMEOUT, META_COMMAND_TIMEOUT))
.build();
final SocketOptions socketOptions =
SocketOptions.builder().connectTimeout(CONNECT_TIMEOUT).keepAlive(true).build();
ClientOptions clientOptions =
ClientOptions.builder().timeoutOptions(timeoutOptions).socketOptions(socketOptions).build();
RedisClient redisClient = RedisClient.create(clientResources, redisUriStandalone);
redisClient.setOptions(clientOptions);
```
## Mengkonfigurasi protokol pilihan untuk cluster tumpukan ganda (Valkey dan Redis OSS)
Untuk mode cluster diaktifkan Valkey atau Redis OSS cluster, Anda dapat mengontrol klien protokol yang akan digunakan untuk terhubung ke node di cluster dengan parameter IP Discovery. Parameter IP Discovery dapat diatur ke salah satu IPv4 atau IPv6.
Untuk cluster Valkey atau Redis OSS, parameter penemuan IP menetapkan protokol IP yang digunakan dalam [slot cluster (), pecahan cluster ()](https://valkey.io/commands/cluster-slots/)[, dan node [cluster](https://valkey.io/commands/cluster-nodes/) ()](https://valkey.io/commands/cluster-shards/) output. Perintah tersebut digunakan oleh klien untuk menemukan topologi klaster. Klien menggunakan perintah IPs in theses untuk terhubung ke node lain di cluster.
Perubahan pada Penemuan IP tidak akan mengakibatkan waktu henti untuk klien yang terhubung. Namun, perubahan ini akan memakan waktu untuk disebarkan. Untuk menentukan kapan perubahan telah sepenuhnya disebarkan untuk Cluster Valkey atau Redis OSS, pantau output dari. `cluster slots` Setelah semua node dikembalikan oleh laporan perintah slot cluster IPs dengan protokol baru, perubahan telah selesai menyebar.
Contoh dengan Redis-Py:
```
cluster = RedisCluster(host="xxxx", port=6379)
target_type = IPv6Address # Or IPv4Address if changing to IPv4
nodes = set()
while len(nodes) == 0 or not all((type(ip_address(host)) is target_type) for host in nodes):
nodes = set()
# This refreshes the cluster topology and will discovery any node updates.
# Under the hood it calls cluster slots
cluster.nodes_manager.initialize()
for node in cluster.get_nodes():
nodes.add(node.host)
self.logger.info(nodes)
time.sleep(1)
```
Contoh dengan Lettuce:
```
RedisClusterClient clusterClient = RedisClusterClient.create(RedisURI.create("xxxx", 6379));
Class targetProtocolType = Inet6Address.class; // Or Inet4Address.class if you're switching to IPv4
Set nodes;
do {
// Check for any changes in the cluster topology.
// Under the hood this calls cluster slots
clusterClient.refreshPartitions();
Set nodes = new HashSet<>();
for (RedisClusterNode node : clusterClient.getPartitions().getPartitions()) {
nodes.add(node.getUri().getHost());
}
Thread.sleep(1000);
} while (!nodes.stream().allMatch(node -> {
try {
return finalTargetProtocolType.isInstance(InetAddress.getByName(node));
} catch (UnknownHostException ignored) {}
return false;
}));
```
# Praktik terbaik untuk klien (Memcached)
Pelajari praktik terbaik untuk skenario umum dengan ElastiCache klaster Memcached.
**Topics**
+ [Mengkonfigurasi ElastiCache klien Anda untuk penyeimbangan beban yang efisien (Memcached)](BestPractices.LoadBalancing.md)
+ [Klien yang divalidasi dengan Memcached](network-type-validated-clients-memcached.md)
+ [Mengkonfigurasi protokol pilihan untuk cluster tumpukan ganda (Memcached)](network-type-configuring-dual-stack-memcached.md)
# Mengkonfigurasi ElastiCache klien Anda untuk penyeimbangan beban yang efisien (Memcached)
**catatan**
Bagian ini berlaku untuk cluster Memcached multi-node berbasis node.
Untuk secara efektif menggunakan beberapa node ElastiCache Memcached, Anda harus dapat menyebarkan kunci cache Anda di seluruh node. Cara sederhana untuk memuat keseimbangan cluster dengan *n* node adalah dengan menghitung hash kunci objek dan mod hasilnya dengan *n*:`hash(key) mod n`. Nilai yang dihasilkan (0 sampai *n*–1) adalah jumlah simpul tempat Anda menempatkan objek.
Pendekatan ini sederhana dan berfungsi dengan baik selama jumlah simpul (*n*) adalah konstan. Namun, setiap kali Anda menambahkan atau menghapus simpul dari klaster, jumlah kunci yang perlu dipindahkan adalah *(n - 1)/n* (dengan *n* adalah jumlah baru simpul). Jadi, pendekatan ini menghasilkan sejumlah besar kunci yang dipindahkan, yang berarti ada sejumlah besar cache miss awal, terutama seiring bertambahnya jumlah simpul. Dalam kasus terbaik, penskalaan dari 1 ke 2 simpul menghasilkan pemindahan kunci (2-1) / 2 (50 persen). Penskalaan dari 9 ke 10 simpul menghasilkan pemindahan kunci (10–1)/10 (90 persen). Jika Anda menaikkan skala karena lonjakan lalu lintas, Anda tidak ingin memiliki banyak cache miss. Banyaknya jumlah cache miss akan menghasilkan hit pada basis data, yang sudah kelebihan beban karena lonjakan lalu lintas.
Solusi untuk dilema ini adalah melakukan hashing secara konsisten. Hashing konsisten menggunakan algoritma sehingga setiap kali simpul ditambahkan atau dihapus dari klaster, jumlah kunci yang harus dipindahkan adalah kira-kira *1 / n* (dengan *n* adalah jumlah baru simpul). Dalam kasus terburuk, penskalaan dari 1 ke 2 simpul menghasilkan pemindahan kunci 1/2 (50 persen). Penskalaan dari 9 ke 10 simpul menghasilkan pemindahan kunci 1/10 (10 persen).
Sebagai pengguna, Anda mengontrol jenis algoritma hashing yang digunakan untuk klaster multisimpul. Sebaiknya konfigurasikan klien Anda untuk menggunakan hashing konsisten. Untungnya, ada banyak pustaka klien Memcached dalam bahasa yang paling populer yang menerapkan hashing konsisten. Periksa dokumentasi untuk pustaka yang Anda gunakan untuk melihat apakah mendukung hashing konsisten dan cara menerapkannya.
Jika Anda bekerja di Java, PHP, atau .NET, kami sarankan Anda menggunakan salah satu pustaka ElastiCache klien Amazon.
## Hashing konsisten Menggunakan Java
Klien Java ElastiCache Memcached didasarkan pada klien Java spymemcached open-source, yang memiliki kemampuan hashing yang konsisten bawaan. Pustaka menyertakan KetamaConnectionFactory kelas yang mengimplementasikan hashing yang konsisten. Secara default, hashing konsisten dinonaktifkan pada spymemcached.
Untuk informasi lebih lanjut, lihat KetamaConnectionFactory dokumentasi di [KetamaConnectionFactory](https://github.com/RTBHOUSE/spymemcached/blob/master/src/main/java/net/spy/memcached/KetamaConnectionFactory.java).
## Hashing konsisten menggunakan PHP dengan Memcached
Klien PHP ElastiCache Memcached adalah pembungkus di sekitar perpustakaan PHP Memcached bawaan. Secara default, hashing konsisten dinonaktifkan oleh pustaka PHP Memcached.
Gunakan kode berikut untuk mengaktifkan hashing konsisten.
```
$m = new Memcached();
$m->setOption(Memcached::OPT_DISTRIBUTION, Memcached::DISTRIBUTION_CONSISTENT);
```
Selain kode sebelumnya, sebaiknya Anda juga mengaktifkan `memcached.sess_consistent_hash` pada file php.ini Anda.
[Untuk informasi selengkapnya, lihat dokumentasi konfigurasi run-time untuk PHP Memcached di http://php. net/manual/en/memcached.configuration.php](http://php.net/manual/en/memcached.configuration.php). Perhatikan secara khusus parameter `memcached.sess_consistent_hash`.
## Hashing konsisten menggunakan .NET dengan Memcached
Klien ElastiCache Memcached .NET adalah pembungkus di sekitar Enyim Memcached. Secara default, hashing konsisten diaktifkan oleh klien Enyim Memcached.
Untuk informasi selengkapnya, lihat `memcached/locator` dokumentasi di [https://github.com/enyim/EnyimMemcached/wiki/MemcachedClient-Configuration\$1 user-content-memcachedlocator](https://github.com/enyim/EnyimMemcached/wiki/MemcachedClient-Configuration#user-content-memcachedlocator).
# Klien yang divalidasi dengan Memcached
Klien berikut secara khusus telah divalidasi untuk bekerja dengan semua konfigurasi jenis jaringan yang didukung untuk Memcached.
Klien yang Divalidasi:
+ [AWS ElastiCache Klien Cluster Memcached untuk Php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php) [- Versi\$1 3.6.2](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php/tree/v3.2.0)
+ [AWS ElastiCache Cluster Client Memcached untuk Java](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-java) - Master terbaru di Github
# Mengkonfigurasi protokol pilihan untuk cluster tumpukan ganda (Memcached)
Untuk klaster Memcached, Anda dapat mengontrol protokol yang akan digunakan klien untuk terhubung ke simpul di klaster dengan parameter Penemuan IP. Parameter IP Discovery dapat diatur ke salah satu IPv4 atau IPv6.
Parameter Penemuan IP mengontrol protokol IP yang digunakan dalam output config get cluster. Yang pada gilirannya akan menentukan protokol IP yang digunakan oleh klien yang mendukung penemuan otomatis ElastiCache untuk klaster Memcached.
Perubahan pada Penemuan IP tidak akan mengakibatkan waktu henti untuk klien yang terhubung. Namun, perubahan ini akan memakan waktu untuk disebarkan.
Pantau output `getAvailableNodeEndPoints` untuk Java, sementara untuk Php, pantau output dari `getServerList`. Setelah output dari fungsi-fungsi ini melaporkan IPs semua node di cluster yang menggunakan protokol yang diperbarui, perubahan telah selesai menyebar.
Contoh Java:
```
MemcachedClient client = new MemcachedClient(new InetSocketAddress("xxxx", 11211));
Class targetProtocolType = Inet6Address.class; // Or Inet4Address.class if you're switching to IPv4
Set nodes;
do {
nodes = client.getAvailableNodeEndPoints().stream().map(NodeEndPoint::getIpAddress).collect(Collectors.toSet());
Thread.sleep(1000);
} while (!nodes.stream().allMatch(node -> {
try {
return finalTargetProtocolType.isInstance(InetAddress.getByName(node));
} catch (UnknownHostException ignored) {}
return false;
}));
```
Contoh Php:
```
$client = new Memcached;
$client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$client->addServer("xxxx", 11211);
$nodes = [];
$target_ips_count = 0;
do {
# The PHP memcached client only updates the server list if the polling interval has expired and a
# command is sent
$client->get('test');
$nodes = $client->getServerList();
sleep(1);
$target_ips_count = 0;
// For IPv4 use FILTER_FLAG_IPV4
$target_ips_count = count(array_filter($nodes, function($node) { return filter_var($node["ipaddress"], FILTER_VALIDATE_IP, FILTER_FLAG_IPV6); }));
} while (count($nodes) !== $target_ips_count);
```
Setiap koneksi klien yang ada yang dibuat sebelum Penemuan IP diperbarui akan tetap terhubung menggunakan protokol lama. Semua klien yang divalidasi akan secara otomatis terhubung kembali ke klaster menggunakan protokol IP baru setelah perubahan terdeteksi dalam output perintah penemuan klaster. Namun, hal ini tergantung pada implementasi klien.
## TLS mengaktifkan cluster tumpukan ElastiCache ganda
Ketika TLS diaktifkan untuk cluster fungsi penemuan cluster (`cluster slots`,`cluster shards`, dan `cluster nodes` untuk Redis) atau `config get cluster` untuk Memcached mengembalikan ElastiCache nama host alih-alih. IPs Nama host kemudian digunakan sebagai pengganti IPs untuk terhubung ke ElastiCache cluster dan melakukan jabat tangan TLS. Hal ini berarti bahwa klien tidak akan terpengaruh oleh parameter Penemuan IP. Untuk klaster dengan TLS diaktifkan, parameter Penemuan IP tidak berpengaruh pada protokol IP pilihan. Sebagai gantinya, protokol IP yang digunakan akan ditentukan berdasarkan protokol IP mana yang lebih dipilih klien saat meresolusi nama host DNS.
**Klien Java**
Saat menghubungkan dari lingkungan Java yang mendukung keduanya IPv4 dan IPv6, Java secara default akan IPv4 lebih memilih IPv6 untuk kompatibilitas mundur. Namun, preferensi protokol IP dapat dikonfigurasi melalui argumen JVM. Untuk memilih IPv4, JVM menerima `-Djava.net.preferIPv4Stack=true` dan memilih set. IPv6 `-Djava.net.preferIPv6Stack=true` Pengaturan `-Djava.net.preferIPv4Stack=true` berarti bahwa JVM tidak akan lagi membuat koneksi apa pun IPv6 . **Untuk Valkey atau Redis OSS, ini termasuk aplikasi OSS non-Valkey dan non-Redis lainnya.**
**Preferensi Tingkat Host**
Secara umum, jika klien atau runtime klien tidak menyediakan opsi konfigurasi untuk mengatur preferensi protokol IP, saat melakukan resolusi DNS, protokol IP akan bergantung pada konfigurasi host. Secara default, sebagian besar host IPv6 lebih suka daripada IPv4 tetapi preferensi ini dapat dikonfigurasi di tingkat host. Ini akan memengaruhi semua permintaan DNS dari host itu, bukan hanya permintaan ke ElastiCache cluster.
**Host Linux**
Untuk Linux, preferensi protokol IP dapat dikonfigurasi dengan mengubah file `gai.conf`. File `gai.conf` dapat ditemukan dalam `/etc/gai.conf`. Jika tidak ada `gai.conf` yang ditentukan, maka contohnya akan tersedia di `/usr/share/doc/glibc-common-x.xx/gai.conf` yang dapat disalin ke `/etc/gai.conf` lalu konfigurasi default-nya harus di-uncommenting. Untuk memperbarui konfigurasi agar lebih disukai IPv4 saat menghubungkan ke ElastiCache kluster, perbarui prioritas untuk rentang CIDR yang mencakup cluster berada di atas prioritas IPs untuk koneksi default. IPv6 Secara default IPv6 koneksi memiliki prioritas 40. Misalnya, dengan asumsi cluster terletak di subnet dengan CIDR 172.31.0. 0:0 /16, konfigurasi di bawah ini akan menyebabkan klien lebih memilih koneksi ke cluster itu. IPv4
```
label ::1/128 0
label ::/0 1
label 2002::/16 2
label ::/96 3
label ::ffff:0:0/96 4
label fec0::/10 5
label fc00::/7 6
label 2001:0::/32 7
label ::ffff:172.31.0.0/112 8
#
# This default differs from the tables given in RFC 3484 by handling
# (now obsolete) site-local IPv6 addresses and Unique Local Addresses.
# The reason for this difference is that these addresses are never
# NATed while IPv4 site-local addresses most probably are. Given
# the precedence of IPv6 over IPv4 (see below) on machines having only
# site-local IPv4 and IPv6 addresses a lookup for a global address would
# see the IPv6 be preferred. The result is a long delay because the
# site-local IPv6 addresses cannot be used while the IPv4 address is
# (at least for the foreseeable future) NATed. We also treat Teredo
# tunnels special.
#
# precedence
# Add another rule to the RFC 3484 precedence table. See section 2.1
# and 10.3 in RFC 3484. The default is:
#
precedence ::1/128 50
precedence ::/0 40
precedence 2002::/16 30
precedence ::/96 20
precedence ::ffff:0:0/96 10
precedence ::ffff:172.31.0.0/112 100
```
Rincian lebih lanjut tentang `gai.conf` tersedia di [halaman manual Linux](https://man7.org/linux/man-pages/man5/gai.conf.5.html)
**Host Windows**
Proses untuk host Windows juga serupa. Untuk host Windows, Anda dapat menjalankan `netsh interface ipv6 set prefix CIDR_CONTAINING_CLUSTER_IPS PRECEDENCE LABEL`. Hal ini memiliki efek yang sama seperti mengubah file `gai.conf` pada host Linux.
Ini akan memperbarui kebijakan preferensi untuk memilih IPv4 koneksi daripada IPv6 koneksi untuk rentang CIDR yang ditentukan. Misalnya, dengan asumsi bahwa cluster berada dalam subnet dengan 172.31.0. 0:0 /16 CIDR mengeksekusi `netsh interface ipv6 set prefix ::ffff:172.31.0.0:0/112 100 15` akan menghasilkan tabel prioritas berikut yang akan menyebabkan klien lebih suka saat menghubungkan ke cluster. IPv4
```
C:\Users\Administrator>netsh interface ipv6 show prefixpolicies
Querying active state...
Precedence Label Prefix
---------- ----- --------------------------------
100 15 ::ffff:172.31.0.0:0/112
20 4 ::ffff:0:0/96
50 0 ::1/128
40 1 ::/0
30 2 2002::/16
5 5 2001::/32
3 13 fc00::/7
1 11 fec0::/10
1 12 3ffe::/16
1 3 ::/96
```
# Mengelola memori cadangan untuk Valkey dan Redis OSS
Memori cadangan adalah memori yang disisihkan untuk penggunaan nondata. Saat melakukan pencadangan atau failover, Valkey dan Redis OSS menggunakan memori yang tersedia untuk merekam operasi tulis ke cluster Anda saat data cluster sedang ditulis ke file.rdb. Jika tidak tersedia memori yang cukup untuk semua operasi tulis, proses tersebut akan gagal. Berikut ini, Anda dapat menemukan informasi tentang opsi untuk mengelola memori cadangan ElastiCache untuk Redis OSS dan cara menerapkan opsi tersebut.
**Topics**
+ [Berapa Banyak Memori Cadangan yang Anda Butuhkan?](#redis-memory-management-need)
+ [Parameter untuk Mengelola Memori Cadangan](#redis-memory-management-parameters)
+ [Menentukan Parameter Manajemen Memori Cadangan](#redis-reserved-memory-management-change)
## Berapa Banyak Memori Cadangan yang Anda Butuhkan?
Jika Anda menjalankan versi Redis OSS sebelum 2.8.22, cadangan lebih banyak memori untuk backup dan failovers daripada jika Anda menjalankan Redis OSS 2.8.22 atau yang lebih baru. Persyaratan ini disebabkan oleh berbagai cara yang ElastiCache untuk Redis OSS mengimplementasikan proses pencadangan. Aturan praktisnya adalah untuk mencadangkan setengah dari `maxmemory` nilai tipe node untuk overhead Redis OSS untuk versi sebelum 2.8.22, dan seperempat untuk Redis OSS versi 2.8.22 dan yang lebih baru.
Karena berbagai cara yang ElastiCache mengimplementasikan proses pencadangan dan replikasi, aturan praktisnya adalah mencadangkan 25% dari `maxmemory` nilai tipe node dengan menggunakan parameter. `reserved-memory-percent` Ini adalah nilai default dan direkomendasikan untuk sebagian besar kasus.
Ketika tipe instans mikro dan kecil burstable beroperasi mendekati `maxmemory` batas, mereka mungkin mengalami penggunaan swap. Untuk meningkatkan keandalan operasional pada jenis instans ini selama pencadangan, replikasi, dan lalu lintas tinggi, kami sarankan untuk meningkatkan nilai `reserved-memory-percent` parameter hingga 30% pada jenis instans kecil, dan hingga 50% pada jenis instans mikro.
Untuk beban kerja berat tulis pada ElastiCache cluster dengan tiering data, kami sarankan untuk meningkatkan `reserved-memory-percent` hingga 50% dari memori node yang tersedia.
Untuk informasi lain, lihat hal berikut:
+ [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md)
+ [Cara penerapan sinkronisasi dan pencadangan](Replication.Redis.Versions.md)
+ [Tingkatan data di ElastiCache](data-tiering.md)
## Parameter untuk Mengelola Memori Cadangan
Mulai 16 Maret 2017, Amazon ElastiCache menyediakan dua parameter yang saling eksklusif untuk mengelola memori Valkey atau Redis OSS Anda, dan. `reserved-memory` `reserved-memory-percent` Tak satu pun dari parameter ini merupakan bagian dari distribusi Valkey atau Redis OSS.
Bergantung pada kapan Anda menjadi ElastiCache pelanggan, satu atau yang lain dari parameter ini adalah parameter manajemen memori default. Parameter ini berlaku ketika Anda membuat cluster Valkey atau Redis OSS baru atau grup replikasi dan menggunakan grup parameter default.
+ Untuk pelanggan yang memulai sebelum 16 Maret 2017 - Saat Anda membuat cluster Redis OSS atau grup replikasi menggunakan grup parameter default, parameter manajemen memori Anda adalah. `reserved-memory` Dalam hal ini, memori cadangan adalah nol (0) byte.
+ Untuk pelanggan yang memulai pada atau setelah 16 Maret 2017 - Saat Anda membuat cluster Valkey atau Redis OSS atau grup replikasi menggunakan grup parameter default, parameter manajemen memori Anda adalah. `reserved-memory-percent` Dalam hal ini, 25 persen dari nilai `maxmemory` dari simpul Anda dicadangkan untuk tujuan nondata.
Setelah membaca tentang dua parameter manajemen memori Valkey atau Redis OSS, Anda mungkin lebih suka menggunakan salah satu yang bukan default Anda atau dengan nilai nondefault. Jika demikian, Anda dapat mengubah ke parameter manajemen memori cadangan yang lain.
Untuk mengubah nilai parameter tersebut, Anda dapat membuat grup parameter kustom dan mengubahnya untuk menggunakan parameter dan nilai manajemen memori pilihan Anda. Anda kemudian dapat menggunakan grup parameter kustom setiap kali Anda membuat cluster Valkey atau Redis OSS baru atau grup replikasi. Untuk klaster atau grup replikasi yang sudah ada, Anda dapat mengubahnya untuk menggunakan grup parameter kustom.
Untuk informasi selengkapnya, lihat berikut ini:
+ [Menentukan Parameter Manajemen Memori Cadangan](#redis-reserved-memory-management-change)
+ [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md)
+ [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md)
+ [Memodifikasi cluster ElastiCache](Clusters.Modify.md)
+ [Mengubah grup replikasi](Replication.Modify.md)
### Parameter reserved-memory
Sebelum 16 Maret 2017, semua ElastiCache untuk manajemen memori cadangan Redis OSS dilakukan dengan menggunakan parameter. `reserved-memory` Nilai default `reserved-memory` adalah 0. Default ini tidak menyimpan memori untuk overhead Valkey atau Redis OSS dan memungkinkan Valkey atau Redis OSS untuk mengkonsumsi semua memori node dengan data.
Mengubah `reserved-memory` agar Anda memiliki cukup memori tersedia untuk pencadangan dan failover mengharuskan Anda membuat grup parameter kustom. Dalam grup parameter kustom ini, Anda menyetel `reserved-memory` ke nilai yang sesuai untuk versi Valkey atau Redis OSS yang berjalan pada tipe node cluster dan cluster Anda. Untuk informasi selengkapnya, lihat [Berapa Banyak Memori Cadangan yang Anda Butuhkan?](#redis-memory-management-need)
Parameter `reserved-memory` khusus untuk ElastiCache dan bukan bagian dari distribusi Redis OSS umum.
Prosedur berikut menunjukkan cara menggunakan `reserved-memory` untuk mengelola memori pada cluster Valkey atau Redis OSS Anda.
**Untuk mencadangkan memori menggunakan reserved-memory**
1. Buat grup parameter kustom yang menentukan keluarga grup parameter yang cocok dengan versi mesin yang Anda jalankan—misalnya, menentukan keluarga grup parameter `redis2.8`. Untuk informasi selengkapnya, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
```
aws elasticache create-cache-parameter-group \
--cache-parameter-group-name redis6x-m3xl \
--description "Redis OSS 2.8.x for m3.xlarge node type" \
--cache-parameter-group-family redis6.x
```
1. Hitung berapa byte memori yang akan dicadangkan untuk overhead Valkey atau Redis OSS. Anda dapat menemukan nilai `maxmemory` untuk jenis simpul Anda di [Parameter spesifik tipe node Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific).
1. Ubah grup parameter kustom agar parameter `reserved-memory` adalah jumlah byte yang Anda hitung pada langkah sebelumnya. AWS CLI Contoh berikut mengasumsikan Anda menjalankan versi Redis OSS sebelum 2.8.22 dan perlu memesan setengah dari node. `maxmemory` Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name redis28-m3xl \
--parameter-name-values "ParameterName=reserved-memory, ParameterValue=7130316800"
```
Anda memerlukan grup parameter kustom terpisah untuk setiap jenis simpul yang Anda gunakan, karena setiap jenis simpul memiliki nilai `maxmemory` yang berbeda. Dengan demikian, setiap jenis simpul membutuhkan nilai yang berbeda untuk `reserved-memory`.
1. Ubah cluster Redis OSS atau grup replikasi Anda untuk menggunakan grup parameter kustom Anda.
Contoh CLI berikut mengubah klaster ` my-redis-cluster` untuk menggunakan grup parameter kustom `redis28-m3xl` yang dimulai segera. Untuk informasi selengkapnya, lihat [Memodifikasi cluster ElastiCache](Clusters.Modify.md).
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-redis-cluster \
--cache-parameter-group-name redis28-m3xl \
--apply-immediately
```
Contoh CLI berikut mengubah grup replikasi `my-redis-repl-grp` untuk menggunakan grup parameter kustom `redis28-m3xl` yang dimulai segera. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
```
aws elasticache modify-replication-group \
--replication-group-id my-redis-repl-grp \
--cache-parameter-group-name redis28-m3xl \
--apply-immediately
```
### reserved-memory-percentParameternya
Pada 16 Maret 2017, Amazon ElastiCache memperkenalkan parameter `reserved-memory-percent` dan membuatnya tersedia di semua versi ElastiCache untuk Redis OSS. Tujuan dari `reserved-memory-percent` adalah untuk menyederhanakan manajemen memori cadangan di semua klaster Anda. Hal ini dilakukan dengan memungkinkan Anda memiliki satu grup parameter tunggal untuk setiap keluarga grup parameter (seperti `redis2.8`) untuk mengelola memori cadangan dari klaster Anda, terlepas dari jenis simpulnya. Nilai default untuk `reserved-memory-percent` adalah 25 (25 persen).
Parameter `reserved-memory-percent` khusus untuk ElastiCache dan bukan bagian dari distribusi Redis OSS umum.
Jika klaster Anda menggunakan jenis simpul dari keluarga r6gd dan penggunaan memori Anda mencapai 75 persen, tingkatan data akan dipicu secara otomatis. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
**Untuk menyimpan memori menggunakan reserved-memory-percent**
Untuk menggunakan `reserved-memory-percent` untuk mengelola memori pada cluster ElastiCache untuk Redis OSS Anda, lakukan salah satu hal berikut:
+ Jika Anda menjalankan Redis OSS 2.8.22 atau yang lebih baru, tetapkan grup parameter default ke cluster Anda. Default 25 persen seharusnya sudah memadai. Jika tidak, lakukan langkah yang dijelaskan berikut untuk mengubah nilai.
+ Jika Anda menjalankan versi Redis OSS sebelum 2.8.22, Anda mungkin perlu memesan lebih banyak memori daripada `reserved-memory-percent` default 25 persen. Untuk melakukannya, gunakan prosedur berikut.
**Untuk mengubah nilai persen reserved-memory-percent**
1. Buat grup parameter kustom yang menentukan keluarga grup parameter yang cocok dengan versi mesin yang Anda jalankan—misalnya, menentukan keluarga grup parameter `redis2.8`. Grup parameter kustom diperlukan karena Anda tidak dapat mengubah grup parameter default. Untuk informasi selengkapnya, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
```
aws elasticache create-cache-parameter-group \
--cache-parameter-group-name redis28-50 \
--description "Redis OSS 2.8.x 50% reserved" \
--cache-parameter-group-family redis2.8
```
Karena `reserved-memory-percent` mencadangkan memori sebagai persentase `maxmemory` simpul, Anda tidak memerlukan grup parameter kustom untuk setiap jenis simpul.
1. Ubah grup parameter kustom agar `reserved-memory-percent` menjadi 50 (50 persen). Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name redis28-50 \
--parameter-name-values "ParameterName=reserved-memory-percent, ParameterValue=50"
```
1. Gunakan grup parameter kustom ini untuk setiap cluster Redis OSS atau grup replikasi yang menjalankan versi Redis OSS yang lebih tua dari 2.8.22.
Contoh CLI berikut memodifikasi cluster Redis OSS `my-redis-cluster` untuk menggunakan kelompok parameter kustom dimulai segera. `redis28-50` Untuk informasi selengkapnya, lihat [Memodifikasi cluster ElastiCache](Clusters.Modify.md).
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-redis-cluster \
--cache-parameter-group-name redis28-50 \
--apply-immediately
```
Contoh CLI berikut memodifikasi kelompok replikasi Redis OSS `my-redis-repl-grp` untuk menggunakan kelompok parameter kustom dimulai segera. `redis28-50` Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
```
aws elasticache modify-replication-group \
--replication-group-id my-redis-repl-grp \
--cache-parameter-group-name redis28-50 \
--apply-immediately
```
## Menentukan Parameter Manajemen Memori Cadangan
Jika Anda adalah ElastiCache pelanggan saat ini pada 16 Maret 2017, parameter manajemen memori cadangan default Anda adalah `reserved-memory` dengan nol (0) byte memori cadangan. Jika Anda menjadi ElastiCache pelanggan setelah 16 Maret 2017, parameter manajemen memori cadangan default Anda adalah `reserved-memory-percent` dengan 25 persen dari memori node yang dicadangkan. Ini benar tidak masalah ketika Anda ElastiCache membuat cluster atau grup replikasi Redis OSS Anda. Namun, Anda dapat mengubah parameter manajemen memori cadangan menggunakan ElastiCache API AWS CLI atau API.
Parameter `reserved-memory` dan `reserved-memory-percent` keduanya bersifat saling eksklusif. Grup parameter selalu memiliki salah satu dari keduanya tetapi tidak pernah keduanya. Anda dapat mengubah parameter yang digunakan grup parameter untuk manajemen memori cadangan dengan mengubah grup parameter. Grup parameter harus berupa grup parameter kustom, karena Anda tidak dapat mengubah grup parameter default. Untuk informasi selengkapnya, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
**Untuk menentukan reserved-memory-percent**
Untuk menggunakan `reserved-memory-percent` sebagai parameter manajemen memori cadangan, ubah grup parameter kustom menggunakan perintah `modify-cache-parameter-group`. Gunakan parameter `parameter-name-values` untuk menentukan `reserved-memory-percent` dan memberikan nilai untuknya.
Contoh CLI berikut mengubah grup parameter kustom `redis32-cluster-on` sehingga menggunakan `reserved-memory-percent` untuk mengelola memori cadangan. Nilai harus diberikan ke `ParameterValue` agar grup parameter dapat menggunakan parameter `ParameterName` untuk manajemen memori cadangan. Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name redis32-cluster-on \
--parameter-name-values "ParameterName=reserved-memory-percent, ParameterValue=25"
```
**Untuk menentukan reserved-memory**
Untuk menggunakan `reserved-memory` sebagai parameter manajemen memori cadangan, ubah grup parameter kustom menggunakan perintah `modify-cache-parameter-group`. Gunakan parameter `parameter-name-values` untuk menentukan `reserved-memory` dan memberikan nilai untuknya.
Contoh CLI berikut mengubah grup parameter kustom `redis32-m3xl` sehingga menggunakan `reserved-memory` untuk mengelola memori cadangan. Nilai harus diberikan ke `ParameterValue` agar grup parameter dapat menggunakan parameter `ParameterName` untuk manajemen memori cadangan. Karena versi mesin lebih baru dari 2.8.22, kami menetapkan nilainya menjadi `3565158400`, yaitu 25 persen `maxmemory` dari `cache.m3.xlarge`. Lihat informasi yang lebih lengkap di [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name redis32-m3xl \
--parameter-name-values "ParameterName=reserved-memory, ParameterValue=3565158400"
```
# Praktik terbaik saat bekerja dengan cluster berbasis node Valkey dan Redis OSS
Penggunaan multi-AZ, memiliki memori yang cukup, mengubah ukuran cluster, dan meminimalkan waktu henti adalah semua konsep yang berguna untuk diingat saat bekerja dengan cluster berbasis node di Valkey atau Redis OSS. Sebaiknya tinjau dan ikuti praktik terbaik ini.
**Topics**
+ [Meminimalkan waktu henti dengan Multi-AZ](multi-az.md)
+ [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md)
+ [Perubahan ukuran klaster online](best-practices-online-resharding.md)
+ [Meminimalkan waktu henti selama pemeliharaan](BestPractices.MinimizeDowntime.md)
# Meminimalkan waktu henti dengan Multi-AZ
Ada sejumlah contoh di mana ElastiCache Valkey atau Redis OSS mungkin perlu mengganti node primer; ini termasuk jenis pemeliharaan terencana tertentu dan kejadian yang tidak mungkin dari node primer atau kegagalan Availability Zone.
Penggantian ini mengakibatkan waktu henti pada klaster, tetapi jika Multi-AZ diaktifkan, waktu henti dapat dikurangi. Peran simpul primer akan secara otomatis melakukan failover ke salah satu replika baca. Tidak perlu membuat dan menyediakan simpul utama baru, karena ElastiCache akan menangani ini secara transparan. Failover dan promosi replika ini memastikan Anda dapat melanjutkan penulisan ke primer baru segera setelah promosi selesai.
Lihat[Meminimalkan downtime ElastiCache dengan menggunakan Multi-AZ dengan Valkey dan Redis OSS](AutoFailover.md), untuk mempelajari lebih lanjut tentang Multi-AZ dan meminimalkan waktu henti.
# Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS
**Snapshot dan sinkronisasi di Valkey 7.2 dan yang lebih baru, dan Redis OSS versi 2.8.22 dan yang lebih baru**
Valkey memiliki dukungan default untuk snapshot dan sinkronisasi. Redis OSS 2.8.22 memperkenalkan proses penyimpanan tanpa garpu yang memungkinkan Anda mengalokasikan lebih banyak memori untuk penggunaan aplikasi Anda tanpa menimbulkan peningkatan penggunaan swap selama sinkronisasi dan penyimpanan. Untuk informasi selengkapnya, lihat [Cara penerapan sinkronisasi dan pencadangan](Replication.Redis.Versions.md).
**Redis OSS snapshot dan sinkronisasi sebelum versi 2.8.22**
Ketika Anda bekerja dengan ElastiCache untuk Redis OSS, Redis OSS memanggil perintah penulisan latar belakang dalam sejumlah kasus:
+ Saat membuat snapshot untuk cadangan.
+ Saat menyinkronkan replika dengan primer dalam grup replikasi.
+ Saat mengaktifkan fitur file append-only (AOF) untuk Redis OSS.
+ Saat mempromosikan replika menjadi primer (yang menyebabkan sinkronisasi primer/replika).
Setiap kali Redis OSS mengeksekusi proses penulisan latar belakang, Anda harus memiliki memori yang cukup tersedia untuk mengakomodasi overhead proses. Jika memori yang tersedia tidak cukup, proses akan gagal. Karena itu, penting untuk memilih jenis instance node yang memiliki memori yang cukup saat membuat cluster Redis OSS Anda.
## Proses Penulisan Latar Belakang dan Penggunaan Memori dengan Valkey dan Redis OSS
Setiap kali proses penulisan latar belakang disebut, Valkey dan Redis OSS memotong prosesnya (ingat, mesin ini berulir tunggal). Satu garpu menyimpan data Anda ke disk dalam file snapshot Redis OSS.rdb. Fork lainnya melayani semua operasi baca dan tulis. Untuk memastikan bahwa snapshot Anda adalah point-in-time snapshot, semua pembaruan dan penambahan data ditulis ke area memori yang tersedia terpisah dari area data.
Asalkan Anda memiliki cukup memori yang tersedia untuk mencatat semua operasi tulis saat data sedang dipersistensi ke disk, Anda tidak akan mengalami masalah kekurangan memori. Anda mungkin mengalami masalah kekurangan memori jika salah satu hal berikut berlaku:
+ Aplikasi Anda melakukan banyak operasi tulis, sehingga membutuhkan sejumlah besar memori yang tersedia untuk menerima data yang baru atau diperbarui.
+ Anda memiliki sedikit memori yang tersedia untuk menulis data yang baru atau diperbarui.
+ Anda memiliki set data besar yang membutuhkan waktu lama untuk dipersistensi ke disk, sehingga memerlukan sejumlah besar operasi tulis.
Diagram berikut menggambarkan penggunaan memori saat menjalankan operasi tulis di latar belakang.
![\[Gambar: Diagram penggunaan memori selama operasi tulis di latar belakang.\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-bgsaveMemoryUseage.png)
Untuk informasi tentang dampak melakukan pencadangan pada performa, lihat [Dampak kinerja pencadangan cluster berbasis node](backups.md#backups-performance).
[Untuk informasi lebih lanjut tentang bagaimana Valkey dan Redis OSS melakukan snapshot, lihat http://valkey.io.](http://valkey.io)
Untuk informasi selengkapnya tentang wilayah dan Zona Ketersediaan, lihat [Memilih wilayah dan zona ketersediaan untuk ElastiCache](RegionsAndAZs.md).
## Menghindari kehabisan memori saat menjalankan operasi tulis di latar belakang
Setiap kali proses penulisan latar belakang seperti `BGSAVE` atau `BGREWRITEAOF` dipanggil, untuk menjaga proses agar tidak gagal, Anda harus memiliki lebih banyak memori yang tersedia daripada yang akan dikonsumsi oleh operasi penulisan selama proses. Skenario terburuk adalah bahwa selama operasi penulisan latar belakang setiap catatan diperbarui dan beberapa catatan baru ditambahkan ke cache. Karena itu, kami menyarankan Anda mengatur `reserved-memory-percent` ke 50 (50 persen) untuk versi Redis OSS sebelum 2.8.22, atau 25 (25 persen) untuk Valkey dan semua Redis OSS versi 2.8.22 dan yang lebih baru.
Nilai `maxmemory` menunjukkan memori yang tersedia untuk overhead data dan operasional. Karena Anda tidak dapat mengubah parameter `reserved-memory` dalam grup parameter default, Anda harus membuat grup parameter kustom untuk klaster. Nilai default untuk `reserved-memory` adalah 0, yang memungkinkan Redis OSS untuk mengkonsumsi semua *maxmemory* dengan data, berpotensi meninggalkan terlalu sedikit memori untuk kegunaan lain, seperti proses penulisan latar belakang. Untuk nilai `maxmemory` berdasarkan jenis instans simpul, lihat [Parameter spesifik tipe node Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific).
Anda juga dapat menggunakan `reserved-memory` parameter untuk mengurangi jumlah memori yang digunakan pada kotak.
Untuk informasi lebih lanjut tentang parameter khusus Valkey dan REDIS di ElastiCache, lihat. [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
Untuk informasi tentang cara membuat dan mengubah grup parameter DB, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md) dan [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
# Perubahan ukuran klaster online
*Resharding* melibatkan proses menambahkan dan menghapus serpihan atau simpul ke klaster Anda dan mendistribusikan ulang ruang kunci. Oleh karena itu, ada beberapa hal yang memiliki dampak pada operasi resharding, seperti beban pada klaster, pemanfaatan memori, dan ukuran keseluruhan data. Untuk pengalaman terbaik, sebaiknya ikuti praktik terbaik klaster secara keseluruhan untuk distribusi pola beban kerja seragam. Selain itu, sebaiknya lakukan langkah-langkah berikut.
Sebelum memulai resharding, sebaiknya lakukan hal berikut:
+ **Uji aplikasi Anda** – Uji perilaku aplikasi Anda selama resharding di lingkungan staging jika memungkinkan.
+ **Dapatkan notifikasi awal untuk masalah penskalaan** – Resharding adalah operasi sarat komputasi. Karena itu, kami merekomendasikan untuk menjaga pemanfaatan CPU di bawah 80 persen pada instance multicore dan kurang dari 50 persen pada instance inti tunggal selama resharding. Pantau ElastiCache metrik Redis OSS dan mulai resharding sebelum aplikasi Anda mulai mengamati masalah penskalaan. Metrik yang berguna untuk dilacak adalah `CPUUtilization`, `NetworkBytesIn`, `NetworkBytesOut`, `CurrConnections`, `NewConnections`, `FreeableMemory`, `SwapUsage`, dan `BytesUsedForCacheItems`.
+ **Pastikan untuk menyediakan memori yang cukup sebelum penskalaan ke dalam** – Jika Anda melakukan penskalaan ke dalam, pastikan memori pada serpihan yang akan dipertahankan tersedia setidaknya 1,5 kali dari memori yang akan digunakan pada serpihan yang akan dihapus.
+ **Mulai resharding di luar jam puncak** – Praktik ini membantu mengurangi dampak latensi dan throughput pada klien selama operasi resharding. Hal ini juga membantu untuk menyelesaikan resharding lebih cepat karena lebih banyak sumber daya dapat digunakan untuk distribusi ulang slot.
+ **Tinjau perilaku waktu habis klien** – Beberapa klien mungkin mengalami latensi yang lebih tinggi selama perubahan ukuran klaster online. Anda dapat mengonfigurasi pustaka klien dengan waktu habis yang lebih tinggi agar sistem memiliki waktu untuk terhubung bahkan dalam kondisi beban yang lebih tinggi pada server. Dalam beberapa kasus, mungkin sebaiknya buka sejumlah besar koneksi ke server. Dalam kasus ini, pertimbangkan untuk menambahkan backoff eksponensial ke logika koneksi ulang. Melakukan hal ini dapat membantu mencegah lonjakan koneksi baru di server pada waktu yang sama.
+ **Muat Functions Anda di setiap shard** — Saat menskalakan klaster Anda, ElastiCache akan secara otomatis mereplikasi Fungsi yang dimuat di salah satu node yang ada (dipilih secara acak) ke node baru. Jika klaster Anda memiliki Valkey 7.2 ke atas, atau Redis OSS 7.0 atau lebih tinggi, dan aplikasi Anda menggunakan [Fungsi](https://valkey.io/topics/functions-intro/), kami sarankan memuat semua fungsi Anda ke semua pecahan sebelum penskalaan sehingga cluster Anda tidak berakhir dengan fungsi yang berbeda pada pecahan yang berbeda.
Setelah resharding, perhatikan hal berikut:
+ Penskalaan ke dalam mungkin berhasil sebagian jika memori tidak cukup pada serpihan target. Jika hal tersebut terjadi, tinjau memori yang tersedia dan coba lagi operasi, jika perlu. Data pada serpihan target tidak akan dihapus.
+ Perintah `FLUSHALL` dan `FLUSHDB` tidak didukung dalam skrip Lua selama operasi resharding. Sebelum Redis OSS 6, `BRPOPLPUSH` perintah tidak didukung jika beroperasi pada slot yang sedang dimigrasikan.
# Meminimalkan waktu henti selama pemeliharaan
Konfigurasi mode klaster memiliki ketersediaan terbaik selama operasi terkelola atau tidak terkelola. Sebaiknya gunakan klien yang mendukung mode klaster yang menghubungkan ke titik akhir penemuan klaster. Untuk mode klaster dinonaktifkan, sebaiknya gunakan titik akhir primer untuk semua operasi tulis.
Untuk aktivitas baca, aplikasi juga dapat menghubungkan ke simpul mana pun di klaster. Tidak seperti titik akhir primer, titik akhir simpul diresolusi ke titik akhir tertentu. Jika Anda membuat perubahan dalam klaster Anda, seperti menambahkan atau menghapus replika, Anda harus memperbarui titik akhir simpul di aplikasi Anda. Dengan demikian, untuk mode klaster dinonaktifkan, sebaiknya gunakan titik akhir pembaca untuk aktivitas baca.
Jika AutoFailover diaktifkan di cluster, simpul utama mungkin berubah. Oleh karena itu, aplikasi harus mengonfirmasi peran simpul dan memperbarui semua titik akhir baca. Tindakan ini akan membantu memastikan bahwa Anda tidak menyebabkan beban besar pada primer. Dengan AutoFailover dinonaktifkan, peran node tidak berubah. Namun, downtime dalam operasi terkelola atau tidak terkelola lebih tinggi dibandingkan dengan cluster yang diaktifkan. AutoFailover
Hindari mengarahkan permintaan baca ke satu simpul replika baca karena ketidaktersediaannya dapat menyebabkan pemadaman operasi baca. Lakukan fallback untuk membaca dari primer, atau pastikan bahwa Anda memiliki setidaknya dua replika baca untuk menghindari gangguan operasi baca selama pemeliharaan.
# Strategi cache untuk Memcached
Dalam topik berikut, Anda dapat menemukan strategi untuk mengisi dan memelihara cache Memcached Anda.
Strategi yang akan diterapkan untuk mengisi dan memelihara cache Anda akan bergantung pada data apa yang disimpan ke cache dan pola akses ke data tersebut. Misalnya, Anda kemungkinan tidak ingin menggunakan strategi yang sama untuk papan peringkat 10 teratas di situs game dan berita yang sedang tren. Selanjutnya, kita akan membahas strategi pemeliharaan cache umum beserta kelebihan dan kekurangannya.
**Topics**
+ [Replika baca](#Strategies.ReadReplicas)
+ [Lazy loading](#Strategies.LazyLoading)
+ [Write-through](#Strategies.WriteThrough)
+ [Menambahkan TTL](#Strategies.WithTTL)
+ [Topik terkait](#Strategies.SeeAlso)
## Replika baca
Anda sering dapat secara signifikan meningkatkan kinerja untuk cache ElastiCache tanpa server dengan membuat replika dan membaca dari mereka alih-alih node cache utama. Untuk mengetahui informasi selengkapnya, lihat [Praktik Terbaik untuk menggunakan Read Replicas](ReadReplicas.md).
## Lazy loading
Seperti namanya, *lazy loading* adalah strategi pembuatan cache yang memuat data ke dalam cache hanya jika diperlukan. Cara kerjanya adalah seperti dijelaskan berikut.
Amazon ElastiCache adalah penyimpanan nilai kunci dalam memori yang berada di antara aplikasi Anda dan penyimpanan data (database) yang diaksesnya. Setiap kali aplikasi Anda meminta data, pertama kali membuat permintaan ke ElastiCache cache. Jika data terdapat di dalam cache dan data itu masih baru, maka ElastiCache mengembalikan data itu ke aplikasi Anda. Jika data tidak ada di dalam cache atau telah kedaluwarsa, maka aplikasi Anda akan meminta data dari penyimpanan data Anda. Penyimpanan data Anda kemudian mengembalikan data ke aplikasi Anda. Aplikasi Anda selanjutnya menulis data yang diterima dari penyimpanan ke cache. Dengan cara ini, data dapat lebih cepat diambil jika diminta lagi pada waktu berikutnya.
*Cache hit* terjadi ketika data ada dalam cache dan tidak habis masa berlakunya:
1. Aplikasi Anda meminta data dari cache.
1. Cache mengembalikan data ke aplikasi.
*Cache miss* terjadi ketika data tidak ada dalam cache atau data sudah tidak berlaku:
1. Aplikasi Anda meminta data dari cache.
1. Cache tidak memiliki data yang diminta, sehingga mengembalikan `null`.
1. Aplikasi Anda meminta dan menerima data dari basis data.
1. Aplikasi Anda memperbarui cache dengan data baru.
### Kelebihan dan kekurangan dari lazy loading
Kelebihan dari lazy loading adalah sebagai berikut:
+ Hanya data yang diminta yang disimpan ke cache.
Karena sebagian besar data tidak pernah diminta, lazy loading menghindari mengisi cache dengan data yang tidak diminta.
+ Kegagalan simpul tidak menjadi fatal untuk aplikasi Anda.
Ketika simpul gagal dan digantikan oleh simpul baru yang kosong, aplikasi Anda terus berfungsi, meskipun dengan peningkatan latensi. Karena permintaan dibuat ke simpul baru, setiap cache miss menghasilkan kueri ke basis data. Pada saat yang sama, salinan data ditambahkan ke cache sehingga permintaan berikutnya diambil dari cache tersebut.
Kekurangan dari lazy loading adalah sebagai berikut:
+ Terjadi kerugian akibat cache miss. Setiap cache miss menyebabkan tiga perjalanan:
1. Permintaan awal untuk data dari cache
1. Kueri basis data untuk data
1. Menulis data ke cache
Miss ini dapat menyebabkan penundaan yang terasa pada data yang masuk ke aplikasi.
+ Data yang usang.
Jika data ditulis ke cache hanya jika ada cache miss, maka data dalam cache dapat menjadi usang. Hal ini terjadi karena tidak ada pembaruan pada cache ketika data berubah dalam basis data. Untuk mengatasi masalah ini, Anda dapat menggunakan strategi [Write-through](#Strategies.WriteThrough) dan [Menambahkan TTL](#Strategies.WithTTL).
### Contoh kode semu lazy loading
Berikut adalah contoh kode semu logika lazy loading.
```
// *****************************************
// function that returns a customer's record.
// Attempts to retrieve the record from the cache.
// If it is retrieved, the record is returned to the application.
// If the record is not retrieved from the cache, it is
// retrieved from the database,
// added to the cache, and
// returned to the application
// *****************************************
get_customer(customer_id)
customer_record = cache.get(customer_id)
if (customer_record == null)
customer_record = db.query("SELECT * FROM Customers WHERE id = {0}", customer_id)
cache.set(customer_id, customer_record)
return customer_record
```
Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.
```
customer_record = get_customer(12345)
```
## Write-through
Strategi write-through menambahkan data atau pembaruan data ke dalam cache setiap kali data ditulis ke basis data.
### Kelebihan dan kekurangan dari write-through
Kelebihan dari write-through adalah sebagai berikut:
+ Data dalam cache tidak pernah usang.
Karena data dalam cache diperbarui setiap kali data itu ditulis ke basis data, data dalam cache selalu yang terbaru.
+ Kerugian operasi tulis vs kerugian operasi baca.
Setiap operasi tulis melibatkan dua proses:
1. Operasi tulis ke cache
1. Operasi tulis ke basis data
Yang menambahkan latensi pada proses. Namun, pengguna akhir umumnya lebih toleran terhadap latensi saat memperbarui data daripada saat mengambil data. Ada perasaan yang melekat bahwa memperbarui membutuhkan upaya lebih banyak dan karena itu memakan waktu lebih lama.
Kekurangan dari write-through adalah sebagai berikut:
+ Data yang hilang.
Jika Anda membuat simpul baru, dengan alasan kegagalan simpul atau untuk penskalaan ke luar, maka akan ada data yang hilang. Data ini tetap hilang hingga ditambahkan atau diperbarui pada basis data. Anda dapat meminimalkan ini dengan menerapkan [lazy loading](#Strategies.LazyLoading) dengan write-through.
+ Churn Cache.
Sebagian besar data tidak pernah dibaca, yang merupakan pemborosan sumber daya. Dengan [menambahkan nilai time to live (TTL)](#Strategies.WithTTL), Anda dapat meminimalkan ruang penyimpanan yang terbuang.
### Contoh kode semu Write-through
Berikut adalah contoh kode semu dari logika write-through.
```
// *****************************************
// function that saves a customer's record.
// *****************************************
save_customer(customer_id, values)
customer_record = db.query("UPDATE Customers WHERE id = {0}", customer_id, values)
cache.set(customer_id, customer_record)
return success
```
Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.
```
save_customer(12345,{"address":"123 Main"})
```
## Menambahkan TTL
Lazy loading memungkinkan data menjadi usang tetapi tidak gagal dengan simpul kosong. Write-through memastikan data selalu segar, tetapi dapat gagal dengan simpul kosong dan dapat mengisi cache dengan data berlebihan yang tidak berguna. Dengan menambahkan nilai time to live (TTL) untuk setiap operasi tulis, Anda dapat memanfaatkan kelebihan dari setiap strategi. Pada saat yang sama, Anda dapat secara signifikan menghindari cache menjadi penuh karena data tambahan.
*Time to live (TTL)* adalah nilai integer yang menentukan jumlah detik sampai kunci berakhir. Valkey atau Redis OSS dapat menentukan detik atau milidetik untuk nilai ini. Memcached menentukan nilai ini dalam detik. Ketika sebuah aplikasi mencoba membaca kunci yang kedaluwarsa, maka perlakuannya adalah seolah-olah kunci itu tidak ditemukan. Terjadi kueri ke basis data untuk meminta kunci dan cache diperbarui. Pendekatan ini tidak menjamin sebuah nilai tidak menjadi usang. Namun, hal ini menjaga data agar tidak terlalu usang dan mensyaratkan nilai di dalam cache agar terkadang disegarkan kembali dari basis data.
[Untuk informasi lebih lanjut, lihat perintah [Valkey dan Redis OSS atau perintah](https://valkey.io/commands) Memcached. `set`](https://www.tutorialspoint.com/memcached/memcached_set_data.htm)
### Contoh kode semu TTL
Berikut adalah contoh kode semu dari logika write-through dengan TTL.
```
// *****************************************
// function that saves a customer's record.
// The TTL value of 300 means that the record expires
// 300 seconds (5 minutes) after the set command
// and future reads will have to query the database.
// *****************************************
save_customer(customer_id, values)
customer_record = db.query("UPDATE Customers WHERE id = {0}", customer_id, values)
cache.set(customer_id, customer_record, 300)
return success
```
Berikut adalah contoh kode semu logika lazy loading dengan TTL.
```
// *****************************************
// function that returns a customer's record.
// Attempts to retrieve the record from the cache.
// If it is retrieved, the record is returned to the application.
// If the record is not retrieved from the cache, it is
// retrieved from the database,
// added to the cache, and
// returned to the application.
// The TTL value of 300 means that the record expires
// 300 seconds (5 minutes) after the set command
// and subsequent reads will have to query the database.
// *****************************************
get_customer(customer_id)
customer_record = cache.get(customer_id)
if (customer_record != null)
if (customer_record.TTL < 300)
return customer_record // return the record and exit function
// do this only if the record did not exist in the cache OR
// the TTL was >= 300, i.e., the record in the cache had expired.
customer_record = db.query("SELECT * FROM Customers WHERE id = {0}", customer_id)
cache.set(customer_id, customer_record, 300) // update the cache
return customer_record // return the newly retrieved record and exit function
```
Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.
```
save_customer(12345,{"address":"123 Main"})
```
```
customer_record = get_customer(12345)
```
## Topik terkait
+ [Penyimpanan Data Dalam Memori](elasticache-use-cases.md#elasticache-use-cases-data-store)
+ [Memilih mesin dan versi](SelectEngine.md)
+ [Penskalaan ElastiCache](Scaling.md)
# Mengelola cluster berbasis node Anda di ElastiCache
ElastiCache menawarkan dua opsi penerapan, cache tanpa server dan cluster berbasis node. Masing-masing memiliki kemampuan dan persyaratannya sendiri.
Bagian ini berisi topik untuk membantu Anda mengelola cluster berbasis simpul.
**catatan**
Topik-topik ini tidak berlaku untuk Tanpa ElastiCache Server.
**Topics**
+ [Auto Scaling Valkey dan Redis OSS cluster](AutoScaling.md)
+ [Mengubah mode klaster](modify-cluster-mode.md)
+ [Replikasi lintas AWS Wilayah menggunakan datastores global](Redis-Global-Datastore.md)
+ [Ketersediaan tinggi menggunakan grup replikasi](Replication.md)
+ [Mengelola pemeliharaan ElastiCache cluster](maintenance-window.md)
+ [Mengkonfigurasi parameter mesin menggunakan grup ElastiCache parameter](ParameterGroups.md)
# Auto Scaling Valkey dan Redis OSS cluster
## Prasyarat
ElastiCache Auto Scaling terbatas pada hal-hal berikut:
+ Valkey atau Redis OSS (mode cluster diaktifkan) cluster yang menjalankan Valkey 7.2 dan seterusnya, atau menjalankan Redis OSS 6.0 dan seterusnya
+ Tiering data (mode cluster diaktifkan) cluster yang menjalankan Valkey 7.2 dan seterusnya, atau menjalankan Redis OSS 7.0.7 dan seterusnya
+ Ukuran instans - Besar, XLarge, 2 XLarge
+ Kelompok tipe instans - R7g, R6g, R6gd, R5, M7g, M6g, M5, C7gn
+ Auto Scaling in tidak ElastiCache didukung untuk cluster yang berjalan di Datastores Global, Outposts atau Local Zones.
## Mengelola Kapasitas Secara Otomatis dengan ElastiCache Auto Scaling dengan Valkey atau Redis OSS
ElastiCache auto scaling dengan Valkey atau Redis OSS adalah kemampuan untuk menambah atau mengurangi pecahan atau replika yang diinginkan dalam layanan Anda secara otomatis. ElastiCache ElastiCache memanfaatkan layanan Application Auto Scaling untuk menyediakan fungsionalitas ini. Untuk informasi selengkapnya, lihat [Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/what-is-application-auto-scaling.html). Untuk menggunakan penskalaan otomatis, Anda menentukan dan menerapkan kebijakan penskalaan yang menggunakan CloudWatch metrik dan nilai target yang Anda tetapkan. ElastiCache auto scaling menggunakan kebijakan untuk menambah atau mengurangi jumlah instance sebagai respons terhadap beban kerja aktual.
Anda dapat menggunakan Konsol Manajemen AWS untuk menerapkan kebijakan penskalaan berdasarkan metrik yang telah ditentukan sebelumnya. Sebuah `predefined metric` didefinisikan dalam penghitungan sehingga Anda dapat menentukannya dengan nama dalam kode atau menggunakannya dalam Konsol Manajemen AWS. Metrik kustom tidak tersedia untuk pilihan menggunakan Konsol Manajemen AWS. Atau, Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling untuk menerapkan kebijakan penskalaan berdasarkan metrik yang telah ditentukan atau kustom.
ElastiCache untuk Valkey dan Redis OSS mendukung penskalaan untuk dimensi berikut:
+ **Serpihan** – Secara otomatis menambahkan/menghapus serpihan di klaster yang mirip dengan resharding online secara manual. Dalam hal ini, penskalaan ElastiCache otomatis memicu penskalaan atas nama Anda.
+ **Replika** - add/remove replicas in the cluster similar to manual Increase/Decrease replica operations. ElastiCache auto scaling for Valkey and Redis OSS adds/removes Replika secara otomatis secara seragam di semua pecahan di cluster.
ElastiCache untuk Valkey dan Redis OSS mendukung jenis kebijakan penskalaan otomatis berikut:
+ [Kebijakan penskalaan pelacakan target](AutoScaling-Scaling-Policies-Target.md)— Menambah atau mengurangi jumlah shards/replicas layanan Anda berjalan berdasarkan nilai target untuk metrik tertentu. Hal ini serupa dengan cara termostat mempertahankan suhu rumah Anda. Anda memilih suhu dan termostat melakukan sisanya.
+ [Penskalaan terjadwal untuk aplikasi Anda.](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html) — ElastiCache untuk Valkey dan Redis OSS auto scaling dapat menambah atau mengurangi shards/replicas jumlah layanan Anda berjalan berdasarkan tanggal dan waktu.
![\[Gambar penskalaan otomatis ElastiCache untuk Valkey dan Redis OSS\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/Auto-scaling.png)
Langkah-langkah berikut merangkum proses ElastiCache penskalaan otomatis Valkey dan Redis OSS seperti yang ditunjukkan pada diagram sebelumnya:
1. Anda membuat kebijakan penskalaan ElastiCache otomatis untuk Grup Replikasi Anda.
1. ElastiCache auto scaling menciptakan sepasang CloudWatch alarm atas nama Anda. Setiap pasangan merepresentasikan batas atas dan bawah Anda untuk metrik. CloudWatch Alarm ini dipicu ketika penggunaan aktual cluster menyimpang dari penggunaan target Anda untuk jangka waktu yang berkelanjutan. Anda dapat melihat alarm di konsol.
1. Jika nilai metrik yang dikonfigurasi melebihi pemanfaatan target Anda (atau berada di bawah target) untuk jangka waktu tertentu, CloudWatch memicu alarm yang memanggil penskalaan otomatis untuk mengevaluasi kebijakan penskalaan Anda.
1. ElastiCache auto scaling mengeluarkan permintaan Modify untuk menyesuaikan kapasitas cluster Anda.
1. ElastiCache memproses permintaan Modify, secara dinamis meningkatkan (atau mengurangi) Shards/Replicas kapasitas cluster sehingga mendekati pemanfaatan target Anda.
Untuk memahami cara kerja ElastiCache Auto Scaling, misalkan Anda memiliki cluster bernama. `UsersCluster` Dengan memantau CloudWatch metrik`UsersCluster`, Anda menentukan pecahan Max yang dibutuhkan cluster saat lalu lintas berada di puncaknya dan Min Shards saat lalu lintas berada pada titik terendah. Anda juga menentukan nilai target untuk pemanfaatan CPU untuk `UsersCluster` cluster. ElastiCache auto scaling menggunakan algoritma pelacakan targetnya untuk memastikan bahwa pecahan yang `UsersCluster` disediakan disesuaikan sesuai kebutuhan sehingga pemanfaatan tetap pada atau mendekati nilai target.
**catatan**
Penskalaan mungkin membutuhkan waktu yang nyata dan akan membutuhkan sumber daya klaster tambahan agar pecahan dapat diseimbangkan kembali. ElastiCache Auto Scaling memodifikasi pengaturan sumber daya hanya jika beban kerja sebenarnya tetap meningkat (atau tertekan) selama beberapa menit. Algoritma pelacakan target penskalaan otomatis berupaya menjaga pemanfaatan target pada atau mendekati nilai yang Anda pilih dalam jangka panjang.
# Kebijakan Auto Scaling
Kebijakan penskalaan memiliki komponen berikut:
+ Metrik target — CloudWatch Metrik yang digunakan ElastiCache untuk Valkey dan Redis OSS Auto Scaling untuk menentukan kapan dan berapa banyak skala.
+ Kapasitas minimum dan maksimum – Jumlah serpihan atau replika minimum dan maksimum yang digunakan untuk penskalaan.
**penting**
Saat membuat kebijakan penskalaan Otomatis, jika kapasitas saat ini lebih tinggi dari kapasitas maksimal yang dikonfigurasi, kami menskaleIn MaxCapacity selama pembuatan kebijakan. Demikian pula jika kapasitas saat ini lebih rendah dari kapasitas min yang dikonfigurasi, kami ScaleOut ke. MinCapacity
+ Periode pendinginan – Jumlah waktu, dalam detik, setelah aktivitas penskalaan ke dalam atau penskalaan ke luar selesai sebelum aktivitas penskalaan ke luar lainnya dapat dimulai.
+ Peran terkait layanan — Peran AWS Identitas dan Manajemen Akses (IAM) and Access Management (IAM) yang ditautkan ke layanan tertentu. AWS Peran terkait layanan mencakup semua izin yang diperlukan layanan untuk memanggil AWS layanan lain atas nama Anda. ElastiCache Auto Scaling secara otomatis menghasilkan peran ini,`AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG`, untuk Anda.
+ Aktifkan atau nonaktifkan aktivitas penskalaan ke dalam - Kemampuan untuk mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam untuk suatu kebijakan.
**Topics**
+ [Metrik target untuk Auto Scaling](#AutoScaling-TargetMetric)
+ [Kapasitas minimum dan maksimum](#AutoScaling-MinMax)
+ [Periode pendinginan](#AutoScaling-Cooldown)
+ [Mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam](#AutoScaling-enable-disable-scale-in)
## Metrik target untuk Auto Scaling
Dalam jenis kebijakan ini, metrik yang telah ditentukan atau kustom dan nilai target untuk metrik ditentukan dalam konfigurasi kebijakan penskalaan pelacakan target. ElastiCache untuk Valkey dan Redis OSS Auto Scaling membuat dan mengelola CloudWatch alarm yang memicu kebijakan penskalaan dan menghitung penyesuaian penskalaan berdasarkan metrik dan nilai target. Kebijakan penskalaan menambahkan atau menghapus shards/replicas sesuai kebutuhan untuk menjaga metrik pada, atau mendekati, nilai target yang ditentukan. Selain menjaga metrik tetap dekat dengan nilai target, kebijakan penskalaan pelacakan target juga disesuaikan menurut fluktuasi metrik karena pola beban kerja yang berubah. Kebijakan semacam itu juga meminimalkan fluktuasi cepat dalam jumlah yang tersedia shards/replicas untuk klaster Anda.
Misalnya, pertimbangkan kebijakan penskalaan yang menggunakan metrik `ElastiCachePrimaryEngineCPUUtilization` rata-rata standar. Kebijakan tersebut dapat menjaga pemanfaatan CPU pada, atau mendekati, persentase pemanfaatan tertentu, seperti 70 persen.
**catatan**
Untuk setiap klaster, Anda hanya dapat membuat satu kebijakan Auto Scaling untuk setiap metrik target.
## Kapasitas minimum dan maksimum
**Serpihan**
Anda dapat menentukan jumlah pecahan maksimum yang dapat diskalakan oleh ElastiCache untuk penskalaan otomatis Valkey dan Redis OSS. Nilai ini harus kurang dari atau sama dengan 250 dengan minimum 1. Anda juga dapat menentukan jumlah minimum pecahan yang akan dikelola dengan penskalaan otomatis. Nilai ini harus minimal 1, dan sama dengan atau kurang dari nilai yang ditentukan untuk serpihan maksimum yaitu 250.
**Replika**
Anda dapat menentukan jumlah maksimum replika yang akan dikelola oleh ElastiCache untuk penskalaan otomatis Valkey dan Redis OSS. Nilai ini harus kurang dari atau sama dengan 5. Anda juga dapat menentukan jumlah minimum replika yang akan dikelola dengan penskalaan otomatis. Nilai ini harus minimal 1, dan sama dengan atau kurang dari nilai yang ditentukan untuk replika maksimum yaitu 5.
Untuk menentukan jumlah minimum dan maksimum shards/replicas yang Anda butuhkan untuk lalu lintas tipikal, uji konfigurasi Auto Scaling Anda dengan tingkat lalu lintas yang diharapkan ke model Anda.
**catatan**
ElastiCache Kebijakan penskalaan otomatis meningkatkan kapasitas klaster hingga mencapai ukuran maksimum yang Anda tentukan atau hingga batas layanan berlaku. Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
**penting**
Penskalaan ke dalam terjadi ketika tidak ada lalu lintas. Jika lalu lintas varian menjadi nol, ElastiCache secara otomatis menskalakan ke jumlah minimum instance yang ditentukan.
## Periode pendinginan
Anda dapat menyesuaikan daya respons kebijakan penskalaan pelacakan target dengan menambahkan periode pendinginan yang memengaruhi penskalaan klaster Anda. Periode pendinginan memblokir permintaan penskalaan ke dalam atau ke luar berikutnya hingga periode ini berakhir. Ini memperlambat penghapusan di cluster Valkey dan Redis OSS Anda ElastiCache untuk permintaan scale-in, dan pembuatan untuk permintaan scale-out. shards/replicas shards/replicas Anda dapat menentukan periode pendinginan berikut:
+ Aktivitas scale-in mengurangi jumlah di klaster shards/replicas Anda. Periode pendinginan penskalaan ke dalam menentukan jumlah waktu, dalam detik, setelah aktivitas penskalaan ke dalam selesai sebelum aktivitas penskalaan ke dalam lainnya dapat dimulai.
+ Aktivitas scale-out meningkatkan jumlah di klaster shards/replicas Anda. Periode pendinginan penskalaan ke luar menentukan jumlah waktu, dalam detik, setelah aktivitas penskalaan ke luar selesai sebelum aktivitas penskalaan ke luar lainnya dapat dimulai.
Ketika periode pendinginan penskalaan ke dalam atau penskalaan ke luar tidak ditentukan, nilai default untuk penskalaan ke luar adalah 600 detik dan untuk penskalaan ke dalam adalah 900 detik.
## Mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam
Anda dapat mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam untuk sebuah kebijakan. Mengaktifkan aktivitas scale-in memungkinkan kebijakan penskalaan dihapus. shards/replicas. When scale-in activities are enabled, the scale-in cooldown period in the scaling policy applies to scale-in activities. Disabling scale-in activities prevents the scaling policy from deleting shards/replicas
**catatan**
Aktivitas scale-out selalu diaktifkan sehingga kebijakan penskalaan dapat membuat ElastiCache pecahan atau replika sesuai kebutuhan.
## Izin IAM Diperlukan untuk Auto Scaling
ElastiCache untuk Valkey dan Redis OSS Auto Scaling dimungkinkan oleh kombinasi,, dan Application CloudWatch Auto ElastiCache Scaling. APIs Cluster dibuat dan diperbarui dengan ElastiCache, alarm dibuat dengan CloudWatch, dan kebijakan penskalaan dibuat dengan Application Auto Scaling. Selain izin IAM standar untuk membuat dan memperbarui cluster, pengguna IAM yang mengakses pengaturan Auto ElastiCache Scaling harus memiliki izin yang sesuai untuk layanan yang mendukung penskalaan dinamis. Dalam kebijakan terbaru ini kami telah menambahkan dukungan untuk penskalaan vertikal Memcached, dengan tindakan tersebut. `elasticache:ModifyCacheCluster` Pengguna IAM harus memiliki izin untuk menggunakan tindakan yang ditunjukkan dalam contoh kebijakan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*",
"elasticache:DescribeReplicationGroups",
"elasticache:ModifyReplicationGroupShardConfiguration",
"elasticache:IncreaseReplicaCount",
"elasticache:DecreaseReplicaCount",
"elasticache:DescribeCacheClusters",
"elasticache:DescribeCacheParameters",
"cloudwatch:DeleteAlarms",
"cloudwatch:DescribeAlarmHistory",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"cloudwatch:PutMetricAlarm",
"cloudwatch:DisableAlarmActions",
"cloudwatch:EnableAlarmActions",
"iam:CreateServiceLinkedRole",
"sns:CreateTopic",
"sns:Subscribe",
"sns:Get*",
"sns:List*"
],
"Resource": "arn:aws:iam::123456789012:role/autoscaling-roles-for-cluster"
}
]
}
```
------
## Peran terkait layanan
Layanan penskalaan otomatis ElastiCache untuk Valkey dan Redis OSS juga memerlukan izin untuk menggambarkan cluster CloudWatch dan alarm Anda, dan izin untuk mengubah ElastiCache kapasitas target Anda atas nama Anda. Jika Anda mengaktifkan Auto Scaling untuk klaster Anda, itu akan membuat peran terkait layanan bernama. `AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG` Peran terkait layanan ini memberikan izin penskalaan ElastiCache otomatis untuk menjelaskan alarm kebijakan Anda, untuk memantau kapasitas armada saat ini, dan untuk memodifikasi kapasitas armada. Peran terkait layanan adalah peran default untuk penskalaan ElastiCache otomatis. Untuk informasi selengkapnya, lihat [Peran terkait layanan ElastiCache untuk penskalaan otomatis Redis OSS di Panduan Pengguna Application](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) Auto Scaling.
## Praktik Terbaik Auto Scaling
Sebelum mendaftar Auto Scaling, kami merekomendasikan hal berikut:
1. **Gunakan hanya satu metrik pelacakan** – Identifikasi apakah klaster Anda memiliki beban kerja yang sarat CPU atau sarat data dan gunakan metrik standar yang sesuai untuk menentukan Kebijakan Penskalaan.
+ CPU mesin: `ElastiCachePrimaryEngineCPUUtilization` (dimensi serpihan) atau `ElastiCacheReplicaEngineCPUUtilization` (dimensi replika)
+ Penggunaan basis data: `ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage` Kebijakan penskalaan ini berfungsi paling baik dengan maxmemory-policy yang ditetapkan ke noeviction di klaster.
Kami menyarankan Anda menghindari beberapa kebijakan per dimensi pada klaster. ElastiCache untuk Valkey dan Redis OSS Penskalaan otomatis akan menskalakan target yang dapat diskalakan jika ada kebijakan pelacakan target yang siap untuk diskalakan, tetapi akan menskalakan hanya jika semua kebijakan pelacakan target (dengan bagian penskalaan diaktifkan) siap untuk diskalakan. Jika beberapa kebijakan menginstruksikan target yang dapat diskalakan untuk menskalakan ke luar atau ke dalam pada saat yang sama, target akan diskalakan berdasarkan kebijakan yang memberikan kapasitas terbesar untuk penskalaan ke dalam dan penskalaan ke luar.
1. **Metrik yang Disesuaikan untuk Pelacakan Target** – Berhati-hatilah saat menggunakan metrik yang disesuaikan untuk Pelacakan Target karena Penskalaan otomatis paling cocok untuk penskalaan ke luar/ke dalam secara berbanding lurus dengan perubahan metrik yang dipilih untuk kebijakan. Jika metrik tersebut tidak berubah secara proporsional dengan tindakan penskalaan yang digunakan untuk pembuatan kebijakan, hal tersebut dapat menyebabkan tindakan penskalaan ke luar atau penskalaan ke dalam berkelanjutan yang dapat memengaruhi ketersediaan atau biaya.
Untuk klaster tingkatan data (jenis instans keluarga r6gd), hindari penggunaan metrik berbasis memori untuk penskalaan.
1. **Penskalaan Terjadwal** - Jika Anda mengidentifikasi bahwa beban kerja Anda bersifat deterministik (mencapai high/low pada waktu tertentu), sebaiknya gunakan Penskalaan Terjadwal dan konfigurasikan kapasitas target Anda sesuai dengan kebutuhan. Pelacakan Target paling cocok untuk beban kerja non-deterministik dan agar klaster beroperasi pada metrik target yang diperlukan dengan penskalaan ke luar saat Anda membutuhkan lebih banyak sumber daya dan penskalaan ke dalam saat Anda membutuhkan lebih sedikit sumber daya.
1. **Nonaktifkan Scale-In** — Penskalaan otomatis pada Pelacakan Target paling cocok untuk cluster dengan beban kerja bertahap karena spikes/dip dalam metrik dapat memicu increase/decrease penskalaan berurut/dalam osilasi. Untuk menghindari pergantian tersebut, Anda dapat memulai dengan menonaktifkan penskalaan ke luar, dan melakukan penskalaan ke dalam secara manual sesuai kebutuhan Anda kapan saja.
1. **Uji aplikasi Anda** — Kami menyarankan Anda menguji aplikasi Anda dengan perkiraan Min/Max beban kerja Anda untuk menentukan Min, Max absolut yang shards/replicas diperlukan untuk klaster sambil membuat kebijakan Penskalaan untuk menghindari masalah ketersediaan. Penskalaan otomatis dapat menskalakan ke luar hingga Maks dan menskalakan ke dalam hingga ambang batas Min yang dikonfigurasi untuk target.
1. **Mendefinisikan Nilai Target** — Anda dapat menganalisis CloudWatch metrik yang sesuai untuk pemanfaatan klaster selama periode empat minggu untuk menentukan ambang nilai target. Jika Anda masih tidak yakin nilai apa yang harus dipilih, sebaiknya mulai dengan nilai metrik standar minimum yang didukung.
1. AutoScaling pada Pelacakan Target paling cocok untuk cluster dengan distribusi beban kerja yang seragam di seluruh shards/replicas dimensi. Memiliki distribusi yang tidak seragam dapat menyebabkan:
+ Penskalaan saat tidak diperlukan karena beban kerja spike/dip pada beberapa pecahan/replika panas.
+ Tidak ada penskalaan saat diperlukan karena nilai rata-rata keseluruhan mendekati target meskipun memiliki serpihan/replika "hot".
**catatan**
Saat menskalakan cluster Anda, secara otomatis ElastiCache akan mereplikasi Fungsi yang dimuat di salah satu node yang ada (dipilih secara acak) ke node baru. Jika klaster Anda memiliki Valkey atau Redis OSS 7.0 atau lebih tinggi dan aplikasi Anda menggunakan [Fungsi](https://valkey.io/topics/functions-intro/), kami sarankan memuat semua fungsi Anda ke semua pecahan sebelum penskalaan sehingga cluster Anda tidak berakhir dengan fungsi yang berbeda pada pecahan yang berbeda.
Setelah mendaftar AutoScaling, perhatikan hal berikut:
+ Ada batasan pada Konfigurasi yang Didukung Auto Scaling. Jadi, kami menyarankan Anda untuk tidak mengubah konfigurasi grup replikasi yang terdaftar untuk Auto Scaling. Berikut ini adalah beberapa contohnya:
+ Mengubah jenis Instans secara manual ke jenis yang tidak didukung.
+ Mengaitkan grup replikasi ke penyimpanan data Global.
+ Mengubah parameter `ReservedMemoryPercent`.
+ increasing/decreasing shards/replicas beyond the Min/MaxKapasitas manual dikonfigurasi selama pembuatan kebijakan.
# Menggunakan Auto Scaling dengan serpihan
Dengan ElastiCache's AutoScaling Anda dapat menggunakan kebijakan pelacakan dan terjadwal dengan mesin Valkey atau Redis OSS Anda.
Berikut ini memberikan rincian tentang pelacakan target dan kebijakan terjadwal dan bagaimana menerapkannya menggunakan Konsol Manajemen AWS AWS CLI dan APIs.
**Topics**
+ [Kebijakan penskalaan pelacakan target](AutoScaling-Scaling-Policies-Target.md)
+ [Menambahkan kebijakan penskalaan](AutoScaling-Scaling-Adding-Policy-Shards.md)
+ [Mendaftarkan Target yang Dapat Diskalakan](AutoScaling-Scaling-Registering-Policy-CLI.md)
+ [Menetapkan kebijakan penskalaan](AutoScaling-Scaling-Defining-Policy-API.md)
+ [Menonaktifkan aktivitas penskalaan ke dalam](AutoScaling-Scaling-Disabling-Scale-in.md)
+ [Menerapkan kebijakan penskalaan](AutoScaling-Scaling-Applying-a-Scaling-Policy.md)
+ [Mengedit kebijakan penskalaan](AutoScaling-Scaling-Editing-a-Scaling-Policy.md)
+ [Menghapus kebijakan penskalaan](AutoScaling-Scaling-Deleting-a-Scaling-Policy.md)
+ [Gunakan CloudFormation untuk kebijakan Auto Scaling](AutoScaling-with-Cloudformation-Shards.md)
+ [Penskalaan terjadwal](AutoScaling-with-Scheduled-Scaling-Shards.md)
# Kebijakan penskalaan pelacakan target
Dengan kebijakan penskalaan pelacakan target, Anda memilih metrik dan menetapkan nilai target. ElastiCache untuk Valkey dan Redis OSS Auto Scaling membuat dan mengelola CloudWatch alarm yang memicu kebijakan penskalaan dan menghitung penyesuaian penskalaan berdasarkan metrik dan nilai target. Kebijakan penskalaan menambahkan atau menghapus serpihan yang diperlukan untuk menjaga metrik pada, atau mendekati, nilai target yang ditentukan. Selain menjaga metrik agar mendekati nilai target, kebijakan penskalaan pelacakan target juga menyesuaikan dengan fluktuasi metrik karena fluktuasi pola beban dan meminimalkan fluktuasi cepat dalam kapasitas armada.
Misalnya, pertimbangkan kebijakan penskalaan yang menggunakan metrik `ElastiCachePrimaryEngineCPUUtilization` rata-rata standar dengan nilai target yang dikonfigurasi. Kebijakan tersebut dapat menjaga pemanfaatan CPU pada, atau mendekati, nilai target yang ditentukan.
## Metrik standar
Metrik yang telah ditentukan adalah struktur yang mengacu pada nama, dimensi, dan statistik tertentu (`average`) dari CloudWatch metrik tertentu. Kebijakan Auto Scaling menentukan salah satu metrik standar di bawah ini untuk klaster Anda:
****
| Nama Metrik Standar | CloudWatch Nama Metrik | CloudWatch Dimensi Metrik | Jenis Instans yang Tidak Memenuhi Syarat |
| --- | --- | --- | --- |
| ElastiCachePrimaryEngineCPUUtilization | `EngineCPUUtilization` | ReplicationGroupId, Peran = Primer | Tidak ada |
| ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage | `DatabaseCapacityUsageCountedForEvictPercentage` | Metrik Grup Replikasi Valkey atau Redis OSS | Tidak ada |
| ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage | `DatabaseMemoryUsageCountedForEvictPercentage` | Metrik Grup Replikasi Valkey atau Redis OSS | R6gd |
Jenis instans bertingkatan data tidak dapat menggunakan `ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage`, karena jenis instans ini menyimpan data di memori dan SSD. Kasus penggunaan yang diharapkan untuk instans bertingkatan data adalah memiliki 100 persen penggunaan memori dan mengisi SSD sesuai kebutuhan.
## Kriteria Auto Scaling untuk serpihan
Ketika layanan mendeteksi bahwa metrik standar Anda sama dengan atau lebih besar dari pengaturan Target, itu akan meningkatkan kapasitas pecahan Anda secara otomatis. ElastiCache untuk Valkey dan Redis OSS menskalakan pecahan cluster Anda dengan hitungan yang sama dengan yang lebih besar dari dua angka: Persen variasi dari Target dan 20 persen pecahan saat ini. Untuk scale-in, ElastiCache tidak akan auto scale-in kecuali nilai metrik keseluruhan di bawah 75 persen dari Target yang Anda tentukan.
Untuk contoh penskalaan ke luar, jika Anda memiliki 50 serpihan dan
+ jika Target Anda melanggar 30 persen, ElastiCache skala sebesar 30 persen, yang menghasilkan 65 pecahan per cluster.
+ jika Target Anda melanggar 10 persen, ElastiCache skala secara default Minimum 20 persen, yang menghasilkan 60 pecahan per cluster.
Untuk contoh scale-in, jika Anda telah memilih nilai Target 60 persen, ElastiCache tidak akan auto scale-in sampai metrik kurang dari atau sama dengan 45 persen (25 persen di bawah Target 60 persen).
## Pertimbangan untuk Auto Scaling
Perhatikan sejumlah pertimbangan berikut:
+ Kebijakan penskalaan pelacakan target mengasumsikan bahwa penskalaan ke luar harus dilakukan saat metrik yang ditentukan berada di atas nilai target. Anda tidak dapat menggunakan kebijakan penskalaan pelacakan target untuk memperkecil skala ketika metrik yang ditentukan berada di bawah nilai target. ElastiCache untuk Valkey dan Redis OSS skala pecahan dengan minimal 20 persen deviasi target pecahan yang ada di cluster.
+ Kebijakan penskalaan pelacakan target tidak melakukan penskalaan saat metrik yang ditentukan tidak memiliki data yang mencukupi. Kebijakan penskalaan pelacakan target tidak melakukan penskalaan ke dalam karena data yang tidak mencukupi tidak ditafsirkan sebagai pemanfaatan yang rendah.
+ Anda mungkin melihat kesenjangan antara nilai target dan titik data metrik aktual. Ini karena ElastiCache Auto Scaling selalu bertindak konservatif dengan membulatkan ke atas atau ke bawah ketika menentukan berapa banyak kapasitas untuk menambah atau menghapus. Hal ini mencegah layanan menambahkan kapasitas yang tidak mencukupi atau menghapus kapasitas terlalu banyak.
+ Untuk memastikan ketersediaan aplikasi, layanan menskalakan ke luar secara proporsional berdasarkan metrik secepat mungkin, tetapi menskalakan ke dalam secara lebih konservatif.
+ Anda dapat memiliki beberapa kebijakan penskalaan pelacakan target ElastiCache untuk klaster Valkey dan Redis OSS, asalkan masing-masing menggunakan metrik yang berbeda. Tujuan ElastiCache Auto Scaling adalah untuk selalu memprioritaskan ketersediaan, sehingga perilakunya berbeda tergantung pada apakah kebijakan pelacakan target siap untuk skala atau skala. Fitur ini akan menskalakan ke luar layanan jika salah satu kebijakan pelacakan target siap untuk diskalakan ke luar. Namun, penskalaan ke dalam akan dilakukan hanya jika semua kebijakan pelacakan target (dengan porsi penskalaan ke dalam diaktifkan) siap untuk diskalakan ke dalam.
+ Jangan mengedit atau menghapus CloudWatch alarm yang dikelola ElastiCache Auto Scaling untuk kebijakan penskalaan pelacakan target. ElastiCache Auto Scaling menghapus alarm secara otomatis saat Anda menghapus kebijakan penskalaan.
+ ElastiCache Auto Scaling tidak mencegah Anda memodifikasi pecahan cluster secara manual. Penyesuaian manual ini tidak memengaruhi CloudWatch alarm yang ada yang melekat pada kebijakan penskalaan, tetapi dapat memengaruhi metrik yang dapat memicu alarm ini. CloudWatch
+ CloudWatch Alarm yang dikelola oleh Auto Scaling ini ditentukan melalui metrik AVG di semua pecahan di cluster. Jadi, serpihan dengan lalu lintas tertinggi dapat menghasilkan salah satu skenario berikut:
+ penskalaan saat tidak diperlukan karena memuat beberapa pecahan panas yang memicu alarm CloudWatch
+ tidak melakukan penskalaan saat diperlukan karena AVG agregat di semua serpihan yang memengaruhi alarm tidak terlampaui.
+ ElastiCache batas default pada Node per cluster masih berlaku. Jadi, saat memilih Auto Scaling dan jika Anda mengharapkan simpul maksimum lebih dari batas default, minta peningkatan batas di [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
+ Pastikan Anda memiliki cukup ENIs (Antarmuka Jaringan Elastis) yang tersedia di VPC Anda, yang diperlukan selama penskalaan. Untuk informasi selengkapnya, lihat [Antarmuka Jaringan Elastis](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ElasticNetworkInterfaces.html).
+ Jika tidak ada kapasitas yang cukup EC2, ElastiCache Auto Scaling tidak akan menskalakan dan ditunda sampai kapasitas tersedia.
+ ElastiCache untuk Redis OSS Auto Scaling selama scale-in tidak akan menghapus pecahan dengan slot yang memiliki ukuran item lebih besar dari 256 MB pasca-serialisasi.
+ Selama penskalaan ke dalam, serpihan tidak akan dihapus jika memori yang tersedia tidak mencukupi pada konfigurasi serpihan yang dihasilkan.
# Menambahkan kebijakan penskalaan
Anda dapat menambahkan kebijakan penskalaan menggunakan. Konsol Manajemen AWS
**Untuk menambahkan kebijakan Auto Scaling ke klaster Valkey dan Redis OSS ElastiCache**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang ingin Anda tambahi kebijakan (pilih nama klaster, bukan tombol di sebelah kirinya).
1. Pilih tab **Kebijakan Auto Scaling**.
1. Pilih **Tambahkan penskalaan dinamis**.
1. Untuk **Nama kebijakan**, masukkan nama kebijakan.
1. Untuk **Dimensi yang Dapat Diskalakan** pilih **serpihan**.
1. Untuk metrik target, pilih salah satu dari berikut:
+ **Pemanfaatan CPU Primer** untuk membuat kebijakan berdasarkan pemanfaatan CPU rata-rata.
+ **Memori** untuk membuat kebijakan berdasarkan memori basis data rata-rata.
+ **Kapasitas** untuk membuat kebijakan berdasarkan penggunaan kapasitas basis data rata-rata. Metrik Kapasitas mencakup pemanfaatan memori dan SSD untuk instans bertingkatan data, dan pemanfaatan memori untuk semua jenis instans lainnya.
1. Untuk nilai target, pilih nilai yang lebih besar dari atau sama dengan 35 dan kurang dari atau sama dengan 70. Penskalaan otomatis akan mempertahankan nilai ini untuk metrik target yang dipilih di seluruh ElastiCache pecahan Anda:
+ **Pemanfaatan CPU Primer**: mempertahankan nilai target untuk metrik `EngineCPUUtilization` di simpul primer.
+ **Memori**: mempertahankan nilai target untuk metrik `DatabaseMemoryUsageCountedForEvictPercentage`
+ **Kapasitas** mempertahankan nilai target untuk metrik `DatabaseCapacityUsageCountedForEvictPercentage`,
Serpihan klaster ditambahkan atau dihapus untuk menjaga metrik tetap mendekati nilai yang ditentukan.
1. (Opsional) Periode pendinginan penskalaan ke dalam atau penskalaan ke luar tidak didukung dari konsol. Gunakan AWS CLI untuk memodifikasi nilai cooldown.
1. Untuk **kapasitas Minimum**, ketikkan jumlah pecahan minimum yang harus dipertahankan oleh kebijakan ElastiCache Auto Scaling.
1. Untuk **kapasitas Maksimum**, ketikkan jumlah pecahan maksimum yang harus dipertahankan oleh kebijakan ElastiCache Auto Scaling. Nilai ini harus kurang dari atau sama dengan 250.
1. Pilih **Buat**.
# Mendaftarkan Target yang Dapat Diskalakan
Sebelum Anda dapat menggunakan Auto Scaling dengan cluster ElastiCache for Valkey dan Redis OSS, Anda mendaftarkan cluster Anda dengan auto scaling. ElastiCache Anda melakukannya untuk menentukan dimensi dan batas penskalaan yang akan diterapkan ke cluster itu. ElastiCache auto scaling secara dinamis menskalakan cluster di sepanjang dimensi yang `elasticache:replication-group:NodeGroups` dapat diskalakan, yang mewakili jumlah pecahan cluster.
**Menggunakan AWS CLI**
Untuk mendaftarkan cluster Valkey dan Redis OSS Anda ElastiCache , gunakan [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)perintah dengan parameter berikut:
+ `--service-namespace` – Atur nilai ini ke `elasticache`.
+ `--resource-id`— Pengidentifikasi sumber daya untuk cluster. Untuk parameter ini, tipe sumber daya adalah `ReplicationGroup` dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ `--scalable-dimension` – Atur nilai ini ke `elasticache:replication-group:NodeGroups`.
+ `--max-capacity `— Jumlah pecahan maksimum yang akan dikelola oleh penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara `--min-capacity`, `--max-capacity`, dan jumlah serpihan dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
+ `--min-capacity `— Jumlah minimum pecahan yang akan dikelola dengan penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara `--min-capacity`, `--max-capacity`, dan jumlah serpihan dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
**Example**
Dalam contoh berikut, Anda mendaftarkan sebuah ElastiCache cluster bernama`myscalablecluster`. Pendaftaran ini menunjukkan bahwa klaster harus diskalakan secara dinamis agar memiliki satu hingga sepuluh serpihan.
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling register-scalable-target \
--service-namespace elasticache \
--resource-id replication-group/myscalablecluster \
--scalable-dimension elasticache:replication-group:NodeGroups \
--min-capacity 1 \
--max-capacity 10 \
```
Untuk Windows:
```
aws application-autoscaling register-scalable-target ^
--service-namespace elasticache ^
--resource-id replication-group/myscalablecluster ^
--scalable-dimension elasticache:replication-group:NodeGroups ^
--min-capacity 1 ^
--max-capacity 10 ^
```
**Menggunakan API**
Untuk mendaftarkan ElastiCache cluster Anda, gunakan [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)perintah dengan parameter berikut:
+ ServiceNamespace — Tetapkan nilai ini ke elasticache.
+ ResourceId — Pengenal sumber daya untuk cluster. ElastiCache Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ ScalableDimension — Tetapkan nilai ini ke`elasticache:replication-group:NodeGroups`.
+ MinCapacity — Jumlah minimum pecahan yang akan dikelola dengan penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
+ MaxCapacity — Jumlah pecahan maksimum yang akan dikelola oleh penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
**Example**
Dalam contoh berikut, Anda mendaftarkan sebuah ElastiCache cluster bernama `myscalablecluster` dengan Application Auto Scaling API. Pendaftaran ini menunjukkan bahwa klaster harus diskalakan secara dinamis agar memiliki satu hingga 5 replika.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:NodeGroups",
"MinCapacity": 1,
"MaxCapacity": 5
}
```
# Menetapkan kebijakan penskalaan
Konfigurasi kebijakan penskalaan pelacakan target direpresentasikan oleh blok JSON yang digunakan untuk mendefinisikan metrik dan nilai target. Anda dapat menyimpan konfigurasi kebijakan penskalaan sebagai blok JSON dalam file teks. Anda menggunakan file teks tersebut saat menjalankan AWS CLI atau Application Auto Scaling API. Untuk informasi selengkapnya tentang sintaks konfigurasi kebijakan, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)di Referensi API Application Auto Scaling.
Opsi berikut tersedia untuk menetapkan konfigurasi kebijakan penskalaan pelacakan target:
**Topics**
+ [Menggunakan metrik standar](#AutoScaling-Scaling-Predefined-Metric)
+ [Menggunakan metrik kustom](#AutoScaling-Scaling-Custom-Metric)
+ [Menggunakan periode pendinginan](#AutoScaling-Scaling-Cooldown-periods)
## Menggunakan metrik standar
Dengan menggunakan metrik yang telah ditentukan sebelumnya, Anda dapat dengan cepat menentukan kebijakan penskalaan pelacakan target untuk klaster Valkey dan Redis OSS yang ElastiCache berfungsi dengan pelacakan target di Auto Scaling. ElastiCache
Saat ini, ElastiCache mendukung metrik standar berikut di Auto NodeGroup Scaling:
+ **ElastiCachePrimaryEngineCPUUtilization**— Nilai rata-rata `EngineCPUUtilization` metrik di CloudWatch seluruh node primer di cluster.
+ **ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage**— Nilai rata-rata `DatabaseMemoryUsageCountedForEvictPercentage` metrik di CloudWatch seluruh node primer di cluster.
+ **ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage**— Nilai rata-rata `ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage` metrik di CloudWatch seluruh node primer di cluster.
Untuk informasi selengkapnya tentang metrik `EngineCPUUtilization`, `DatabaseMemoryUsageCountedForEvictPercentage` dan `DatabaseCapacityUsageCountedForEvictPercentage`, lihat [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md). Untuk menggunakan metrik standar dalam kebijakan penskalaan, Anda mengonfigurasi pelacakan target untuk kebijakan penskalaan Anda. Konfigurasi ini harus menyertakan `PredefinedMetricSpecification` untuk metrik standar dan TargetValue untuk nilai target metrik tersebut.
**Example**
Contoh berikut menjelaskan konfigurasi kebijakan tipikal untuk penskalaan pelacakan target untuk klaster Valkey dan Redis OSS. ElastiCache Dalam konfigurasi ini, metrik yang `ElastiCachePrimaryEngineCPUUtilization` telah ditentukan digunakan untuk menyesuaikan cluster berdasarkan pemanfaatan CPU rata-rata 40 persen di semua node primer di cluster.
```
{
"TargetValue": 40.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "ElastiCachePrimaryEngineCPUUtilization"
}
}
```
## Menggunakan metrik kustom
Dengan metrik kustom, Anda dapat menentukan kebijakan penskalaan pelacakan target yang memenuhi persyaratan kustom Anda. Anda dapat menentukan metrik kustom berdasarkan ElastiCache metrik apa pun yang berubah sebanding dengan penskalaan. Tidak semua ElastiCache metrik berfungsi untuk pelacakan target. Metrik harus berupa metrik pemanfaatan yang valid dan menjelaskan seberapa sibuk suatu instans. Nilai metrik harus meningkat atau menurun secara berbanding lurus dengan jumlah Serpihan dalam klaster. Peningkatan atau penurunan proporsional ini diperlukan untuk menggunakan data metrik untuk menskalakan jumlah serpihan ke luar atau ke dalam secara proporsional.
**Example**
Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik kustom menyesuaikan cluster ElastiCache untuk Redis OSS berdasarkan pemanfaatan CPU rata-rata 50 persen di semua pecahan dalam cluster bernama. `my-db-cluster`
```
{
"TargetValue": 50,
"CustomizedMetricSpecification":
{
"MetricName": "EngineCPUUtilization",
"Namespace": "AWS/ElastiCache",
"Dimensions": [
{
"Name": "ReplicationGroup","Value": "my-db-cluster"
},
{
"Name": "Role","Value": "PRIMARY"
}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## Menggunakan periode pendinginan
Anda dapat menentukan nilai, dalam detik, untuk `ScaleOutCooldown` guna menambahkan periode pendinginan untuk menskalakan klaster Anda ke luar. Demikian pula, Anda dapat menentukan nilai, dalam detik, untuk `ScaleInCooldown` guna menambahkan periode pendinginan untuk menskalakan klaster Anda ke dalam. Untuk informasi selengkapnya, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)di Referensi API Application Auto Scaling.
Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik yang `ElastiCachePrimaryEngineCPUUtilization` telah ditentukan digunakan untuk menyesuaikan cluster ElastiCache for Redis OSS berdasarkan pemanfaatan CPU rata-rata 40 persen di semua node utama di cluster tersebut. Konfigurasi ini menyediakan periode pendinginan penskalaan ke dalam selama 10 menit dan periode pendinginan penskalaan ke luar selama 5 menit.
```
{
"TargetValue": 40.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "ElastiCachePrimaryEngineCPUUtilization"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# Menonaktifkan aktivitas penskalaan ke dalam
Anda dapat mencegah konfigurasi kebijakan penskalaan pelacakan target dari penskalaan di klaster Anda dengan menonaktifkan aktivitas penskalaan. Menonaktifkan aktivitas penskalaan ke dalam mencegah kebijakan penskalaan menghapus serpihan, namun masih memungkinkan kebijakan penskalaan untuk membuatnya sesuai kebutuhan.
Anda dapat menentukan nilai Boolean untuk `DisableScaleIn` guna mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam untuk klaster Anda. Untuk informasi selengkapnya, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)di Referensi API Application Auto Scaling.
Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik yang `ElastiCachePrimaryEngineCPUUtilization` telah ditentukan menyesuaikan cluster ElastiCache untuk Valkey dan Redis OSS berdasarkan pemanfaatan CPU rata-rata 40 persen di semua node utama di cluster itu. Konfigurasi ini menonaktifkan aktivitas penskalaan ke dalam untuk kebijakan penskalaan.
```
{
"TargetValue": 40.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "ElastiCachePrimaryEngineCPUUtilization"
},
"DisableScaleIn": true
}
```
# Menerapkan kebijakan penskalaan
Setelah mendaftarkan klaster Anda dengan ElastiCache penskalaan otomatis Valkey dan Redis OSS dan menentukan kebijakan penskalaan, Anda menerapkan kebijakan penskalaan ke klaster terdaftar. Untuk menerapkan kebijakan penskalaan ke klaster Redis OSS, Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling. ElastiCache
## Menerapkan kebijakan penskalaan menggunakan AWS CLI
Untuk menerapkan kebijakan penskalaan ke klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)perintah dengan parameter berikut:
+ **--policy-name** – Nama kebijakan penskalaan.
+ **--policy-name** – Atur nilai ini ke `TargetTrackingScaling`.
+ **--resource-id** — Pengidentifikasi sumber daya. Untuk parameter ini, tipe sumber daya adalah `ReplicationGroup` dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ **--service-namespace** – Atur nilai ini ke `elasticache`.
+ **--scalable-dimension** – Atur nilai ini ke `elasticache:replication-group:NodeGroups`.
+ **-- target-tracking-scaling-policy -configuration - Konfigurasi** kebijakan penskalaan pelacakan target yang akan digunakan untuk klaster.
Dalam contoh berikut, Anda menerapkan kebijakan penskalaan pelacakan target yang diberi nama `myscalablepolicy` untuk klaster Valkey dan Redis OSS yang ElastiCache diberi nama dengan penskalaan otomatis. `myscalablecluster` ElastiCache Untuk melakukannya, Anda menggunakan konfigurasi kebijakan yang disimpan dalam file bernama `config.json`.
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling put-scaling-policy \
--policy-name myscalablepolicy \
--policy-type TargetTrackingScaling \
--resource-id replication-group/myscalablecluster \
--service-namespace elasticache \
--scalable-dimension elasticache:replication-group:NodeGroups \
--target-tracking-scaling-policy-configuration file://config.json
```
Untuk Windows:
```
aws application-autoscaling put-scaling-policy ^
--policy-name myscalablepolicy ^
--policy-type TargetTrackingScaling ^
--resource-id replication-group/myscalablecluster ^
--service-namespace elasticache ^
--scalable-dimension elasticache:replication-group:NodeGroups ^
--target-tracking-scaling-policy-configuration file://config.json
```
## Menerapkan kebijakan penskalaan menggunakan API
Untuk menerapkan kebijakan penskalaan ke klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [PutScalingPolicy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI perintah dengan parameter berikut:
+ **--policy-name** – Nama kebijakan penskalaan.
+ **--resource-id** — Pengidentifikasi sumber daya. Untuk parameter ini, tipe sumber daya adalah `ReplicationGroup` dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ **--service-namespace** – Atur nilai ini ke `elasticache`.
+ **--scalable-dimension** – Atur nilai ini ke `elasticache:replication-group:NodeGroups`.
+ **-- target-tracking-scaling-policy -configuration - Konfigurasi** kebijakan penskalaan pelacakan target yang akan digunakan untuk klaster.
Dalam contoh berikut, Anda menerapkan kebijakan penskalaan pelacakan target yang diberi nama `myscalablepolicy` ke ElastiCache kluster yang diberi nama dengan penskalaan `myscalablecluster` otomatis ElastiCache . Anda menggunakan konfigurasi kebijakan berdasarkan pada metrik standar `ElastiCachePrimaryEngineCPUUtilization`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "myscalablepolicy",
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:NodeGroups",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 40.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "ElastiCachePrimaryEngineCPUUtilization"
}
}
}
```
# Mengedit kebijakan penskalaan
Anda dapat mengedit kebijakan penskalaan menggunakan API Konsol Manajemen AWS, Application Auto Scaling AWS CLI, atau Application Auto Scaling.
## Mengedit kebijakan penskalaan menggunakan Konsol Manajemen AWS
**Untuk mengedit kebijakan Auto Scaling untuk klaster Valkey dan Redis OSS ElastiCache**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih mesin yang sesuai.
1. Pilih klaster yang ingin Anda tambahi kebijakan (pilih nama klaster, bukan tombol di sebelah kirinya).
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan penskalaan**, pilih tombol di samping kebijakan Auto Scaling yang ingin Anda ubah, lalu pilih **Ubah**.
1. Buat perubahan yang diperlukan pada kebijakan.
1. Pilih **Ubah**.
## Mengedit kebijakan penskalaan menggunakan AWS CLI dan API
Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling untuk mengedit kebijakan penskalaan dengan cara yang sama seperti Anda menerapkan kebijakan penskalaan:
+ Saat menggunakan AWS CLI, tentukan nama kebijakan yang ingin Anda edit di `--policy-name` parameter. Tentukan nilai baru untuk parameter yang ingin Anda ubah.
+ Saat menggunakan API Application Auto Scaling, tentukan nama kebijakan yang ingin Anda edit dalam parameter `PolicyName`. Tentukan nilai baru untuk parameter yang ingin Anda ubah.
Lihat informasi yang lebih lengkap di [Menerapkan kebijakan penskalaan](AutoScaling-Scaling-Applying-a-Scaling-Policy.md).
# Menghapus kebijakan penskalaan
Anda dapat menghapus kebijakan penskalaan menggunakan API Konsol Manajemen AWS, Application Auto Scaling AWS CLI, atau Application Auto Scaling.
## Menghapus kebijakan penskalaan menggunakan Konsol Manajemen AWS
**Untuk menghapus kebijakan Auto Scaling untuk klaster Redis ElastiCache OSS**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang kebijakan Auto Scaling-nya ingin Anda edit (pilih nama klaster, bukan tombol di sebelah kiri).
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan penskalaan**, pilih kebijakan Auto Scaling, lalu pilih **Hapus**.
## Menghapus kebijakan penskalaan menggunakan AWS CLI
Untuk menghapus kebijakan penskalaan ke klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/delete-scaling-policy.html) AWS CLI perintah dengan parameter berikut:
+ **--policy-name** – Nama kebijakan penskalaan.
+ **--resource-id** — Pengidentifikasi sumber daya. Untuk parameter ini, tipe sumber daya adalah `ReplicationGroup` dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ **--service-namespace** – Atur nilai ini ke `elasticache`.
+ **--scalable-dimension** – Atur nilai ini ke `elasticache:replication-group:NodeGroups`.
Dalam contoh berikut, Anda menghapus kebijakan penskalaan pelacakan target yang dinamai `myscalablepolicy` dari kluster bernama. `myscalablecluster`
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling delete-scaling-policy \
--policy-name myscalablepolicy \
--resource-id replication-group/myscalablecluster \
--service-namespace elasticache \
--scalable-dimension elasticache:replication-group:NodeGroups
```
Untuk Windows:
```
aws application-autoscaling delete-scaling-policy ^
--policy-name myscalablepolicy ^
--resource-id replication-group/myscalablecluster ^
--service-namespace elasticache ^
--scalable-dimension elasticache:replication-group:NodeGroups
```
## Menghapus kebijakan penskalaan menggunakan API
Untuk menghapus kebijakan penskalaan ke klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [DeleteScalingPolicy](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/delete-scaling-policy.html) AWS CLI perintah dengan parameter berikut:
+ **--policy-name** – Nama kebijakan penskalaan.
+ **--resource-id** — Pengidentifikasi sumber daya. Untuk parameter ini, tipe sumber daya adalah `ReplicationGroup` dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ **--service-namespace** – Atur nilai ini ke `elasticache`.
+ **--scalable-dimension** – Atur nilai ini ke `elasticache:replication-group:NodeGroups`.
Dalam contoh berikut, Anda menghapus kebijakan penskalaan pelacakan target yang dinamai `myscalablepolicy` dari kluster bernama. `myscalablecluster`
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "myscalablepolicy",
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:NodeGroups"
}
```
# Gunakan CloudFormation untuk kebijakan Auto Scaling
Cuplikan ini menunjukkan cara membuat kebijakan pelacakan target dan menerapkannya ke [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticache-replicationgroup.html)sumber daya menggunakan sumber daya. [AWS::ApplicationAutoScaling::ScalableTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalabletarget.html) Tindakan tersebut menggunakan fungsi intrinsik [Fn::Join](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html) dan [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html) untuk membangun properti `ResourceId` dengan nama logis sumber daya `AWS::ElastiCache::ReplicationGroup` yang ditentukan dalam templat yang sama.
```
ScalingTarget:
Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
Properties:
MaxCapacity: 3
MinCapacity: 1
ResourceId: !Sub replication-group/${logicalName}
ScalableDimension: 'elasticache:replication-group:NodeGroups'
ServiceNamespace: elasticache
RoleARN: !Sub "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/elasticache.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG"
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
ScalingTargetId: !Ref ScalingTarget
ServiceNamespace: elasticache
PolicyName: testpolicy
PolicyType: TargetTrackingScaling
ScalableDimension: 'elasticache:replication-group:NodeGroups'
TargetTrackingScalingPolicyConfiguration:
PredefinedMetricSpecification:
PredefinedMetricType: ElastiCachePrimaryEngineCPUUtilization
TargetValue: 40
```
# Penskalaan terjadwal
Penskalaan berdasarkan jadwal memungkinkan Anda menskalakan aplikasi sebagai respons terhadap perubahan permintaan yang dapat diprediksi. Untuk menggunakan penskalaan terjadwal, Anda membuat tindakan terjadwal, yang memberi tahu Valkey dan Redis OSS ElastiCache untuk melakukan aktivitas penskalaan pada waktu tertentu. Saat membuat tindakan terjadwal, Anda menentukan klaster yang ada, kapan aktivitas penskalaan harus terjadi, kapasitas minimum, dan kapasitas maksimum. Anda dapat membuat tindakan terjadwal yang menskalakan satu kali saja atau menskalakan berdasarkan jadwal berulang.
Anda hanya dapat membuat tindakan terjadwal untuk cluster yang sudah ada. Anda tidak dapat membuat tindakan terjadwal pada saat yang sama saat Anda membuat klaster.
Untuk informasi selengkapnya tentang terminologi untuk pembuatan, manajemen, dan penghapusan tindakan terjadwal, lihat [Perintah yang umum digunakan untuk pembuatan, manajemen, dan penghapusan tindakan terjadwal ](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html#scheduled-scaling-commonly-used-commands)
**Untuk membuat jadwal berulang:**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang ingin Anda tambahkan kebijakannya.
1. Pilih **Kelola kebijakan Auto Scaling** dari drop-down **Tindakan**.
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan Auto Scaling**, kotak dialog **Tambahkan kebijakan penskalaan** akan muncul. Pilih **Penskalaan terjadwal**.
1. Untuk **Nama Kebijakan**, masukkan nama kebijakan.
1. Untuk **Dimensi yang Dapat Diskalakan**, pilih **Serpihan**.
1. Untuk **Serpihan Target**, pilih nilai.
1. Untuk **Perulangan**, pilih **Berulang**.
1. Untuk **Frekuensi**, pilih nilai masing-masing.
1. Untuk **Tanggal Mulai** dan **Waktu mulai**, pilih waktu dari kapan kebijakan akan berlaku.
1. Pilih **Tambahkan kebijakan**.
**Untuk membuat tindakan terjadwal satu kali:**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang ingin Anda tambahkan kebijakannya.
1. Pilih **Kelola kebijakan Auto Scaling** dari drop-down **Tindakan**.
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan Auto Scaling**, kotak dialog **Tambahkan kebijakan penskalaan** akan muncul. Pilih **Penskalaan terjadwal**.
1. Untuk **Nama Kebijakan**, masukkan nama kebijakan.
1. Untuk **Dimensi yang Dapat Diskalakan**, pilih **Serpihan**.
1. Untuk **Serpihan Target**, pilih nilai.
1. Untuk **Perulangan**, pilih **Satu Kali**.
1. Untuk **Tanggal Mulai** dan **Waktu mulai**, pilih waktu dari kapan kebijakan akan berlaku.
1. Untuk **Tanggal Berakhir** pilih sampai tanggal kapan kebijakan akan berlaku.
1. Pilih **Tambahkan kebijakan**.
**Untuk menghapus tindakan terjadwal**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang ingin Anda tambahkan kebijakannya.
1. Pilih **Kelola kebijakan Auto Scaling** dari drop-down **Tindakan**.
1. Pilih tab **Kebijakan Auto Scaling**.
1. Pada bagian **Kebijakan Auto Scaling**, pilih kebijakan Auto Scaling, lalu pilih **Hapus** dari dialog **Tindakan**.
**Untuk mengelola penskalaan terjadwal menggunakan AWS CLI **
Gunakan APIs aplikasi-autoscaling berikut:
+ [put-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/put-scheduled-action.html)
+ [describe-scheduled-actions](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-scheduled-actions.html)
+ [delete-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/delete-scheduled-action.html)
## Gunakan CloudFormation untuk membuat tindakan terjadwal
Cuplikan ini menunjukkan cara membuat kebijakan pelacakan target dan menerapkannya ke [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticache-replicationgroup.html)sumber daya menggunakan sumber daya. [AWS::ApplicationAutoScaling::ScalableTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalabletarget.html) Tindakan tersebut menggunakan fungsi intrinsik [Fn::Join](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html) dan [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html) untuk membangun properti `ResourceId` dengan nama logis sumber daya `AWS::ElastiCache::ReplicationGroup` yang ditentukan dalam templat yang sama.
```
ScalingTarget:
Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
Properties:
MaxCapacity: 3
MinCapacity: 1
ResourceId: !Sub replication-group/${logicalName}
ScalableDimension: 'elasticache:replication-group:NodeGroups'
ServiceNamespace: elasticache
RoleARN: !Sub "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/elasticache.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG"
ScheduledActions:
- EndTime: '2020-12-31T12:00:00.000Z'
ScalableTargetAction:
MaxCapacity: '5'
MinCapacity: '2'
ScheduledActionName: First
Schedule: 'cron(0 18 * * ? *)'
```
# Menggunakan Auto Scaling dengan replika
Grup ElastiCache replikasi dapat mengatur satu atau lebih cache untuk bekerja sebagai simpul logis tunggal.
Berikut ini memberikan rincian tentang pelacakan target dan kebijakan terjadwal dan bagaimana menerapkannya menggunakan Konsol Manajemen AWS AWS CLI dan APIs.
# Kebijakan penskalaan pelacakan target
Dengan kebijakan penskalaan pelacakan target, Anda memilih metrik dan menetapkan nilai target. ElastiCache untuk Valkey dan Redis OSS AutoScaling membuat dan mengelola CloudWatch alarm yang memicu kebijakan penskalaan dan menghitung penyesuaian penskalaan berdasarkan metrik dan nilai target. Kebijakan penskalaan menambahkan atau menghapus replika secara seragam di semua serpihan yang diperlukan untuk menjaga metrik pada, atau mendekati, nilai target yang ditentukan. Selain menjaga metrik agar mendekati nilai target, kebijakan penskalaan pelacakan target juga menyesuaikan dengan fluktuasi metrik karena fluktuasi pola beban dan meminimalkan fluktuasi cepat dalam kapasitas armada.
## Kriteria Auto Scaling untuk replika
Kebijakan Auto Scaling menentukan metrik standar berikut untuk klaster Anda:
`ElastiCacheReplicaEngineCPUUtilization`: Ambang batas pemanfaatan AVG EngineCPU digabungkan di semua replika yang digunakan ElastiCache untuk memicu operasi auto-scaling. Anda dapat menetapkan target pemanfaatan antara 35 persen dan 70 persen.
Ketika layanan mendeteksi bahwa `ElastiCacheReplicaEngineCPUUtilization` metrik Anda sama dengan atau lebih besar dari pengaturan Target, itu akan meningkatkan replika di seluruh pecahan Anda secara otomatis. ElastiCache skala replika cluster Anda dengan hitungan yang sama dengan yang lebih besar dari dua angka: Variasi persen dari Target dan satu replika. Untuk scale-in, ElastiCache tidak akan auto scale-in kecuali nilai metrik keseluruhan di bawah 75 persen dari Target yang Anda tentukan.
Sebagai contoh penskalaan ke luar, jika Anda memiliki 5 serpihan dan 1 replika masing-masing:
Jika Target Anda melanggar 30 persen, ElastiCache untuk Valkey dan Redis OSS skala sebesar 1 replika (maks (0,3, default 1)) di semua pecahan. yang menghasilkan 5 pecahan dengan masing-masing 2 replika,
Untuk contoh scale-in, jika Anda telah memilih nilai Target 60 persen, ElastiCache untuk Valkey dan Redis OSS tidak akan auto scale-in sampai metrik kurang dari atau sama dengan 45 persen (25 persen di bawah Target 60 persen).
### Pertimbangan untuk Auto Scaling
Perhatikan sejumlah pertimbangan berikut:
+ Kebijakan penskalaan pelacakan target mengasumsikan bahwa penskalaan ke luar harus dilakukan saat metrik yang ditentukan berada di atas nilai target. Anda tidak dapat menggunakan kebijakan penskalaan pelacakan target untuk memperkecil skala ketika metrik yang ditentukan berada di bawah nilai target. ElastiCache untuk Valkey dan Redis OSS menskalakan replika dengan maksimum (% deviasi dibulatkan dari Target, default 1) dari replika yang ada di semua pecahan di cluster.
+ Kebijakan penskalaan pelacakan target tidak melakukan penskalaan saat metrik yang ditentukan tidak memiliki data yang mencukupi. Kebijakan penskalaan pelacakan target tidak melakukan penskalaan ke dalam karena data yang tidak mencukupi tidak ditafsirkan sebagai pemanfaatan yang rendah.
+ Anda mungkin melihat kesenjangan antara nilai target dan titik data metrik yang aktual. Ini karena ElastiCache Auto Scaling selalu bertindak konservatif dengan membulatkan ke atas atau ke bawah ketika menentukan berapa banyak kapasitas untuk menambah atau menghapus. Hal ini mencegah layanan menambahkan kapasitas yang tidak mencukupi atau menghapus kapasitas terlalu banyak.
+ Untuk memastikan ketersediaan aplikasi, layanan menskalakan ke luar secara proporsional berdasarkan metrik secepat mungkin, tetapi menskalakan ke dalam secara lebih bertahap dengan penskalaan ke dalam maksimal 1 replika di seluruh serpihan di klaster.
+ Anda dapat memiliki beberapa kebijakan penskalaan pelacakan target ElastiCache untuk klaster Valkey dan Redis OSS, asalkan masing-masing menggunakan metrik yang berbeda. Tujuan Auto Scaling adalah untuk selalu memprioritaskan ketersediaan, sehingga perilakunya berbeda tergantung pada apakah kebijakan pelacakan target siap untuk skala atau skala. Fitur ini akan menskalakan ke luar layanan jika salah satu kebijakan pelacakan target siap untuk diskalakan ke luar. Namun, penskalaan ke dalam akan dilakukan hanya jika semua kebijakan pelacakan target (dengan porsi penskalaan ke dalam diaktifkan) siap untuk diskalakan ke dalam.
+ Jangan mengedit atau menghapus CloudWatch alarm yang dikelola ElastiCache Auto Scaling untuk kebijakan penskalaan pelacakan target. Auto Scaling menghapus alarm secara otomatis saat Anda menghapus kebijakan penskalaan atau menghapus klaster.
+ ElastiCache Auto Scaling tidak mencegah Anda memodifikasi replika secara manual di seluruh pecahan. Penyesuaian manual ini tidak memengaruhi CloudWatch alarm yang ada yang melekat pada kebijakan penskalaan, tetapi dapat memengaruhi metrik yang dapat memicu alarm ini. CloudWatch
+ CloudWatch Alarm yang dikelola oleh Auto Scaling ini ditentukan melalui metrik AVG di semua pecahan di cluster. Jadi, serpihan dengan lalu lintas tertinggi dapat menghasilkan salah satu skenario berikut:
+ penskalaan saat tidak diperlukan karena beban pada beberapa pecahan panas yang memicu alarm CloudWatch
+ tidak melakukan penskalaan saat diperlukan karena AVG agregat di semua serpihan yang memengaruhi alarm tidak terlampaui.
+ ElastiCache batas default pada node per cluster masih berlaku. Jadi, saat memilih Auto Scaling dan jika Anda mengharapkan simpul maksimum lebih dari batas default, minta peningkatan batas di [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
+ Pastikan Anda memiliki cukup ENIs (Antarmuka Jaringan Elastis) yang tersedia di VPC Anda, yang diperlukan selama penskalaan. Untuk informasi selengkapnya, lihat [Antarmuka Jaringan Elastis](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ElasticNetworkInterfaces.html).
+ Jika kapasitas tidak cukup tersedia EC2, ElastiCache Auto Scaling tidak akan ditingkatkan hingga kapasitas tersedia, atau jika Anda memodifikasi cluster secara manual ke jenis instans yang memiliki kapasitas cukup.
+ ElastiCache Auto Scaling tidak mendukung penskalaan replika dengan cluster yang memiliki `ReservedMemoryPercent` kurang dari 25 persen. Lihat informasi yang lebih lengkap di [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
# Menambahkan kebijakan penskalaan
Anda dapat menambahkan kebijakan penskalaan menggunakan. Konsol Manajemen AWS
**Menambahkan kebijakan penskalaan menggunakan Konsol Manajemen AWS**
Untuk menambahkan kebijakan penskalaan otomatis ElastiCache untuk Valkey dan Redis OSS
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Pilih klaster yang ingin Anda tambahi kebijakan (pilih nama klaster, bukan tombol di sebelah kirinya).
1. Pilih tab **Kebijakan Auto Scaling**.
1. Pilih **Tambahkan penskalaan dinamis**.
1. Di bagian **Kebijakan penskalaan**, pilih **Tambahkan penskalaan dinamis**.
1. Untuk **Nama Kebijakan**, masukkan nama kebijakan.
1. Untuk **Dimensi yang Dapat Diskalakan**, pilih **Replika** dari kotak dialog.
1. Untuk nilai target, ketikkan persentase Avg dari pemanfaatan CPU yang ingin Anda pertahankan di ElastiCache Replicas. Nilai ini harus >=35 dan <=70. Replika klaster ditambahkan atau dihapus untuk menjaga metrik tetap mendekati nilai yang ditentukan.
1. (Opsional) Periode pendinginan penskalaan ke dalam atau penskalaan ke luar tidak didukung dari Konsol. Gunakan AWS CLI untuk memodifikasi nilai pendinginan.
1. Untuk **kapasitas Minimum**, ketikkan jumlah replika minimum yang harus dipertahankan oleh kebijakan ElastiCache Auto Scaling.
1. Untuk **kapasitas Maksimum**, ketikkan jumlah maksimum replika yang harus dipertahankan oleh kebijakan ElastiCache Auto Scaling. Nilai ini harus >=5.
1. Pilih **Buat**.
# Mendaftarkan Target yang Dapat Diskalakan
Anda dapat menerapkan kebijakan penskalaan berdasarkan metrik standar atau kustom. Untuk melakukannya, Anda dapat menggunakan Application Auto Scaling AWS CLI API atau Application Auto Scaling. Langkah pertama adalah mendaftarkan grup replikasi Valkey dan Redis OSS Anda ElastiCache dengan Auto Scaling.
Sebelum Anda dapat menggunakan ElastiCache auto scaling dengan cluster, Anda harus mendaftarkan cluster Anda dengan ElastiCache auto scaling. Anda melakukannya untuk menentukan dimensi dan batas penskalaan yang akan diterapkan ke cluster itu. ElastiCache auto scaling secara dinamis menskalakan cluster di sepanjang dimensi yang `elasticache:replication-group:Replicas` dapat diskalakan, yang mewakili jumlah replika cluster per shard.
**Menggunakan CLI**
Untuk mendaftarkan ElastiCache cluster Anda, gunakan [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)perintah dengan parameter berikut:
+ --service-namespace – Atur nilai ini ke elasticache.
+ --resource-id — Pengidentifikasi sumber daya untuk cluster. ElastiCache Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ --scalable-dimension – Atur nilai ini ke `elasticache:replication-group:Replicas`.
+ --min-capacity — Jumlah minimum replika yang akan dikelola dengan penskalaan otomatis. ElastiCache Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
+ --max-capacity — Jumlah maksimum replika yang akan dikelola dengan penskalaan otomatis. ElastiCache Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
**Example**
Dalam contoh berikut, Anda mendaftarkan sebuah ElastiCache cluster bernama`myscalablecluster`. Pendaftaran ini menunjukkan bahwa klaster harus diskalakan secara dinamis agar memiliki satu hingga 5 replika.
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling register-scalable-target \
--service-namespace elasticache \
--resource-id replication-group/myscalablecluster \
--scalable-dimension elasticache:replication-group:Replicas \
--min-capacity 1 \
--max-capacity 5 \
```
Untuk Windows:
```
aws application-autoscaling register-scalable-target ^
--service-namespace elasticache ^
--resource-id replication-group/myscalablecluster ^
--scalable-dimension elasticache:replication-group:Replicas ^
--min-capacity 1 ^
--max-capacity 5 ^
```
**Menggunakan API**
Untuk mendaftarkan ElastiCache cluster Anda, gunakan [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)perintah dengan parameter berikut:
+ ServiceNamespace — Tetapkan nilai ini ke elasticache.
+ ResourceId — Pengenal sumber daya untuk cluster. ElastiCache Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ ScalableDimension — Tetapkan nilai ini ke`elasticache:replication-group:Replicas`.
+ MinCapacity — Jumlah minimum replika yang akan dikelola dengan penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
+ MaxCapacity — Jumlah maksimum replika yang akan dikelola oleh penskalaan ElastiCache otomatis. Untuk informasi tentang hubungan antara --min-capacity, --max-capacity, dan jumlah replika dalam klaster Anda, lihat [Kapasitas minimum dan maksimum](AutoScaling-Policies.md#AutoScaling-MinMax).
**Example**
Dalam contoh berikut, Anda mendaftarkan klaster bernama `myscalablecluster` Application Auto Scaling API. Pendaftaran ini menunjukkan bahwa klaster harus diskalakan secara dinamis agar memiliki satu hingga 5 replika.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:Replicas",
"MinCapacity": 1,
"MaxCapacity": 5
}
```
# Menetapkan kebijakan penskalaan
Konfigurasi kebijakan penskalaan pelacakan target direpresentasikan oleh blok JSON yang digunakan untuk mendefinisikan metrik dan nilai target. Anda dapat menyimpan konfigurasi kebijakan penskalaan sebagai blok JSON dalam file teks. Anda menggunakan file teks tersebut saat menjalankan AWS CLI atau Application Auto Scaling API. Untuk informasi selengkapnya tentang sintaksis konfigurasi kebijakan, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) dalam *Referensi API Application Auto Scaling*.
Opsi berikut tersedia untuk menetapkan konfigurasi kebijakan penskalaan pelacakan target:
**Topics**
+ [Menggunakan metrik standar](#AutoScaling-Predefined-Metric)
+ [Mengedit kebijakan penskalaan](AutoScaling-Editing-Policy.md)
+ [Menghapus kebijakan penskalaan](AutoScaling-Deleting-Policy.md)
+ [Gunakan CloudFormation untuk kebijakan Auto Scaling](AutoScaling-with-Cloudformation.md)
+ [Penskalaan terjadwal](AutoScaling-with-Scheduled-Scaling-Replicas.md)
## Menggunakan metrik standar
Konfigurasi kebijakan penskalaan pelacakan target direpresentasikan oleh blok JSON yang digunakan untuk mendefinisikan metrik dan nilai target. Anda dapat menyimpan konfigurasi kebijakan penskalaan sebagai blok JSON dalam file teks. Anda menggunakan file teks tersebut saat menjalankan AWS CLI atau Application Auto Scaling API. Untuk informasi selengkapnya tentang sintaksis konfigurasi kebijakan, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) dalam *Referensi API Application Auto Scaling*.
Opsi berikut tersedia untuk menetapkan konfigurasi kebijakan penskalaan pelacakan target:
**Topics**
+ [Menggunakan metrik standar](#AutoScaling-Predefined-Metric)
+ [Menggunakan metrik kustom](#AutoScaling-Custom-Metric)
+ [Menggunakan periode pendinginan](#AutoScaling-Using-Cooldowns)
+ [Menonaktifkan aktivitas penskalaan ke dalam](#AutoScaling-Disabling-Scalein)
+ [Menerapkan kebijakan penskalaan ke klaster ElastiCache Valkey dan Redis OSS](#AutoScaling-Applying-Policy)
### Menggunakan metrik standar
Dengan menggunakan metrik yang telah ditentukan sebelumnya, Anda dapat dengan cepat menentukan kebijakan penskalaan pelacakan target untuk klaster Valkey dan Redis OSS yang ElastiCache berfungsi dengan pelacakan target di Auto Scaling. ElastiCache Saat ini, ElastiCache mendukung metrik standar berikut di Auto Scaling ElastiCache Replika:
`ElastiCacheReplicaEngineCPUUtilization`— Nilai rata-rata CPUUtilization metrik Engine CloudWatch di semua replika di cluster. Anda dapat menemukan nilai metrik agregat di CloudWatch bawah ElastiCache `ReplicationGroupId, Role` untuk Replica Required ReplicationGroupId dan Role Replica.
Untuk menggunakan metrik standar dalam kebijakan penskalaan, Anda membuat konfigurasi pelacakan target untuk kebijakan penskalaan Anda. Konfigurasi ini harus menyertakan `PredefinedMetricSpecification` untuk metrik standar dan `TargetValue` untuk nilai target metrik tersebut.
### Menggunakan metrik kustom
Dengan menggunakan metrik kustom, Anda dapat menentukan kebijakan penskalaan pelacakan target yang memenuhi persyaratan kustom Anda. Anda dapat menentukan metrik kustom berdasarkan metrik Valkey dan Redis OSS apa pun ElastiCache yang berubah sebanding dengan penskalaan. Tidak semua ElastiCache metrik berfungsi untuk pelacakan target. Metrik harus berupa metrik pemanfaatan yang valid dan menjelaskan seberapa sibuk suatu instans. Nilai metrik harus meningkat atau menurun proporsinya terhadap jumlah replika dalam klaster. Peningkatan atau penurunan proporsional ini diperlukan untuk menggunakan data metrik untuk meningkatkan atau menurunkan jumlah replika secara proporsional.
**Example**
Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik kustom menyesuaikan cluster berdasarkan pemanfaatan CPU rata-rata 50 persen di semua replika dalam sebuah cluster bernama. `my-db-cluster`
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "EngineCPUUtilization",
"Namespace": "AWS/ElastiCache",
"Dimensions": [
{"Name": "ReplicationGroup","Value": "my-db-cluster"},
{"Name": "Role","Value": "REPLICA"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
### Menggunakan periode pendinginan
Anda dapat menentukan nilai, dalam detik, untuk `ScaleOutCooldown` guna menambahkan periode pendinginan untuk menskalakan klaster Anda ke luar. Demikian pula, Anda dapat menentukan nilai, dalam detik, untuk `ScaleInCooldown` guna menambahkan periode pendinginan untuk menskalakan klaster Anda ke dalam. Untuk informasi selengkapnya tentang `ScaleInCooldown` dan `ScaleOutCooldown`, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) dalam *Referensi API Application Auto Scaling*. Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik yang `ElastiCacheReplicaEngineCPUUtilization` telah ditentukan digunakan untuk menyesuaikan cluster berdasarkan pemanfaatan CPU rata-rata 40 persen di semua replika di cluster itu. Konfigurasi ini menyediakan periode pendinginan penskalaan ke dalam selama 10 menit dan periode pendinginan penskalaan ke luar selama 5 menit.
```
{"TargetValue": 40.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "ElastiCacheReplicaEngineCPUUtilization"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
### Menonaktifkan aktivitas penskalaan ke dalam
Anda dapat mencegah konfigurasi kebijakan penskalaan pelacakan target dari penskalaan di klaster Valkey dan Redis ElastiCache OSS Anda dengan menonaktifkan aktivitas penskalaan. Menonaktifkan aktivitas penskalaan ke dalam mencegah kebijakan penskalaan menghapus replika, namun masih memungkinkan kebijakan penskalaan untuk menambahkannya sesuai kebutuhan.
Anda dapat menentukan nilai Boolean untuk `DisableScaleIn` guna mengaktifkan atau menonaktifkan aktivitas penskalaan ke dalam untuk klaster Anda. Untuk informasi selengkapnya tentang `DisableScaleIn`, lihat [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) dalam *Referensi API Application Auto Scaling*.
**Example**
Contoh berikut menjelaskan konfigurasi pelacakan target untuk kebijakan penskalaan. Dalam konfigurasi ini, metrik yang `ElastiCacheReplicaEngineCPUUtilization` telah ditentukan menyesuaikan cluster berdasarkan pemanfaatan CPU rata-rata 40 persen di semua replika di cluster itu. Konfigurasi ini menonaktifkan aktivitas penskalaan ke dalam untuk kebijakan penskalaan.
```
{"TargetValue": 40.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "ElastiCacheReplicaEngineCPUUtilization"
},
"DisableScaleIn": true
}
```
### Menerapkan kebijakan penskalaan ke klaster ElastiCache Valkey dan Redis OSS
Setelah mendaftarkan klaster Anda dengan ElastiCache penskalaan otomatis Valkey dan Redis OSS dan menentukan kebijakan penskalaan, Anda menerapkan kebijakan penskalaan ke klaster terdaftar. Untuk menerapkan kebijakan penskalaan ke klaster Valkey dan Redis OSS, Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling. ElastiCache
**Menggunakan AWS CLI**
Untuk menerapkan kebijakan penskalaan ke klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/put-scaling-policy.html)perintah dengan parameter berikut:
+ --policy-name – Nama kebijakan penskalaan.
+ --policy-name – Atur nilai ini ke `TargetTrackingScaling`.
+ --resource-id — Pengidentifikasi sumber daya untuk cluster. Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ --service-namespace – Atur nilai ini ke elasticache.
+ --scalable-dimension – Atur nilai ini ke `elasticache:replication-group:Replicas`.
+ -- target-tracking-scaling-policy -configuration - Konfigurasi kebijakan penskalaan pelacakan target yang akan digunakan untuk klaster.
**Example**
Dalam contoh berikut, Anda menerapkan kebijakan penskalaan pelacakan target yang diberi nama `myscalablepolicy` ke kluster yang diberi nama dengan penskalaan `myscalablecluster` otomatis ElastiCache . Untuk melakukannya, Anda menggunakan konfigurasi kebijakan yang disimpan dalam file bernama `config.json`.
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling put-scaling-policy \
--policy-name myscalablepolicy \
--policy-type TargetTrackingScaling \
--resource-id replication-group/myscalablecluster \
--service-namespace elasticache \
--scalable-dimension elasticache:replication-group:Replicas \
--target-tracking-scaling-policy-configuration file://config.json
```
```
{"TargetValue": 40.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "ElastiCacheReplicaEngineCPUUtilization"
},
"DisableScaleIn": true
}
```
Untuk Windows:
```
aws application-autoscaling put-scaling-policy ^
--policy-name myscalablepolicy ^
--policy-type TargetTrackingScaling ^
--resource-id replication-group/myscalablecluster ^
--service-namespace elasticache ^
--scalable-dimension elasticache:replication-group:Replicas ^
--target-tracking-scaling-policy-configuration file://config.json
```
**Menggunakan API**
Untuk menerapkan kebijakan penskalaan ke ElastiCache klaster Anda dengan Application Auto Scaling API, gunakan [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)operasi Application Auto Scaling API dengan parameter berikut:
+ PolicyName — Nama kebijakan penskalaan.
+ PolicyType — Tetapkan nilai ini ke`TargetTrackingScaling`.
+ ResourceId — Pengidentifikasi sumber daya untuk cluster. Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster ElastiCache untuk Redis OSS, misalnya. `replication-group/myscalablecluster`
+ ServiceNamespace — Tetapkan nilai ini ke elasticache.
+ ScalableDimension — Tetapkan nilai ini ke`elasticache:replication-group:Replicas`.
+ TargetTrackingScalingPolicyConfiguration — Konfigurasi kebijakan penskalaan pelacakan target yang akan digunakan untuk klaster.
**Example**
Dalam contoh berikut, Anda menerapkan kebijakan penskalaan pelacakan target yang diberi nama `scalablepolicy` ke kluster yang diberi nama dengan penskalaan `myscalablecluster` otomatis ElastiCache . Anda menggunakan konfigurasi kebijakan berdasarkan pada metrik standar `ElastiCacheReplicaEngineCPUUtilization`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "myscalablepolicy",
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:Replicas",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 40.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "ElastiCacheReplicaEngineCPUUtilization"
}
}
}
```
# Mengedit kebijakan penskalaan
Anda dapat mengedit kebijakan penskalaan menggunakan API Konsol Manajemen AWS, Application Auto Scaling AWS CLI, atau Application Auto Scaling.
**Mengedit kebijakan penskalaan menggunakan Konsol Manajemen AWS**
Anda hanya dapat mengedit kebijakan dengan jenis Metrik standar menggunakan Konsol Manajemen AWS
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. **Di panel navigasi, pilih **Valkey** atau Redis OSS**
1. Pilih klaster yang ingin Anda tambahi kebijakan (pilih nama klaster, bukan tombol di sebelah kirinya).
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan penskalaan**, pilih tombol di samping kebijakan Auto Scaling yang ingin Anda ubah, lalu pilih **Ubah**.
1. Buat perubahan yang diperlukan pada kebijakan.
1. Pilih **Ubah**.
1. Buat perubahan pada kebijakan.
1. Pilih **Ubah**.
**Mengedit kebijakan penskalaan menggunakan AWS CLI atau Application Auto Scaling API**
Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling untuk mengedit kebijakan penskalaan dengan cara yang sama seperti Anda menerapkan kebijakan penskalaan:
+ Saat menggunakan API Application Auto Scaling, tentukan nama kebijakan yang ingin Anda edit dalam parameter `PolicyName`. Tentukan nilai baru untuk parameter yang ingin Anda ubah.
Lihat informasi yang lebih lengkap di [Menerapkan kebijakan penskalaan ke klaster ElastiCache Valkey dan Redis OSS](AutoScaling-Defining-Policy.md#AutoScaling-Applying-Policy).
# Menghapus kebijakan penskalaan
Anda dapat menghapus kebijakan penskalaan menggunakan Konsol Manajemen AWS, Application Auto Scaling API AWS CLI atau Application Auto Scaling
**Menghapus kebijakan penskalaan menggunakan Konsol Manajemen AWS**
Anda hanya dapat mengedit kebijakan dengan jenis Metrik standar menggunakan Konsol Manajemen AWS
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol Amazon di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. **Di panel navigasi, pilih **Valkey** atau Redis OSS**
1. Pilih klaster yang kebijakan Auto Scaling-nya ingin Anda hapus.
1. Pilih tab **Kebijakan Auto Scaling**.
1. Di bagian **Kebijakan penskalaan**, pilih kebijakan Auto Scaling, lalu pilih **Hapus**.
**Menghapus kebijakan penskalaan menggunakan AWS CLI atau Application Auto Scaling API**
Anda dapat menggunakan Application Auto Scaling API AWS CLI atau Application Auto Scaling untuk menghapus kebijakan penskalaan dari klaster. ElastiCache
**CLI**
Untuk menghapus kebijakan penskalaan dari klaster Valkey dan Redis OSS Anda ElastiCache , gunakan [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)perintah dengan parameter berikut:
+ --policy-name – Nama kebijakan penskalaan.
+ --resource-id — Pengidentifikasi sumber daya untuk cluster. Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ --service-namespace – Atur nilai ini ke elasticache.
+ --scalable-dimension – Atur nilai ini ke `elasticache:replication-group:Replicas`.
**Example**
Dalam contoh berikut, Anda menghapus kebijakan penskalaan pelacakan target yang disebut `myscalablepolicy` dari ElastiCache for Redis bernama `myscalablecluster`.
Untuk Linux, macOS, atau Unix:
```
aws application-autoscaling delete-scaling-policy \
--policy-name myscalablepolicy \
--resource-id replication-group/myscalablecluster \
--service-namespace elasticache \
--scalable-dimension elasticache:replication-group:Replicas \
```
Untuk Windows:
```
aws application-autoscaling delete-scaling-policy ^
--policy-name myscalablepolicy ^
--resource-id replication-group/myscalablecluster ^
--service-namespace elasticache ^
--scalable-dimension elasticache:replication-group:Replicas ^
```
**API**
Untuk menghapus kebijakan penskalaan dari klaster Valkey dan Redis OSS Anda ElastiCache , gunakan operasi [DeleteScalingPolicy](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_DeleteScalingPolicy.html)Application Auto Scaling API dengan parameter berikut:
+ PolicyName — Nama kebijakan penskalaan.
+ ResourceId — Pengidentifikasi sumber daya untuk cluster. Untuk parameter ini, tipe sumber daya adalah ReplicationGroup dan pengidentifikasi unik adalah nama cluster, misalnya`replication-group/myscalablecluster`.
+ ServiceNamespace — Tetapkan nilai ini ke elasticache.
+ ScalableDimension — Tetapkan nilai ini ke`elasticache:replication-group:Replicas`.
Dalam contoh berikut, Anda menghapus kebijakan penskalaan pelacakan target yang diberi nama `myscalablepolicy` dari klaster bernama `myscalablecluster` dengan Application Auto Scaling API.
```
POST / HTTP/1.1
>>>>>>> mainline
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
Content-Length: 219
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "myscalablepolicy",
"ServiceNamespace": "elasticache",
"ResourceId": "replication-group/myscalablecluster",
"ScalableDimension": "elasticache:replication-group:Replicas"
}
```
# Gunakan CloudFormation untuk kebijakan Auto Scaling
Cuplikan ini menunjukkan cara membuat tindakan terjadwal dan menerapkannya ke [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticache-replicationgroup.html)sumber daya menggunakan sumber daya. [AWS::ApplicationAutoScaling::ScalableTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalabletarget.html) Tindakan tersebut menggunakan fungsi intrinsik [Fn::Join](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html) dan [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html) untuk membangun properti `ResourceId` dengan nama logis sumber daya `AWS::ElastiCache::ReplicationGroup` yang ditentukan dalam templat yang sama.
```
ScalingTarget:
Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
Properties:
MaxCapacity: 0
MinCapacity: 0
ResourceId: !Sub replication-group/${logicalName}
ScalableDimension: 'elasticache:replication-group:Replicas'
ServiceNamespace: elasticache
RoleARN: !Sub "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/elasticache.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG"
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
ScalingTargetId: !Ref ScalingTarget
ServiceNamespace: elasticache
PolicyName: testpolicy
PolicyType: TargetTrackingScaling
ScalableDimension: 'elasticache:replication-group:Replicas'
TargetTrackingScalingPolicyConfiguration:
PredefinedMetricSpecification:
PredefinedMetricType: ElastiCacheReplicaEngineCPUUtilization
TargetValue: 40
```
# Penskalaan terjadwal
Penskalaan berdasarkan jadwal memungkinkan Anda menskalakan aplikasi sebagai respons terhadap perubahan permintaan yang dapat diprediksi. Untuk menggunakan penskalaan terjadwal, Anda membuat tindakan terjadwal, yang memberi tahu Valkey dan Redis OSS ElastiCache untuk melakukan aktivitas penskalaan pada waktu tertentu. Saat membuat tindakan terjadwal, Anda menentukan ElastiCache klaster yang ada, kapan aktivitas penskalaan harus terjadi, kapasitas minimum, dan kapasitas maksimum. Anda dapat membuat tindakan terjadwal yang menskalakan satu kali saja atau menskalakan berdasarkan jadwal berulang.
Anda hanya dapat membuat tindakan terjadwal untuk ElastiCache cluster yang sudah ada. Anda tidak dapat membuat tindakan terjadwal pada saat yang sama saat Anda membuat klaster.
Untuk informasi selengkapnya tentang terminologi untuk pembuatan, manajemen, dan penghapusan tindakan terjadwal, lihat [Perintah yang umum digunakan untuk pembuatan, manajemen, dan penghapusan tindakan terjadwal ](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html#scheduled-scaling-commonly-used-commands)
**Untuk membuat tindakan terjadwal satu kali:**
Mirip dengan dimensi Serpihan. Lihat [Penskalaan terjadwal](AutoScaling-with-Scheduled-Scaling-Shards.md).
**Untuk menghapus tindakan terjadwal**
Mirip dengan dimensi Serpihan. Lihat [Penskalaan terjadwal](AutoScaling-with-Scheduled-Scaling-Shards.md).
**Untuk mengelola penskalaan terjadwal menggunakan AWS CLI **
Gunakan APIs aplikasi-autoscaling berikut:
+ [put-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scheduled-action.html)
+ [describe-scheduled-actions](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scheduled-actions.html)
+ [delete-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scheduled-action.html)
## Gunakan CloudFormation untuk membuat kebijakan Auto Scaling
Cuplikan ini menunjukkan cara membuat tindakan terjadwal dan menerapkannya ke [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticache-replicationgroup.html)sumber daya menggunakan sumber daya. [AWS::ApplicationAutoScaling::ScalableTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalabletarget.html) Tindakan tersebut menggunakan fungsi intrinsik [Fn::Join](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html) dan [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html) untuk membangun properti `ResourceId` dengan nama logis sumber daya `AWS::ElastiCache::ReplicationGroup` yang ditentukan dalam templat yang sama.
```
ScalingTarget:
Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
Properties:
MaxCapacity: 0
MinCapacity: 0
ResourceId: !Sub replication-group/${logicalName}
ScalableDimension: 'elasticache:replication-group:Replicas'
ServiceNamespace: elasticache
RoleARN: !Sub "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/elasticache.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ElastiCacheRG"
ScheduledActions:
- EndTime: '2020-12-31T12:00:00.000Z'
ScalableTargetAction:
MaxCapacity: '5'
MinCapacity: '2'
ScheduledActionName: First
Schedule: 'cron(0 18 * * ? *)'
```
# Mengubah mode klaster
Valkey dan Redis OSS adalah database dalam memori terdistribusi yang mendukung sharding dan replikasi. ElastiCache Cluster Valkey dan Redis OSS adalah implementasi terdistribusi yang memungkinkan data dipartisi di beberapa node. Cluster ElastiCache untuk Redis OSS memiliki dua mode operasi, mode Cluster diaktifkan (CME) dan mode cluster dinonaktifkan (CMD). Di CME, mesin Valkey dan Redis OSS bekerja sebagai database terdistribusi dengan beberapa pecahan dan node, sedangkan di CMD, Valkey dan Redis OSS bekerja sebagai node tunggal.
Sebelum bermigrasi dari CMD ke CME, kondisi berikut harus dipenuhi:
**penting**
Konfigurasi mode klaster hanya dapat diubah dari mode klaster dinonaktifkan ke mode klaster diaktifkan. Konfigurasi ini tidak dapat dikembalikan.
+ Klaster mungkin hanya memiliki kunci dalam basis data 0 saja.
+ Aplikasi harus menggunakan klien Valkey atau Redis OSS yang mampu menggunakan protokol Cluster dan menggunakan titik akhir konfigurasi.
+ Failover otomatis harus diaktifkan pada klaster dengan minimal 1 replika.
+ Versi mesin minimum yang diperlukan untuk migrasi adalah Valkey 7.2 ke atas, atau Redis OSS 7.0 ke atas.
Untuk bermigrasi dari CMD ke CME, konfigurasi mode klaster harus diubah dari mode klaster dinonaktifkan ke mode klaster diaktifkan. Ini adalah prosedur dua langkah yang memastikan ketersediaan klaster selama proses migrasi.
**catatan**
Anda perlu menyediakan grup parameter dengan konfigurasi klaster diaktifkan, yaitu parameter klaster diaktifkan diatur ke `yes`. Jika Anda menggunakan grup parameter default, ElastiCache untuk Redis OSS akan secara otomatis memilih grup parameter default yang sesuai dengan konfigurasi cluster-enabled. Nilai parameter yang didukung klaster diatur ke `no` untuk klaster CMD. Saat klaster beralih ke mode yang kompatibel, nilai parameter klaster diaktifkan akan diperbarui ke `yes` sebagai bagian dari tindakan perubahan.
Untuk informasi selengkapnya, lihat [Mengkonfigurasi parameter mesin menggunakan grup ElastiCache parameter](ParameterGroups.md)
1. **Siapkan** — Buat cluster CME uji dan pastikan tumpukan Anda siap untuk bekerja dengannya. ElastiCache untuk Redis OSS tidak memiliki cara untuk memverifikasi kesiapan Anda. Untuk informasi selengkapnya, lihat [Membuat cluster untuk Valkey atau Redis OSS](Clusters.Create.md).
1. **Ubah Konfigurasi CMD Cluster yang ada ke mode cluster yang kompatibel** - Dalam mode ini, akan ada pecahan tunggal yang digunakan, dan ElastiCache untuk Redis OSS akan berfungsi sebagai node tunggal tetapi juga sebagai cluster shard tunggal. Mode yang kompatibel berarti aplikasi klien dapat menggunakan kedua protokol untuk berkomunikasi dengan klaster. Dalam mode ini, aplikasi harus dikonfigurasi ulang untuk mulai menggunakan protokol Valkey atau Redis OSS Cluster dan titik akhir konfigurasi. Untuk mengubah mode cluster Valkey atau Redis OSS ke mode cluster yang kompatibel, ikuti langkah-langkah di bawah ini:
**catatan**
Dalam mode kompatibel, operasi perubahan lainnya seperti penskalaan dan versi mesin tidak diizinkan untuk klaster. Selain itu, parameter (tidak termasuk`cacheParameterGroupName`) tidak dapat dimodifikasi saat menentukan parameter mode cluster dalam permintaan. [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)
1. Menggunakan Konsol Manajemen AWS, melihat [Mengubah grup replikasi](Replication.Modify.md) dan mengatur mode cluster ke **Kompatibel**
1. Menggunakan API, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)dan perbarui `ClusterMode` parameter ke`compatible`.
1. Menggunakan AWS CLI, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)dan perbarui `cluster-mode` parameter ke`compatible`.
Setelah mengubah mode cluster Valkey atau Redis OSS ke mode cluster yang kompatibel, [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)API akan mengembalikan titik akhir konfigurasi cluster Redis OSS ElastiCache untuk. Titik akhir konfigurasi klaster adalah titik akhir tunggal yang dapat digunakan oleh aplikasi untuk terhubung ke klaster. Untuk informasi selengkapnya, lihat [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md).
1. **Mengubah Konfigurasi Klaster ke mode klaster diaktifkan** – Setelah mode klaster diatur ke mode klaster kompatibel, langkah kedua adalah mengubah konfigurasi klaster ke mode klaster diaktifkan. Dalam mode ini, serpihan tunggal sedang berjalan, dan pelanggan sekarang dapat menskalakan klaster mereka atau mengubah konfigurasi klaster lainnya.
Untuk mengubah mode klaster ke diaktifkan, ikuti langkah di bawah:
Sebelum memulai, pastikan klien Valkey atau Redis OSS Anda telah bermigrasi menggunakan protokol cluster dan titik akhir konfigurasi cluster tidak digunakan.
1. Menggunakan Konsol Manajemen AWS, lihat [Mengubah grup replikasi](Replication.Modify.md) dan atur mode cluster ke **Enabled**.
1. Menggunakan API, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)dan perbarui `ClusterMode` parameter ke`enabled`.
1. Menggunakan AWS CLI, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)dan perbarui `cluster-mode` parameter ke`enabled`.
Setelah mengubah mode cluster menjadi diaktifkan, titik akhir akan dikonfigurasi sesuai spesifikasi cluster Valkey atau Redis OSS. [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)API akan mengembalikan parameter mode cluster sebagai `enabled` dan titik akhir cluster yang sekarang tersedia untuk digunakan oleh aplikasi untuk terhubung ke cluster.
Perhatikan bahwa titik akhir klaster akan berubah setelah mode klaster diubah menjadi diaktifkan. Pastikan untuk memperbarui aplikasi Anda dengan titik akhir baru.
Anda juga dapat memilih untuk kembali ke mode klaster dinonaktifkan (CMD) dari mode klaster yang kompatibel dan mempertahankan konfigurasi asli.
**Mengubah Konfigurasi Klaster ke mode klaster dinonaktifkan dari mode klaster kompatibel**
1. Menggunakan Konsol Manajemen AWS, melihat [Mengubah grup replikasi](Replication.Modify.md) dan mengatur mode cluster ke **Dinonaktifkan**
1. Menggunakan API, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)dan perbarui `ClusterMode` parameter ke`disabled`.
1. Menggunakan AWS CLI, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)dan perbarui `cluster-mode` parameter ke`disabled`.
Setelah mengubah mode cluster menjadi dinonaktifkan, [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)API akan mengembalikan parameter mode cluster sebagai`disabled`.
# Replikasi lintas AWS Wilayah menggunakan datastores global
**catatan**
Global Datastore saat ini hanya tersedia untuk cluster berbasis node.
Dengan menggunakan fitur Global Datastore, Anda dapat bekerja dengan replikasi klaster Valkey atau Redis OSS yang dikelola sepenuhnya, cepat, andal, dan aman di seluruh Wilayah.AWS Dengan menggunakan fitur ini, Anda dapat membuat klaster replika baca lintas wilayah untuk mengaktifkan pembacaan latensi rendah dan pemulihan bencana di seluruh Wilayah.AWS
Di bagian berikutnya, Anda dapat menemukan deskripsi tentang cara menggunakan penyimpanan data global.
**Topics**
+ [Gambaran Umum](#Redis-Global-Data-Stores-Overview)
+ [Prasyarat dan batasan](Redis-Global-Datastores-Getting-Started.md)
+ [Menggunakan penyimpanan data global (konsol)](Redis-Global-Datastores-Console.md)
+ [Menggunakan penyimpanan data global (CLI)](Redis-Global-Datastores-CLI.md)
## Gambaran Umum
Setiap *penyimpanan data global* adalah kumpulan dari satu klaster atau lebih yang mereplikasi satu sama lain.
Penyimpanan data global mencakup klaster berikut:
+ **Klaster primer (aktif) ** – Klaster primer menerima operasi tulis yang direplikasi ke semua klaster dalam penyimpanan data global. Klaster primer juga menerima permintaan baca.
+ **Klaster sekunder (pasif) ** – Klaster sekunder hanya menerima permintaan baca dan mereplikasi pembaruan data dari klaster primer. Cluster sekunder harus berada di AWS Wilayah yang berbeda dari cluster primer.
Saat Anda membuat datastore global ElastiCache untuk Valkey atau Redis OSS, data tersebut secara otomatis mereplikasi data Anda dari cluster primer ke cluster sekunder. Anda memilih AWS Wilayah di mana data Valkey atau Redis OSS harus direplikasi dan kemudian membuat cluster sekunder di Wilayah itu.AWS ElastiCache kemudian mengatur dan mengelola replikasi data asinkron otomatis antara dua cluster.
Menggunakan datastore global untuk Valkey atau Redis OSS memberikan keuntungan sebagai berikut:
+ **Kinerja geolokal** — Dengan menyiapkan klaster replika jarak jauh di AWS Wilayah tambahan dan menyinkronkan data Anda di antara mereka, Anda dapat mengurangi latensi akses data di Wilayah tersebut.AWS Datastore global dapat membantu meningkatkan daya tanggap aplikasi Anda dengan menyajikan pembacaan geolokal latensi rendah di seluruh Wilayah.AWS
+ **Pemulihan bencana** – Jika klaster primer di penyimpanan data global mengalami penurunan, Anda dapat mempromosikan klaster sekunder sebagai klaster primer baru Anda. Anda dapat melakukannya dengan menghubungkan ke AWS Wilayah mana pun yang berisi cluster sekunder.
Diagram berikut menunjukkan cara kerja penyimpanan data global.
![\[penyimpanan data global\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/Global-DataStore.png)
# Prasyarat dan batasan
Sebelum mulai menggunakan penyimpanan data global, perhatikan sejumlah hal berikut:
+ Datastores global didukung di Wilayah berikut: AWS
+ **Afrika** - Cape Town
+ **Asia Pasifik** - Hong Kong, Hyderabad, Jakarta, Malaysia, Melbourne, Mumbai, Osaka, Seoul, Singapura, Sydney, Thailand, dan Tokyo
+ **Kanada** - Kanada Tengah dan Kanada Barat (Calgary)
+ **Tiongkok** - Beijing dan Ningxia
+ **Eropa** - Frankfurt, London, Irlandia, Milan, Paris, Spanyol, Stockholm, dan Zurich
+ **AWS GovCloud**-AS-Barat dan AS-Timur
+ **Israel** - Tel Aviv
+ **Timur Tengah** - Bahrain dan UEA
+ **AS** - Timur (Virginia N. dan Ohio) dan AS Barat (California N. dan Oregon)
+ **Amerika Selatan** - Meksiko (Tengah) dan São Paulo
+ Semua klaster—primer dan sekunder—di penyimpanan data global Anda harus memiliki kesamaan dalam hal jumlah simpul primer, jenis simpul, versi mesin, dan jumlah serpihan (dalam kasus mode klaster diaktifkan). Setiap klaster di penyimpanan data global Anda dapat memiliki jumlah replika baca yang berbeda untuk mengakomodasi lalu lintas baca lokal untuk klaster tersebut.
Replikasi harus diaktifkan jika Anda berencana menggunakan klaster simpul tunggal yang sudah ada.
+ Datastores global didukung pada contoh ukuran besar dan di atas.
+ Anda dapat mengatur replikasi untuk klaster utama dari satu AWS Wilayah ke cluster sekunder hingga dua AWS Wilayah lainnya.
**catatan**
Pengecualian berlaku pada Wilayah Tiongkok (Beijing) dan Tiongkok (Ningxia), di mana replikasi hanya dapat terjadi di antara kedua wilayah itu.
+ Anda dapat menggunakan penyimpanan data global hanya dalam klaster VPC. Untuk informasi selengkapnya, lihat [Pola Akses untuk Mengakses ElastiCache Cache di VPC Amazon](elasticache-vpc-accessing.md). Datastores global tidak didukung saat Anda menggunakan -Classic. EC2 Untuk informasi selengkapnya, lihat [EC2-Klasik](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/ec2-classic-platform.html) di *Panduan EC2 Pengguna Amazon*.
**catatan**
Untuk saat ini, Anda tidak dapat menggunakan penyimpanan data global di [Menggunakan zona lokal dengan ElastiCache](Local_zones.md).
+ ElastiCache tidak mendukung autofailover dari satu AWS Wilayah ke Wilayah lainnya. Jika diperlukan, Anda dapat mempromosikan klaster sekunder secara manual. Sebagai contoh, lihat [Mempromosikan klaster sekunder menjadi primer](Redis-Global-Datastores-Console.md#Redis-Global-Datastores-Console-Promote-Secondary).
+ Untuk melakukan bootstrap dari data yang sudah ada, gunakan klaster yang sudah ada sebagai klaster primer untuk membuat penyimpanan data global. Sebaiknya jangan menambahkan klaster yang sudah ada sebagai klaster sekunder. Proses penambahan klaster sebagai klaster sekunder akan menghapus data, yang dapat mengakibatkan hilangnya data.
+ Pembaruan parameter diterapkan untuk semua klaster saat Anda mengubah grup parameter lokal dari klaster yang termasuk dalam penyimpanan data global.
+ Anda dapat menskalakan klaster regional baik secara vertikal (menaikkan dan menurunkan skala) maupun horizontal (menskalakan ke dalam dan ke luar). Anda dapat menskalakan klaster dengan mengubah penyimpanan data global. Selanjutnya, semua klaster regional pada penyimpanan data global akan diskalakan tanpa gangguan. Untuk informasi selengkapnya, lihat [Penskalaan ElastiCache](Scaling.md).
+ [Datastores global mendukung [enkripsi saat istirahat](at-rest-encryption.md), [enkripsi dalam perjalanan](in-transit-encryption.md), dan AUTH.](auth.md)
+ Datastores global tidak mendukung Internet Protocol versi 6 (). IPv6
+ Kunci dukungan datastores global. AWS KMS Untuk informasi selengkapnya, lihat [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) dalam *Panduan Developer AWS Key Management Service .*
**catatan**
Penyimpanan data global mendukung [pesan pub/sub](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-use-cases.html#elasticache-for-redis-use-cases-messaging) dengan ketentuan sebagai berikut:
Untuk mode cluster dinonaktifkan, didukung pub/sub sepenuhnya. Peristiwa yang diterbitkan di cluster utama AWS Wilayah primer disebarkan ke AWS Wilayah sekunder.
Untuk mode klaster diaktifkan, hal berikut berlaku:
Untuk acara yang dipublikasikan yang tidak berada di ruang kunci, hanya pelanggan di AWS Wilayah yang sama yang menerima acara tersebut.
Untuk acara keyspace yang dipublikasikan, pelanggan di semua AWS Wilayah menerima acara.
# Menggunakan penyimpanan data global (konsol)
Untuk membuat penyimpanan data global menggunakan konsol, ikuti proses dua langkah ini:
1. Buat klaster primer, baik menggunakan klaster yang sudah ada atau membuat klaster baru. Mesin harus Valkey 7.2 atau lebih baru, atau Redis OSS 5.0.6 atau lebih baru.
1. Tambahkan hingga dua cluster sekunder di AWS Wilayah yang berbeda, sekali lagi menggunakan Valkey 7.2 atau yang lebih baru, atau Redis OSS 5.0.6 atau yang lebih baru.
Prosedur berikut memandu Anda tentang cara membuat datastore global untuk Valkey atau Redis OSS dan melakukan operasi lain menggunakan konsol. ElastiCache
**Topics**
+ [Membuat penyimpanan data global menggunakan klaster yang sudah ada](#Redis-Global-Datastores-Console-Create-Primary)
+ [Membuat penyimpanan data global baru menggunakan klaster primer baru](#Redis-Global-Datastores-Create-From-Scratch)
+ [Melihat detail penyimpanan data global](#Redis-Global-Datastores-Console-Details)
+ [Menambahkan Wilayah ke penyimpanan data global](#Redis-Global-Datastores-Console-Create-Secondary)
+ [Mengubah penyimpanan data global](#Redis-Global-Datastores-Console-Modify-Regional-Clusters)
+ [Mempromosikan klaster sekunder menjadi primer](#Redis-Global-Datastores-Console-Promote-Secondary)
+ [Menghapus Wilayah dari penyimpanan data global](#Redis-Global-Datastore-Console-Remove-Region)
+ [Menghapus penyimpanan data global](#Redis-Global-Datastores-Console-Delete-GlobalDatastore)
## Membuat penyimpanan data global menggunakan klaster yang sudah ada
Dalam skenario ini, Anda menggunakan klaster yang sudah ada agar berfungsi sebagai klaster primer penyimpanan data global yang baru. Anda kemudian membuat klaster sekunder hanya baca di Wilayah AWS yang berbeda. Klaster sekunder ini menerima pembaruan otomatis dan asinkron dari klaster primer.
**penting**
Cluster yang ada harus menggunakan mesin yaitu Valkey 7.2 atau yang lebih baru atau Redis OSS 5.0.6 atau yang lebih baru.
**Untuk membuat penyimpanan data global menggunakan klaster yang sudah ada**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. **Pada panel navigasi, pilih **Global Datastores** dan kemudian pilih Create global datastore.**
1. Pada halaman **pengaturan klaster utama**, lakukan hal berikut:
+ Di bidang **info Datastore Global**, masukkan nama untuk datastore global baru.
+ (Opsional) Masukkan nilai **Deskripsi**.
1. Di bawah **Cluster Regional**, pilih **Gunakan klaster regional yang ada**.
1. Di bawah **Cluster** yang ada, pilih cluster yang ada yang ingin Anda gunakan.
1. Jangan ubah opsi berikut. Opsi tersebut sudah diisi otomatis agar sesuai dengan konfigurasi klaster primer dan Anda tidak dapat mengubahnya.
+ Versi mesin
+ Jenis simpul
+ Grup parameter
**catatan**
ElastiCache membuat otomatis grup parameter baru dari nilai grup parameter yang disediakan dan menerapkan grup parameter baru ke cluster. Gunakan grup parameter baru ini untuk mengubah parameter pada penyimpanan data global. Setiap grup parameter yang dihasilkan otomatis dikaitkan dengan hanya satu klaster dan, karena itu, hanya satu penyimpanan data global.
+ Jumlah serpihan
+ Enkripsi diam – Mengaktifkan enkripsi pada data yang disimpan di disk. Untuk informasi selengkapnya, lihat [Enkripsi diam](at-rest-encryption.md).
**catatan**
Anda dapat menyediakan kunci enkripsi yang berbeda dengan memilih kunci ** AWS KMS yang Dikelola Pelanggan** dan memilih kunci. Untuk informasi selengkapnya, lihat [Menggunakan kunci AWS KMS yang Dikelola Pelanggan](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ Enkripsi bergerak – Mengaktifkan enkripsi data selama pengiriman. Untuk informasi selengkapnya, lihat [Enkripsi bergerak](in-transit-encryption.md). **Untuk Valkey 7.2 dan seterusnya dan Redis OSS 6.0 dan seterusnya, jika Anda mengaktifkan enkripsi dalam perjalanan, Anda diminta untuk menentukan salah satu opsi Kontrol Akses berikut:**
+ **Tidak Ada Kontrol Akses** – Ini adalah pengaturan default. Hal ini menunjukkan tidak ada batasan.
+ **Daftar Kontrol Akses Grup Pengguna** – Pilih grup pengguna dengan sejumlah pengguna yang ditentukan dan izin untuk operasi yang tersedia. Untuk informasi selengkapnya, lihat [Mengelola Grup Pengguna dengan Konsol dan CLI](Clusters.RBAC.md#User-Groups).
+ **AUTH Default User** - Mekanisme otentikasi untuk server Valkey atau Redis OSS. Untuk informasi lebih lanjut, lihat [AUTH](auth.md).
1. (Opsional) Jika diperlukan, perbarui pengaturan klaster sekunder yang tersisa. Pengaturan ini sudah diisi otomatis dengan nilai yang sama dengan klaster primer, tetapi Anda dapat memperbarui nilainya untuk memenuhi persyaratan khusus untuk klaster tersebut.
+ Port
+ Jumlah replika
+ Grup subnet
+ Zona Ketersediaan Pilihan
+ Grup keamanan
+ Dikelola Pelanggan (kunci AWS KMS)
+ Token AUTH
+ Aktifkan pencadangan otomatis
+ Periode retensi cadangan
+ Periode pencadangan
+ Periode pemeliharaan
+ Topik untuk notifikasi SNS
1. Pilih **Buat**. Tindakan ini mengubah status penyimpanan data global menjadi **Membuat**. Status berubah menjadi **Mengubah** setelah klaster primer dikaitkan dengan penyimpanan data global dan klaster sekunder dalam status **Mengaitkan**.
Setelah klaster primer dan klaster sekunder dikaitkan dengan penyimpanan data global, status berubah menjadi **Tersedia**. Pada tahap ini, Anda memiliki klaster primer yang menerima operasi baca dan tulis serta klaster sekunder yang menerima operasi baca yang direplikasi dari klaster primer.
Halaman diperbarui untuk menunjukkan apakah klaster merupakan bagian dari datastore global, termasuk:
+ **Penyimpanan Data Global** – Nama penyimpanan data global yang menjadi asal klaster.
+ **Peran Penyimpanan Data Global** – Peran klaster, primer atau sekunder.
Anda dapat menambahkan hingga satu cluster sekunder tambahan di AWS Wilayah yang berbeda. Untuk informasi selengkapnya, lihat [Menambahkan Wilayah ke penyimpanan data global](#Redis-Global-Datastores-Console-Create-Secondary).
## Membuat penyimpanan data global baru menggunakan klaster primer baru
Jika Anda memilih untuk membuat penyimpanan data global dengan klaster baru, gunakan prosedur berikut.
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. **Pada panel navigasi, pilih **Global Datastores** dan kemudian pilih Create global datastore.**
1. Pada **Pengaturan klaster primer**, lakukan hal berikut:
1. Untuk **Mode klaster**, pilih **Diaktifkan** atau **Dinonaktifkan**.
1. **Untuk **info Global Datastore** masukkan nilai untuk Nama.** ElastiCache menggunakan akhiran untuk menghasilkan nama unik untuk datastore global. Anda dapat mencari penyimpanan data global menggunakan akhiran yang Anda tentukan di sini.
1. (Opsional) Masukkan nilai untuk **Deskripsi Penyimpanan Data Global**.
1. Di **Klaster regional**:
1. Untuk **Wilayah**, pilih AWS Wilayah yang tersedia.
1. Pilih **Buat klaster regional baru** atau **Gunakan klaster regional yang ada**
1. Jika Anda memilih **Buat klaster regional baru**, di **Info klaster**, masukkan nama dan deskripsi opsional klaster.
1. Untuk **Lokasi**, sebaiknya Anda menerima pengaturan default untuk **Multi-AZ** dan **Failover Otomatis**.
1. Di **Pengaturan klaster**
1. Untuk **Versi mesin**, pilih versi yang tersedia, yaitu 5.0.6 atau yang lebih baru.
1. Untuk **Port**, gunakan port default, 6379. Jika Anda memiliki alasan untuk menggunakan port lain, masukkan nomor port tersebut.
1. Untuk **Grup parameter**, pilih grup parameter atau buat yang baru. Grup parameter mengontrol parameter runtime dari klaster Anda. Untuk informasi selengkapnya tentang grup parameter, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) dan [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
**catatan**
Saat Anda memilih grup parameter untuk menetapkan nilai konfigurasi mesin, grup parameter tersebut diterapkan ke semua klaster di penyimpanan data global. Pada halaman **Grup Parameter**, atribut **Global** ya/tidak menunjukkan apakah grup parameter adalah bagian dari penyimpanan data global.
1. Untuk **Jenis simpul**, pilih panah bawah (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). Pada kotak dialog **Ubah jenis simpul**, pilih nilai untuk **Keluarga instans** untuk jenis simpul yang Anda inginkan. Kemudian pilih jenis simpul yang ingin Anda gunakan untuk klaster ini, lalu pilih **Simpan**.
Untuk informasi selengkapnya, lihat [Memilih ukuran simpul Anda](CacheNodes.SelectSize.md).
Jika Anda memilih jenis simpul r6gd, tingkatan data akan diaktifkan secara otomatis. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
1. Jika Anda membuat cluster Valkey atau Redis OSS (mode cluster dinonaktifkan):
Untuk **Jumlah replika**, pilih jumlah replika yang Anda inginkan untuk klaster ini.
1. Jika Anda membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan):
1. Untuk **Jumlah pecahan**, pilih jumlah pecahan (partisi/grup simpul) yang Anda inginkan untuk cluster Valkey atau Redis OSS (mode cluster diaktifkan) ini.
Untuk beberapa versi Valkey atau Redis OSS (mode cluster diaktifkan), Anda dapat mengubah jumlah pecahan di cluster Anda secara dinamis:
+ **Redis OSS 3.2.10 dan yang lebih baru** - Jika cluster Anda menjalankan Redis OSS 3.2.10 atau versi yang lebih baru, Anda dapat mengubah jumlah pecahan di cluster Anda secara dinamis. Untuk informasi selengkapnya, lihat [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md).
+ **Versi Redis OSS lainnya** - Jika cluster Anda menjalankan versi Redis OSS sebelum versi 3.2.10, ada pendekatan lain. Untuk mengubah jumlah serpihan di klaster Anda, buat klaster baru dengan jumlah serpihan baru. Untuk informasi selengkapnya, lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
1. Untuk **Replika per serpihan**, pilih jumlah simpul replika baca yang Anda inginkan dalam setiap serpihan.
Pembatasan berikut ada untuk Valkey atau Redis OSS (mode cluster diaktifkan).
+ Jika Multi-AZ diaktifkan, pastikan bahwa Anda memiliki setidaknya satu replika per serpihan.
+ Replika akan berjumlah sama untuk setiap serpihan saat membuat klaster menggunakan konsol.
+ Jumlah replika baca per serpihan bersifat tetap dan tidak dapat diubah. Jika Anda membutuhkan lebih banyak atau lebih sedikit replika per serpihan (API/CLI: grup simpul), Anda harus membuat klaster baru dengan jumlah replika yang baru. Untuk informasi selengkapnya, lihat [Tutorial: Menyemai cluster berbasis node baru dengan cadangan yang dibuat secara eksternal](backups-seeding-redis.md).
1. Untuk **pengaturan grup Subnet**, pilih subnet yang ingin Anda terapkan ke cluster ini. ElastiCache menyediakan grup IPv4 subnet default atau Anda dapat memilih untuk membuat yang baru. Untuk IPv6, Anda perlu membuat grup subnet dengan blok IPv6 CIDR. Jika Anda memilih **tumpukan ganda**, Anda harus memilih jenis IP Discovery, salah satu IPv6 atau IPv4.
Untuk informasi selengkapnya, lihat [Membuat subnet di VPC Anda](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet).
1. Untuk **Penempatan zona ketersediaan**, Anda memiliki dua opsi:
+ **Tidak ada preferensi** — ElastiCache memilih Availability Zone.
+ **Tentukan zona ketersediaan** – Anda menentukan Zona Ketersediaan untuk setiap klaster.
Jika Anda memilih untuk menentukan Zona Ketersediaan, untuk setiap klaster di setiap serpihan, pilih Zona Ketersediaan dari daftar.
Untuk informasi selengkapnya, lihat [Memilih wilayah dan zona ketersediaan untuk ElastiCache](RegionsAndAZs.md).
![\[Gambar: Menentukan Ruang Kunci dan Zona Ketersediaan\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-ClusterOn-Slots-AZs.png)
*Menentukan Ruang Kunci dan Zona Ketersediaan*
1. Pilih **Berikutnya**
1. Di bawah **pengaturan Advanced Valkey dan Redis** OSS
1. Untuk **Keamanan**:
1. Untuk mengenkripsi data Anda, Anda memiliki opsi berikut:
+ **Enkripsi diam** – Mengaktifkan enkripsi pada data yang disimpan di disk. Untuk informasi selengkapnya, lihat [Enkripsi Diam](at-rest-encryption.md).
**catatan**
Anda memiliki opsi untuk menyediakan kunci enkripsi yang berbeda dengan memilih kunci ** AWS KMS yang Dikelola Pelanggan** dan memilih kunci. Untuk informasi selengkapnya, lihat [Menggunakan kunci yang dikelola pelanggan dari AWS KMS](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Enkripsi bergerak** – Mengaktifkan enkripsi data selama pengiriman. Untuk informasi selengkapnya, lihat [Enkripsi bergerak](in-transit-encryption.md). **Untuk Valkey 7.2 dan di atasnya dan Redis OSS 6.0 ke atas, jika Anda mengaktifkan Enkripsi dalam perjalanan, Anda akan diminta untuk menentukan salah satu opsi Kontrol Akses berikut:**
+ **Tanpa Kontrol Akses** – Ini adalah pengaturan default. Opsi ini menunjukkan bahwa tidak ada batasan akses pengguna ke klaster.
+ **Daftar Kontrol Akses Grup Pengguna** – Pilih grup pengguna dengan kumpulan pengguna tertentu yang dapat mengakses klaster. Untuk informasi selengkapnya, lihat [Mengelola Grup Pengguna dengan Konsol dan CLI](Clusters.RBAC.md#User-Groups).
+ **AUTH Default User** - Mekanisme otentikasi untuk server Valkey atau Redis OSS. Untuk informasi lebih lanjut, lihat [AUTH](auth.md).
+ **AUTH** — Mekanisme otentikasi untuk server Valkey atau Redis OSS. Untuk informasi lebih lanjut, lihat [AUTH](auth.md).
**catatan**
Untuk versi Redis OSS antara 3.2.6 dan seterusnya, tidak termasuk versi 3.2.10, AUTH adalah satu-satunya pilihan.
1. Untuk **Grup keamanan**, pilih grup keamanan yang Anda inginkan untuk klaster ini. *Grup keamanan* bertindak sebagai firewall untuk mengontrol akses jaringan ke klaster Anda. Anda dapat menggunakan grup keamanan default untuk VPC Anda atau membuat yang baru.
Untuk informasi selengkapnya tentang grup keamanan, lihat [Grup Keamanan untuk VPC Anda](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) dalam *Panduan Pengguna Amazon VPC.*
1. Untuk pencadangan otomatis terjadwal secara berkala, pilih **Aktifkan pencadangan otomatis**, lalu masukkan jumlah hari yang diinginkan untuk mempertahankan cadangan otomatis sebelum dihapus secara otomatis. Jika Anda tidak ingin melakukan pencadangan otomatis terjadwal secara berkala, hapus kotak centang **Aktifkan pencadangan otomatis**. Apa pun pilihannya, Anda dapat membuat pencadangan secara manual kapan saja.
Untuk informasi selengkapnya tentang pencadangan dan pemulihan, lihat[Melakukan snapshot dan pemulihan](backups.md).
1. (Opsional) Tentukan periode pemeliharaan. *Jendela pemeliharaan* adalah waktu yang biasanya satu jam setiap minggu saat ElastiCache menjadwalkan pemeliharaan sistem untuk klaster Anda. Anda dapat mengizinkan ElastiCache untuk memilih hari dan waktu untuk jendela pemeliharaan Anda (*Tidak ada preferensi*), atau Anda dapat memilih hari, waktu, dan durasi sendiri (*Tentukan jendela pemeliharaan*). Jika Anda memilih *Tentukan periode pemeliharaan* dari daftar, pilih *Hari mulai*, *Waktu mulai*, dan *Durasi* (dalam jam) untuk periode pemeliharaan. Semua waktu menggunakan zona waktu UTC.
Untuk informasi selengkapnya, lihat [Mengelola pemeliharaan ElastiCache cluster](maintenance-window.md).
1. (Opsional) Untuk **Log**:
+ Di bagian **Format log**, pilih **Teks** atau **JSON**.
+ Di bawah **Jenis Tujuan**, pilih **CloudWatch Log** atau **Kinesis Firehose**.
+ Di bawah **Tujuan log**, pilih **Buat baru** dan masukkan nama grup CloudWatch log Log atau nama aliran Firehose Anda, atau **pilih Pilih yang ada, lalu pilih** nama grup CloudWatch log Log atau nama aliran Firehose Anda,
1. Untuk **Tag**, untuk membantu mengelola cluster dan ElastiCache sumber daya lainnya, Anda dapat menetapkan metadata Anda sendiri ke setiap sumber daya dalam bentuk tag. Untuk informasi selengkapnya, lihat [Menandai sumber daya Anda ElastiCache](Tagging-Resources.md).
1. Tinjau semua entri dan pilihan Anda, lalu lakukan koreksi yang diperlukan. Saat Anda siap, pilih **Berikutnya**.
1. Setelah Anda mengonfigurasi klaster di langkah sebelumnya, Anda sekarang harus mengonfigurasi detail klaster sekunder Anda.
1. Di bawah **kluster Regional**, pilih AWS Wilayah tempat klaster berada.
1. Di **Info klaster**, masukkan nama dan deskripsi opsional klaster.
1. Opsi berikut sudah diisi sebelumnya untuk menyesuaikan konfigurasi klaster primer dan tidak dapat diubah:
+ Lokasi
+ Versi mesin
+ Jenis instans
+ Jenis simpul
+ Jumlah serpihan
+ Grup parameter
**catatan**
ElastiCache membuat otomatis grup parameter baru dari nilai grup parameter yang disediakan dan menerapkan grup parameter baru ke cluster. Gunakan grup parameter baru ini untuk mengubah parameter pada penyimpanan data global. Setiap grup parameter yang dihasilkan otomatis dikaitkan dengan hanya satu klaster dan, karena itu, hanya satu penyimpanan data global.
+ Enkripsi diam – Mengaktifkan enkripsi pada data yang disimpan di disk. Untuk informasi selengkapnya, lihat [Enkripsi diam](at-rest-encryption.md).
**catatan**
Anda dapat menyediakan kunci enkripsi yang berbeda dengan memilih kunci ** AWS KMS yang Dikelola Pelanggan** dan memilih kunci. Untuk informasi selengkapnya, lihat [Menggunakan kunci AWS KMS yang Dikelola Pelanggan](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ Enkripsi bergerak – Mengaktifkan enkripsi data selama pengiriman. Untuk informasi selengkapnya, lihat [Enkripsi bergerak](in-transit-encryption.md). **Untuk Valkey 7.2 dan di atasnya dan Redis OSS 6.4 ke atas, jika Anda mengaktifkan enkripsi dalam perjalanan, Anda diminta untuk menentukan salah satu opsi Kontrol Akses berikut:**
+ **Tanpa Kontrol Akses** – Ini adalah pengaturan default. Opsi ini menunjukkan bahwa tidak ada batasan akses pengguna ke klaster.
+ **Daftar Kontrol Akses Grup Pengguna** – Pilih grup pengguna dengan kelompok pengguna tertentu yang dapat mengakses klaster. Untuk informasi selengkapnya, lihat [Mengelola Grup Pengguna dengan Konsol dan CLI](Clusters.RBAC.md#User-Groups).
+ **AUTH Default User** - Mekanisme otentikasi untuk server Valkey atau Redis OSS. Untuk informasi lebih lanjut, lihat [AUTH](auth.md).
**catatan**
Untuk versi Redis OSS antara 4.0.2, saat Enkripsi dalam transit pertama kali didukung, dan 6.0.4, AUTH adalah satu-satunya pilihan.
Pengaturan klaster sekunder yang tersisa diisi otomatis dengan nilai yang sama dengan klaster primer, tetapi daftar berikut ini dapat diperbarui untuk memenuhi persyaratan khusus untuk klaster tersebut:
+ Port
+ Jumlah replika
+ Grup subnet
+ Zona Ketersediaan Pilihan
+ Grup keamanan
+ Dikelola Pelanggan (kunci AWS KMS)
+ Token AUTH
+ Aktifkan pencadangan otomatis
+ Periode retensi cadangan
+ Periode pencadangan
+ Periode pemeliharaan
+ Topik untuk notifikasi SNS
1. Pilih **Buat**. Tindakan ini menetapkan status penyimpanan data global menjadi **Membuat**. Setelah klaster primer dan klaster sekunder dikaitkan dengan penyimpanan data global, status berubah menjadi **Tersedia**. Anda memiliki klaster primer yang menerima operasi baca dan tulis serta klaster sekunder yang menerima operasi baca yang direplikasi dari klaster primer.
Halaman ini juga diperbarui untuk menunjukkan apakah klaster merupakan bagian dari datastore global, termasuk yang berikut ini:
+ **Penyimpanan Data Global** – Nama penyimpanan data global yang menjadi asal klaster.
+ **Peran Penyimpanan Data Global** – Peran klaster, primer atau sekunder.
Anda dapat menambahkan hingga satu cluster sekunder tambahan di AWS Wilayah yang berbeda. Untuk informasi selengkapnya, lihat [Menambahkan Wilayah ke penyimpanan data global](#Redis-Global-Datastores-Console-Create-Secondary).
## Melihat detail penyimpanan data global
Anda dapat melihat detail datastores global yang ada dan juga memodifikasinya di halaman **Global** Datastores.
**Untuk melihat detail penyimpanan data global**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Datastores Global dan kemudian pilih datastore** global yang tersedia.
Anda kemudian dapat memeriksa properti penyimpanan data global berikut:
+ **Nama Penyimpanan Data Global:** Nama penyimpanan data global
+ **Deskripsi:** Deskripsi tentang penyimpanan data global
+ **Status:** Opsinya meliputi:
+ Membuat
+ Mengubah
+ Tersedia
+ Menghapus
+ Hanya Primer - Status ini menunjukkan bahwa penyimpanan data global hanya berisi klaster primer. Kemungkinan semua klaster sekunder dihapus atau tidak berhasil dibuat.
+ **Mode Klaster:** Diaktifkan atau dinonaktifkan
+ **Versi Mesin: Versi mesin** Valkey atau Redis OSS yang menjalankan datastore global
+ **Jenis Simpul Instans:** Jenis simpul yang digunakan untuk penyimpanan data global
+ **Enkripsi saat tidak digunakan:** Diaktifkan atau dinonaktifkan
+ **Enkripsi bergerak:** Diaktifkan atau dinonaktifkan
+ **AUTH:** Entah diaktifkan atau dinonaktifkan
Anda dapat membuat perubahan berikut pada penyimpanan data global:
+ [Menambahkan Wilayah ke penyimpanan data global](#Redis-Global-Datastores-Console-Create-Secondary)
+ [Menghapus Wilayah dari penyimpanan data global](#Redis-Global-Datastore-Console-Remove-Region)
+ [Mempromosikan klaster sekunder menjadi primer](#Redis-Global-Datastores-Console-Promote-Secondary)
+ [Mengubah penyimpanan data global](#Redis-Global-Datastores-Console-Modify-Regional-Clusters)
Halaman Penyimpanan Data Global juga mencantumkan klaster individual yang membentuk penyimpanan data global dan properti berikut untuk masing-masing:
+ **Wilayah** - AWS Wilayah tempat cluster disimpan
+ **Peran** - Primer atau sekunder
+ **Nama klaster**: Nama klaster
+ **Status** - Opsinya meliputi:
+ **Mengaitkan** - Klaster sedang dalam proses dikaitkan dengan penyimpanan data global
+ **Dikaitkan** - Klaster sudah dikaitkan dengan penyimpanan data global
+ **Tidak mengaitkan** - Proses menghapus klaster sekunder dari penyimpanan data global menggunakan nama penyimpanan data global. Setelah ini, cluster sekunder tidak lagi menerima pembaruan dari cluster primer tetapi tetap sebagai cluster mandiri di AWS Wilayah itu.
+ **Terpisah** - Klaster sekunder telah dihapus dari penyimpanan data global dan sekarang menjadi klaster mandiri di Wilayah AWS .
+ **Kelambatan Replika Datastore Global** - Menunjukkan satu nilai per AWS Wilayah sekunder di datastore global. Ini adalah lag antara simpul primer dari Wilayah sekunder dan simpul primer dari Wilayah primer. Untuk mode cluster yang diaktifkan Valkey atau Redis OSS, lag menunjukkan penundaan maksimum dalam hitungan detik di antara pecahan.
## Menambahkan Wilayah ke penyimpanan data global
Anda dapat menambahkan hingga satu AWS Wilayah tambahan ke datastore global yang ada. Dalam skenario ini, Anda membuat klaster hanya-baca di AWS Wilayah terpisah yang menerima pembaruan otomatis dan asinkron dari cluster utama.
**Untuk menambahkan AWS Region ke datastore global**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Datastores Global, lalu pilih datastore** global yang ada.
1. Pilih **Add Regional cluster**, dan pilih AWS Region tempat klaster sekunder berada.
1. Di bawah **Info Cluster**, masukkan nilai untuk **Nama** dan, secara opsional, untuk **Deskripsi** untuk klaster.
1. Jangan ubah opsi berikut. Opsi diisi otomatis agar sesuai dengan konfigurasi klaster primer dan Anda tidak dapat mengubahnya.
+ Versi mesin
+ Jenis instans
+ Jenis simpul
+ Jumlah serpihan
+ Grup parameter
**catatan**
ElastiCache membuat otomatis grup parameter baru dari nilai grup parameter yang disediakan dan menerapkan grup parameter baru ke cluster. Gunakan grup parameter baru ini untuk mengubah parameter pada penyimpanan data global. Setiap grup parameter yang dihasilkan otomatis dikaitkan dengan hanya satu klaster dan, karena itu, hanya satu penyimpanan data global.
+ Enkripsi diam
**catatan**
Anda dapat menyediakan kunci enkripsi yang berbeda dengan memilih kunci ** AWS KMS yang Dikelola Pelanggan** dan memilih kunci.
+ Enkripsi bergerak
+ AUTENTIKASI
1. (Opsional) Perbarui pengaturan klaster sekunder yang tersisa. Pengaturan ini sudah diisi otomatis dengan nilai yang sama dengan klaster primer, tetapi Anda dapat memperbarui nilainya untuk memenuhi persyaratan khusus untuk klaster tersebut.
+ Port
+ Jumlah replika
+ Grup subnet
+ Zona Ketersediaan Pilihan
+ Grup keamanan
+ Kunci AWS KMS yang Dikelola Pelanggan)
+ Token AUTH
+ Aktifkan pencadangan otomatis
+ Periode retensi cadangan
+ Periode pencadangan
+ Periode pemeliharaan
+ Topik untuk notifikasi SNS
1. Pilih **Tambahkan**.
## Mengubah penyimpanan data global
Anda dapat mengubah properti dari klaster regional. Hanya satu operasi perubahan dapat berlangsung pada penyimpanan data global, dengan pengecualian pada operasi mempromosikan klaster sekunder menjadi primer. Untuk informasi selengkapnya, lihat [Mempromosikan klaster sekunder menjadi primer](#Redis-Global-Datastores-Console-Promote-Secondary).
**Untuk mengubah penyimpanan data global**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Datastores Global, dan kemudian untuk Nama Datastore** **Global, pilih datastore** global.
1. Pilih **Ubah** dan pilih salah satu opsi berikut:
+ **Ubah deskripsi** – Memperbarui deskripsi penyimpanan data global
+ **Ubah versi mesin** - Hanya Valkey 7.2 dan yang lebih baru atau Redis OSS 5.0.6 dan yang lebih baru tersedia.
+ **Ubah jenis simpul** – Menskalakan klaster regional baik secara vertikal (menaikkan dan menurunkan skala) dan secara horizontal (menskalakan ke dalam dan ke luar). Opsi mencakup keluarga simpul R5 dan M5. Untuk informasi selengkapnya tentang jenis simpul, lihat [Jenis simpul yang didukung](CacheNodes.SupportedTypes.md).
+ **Ubah Failover Otomatis** – Aktifkan atau nonaktifkan Failover Otomatis. Saat Anda mengaktifkan failover dan node primer di kluster regional ditutup secara tak terduga, ElastiCache gagal ke salah satu replika regional. Untuk informasi selengkapnya, lihat [Failover otomatis](AutoFailover.md).
Untuk cluster Valkey atau Redis OSS dengan mode cluster diaktifkan:
+ **Tambahkan serpihan** – Masukkan jumlah serpihan untuk ditambahkan dan, jika perlu, tentukan satu atau beberapa Zona Ketersediaan.
+ **Hapus pecahan** — Pilih pecahan yang akan dihapus di setiap AWS Wilayah.
+ **Seimbangkan ulang serpihan** – Menyeimbangkan ulang distribusi slot untuk memastikan distribusi yang merata di seluruh serpihan yang ada dalam klaster.
Untuk memodifikasi parameter datastore global, modifikasi grup parameter dari setiap cluster anggota untuk datastore global. ElastiCache menerapkan perubahan ini ke semua cluster dalam datastore global itu secara otomatis. Untuk memodifikasi grup parameter cluster tersebut, gunakan konsol Valkey atau Redis OSS atau operasi API. [ModifyCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html) Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md). Saat Anda mengubah grup parameter dari klaster yang tercakup dalam penyimpanan data global, tindakan ini akan diterapkan ke semua klaster dalam penyimpanan data global.
Untuk mengatur ulang seluruh grup parameter atau parameter tertentu, gunakan operasi [ResetCacheParameterGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ResetCacheParameterGroup.html)API.
## Mempromosikan klaster sekunder menjadi primer
Jika klaster utama atau AWS Wilayah menjadi tidak tersedia atau mengalami masalah kinerja, Anda dapat mempromosikan klaster sekunder ke primer. Promosi boleh dilakukan setiap saat, bahkan saat perubahan lain sedang berlangsung. Anda juga dapat menjalankan beberapa promosi secara paralel dan penyimpanan data global pada akhirnya tetap akan diresolusi ke satu primer. Jika Anda mempromosikan beberapa cluster sekunder secara bersamaan, ElastiCache tidak menjamin mana yang akhirnya diselesaikan menjadi primer.
**Untuk mempromosikan klaster sekunder menjadi primer**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Global Datastores**.
1. Pilih nama penyimpanan data global untuk melihat detailnya.
1. Pilih klaster **Sekunder**.
1. Pilih **Promosikan menjadi primer**.
Anda kemudian diminta untuk mengonfirmasi keputusan Anda dengan peringatan berikut: ` Promoting a region to primary will make the cluster in this region as read/writable. Are you sure you want to promote the secondary cluster to primary?`
`The current primary cluster in primary region will become secondary and will stop accepting writes after this operation completes. Please ensure you update your application stack to direct traffic to the new primary region.`
1. Pilih **Konfirmasi** jika Anda ingin melanjutkan promosi atau **Batalkan** jika tidak.
Jika Anda memilih untuk mengonfirmasi, penyimpanan data global Anda akan berubah status menjadi **Mengubah** dan tidak tersedia sampai promosi selesai.
## Menghapus Wilayah dari penyimpanan data global
Anda dapat menghapus AWS Region dari datastore global dengan menggunakan prosedur berikut.
**Untuk menghapus AWS Region dari datastore global**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Global Datastores**.
1. Pilih penyimpanan data global.
1. Pilih **Wilayah** yang ingin dihapus.
1. Pilih **Hapus wilayah**.
**catatan**
Opsi ini hanya tersedia untuk klaster sekunder.
Anda kemudian diminta untuk mengonfirmasi keputusan Anda dengan peringatan berikut: ` Removing the region will remove your only available cross region replica for the primary cluster. Your primary cluster will no longer be set up for disaster recovery and improved read latency in remote region. Are you sure you want to remove the selected region from the global datastore?`
1. Pilih **Konfirmasi** jika Anda ingin melanjutkan promosi atau **Batalkan** jika tidak.
Jika Anda memilih konfirmasi, AWS Wilayah akan dihapus dan klaster sekunder tidak lagi menerima pembaruan replikasi.
## Menghapus penyimpanan data global
Untuk menghapus penyimpanan data global, hapus semua klaster sekunder terlebih dahulu. Untuk informasi selengkapnya, lihat [Menghapus Wilayah dari penyimpanan data global](#Redis-Global-Datastore-Console-Remove-Region). Tindakan ini membuat penyimpanan data global berstatus **hanya primer**.
**Untuk menghapus penyimpanan data global**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pada panel navigasi, pilih **Global Datastores**.
1. Di bagian **Nama Penyimpanan Data Global**, pilih penyimpanan data global yang ingin dihapus, lalu pilih **Hapus**.
Anda kemudian diminta untuk mengonfirmasi keputusan Anda dengan peringatan berikut: `Are you sure you want to delete this Global Datastore?`
1. Pilih **Hapus**.
Penyimpanan data global berubah status menjadi **Menghapus**.
# Menggunakan penyimpanan data global (CLI)
Anda dapat menggunakan AWS Command Line Interface (AWS CLI) untuk mengontrol beberapa AWS layanan dari baris perintah dan mengotomatiskannya melalui skrip. Anda dapat menggunakan AWS CLI untuk operasi ad hoc (satu kali).
## Mengunduh dan mengonfigurasi AWS CLI
AWS CLI Berjalan di Windows, macOS, atau Linux. Gunakan prosedur berikut untuk mengunduh dan mengonfigurasinya.
**Untuk mengunduh, menginstal, dan mengonfigurasi CLI**
1. Unduh AWS CLI di halaman web [antarmuka AWS baris perintah](https://aws.amazon.com/cli).
1. *Ikuti petunjuk untuk Menginstal AWS CLI dan Mengkonfigurasi AWS CLI di Panduan Pengguna.AWS Command Line Interface *
## Menggunakan AWS CLI dengan datastores global
Gunakan operasi CLI berikut untuk menangani penyimpanan data global:
+ [create-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-global-replication-group.html)
```
aws elasticache create-global-replication-group \
--global-replication-group-id-suffix my global datastore \
--primary-replication-group-id sample-repl-group \
--global-replication-group-description an optional description of the global datastore
```
Amazon ElastiCache secara otomatis menerapkan awalan ke ID datastore global saat dibuat. Setiap AWS Wilayah memiliki awalan sendiri. Sebagai contoh, ID penyimpanan data global yang dibuat di Wilayah AS Barat (California Utara) dimulai dengan "virxk" dan diikuti nama akhiran yang Anda berikan. Akhiran tersebut dikombinasikan dengan awalan yang dihasilkan secara otomatis, menjamin keunikan nama penyimpanan data global di beberapa Wilayah.
Tabel berikut mencantumkan setiap AWS Wilayah dan awalan ID datastore globalnya.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/Redis-Global-Datastores-CLI.html)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)— Gunakan operasi ini untuk membuat cluster sekunder untuk datastore global dengan memasok nama datastore global ke parameter. `--global-replication-group-id`
```
aws elasticache create-replication-group \
--replication-group-id secondary replication group name \
--replication-group-description “Replication group description" \
--global-replication-group-id global datastore name
```
Saat memanggil operasi ini dan meneruskan `--global-replication-group-id` nilai, ElastiCache akan menyimpulkan nilai dari grup replikasi utama grup replikasi global untuk parameter berikut. Jangan memasukkan nilai untuk parameter ini:
`"PrimaryClusterId",`
`"AutomaticFailoverEnabled",`
` "NumNodeGroups",`
` "CacheParameterGroupName",`
` "CacheNodeType",`
` "Engine",`
` "EngineVersion",`
` "CacheSecurityGroupNames",`
` "EnableTransitEncryption",`
` "AtRestEncryptionEnabled",`
` "SnapshotArns",`
` "SnapshotName"`
+ [describe-global-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-global-replication-groups.html)
```
aws elasticache describe-global-replication-groups \
--global-replication-group-id my global datastore \
--show-member-info an optional parameter that returns a list of the primary and secondary clusters that make up the global datastore
```
+ [modify-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-global-replication-group.html)
```
aws elasticache modify-global-replication-group \
--global-replication-group-id my global datastore \
--automatic-failover-enabled \
--cache-node-type node type \
--cache-parameter-group-name parameter group name \
--engine-version engine version \
-—apply-immediately \
--global-replication-group-description description
```
**Redis ke OSS Valkey cross-engine upgrade untuk ElastiCache GlobalDataStore**
Anda dapat memutakhirkan grup replikasi global Redis OSS yang ada ke Valkey menggunakan Konsol, API, atau CLI.
Jika Anda memiliki grup replikasi global Redis OSS yang ada, Anda dapat meningkatkan ke Valkey dengan menentukan versi mesin dan mesin baru dengan API. modify-global-replication-group
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-global-replication-group \
--global-replication-group-id myGlobalReplGroup \
--engine valkey \
--apply-immediately \
--engine-version 8.0
```
Untuk Windows:
```
aws elasticache modify-global-replication-group ^
--global-replication-group-id myGlobalReplGroup ^
--engine valkey ^
--apply-immediately ^
--engine-version 8.0
```
Jika Anda memiliki grup parameter cache khusus yang diterapkan ke grup replikasi global Redis OSS yang ingin Anda tingkatkan, Anda juga harus melewati grup parameter cache Valkey kustom dalam permintaan. Grup parameter kustom Valkey input harus memiliki nilai parameter statis Redis OSS yang sama dengan grup parameter kustom Redis OSS yang ada.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-global-replication-group \
--global-replication-group-id myGlobalReplGroup \
--engine valkey \
--engine-version 8.0 \
--apply-immediately \
--cache-parameter-group-name myParamGroup
```
Untuk Windows:
```
aws elasticache modify-global-replication-group ^
--global-replication-group-id myGlobalReplGroup ^
--engine valkey ^
--engine-version 8.0 ^
--apply-immediately ^
--cache-parameter-group-name myParamGroup
```
+ [delete-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-global-replication-group.html)
```
aws elasticache delete-global-replication-group \
--global-replication-group-id my global datastore \
--retain-primary-replication-group defaults to true
```
+ [disassociate-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/disassociate-global-replication-group.html)
```
aws elasticache disassociate-global-replication-group \
--global-replication-group-id my global datastore \
--replication-group-id my secondary cluster \
--replication-group-region the AWS Region in which the secondary cluster resides
```
+ [failover-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/failover-global-replication-group.html)
```
aws elasticache failover-replication-group \
--global-replication-group-id my global datastore \
--primary-region The AWS Region of the primary cluster \
--primary-replication-group-id The name of the global datastore, including the suffix.
```
+ [increase-node-groups-in-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-node-groups-in-global-replication-group.html)
```
aws elasticache increase-node-groups-in-global-replication-group \
--apply-immediately yes \
--global-replication-group-id global-replication-group-name \
--node-group-count 3
```
+ [decrease-node-groups-in-global-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-node-groups-in-global-replication-group.html)
```
aws elasticache decrease-node-groups-in-global-replication-group \
--apply-immediately yes \
--global-replication-group-id global-replication-group-name \
--node-group-count 3
```
+ [rebalance-shards-in-global-replikasi-kelompok](https://docs.aws.amazon.com/cli/latest/reference/elasticache/rebalance-slots-in-global-replication-group.html)
```
aws elasticache rebalance-shards-in-global-replication-group \
--apply-immediately yes \
--global-replication-group-id global-replication-group-name
```
Gunakan bantuan untuk membuat daftar semua perintah yang tersedia ElastiCache untuk Valkey atau Redis OSS.
```
aws elasticache help
```
Anda juga dapat menggunakan bantuan untuk mengetahui penjelasan perintah tertentu dan mempelajari selengkapnya penggunaannya:
```
aws elasticache create-global-replication-group help
```
# Ketersediaan tinggi menggunakan grup replikasi
Cluster Amazon ElastiCache Valkey dan Redis OSS simpul tunggal adalah entitas dalam memori dengan layanan perlindungan data terbatas (AOF). Jika klaster Anda gagal karena alasan apa pun, Anda akan kehilangan semua data klaster. Namun, jika Anda menjalankan mesin Valkey atau Redis OSS, Anda dapat mengelompokkan 2 hingga 6 node ke dalam cluster dengan replika di mana 1 hingga 5 node read-only berisi data replikasi dari node primer tunggal grup. read/write Dalam skenario ini, jika salah satu simpul gagal karena alasan apa pun, Anda tidak kehilangan semua data karena data direplikasikan pada satu atau beberapa simpul lainnya. Karena latensi replikasi, beberapa data mungkin hilang jika itu adalah read/write node utama yang gagal.
Seperti yang terlihat pada grafik berikut, struktur replikasi terkandung dalam pecahan (disebut *kelompok simpul* dalam API/CLI) yang terkandung dalam cluster Valkey atau Redis OSS. Cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) selalu memiliki satu pecahan. Cluster Valkey atau Redis OSS (mode cluster enabled) dapat memiliki hingga 500 pecahan dengan data cluster yang dipartisi di seluruh pecahan. Anda dapat membuat klaster dengan jumlah serpihan lebih banyak dan jumlah replika lebih sedikit dengan jumlah total hingga 90 simpul per klaster. Konfigurasi klaster ini dapat berkisar dari 90 serpihan dan 0 replika hingga 15 serpihan dan 5 replika, yang merupakan jumlah replika maksimum yang diizinkan.
Batas node atau shard dapat ditingkatkan hingga maksimum 500 per cluster dengan Valkey, dan dengan ElastiCache versi 5.0.6 atau lebih tinggi ElastiCache untuk Redis OSS. Sebagai contoh, Anda dapat memilih untuk mengonfigurasi sebuah klaster dengan 500 simpul yang berkisar antara 83 serpihan (satu primer dan 5 replika per serpihan) dan 500 serpihan (satu primer dan tanpa replika). Pastikan alamat IP yang tersedia mencukupi untuk mengakomodasi peningkatan tersebut. Kesalahan umumnya termasuk subnet dalam grup subnet memiliki rentang CIDR yang terlalu kecil atau subnet dibagikan dan banyak digunakan oleh klaster lainnya. Untuk informasi selengkapnya, lihat [Membuat grup subnet](SubnetGroups.Creating.md).
Untuk versi di bawah 5.0.6, batasnya adalah 250 per klaster.
Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
![\[Gambar: Cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) memiliki satu pecahan dan 0 hingga 5 node replika\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-Redis-Replicas.png)
*Cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) memiliki satu pecahan dan 0 hingga 5 node replika*
Jika klaster dengan replika mengaktifkan Multi-AZ dan simpul primer gagal, simpul primer akan melakukan failover ke replika baca. Karena data diperbarui pada simpul replika secara asinkron, mungkin akan terjadi sejumlah kehilangan data karena latensi dalam pembaruan simpul replika. Lihat informasi yang lebih lengkap di [Mengurangi Kegagalan saat Menjalankan Valkey atau Redis OSS](disaster-recovery-resiliency.md#FaultTolerance.Redis).
**Topics**
+ [Memahami replikasi Valkey dan Redis OSS](Replication.Redis.Groups.md)
+ [Replikasi: Mode Cluster Valkey dan Redis OSS Dinonaktifkan vs Diaktifkan](Replication.Redis-RedisCluster.md)
+ [Meminimalkan downtime ElastiCache dengan menggunakan Multi-AZ dengan Valkey dan Redis OSS](AutoFailover.md)
+ [Cara penerapan sinkronisasi dan pencadangan](Replication.Redis.Versions.md)
+ [Membuat grup replikasi Valkey atau Redis OSS](Replication.CreatingRepGroup.md)
+ [Melihat detail grup replikasi](Replication.ViewDetails.md)
+ [Menemukan titik akhir grup replikasi](Replication.Endpoints.md)
+ [Mengubah grup replikasi](Replication.Modify.md)
+ [Menghapus grup replikasi](Replication.DeletingRepGroup.md)
+ [Mengubah jumlah replika](increase-decrease-replica-count.md)
+ [Mempromosikan replika baca ke primer, untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan)](Replication.PromoteReplica.md)
# Memahami replikasi Valkey dan Redis OSS
Redis OSS mengimplementasikan replikasi dalam dua cara:
+ Dengan pecahan tunggal yang berisi semua data cluster di setiap node—Valkey atau Redis OSS (mode cluster dinonaktifkan)
+ Dengan data yang dipartisi hingga 500 pecahan — Valkey atau Redis OSS (mode cluster diaktifkan)
Setiap pecahan dalam grup replikasi memiliki simpul read/write primer tunggal dan hingga 5 node replika hanya-baca. Anda dapat membuat klaster dengan jumlah serpihan lebih banyak dan jumlah replika lebih sedikit dengan jumlah total hingga 90 simpul per klaster. Konfigurasi klaster ini dapat berkisar dari 90 serpihan dan 0 replika hingga 15 serpihan dan 5 replika, yang merupakan jumlah replika maksimum yang diizinkan.
Batas node atau shard dapat ditingkatkan hingga maksimum 500 per cluster jika versi mesin Redis OSS adalah 5.0.6 atau lebih tinggi. Sebagai contoh, Anda dapat memilih untuk mengonfigurasi sebuah klaster dengan 500 simpul yang berkisar antara 83 serpihan (satu primer dan 5 replika per serpihan) dan 500 serpihan (satu primer dan tanpa replika). Pastikan alamat IP yang tersedia mencukupi untuk mengakomodasi peningkatan tersebut. Kesalahan umumnya termasuk subnet dalam grup subnet memiliki rentang CIDR yang terlalu kecil atau subnet dibagikan dan banyak digunakan oleh klaster lainnya. Untuk informasi selengkapnya, lihat [Membuat grup subnet](SubnetGroups.Creating.md).
Untuk versi di bawah 5.0.6, batasnya adalah 250 per klaster.
Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
**Topics**
+ [Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](#Replication.Redis.Groups.Classic)
+ [Valkey atau Redis OSS (mode cluster diaktifkan)](#Replication.Redis.Groups.Cluster)
## Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Cluster Valkey atau Redis OSS (mode cluster disabled) memiliki pecahan tunggal, di dalamnya terdapat kumpulan node; satu node primer dan hingga lima read/write node replika read-only sekunder. Setiap replika baca memelihara salinan data dari simpul primer klaster. Mekanisme replikasi asinkron digunakan untuk menjaga sinkronisasi replika baca dengan primer. Aplikasi dapat membaca dari simpul apa pun dalam klaster. Aplikasi hanya dapat menulis ke simpul primer. Replika baca meningkatkan throughput baca dan menjaga agar data tidak hilang jika terjadi kegagalan simpul.
![\[Gambar: Valkey atau Redis OSS (mode cluster dinonaktifkan) cluster dengan pecahan tunggal dan node replika\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-Redis-Replicas.png)
*Valkey atau Redis OSS (mode cluster dinonaktifkan) cluster dengan pecahan tunggal dan node replika*
Anda dapat menggunakan klaster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan node replika untuk menskalakan solusi Anda ElastiCache untuk menangani aplikasi yang intensif baca atau untuk mendukung sejumlah besar klien yang secara bersamaan membaca dari cluster yang sama.
Semua node dalam cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) harus berada di wilayah yang sama.
Saat Anda menambahkan replika baca ke klaster, semua data dari simpul primer akan disalin ke simpul baru. Setelah tindakan tersebut, setiap kali data ditulis ke simpul primer, perubahan akan disebarkan secara asinkron ke semua replika baca.
Untuk meningkatkan toleransi kesalahan dan mengurangi waktu henti tulis, aktifkan Multi-AZ dengan Failover Otomatis untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) Anda dengan replika. Untuk informasi selengkapnya, lihat [Meminimalkan downtime ElastiCache dengan menggunakan Multi-AZ dengan Valkey dan Redis OSS](AutoFailover.md).
Anda dapat mengubah peran node dalam klaster Valkey atau Redis OSS (mode cluster dinonaktifkan), dengan peran utama dan salah satu replika bertukar peran. Sebaiknya pertimbangkan untuk melakukan tindakan ini untuk menyesuaikan performa. Misalnya, dengan aplikasi web yang memiliki operasi tulis yang berat, Anda dapat memilih simpul dengan latensi jaringan terendah. Untuk informasi selengkapnya, lihat [Mempromosikan replika baca ke primer, untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan)](Replication.PromoteReplica.md).
## Valkey atau Redis OSS (mode cluster diaktifkan)
Cluster Valkey atau Redis OSS (mode cluster enabled) terdiri dari 1 hingga 500 pecahan (API/CLI: grup node). Setiap serpihan memiliki satu simpul primer dan hingga lima simpul replika hanya baca. Konfigurasi dapat berkisar dari 90 serpihan dan 0 replika hingga 15 serpihan dan 5 replika, yang merupakan jumlah replika maksimum yang diizinkan.
Batas node atau shard dapat ditingkatkan hingga maksimum 500 per cluster jika versi mesin Valkey 7.2 dan lebih tinggi, atau Redis OSS 5.0.6 dan lebih tinggi. Sebagai contoh, Anda dapat memilih untuk mengonfigurasi sebuah klaster dengan 500 simpul yang berkisar antara 83 serpihan (satu primer dan 5 replika per serpihan) dan 500 serpihan (satu primer dan tanpa replika). Pastikan alamat IP yang tersedia mencukupi untuk mengakomodasi peningkatan tersebut. Kesalahan umumnya termasuk subnet dalam grup subnet memiliki rentang CIDR yang terlalu kecil atau subnet dibagikan dan banyak digunakan oleh klaster lainnya. Untuk informasi selengkapnya, lihat [Membuat grup subnet](SubnetGroups.Creating.md).
Untuk versi di bawah 5.0.6, batasnya adalah 250 per klaster.
Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
Setiap replika baca dalam serpihan mempertahankan salinan data dari primer pada serpihan ini. Mekanisme replikasi asinkron digunakan untuk menjaga sinkronisasi replika baca dengan primer. Aplikasi dapat membaca dari simpul apa pun dalam klaster. Aplikasi hanya dapat menulis ke simpul primer. Replika baca meningkatkan skalabilitas baca dan mencegah kehilangan data. Data dipartisi di seluruh pecahan dalam cluster Valkey atau Redis OSS (mode cluster enabled).
Aplikasi menggunakan *titik akhir konfigurasi* cluster Valkey atau Redis OSS (mode cluster enabled) untuk terhubung dengan node di cluster. Untuk informasi selengkapnya, lihat [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md).
![\[Gambar: Valkey atau Redis OSS (mode cluster diaktifkan) cluster dengan beberapa pecahan dan node replika\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisClusters.png)
*Valkey atau Redis OSS (mode cluster diaktifkan) cluster dengan beberapa pecahan dan node replika*
Semua node dalam cluster Valkey atau Redis OSS (mode cluster enabled) harus berada di wilayah yang sama. Untuk meningkatkan toleransi kesalahan, Anda dapat menyediakan replika primer dan replika baca pada beberapa Zona Ketersediaan dalam wilayah tersebut.
Saat ini, fitur Valkey atau Redis OSS (mode cluster enabled) memiliki beberapa keterbatasan.
+ Anda tidak dapat secara manual mempromosikan salah satu simpul replika menjadi primer.
# Replikasi: Mode Cluster Valkey dan Redis OSS Dinonaktifkan vs Diaktifkan
Dimulai dengan Valkey 7.2 dan Redis OSS versi 3.2, Anda memiliki kemampuan untuk membuat salah satu dari dua jenis cluster yang berbeda (API/CLI: replication groups). A Valkey or Redis OSS (cluster mode disabled) cluster always has a single shard (API/CLI: grup node) dengan hingga 5 node replika baca. Cluster Valkey atau Redis OSS (mode cluster enabled) memiliki hingga 500 pecahan dengan 1 hingga 5 node replika baca di masing-masing.
![\[Gambar: Valkey atau Redis OSS (mode cluster dinonaktifkan), dan cluster Valkey atau Redis OSS (mode cluster diaktifkan)\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-NodeGroups.png)
*Valkey atau Redis OSS (mode cluster dinonaktifkan), dan Valkey atau Redis OSS (mode cluster diaktifkan) cluster*
Tabel berikut merangkum perbedaan penting antara Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan) cluster.
**Membandingkan Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan) Cluster**
| Fitur | Valkey atau Redis OSS (mode cluster dinonaktifkan) | Valkey atau Redis OSS (mode cluster diaktifkan) |
| --- | --- | --- |
| Dapat diubah | Ya. Mendukung penambahan dan penghapusan simpul replika, dan peningkatan skala jenis simpul. | Terbatas. Untuk informasi selengkapnya, lihat [Manajemen Versi untuk ElastiCache](VersionManagement.md) dan [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md). |
| Pembuatan Partisi Data | Tidak | Ya |
| Serpihan | 1 | 1 hingga 500 |
| Replika baca | 0 hingga 5 Jika replika tidak tersedia dan simpul gagal, Anda akan mengalami kehilangan data total. | 0 hingga 5 per serpihan. Jika replika tidak tersedia dan satu simpul gagal, Anda akan mengalami kehilangan semua data di serpihan tersebut. |
| Multi-AZ | Ya, dengan setidaknya 1 replika. Tidak wajib. Aktif secara default. | YaOpsional. Aktif secara default. |
| Snapshot (Cadangan) | Ya, membuat file .rdb tunggal. | Ya, membuat file .rdb yang unik untuk setiap serpihan. |
| Memulihkan | Ya, menggunakan satu file.rdb dari cluster Valkey atau Redis OSS (mode cluster dinonaktifkan). | Ya, menggunakan file.rdb dari Valkey atau Redis OSS (mode cluster dinonaktifkan) atau cluster Valkey atau Redis OSS (mode cluster diaktifkan). |
| Didukung oleh | Semua versi Valkey dan Redis OSS | Semua versi Valkey, dan Redis OSS 3.2 dan berikut |
| Mesin dapat ditingkatkan | Ya, dengan beberapa batasan. Untuk informasi selengkapnya, lihat [Manajemen Versi untuk ElastiCache](VersionManagement.md). | Ya, dengan beberapa batasan. Untuk informasi selengkapnya, lihat [Manajemen Versi untuk ElastiCache](VersionManagement.md). |
| Enkripsi | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. |
| Memenuhi Syarat HIPAA | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. |
| Mematuhi Standar PCI DSS | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. | Versi 3.2.6 (dijadwalkan untuk EOL, lihat [jadwal akhir masa pakai versi Redis OSS) dan 4.0.10 dan](engine-versions.md#deprecated-engine-versions) yang lebih baru. |
| Resharding online | N/A | Versi 3.2.10 (dijadwalkan untuk EOL, lihat [versi Redis OSS jadwal akhir hidup) dan yang](engine-versions.md#deprecated-engine-versions) lebih baru. |
## Sebaiknya memilih yang mana?
Saat memilih antara Valkey atau Redis OSS (mode cluster dinonaktifkan) atau Valkey atau Redis OSS (mode cluster diaktifkan), pertimbangkan faktor-faktor berikut:
+ **Penskalaan vs. pembuatan partisi** – Bisnis membutuhkan perubahan. Anda perlu menyediakan baik untuk permintaan puncak atau melakukan penskalaan mengikuti perubahan permintaan. Valkey atau Redis OSS (mode cluster dinonaktifkan) mendukung penskalaan. Anda dapat menskalakan kapasitas baca dengan menambahkan atau menghapus simpul replika, atau Anda dapat menskalakan kapasitas dengan menaikkan skala ke jenis simpul yang lebih besar. Kedua operasi ini membutuhkan waktu. Untuk informasi lebih lanjut, lihat [Menskalakan node replika untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Scaling.RedisReplGrps.md).
Valkey atau Redis OSS (mode cluster diaktifkan) mendukung partisi data Anda di hingga 500 grup node. Anda dapat mengubah jumlah serpihan secara dinamis mengikuti perubahan kebutuhan bisnis Anda. Salah satu keuntungan dari pembuatan partisi adalah beban disebarkan ke lebih banyak titik akhir, sehingga mengurangi kemacetan akses selama permintaan puncak. Selain itu, Anda dapat mengakomodasi set data yang lebih besar karena data dapat disebarkan ke beberapa server. Untuk informasi tentang penskalaan partisi Anda, lihat. [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ **Ukuran node v. jumlah node** — Karena cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) hanya memiliki satu pecahan, tipe node harus cukup besar untuk mengakomodasi semua data cluster ditambah overhead yang diperlukan. Di sisi lain, karena Anda dapat mempartisi data Anda di beberapa pecahan saat menggunakan cluster Valkey atau Redis OSS (mode cluster enabled), tipe node bisa lebih kecil, meskipun Anda membutuhkan lebih banyak dari mereka. Untuk informasi selengkapnya, lihat [Memilih ukuran simpul Anda](CacheNodes.SelectSize.md).
+ **Membaca v. menulis** - Jika beban utama pada cluster Anda adalah aplikasi yang membaca data, Anda dapat menskalakan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan menambahkan dan menghapus replika baca. Namun, terdapat jumlah maksimum sebanyak 5 replika baca. Jika beban pada cluster Anda berat tulis, Anda bisa mendapatkan keuntungan dari titik akhir penulisan tambahan dari cluster Valkey atau Redis OSS (mode cluster enabled) dengan beberapa pecahan.
Apa pun jenis klaster yang Anda pilih untuk diterapkan, pastikan untuk memilih jenis simpul yang memadai untuk kebutuhan Anda saat ini dan pada masa mendatang.
# Meminimalkan downtime ElastiCache dengan menggunakan Multi-AZ dengan Valkey dan Redis OSS
Ada sejumlah contoh di mana ElastiCache untuk Valkey dan Redis OSS mungkin perlu mengganti node primer; ini termasuk jenis pemeliharaan terencana tertentu dan kejadian yang tidak mungkin dari node primer atau kegagalan Availability Zone.
Penggantian ini mengakibatkan waktu henti pada klaster, tetapi jika Multi-AZ diaktifkan, waktu henti dapat dikurangi. Peran simpul primer akan secara otomatis melakukan failover ke salah satu replika baca. Tidak perlu membuat dan menyediakan simpul utama baru, karena ElastiCache akan menangani ini secara transparan. Failover dan promosi replika ini memastikan Anda dapat melanjutkan penulisan ke primer baru segera setelah promosi selesai.
ElastiCache juga menyebarkan nama Domain Name Service (DNS) dari replika yang dipromosikan. Hal ini dilakukan karena jika aplikasi Anda menulis ke titik akhir primer, tidak perlu ada perubahan titik akhir dalam aplikasi Anda. Jika Anda membaca dari titik akhir individual, pastikan untuk mengubah titik akhir baca dari replika yang dipromosikan menjadi primer ke titik akhir dari replika yang baru.
Jika penggantian simpul terencana dimulai karena pembaruan pemeliharaan atau pembaruan mandiri, perhatikan hal berikut:
+ Untuk cluster Valkey dan Redis OSS, penggantian node yang direncanakan selesai sementara cluster melayani permintaan tulis yang masuk.
+ Untuk cluster yang dinonaktifkan mode cluster Valkey dan Redis OSS dengan multi-AZ diaktifkan yang berjalan pada mesin 5.0.6 atau yang lebih baru, penggantian node yang direncanakan selesai sementara cluster melayani permintaan tulis yang masuk.
+ Untuk cluster yang dinonaktifkan mode cluster Valkey dan Redis OSS dengan multi-AZ diaktifkan yang berjalan pada mesin 4.0.10 atau sebelumnya, Anda mungkin melihat gangguan penulisan singkat yang terkait dengan pembaruan DNS. Gangguan ini mungkin memakan waktu hingga beberapa detik. Proses ini jauh lebih cepat daripada membuat dan menetapkan primer baru, yang akan terjadi jika Anda tidak mengaktifkan Multi-AZ.
Anda dapat mengaktifkan Multi-AZ menggunakan ElastiCache Management Console, the AWS CLI, atau ElastiCache API.
Mengaktifkan ElastiCache Multi-AZ di klaster Valkey atau Redis OSS Anda (di API dan CLI, grup replikasi) meningkatkan toleransi kesalahan Anda. Hal ini berlaku terutama dalam kasus di mana klaster read/write utama cluster Anda menjadi tidak dapat dijangkau atau gagal karena alasan apa pun. Multi-AZ hanya didukung pada cluster Valkey dan Redis OSS dengan lebih dari satu node di setiap shard.
**Topics**
+ [Mengaktifkan Multi-AZ](#AutoFailover.Enable)
+ [Skenario kegagalan dengan respons Multi-AZ](#AutoFailover.Scenarios)
+ [Menguji failover otomatis](#auto-failover-test)
+ [Batasan pada Multi-AZ](#AutoFailover.Limitations)
## Mengaktifkan Multi-AZ
Anda dapat mengaktifkan Multi-AZ saat membuat atau memodifikasi cluster (API atau CLI, grup replikasi) menggunakan ElastiCache konsol AWS CLI,, atau API. ElastiCache
Anda dapat mengaktifkan Multi-AZ hanya pada cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang memiliki setidaknya satu replika baca yang tersedia. Klaster tanpa replika baca tidak menyediakan ketersediaan tinggi atau toleransi kesalahan. Untuk informasi tentang cara membuat klaster dengan replikasi, lihat [Membuat grup replikasi Valkey atau Redis OSS](Replication.CreatingRepGroup.md). Untuk informasi tentang cara menambahkan replika baca ke klaster dengan replikasi, lihat [Menambahkan replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Replication.AddReadReplica.md).
**Topics**
+ [Mengaktifkan Multi-AZ (Konsol)](#AutoFailover.Enable.Console)
+ [Mengaktifkan Multi-AZ (AWS CLI)](#AutoFailover.Enable.CLI)
+ [Mengaktifkan Multi-AZ (API) ElastiCache](#AutoFailover.Enable.API)
### Mengaktifkan Multi-AZ (Konsol)
Anda dapat mengaktifkan Multi-AZ menggunakan ElastiCache konsol saat Anda membuat cluster Valkey atau Redis OSS baru atau dengan memodifikasi cluster yang ada dengan replikasi.
Multi-AZ diaktifkan secara default pada cluster Valkey atau Redis OSS (mode cluster enabled).
**penting**
ElastiCache akan secara otomatis mengaktifkan Multi-AZ hanya jika cluster berisi setidaknya satu replika di Availability Zone yang berbeda dari yang utama di semua pecahan.
#### Mengaktifkan Multi-AZ saat membuat cluster menggunakan konsol ElastiCache
Lihat informasi selengkapnya tentang prosedur ini, lihat [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs). Pastikan untuk memiliki satu atau beberapa replika dan mengaktifkan Multi-AZ.
#### Mengaktifkan Multi-AZ pada klaster yang sudah ada (Konsol)
Untuk informasi selengkapnya tentang proses ini, lihat Mengubah Klaster [Menggunakan ElastiCache Konsol Manajemen AWS](Clusters.Modify.md#Clusters.Modify.CON).
### Mengaktifkan Multi-AZ (AWS CLI)
Contoh kode berikut menggunakan AWS CLI untuk mengaktifkan Multi-AZ untuk grup replikasi. `redis12`
**penting**
Replikasi grup `redis12` harus sudah ada dan memiliki setidaknya satu replika baca yang tersedia.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id redis12 \
--automatic-failover-enabled \
--multi-az-enabled \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id redis12 ^
--automatic-failover-enabled ^
--multi-az-enabled ^
--apply-immediately
```
Output JSON dari perintah ini akan terlihat seperti berikut.
```
{
"ReplicationGroup": {
"Status": "modifying",
"Description": "One shard, two nodes",
"NodeGroups": [
{
"Status": "modifying",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "redis12-001.v5r9dc.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "redis12-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "redis12-002.v5r9dc.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "redis12-002"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "redis12.v5r9dc.ng.0001.usw2.cache.amazonaws.com"
}
}
],
"ReplicationGroupId": "redis12",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabling",
"MultiAZ": "enabled",
"SnapshotWindow": "07:00-08:00",
"SnapshottingClusterId": "redis12-002",
"MemberClusters": [
"redis12-001",
"redis12-002"
],
"PendingModifiedValues": {}
}
}
```
Untuk informasi selengkapnya, lihat topik ini dalam *Referensi Perintah AWS CLI *:
+ [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
+ [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)dalam *AWS CLI Command Reference.*
### Mengaktifkan Multi-AZ (API) ElastiCache
Contoh kode berikut menggunakan ElastiCache API untuk mengaktifkan Multi-AZ untuk grup replikasi. `redis12`
**catatan**
Untuk menggunakan contoh ini, grup replikasi `redis12` harus sudah ada dan memiliki setidaknya satu replika baca dalam keadaan tersedia.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ApplyImmediately=true
&AutoFailover=true
&MultiAZEnabled=true
&ReplicationGroupId=redis12
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20140401T192317Z
&X-Amz-Credential=
```
Untuk informasi lain, lihat topik ini di *Referensi API ElastiCache *:
+ [CreateCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheCluster.html)
+ [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)
## Skenario kegagalan dengan respons Multi-AZ
Sebelum pengenalan Multi-AZ, ElastiCache mendeteksi dan mengganti node gagal cluster dengan membuat ulang dan reprovisioning node gagal. Jika Anda mengaktifkan Multi-AZ, simpul primer yang gagal akan melakukan failover ke replika dengan lag replikasi terkecil. Replika yang dipilih akan dipromosikan secara otomatis menjadi primer, yang jauh lebih cepat daripada membuat dan menetapkan kembali simpul primer baru. Proses ini biasanya memakan waktu hanya beberapa detik hingga Anda dapat menulis lagi ke klaster.
Ketika Multi-AZ diaktifkan, ElastiCache terus memonitor keadaan node utama. Jika simpul primer gagal, salah satu tindakan berikut akan dilakukan bergantung pada jenis kegagalan.
**Topics**
+ [Skenario kegagalan ketika hanya simpul primer yang gagal](#AutoFailover.Scenarios.PrimaryOnly)
+ [Skenario kegagalan ketika simpul primer dan beberapa replika baca gagal](#AutoFailover.Scenarios.PrimaryAndReplicas)
+ [Skenario kegagalan ketika seluruh klaster gagal](#AutoFailover.Scenarios.AllFail)
### Skenario kegagalan ketika hanya simpul primer yang gagal
Jika hanya simpul primer yang gagal, replika baca dengan lag replikasi terkecil akan dipromosikan menjadi primer. Replika baca pengganti kemudian dibuat dan ditetapkan di Zona Ketersediaan yang sama dengan primer yang gagal.
Ketika hanya node utama yang gagal, ElastiCache Multi-AZ melakukan hal berikut:
1. Simpul primer yang gagal akan dibuat offline.
1. Replika baca dengan lag replikasi terkecil akan dipromosikan menjadi primer.
Proses tulis dapat dilanjutkan segera setelah proses promosi selesai, biasanya hanya beberapa detik. Jika aplikasi Anda menulis ke titik akhir primer, Anda tidak perlu mengubah titik akhir untuk tulis atau baca. ElastiCache menyebarkan nama DNS dari replika yang dipromosikan.
1. Replika baca pengganti diluncurkan dan ditetapkan.
Replika baca pengganti diluncurkan pada Zona Ketersediaan yang sama dengan simpul primer yang gagal sehingga distribusi simpul tetap terpelihara.
1. Replika melakukan sinkronisasi dengan simpul primer yang baru.
Setelah replika baru tersedia, perhatikan efeknya berikut ini:
+ **Titik akhir primer** – Anda tidak perlu membuat perubahan apa pun pada aplikasi Anda, karena nama DNS dari simpul primer baru disebarkan ke titik akhir primer.
+ **Titik akhir baca** – Titik akhir pembaca diperbarui secara otomatis untuk mengarah ke simpul replika yang baru.
Untuk informasi tentang cara menemukan titik akhir klaster, lihat topik berikut:
+ [Menemukan Titik Akhir Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.Redis)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS ()AWS CLI](Endpoints.md#Endpoints.Find.CLI.ReplGroups)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS (API) ElastiCache](Endpoints.md#Endpoints.Find.API.ReplGroups)
### Skenario kegagalan ketika simpul primer dan beberapa replika baca gagal
Jika primer dan setidaknya satu replika baca gagal, replika yang tersedia dengan lag replikasi terkecil akan dipromosikan menjadi klaster primer. Replika baca yang baru juga dibuat dan ditetapkan di Zona Ketersediaan yang sama dengan simpul yang gagal dan replika yang dipromosikan menjadi primer.
Ketika node utama dan beberapa replika baca gagal, ElastiCache Multi-AZ melakukan hal berikut:
1. Simpul primer yang gagal dan replika baca yang gagal akan dibuat offline.
1. Replika yang tersedia dengan lag replikasi terkecil akan dipromosikan menjadi simpul primer.
Operasi tulis dapat dilanjutkan segera setelah proses promosi selesai, biasanya hanya beberapa detik. Jika aplikasi Anda menulis ke titik akhir utama, tidak perlu mengubah titik akhir untuk menulis. ElastiCache menyebarkan nama DNS dari replika yang dipromosikan.
1. Replika pengganti dibuat dan ditetapkan.
Replika pengganti dibuat di Zona Ketersediaan dari simpul yang gagal sehingga distribusi simpul tetap terpelihara.
1. Semua klaster melakukan sinkronisasi dengan simpul primer baru.
Lakukan perubahan berikut pada aplikasi Anda setelah simpul yang baru tersedia:
+ **Titik akhir primer** – Jangan membuat perubahan apa pun pada aplikasi Anda. Nama DNS dari simpul primer baru disebarkan ke titik akhir primer.
+ **Titik akhir baca** – Titik akhir baca diperbarui secara otomatis untuk mengarah ke simpul replika yang baru.
Untuk informasi tentang menemukan titik akhir grup replikasi, lihat topik berikut:
+ [Menemukan Titik Akhir Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.Redis)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS ()AWS CLI](Endpoints.md#Endpoints.Find.CLI.ReplGroups)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS (API) ElastiCache](Endpoints.md#Endpoints.Find.API.ReplGroups)
### Skenario kegagalan ketika seluruh klaster gagal
Jika semuanya gagal, semua simpul dibuat kembali dan ditetapkan pada Zona Ketersediaan yang sama dengan simpul asli.
Dalam skenario ini, semua data dalam klaster akan hilang karena kegagalan dari setiap simpul dalam klaster. Kasus ini jarang terjadi.
Ketika seluruh cluster gagal, ElastiCache Multi-AZ melakukan hal berikut:
1. Simpul primer dan replika baca yang gagal akan dibuat offline.
1. Simpul primer pengganti dibuat dan ditetapkan.
1. Replika pengganti dibuat dan ditetapkan.
Penggantinya dibuat di Zona Ketersediaan dari simpul yang gagal sehingga distribusi simpul tetap dipertahankan.
Karena seluruh klaster gagal, data menjadi hilang dan semua simpul baru akan melakukan cold start.
Karena setiap simpul pengganti memiliki titik akhir yang sama dengan simpul yang digantikannya, Anda tidak perlu membuat perubahan titik akhir pada aplikasi Anda.
Untuk informasi tentang menemukan titik akhir grup replikasi, lihat topik berikut:
+ [Menemukan Titik Akhir Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.Redis)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS ()AWS CLI](Endpoints.md#Endpoints.Find.CLI.ReplGroups)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS (API) ElastiCache](Endpoints.md#Endpoints.Find.API.ReplGroups)
Sebaiknya buat simpul primer dan replika baca di Zona Ketersediaan yang berbeda untuk meningkatkan tingkat toleransi kesalahan Anda.
## Menguji failover otomatis
Setelah mengaktifkan failover otomatis, Anda dapat mengujinya menggunakan ElastiCache konsol, file AWS CLI, dan ElastiCache API.
Saat menguji, perhatikan hal berikut:
+ Anda dapat menggunakan operasi ini untuk menguji failover otomatis hingga 15 pecahan (disebut grup simpul di ElastiCache API dan AWS CLI) dalam periode 24 jam bergulir apa pun.
+ Jika Anda memanggil operasi ini pada serpihan di klaster yang berbeda (disebut grup replikasi pada API dan CLI), Anda dapat membuat panggilan secara konkuren.
+ Dalam beberapa kasus, Anda mungkin memanggil operasi ini beberapa kali pada pecahan yang berbeda di grup replikasi Valkey atau Redis OSS (mode cluster enabled) yang sama. Dalam kasus tersebut, penggantian simpul pertama harus selesai sebelum panggilan berikutnya dapat dibuat.
+ Untuk menentukan apakah penggantian node selesai, periksa peristiwa menggunakan ElastiCache konsol Amazon, API AWS CLI, atau ElastiCache API. Cari peristiwa yang berkaitan dengan failover otomatis, yang tercantum berikut ini dalam urutan kemungkinan kemunculannya:
1. Pesan grup replikasi: `Test Failover API called for node group `
1. Pesan klaster cache: `Failover from primary node to replica node completed`
1. Pesan grup replikasi: `Failover from primary node to replica node completed`
1. Pesan klaster cache: `Recovering cache nodes `
1. Pesan klaster cache: `Finished recovery for cache nodes `
Untuk informasi lain, lihat hal berikut:
+ [Melihat ElastiCache acara](ECEvents.Viewing.md) di *Panduan Pengguna ElastiCache *
+ [DescribeEvents](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEvents.html) di *Referensi API ElastiCache *
+ [describe-events](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-events.html) dalam *Referensi Perintah AWS CLI .*
+ API ini dirancang untuk menguji perilaku aplikasi Anda jika terjadi ElastiCache failover. Hal ini tidak dirancang untuk menjadi alat operasional untuk memulai failover guna mengatasi masalah dengan klaster. Selain itu, dalam kondisi tertentu seperti peristiwa operasional skala besar, AWS dapat memblokir API ini.
**Topics**
+ [Menguji failover otomatis menggunakan Konsol Manajemen AWS](#auto-failover-test-con)
+ [Menguji failover otomatis menggunakan AWS CLI](#auto-failover-test-cli)
+ [Menguji failover otomatis menggunakan API ElastiCache](#auto-failover-test-api)
### Menguji failover otomatis menggunakan Konsol Manajemen AWS
Gunakan prosedur berikut untuk menguji failover otomatis dengan konsol.
**Untuk menguji failover otomatis**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis** OSS.
1. Dari daftar cluster, pilih kotak di sebelah kiri cluster yang ingin Anda uji. Klaster ini harus memiliki setidaknya satu simpul replika baca.
1. Pada bagian **Detail**, lakukan konfirmasi bahwa klaster ini sudah mengaktifkan Multi-AZ. Jika klaster tidak memiliki Multi-AZ yang aktif, pilih klaster yang berbeda atau ubah klaster ini agar memiliki Multi-AZ yang aktif. Untuk informasi selengkapnya, lihat [Menggunakan ElastiCache Konsol Manajemen AWS](Clusters.Modify.md#Clusters.Modify.CON).
![\[Gambar: Area detail kluster berkemampuan Multi-AZ\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-AutoFailover-MultiAZ-Enabled.png)
1. Untuk Valkey atau Redis OSS (mode cluster dinonaktifkan), pilih nama cluster.
Untuk Valkey atau Redis OSS (mode cluster diaktifkan), lakukan hal berikut:
1. Pilih nama klaster.
1. Di halaman **Serpihan**, untuk serpihan (disebut grup simpul pada API dan CLI) yang ingin Anda uji failover-nya, pilih nama serpihan ini.
1. Di halaman Simpul, pilih **Failover Primer**.
1. Pilih **Lanjutkan** untuk melakukan failover primer, atau **Batalkan** untuk membatalkan failover simpul primer.
Selama proses failover, konsol terus menunjukkan status simpul sebagai *tersedia*. Untuk memantau progres pengujian failover Anda, pilih **Peristiwa** dari panel navigasi konsol. Di tab **Peristiwa**, perhatikan peristiwa yang menunjukkan failover Anda telah dimulai (`Test Failover API called`) dan selesai (`Recovery completed`).
### Menguji failover otomatis menggunakan AWS CLI
Anda dapat menguji failover otomatis pada cluster yang diaktifkan Multi-AZ menggunakan operasi. AWS CLI `test-failover`
**Parameter**
+ `--replication-group-id` – Wajib. Grup replikasi (di konsol, klaster) yang akan diuji.
+ `--node-group-id` – Wajib. Nama grup simpul yang ingin diuji failover otomatis. Anda dapat menguji maksimal 15 grup node dalam periode 24 jam bergulir.
Contoh berikut menggunakan AWS CLI untuk menguji failover otomatis pada grup `redis00-0003` node di Valkey atau Redis OSS (mode cluster enabled) cluster. `redis00`
**Example Menguji failover otomatis**
Untuk Linux, macOS, atau Unix:
```
aws elasticache test-failover \
--replication-group-id redis00 \
--node-group-id redis00-0003
```
Untuk Windows:
```
aws elasticache test-failover ^
--replication-group-id redis00 ^
--node-group-id redis00-0003
```
Output dari perintah sebelumnya akan terlihat seperti berikut.
```
{
"ReplicationGroup": {
"Status": "available",
"Description": "1 shard, 3 nodes (1 + 2 replicas)",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "redis1x3-001.7ekv3t.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "redis1x3-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "redis1x3-002.7ekv3t.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "redis1x3-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "redis1x3-003.7ekv3t.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "redis1x3-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "redis1x3.7ekv3t.ng.0001.usw2.cache.amazonaws.com"
}
}
],
"ClusterEnabled": false,
"ReplicationGroupId": "redis1x3",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotWindow": "11:30-12:30",
"SnapshottingClusterId": "redis1x3-002",
"MemberClusters": [
"redis1x3-001",
"redis1x3-002",
"redis1x3-003"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
}
```
Untuk melacak kemajuan failover Anda, gunakan AWS CLI `describe-events` operasi.
Untuk informasi selengkapnya, lihat berikut ini:
+ [test-failover](https://docs.aws.amazon.com/cli/latest/reference/elasticache/test-failover.html) dalam *Referensi Perintah AWS CLI .*
+ [describe-events](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-events.html) dalam *Referensi Perintah AWS CLI .*
### Menguji failover otomatis menggunakan API ElastiCache
Anda dapat menguji failover otomatis pada cluster apa pun yang diaktifkan dengan Multi-AZ menggunakan operasi ElastiCache API. `TestFailover`
**Parameter**
+ `ReplicationGroupId` – Wajib. Grup replikasi (di konsol, klaster) yang akan diuji.
+ `NodeGroupId` – Wajib. Nama grup simpul yang ingin diuji failover otomatis. Anda dapat menguji maksimal 15 grup node dalam periode 24 jam bergulir.
Contoh berikut menguji failover otomatis pada grup simpul `redis00-0003` pada grup replikasi (pada konsol, klaster) `redis00`.
**Example Menguji failover otomatis**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=TestFailover
&NodeGroupId=redis00-0003
&ReplicationGroupId=redis00
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20140401T192317Z
&X-Amz-Credential=
```
Untuk melacak kemajuan failover Anda, gunakan operasi ElastiCache `DescribeEvents` API.
Untuk informasi selengkapnya, lihat berikut ini:
+ [TestFailover](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_TestFailover.html)di *Referensi ElastiCache API*
+ [DescribeEvents](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEvents.html)di *Referensi ElastiCache API*
## Batasan pada Multi-AZ
Waspadai batasan berikut untuk Multi-AZ:
+ Multi-AZ didukung pada Valkey, dan pada Redis OSS versi 2.8.6 dan yang lebih baru.
+ Multi-AZ tidak didukung pada tipe node T1.
+ Replikasi Valkey dan Redis OSS tidak sinkron. Oleh karena itu, saat simpul primer melakukan failover ke replika, sejumlah kecil data mungkin hilang karena lag replikasi.
Saat memilih replika untuk dipromosikan ke primer, ElastiCache pilih replika dengan jeda replikasi paling sedikit. Dengan kata lain, yang dipilih adalah replika yang terkini. Hal ini membantu meminimalkan jumlah data yang hilang. Replika dengan lag replikasi terkecil dapat berada di Zona Ketersediaan yang sama atau berbeda dari simpul primer yang gagal.
+ Saat Anda mempromosikan replika baca secara manual ke primer di cluster Valkey atau Redis OSS dengan mode cluster dinonaktifkan, Anda hanya dapat melakukannya ketika multi-AZ dan failover otomatis dinonaktifkan. Untuk mempromosikan replika baca menjadi primer, lakukan langkah berikut:
1. Nonaktifkan Multi-AZ pada klaster.
1. Nonaktifkan failover otomatis pada klaster. Anda dapat melakukan ini melalui konsol dengan membersihkan kotak centang **Auto failover** untuk grup replikasi. Anda juga dapat melakukan ini menggunakan AWS CLI dengan mengatur `AutomaticFailoverEnabled` properti `false` saat memanggil `ModifyReplicationGroup` operasi.
1. Promosikan replika baca menjadi primer.
1. Aktifkan kembali Multi-AZ.
+ ElastiCache untuk Redis OSS Multi-AZ dan file append-only (AOF) saling eksklusif. Jika Anda mengaktifkan salah satunya, Anda tidak dapat mengaktifkan yang lain.
+ Kegagalan simpul dapat disebabkan oleh peristiwa langka saat seluruh Zona Ketersediaan gagal. Dalam kasus ini, replika untuk menggantikan primer yang gagal akan dibuat hanya saat Zona Ketersediaan sudah dipulihkan. Sebagai contoh, misalkan grup replikasi dengan primer berada di AZ-a, sedangkan replika ada di AZ-b dan AZ-c. Jika primer gagal, replika dengan lag replikasi terkecil akan dipromosikan menjadi klaster primer. Kemudian, ElastiCache buat replika baru di AZ-a (di mana primer yang gagal berada) hanya ketika AZ-A di-back up dan tersedia.
+ Boot ulang primer yang dilakukan oleh pelanggan tidak memicu failover otomatis. Boot ulang lain dan kegagalan akan memicu failover otomatis.
+ Saat primer di-booting ulang, data dihapus dari primer saat primer kembali online. Saat replika baca melihat klaster primer yang bersih tanpa data, replika baca akan menghapus salinan datanya, yang menyebabkan hilangnya data.
+ Setelah replika baca dipromosikan, replika lain melakukan sinkronisasi dengan primer yang baru. Setelah sinkronisasi awal, konten replikasi dihapus dan replika menyinkronkan data dari primer yang baru. Proses sinkronisasi ini menyebabkan gangguan singkat, sehingga replika tidak dapat diakses. Proses sinkronisasi juga menyebabkan peningkatan beban sementara pada primer pada saat melakukan sinkronisasi dengan replika. Perilaku ini asli Valkey dan Redis OSS dan tidak unik untuk Multi-AZ. ElastiCache Untuk detail tentang perilaku ini, lihat [Replikasi](http://valkey.io/topics/replication) di situs web Valkey.
**penting**
Untuk Valkey 7.2.6 dan yang lebih baru atau Redis OSS versi 2.8.22 dan yang lebih baru, Anda tidak dapat membuat replika eksternal.
Untuk versi Redis OSS sebelum 2.8.22, sebaiknya Anda tidak menghubungkan replika eksternal ke ElastiCache cluster yang diaktifkan Multi-AZ. Konfigurasi yang tidak didukung ini dapat membuat masalah yang ElastiCache mencegah terjadinya failover dan pemulihan dengan benar. Untuk menghubungkan replika eksternal ke ElastiCache cluster, pastikan bahwa Multi-AZ tidak diaktifkan sebelum Anda membuat koneksi.
# Cara penerapan sinkronisasi dan pencadangan
Semua versi Valkey dan Redis OSS yang didukung mendukung pencadangan dan sinkronisasi antara node primer dan replika. Namun, cara pencadangan dan sinkronisasi diimplementasikan bervariasi tergantung pada versinya.
## Redis OSS Versi 2.8.22 dan yang lebih baru
Redis OSS replikasi, dalam versi 2.8.22 dan yang lebih baru, pilih antara dua metode. Untuk informasi selengkapnya, lihat [Versi Redis OSS Sebelum 2.8.22](#Replication.Redis.Earlier2-8-22) dan [Melakukan snapshot dan pemulihan](backups.md).
Selama proses forkless, jika operasi tulis memiliki beban berat, operasi tulis ke klaster akan ditunda untuk memastikan bahwa Anda tidak menumpuk terlalu banyak perubahan sehingga menghalangi keberhasilan snapshot.
## Versi Redis OSS Sebelum 2.8.22
Redis OSS backup dan sinkronisasi dalam versi sebelum 2.8.22 adalah proses tiga langkah.
1. Fork, dan dalam proses di latar belakang, menserialisasi data klaster ke disk. Ini menciptakan point-in-time snapshot.
1. Di latar depan, log perubahan pada *buffer output klien* diakumulasi.
**penting**
Jika log perubahan melebihi ukuran *buffer output klien*, pencadangan atau sinkronisasi akan gagal. Untuk informasi selengkapnya, lihat [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md).
1. Sebagai langkah terakhir, data cache dan log perubahan ditransmisikan ke simpul replika.
# Membuat grup replikasi Valkey atau Redis OSS
Anda memiliki opsi berikut untuk membuat klaster dengan simpul replika. Satu berlaku ketika Anda sudah memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia yang tidak terkait dengan cluster mana pun yang memiliki replika untuk digunakan sebagai simpul utama. Opsi lain berlaku jika Anda perlu membuat simpul primer dengan klaster dan replika baca. Saat ini, cluster Valkey atau Redis OSS (mode cluster enabled) harus dibuat dari awal.
**Opsi 1: [Membuat grup replikasi menggunakan klaster yang sudah ada](Replication.CreatingReplGroup.ExistingCluster.md)**
Gunakan opsi ini untuk memanfaatkan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang ada. Anda menetapkan simpul yang sudah ada ini sebagai simpul primer dalam klaster baru, lalu secara individual menambahkan 1 hingga 5 replika baca untuk klaster ini. Jika klaster yang sudah ada ini aktif, replika baca melakukan sinkronisasi dengan klaster itu begitu replika dibuat. Lihat [Membuat grup replikasi menggunakan klaster yang sudah ada](Replication.CreatingReplGroup.ExistingCluster.md).
Anda tidak dapat membuat cluster Valkey atau Redis OSS (mode cluster enabled) menggunakan cluster yang ada. Untuk membuat cluster Valkey atau Redis OSS (mode cluster enabled) (API/CLI: grup replikasi) menggunakan konsol, lihat. ElastiCache [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
**Opsi 2: [Membuat grup replikasi Valkey atau Redis OSS dari awal](Replication.CreatingReplGroup.NoExistingCluster.md)**
Gunakan opsi ini jika Anda belum memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia untuk digunakan sebagai simpul utama cluster, atau jika Anda ingin membuat cluster Valkey atau Redis OSS (mode cluster enabled). Lihat [Membuat grup replikasi Valkey atau Redis OSS dari awal](Replication.CreatingReplGroup.NoExistingCluster.md).
# Membuat grup replikasi menggunakan klaster yang sudah ada
Prosedur berikut menambahkan grup replikasi ke cluster simpul tunggal Valkey atau Redis OSS (mode cluster dinonaktifkan) Anda, yang diperlukan untuk meningkatkan klaster Anda ke versi terbaru Valkey. Ini adalah prosedur di tempat yang melibatkan nol downtime dan nol kehilangan data. Saat Anda membuat grup replikasi untuk kluster simpul tunggal Anda, simpul klaster menjadi simpul utama di cluster baru. Jika Anda tidak memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang dapat Anda gunakan sebagai cluster utama klaster baru, lihat. [Membuat grup replikasi Valkey atau Redis OSS dari awal](Replication.CreatingReplGroup.NoExistingCluster.md)
Cluster yang tersedia adalah cluster Valkey atau Redis OSS node tunggal yang ada. Saat ini, Valkey atau Redis OSS (mode cluster diaktifkan) tidak mendukung pembuatan cluster dengan replika menggunakan cluster simpul tunggal yang tersedia. Jika Anda ingin membuat cluster Valkey atau Redis OSS (mode cluster enabled), lihat. [Membuat cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan) (Konsol)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CON)
## Membuat grup replikasi menggunakan cluster yang ada (Console)
Lihat topik [Menggunakan ElastiCache Konsol Manajemen AWS](Clusters.AddNode.md#Clusters.AddNode.CON).
## Membuat grup replikasi menggunakan cluster Valkey atau Redis OSS yang tersedia ()AWS CLI
Ada dua langkah untuk membuat grup replikasi dengan replika baca saat menggunakan Valkey atau Redis OSS Cache Cluster yang tersedia untuk primer saat menggunakan.AWS CLI
Saat menggunakan AWS CLI Anda membuat grup replikasi yang menentukan node mandiri yang tersedia sebagai simpul utama cluster, `--primary-cluster-id` dan jumlah node yang Anda inginkan di cluster menggunakan perintah CLI,. `create-replication-group` Sertakan parameter berikut.
**--replication-group-id**
Nama grup replikasi yang Anda buat. Nilai parameter ini digunakan sebagai dasar untuk nama simpul yang ditambahkan dengan nomor 3 digit berurutan ditambahkan di akhir `--replication-group-id`. Misalnya, `sample-repl-group-001`.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**--replication-group-description**
Deskripsi grup replikasi.
**--num-node-groups**
Jumlah simpul yang Anda inginkan dalam klaster ini. Nilai ini mencakup simpul primer. Parameter ini memiliki nilai maksimum sebesar enam.
**--primary-cluster-id**
Nama node cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia yang Anda inginkan menjadi simpul utama dalam grup replikasi ini.
Perintah berikut membuat grup replikasi `sample-repl-group` menggunakan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia `redis01` sebagai node utama grup replikasi. Tindakan ini membuat 2 simpul baru yang merupakan replika baca. Pengaturan dari `redis01` (yaitu grup parameter, grup keamanan, jenis simpul, versi mesin, dan seterusnya.) akan diterapkan untuk semua simpul dalam grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat AWS CLI topiknya[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
**Selanjutnya, tambahkan replika baca ke grup replikasi**
Setelah grup replikasi dibuat, tambahkan satu hingga lima replika baca ke grup untuk menggunakan perintah `create-cache-cluster`. Pastikan untuk menyertakan parameter berikut.
**--cache-cluster-id**
Nama klaster yang Anda tambahkan ke grup replikasi.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**--replication-group-id**
Nama grup replikasi yang Anda tambahkan cluster ini.
Ulangi perintah ini untuk setiap replika baca yang ingin Anda tambahkan ke grup replikasi, dengan mengubah nilai dari parameter `--cache-cluster-id` saja.
**catatan**
Ingat, grup replikasi tidak dapat memiliki lebih dari lima replika baca. Jika Anda mencoba menambahkan replika baca ke grup replikasi yang sudah memiliki lima replika baca, maka operasi ini akan gagal.
Kode berikut menambahkan replika baca `my-replica01` ke grup replikasi `sample-repl-group`. Pengaturan dari klaster primer–grup parameter, grup keamanan, jenis simpul, dan sebagainya–akan diterapkan ke simpul begitu simpul ditambahkan ke grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-replica01 \
--replication-group-id sample-repl-group
```
Untuk Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-replica01 ^
--replication-group-id sample-repl-group
```
Output dari perintah ini akan terlihat seperti ini.
```
{
"ReplicationGroup": {
"Status": "creating",
"Description": "demo cluster with replicas",
"ClusterEnabled": false,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "disabled",
"SnapshotWindow": "00:00-01:00",
"SnapshottingClusterId": "redis01",
"MemberClusters": [
"sample-repl-group-001",
"sample-repl-group-002",
"redis01"
],
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
}
```
Untuk informasi tambahan, lihat AWS CLI topik:
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
+ [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)
## Menambahkan replika ke cluster Valkey atau Redis OSS (Cluster Mode Disabled) mandiri (API) ElastiCache
Saat menggunakan ElastiCache API, Anda membuat grup replikasi yang menentukan node mandiri yang tersedia sebagai simpul utama cluster, `PrimaryClusterId` dan jumlah node yang Anda inginkan di cluster menggunakan perintah CLI,. `CreateReplicationGroup` Sertakan parameter berikut.
**ReplicationGroupId**
Nama grup replikasi yang Anda buat. Nilai parameter ini digunakan sebagai dasar untuk nama simpul yang ditambahkan dengan nomor 3 digit berurutan ditambahkan di akhir `ReplicationGroupId`. Misalnya, `sample-repl-group-001`.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**ReplicationGroupDescription**
Deskripsi klaster dengan replika.
**NumCacheClusters**
Jumlah simpul yang Anda inginkan dalam klaster ini. Nilai ini mencakup simpul primer. Parameter ini memiliki nilai maksimum sebesar enam.
**PrimaryClusterId**
Nama klaster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia yang Anda inginkan menjadi simpul utama di cluster ini.
Perintah berikut membuat cluster dengan replika `sample-repl-group` menggunakan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) yang tersedia `redis01` sebagai node utama grup replikasi. Tindakan ini membuat 2 simpul baru yang merupakan replika baca. Pengaturan dari `redis01` (yaitu grup parameter, grup keamanan, jenis simpul, versi mesin, dan seterusnya.) akan diterapkan untuk semua simpul dalam grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateReplicationGroup
&Engine=redis
&EngineVersion=6.0
&ReplicationGroupDescription=Demo%20cluster%20with%20replicas
&ReplicationGroupId=sample-repl-group
&PrimaryClusterId=redis01
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi tambahan, lihat topik ElastiCache APL:
+ [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)
**Selanjutnya, tambahkan replika baca ke grup replikasi**
Setelah grup replikasi dibuat, tambahkan satu hingga lima replika baca ke grup untuk menggunakan operasi `CreateCacheCluster`. Pastikan untuk menyertakan parameter berikut.
**CacheClusterId**
Nama klaster yang Anda tambahkan ke grup replikasi.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**ReplicationGroupId**
Nama grup replikasi yang Anda tambahkan cluster ini.
Ulangi operasi ini untuk setiap replika baca yang ingin Anda tambahkan ke grup replikasi, dengan mengubah nilai dari parameter `CacheClusterId` saja.
Kode berikut menambahkan replika baca `myReplica01` ke grup replikasi `myReplGroup`. Pengaturan klaster primer–grup parameter, grup keamanan, jenis simpul, dan sebagainya–akan diterapkan ke simpul begitu simpul ditambahkan ke grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=myReplica01
&ReplicationGroupId=myReplGroup
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=[your-access-key-id]/20150202/us-west-2/elasticache/aws4_request
&X-Amz-Date=20150202T170651Z
&X-Amz-SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date
&X-Amz-Signature=[signature-value]
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat topik ElastiCache API[CreateCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheCluster.html).
# Membuat grup replikasi Valkey atau Redis OSS dari awal
Berikut ini, Anda dapat menemukan cara membuat grup replikasi Valkey atau Redis OSS tanpa menggunakan cluster Valkey atau Redis OSS yang ada sebagai yang utama. Anda dapat membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) atau Valkey atau Redis OSS (mode cluster enabled) dari awal menggunakan ElastiCache konsol, the, atau API. AWS CLI ElastiCache
Sebelum melanjutkan, putuskan apakah Anda ingin membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) atau Valkey atau Redis OSS (mode cluster diaktifkan). Untuk panduan dalam memutuskan, lihat [Replikasi: Mode Cluster Valkey dan Redis OSS Dinonaktifkan vs Diaktifkan](Replication.Redis-RedisCluster.md).
**Topics**
+ [Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Disabled) dari awal](Replication.CreatingReplGroup.NoExistingCluster.Classic.md)
+ [Membuat grup replikasi di Valkey atau Redis OSS (Mode Cluster Diaktifkan) dari awal](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md)
# Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Disabled) dari awal
Anda dapat membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dari awal menggunakan ElastiCache konsol, the AWS CLI, atau API. ElastiCache Grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) selalu memiliki satu grup node, cluster utama, dan hingga lima replika baca. Grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) tidak mendukung partisi data Anda.
**catatan**
node/shard Batas dapat ditingkatkan hingga maksimum 500 per cluster. Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan sertakan jenis instans dalam permintaan yang diajukan.
Untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dari awal, ambil salah satu pendekatan berikut:
## Membuat grup replikasi Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dari awal ()AWS CLI
Prosedur berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) menggunakan grup replikasi. AWS CLI
Saat Anda membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dari awal, Anda membuat grup replikasi dan semua node dengan satu panggilan ke perintah. AWS CLI `create-replication-group` Sertakan parameter berikut.
**--replication-group-id**
Nama grup replikasi yang Anda buat.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**--replication-group-description**
Deskripsi grup replikasi.
**--num-cache-clusters**
Jumlah simpul yang ingin dibuat dengan grup replikasi ini, digabungkan dengan replika primer dan replika baca.
Jika Anda mengaktifkan Multi-AZ (`--automatic-failover-enabled`), nilai dari `--num-cache-clusters` harus minimal 2.
**--cache-node-type**
Jenis simpul untuk setiap simpul dalam grup replikasi.
ElastiCache mendukung jenis node berikut. Secara umum, jenis generasi saat ini memberikan lebih banyak memori dan daya komputasi dengan biaya lebih rendah dibandingkan dengan jenis generasi sebelumnya yang setara.
Untuk informasi selengkapnya tentang detail performa untuk setiap jenis node, lihat [Jenis EC2 Instance Amazon](https://aws.amazon.com/ec2/instance-types/).
**--data-tiering-enabled**
Atur parameter ini jika Anda menggunakan jenis simpul r6gd. Jika Anda tidak ingin tingkatan data, atur `--no-data-tiering-enabled`. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
**--cache-parameter-group**
Tentukan grup parameter yang sesuai dengan versi mesin Anda. Jika Anda menjalankan Redis OSS 3.2.4 atau yang lebih baru, tentukan grup parameter atau grup `default.redis3.2` parameter yang berasal dari `default.redis3.2` untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan). Untuk informasi selengkapnya, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis).
**--network-type**
Baik `ipv4`, `ipv6` atau `dual-stack`. Jika Anda memilih tumpukan ganda, Anda harus menetapkan parameter `--IpDiscovery` ke `ipv4` atau `ipv6`.
**--engine**
redis
**--engine-version**
Untuk mendapatkan kumpulan fitur terbanyak, pilih versi mesin terbaru.
Nama simpul akan diambil dari nama grup replikasi dengan tambahan `-00`*\$1* di belakang nama grup replikasi. Sebagai contoh, menggunakan nama grup replikasi `myReplGroup`, nama untuk replika primer menjadi `myReplGroup-001` dan replika baca menjadi `myReplGroup-002` hingga `myReplGroup-006`.
Jika Anda ingin mengaktifkan enkripsi bergerak atau diam pada grup replikasi ini, tambahkan salah satu atau kedua parameter `--transit-encryption-enabled` atau `--at-rest-encryption-enabled` dan penuhi kondisi berikut.
+ Grup replikasi Anda harus menjalankan Redis OSS versi 3.2.6 atau 4.0.10.
+ Grup replikasi harus dibuat dalam Amazon VPC.
+ Anda juga harus menyertakan parameter `--cache-subnet-group`.
+ Anda juga harus menyertakan parameter `--auth-token` dengan nilai string yang ditentukan oleh pelanggan untuk token (kata sandi) AUTH Anda yang diperlukan untuk melakukan operasi pada grup replikasi ini.
Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) `sample-repl-group` dengan tiga node, primer dan dua replika.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "Demo cluster with replicas" \
--num-cache-clusters 3 \
--cache-node-type cache.m4.large \
--engine redis
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "Demo cluster with replicas" ^
--num-cache-clusters 3 ^
--cache-node-type cache.m4.large ^
--engine redis
```
Output dari perintah ini adalah seperti berikut.
```
{
"ReplicationGroup": {
"Status": "creating",
"Description": "Demo cluster with replicas",
"ClusterEnabled": false,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 0,
"AutomaticFailover": "disabled",
"SnapshotWindow": "01:30-02:30",
"MemberClusters": [
"sample-repl-group-001",
"sample-repl-group-002",
"sample-repl-group-003"
],
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
}
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat AWS CLI topiknya [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
## Membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dari awal (API) ElastiCache
Prosedur berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) menggunakan API. ElastiCache
Saat Anda membuat grup replikasi Valkey atau Redis OSS (mode cluster disabled) dari awal, Anda membuat grup replikasi dan semua node dengan satu panggilan ke operasi API. ElastiCache `CreateReplicationGroup` Sertakan parameter berikut.
**ReplicationGroupId**
Nama grup replikasi yang Anda buat.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster enabled) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**ReplicationGroupDescription**
Deskripsi Anda tentang grup replikasi.
**NumCacheClusters**
Total jumlah simpul yang ingin dibuat dengan grup replikasi ini, digabungkan dengan primer dan replika baca.
Jika Anda mengaktifkan Multi-AZ (`AutomaticFailoverEnabled=true`), nilai dari `NumCacheClusters` harus minimal 2.
**CacheNodeType**
Jenis simpul untuk setiap simpul dalam grup replikasi.
ElastiCache mendukung jenis node berikut. Secara umum, jenis generasi saat ini memberikan lebih banyak memori dan daya komputasi dengan biaya lebih rendah dibandingkan dengan jenis generasi sebelumnya yang setara.
Untuk informasi selengkapnya tentang detail performa untuk setiap jenis node, lihat [Jenis EC2 Instance Amazon](https://aws.amazon.com/ec2/instance-types/).
**--data-tiering-enabled**
Atur parameter ini jika Anda menggunakan jenis simpul r6gd. Jika Anda tidak ingin tingkatan data, atur `--no-data-tiering-enabled`. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
**CacheParameterGroup**
Tentukan grup parameter yang sesuai dengan versi mesin Anda. Jika Anda menjalankan Redis OSS 3.2.4 atau yang lebih baru, tentukan grup parameter atau grup `default.redis3.2` parameter yang berasal dari `default.redis3.2` untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan). Untuk informasi selengkapnya, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis).
**--network-type**
Baik `ipv4`, `ipv` atau `dual-stack`. Jika Anda memilih tumpukan ganda, Anda harus mengatur parameter `--IpDiscovery` ke salah satu `ipv4` atau `ipv6`.
**Engine**
redis
**EngineVersion**
6.0
Nama simpul akan diambil dari nama grup replikasi dengan tambahan `-00`*\$1* di belakang nama grup replikasi. Sebagai contoh, menggunakan nama grup replikasi `myReplGroup`, nama untuk replika primer menjadi `myReplGroup-001` dan replika baca menjadi `myReplGroup-002` hingga `myReplGroup-006`.
Jika Anda ingin mengaktifkan enkripsi bergerak atau diam pada grup replikasi ini, tambahkan salah satu atau kedua parameter `TransitEncryptionEnabled=true` atau `AtRestEncryptionEnabled=true` dan penuhi kondisi berikut.
+ Grup replikasi Anda harus menjalankan Redis OSS versi 3.2.6 atau 4.0.10.
+ Grup replikasi harus dibuat dalam Amazon VPC.
+ Anda juga harus menyertakan parameter `CacheSubnetGroup`.
+ Anda juga harus menyertakan parameter `AuthToken` dengan nilai string yang ditentukan oleh pelanggan untuk token (kata sandi) AUTH Anda yang diperlukan untuk melakukan operasi pada grup replikasi ini.
Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) `myReplGroup` dengan tiga node, primer dan dua replika.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateReplicationGroup
&CacheNodeType=cache.m4.large
&CacheParameterGroup=default.redis6.x
&Engine=redis
&EngineVersion=6.0
&NumCacheClusters=3
&ReplicationGroupDescription=test%20group
&ReplicationGroupId=myReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat topik ElastiCache API[CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html).
# Membuat grup replikasi di Valkey atau Redis OSS (Mode Cluster Diaktifkan) dari awal
Anda dapat membuat klaster Valkey atau Redis OSS (mode cluster enabled) (API/CLI: *grup replikasi*) menggunakan ElastiCache konsol, the, atau API. AWS CLI ElastiCache Grup replikasi Valkey atau Redis OSS (mode cluster enabled) memiliki 1 hingga 500 pecahan (API/CLI: grup simpul), simpul utama di setiap pecahan, dan hingga 5 replika baca di setiap pecahan. Anda dapat membuat klaster dengan jumlah serpihan lebih banyak dan jumlah replika lebih sedikit dengan jumlah total hingga 90 simpul per klaster. Konfigurasi klaster ini dapat berkisar dari 90 serpihan dan 0 replika hingga 15 serpihan dan 5 replika, yang merupakan jumlah replika maksimum yang diizinkan.
Batas node atau shard dapat ditingkatkan hingga maksimum 500 per cluster jika versi mesin Valkey atau Redis OSS adalah 5.0.6 atau lebih tinggi. Sebagai contoh, Anda dapat memilih untuk mengonfigurasi sebuah klaster dengan 500 simpul yang berkisar antara 83 serpihan (satu primer dan 5 replika per serpihan) dan 500 serpihan (satu primer dan tanpa replika). Pastikan alamat IP yang tersedia mencukupi untuk mengakomodasi peningkatan tersebut. Kesalahan umumnya termasuk subnet dalam grup subnet memiliki rentang CIDR yang terlalu kecil atau subnet dibagikan dan banyak digunakan oleh klaster lainnya. Untuk informasi selengkapnya, lihat [Membuat grup subnet](SubnetGroups.Creating.md).
Untuk versi di bawah 5.0.6, batasnya adalah 250 per klaster.
Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas **Simpul per klaster per jenis instans**.
**Topics**
+ [Menggunakan ElastiCache Konsol](#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CON)
+ [Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Enabled) dari awal ()AWS CLI](#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
+ [Membuat grup replikasi di Valkey atau Redis OSS (Mode Cluster Diaktifkan) dari awal (API) ElastiCache](#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API)
## Membuat cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan) (Konsol)
Untuk membuat cluster Valkey atau Redis OSS (mode cluster enabled), lihat. [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) Pastikan untuk mengaktifkan mode klaster, **Mode Klaster diaktifkan (Menskalakan Ke Luar)**, dan tentukan setidaknya dua serpihan dan satu simpul replika di setiap serpihan.
## Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Enabled) dari awal ()AWS CLI
Prosedur berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) menggunakan. AWS CLI
Saat Anda membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) dari awal, Anda membuat grup replikasi dan semua node dengan satu panggilan ke perintah. AWS CLI `create-replication-group` Sertakan parameter berikut.
**--replication-group-id**
Nama grup replikasi yang Anda buat.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster enabled) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**--replication-group-description**
Deskripsi grup replikasi.
**--cache-node-type**
Jenis simpul untuk setiap simpul dalam grup replikasi.
ElastiCache mendukung jenis node berikut. Secara umum, jenis generasi saat ini memberikan lebih banyak memori dan daya komputasi dengan biaya lebih rendah dibandingkan dengan jenis generasi sebelumnya yang setara.
Untuk informasi selengkapnya tentang detail performa untuk setiap jenis node, lihat [Jenis EC2 Instance Amazon](https://aws.amazon.com/ec2/instance-types/).
**--data-tiering-enabled**
Atur parameter ini jika Anda menggunakan jenis simpul r6gd. Jika Anda tidak ingin tingkatan data, atur `--no-data-tiering-enabled`. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
**--cache-parameter-group**
Tentukan grup `default.redis6.x.cluster.on` parameter atau grup parameter yang berasal dari `default.redis6.x.cluster.on` untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster diaktifkan). Untuk informasi selengkapnya, lihat [Redis OSS 6.x perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.6-x).
**--engine**
redis
**--engine-version**
3.2.4
**--num-node-groups**
Jumlah grup simpul dalam grup replikasi ini. Nilai yang valid adalah 1 sampai 500.
node/shard Batas dapat ditingkatkan hingga maksimum 500 per cluster. Untuk meminta penambahan batas, lihat [Batas Layanan AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dan pilih jenis batas "Simpul per klaster per jenis instans".
**--replicas-per-node-group**
Jumlah simpul replika di setiap grup simpul. Nilai yang valid adalah 0 sampai 5.
**--network-type**
Baik `ipv4`, `ipv` atau `dual-stack`. Jika Anda memilih tumpukan ganda, Anda harus mengatur parameter `--IpDiscovery` ke salah satu `ipv4` atau `ipv6`.
Jika Anda ingin mengaktifkan enkripsi bergerak atau diam pada grup replikasi ini, tambahkan salah satu atau kedua parameter `--transit-encryption-enabled` atau `--at-rest-encryption-enabled` dan penuhi kondisi berikut.
+ Grup replikasi Anda harus menjalankan Redis OSS versi 3.2.6 atau 4.0.10.
+ Grup replikasi harus dibuat dalam Amazon VPC.
+ Anda juga harus menyertakan parameter `--cache-subnet-group`.
+ Anda juga harus menyertakan parameter `--auth-token` dengan nilai string yang ditentukan oleh pelanggan untuk token (kata sandi) AUTH Anda yang diperlukan untuk melakukan operasi pada grup replikasi ini.
Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) `sample-repl-group` dengan tiga node groups/shards (--num-node-groups), masing-masing dengan tiga node, primer dan dua replika baca (--). replicas-per-node-group
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "Demo cluster with replicas" \
--num-node-groups 3 \
--replicas-per-node-group 2 \
--cache-node-type cache.m4.large \
--engine redis \
--security-group-ids SECURITY_GROUP_ID \
--cache-subnet-group-name SUBNET_GROUP_NAME>
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "Demo cluster with replicas" ^
--num-node-groups 3 ^
--replicas-per-node-group 2 ^
--cache-node-type cache.m4.large ^
--engine redis ^
--security-group-ids SECURITY_GROUP_ID ^
--cache-subnet-group-name SUBNET_GROUP_NAME>
```
Perintah sebelumnya menghasilkan output berikut.
```
{
"ReplicationGroup": {
"Status": "creating",
"Description": "Demo cluster with replicas",
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 0,
"AutomaticFailover": "enabled",
"SnapshotWindow": "05:30-06:30",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0001-003",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002",
"sample-repl-group-0002-003",
"sample-repl-group-0003-001",
"sample-repl-group-0003-002",
"sample-repl-group-0003-003"
],
"PendingModifiedValues": {}
}
}
```
Saat Anda membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) dari awal, Anda dapat mengonfigurasi setiap pecahan di cluster menggunakan `--node-group-configuration` parameter seperti yang ditunjukkan pada contoh berikut yang mengonfigurasi dua grup node (Console: shards). Serpihan pertama memiliki dua simpul, satu primer dan satu replika baca. Serpihan kedua memiliki tiga simpul, satu primer dan dua replika baca.
**--node-group-configuration**
Konfigurasi untuk setiap grup simpul. Parameter `--node-group-configuration` terdiri dari bidang berikut.
+ `PrimaryAvailabilityZone` – Zona Ketersediaan yang menjadi lokasi dari simpul primer dari grup simpul ini. Jika parameter ini dihilangkan, ElastiCache pilih Availability Zone untuk node utama.
**Contoh:** us-west-2a.
+ `ReplicaAvailabilityZones` – Daftar yang dipisahkan koma untuk Zona Ketersediaan yang menjadi lokasi replika baca. Jumlah Zona Ketersediaan dalam daftar harus sesuai dengan nilai dari `ReplicaCount`. Jika parameter ini dihilangkan, ElastiCache pilih Availability Zones untuk node replika.
**Contoh:** "us-west-2a,us-west-2b,us-west-2c"
+ `ReplicaCount` – Jumlah simpul replika di setiap grup simpul.
+ `Slots` – String yang menentukan ruang kunci untuk grup simpul. String menggunakan format `startKey-endKey`. Jika parameter ini dihilangkan, ElastiCache mengalokasikan kunci secara merata di antara kelompok node.
**Contoh:** "0-4999"
Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) `new-group` dengan dua grup simpul/pecahan (). `--num-node-groups` Tidak seperti contoh sebelumnya, setiap grup simpul dikonfigurasi secara berbeda dari grup simpul lainnya (`--node-group-configuration`).
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id new-group \
--replication-group-description "Sharded replication group" \
--engine redis \
--snapshot-retention-limit 8 \
--cache-node-type cache.m4.medium \
--num-node-groups 2 \
--node-group-configuration \
"ReplicaCount=1,Slots=0-8999,PrimaryAvailabilityZone='us-east-1c',ReplicaAvailabilityZones='us-east-1b'" \
"ReplicaCount=2,Slots=9000-16383,PrimaryAvailabilityZone='us-east-1a',ReplicaAvailabilityZones='us-east-1a','us-east-1c'"
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id new-group ^
--replication-group-description "Sharded replication group" ^
--engine redis ^
--snapshot-retention-limit 8 ^
--cache-node-type cache.m4.medium ^
--num-node-groups 2 ^
--node-group-configuration \
"ReplicaCount=1,Slots=0-8999,PrimaryAvailabilityZone='us-east-1c',ReplicaAvailabilityZones='us-east-1b'" \
"ReplicaCount=2,Slots=9000-16383,PrimaryAvailabilityZone='us-east-1a',ReplicaAvailabilityZones='us-east-1a','us-east-1c'"
```
Operasi sebelumnya menghasilkan output berikut.
```
{
"ReplicationGroup": {
"Status": "creating",
"Description": "Sharded replication group",
"ReplicationGroupId": "rc-rg",
"SnapshotRetentionLimit": 8,
"AutomaticFailover": "enabled",
"SnapshotWindow": "10:00-11:00",
"MemberClusters": [
"rc-rg-0001-001",
"rc-rg-0001-002",
"rc-rg-0002-001",
"rc-rg-0002-002",
"rc-rg-0002-003"
],
"PendingModifiedValues": {}
}
}
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat AWS CLI topiknya[create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
## Membuat grup replikasi di Valkey atau Redis OSS (Mode Cluster Diaktifkan) dari awal (API) ElastiCache
Prosedur berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) menggunakan API. ElastiCache
Saat Anda membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) dari awal, Anda membuat grup replikasi dan semua node dengan satu panggilan ke operasi API. ElastiCache `CreateReplicationGroup` Sertakan parameter berikut.
**ReplicationGroupId**
Nama grup replikasi yang Anda buat.
Kendala penamaan grup replikasi Valkey atau Redis OSS (mode cluster enabled) adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
**ReplicationGroupDescription**
Deskripsi grup replikasi.
**NumNodeGroups**
Jumlah grup simpul yang ingin Anda buat dengan grup replikasi ini. Nilai yang valid adalah 1 sampai 500.
**ReplicasPerNodeGroup**
Jumlah simpul replika di setiap grup simpul. Nilai yang valid adalah 1 sampai 5.
**NodeGroupConfiguration**
Konfigurasi untuk setiap grup simpul. Parameter `NodeGroupConfiguration` terdiri dari bidang berikut.
+ `PrimaryAvailabilityZone` – Zona Ketersediaan yang menjadi lokasi dari simpul primer dari grup simpul ini. Jika parameter ini dihilangkan, ElastiCache pilih Availability Zone untuk node utama.
**Contoh:** us-west-2a.
+ `ReplicaAvailabilityZones` – Daftar Zona Ketersediaan tempat replika baca berada. Jumlah Zona Ketersediaan dalam daftar harus sesuai dengan nilai dari `ReplicaCount`. Jika parameter ini dihilangkan, ElastiCache pilih Availability Zones untuk node replika.
+ `ReplicaCount` – Jumlah simpul replika di setiap grup simpul.
+ `Slots` – String yang menentukan ruang kunci untuk grup simpul. String menggunakan format `startKey-endKey`. Jika parameter ini dihilangkan, ElastiCache mengalokasikan kunci secara merata di antara kelompok node.
**Contoh:** "0-4999"
**CacheNodeType**
Jenis simpul untuk setiap simpul dalam grup replikasi.
ElastiCache mendukung jenis node berikut. Secara umum, jenis generasi saat ini memberikan lebih banyak memori dan daya komputasi dengan biaya lebih rendah dibandingkan dengan jenis generasi sebelumnya yang setara.
Untuk informasi selengkapnya tentang detail performa untuk setiap jenis node, lihat [Jenis EC2 Instance Amazon](https://aws.amazon.com/ec2/instance-types/).
**--data-tiering-enabled**
Atur parameter ini jika Anda menggunakan jenis simpul r6gd. Jika Anda tidak ingin tingkatan data, atur `--no-data-tiering-enabled`. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
**CacheParameterGroup**
Tentukan grup `default.redis6.x.cluster.on` parameter atau grup parameter yang berasal dari `default.redis6.x.cluster.on` untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster diaktifkan). Untuk informasi selengkapnya, lihat [Redis OSS 6.x perubahan parameter](ParameterGroups.Engine.md#ParameterGroups.Redis.6-x).
**--network-type**
Baik `ipv4`, `ipv` atau `dual-stack`. Jika Anda memilih tumpukan ganda, Anda harus mengatur parameter `--IpDiscovery` ke salah satu `ipv4` atau `ipv6`.
**Engine**
redis
**EngineVersion**
6.0
Jika Anda ingin mengaktifkan enkripsi bergerak atau diam pada grup replikasi ini, tambahkan salah satu atau kedua parameter `TransitEncryptionEnabled=true` atau `AtRestEncryptionEnabled=true` dan penuhi kondisi berikut.
+ Grup replikasi Anda harus menjalankan Redis OSS versi 3.2.6 atau 4.0.10.
+ Grup replikasi harus dibuat dalam Amazon VPC.
+ Anda juga harus menyertakan parameter `CacheSubnetGroup`.
+ Anda juga harus menyertakan parameter `AuthToken` dengan nilai string yang ditentukan oleh pelanggan untuk token (kata sandi) AUTH Anda yang diperlukan untuk melakukan operasi pada grup replikasi ini.
Jeda baris ditambahkan agar dapat lebih mudah dibaca.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateReplicationGroup
&CacheNodeType=cache.m4.large
&CacheParemeterGroup=default.redis6.xcluster.on
&Engine=redis
&EngineVersion=6.0
&NumNodeGroups=3
&ReplicasPerNodeGroup=2
&ReplicationGroupDescription=test%20group
&ReplicationGroupId=myReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi dan parameter tambahan yang mungkin ingin Anda gunakan, lihat topik ElastiCache API[CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html).
# Melihat detail grup replikasi
Terkadang Anda sebaiknya melihat detail grup replikasi. Anda dapat menggunakan ElastiCache konsol, AWS CLI for ElastiCache, atau ElastiCache API. Proses konsol berbeda untuk Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan).
**Contents**
+ [Melihat Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dengan replika](Replication.ViewDetails.Redis.md)
+ [Menggunakan ElastiCache Konsol](Replication.ViewDetails.Redis.md#Replication.ViewDetails.Redis.CON)
+ [Menggunakan AWS CLI](Replication.ViewDetails.Redis.md#Replication.ViewDetails.Redis.CLI)
+ [Menggunakan ElastiCache API](Replication.ViewDetails.Redis.md#Replication.ViewDetails.Redis.API)
+ [Melihat grup replikasi: Valkey atau Redis OSS (Mode Cluster Diaktifkan)](Replication.ViewDetails.RedisCluster.md)
+ [Menggunakan ElastiCache Konsol](Replication.ViewDetails.RedisCluster.md#Replication.ViewDetails.RedisCluster.CON)
+ [Menggunakan AWS CLI](Replication.ViewDetails.RedisCluster.md#Replication.ViewDetails.RedisCluster.CLI)
+ [Menggunakan ElastiCache API](Replication.ViewDetails.RedisCluster.md#Replication.ViewDetails.RedisCluster.API)
+ [Melihat detail grup replikasi (AWS CLI)](Replication.ViewDetails.CLI.md)
+ [Melihat detail grup replikasi (ElastiCache API)](Replication.ViewDetails.API.md)
# Melihat Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dengan replika
Anda dapat melihat detail cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan replika (API/CLI: *grup replikasi*) menggunakan ElastiCache konsol, for, atau API. AWS CLI ElastiCache ElastiCache
**Contents**
+ [Menggunakan ElastiCache Konsol](#Replication.ViewDetails.Redis.CON)
+ [Menggunakan AWS CLI](#Replication.ViewDetails.Redis.CLI)
+ [Menggunakan ElastiCache API](#Replication.ViewDetails.Redis.API)
## Melihat Grup Replikasi Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)
Untuk melihat detail cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan replika menggunakan ElastiCache konsol, lihat topiknya. [Melihat detail Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Clusters.ViewDetails.md#Clusters.ViewDetails.CON.Redis)
## Melihat grup replikasi Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) ()AWS CLI
Untuk AWS CLI contoh yang menampilkan detail grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), lihat. [Melihat detail grup replikasi (AWS CLI)](Replication.ViewDetails.CLI.md)
## Melihat Grup Replikasi (API) Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) ElastiCache
Untuk contoh ElastiCache API yang menampilkan detail grup replikasi Valkey atau Redis OSS (mode klaster dinonaktifkan), lihat. [Melihat detail grup replikasi (ElastiCache API)](Replication.ViewDetails.API.md)
# Melihat grup replikasi: Valkey atau Redis OSS (Mode Cluster Diaktifkan)
## Melihat cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan) (Konsol)
Untuk melihat detail cluster Valkey atau Redis OSS (mode cluster enabled) menggunakan ElastiCache konsol, lihat. [Melihat detail untuk cluster Valkey atau Redis OSS (Cluster Mode Enabled) (Konsol)](Clusters.ViewDetails.md#Clusters.ViewDetails.CON.RedisCluster)
## Melihat cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan) ()AWS CLI
Untuk contoh ElastiCache CLI yang menampilkan detail grup replikasi Valkey atau Redis OSS (mode cluster enabled), lihat. [Melihat detail grup replikasi (AWS CLI)](Replication.ViewDetails.CLI.md)
## Melihat Cluster (API) Valkey atau Redis OSS (Mode Cluster Diaktifkan) ElastiCache
Untuk contoh ElastiCache API yang menampilkan detail grup replikasi Valkey atau Redis OSS (mode cluster enabled), lihat. [Melihat detail grup replikasi (ElastiCache API)](Replication.ViewDetails.API.md)
# Melihat detail grup replikasi (AWS CLI)
Anda dapat melihat detail untuk grup replikasi menggunakan AWS CLI `describe-replication-groups` perintah. Gunakan parameter opsional berikut untuk menyaring daftar. Menghilangkan parameter akan menampilkan detail hingga 100 grup replikasi.
**Parameter Opsional**
+ `--replication-group-id` – Gunakan parameter ini untuk mencantumkan detail grup replikasi tertentu. Jika grup replikasi yang ditentukan memiliki lebih dari satu grup simpul, hasil yang ditampilkan akan dikelompokkan berdasarkan grup simpul.
+ `--max-items` – Gunakan parameter ini untuk membatasi jumlah grup replikasi yang dicantumkan. Nilai dari `--max-items` tidak boleh kurang dari 20 atau lebih besar dari 100.
**Example**
Kode berikut menampilkan daftar detail hingga 100 grup replikasi.
```
aws elasticache describe-replication-groups
```
Kode berikut menampilkan daftar detail untuk `sample-repl-group`.
```
aws elasticache describe-replication-groups --replication-group-id sample-repl-group
```
Kode berikut menampilkan daftar detail untuk `sample-repl-group`.
```
aws elasticache describe-replication-groups --replication-group-id sample-repl-group
```
Kode berikut mencantumkan detail hingga 25 grup replikasi.
```
aws elasticache describe-replication-groups --max-items 25
```
Output dari operasi ini terlihat seperti berikut ini (format JSON).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "rg-name-001.1abc4d.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "rg-name-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "rg-name-002.1abc4d.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "rg-name-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "rg-name-003.1abc4d.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "rg-name-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "rg-name.1abc4d.ng.0001.usw2.cache.amazonaws.com"
}
}
],
"ReplicationGroupId": "rg-name",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "rg-name-002",
"MemberClusters": [
"rg-name-001",
"rg-name-002",
"rg-name-003"
],
"PendingModifiedValues": {}
},
{
... some output omitted for brevity
}
]
}
```
Untuk informasi selengkapnya, lihat ElastiCache topik AWS CLI untuk[describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html).
# Melihat detail grup replikasi (ElastiCache API)
Anda dapat melihat detail untuk replikasi menggunakan AWS CLI `DescribeReplicationGroups` operasi. Gunakan parameter opsional berikut untuk menyaring daftar. Menghilangkan parameter akan menampilkan detail hingga 100 grup replikasi.
**Parameter Opsional**
+ `ReplicationGroupId` – Gunakan parameter ini untuk mencantumkan detail grup replikasi tertentu. Jika grup replikasi yang ditentukan memiliki lebih dari satu grup simpul, hasil yang ditampilkan akan dikelompokkan berdasarkan grup simpul.
+ `MaxRecords` – Gunakan parameter ini untuk membatasi jumlah grup replikasi yang dicantumkan. Nilai dari `MaxRecords` tidak boleh kurang dari 20 atau lebih besar dari 100. Secara default, nilainya adalah 100.
**Example**
Kode berikut mencantumkan detail maksimum hingga 100 grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Kode berikut menampilkan daftar detail untuk `myReplGroup`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Kode berikut menampilkan daftar detail untuk maksimal 25 klaster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat topik referensi ElastiCache API[DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Menemukan titik akhir grup replikasi
Aplikasi dapat terhubung ke simpul apa pun dalam grup replikasi, asalkan memiliki titik akhir DNS dan nomor port untuk simpul tersebut. Bergantung pada apakah Anda menjalankan grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) atau Valkey atau Redis OSS (mode cluster diaktifkan), Anda akan tertarik pada titik akhir yang berbeda.
**Valkey atau Redis OSS (mode cluster dinonaktifkan)**
**Cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan replika memiliki tiga jenis titik akhir; titik akhir *primer, titik akhir pembaca, dan titik akhir* node.** Titik akhir primer adalah nama DNS yang selalu diresolusi ke simpul primer di klaster. Titik akhir primer tidak terpengaruh oleh perubahan klaster Anda, seperti promosi replika baca ke peran primer. Untuk aktivitas tulis, sebaiknya aplikasi Anda terhubung ke titik akhir primer.
Titik akhir pembaca akan membagi koneksi masuk secara merata ke titik akhir antara semua replika baca dalam sebuah cluster. ElastiCache Faktor lain seperti saat aplikasi membuat koneksi atau cara aplikasi menggunakan atau menggunakan ulang koneksi akan menentukan distribusi lalu lintas. Titik akhir pembaca tetap mengikuti perubahan klaster dalam waktu nyata saat replika ditambahkan atau dihapus. Anda dapat menempatkan beberapa replika baca klaster Redis OSS Anda ElastiCache di AWS Availability Zones (AZ) yang berbeda untuk memastikan ketersediaan titik akhir pembaca yang tinggi.
**catatan**
Titik akhir pembaca bukan penyeimbang beban. Ini adalah catatan DNS yang akan diresolusi sebagai alamat IP dari salah satu simpul replika dengan metode round robin.
Untuk aktivitas baca, aplikasi juga dapat menghubungkan ke simpul mana pun di klaster. Tidak seperti titik akhir primer, titik akhir simpul diresolusi ke titik akhir tertentu. Jika Anda membuat perubahan dalam klaster Anda, seperti menambahkan atau menghapus replika, Anda harus memperbarui titik akhir simpul di aplikasi Anda.
**Valkey atau Redis OSS (mode cluster diaktifkan)**
Valkey atau Redis OSS (mode cluster enabled) cluster dengan replika, karena mereka memiliki beberapa pecahan (API/CLI: grup node), yang berarti mereka juga memiliki beberapa node primer, memiliki struktur endpoint yang berbeda dari Valkey atau Redis OSS (cluster mode disabled) cluster. Valkey atau Redis OSS (mode cluster diaktifkan) memiliki *titik akhir konfigurasi yang “mengetahui” semua titik akhir* primer dan node di cluster. Aplikasi Anda terhubung ke titik akhir konfigurasi. Setiap kali aplikasi Anda menulis atau membaca dari titik akhir konfigurasi cluster, Valkey dan Redis OSS, di belakang layar, tentukan pecahan kunci mana dan titik akhir mana dalam pecahan itu untuk digunakan. Semua proses ini bersifat cukup transparan untuk aplikasi Anda.
Anda dapat menemukan titik akhir untuk klaster menggunakan ElastiCache konsol, the AWS CLI, atau ElastiCache API.
**Menemukan Titik Akhir Grup Replikasi**
Untuk menemukan titik akhir untuk grup replikasi Anda, lihat salah satu topik berikut:
+ [Menemukan Titik Akhir Cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.Redis)
+ [Menemukan Titik Akhir untuk Cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan) (Konsol)](Endpoints.md#Endpoints.Find.RedisCluster)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS ()AWS CLI](Endpoints.md#Endpoints.Find.CLI.ReplGroups)
+ [Menemukan Titik Akhir untuk Grup Replikasi Valkey atau Redis OSS (API) ElastiCache](Endpoints.md#Endpoints.Find.API.ReplGroups)
# Mengubah grup replikasi
**Batasan Penting**
Saat ini, ElastiCache mendukung modifikasi terbatas dari grup replikasi Valkey atau Redis OSS (mode cluster enabled), misalnya mengubah versi mesin, menggunakan operasi API (`ModifyReplicationGroup`CLI:). `modify-replication-group` Anda dapat memodifikasi jumlah pecahan (grup node) di cluster Valkey atau Redis OSS (mode cluster enabled) dengan operasi API ([https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html)CLI:). [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group-shard-configuration.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group-shard-configuration.html) Untuk informasi selengkapnya, lihat [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md).
Modifikasi lain pada cluster Valkey atau Redis OSS (mode cluster enabled) mengharuskan Anda membuat cluster dengan cluster baru yang menggabungkan perubahan.
Anda dapat memutakhirkan Valkey atau Redis OSS (mode cluster dinonaktifkan) dan Valkey atau Redis OSS (mode cluster diaktifkan) cluster dan grup replikasi ke versi mesin yang lebih baru. Namun, Anda tidak dapat menurunkan klaster ke versi mesin yang lebih lama kecuali dengan menghapus klaster atau grup replikasi yang sudah ada dan membuatnya lagi. Untuk informasi selengkapnya, lihat [Manajemen Versi untuk ElastiCache](VersionManagement.md).
Anda dapat memutakhirkan cluster Valkey atau Redis OSS yang sudah ada ElastiCache yang menggunakan mode cluster dinonaktifkan untuk menggunakan mode cluster diaktifkan, menggunakan konsol, [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html)API atau perintah [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)CLI, seperti yang ditunjukkan pada contoh di bawah ini. Anda juga dapat mengikuti langkah-langkah di [Mengubah mode klaster](modify-cluster-mode.md).
Anda dapat memodifikasi pengaturan cluster Valkey atau Redis OSS (mode cluster disabled) menggunakan ElastiCache konsol, API AWS CLI, atau API. ElastiCache Saat ini, ElastiCache mendukung sejumlah modifikasi terbatas pada grup replikasi Valkey atau Redis OSS (mode cluster enabled). Modifikasi lain mengharuskan Anda membuat cadangan grup replikasi saat ini kemudian menggunakan cadangan itu untuk menyemai grup replikasi Valkey atau Redis OSS (mode cluster enabled) baru.
**Topics**
+ [Menggunakan Konsol Manajemen AWS](#Replication.Modify.CON)
+ [Menggunakan AWS CLI](#Replication.Modify.CLI)
+ [Menggunakan ElastiCache API](#Replication.Modify.API)
## Menggunakan Konsol Manajemen AWS
Untuk memodifikasi cluster Valkey atau Redis OSS (mode cluster dinonaktifkan), lihat. [Memodifikasi cluster ElastiCache](Clusters.Modify.md)
## Menggunakan AWS CLI
Berikut ini adalah AWS CLI contoh `modify-replication-group` perintah. Anda dapat menggunakan perintah yang sama untuk membuat perubahan lain pada grup replikasi.
**Aktifkan Multi-AZ pada grup replikasi Valkey atau Redis OSS yang ada:**
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id myReplGroup \
--multi-az-enabled = true
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id myReplGroup ^
--multi-az-enabled
```
**Ubah mode klaster dari dinonaktifkan menjadi diaktifkan:**
Untuk mengubah mode klaster dari *dinonaktifkan* ke *diaktifkan*, Anda harus terlebih dahulu mengatur mode klaster ke *kompatibel*. Mode yang kompatibel memungkinkan klien Valkey atau Redis OSS Anda terhubung menggunakan mode cluster diaktifkan dan mode cluster dinonaktifkan. *Setelah Anda memigrasikan semua klien Valkey atau Redis OSS untuk menggunakan mode cluster yang diaktifkan, Anda kemudian dapat menyelesaikan konfigurasi mode cluster dan mengatur mode cluster ke diaktifkan.*
Untuk Linux, macOS, atau Unix:
Atur ke mode klaster *kompatibel*.
```
aws elasticache modify-replication-group \
--replication-group-id myReplGroup \
--cache-parameter-group-name myParameterGroupName \
--cluster-mode compatible
```
Atur ke mode klaster *diaktifkan*.
```
aws elasticache modify-replication-group \
--replication-group-id myReplGroup \
--cluster-mode enabled
```
Untuk Windows:
Atur ke mode klaster *kompatibel*.
```
aws elasticache modify-replication-group ^
--replication-group-id myReplGroup ^
--cache-parameter-group-name myParameterGroupName ^
--cluster-mode compatible
```
Atur ke mode klaster *diaktifkan*.
```
aws elasticache modify-replication-group ^
--replication-group-id myReplGroup ^
--cluster-mode enabled
```
Untuk informasi selengkapnya tentang AWS CLI `modify-replication-group` perintah, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) atau [Memodifikasi mode cluster]() di Panduan *ElastiCache Pengguna Redis OSS*.
## Menggunakan ElastiCache API
Operasi ElastiCache API berikut memungkinkan Multi-AZ pada grup replikasi Valkey atau Redis OSS yang ada. Anda dapat menggunakan operasi yang sama untuk membuat perubahan lain pada grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&AutomaticFailoverEnabled=true
&Mutli-AZEnabled=true
&ReplicationGroupId=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya tentang `ModifyReplicationGroup` operasi ElastiCache API, lihat[ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html).
# Menghapus grup replikasi
Jika Anda tidak lagi memerlukan salah satu klaster dengan replika (disebut *grup replikasi* pada API/CLI), Anda dapat menghapusnya. Ketika Anda menghapus grup replikasi, ElastiCache menghapus semua node dalam grup itu.
Setelah Anda memulainya, operasi ini tidak dapat dihentikan atau dibatalkan.
**Awas**
Saat Anda menghapus cluster ElastiCache untuk Redis OSS, snapshot manual Anda dipertahankan. Anda juga memiliki pilihan untuk membuat snapshot terakhir sebelum klaster dihapus. Snapshot cache otomatis tidak dipertahankan.
`CreateSnapshot`izin diperlukan untuk membuat snapshot akhir. Tanpa izin ini, panggilan API akan gagal dengan `Access Denied` pengecualian.
## Menghapus Grup Replikasi (Konsol)
Untuk menghapus klaster yang memiliki replika, lihat [Menghapus cluster di ElastiCache](Clusters.Delete.md).
## Menghapus Grup Replikasi (AWS CLI)
Gunakan perintah [delete-replication-group](https://docs.aws.amazon.com/AmazonElastiCache/latest/CommandLineReference/CLIReference-cmd-DeleteReplicationGroup.html) untuk menghapus grup replikasi.
```
aws elasticache delete-replication-group --replication-group-id my-repgroup
```
Muncul prompt yang meminta konfirmasi keputusan Anda. Masukkan *y* (ya) untuk segera memulai operasi tersebut. Setelah dimulai, proses tidak dapat dibatalkan.
```
After you begin deleting this replication group, all of its nodes will be deleted as well.
Are you sure you want to delete this replication group? [Ny]y
REPLICATIONGROUP my-repgroup My replication group deleting
```
## Menghapus grup replikasi (API) ElastiCache
Memanggil [DeleteReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteReplicationGroup.html) dengan parameter `ReplicationGroup`.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteReplicationGroup
&ReplicationGroupId=my-repgroup
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
**catatan**
Jika Anda menetapkan parameter `RetainPrimaryCluster` ke `true`, semua replika baca akan dihapus, tetapi klaster primer akan dipertahankan.
# Mengubah jumlah replika
Anda dapat secara dinamis menambah atau mengurangi jumlah replika baca di grup replikasi Valkey atau Redis OSS Anda menggunakan Konsol Manajemen AWS, the, atau API. AWS CLI ElastiCache Jika grup replikasi Anda adalah grup replikasi Valkey atau Redis OSS (mode cluster enabled), Anda dapat memilih pecahan (grup simpul) mana yang akan menambah atau mengurangi jumlah replika.
Untuk secara dinamis mengubah jumlah replika dalam grup replikasi Anda, pilih operasi dari tabel berikut yang sesuai dengan situasi Anda.
| Untuk Melakukannya | Untuk Valkey atau Redis OSS (mode cluster diaktifkan) | Untuk Valkey atau Redis OSS (mode cluster dinonaktifkan) |
| --- | --- | --- |
| Tambahkan replika | [Menambah jumlah replika dalam serpihan](increase-replica-count.md) | [Menambah jumlah replika dalam serpihan](increase-replica-count.md) [Menambahkan replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Replication.AddReadReplica.md) |
| Menghapus replika | [Mengurangi jumlah replika dalam serpihan](decrease-replica-count.md) | [Mengurangi jumlah replika dalam serpihan](decrease-replica-count.md) [Menghapus replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Replication.RemoveReadReplica.md) |
# Menambah jumlah replika dalam serpihan
Anda dapat meningkatkan jumlah replika dalam pecahan Valkey atau Redis OSS (mode cluster diaktifkan) atau Valkey atau Redis OSS (mode cluster dinonaktifkan) grup replikasi hingga maksimal lima. Anda dapat melakukannya dengan menggunakan Konsol Manajemen AWS, the AWS CLI, atau ElastiCache API.
**Topics**
+ [Menggunakan Konsol Manajemen AWS](#increase-replica-count-con)
+ [Menggunakan AWS CLI](#increase-replica-count-cli)
+ [Menggunakan ElastiCache API](#increase-replica-count-api)
## Menggunakan Konsol Manajemen AWS
Prosedur berikut menggunakan konsol untuk meningkatkan jumlah replika dalam grup replikasi Valkey atau Redis OSS (mode cluster enabled).
**Untuk meningkatkan jumlah replika dalam pecahan**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis OSS**, lalu pilih nama grup replikasi yang ingin Anda tambahkan replika.
1. Pilih kotak untuk setiap serpihan yang replikanya akan ditambah.
1. Pilih **Tambahkan replika**.
1. Lengkapi halaman **Tambahkan Replika ke Serpihan**:
+ Untuk **Jumlah replikasi/serpihan baru**, masukkan jumlah replika yang Anda inginkan untuk semua serpihan yang dipilih. Nilai ini harus lebih besar atau sama dengan **Jumlah replika per serpihan saat ini** dan kurang dari atau sama dengan lima. Kami menyarankan setidaknya dua replika sebagai syarat minimum.
+ Untuk **Availability Zone**, pilih salah satu **Tidak ada preferensi** untuk ElastiCache memilih Availability Zone untuk setiap replika baru, atau **Tentukan Availability Zone** untuk memilih Availability Zone untuk setiap replika baru.
Jika Anda memilih **Tentukan Zona Ketersediaan**, tentukan satu Zona Ketersediaan untuk setiap replika baru menggunakan daftar.
1. Pilih **Tambahkan** untuk menambahkan replika atau **Batalkan** untuk membatalkan operasi.
## Menggunakan AWS CLI
Untuk meningkatkan jumlah replika dalam pecahan Valkey atau Redis OSS, gunakan `increase-replica-count` perintah dengan parameter berikut:
+ `--replication-group-id` – Wajib. Identifikasi grup replikasi yang ingin ditambah jumlah replikanya.
+ `--apply-immediately` atau `--no-apply-immediately` – Wajib. Menentukan apakah akan menambah jumlah replika segera (`--apply-immediately`) atau pada periode pemeliharaan berikutnya (`--no-apply-immediately`). Saat ini, `--no-apply-immediately` belum didukung.
+ `--new-replica-count` – Opsional. Menentukan jumlah simpul replika yang Anda inginkan saat selesai, maksimum lima. Gunakan parameter ini untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) di mana hanya ada satu grup node atau grup Valkey atau Redis OSS (mode cluster diaktifkan), atau di mana Anda ingin semua grup node memiliki jumlah replika yang sama. Jika nilai ini tidak lebih besar dari jumlah replika saat ini dalam grup simpul, panggilan akan gagal dengan pengecualian.
+ `--replica-configuration` – Opsional. Memungkinkan Anda menentukan jumlah replika dan Zona Ketersediaan untuk setiap grup simpul secara terpisah. Gunakan parameter ini untuk grup Valkey atau Redis OSS (mode cluster enabled) di mana Anda ingin mengkonfigurasi setiap grup node secara independen.
`--replica-configuration` memiliki tiga anggota opsional:
+ `NodeGroupId` – ID empat digit untuk grup simpul yang sedang dikonfigurasi. Untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), ID pecahan selalu ada. `0001` Untuk menemukan ID grup node (shard) Valkey atau Redis OSS (mode cluster enabled), lihat. [Menemukan ID serpihan](Shards.md#shard-find-id)
+ `NewReplicaCount` – Jumlah replika yang Anda inginkan dalam grup simpul ini pada akhir operasi ini. Nilai ini harus lebih besar dari jumlah replika saat ini, maksimum lima. Jika nilai ini tidak lebih besar dari jumlah replika saat ini dalam grup simpul, panggilan akan gagal dengan pengecualian.
+ `PreferredAvailabilityZones` – Daftar string `PreferredAvailabilityZone` yang menentukan Zona Ketersediaan tempat simpul grup replikasi berada. Jumlah nilai `PreferredAvailabilityZone` harus sama dengan nilai `NewReplicaCount` ditambah 1 untuk memperhitungkan simpul primer. Jika anggota `--replica-configuration` ini dihilangkan, ElastiCache untuk Redis OSS memilih Availability Zone untuk masing-masing replika baru.
**penting**
Anda harus menyertakan parameter `--new-replica-count` atau `--replica-configuration`, tetapi tidak keduanya sekaligus, dalam panggilan Anda.
**Example**
Contoh berikut menambah jumlah replika dalam grup replikasi `sample-repl-group` menjadi tiga. Ketika contoh ini selesai, terdapat tiga replika di setiap grup simpul. Nomor ini berlaku apakah ini adalah grup Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan grup node tunggal atau grup Valkey atau Redis OSS (mode cluster diaktifkan) dengan beberapa grup node.
Untuk Linux, macOS, atau Unix:
```
aws elasticache increase-replica-count \
--replication-group-id sample-repl-group \
--new-replica-count 3 \
--apply-immediately
```
Untuk Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id sample-repl-group ^
--new-replica-count 3 ^
--apply-immediately
```
Contoh berikut menambah jumlah replika dalam grup replikasi `sample-repl-group` ke nilai yang ditentukan untuk kedua grup simpul yang ditentukan tersebut. Mengingat bahwa ada beberapa grup node, ini adalah grup replikasi Valkey atau Redis OSS (mode cluster enabled). Saat menentukan `PreferredAvailabilityZones` opsional, jumlah Zona Ketersediaan yang tercantum harus sama dengan nilai dari `NewReplicaCount` ditambah 1. Pendekatan ini memperhitungkan simpul primer untuk grup yang diidentifikasi berdasarkan `NodeGroupId`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache increase-replica-count \
--replication-group-id sample-repl-group \
--replica-configuration \
NodeGroupId=0001,NewReplicaCount=2,PreferredAvailabilityZones=us-east-1a,us-east-1c,us-east-1b \
NodeGroupId=0003,NewReplicaCount=3,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c,us-east-1c \
--apply-immediately
```
Untuk Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id sample-repl-group ^
--replica-configuration ^
NodeGroupId=0001,NewReplicaCount=2,PreferredAvailabilityZones=us-east-1a,us-east-1c,us-east-1b ^
NodeGroupId=0003,NewReplicaCount=3,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c,us-east-1c \
--apply-immediately
```
Untuk informasi selengkapnya tentang meningkatkan jumlah replika menggunakan CLI, [increase-replica-count](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html)lihat di Referensi Baris *Perintah ElastiCache Amazon*.
## Menggunakan ElastiCache API
Untuk meningkatkan jumlah replika dalam pecahan Valkey atau Redis OSS, gunakan `IncreaseReplicaCount` tindakan dengan parameter berikut:
+ `ReplicationGroupId` – Wajib. Identifikasi grup replikasi yang ingin ditambah jumlah replikanya.
+ `ApplyImmediately` – Wajib. Menentukan apakah akan menambah jumlah replika segera (`ApplyImmediately=True`) atau pada periode pemeliharaan berikutnya (`ApplyImmediately=False`). Saat ini, `ApplyImmediately=False` belum didukung.
+ `NewReplicaCount` – Opsional. Menentukan jumlah simpul replika yang Anda inginkan saat selesai, maksimum lima. Gunakan parameter ini untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) di mana hanya ada satu grup node, atau grup Valkey atau Redis OSS (mode cluster diaktifkan) di mana Anda ingin semua grup node memiliki jumlah replika yang sama. Jika nilai ini tidak lebih besar dari jumlah replika saat ini dalam grup simpul, panggilan akan gagal dengan pengecualian.
+ `ReplicaConfiguration` – Opsional. Memungkinkan Anda menentukan jumlah replika dan Zona Ketersediaan untuk setiap grup simpul secara terpisah. Gunakan parameter ini untuk grup Valkey atau Redis OSS (mode cluster enabled) di mana Anda ingin mengkonfigurasi setiap grup node secara independen.
`ReplicaConfiguraion` memiliki tiga anggota opsional:
+ `NodeGroupId` – ID empat digit untuk grup simpul yang sedang dikonfigurasi. Untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), ID grup node (shard) selalu. `0001` Untuk menemukan ID grup node (shard) Valkey atau Redis OSS (mode cluster enabled), lihat. [Menemukan ID serpihan](Shards.md#shard-find-id)
+ `NewReplicaCount` – Jumlah replika yang Anda inginkan dalam grup simpul ini pada akhir operasi ini. Nilai ini harus lebih dari jumlah replika saat ini dan maksimum lima. Jika nilai ini tidak lebih besar dari jumlah replika saat ini dalam grup simpul, panggilan akan gagal dengan pengecualian.
+ `PreferredAvailabilityZones` – Daftar string `PreferredAvailabilityZone` yang menentukan Zona Ketersediaan tempat simpul grup replikasi berada. Jumlah nilai `PreferredAvailabilityZone` harus sama dengan nilai `NewReplicaCount` ditambah 1 untuk memperhitungkan simpul primer. Jika anggota `ReplicaConfiguration` ini dihilangkan, ElastiCache untuk Redis OSS memilih Availability Zone untuk masing-masing replika baru.
**penting**
Anda harus menyertakan parameter `NewReplicaCount` atau `ReplicaConfiguration`, tetapi tidak keduanya sekaligus, dalam panggilan Anda.
**Example**
Contoh berikut menambah jumlah replika dalam grup replikasi `sample-repl-group` menjadi tiga. Ketika contoh ini selesai, terdapat tiga replika di setiap grup simpul. Nomor ini berlaku apakah ini adalah grup Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan grup node tunggal, atau grup Valkey atau Redis OSS (mode cluster diaktifkan) dengan beberapa grup node.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=True
&NewReplicaCount=3
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Contoh berikut menambah jumlah replika dalam grup replikasi `sample-repl-group` ke nilai yang ditentukan untuk kedua grup simpul yang ditentukan tersebut. Mengingat bahwa ada beberapa grup node, ini adalah grup replikasi Valkey atau Redis OSS (mode cluster enabled). Saat menentukan `PreferredAvailabilityZones` opsional, jumlah Zona Ketersediaan yang tercantum harus sama dengan nilai dari `NewReplicaCount` ditambah 1. Pendekatan ini memperhitungkan simpul primer, untuk grup yang diidentifikasi berdasarkan `NodeGroupId`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=True
&ReplicaConfiguration.ConfigureShard.1.NodeGroupId=0001
&ReplicaConfiguration.ConfigureShard.1.NewReplicaCount=2
&ReplicaConfiguration.ConfigureShard.1.PreferredAvailabilityZones.PreferredAvailabilityZone.1=us-east-1a
&ReplicaConfiguration.ConfigureShard.1.PreferredAvailabilityZones.PreferredAvailabilityZone.2=us-east-1c
&ReplicaConfiguration.ConfigureShard.1.PreferredAvailabilityZones.PreferredAvailabilityZone.3=us-east-1b
&ReplicaConfiguration.ConfigureShard.2.NodeGroupId=0003
&ReplicaConfiguration.ConfigureShard.2.NewReplicaCount=3
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.1=us-east-1a
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.2=us-east-1b
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.3=us-east-1c
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.4=us-east-1c
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya tentang meningkatkan jumlah replika yang menggunakan API, lihat [IncreaseReplicaCount](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html)di *Referensi Amazon ElastiCache API*.
# Mengurangi jumlah replika dalam serpihan
Anda dapat mengurangi jumlah replika dalam pecahan untuk Valkey atau Redis OSS (mode cluster diaktifkan), atau dalam grup replikasi untuk Valkey atau Redis OSS (mode cluster dinonaktifkan):
+ Untuk Valkey atau Redis OSS (mode cluster dinonaktifkan), Anda dapat mengurangi jumlah replika menjadi satu jika Multi-AZ diaktifkan, dan menjadi nol jika tidak diaktifkan.
+ Untuk Valkey atau Redis OSS (mode cluster diaktifkan), Anda dapat mengurangi jumlah replika menjadi nol. Namun, Anda tidak dapat melakukan failover ke replika jika simpul primer Anda gagal.
Anda dapat menggunakan Konsol Manajemen AWS, the AWS CLI atau ElastiCache API untuk mengurangi jumlah replika dalam grup node (shard) atau grup replikasi.
**Topics**
+ [Menggunakan Konsol Manajemen AWS](#decrease-replica-count-con)
+ [Menggunakan AWS CLI](#decrease-replica-count-cli)
+ [Menggunakan ElastiCache API](#decrease-replica-count-api)
## Menggunakan Konsol Manajemen AWS
Prosedur berikut menggunakan konsol untuk mengurangi jumlah replika dalam grup replikasi Valkey atau Redis OSS (mode cluster enabled).
**Untuk mengurangi jumlah replika dalam pecahan Valkey atau Redis OSS**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih **Valkey** atau **Redis OSS**, lalu pilih nama grup replikasi tempat Anda ingin menghapus replika.
1. Pilih kotak untuk setiap serpihan yang ingin dihapus simpul replika dalamnya.
1. Pilih **Hapus replika**.
1. Lengkapi halaman **Hapus Replika dari Serpihan**:
1. Untuk **Jumlah replikasi/serpihan baru**, masukkan jumlah replika yang Anda inginkan untuk serpihan yang dipilih. Nilai ini harus lebih besar atau sama dengan 1. Kami menyarankan setidaknya dua replika per serpihan sebagai syarat minimum.
1. Pilih **Hapus** untuk menghapus replika atau **Batalkan** untuk membatalkan operasi.
**penting**
Jika Anda tidak menentukan node replika yang akan dihapus, ElastiCache untuk Redis OSS secara otomatis memilih node replika untuk dihapus. Saat melakukannya, ElastiCache untuk Redis OSS mencoba mempertahankan arsitektur multi-AZ untuk grup replikasi Anda diikuti dengan mempertahankan replika dengan lag replikasi minimum dengan primer.
Anda tidak dapat menghapus primer atau simpul primer dalam grup replikasi. Jika Anda menentukan simpul primer untuk dihapus, operasi akan gagal dengan peristiwa kesalahan yang menunjukkan bahwa simpul primer telah dipilih untuk penghapusan.
## Menggunakan AWS CLI
Untuk mengurangi jumlah replika dalam pecahan Valkey atau Redis OSS, gunakan `decrease-replica-count` perintah dengan parameter berikut:
+ `--replication-group-id` – Wajib. Identifikasi grup replikasi yang ingin dikurangi jumlah replikanya.
+ `--apply-immediately` atau `--no-apply-immediately` – Wajib. Menentukan apakah akan mengurangi jumlah replika dengan segera (`--apply-immediately`) atau pada periode pemeliharaan berikutnya (`--no-apply-immediately`). Saat ini, `--no-apply-immediately` belum didukung.
+ `--new-replica-count` – Opsional. Menentukan jumlah simpul replika yang Anda inginkan. Nilai dari `--new-replica-count` harus nilai yang valid dan kurang dari jumlah replika saat ini dalam grup simpul. Untuk nilai minimum yang diizinkan, lihat [Mengurangi jumlah replika dalam serpihan](#decrease-replica-count). Jika nilai `--new-replica-count` tidak memenuhi persyaratan ini, panggilan akan gagal.
+ `--replicas-to-remove` – Opsional. Berisi daftar node yang IDs menentukan node replika untuk dihapus.
+ `--replica-configuration` – Opsional. Memungkinkan Anda menentukan jumlah replika dan Zona Ketersediaan untuk setiap grup simpul secara terpisah. Gunakan parameter ini untuk grup Valkey atau Redis OSS (mode cluster enabled) di mana Anda ingin mengkonfigurasi setiap grup node secara independen.
`--replica-configuration` memiliki tiga anggota opsional:
+ `NodeGroupId` – ID empat digit untuk grup simpul yang sedang dikonfigurasi. Untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), ID pecahan selalu ada. `0001` Untuk menemukan ID grup node (shard) Valkey atau Redis OSS (mode cluster enabled), lihat. [Menemukan ID serpihan](Shards.md#shard-find-id)
+ `NewReplicaCount` – Parameter opsional yang menentukan jumlah simpul replika yang Anda inginkan. Nilai dari `NewReplicaCount` harus nilai yang valid dan kurang dari jumlah replika saat ini dalam grup simpul. Untuk nilai minimum yang diizinkan, lihat [Mengurangi jumlah replika dalam serpihan](#decrease-replica-count). Jika nilai `NewReplicaCount` tidak memenuhi persyaratan ini, panggilan akan gagal.
+ `PreferredAvailabilityZones` – Daftar string `PreferredAvailabilityZone` yang menentukan Zona Ketersediaan tempat simpul grup replikasi berada. Jumlah nilai `PreferredAvailabilityZone` harus sama dengan nilai `NewReplicaCount` ditambah 1 untuk memperhitungkan simpul primer. Jika anggota `--replica-configuration` ini dihilangkan, ElastiCache untuk Redis OSS memilih Availability Zone untuk masing-masing replika baru.
**penting**
Anda harus menyertakan satu dan hanya satu parameter `--new-replica-count`, `--replicas-to-remove`, atau `--replica-configuration`.
**Example**
Contoh berikut menggunakan `--new-replica-count` untuk mengurangi jumlah replika dalam grup replikasi `sample-repl-group` menjadi satu. Saat contoh ini selesai, terdapat satu replika di setiap grup simpul. Nomor ini berlaku apakah ini adalah grup Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan grup node tunggal atau grup Valkey atau Redis OSS (mode cluster diaktifkan) dengan beberapa grup node.
Untuk Linux, macOS, atau Unix:
```
aws elasticache decrease-replica-count
--replication-group-id sample-repl-group \
--new-replica-count 1 \
--apply-immediately
```
Untuk Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id sample-repl-group ^
--new-replica-count 1 ^
--apply-immediately
```
Contoh berikut mengurangi jumlah replika dalam grup replikasi `sample-repl-group` dengan menghapus dua replika yang ditentukan (`0001` dan `0003`) dari grup simpul.
Untuk Linux, macOS, atau Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id sample-repl-group \
--replicas-to-remove 0001,0003 \
--apply-immediately
```
Untuk Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id sample-repl-group ^
--replicas-to-remove 0001,0003 \
--apply-immediately
```
Contoh berikut menggunakan `--replica-configuration` untuk mengurangi jumlah replika dalam grup replikasi `sample-repl-group` dengan nilai yang ditentukan untuk dua grup simpul yang ditentukan. Mengingat bahwa ada beberapa grup node, ini adalah grup replikasi Valkey atau Redis OSS (mode cluster enabled). Saat menentukan `PreferredAvailabilityZones` opsional, jumlah Zona Ketersediaan yang tercantum harus sama dengan nilai dari `NewReplicaCount` ditambah 1. Pendekatan ini memperhitungkan simpul primer untuk grup yang diidentifikasi berdasarkan `NodeGroupId`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id sample-repl-group \
--replica-configuration \
NodeGroupId=0001,NewReplicaCount=1,PreferredAvailabilityZones=us-east-1a,us-east-1c \
NodeGroupId=0003,NewReplicaCount=2,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c \
--apply-immediately
```
Untuk Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id sample-repl-group ^
--replica-configuration ^
NodeGroupId=0001,NewReplicaCount=2,PreferredAvailabilityZones=us-east-1a,us-east-1c ^
NodeGroupId=0003,NewReplicaCount=3,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c \
--apply-immediately
```
*Untuk informasi selengkapnya tentang mengurangi jumlah replika menggunakan CLI, lihat di Referensi Baris [decrease-replica-count](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html)Perintah Amazon. ElastiCache *
## Menggunakan ElastiCache API
Untuk mengurangi jumlah replika dalam pecahan Valkey atau Redis OSS, gunakan `DecreaseReplicaCount` tindakan dengan parameter berikut:
+ `ReplicationGroupId` – Wajib. Identifikasi grup replikasi yang ingin dikurangi jumlah replikanya.
+ `ApplyImmediately` – Wajib. Menentukan apakah akan mengurangi jumlah replika dengan segera (`ApplyImmediately=True`) atau pada periode pemeliharaan berikutnya (`ApplyImmediately=False`). Saat ini, `ApplyImmediately=False` belum didukung.
+ `NewReplicaCount` – Opsional. Menentukan jumlah simpul replika yang Anda inginkan. Nilai dari `NewReplicaCount` harus nilai yang valid dan kurang dari jumlah replika saat ini dalam grup simpul. Untuk nilai minimum yang diizinkan, lihat [Mengurangi jumlah replika dalam serpihan](#decrease-replica-count). Jika nilai `--new-replica-count` tidak memenuhi persyaratan ini, panggilan akan gagal.
+ `ReplicasToRemove` – Opsional. Berisi daftar node yang IDs menentukan node replika untuk dihapus.
+ `ReplicaConfiguration` – Opsional. Berisi daftar grup simpul yang memungkinkan Anda menentukan jumlah replika dan Zona Ketersediaan untuk setiap grup simpul secara terpisah. Gunakan parameter ini untuk grup Valkey atau Redis OSS (mode cluster enabled) di mana Anda ingin mengkonfigurasi setiap grup node secara independen.
`ReplicaConfiguraion` memiliki tiga anggota opsional:
+ `NodeGroupId` – ID empat digit untuk grup simpul yang sedang dikonfigurasi. Untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), ID grup node selalu. `0001` Untuk menemukan ID grup node (shard) Valkey atau Redis OSS (mode cluster enabled), lihat. [Menemukan ID serpihan](Shards.md#shard-find-id)
+ `NewReplicaCount` – Jumlah replika yang Anda inginkan dalam grup simpul ini pada akhir operasi ini. Nilai ini harus kurang dari jumlah replika saat ini hingga minimum 1 jika Multi-AZ diaktifkan atau hingga 0 jika Multi-AZ dengan Failover Otomatis tidak diaktifkan. Jika nilai ini tidak lebih kecil dari jumlah replika saat ini dalam grup simpul, maka panggilan akan gagal dengan pengecualian.
+ `PreferredAvailabilityZones` – Daftar string `PreferredAvailabilityZone` yang menentukan Zona Ketersediaan tempat simpul grup replikasi berada. Jumlah nilai `PreferredAvailabilityZone` harus sama dengan nilai `NewReplicaCount` ditambah 1 untuk memperhitungkan simpul primer. Jika anggota `ReplicaConfiguration` ini dihilangkan, ElastiCache untuk Redis OSS memilih Availability Zone untuk masing-masing replika baru.
**penting**
Anda harus menyertakan satu dan hanya satu parameter `NewReplicaCount`, `ReplicasToRemove`, atau `ReplicaConfiguration`.
**Example**
Contoh berikut menggunakan `NewReplicaCount` untuk mengurangi jumlah replika dalam grup replikasi `sample-repl-group` menjadi satu. Saat contoh ini selesai, terdapat satu replika di setiap grup simpul. Nomor ini berlaku apakah ini adalah grup Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan grup node tunggal atau grup Valkey atau Redis OSS (mode cluster diaktifkan) dengan beberapa grup node.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ApplyImmediately=True
&NewReplicaCount=1
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Contoh berikut mengurangi jumlah replika dalam grup replikasi `sample-repl-group` dengan menghapus dua replika yang ditentukan (`0001` dan `0003`) dari grup simpul.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ApplyImmediately=True
&ReplicasToRemove.ReplicaToRemove.1=0001
&ReplicasToRemove.ReplicaToRemove.2=0003
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Contoh berikut menggunakan `ReplicaConfiguration` untuk mengurangi jumlah replika dalam grup replikasi `sample-repl-group` dengan nilai yang ditentukan untuk dua grup simpul yang ditentukan. Mengingat bahwa ada beberapa grup node, ini adalah grup replikasi Valkey atau Redis OSS (mode cluster enabled). Saat menentukan `PreferredAvailabilityZones` opsional, jumlah Zona Ketersediaan yang tercantum harus sama dengan nilai dari `NewReplicaCount` ditambah 1. Pendekatan ini memperhitungkan simpul primer untuk grup yang diidentifikasi berdasarkan `NodeGroupId`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ApplyImmediately=True
&ReplicaConfiguration.ConfigureShard.1.NodeGroupId=0001
&ReplicaConfiguration.ConfigureShard.1.NewReplicaCount=1
&ReplicaConfiguration.ConfigureShard.1.PreferredAvailabilityZones.PreferredAvailabilityZone.1=us-east-1a
&ReplicaConfiguration.ConfigureShard.1.PreferredAvailabilityZones.PreferredAvailabilityZone.2=us-east-1c
&ReplicaConfiguration.ConfigureShard.2.NodeGroupId=0003
&ReplicaConfiguration.ConfigureShard.2.NewReplicaCount=2
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.1=us-east-1a
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.2=us-east-1b
&ReplicaConfiguration.ConfigureShard.2.PreferredAvailabilityZones.PreferredAvailabilityZone.4=us-east-1c
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya tentang mengurangi jumlah replika yang menggunakan API, lihat [DecreaseReplicaCount](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html)di Referensi *Amazon ElastiCache * API.
# Menambahkan replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Informasi dalam topik berikut hanya berlaku untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan).
Saat lalu lintas baca Anda meningkat, sebaiknya sebarkan operasi baca tersebut ke lebih banyak simpul dan kurangi kepadatan operasi baca pada salah satu simpul. Dalam topik ini, Anda dapat menemukan cara menambahkan replika baca ke cluster Valkey atau Redis OSS (mode cluster dinonaktifkan).
Grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dapat memiliki maksimal lima replika baca. Jika Anda mencoba menambahkan replika baca ke grup replikasi yang sudah memiliki lima replika baca, maka operasi ini akan gagal.
Untuk informasi tentang menambahkan replika ke grup replikasi Valkey atau Redis OSS (mode cluster enabled), lihat berikut ini:
+ [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ [Menambah jumlah replika dalam serpihan](increase-replica-count.md)
Anda dapat menambahkan replika baca ke cluster Valkey atau Redis OSS (mode cluster disabled) menggunakan ElastiCache Console, the AWS CLI, atau API. ElastiCache
**Topik terkait**
+ [Menambahkan node ke ElastiCache cluster](Clusters.AddNode.md)
+ [Menambahkan replika baca ke grup replikasi (AWS CLI)](#Replication.AddReadReplica.CLI)
+ [Menambahkan replika baca ke grup replikasi menggunakan API](#Replication.AddReadReplica.API)
## Menambahkan replika baca ke grup replikasi (AWS CLI)
Untuk menambahkan replika baca ke grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), gunakan AWS CLI `create-cache-cluster` perintah, dengan parameter `--replication-group-id` untuk menentukan grup replikasi mana yang akan ditambahkan cluster (node).
Contoh berikut membuat klaster `my-read replica` dan menambahkannya ke grup replikasi `my-replication-group`. Jenis simpul, grup parameter, grup keamanan, periode pemeliharaan, dan pengaturan lain untuk replika baca sama seperti yang digunakan untuk simpul lain, `my-replication-group`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-read-replica \
--replication-group-id my-replication-group
```
Untuk Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-read-replica ^
--replication-group-id my-replication-group
```
Untuk informasi selengkapnya tentang menambahkan replika baca menggunakan CLI, [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html) lihat di Referensi Baris *Perintah ElastiCache Amazon*.
## Menambahkan replika baca ke grup replikasi menggunakan API
Untuk menambahkan replika baca ke grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan), gunakan ElastiCache `CreateCacheCluster` operasi, dengan parameter `ReplicationGroupId` untuk menentukan grup replikasi mana yang akan ditambahkan cluster (node).
Contoh berikut membuat klaster `myReadReplica` dan menambahkannya ke grup replikasi `myReplicationGroup`. Jenis simpul, grup parameter, grup keamanan, periode pemeliharaan, dan pengaturan lain untuk replika baca sama seperti yang digunakan untuk simpul lain, `myReplicationGroup`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=myReadReplica
&ReplicationGroupId=myReplicationGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya tentang menambahkan replika baca menggunakan API, lihat [CreateCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheCluster.html) di *Referensi Amazon ElastiCache API*.
# Menghapus replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Informasi dalam topik berikut hanya berlaku untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan).
Saat lalu lintas baca di grup replikasi Valkey atau Redis OSS Anda berubah, Anda mungkin ingin menambah atau menghapus replika baca. Menghapus simpul dari grup replikasi adalah sama seperti menghapus klaster saja, meskipun terdapat pembatasan:
+ Anda tidak dapat menghapus primer dari grup replikasi. Jika Anda ingin menghapus replika primer, lakukan hal berikut:
1. Promosikan replika baca menjadi primer. Untuk informasi tentang mempromosikan replika baca menjadi primer, lihat [Mempromosikan replika baca ke primer, untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan)](Replication.PromoteReplica.md).
1. Hapus replika primer lama. Untuk batasan dari metode ini, lihat poin berikutnya.
+ Jika Multi-AZ diaktifkan pada grup replikasi, Anda tidak dapat menghapus replika baca terakhir dari grup replikasi tersebut. Dalam kasus ini, lakukan hal berikut:
1. Ubah grup replikasi dengan menonaktifkan Multi-AZ. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
1. Hapus replika baca.
Anda dapat menghapus replika baca dari grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) menggunakan ElastiCache konsol, AWS CLI for ElastiCache, atau API. ElastiCache
Untuk petunjuk cara menghapus cluster dari grup replikasi Valkey atau Redis OSS, lihat berikut ini:
+ [Menggunakan Konsol Manajemen AWS](Clusters.Delete.md#Clusters.Delete.CON)
+ [Menggunakan AWS CLI untuk menghapus ElastiCache cluster](Clusters.Delete.md#Clusters.Delete.CLI)
+ [Menggunakan ElastiCache API](Clusters.Delete.md#Clusters.Delete.API)
+ [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ [Mengurangi jumlah replika dalam serpihan](decrease-replica-count.md)
# Mempromosikan replika baca ke primer, untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan)
Informasi dalam topik berikut hanya berlaku untuk grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan).
Anda dapat mempromosikan replika baca Valkey atau Redis OSS (mode cluster dinonaktifkan) ke primer menggunakan Konsol Manajemen AWS, the AWS CLI, atau API. ElastiCache Anda tidak dapat menaikkan replika baca ke primer jika Multi-AZ dengan Failover Otomatis diaktifkan pada grup replikasi . Untuk mempromosikan replika Valkey atau Redis OSS (mode cluster dinonaktifkan) ke primer pada grup replikasi berkemampuan multi-AZ, lakukan hal berikut:
1. Ubah grup replikasi untuk menonaktifkan Multi-AZ (melakukan hal ini tidak mensyaratkan semua klaster Anda berada dalam Zona Ketersediaan yang sama). Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
1. Promosikan replika baca menjadi primer.
1. Ubah grup replikasi untuk mengaktifkan kembali Multi-AZ.
Multi-AZ tidak tersedia pada grup replikasi yang menjalankan Redis OSS 2.6.13 atau yang lebih lama.
## Menggunakan Konsol Manajemen AWS
Prosedur berikut menggunakan konsol untuk mempromosikan simpul replika menjadi primer.
**Untuk mempromosikan replika baca menjadi primer (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Jika replika yang ingin Anda promosikan adalah anggota grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) tempat multi-AZ diaktifkan, modifikasi grup replikasi untuk menonaktifkan Multi-AZ sebelum Anda melanjutkan. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
1. Pilih **Valkey** atau **Redis OSS**, lalu dari daftar cluster, pilih grup replikasi yang ingin Anda modifikasi. Grup replikasi ini harus menjalankan mesin "Redis", bukan mesin "Redis Berklaster", dan harus memiliki dua atau lebih simpul.
1. Dari daftar simpul, pilih simpul replika yang ingin dipromosikan menjadi primer, kemudian untuk **Tindakan**, pilih **Promosikan**.
1. Pada kotak dialog **Mempromosikan Replika Baca**, lakukan hal berikut:
1. Untuk **Terapkan Segera**, pilih **Ya** untuk mempromosikan replika baca segera, atau **Tidak** untuk mempromosikannya pada periode pemeliharaan berikutnya untuk klaster.
1. Pilih **Promosikan** untuk mempromosikan replika baca atau **Batalkan** untuk membatalkan operasi.
1. Jika klaster Multi-AZ diaktifkan sebelum Anda memulai proses promosi, tunggu hingga status grup replikasi menjadi **tersedia**, lalu ubah klaster untuk mengaktifkan kembali Multi-AZ. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
## Menggunakan AWS CLI
Anda tidak dapat mempromosikan replika baca menjadi primer jika grup replikasi mengaktifkan Multi-AZ. Dalam beberapa kasus, replika yang ingin dipromosikan mungkin adalah anggota grup replikasi yang mengaktifkan Multi-AZ. Dalam kasus ini, Anda harus mengubah grup replikasi untuk menonaktifkan Multi-AZ sebelum Anda melanjutkan. Untuk melakukan tindakan ini, semua klaster tidak harus berada dalam Zona Ketersediaan yang sama. Untuk informasi selengkapnya tentang mengubah grup replikasi, lihat [Mengubah grup replikasi](Replication.Modify.md).
AWS CLI Perintah berikut memodifikasi grup replikasi`sample-repl-group`, membuat replika `my-replica-1` baca utama dalam grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id sample-repl-group \
--primary-cluster-id my-replica-1
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id sample-repl-group ^
--primary-cluster-id my-replica-1
```
Untuk informasi selengkapnya tentang memodifikasi grup replikasi, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) di Referensi *Baris ElastiCache Perintah Amazon*.
## Menggunakan ElastiCache API
Anda tidak dapat mempromosikan replika baca menjadi primer jika grup replikasi mengaktifkan Multi-AZ. Dalam beberapa kasus, replika yang ingin dipromosikan mungkin adalah anggota grup replikasi yang mengaktifkan Multi-AZ. Dalam kasus ini, Anda harus mengubah grup replikasi untuk menonaktifkan Multi-AZ sebelum Anda melanjutkan. Untuk melakukan tindakan ini, semua klaster tidak harus berada dalam Zona Ketersediaan yang sama. Untuk informasi selengkapnya tentang mengubah grup replikasi, lihat [Mengubah grup replikasi](Replication.Modify.md).
Tindakan ElastiCache API berikut memodifikasi grup replikasi`myReplGroup`, menjadikan replika baca sebagai yang `myReplica-1` utama dalam grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ReplicationGroupId=myReplGroup
&PrimaryClusterId=myReplica-1
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya tentang memodifikasi grup replikasi, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) di Referensi *Amazon ElastiCache API*.
# Mengelola pemeliharaan ElastiCache cluster
Setiap klaster memiliki periode pemeliharaan mingguan saat perubahan sistem akan diterapkan. Dengan Valkey dan Redis OSS, grup replikasi memiliki jendela pemeliharaan mingguan yang sama. Jika Anda tidak menentukan jendela pemeliharaan yang disukai saat membuat atau memodifikasi klaster atau grup replikasi, tetapkan ElastiCache jendela pemeliharaan 60 menit dalam jendela pemeliharaan wilayah Anda pada hari yang dipilih secara acak dalam seminggu.
Periode pemeliharaan 60 menit dipilih secara acak dari blok waktu 8 jam per wilayah. Tabel berikut menampilkan daftar blok waktu untuk setiap wilayah yang akan digunakan untuk menetapkan periode pemeliharaan default. Anda dapat memilih periode pemeliharaan yang diinginkan di luar blok periode pemeliharaan wilayah.
| Kode Wilayah | Nama wilayah | Periode Pemeliharaan Wilayah |
| --- | --- | --- |
| ap-northeast-1 | Wilayah Asia Pasifik (Tokyo) | 13.00–21.00 UTC |
| ap-northeast-2 | Wilayah Asia Pasifik (Seoul) | 12.00–20.00 UTC |
| ap-northeast-3 | Wilayah Asia Pasifik (Osaka) | 12.00–20.00 UTC |
| ap-southeast-3 | Wilayah Asia Pasifik (Jakarta) | 14.00–22.00 UTC |
| ap-south-1 | Wilayah Asia Pasifik (Mumbai) | 17.30–01.30 UTC |
| ap-southeast-1 | Wilayah Asia Pasifik (Singapura) | 14.00–22.00 UTC |
| cn-north-1 | Wilayah Tiongkok (Beijing) | 14.00–22.00 UTC |
| cn-northwest-1 | Wilayah Tiongkok (Ningxia) | 14.00–22.00 UTC |
| ap-east-1 | Wilayah Asia Pasifik (Hong Kong) | 13.00–21.00 UTC |
| ap-southeast-2 | Wilayah Asia Pasifik (Sydney) | 12.00–20.00 UTC |
| eu-west-3 | Wilayah Eropa (Paris) | 23.59–07.29 UTC |
| af-south-1 | Wilayah Afrika (Cape Town) | 13.00–21.00 UTC |
| eu-central-1 | Wilayah Eropa (Frankfurt) | 23.00–07.00 UTC |
| eu-west-1 | Wilayah Eropa (Irlandia) | 22.00–06.00 UTC |
| eu-west-2 | Wilayah Eropa (London) | 23.00–07.00 UTC |
| me-south-1 | Wilayah Timur Tengah (Bahrain) | 13.00–21.00 UTC |
| me-central-1 | Wilayah Timur Tengah (UEA) | 13.00–21.00 UTC |
| eu-south-1 | Wilayah Eropa (Milan) | 21.00–05.00 UTC |
| sa-east-1 | Wilayah South America (São Paulo) | 01.00–09.00 UTC |
| us-east-1 | Wilayah AS Timur (Virginia Utara) | 03.00–11.00 UTC |
| us-east-2 | Wilayah AS Timur (Ohio) | 04.00–12.00 UTC |
| us-gov-west-1 | AWS GovCloud (US) wilayah | 06.00–14.00 UTC |
| us-west-1 | Wilayah US West (N. California) | 06.00–14.00 UTC |
| us-west-2 | Wilayah US West (Oregon) | 06.00–14.00 UTC |
**Mengubah jendela pemeliharaan klaster atau grup replikasi**
Periode pemeliharaan harus berada dalam waktu penggunaan terendah, sehingga kemungkinan memerlukan perubahan dari waktu ke waktu. Anda dapat mengubah klaster atau grup replikasi Anda untuk menentukan rentang waktu hingga durasi 24 jam saat aktivitas pemeliharaan yang Anda minta akan dilakukan. Setiap perubahan klaster yang Anda minta yang ditangguhkan atau tertunda akan terjadi dalam kurun waktu ini.
**catatan**
Jika Anda ingin menerapkan modifikasi tipe node upgrade and/or mesin segera menggunakan Konsol Manajemen AWS pilih kotak **Terapkan sekarang**. Jika tidak, perubahan ini akan diterapkan selama periode pemeliharaan terjadwal berikutnya. Untuk menggunakan API, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html)atau [modify-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
**Informasi selengkapnya**
Untuk informasi tentang periode pemeliharaan dan penggantian simpul, lihat yang berikut ini:
+ [ElastiCache Pemeliharaan](https://aws.amazon.com/elasticache/elasticache-maintenance/) —FAQ tentang pemeliharaan dan penggantian simpul
+ [Mengganti node (Memcached)](CacheNodes.NodeReplacement-mc.md)—Mengelola penggantian node untuk Memcached
+ [Memodifikasi cluster ElastiCache](Clusters.Modify.md)—Mengubah periode pemeliharaan klaster
+ [Mengganti node (Valkey dan Redis OSS)](CacheNodes.NodeReplacement.md)—Mengelola penggantian simpul
+ [Mengubah grup replikasi](Replication.Modify.md)—Mengubah periode pemeliharaan grup replikasi
# Mengkonfigurasi parameter mesin menggunakan grup ElastiCache parameter
Amazon ElastiCache menggunakan parameter untuk mengontrol properti runtime node dan cluster Anda. Secara umum, versi mesin yang lebih baru mencakup parameter tambahan untuk mendukung fungsionalitas yang lebih baru. Untuk tabel parameter Memcached, lihat. [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached) Untuk tabel parameter Valkey dan Redis OSS, lihat. [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
Seperti yang Anda harapkan, beberapa nilai parameter, seperti `maxmemory`, ditentukan oleh mesin dan jenis simpul. Untuk tabel nilai parameter Memcached ini menurut jenis node, lihat. [Parameter khusus jenis simpul Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.NodeSpecific) Untuk tabel nilai parameter Valkey dan Redis OSS ini berdasarkan tipe node, lihat. [Parameter spesifik tipe node Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific)
**catatan**
Untuk daftar parameter kustom Memcached, lihat [Parameter Khusus Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached).
**Topics**
+ [Manajemen parameter di ElastiCache](ParameterGroups.Management.md)
+ [Tingkatan grup parameter cache di ElastiCache](ParameterGroups.Tiers.md)
+ [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md)
+ [Daftar grup ElastiCache parameter berdasarkan nama](ParameterGroups.ListingGroups.md)
+ [Daftar nilai kelompok ElastiCache parameter](ParameterGroups.ListingValues.md)
+ [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md)
+ [Menghapus grup ElastiCache parameter](ParameterGroups.Deleting.md)
+ [Parameter spesifik mesin](ParameterGroups.Engine.md)
# Manajemen parameter di ElastiCache
ElastiCache parameter dikelompokkan bersama ke dalam kelompok parameter bernama untuk manajemen parameter yang lebih mudah. Grup parameter merepresentasikan kombinasi nilai tertentu untuk parameter yang diteruskan ke perangkat lunak mesin selama pengaktifan. Nilai ini menentukan perilaku berbagai proses mesin di setiap simpul pada saat runtime. Nilai parameter pada grup parameter tertentu berlaku untuk semua simpul yang terkait dengan grup ini, terlepas dari klaster yang memiliki simpul tersebut.
Untuk menyesuaikan performa klaster, Anda dapat mengubah beberapa nilai parameter atau mengubah grup parameter klaster.
+ Anda tidak dapat mengubah atau menghapus grup parameter default. Jika membutuhkan nilai parameter kustom, Anda harus membuat grup parameter kustom.
+ Untuk Memcached, keluarga grup parameter dan cluster yang Anda tetapkan harus kompatibel. Misalnya, jika klaster menjalankan Memcached versi 1.4.8, Anda hanya dapat menggunakan grup parameter, default atau kustom, dari keluarga Memcached 1.4.
Untuk Redis OSS, keluarga grup parameter dan cluster yang Anda tetapkan harus kompatibel. Misalnya, jika cluster Anda menjalankan Redis OSS versi 3.2.10, Anda hanya dapat menggunakan grup parameter, default atau kustom, dari keluarga Redis OSS 3.2.
+ Jika Anda mengubah grup parameter klaster, nilai untuk setiap parameter yang dapat diubah secara bersyarat harus sama di kedua grup parameter baru dan saat ini.
+ Untuk Memcached, saat Anda mengubah parameter cluster, perubahan diterapkan ke cluster segera. Hal ini berlaku terlepas dari apakah Anda mengubah grup parameter klaster itu sendiri atau nilai parameter dalam grup parameter klaster. Untuk menentukan waktu penerapan perubahan parameter tertentu, lihat kolom **Perubahan Berlaku** dalam tabel untuk [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached). Untuk informasi tentang mem-boot ulang simpul klaster, lihat [Mem-boot ulang klaster](Clusters.html#Rebooting).
+ Untuk Redis OSS, ketika Anda mengubah parameter cluster, perubahan diterapkan ke cluster baik segera atau, dengan pengecualian dicatat berikut, setelah node cluster di-boot ulang. Hal ini berlaku terlepas dari apakah Anda mengubah grup parameter klaster itu sendiri atau nilai parameter dalam grup parameter klaster. Untuk menentukan waktu penerapan perubahan parameter tertentu, lihat kolom **Perubahan Berlaku** dalam tabel untuk [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis).
Untuk informasi lebih lanjut tentang me-reboot node Valkey atau Redis OSS, lihat. [Mem-boot ulang node](nodes.rebooting.md)
**Perubahan parameter Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Jika Anda membuat perubahan pada parameter berikut pada cluster Valkey atau Redis OSS (mode cluster enabled), ikuti langkah-langkah berikutnya.
activerehashing
databases
Buat cadangan manual klaster Anda. Lihat [Membuat cadangan manual](backups-manual.md).
Hapus klaster . Lihat [Menghapus klaster](Clusters.html#Delete).
Pulihkan klaster menggunakan grup parameter dan cadangan yang sudah diubah untuk melakukan seeding klaster baru. Lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Perubahan pada parameter lain tidak memerlukan tindakan ini.
+ Anda dapat mengaitkan grup parameter dengan datastores global Valkey dan Redis OSS. *Datastores global* adalah kumpulan dari satu atau lebih cluster yang menjangkau Wilayah. AWS Dalam hal ini, grup parameter digunakan bersama-sama oleh semua klaster yang membentuk penyimpanan data global. Perubahan apa pun ke grup parameter klaster primer akan direplikasi ke semua klaster lain di penyimpanan data global. Untuk informasi selengkapnya, lihat [Replikasi lintas AWS Wilayah menggunakan datastores global](Redis-Global-Datastore.md).
Anda dapat memeriksa apakah grup parameter merupakan bagian dari penyimpanan data global dengan melihatnya di lokasi berikut:
+ Pada ElastiCache konsol pada halaman **Parameter Groups**, atribut yes/no **Global**
+ yes/no `IsGlobal`Properti operasi [CacheParameterGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CacheParameterGroup.html)API
# Tingkatan grup parameter cache di ElastiCache
Amazon ElastiCache memiliki tiga tingkatan grup parameter cache seperti yang ditunjukkan berikut.
![\[Gambar: Tingkatan grup ElastiCache parameter Amazon\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-ParameterGroups-Tiers.png)
*Tingkatan grup ElastiCache parameter Amazon*
**Default Global**
Grup parameter root tingkat atas untuk semua ElastiCache pelanggan Amazon di wilayah tersebut.
Grup parameter cache default global:
+ Dicadangkan untuk ElastiCache dan tidak tersedia untuk pelanggan.
**Default Pelanggan**
Salinan grup parameter cache Default Global yang dibuat untuk penggunaan pelanggan.
Grup parameter cache Default Pelanggan:
+ Dibuat dan dimiliki oleh ElastiCache.
+ Tersedia bagi pelanggan untuk digunakan sebagai grup parameter cache untuk setiap klaster yang menjalankan versi mesin yang didukung oleh grup parameter cache ini.
+ Tidak dapat diedit oleh pelanggan.
**Milik Pelanggan**
Salinan grup parameter cache Default Pelanggan. Grup parameter cache Milik Pelanggan dibuat setiap kali pelanggan membuat grup parameter cache.
Grup parameter cache Milik Pelanggan:
+ Dibuat dan dimiliki oleh pelanggan.
+ Dapat ditetapkan untuk salah satu klaster pelanggan yang kompatibel.
+ Dapat diubah oleh pelanggan untuk membuat grup parameter cache kustom.
Tidak semua nilai parameter dapat diubah. Untuk informasi selengkapnya tentang nilai Memcached, lihat. [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached) Untuk informasi lebih lanjut tentang nilai Valkey dan Redis OSS, lihat. [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
# Membuat grup ElastiCache parameter
Anda perlu membuat grup parameter baru jika ada satu atau beberapa nilai parameter yang ingin Anda ubah dari nilai default. Anda dapat membuat grup parameter menggunakan ElastiCache konsol, the AWS CLI, atau ElastiCache API.
## Membuat grup ElastiCache parameter (Konsol)
Prosedur berikut menunjukkan cara membuat grup parameter menggunakan konsol ElastiCache.
**Untuk membuat grup parameter menggunakan ElastiCache konsol**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar semua grup parameter yang tersedia, di panel navigasi sebelah kiri pilih **Grup Parameter**.
1. Untuk membuat grup parameter, pilih **Buat Grup Parameter**.
Layar **Buat Grup Parameter** akan muncul.
1. Dari daftar **Keluarga**, pilih grup parameter yang akan menjadi templat untuk grup parameter Anda.
Keluarga grup parameter, seperti *memcached1.4* atau *redis3.2* mendefinisikan parameter aktual dalam grup parameter Anda dan nilai awalnya. Keluarga grup parameter harus sesuai dengan mesin dan versi klaster.
1. Di kotak **Nama**, ketik nama unik untuk grup parameter ini.
Saat membuat klaster atau mengubah grup parameter klaster, Anda akan memilih grup parameter berdasarkan namanya. Oleh karena itu, kami merekomendasikan agar namanya informatif dan dapat mengidentifikasi keluarga grup parameter.
Batasan penamaan grup parameter adalah sebagai berikut:
+ Harus diawali dengan huruf ASCII.
+ Hanya dapat berisi huruf ASCII, angka, dan tanda hubung.
+ Harus memiliki panjang 1-255 karakter.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan sebuah tanda hubung.
1. Di kotak **Deskripsi**, ketik deskripsi untuk grup parameter.
1. Untuk membuat grup parameter, pilih **Buat**.
Untuk mengakhiri proses tanpa membuat grup parameter, pilih **Batalkan**.
1. Ketika grup parameter dibuat, grup parameter ini akan memiliki nilai default keluarga. Untuk mengubah nilai default, Anda harus mengubah grup parameter. Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
## Membuat grup ElastiCache parameter (AWS CLI)
Untuk membuat grup parameter menggunakan AWS CLI, gunakan perintah `create-cache-parameter-group` dengan parameter ini.
+ `--cache-parameter-group-name` – Nama grup parameter.
Batasan penamaan grup parameter adalah sebagai berikut:
+ Harus diawali dengan huruf ASCII.
+ Hanya dapat berisi huruf ASCII, angka, dan tanda hubung.
+ Harus memiliki panjang 1-255 karakter.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
+ `--cache-parameter-group-family` – Keluarga mesin dan versi untuk grup parameter.
+ `--description` – Deskripsi yang diberikan pengguna untuk grup parameter.
**Example**
Contoh berikut membuat grup parameter bernama *myMem14* menggunakan keluarga memcached1.4 sebagai templat.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-cache-parameter-group \
--cache-parameter-group-name myMem14 \
--cache-parameter-group-family memcached1.4 \
--description "My first parameter group"
```
Untuk Windows:
```
aws elasticache create-cache-parameter-group ^
--cache-parameter-group-name myMem14 ^
--cache-parameter-group-family memcached1.4 ^
--description "My first parameter group"
```
Output dari perintah ini akan terlihat seperti ini.
```
{
"CacheParameterGroup": {
"CacheParameterGroupName": "myMem14",
"CacheParameterGroupFamily": "memcached1.4",
"Description": "My first parameter group"
}
}
```
**Example**
Contoh berikut membuat grup parameter bernama *myRed28* menggunakan keluarga redis2.8 sebagai templat.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-cache-parameter-group \
--cache-parameter-group-name myRed28 \
--cache-parameter-group-family redis2.8 \
--description "My first parameter group"
```
Untuk Windows:
```
aws elasticache create-cache-parameter-group ^
--cache-parameter-group-name myRed28 ^
--cache-parameter-group-family redis2.8 ^
--description "My first parameter group"
```
Output dari perintah ini akan terlihat seperti ini.
```
{
"CacheParameterGroup": {
"CacheParameterGroupName": "myRed28",
"CacheParameterGroupFamily": "redis2.8",
"Description": "My first parameter group"
}
}
```
Ketika grup parameter dibuat, grup parameter ini akan memiliki nilai default keluarga. Untuk mengubah nilai default, Anda harus mengubah grup parameter. Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-parameter-group.html).
## Membuat grup ElastiCache parameter (ElastiCache API)
Untuk membuat grup parameter menggunakan ElastiCache API, gunakan `CreateCacheParameterGroup` tindakan dengan parameter ini.
+ `ParameterGroupName` – Nama grup parameter.
Batasan penamaan grup parameter adalah sebagai berikut:
+ Harus diawali dengan huruf ASCII.
+ Hanya dapat berisi huruf ASCII, angka, dan tanda hubung.
+ Harus memiliki panjang 1-255 karakter.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
+ `CacheParameterGroupFamily` – Keluarga mesin dan versi untuk grup parameter. Misalnya, `memcached1.4`.
+ `CacheParameterGroupFamily` – Keluarga mesin dan versi untuk grup parameter. Misalnya, `redis2.8`.
+ `Description` – Deskripsi yang diberikan pengguna untuk grup parameter.
**Example**
Contoh berikut membuat grup parameter bernama *myMem14* menggunakan keluarga memcached1.4 sebagai templat.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheParameterGroup
&CacheParameterGroupFamily=memcached1.4
&CacheParameterGroupName=myMem14
&Description=My%20first%20parameter%20group
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini.
```
myMem14memcached1.4My first parameter groupd8465952-af48-11e0-8d36-859edca6f4b8
```
**Example**
Contoh berikut membuat grup parameter bernama *myRed28* menggunakan keluarga redis2.8 sebagai templat.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheParameterGroup
&CacheParameterGroupFamily=redis2.8
&CacheParameterGroupName=myRed28
&Description=My%20first%20parameter%20group
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini.
```
myRed28redis2.8My first parameter groupd8465952-af48-11e0-8d36-859edca6f4b8
```
Ketika grup parameter dibuat, grup parameter ini akan memiliki nilai default keluarga. Untuk mengubah nilai default, Anda harus mengubah grup parameter. Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md).
Lihat informasi yang lebih lengkap di [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheParameterGroup.html).
# Daftar grup ElastiCache parameter berdasarkan nama
Anda dapat membuat daftar grup parameter menggunakan ElastiCache konsol, the AWS CLI, atau ElastiCache API.
## Menampilkan daftar grup parameter berdasarkan nama (Konsol)
Prosedur berikut menunjukkan cara melihat daftar grup parameter menggunakan konsol ElastiCache .
**Untuk membuat daftar grup parameter menggunakan ElastiCache konsol**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar semua grup parameter yang tersedia, pilih **Grup Parameter** di panel navigasi sebelah kiri.
## Daftar grup ElastiCache parameter berdasarkan nama (AWS CLI)
Untuk menghasilkan daftar kelompok parameter menggunakan AWS CLI, gunakan perintah`describe-cache-parameter-groups`. Jika Anda memberikan nama grup parameter, hanya grup parameter tersebut yang akan dicantumkan. Jika Anda memberikan nama grup parameter, hanya grup parameter hingga `--max-records` yang akan dicantumkan. Dalam kedua kasus, nama, keluarga, dan deskripsi grup parameter akan dicantumkan.
**Example**
Contoh kode berikut menampilkan daftar grup parameter *myMem14*.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-cache-parameter-groups \
--cache-parameter-group-name myMem14
```
Untuk Windows:
```
aws elasticache describe-cache-parameter-groups ^
--cache-parameter-group-name myMem14
```
Output dari perintah ini akan terlihat seperti ini, mencantumkan nama, keluarga, dan deskripsi untuk grup parameter.
```
{
"CacheParameterGroups": [
{
"CacheParameterGroupName": "myMem14",
"CacheParameterGroupFamily": "memcached1.4",
"Description": "My first parameter group"
}
]
}
```
**Example**
Contoh kode berikut menampilkan daftar grup parameter *myRed28*.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-cache-parameter-groups \
--cache-parameter-group-name myRed28
```
Untuk Windows:
```
aws elasticache describe-cache-parameter-groups ^
--cache-parameter-group-name myRed28
```
Output dari perintah ini akan terlihat seperti ini, mencantumkan nama, keluarga, dan deskripsi untuk grup parameter.
```
{
"CacheParameterGroups": [
{
"CacheParameterGroupName": "myRed28",
"CacheParameterGroupFamily": "redis2.8",
"Description": "My first parameter group"
}
]
}
```
**Example**
Kode contoh berikut mencantumkan grup parameter *MyRed56* untuk grup parameter yang berjalan pada mesin Redis OSS versi 5.0.6 dan seterusnya. Jika grup parameter adalah bagian dari [Replikasi lintas AWS Wilayah menggunakan datastores global](Redis-Global-Datastore.md), nilai properti `IsGlobal` yang dikembalikan dalam output akan berupa `Yes`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-cache-parameter-groups \
--cache-parameter-group-name myRed56
```
Untuk Windows:
```
aws elasticache describe-cache-parameter-groups ^
--cache-parameter-group-name myRed56
```
Output dari perintah ini akan terlihat seperti ini, dengan menampilkan daftar nama, keluarga, isGlobal, dan deskripsi untuk grup parameter.
```
{
"CacheParameterGroups": [
{
"CacheParameterGroupName": "myRed56",
"CacheParameterGroupFamily": "redis5.0",
"Description": "My first parameter group",
"IsGlobal": "yes"
}
]
}
```
**Example**
Contoh kode berikut menampilkan daftar hingga 10 grup parameter.
```
aws elasticache describe-cache-parameter-groups --max-records 10
```
Output JSON dari perintah ini akan terlihat seperti ini, mencantumkan nama, keluarga, deskripsi dan, pada redis5.6 menunjukkan apakah grup parameter bagian dari penyimpanan data global (isGlobal), untuk setiap grup parameter.
```
{
"CacheParameterGroups": [
{
"CacheParameterGroupName": "custom-redis32",
"CacheParameterGroupFamily": "redis3.2",
"Description": "custom parameter group with reserved-memory > 0"
},
{
"CacheParameterGroupName": "default.memcached1.4",
"CacheParameterGroupFamily": "memcached1.4",
"Description": "Default parameter group for memcached1.4"
},
{
"CacheParameterGroupName": "default.redis2.6",
"CacheParameterGroupFamily": "redis2.6",
"Description": "Default parameter group for redis2.6"
},
{
"CacheParameterGroupName": "default.redis2.8",
"CacheParameterGroupFamily": "redis2.8",
"Description": "Default parameter group for redis2.8"
},
{
"CacheParameterGroupName": "default.redis3.2",
"CacheParameterGroupFamily": "redis3.2",
"Description": "Default parameter group for redis3.2"
},
{
"CacheParameterGroupName": "default.redis3.2.cluster.on",
"CacheParameterGroupFamily": "redis3.2",
"Description": "Customized default parameter group for redis3.2 with cluster mode on"
},
{
"CacheParameterGroupName": "default.redis5.6.cluster.on",
"CacheParameterGroupFamily": "redis5.0",
"Description": "Customized default parameter group for redis5.6 with cluster mode on",
"isGlobal": "yes"
},
]
}
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameter-groups.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameter-groups.html).
## Daftar grup ElastiCache parameter berdasarkan nama (ElastiCache API)
Untuk membuat daftar grup parameter menggunakan ElastiCache API, gunakan `DescribeCacheParameterGroups` tindakan. Jika Anda memberikan nama grup parameter, hanya grup parameter tersebut yang akan dicantumkan. Jika Anda memberikan nama grup parameter, hanya grup parameter hingga `MaxRecords` yang akan dicantumkan. Dalam kedua kasus, nama, keluarga, dan deskripsi grup parameter akan dicantumkan.
**Example**
Contoh kode berikut menampilkan daftar grup parameter *myMem14*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameterGroups
&CacheParameterGroupName=myMem14
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini, menampilkan daftar nama, keluarga, dan deskripsi untuk setiap grup parameter.
```
myMem14memcached1.4My custom Memcached 1.4 parameter group3540cc3d-af48-11e0-97f9-279771c4477e
```
**Example**
Contoh kode berikut menampilkan daftar hingga 10 grup parameter.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameterGroups
&MaxRecords=10
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini, menampilkan daftar nama, keluarga, deskripsi dan, dalam kasus redis5.6 jika grup parameter milik penyimpanan data global (isGlobal), untuk setiap grup parameter.
```
myRedis28redis2.8My custom Redis 2.8 parameter groupmyMem14memcached1.4My custom Memcached 1.4 parameter groupmyRedis56redis5.0My custom redis 5.6 parameter groupyes3540cc3d-af48-11e0-97f9-279771c4477e
```
**Example**
Contoh kode berikut menampilkan daftar grup parameter *myRed28*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameterGroups
&CacheParameterGroupName=myRed28
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini, menampilkan daftar nama, keluarga, dan deskripsi.
```
myRed28redis2.8My custom Redis 2.8 parameter group3540cc3d-af48-11e0-97f9-279771c4477e
```
**Example**
Contoh kode berikut menampilkan daftar grup parameter *myRed56*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameterGroups
&CacheParameterGroupName=myRed56
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini, dengan menampilkan daftar nama, keluarga, deskripsi, dan apakah grup parameter adalah bagian dari penyimpanan data global (isGlobal).
```
myRed56redis5.0My custom Redis 5.6 parameter groupyes3540cc3d-af48-11e0-97f9-279771c4477e
```
Lihat informasi yang lebih lengkap di [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameterGroups.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameterGroups.html).
# Daftar nilai kelompok ElastiCache parameter
Anda dapat mencantumkan parameter dan nilainya untuk grup parameter menggunakan ElastiCache konsol, the AWS CLI, atau ElastiCache API.
## Daftar nilai grup ElastiCache parameter (Konsol)
Prosedur berikut menunjukkan cara membuat daftar parameter dan nilainya untuk grup parameter menggunakan ElastiCache konsol.
**Untuk membuat daftar parameter dan nilainya dari grup parameter menggunakan konsol ElastiCache**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar semua grup parameter yang tersedia, di panel navigasi sebelah kiri pilih **Grup Parameter**.
1. Pilih grup parameter yang ingin Anda tampilkan daftar parameter dan nilainya dengan memilih kotak di sebelah kiri nama grup parameter.
Parameter dan nilainya akan tercantum di bagian bawah layar. Karena jumlah parameter, Anda mungkin harus menggulir ke atas/bawah untuk menemukan parameter yang diinginkan.
## Menampilkan daftar nilai grup parameter (AWS CLI)
Untuk membuat daftar parameter grup parameter dan nilainya menggunakan AWS CLI, gunakan perintah`describe-cache-parameters`.
**Example**
*Kode contoh berikut mencantumkan semua parameter Memcached dan nilainya untuk grup parameter MyMEM14.*
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-cache-parameters \
--cache-parameter-group-name myMem14
```
Untuk Windows:
```
aws elasticache describe-cache-parameters ^
--cache-parameter-group-name myMem14
```
**Example**
Contoh kode berikut menampilkan daftar semua parameter dan nilainya untuk grup parameter *myRedis28*.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-cache-parameters \
--cache-parameter-group-name myRedis28
```
Untuk Windows:
```
aws elasticache describe-cache-parameters ^
--cache-parameter-group-name myRed28
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameters.html).
## Daftar nilai grup parameter (ElastiCache API)
Untuk membuat daftar parameter grup parameter dan nilainya menggunakan ElastiCache API, gunakan `DescribeCacheParameters` tindakan.
**Example**
*Kode contoh berikut mencantumkan semua parameter Memcached untuk grup parameter MyMEM14.*
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameters
&CacheParameterGroupName=myMem14
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini. Respons ini telah terpotong.
```
integersystemfalseThe maximum configurable amount of memory to use to store items, in megabytes.1000cache.c1.medium6000cache.c1.xlarge7100cache.m1.large1300cache.m1.small
...output omitted...
6d355589-af49-11e0-97f9-279771c4477e
```
**Example**
Contoh kode berikut menampilkan daftar semua parameter untuk grup parameter *myRed28*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheParameters
&CacheParameterGroupName=myRed28
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Respons dari tindakan ini akan terlihat seperti ini. Respons ini telah terpotong.
```
integersystemfalseThe maximum configurable amount of memory to use to store items, in megabytes.1000cache.c1.medium6000cache.c1.xlarge7100cache.m1.large1300cache.m1.small
...output omitted...
6d355589-af49-11e0-97f9-279771c4477e
```
Lihat informasi yang lebih lengkap di [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameters.html).
# Memodifikasi grup ElastiCache parameter
**penting**
Anda tidak dapat mengubah grup parameter default.
Anda dapat mengubah beberapa nilai parameter di grup parameter. Nilai parameter ini diterapkan ke klaster yang terkait dengan grup parameter. Untuk informasi selengkapnya tentang kapan perubahan nilai parameter diterapkan ke grup parameter, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) dan[Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached).
## Mengubah grup parameter (Konsol)
Prosedur berikut menunjukkan cara mengubah nilai `cluster-enabled` parameter menggunakan ElastiCache konsol. Anda akan menggunakan prosedur yang sama untuk mengubah nilai parameter apa pun.
**Untuk mengubah nilai parameter menggunakan ElastiCache konsol**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar semua grup parameter yang tersedia, pilih **Grup Parameter** di panel navigasi sebelah kiri.
1. Pilih grup parameter yang ingin Anda ubah dengan memilih kotak di sebelah kiri nama grup parameter.
Parameter dari grup parameter akan tercantum di bagian bawah layar. Anda mungkin perlu menelusuri daftar untuk melihat semua parameter.
1. Untuk mengubah satu atau beberapa parameter, pilih **Edit Parameter**.
1. Di layar **Edit Grup Parameter:**, gulir menggunakan panah kiri dan kanan sampai Anda menemukan parameter `binding_protocol`, lalu ketik `ascii` di kolom **Nilai**.
1. Pilih **Simpan Perubahan**.
1. Untuk Memcached, untuk menemukan nama parameter yang Anda ubah, lihat. [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached) Jika perubahan parameter diterapkan *Setelah pengaktifan ulang*, boot ulang setiap klaster yang menggunakan grup parameter ini. Untuk informasi selengkapnya, lihat [Mem-boot ulang klaster](Clusters.html#Rebooting).
1. Dengan Valkey dan Redis OSS, untuk menemukan nama parameter yang Anda ubah, lihat. [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) Jika Anda memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan membuat perubahan pada parameter berikut, Anda harus me-reboot node di cluster:
+ activerehashing
+ databases
Untuk informasi selengkapnya, lihat [Mem-boot ulang simpul](nodes.rebooting.md).
**Perubahan parameter Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Jika Anda membuat perubahan pada parameter berikut pada cluster Valkey atau Redis OSS (mode cluster enabled), ikuti langkah-langkah berikutnya.
activerehashing
databases
Dengan Redis OSS, Anda dapat membuat cadangan manual cluster Anda. Lihat [Membuat cadangan manual](backups-manual.md).
Hapus klaster . Lihat [Menghapus klaster](Clusters.html#Delete).
Pulihkan klaster menggunakan grup parameter dan cadangan yang sudah diubah untuk melakukan seeding klaster baru. Lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Perubahan pada parameter lain tidak memerlukan tindakan ini.
## Mengubah grup parameter (AWS CLI)
Untuk mengubah nilai parameter menggunakan AWS CLI, gunakan perintah`modify-cache-parameter-group`.
**Example**
Dengan Memcached, untuk menemukan nama dan nilai yang diizinkan dari parameter yang ingin Anda ubah, lihat [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached)
Contoh kode berikut menetapkan nilai dua parameter, *chunk\$1size* dan *chunk\$1size\$1growth\$1fact* pada grup parameter `myMem14`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name myMem14 \
--parameter-name-values \
ParameterName=chunk_size,ParameterValue=96 \
ParameterName=chunk_size_growth_fact,ParameterValue=1.5
```
Untuk Windows:
```
aws elasticache modify-cache-parameter-group ^
--cache-parameter-group-name myMem14 ^
--parameter-name-values ^
ParameterName=chunk_size,ParameterValue=96 ^
ParameterName=chunk_size_growth_fact,ParameterValue=1.5
```
Output dari perintah ini akan terlihat seperti ini.
```
{
"CacheParameterGroupName": "myMem14"
}
```
**Example**
Dengan Valkey dan Redis OSS, untuk menemukan nama dan nilai yang diizinkan dari parameter yang ingin Anda ubah, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
Kode sampel berikut menetapkan nilai dua parameter, *reserved-memory-percent*dan *cluster diaktifkan* pada kelompok parameter. `myredis32-on-30` Kami mengatur *reserved-memory-percent*ke `30` (30 persen) dan *mengaktifkan cluster* `yes` sehingga grup parameter dapat digunakan dengan cluster Valkey atau Redis OSS (mode cluster diaktifkan) (grup replikasi).
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-cache-parameter-group \
--cache-parameter-group-name myredis32-on-30 \
--parameter-name-values \
ParameterName=reserved-memory-percent,ParameterValue=30 \
ParameterName=cluster-enabled,ParameterValue=yes
```
Untuk Windows:
```
aws elasticache modify-cache-parameter-group ^
--cache-parameter-group-name myredis32-on-30 ^
--parameter-name-values ^
ParameterName=reserved-memory-percent,ParameterValue=30 ^
ParameterName=cluster-enabled,ParameterValue=yes
```
Output dari perintah ini akan terlihat seperti ini.
```
{
"CacheParameterGroupName": "my-redis32-on-30"
}
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-parameter-group.html).
Untuk menemukan nama parameter yang Anda ubah, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis).
Jika Anda memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan membuat perubahan pada parameter berikut, Anda harus me-reboot node di cluster:
+ activerehashing
+ databases
Untuk informasi selengkapnya, lihat [Mem-boot ulang simpul](nodes.rebooting.md).
**Perubahan parameter Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Jika Anda membuat perubahan pada parameter berikut pada cluster Valkey atau Redis OSS (mode cluster enabled), ikuti langkah-langkah berikutnya.
activerehashing
databases
Buat cadangan manual klaster Anda. Lihat [Membuat cadangan manual](backups-manual.md).
Hapus klaster . Lihat [Menghapus klaster](Clusters.html#Delete).
Pulihkan klaster menggunakan grup parameter dan cadangan yang sudah diubah untuk melakukan seeding klaster baru. Lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Perubahan pada parameter lain tidak memerlukan tindakan ini.
## Memodifikasi grup parameter (ElastiCache API)
Untuk mengubah nilai parameter grup parameter menggunakan ElastiCache API, gunakan `ModifyCacheParameterGroup` tindakan.
**Example**
Dengan Memcached, untuk menemukan nama dan nilai yang diizinkan dari parameter yang ingin Anda ubah, lihat [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached)
Contoh kode berikut menetapkan nilai dua parameter, *chunk\$1size* dan *chunk\$1size\$1growth\$1fact* pada grup parameter `myMem14`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheParameterGroup
&CacheParameterGroupName=myMem14
&ParameterNameValues.member.1.ParameterName=chunk_size
&ParameterNameValues.member.1.ParameterValue=96
&ParameterNameValues.member.2.ParameterName=chunk_size_growth_fact
&ParameterNameValues.member.2.ParameterValue=1.5
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
**Example**
Dengan Valkey dan Redis OSS, untuk menemukan nama dan nilai yang diizinkan dari parameter yang ingin Anda ubah, lihat [Parameter Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
Kode sampel berikut menetapkan nilai dua parameter, *reserved-memory-percent*dan *cluster diaktifkan* pada kelompok parameter. `myredis32-on-30` Kami mengatur *reserved-memory-percent*ke `30` (30 persen) dan *mengaktifkan cluster* `yes` sehingga grup parameter dapat digunakan dengan cluster Valkey atau Redis OSS (mode cluster diaktifkan) (grup replikasi).
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheParameterGroup
&CacheParameterGroupName=myredis32-on-30
&ParameterNameValues.member.1.ParameterName=reserved-memory-percent
&ParameterNameValues.member.1.ParameterValue=30
&ParameterNameValues.member.2.ParameterName=cluster-enabled
&ParameterNameValues.member.2.ParameterValue=yes
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html).
Jika Anda memiliki cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan membuat perubahan pada parameter berikut, Anda harus me-reboot node di cluster:
+ activerehashing
+ databases
Untuk informasi selengkapnya, lihat [Mem-boot ulang node](nodes.rebooting.md).
**Perubahan parameter Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Jika Anda membuat perubahan pada parameter berikut pada cluster Valkey atau Redis OSS (mode cluster enabled), ikuti langkah-langkah berikutnya.
activerehashing
databases
Buat cadangan manual klaster Anda. Lihat [Membuat cadangan manual](backups-manual.md).
Hapus klaster . Lihat [Menghapus cluster di ElastiCache](Clusters.Delete.md).
Pulihkan klaster menggunakan grup parameter dan cadangan yang sudah diubah untuk melakukan seeding klaster baru. Lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
Perubahan pada parameter lain tidak memerlukan tindakan ini.
# Menghapus grup ElastiCache parameter
Anda dapat menghapus grup parameter kustom menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API.
Anda tidak dapat menghapus grup parameter jika grup parameter ini dikaitkan dengan klaster. Anda juga tidak dapat menghapus grup parameter default.
## Menghapus grup parameter (Konsol)
Prosedur berikut menunjukkan cara menghapus grup parameter menggunakan konsol ElastiCache.
**Untuk menghapus grup parameter menggunakan ElastiCache konsol**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Untuk melihat daftar semua grup parameter yang tersedia, di panel navigasi sebelah kiri pilih **Grup Parameter**.
1. Pilih grup parameter yang ingin Anda hapus dengan memilih kotak di sebelah kiri nama grup parameter.
Tombol **Hapus** akan menjadi aktif.
1. Pilih **Hapus**.
Layar konfirmasi **Hapus Grup Parameter** akan muncul.
1. Untuk menghapus grup parameter, pada layar konfirmasi **Hapus Grup Parameter**, pilih **Hapus**.
Untuk mempertahankan grup parameter, pilih **Batalkan**.
## Menghapus grup parameter (AWS CLI)
Untuk menghapus grup parameter menggunakan AWS CLI, gunakan perintah`delete-cache-parameter-group`. Untuk grup parameter yang akan dihapus, grup parameter yang ditentukan berdasarkan `--cache-parameter-group-name` tidak boleh memiliki klaster yang terkait dengannya, dan juga tidak dapat berupa grup parameter default.
Contoh kode berikut menghapus grup parameter *myMem14*.
**Example**
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-cache-parameter-group \
--cache-parameter-group-name myRed28
```
Untuk Windows:
```
aws elasticache delete-cache-parameter-group ^
--cache-parameter-group-name myRed28
```
Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-parameter-group.html).
## Menghapus grup parameter (ElastiCache API)
Untuk menghapus grup parameter menggunakan ElastiCache API, gunakan `DeleteCacheParameterGroup` tindakan. Untuk grup parameter yang akan dihapus, grup parameter yang ditentukan berdasarkan `CacheParameterGroupName` tidak boleh memiliki klaster yang terkait dengannya, dan juga tidak dapat berupa grup parameter default.
**Example**
Dengan Memcached, kode contoh berikut menghapus grup parameter *MyMEM14*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheParameterGroup
&CacheParameterGroupName=myMem14
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
**Example**
Contoh kode berikut menghapus grup parameter *myRed28*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheParameterGroup
&CacheParameterGroupName=myRed28
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Lihat informasi yang lebih lengkap di [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheParameterGroup.html).
# Parameter spesifik mesin
**Valkey dan Redis OSS**
Sebagian besar parameter Valkey 8 kompatibel dengan parameter Redis OSS 7.1. Parameter Valkey 7.2 sama dengan parameter Redis OSS 7.
Jika Anda tidak menentukan grup parameter untuk cluster Valkey atau Redis OSS Anda, maka grup parameter default yang sesuai dengan versi mesin Anda akan digunakan. Anda tidak dapat mengubah nilai parameter dalam grup parameter default. Namun, Anda dapat membuat grup parameter kustom dan menetapkannya ke klaster Anda setiap saat asalkan nilai parameter yang dapat diubah secara bersyarat di kedua grup parameter sama. Untuk informasi selengkapnya, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
**Topics**
+ [Parameter Valkey dan Redis OSS](#ParameterGroups.Redis)
+ [Parameter spesifik Memcached](#ParameterGroups.Memcached)
## Parameter Valkey dan Redis OSS
**Topics**
+ [Perubahan parameter Valkey 8.2](#ParameterGroups.Valkey.8.2)
+ [Perubahan parameter Valkey 8.1](#ParameterGroups.Valkey.8.1)
+ [Perubahan parameter Valkey 8.0](#ParameterGroups.Valkey.8)
+ [Perubahan parameter Valkey 7.2 dan Redis OSS 7](#ParameterGroups.Redis.7)
+ [Redis OSS 6.x perubahan parameter](#ParameterGroups.Redis.6-x)
+ [Redis OSS 5.0.3 perubahan parameter](#ParameterGroups.Redis.5-0-3)
+ [Redis OSS 5.0.0 perubahan parameter](#ParameterGroups.Redis.5.0)
+ [Redis OSS 4.0.10 perubahan parameter](#ParameterGroups.Redis.4-0-10)
+ [Redis OSS 3.2.10 perubahan parameter](#ParameterGroups.Redis.3-2-10)
+ [Redis OSS 3.2.6 perubahan parameter](#ParameterGroups.Redis.3-2-6)
+ [Redis OSS 3.2.4 perubahan parameter](#ParameterGroups.Redis.3-2-4)
+ [Redis OSS 2.8.24 (ditingkatkan) menambahkan parameter](#ParameterGroups.Redis.2-8-24)
+ [Redis OSS 2.8.23 (ditingkatkan) menambahkan parameter](#ParameterGroups.Redis.2-8-23)
+ [Redis OSS 2.8.22 (ditingkatkan) menambahkan parameter](#ParameterGroups.Redis.2-8-22)
+ [Redis OSS 2.8.21 menambahkan parameter](#ParameterGroups.Redis.2-8-21)
+ [Redis OSS 2.8.19 menambahkan parameter](#ParameterGroups.Redis.2-8-19)
+ [Redis OSS 2.8.6 menambahkan parameter](#ParameterGroups.Redis.2-8-6)
+ [Redis OSS 2.6.13 parameter](#ParameterGroups.Redis.2-6-13)
+ [Parameter spesifik tipe node Redis OSS](#ParameterGroups.Redis.NodeSpecific)
### Perubahan parameter Valkey 8.2
**Keluarga kelompok parameter: valkey8**
**catatan**
Perubahan parameter Valkey 8.2 tidak berlaku untuk Valkey 8.1
Valkey 8.0 dan kelompok parameter di atas tidak kompatibel dengan Redis OSS 7.2.4.
di Valkey 8.2, perintah berikut tidak tersedia untuk cache tanpa server:,,,, dan `commandlog` `commandlog get` `commandlog help` `commandlog len` `commandlog reset.`
**Grup parameter baru di Valkey 8.2**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| search-fanout-target-mode (ditambahkan di 8.2) | Default: klien Jenis: string Dapat diubah: Ya Perubahan Berlaku: Segera | Parameter search-fanout-target-mode konfigurasi mengontrol bagaimana kueri penelusuran didistribusikan di seluruh node dalam lingkungan cluster Valkey. Pengaturan ini menerima dua nilai: “throughput” yang mengoptimalkan throughput maksimum dengan mendistribusikan kueri pencarian secara acak di semua node cluster terlepas dari jenis klien atau status READONLY, dan “klien” yang menghormati karakteristik koneksi klien dengan merutekan klien non-ReadOnly ke node primer saja, klien READONLY pada koneksi replika ke node replika saja, dan klien READONLY pada koneksi primer secara acak di semua node. Perilaku default adalah mode “klien”, yang berarti sistem akan menghormati jenis koneksi klien dan status READONLY untuk keputusan perutean kueri. Gunakan mode throughput untuk beban kerja pencarian volume tinggi di mana pemanfaatan sumber daya klaster maksimum diinginkan, dan mode klien saat Anda ingin mempertahankan read/write pemisahan dan menghormati pola koneksi READONLY tingkat aplikasi. |
| search-default-timeout-ms | Default: 50000 Nilai yang diizinkan: 1 hingga 60000 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Batas waktu kueri pencarian Valkey default (dalam milidetik). |
| search-enable-partial-results | Default: yes Nilai yang diizinkan: ya, tidak Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Segera | Mengkonfigurasi perilaku kegagalan kueri untuk pencarian Valkey. Saat diaktifkan, kueri penelusuran akan mengembalikan sebagian hasil jika batas waktu terjadi pada satu atau beberapa pecahan. Saat dinonaktifkan, batas waktu pecahan apa pun akan menyebabkan seluruh permintaan pencarian gagal dan mengembalikan kesalahan. |
### Perubahan parameter Valkey 8.1
**Keluarga kelompok parameter: valkey8**
**catatan**
Perubahan parameter Valkey 8.1 tidak berlaku untuk Valkey 8.0
Valkey 8.0 dan kelompok parameter di atas tidak kompatibel dengan Redis OSS 7.2.4.
di Valkey 8.1, perintah berikut tidak tersedia untuk cache tanpa server:`commandlog`,,,, dan `commandlog get` `commandlog help` `commandlog len` `commandlog reset.`
**Grup parameter baru di Valkey 8.1**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| commandlog-large-request-max-len (ditambahkan dalam 8.1) | Default: 1048576 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Ukuran maksimum, dalam byte, untuk permintaan yang akan dicatat oleh fitur Log Perintah Valkey. |
| commandlog-large-request-max-len (ditambahkan dalam 8.1) | Default: 128 Nilai yang diizinkan: 0-1024 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Panjang maksimum Log Perintah Valkey untuk permintaan. |
| commandlog-reply-larger-than (ditambahkan di 8.1) | Default: 1048576 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Ukuran maksimum, dalam byte, untuk respons yang akan dicatat oleh fitur Log Perintah Valkey. |
| commandlog-large-reply-max-len (ditambahkan dalam 8.1) | Default: 128 Nilai yang diizinkan: 0-1024 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Panjang maksimum Log Perintah Valkey untuk tanggapan. |
### Perubahan parameter Valkey 8.0
**Keluarga kelompok parameter: valkey8**
**catatan**
Redis OSS 7.2.4 tidak kompatibel dengan Valkey 8 dan di atas kelompok parameter.
**Perubahan parameter spesifik di Valkey 8.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| repl-backlog-size | Standar: 10485760 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Ukuran, dalam byte, buffer backlog simpul primer. Backlog digunakan untuk mencatat pembaruan data pada simpul primer. Ketika replika baca terhubung ke primer, ia mencoba untuk melakukan sinkronisasi paral (psync), di mana ia menerapkan data dari backlog untuk mengejar ketinggalan dengan simpul utama. Jika psync gagal, maka sinkronisasi penuh diperlukan. Nilai minimum untuk parameter ini adalah 16384. Catatan: Dimulai dengan Redis OSS 2.8.22, parameter ini berlaku untuk cluster primer serta replika baca. |
| maxmemory-sampel | Default: 3 Nilai yang diizinkan: 1 hingga 64 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Untuk perhitungan least-recently-used (LRU) dan time-to-live (TTL), parameter ini mewakili ukuran sampel kunci untuk diperiksa. Secara default, Redis OSS memilih 3 kunci dan menggunakan salah satu yang paling tidak digunakan baru-baru ini. |
**Grup parameter baru di Valkey 8.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| extended-redis-compatibility | Nilai yang diizinkan: ya, tidak Default: yes Jenis: boolean Dapat diubah: Ya Perubahan berlaku: segera | Mode kompatibilitas Redis OSS yang diperluas membuat Valkey berpura-pura menjadi Redis OSS 7.2. Aktifkan ini hanya jika Anda memiliki masalah dengan alat atau klien. Dampak yang dihadapi pelanggan: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) |
**Dihapus kelompok parameter di Valkey 8.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| lazyfree-lazy-eviction | Nilai yang diizinkan: ya, tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron pada pengosongan. |
| lazyfree-lazy-expire | Nilai yang diizinkan: ya, tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron pada kunci kedaluwarsa. |
| lazyfree-lazy-server-del | Nilai yang diizinkan: ya, tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron untuk perintah yang memperbarui nilai. |
| lazyfree-lazy-user-del | Default: no Jenis: string Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Ketika nilai diatur ke ya, perintah DEL bertindak sama seperti UNLINK. |
| replica-lazy-flush | Default: yes Jenis: boolean Dapat diubah: Tidak Nama sebelumnya: slave-lazy-flush | Melakukan flushDB asinkron selama sinkronisasi replika. |
### Perubahan parameter Valkey 7.2 dan Redis OSS 7
**Keluarga kelompok parameter: valkey7**
Grup parameter default Valkey 7.2 adalah sebagai berikut:
+ `default.valkey7`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.valkey7.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk klaster Valkey (mode cluster diaktifkan) dan grup replikasi.
**Keluarga grup parameter:** redis7
Redis OSS 7 kelompok parameter default adalah sebagai berikut:
+ `default.redis7`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk kelompok Redis OSS (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.redis7.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk kelompok Redis OSS (mode cluster diaktifkan) dan grup replikasi.
**Perubahan parameter spesifik**
Parameter yang ditambahkan dalam Redis OSS 7 adalah sebagai berikut. Valkey 7.2 juga mendukung parameter ini.
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| cluster-allow-pubsubshard-when-down | Nilai yang diizinkan: `yes`, `no` Default: `yes` Jenis: string Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Ketika diatur ke nilai default ya, memungkinkan simpul melayani lalu lintas serpihan pubsub saat klaster dalam keadaan nonaktif, asalkan klaster ini mengetahui bahwa dirinya memiliki slot. |
| cluster-preferred-endpoint-type | Nilai yang diizinkan: `ip`, `tls-dynamic` Default: `tls-dynamic` Jenis: string Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Nilai ini mengontrol titik akhir apa yang dikembalikan untuk permintaan MOVED/ASKING serta bidang titik akhir untuk `CLUSTER SLOTS` dan `CLUSTER SHARDS`. Ketika nilai diatur ke ip, simpul akan menyatakan alamat ip-nya. Ketika nilai diatur ke tls-dynamic, node akan mengiklankan nama host saat encryption-in-transit diaktifkan dan alamat ip sebaliknya. |
| latency-tracking | Nilai yang diizinkan: `yes`, `no` Default: `no` Jenis: string Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Ketika diatur ke ya akan melacak latensi per perintah dan memungkinkan ekspor distribusi persentil melalui perintah statistik latensi `INFO`, dan distribusi latensi kumulatif (histogram) melalui perintah `LATENCY`. |
| hash-max-listpack-entries | Nilai yang diizinkan: `0+` Default: `512` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Jumlah maksimum entri hash agar set data dikompresi. |
| hash-max-listpack-value | Nilai yang diizinkan: `0+` Default: `64` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Ambang entri hash terbesar agar set data dikompresi. |
| zset-max-listpack-entries | Nilai yang diizinkan: `0+` Default: `128` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Jumlah maksimum entri sorted set agar set data dikompresi. |
| zset-max-listpack-value | Nilai yang diizinkan: `0+` Default: `64` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Ambang batas entri sorted set terbesar agar set data dikompresi. |
Parameter yang diubah dalam Redis OSS 7 adalah sebagai berikut.
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| activerehashing | Dapat diubah: `no`. Di Redis OSS 7, parameter ini disembunyikan dan diaktifkan secara default. Untuk menonaktifkannya, Anda perlu membuat [kasus dukungan](https://console.aws.amazon.com/support/home). | Dapat diubah sebelumnya adalah ya. |
Parameter dihapus dalam Redis OSS 7 adalah sebagai berikut.
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| hash-max-ziplist-entries | Nilai yang diizinkan: `0+` Default: `512` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Gunakan `listpack` bukan `ziplist` untuk merepresentasikan pengenkodean hash kecil. |
| hash-max-ziplist-value | Nilai yang diizinkan: `0+` Default: `64` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Gunakan `listpack` bukan `ziplist` untuk merepresentasikan pengenkodean hash kecil. |
| zset-max-ziplist-entries | Nilai yang diizinkan: `0+` Default: `128` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Gunakan `listpack` bukan `ziplist` untuk merepresentasikan pengenkodean hash kecil. |
| zset-max-ziplist-value | Nilai yang diizinkan: `0+` Default: `64` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Gunakan `listpack` bukan `ziplist` untuk merepresentasikan pengenkodean hash kecil. |
| list-max-ziplist-size | Nilai yang diizinkan: Default: `-2` Jenis: integer Dapat diubah: Ya Penerapan perubahan: Segera di semua simpul dalam klaster. | Jumlah entri yang diizinkan per simpul daftar internal. |
### Redis OSS 6.x perubahan parameter
**Keluarga grup parameter:** redis6.x
Redis OSS 6.x kelompok parameter default adalah sebagai berikut:
+ `default.redis6.x`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.redis6.x.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster diaktifkan) dan grup replikasi.
**catatan**
*Di mesin Redis OSS versi 6.2, ketika keluarga node r6gd diperkenalkan untuk digunakan dengan, hanya kebijakan *noeviction [Tingkatan data di ElastiCache](data-tiering.md)*, *volatile-lru* dan allkeys-lru max-memory yang didukung dengan tipe node r6gd.*
Untuk informasi selengkapnya, lihat [ElastiCache versi 6.2 untuk Redis OSS (ditingkatkan)](engine-versions.md#redis-version-6.2) dan [ElastiCache versi 6.0 untuk Redis OSS (ditingkatkan)](engine-versions.md#redis-version-6.0).
Parameter yang ditambahkan dalam Redis OSS 6.x adalah sebagai berikut.
| Detail | Deskripsi |
| --- | --- |
| acl-pubsub-default (added in 6.2) | Nilai yang diizinkan: `resetchannels`, `allchannels` Default: `allchannels` Jenis: string Dapat diubah: Ya Perubahan berlaku: Pengguna Redis OSS yang ada yang terkait dengan cluster akan terus memiliki izin yang ada. Baik memperbarui pengguna atau reboot cluster untuk memperbarui pengguna Redis OSS yang ada. | Izin saluran pubsub default untuk pengguna ACL yang di-deploy ke klaster ini. |
| cluster-allow-reads-when-down (added in 6.0) | Default: no Jenis: string Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Ketika disetel ke ya, grup replikasi Redis OSS (mode cluster enabled) terus memproses perintah baca bahkan ketika sebuah node tidak dapat mencapai kuorum primer. Jika diatur ke default tidak, grup replikasi menolak semua perintah. Kami merekomendasikan untuk mengatur nilai ini ke ya jika Anda menggunakan klaster dengan kurang dari tiga grup simpul atau aplikasi Anda dapat dengan aman menangani pembacaan yang usang dengan aman. |
| tracking-table-max-keys (added in 6.0) | Default: 1.000.000 Jenis: angka Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Untuk membantu caching sisi klien, Redis OSS mendukung pelacakan klien mana yang telah mengakses kunci mana. Ketika kunci yang dilacak diubah, pesan invalidasi dikirim ke semua klien untuk memberitahukan bahwa nilai cache-nya tidak valid lagi. Nilai ini memungkinkan Anda menentukan batas atas tabel ini. Setelah nilai parameter ini terlampaui, klien mendapatkan pesan invalidasi secara acak. Nilai ini harus diatur untuk membatasi penggunaan memori sambil masih melacak kunci. Kunci juga diinvalidasi dalam kondisi memori rendah. |
| acllog-max-len (added in 6.0) | Default: 128 Jenis: angka Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Nilai ini sesuai dengan jumlah maksimum entri di log ACL. |
| active-expire-effort (added in 6.0) | Default: 1 Jenis: angka Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Redis OSS menghapus kunci yang telah melampaui waktu mereka untuk hidup dengan dua mekanisme. Di satu sisi, kunci diakses dan ditemukan akan kedaluwarsa. Di sisi lain, pekerjaan berkala mengambil sampel kunci dan membuat kunci yang telah melebihi time-to-live (TTL)-nya menjadi kedaluwarsa. Parameter ini mendefinisikan jumlah upaya yang digunakan Redis OSS untuk mengakhiri item dalam pekerjaan periodik. Nilai default 1 akan mencoba mencegah adanya lebih dari 10 persen kunci kedaluwarsa yang masih berada dalam memori. Hal ini juga akan mencoba mencegah konsumsi lebih dari 25 persen dari total memori dan menambahkan latensi ke sistem. Anda dapat meningkatkan nilai ini hingga 10 untuk meningkatkan jumlah upaya yang digunakan untuk kunci kedaluwarsa. Komprominya adalah CPU lebih tinggi dan latensi berpotensi lebih tinggi. Kami merekomendasikan nilai 1 kecuali jika Anda melihat penggunaan memori tinggi dan dapat menoleransi peningkatan pemanfaatan CPU. |
| lazyfree-lazy-user-del (added in 6.0) | Default: no Jenis: string Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Ketika nilai diatur ke ya, perintah `DEL` bertindak sama seperti `UNLINK`. |
Parameter dihapus dalam Redis OSS 6.x adalah sebagai berikut.
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| lua-replicate-commands | Nilai yang diizinkan: yes/no Default: yes Jenis: boolean Dapat diubah: Ya Perubahan berlaku: Segera. | Selalu mengaktifkan replikasi efek Lua atau tidak dalam skrip Lua |
### Redis OSS 5.0.3 perubahan parameter
**Keluarga grup parameter:** redis5.0
Redis OSS 5.0 grup parameter default
+ `default.redis5.0`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.redis5.0.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster diaktifkan) dan grup replikasi.
**Parameter ditambahkan di Redis OSS 5.0.3**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| rename-commands | Default: tidak ada Jenis: string Dapat diubah: Ya Perubahan berlaku: Segera di semua simpul dalam klaster | Daftar yang dipisahkan spasi dari perintah Redis OSS yang diganti namanya. Berikut adalah daftar terbatas perintah yang tersedia untuk diubah namanya: `APPEND AUTH BITCOUNT BITFIELD BITOP BITPOS BLPOP BRPOP BRPOPLPUSH BZPOPMIN BZPOPMAX CLIENT CLUSTER COMMAND DBSIZE DECR DECRBY DEL DISCARD DUMP ECHO EVAL EVALSHA EXEC EXISTS EXPIRE EXPIREAT FLUSHALL FLUSHDB GEOADD GEOHASH GEOPOS GEODIST GEORADIUS GEORADIUSBYMEMBER GET GETBIT GETRANGE GETSET HDEL HEXISTS HGET HGETALL HINCRBY HINCRBYFLOAT HKEYS HLEN HMGET HMSET HSET HSETNX HSTRLEN HVALS INCR INCRBY INCRBYFLOAT INFO KEYS LASTSAVE LINDEX LINSERT LLEN LPOP LPUSH LPUSHX LRANGE LREM LSET LTRIM MEMORY MGET MONITOR MOVE MSET MSETNX MULTI OBJECT PERSIST PEXPIRE PEXPIREAT PFADD PFCOUNT PFMERGE PING PSETEX PSUBSCRIBE PUBSUB PTTL PUBLISH PUNSUBSCRIBE RANDOMKEY READONLY READWRITE RENAME RENAMENX RESTORE ROLE RPOP RPOPLPUSH RPUSH RPUSHX SADD SCARD SCRIPT SDIFF SDIFFSTORE SELECT SET SETBIT SETEX SETNX SETRANGE SINTER SINTERSTORE SISMEMBER SLOWLOG SMEMBERS SMOVE SORT SPOP SRANDMEMBER SREM STRLEN SUBSCRIBE SUNION SUNIONSTORE SWAPDB TIME TOUCH TTL TYPE UNSUBSCRIBE UNLINK UNWATCH WAIT WATCH ZADD ZCARD ZCOUNT ZINCRBY ZINTERSTORE ZLEXCOUNT ZPOPMAX ZPOPMIN ZRANGE ZRANGEBYLEX ZREVRANGEBYLEX ZRANGEBYSCORE ZRANK ZREM ZREMRANGEBYLEX ZREMRANGEBYRANK ZREMRANGEBYSCORE ZREVRANGE ZREVRANGEBYSCORE ZREVRANK ZSCORE ZUNIONSTORE SCAN SSCAN HSCAN ZSCAN XINFO XADD XTRIM XDEL XRANGE XREVRANGE XLEN XREAD XGROUP XREADGROUP XACK XCLAIM XPENDING GEORADIUS_RO GEORADIUSBYMEMBER_RO LOLWUT XSETID SUBSTR` |
Untuk informasi selengkapnya, lihat [ElastiCache versi 5.0.6 untuk Redis OSS (ditingkatkan)](engine-versions.md#redis-version-5-0.6).
### Redis OSS 5.0.0 perubahan parameter
**Keluarga grup parameter:** redis5.0
Redis OSS 5.0 grup parameter default
+ `default.redis5.0`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.redis5.0.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster diaktifkan) dan grup replikasi.
**Parameter ditambahkan di Redis OSS 5.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| stream-node-max-bytes | Nilai yang diizinkan: 0\$1 Default: 4096 Jenis: integer Dapat diubah: Ya Perubahan berlaku: Segera. | Struktur aliran data adalah pohon radix simpul yang mengodekan beberapa item dalamnya. Gunakan konfigurasi ini untuk menentukan ukuran maksimum simpul tunggal dalam pohon radix dalam Byte. Jika diatur ke 0, ukuran simpul pohon adalah tidak terbatas. |
| stream-node-max-entries | Nilai yang diizinkan: 0\$1 Default: 100 Jenis: integer Dapat diubah: Ya Perubahan berlaku: Segera. | Struktur data aliran adalah pohon radix simpul yang mengenkode beberapa item dalamnya. Gunakan konfigurasi ini untuk menentukan jumlah maksimum item yang dapat ditampung simpul tunggal sebelum beralih ke simpul baru saat menambahkan entri aliran baru. Jika diatur ke 0, jumlah item di simpul pohon adalah tidak terbatas |
| active-defrag-max-scan-fields | Nilai yang diizinkan: 1 hingga 1000000 Default: 1000 Jenis: integer Dapat diubah: Ya Perubahan berlaku: Segera. | Jumlah maksimum set/hash/zset/list bidang yang akan diproses dari pemindaian kamus utama |
| lua-replicate-commands | Nilai yang diizinkan: yes/no Default: yes Jenis: boolean Dapat diubah: Ya Perubahan berlaku: Segera. | Selalu mengaktifkan replikasi efek Lua atau tidak dalam skrip Lua |
| replica-ignore-maxmemory | Default: yes Jenis: boolean Dapat diubah: Tidak | Menentukan apakah replika mengabaikan pengaturan maxmemory dengan tidak mengosongkan item yang independen dari primer |
Redis OSS telah mengganti nama beberapa parameter di engine versi 5.0 sebagai tanggapan atas umpan balik komunitas. Untuk informasi selengkapnya, lihat [Apa yang Baru di Redis OSS 5?](https://aws.amazon.com/redis/Whats_New_Redis5/) . Tabel berikut mencantumkan nama baru dan pemetaannya ke versi sebelumnya.
**Parameter berganti nama dalam Redis OSS 5.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| replica-lazy-flush | Default: yes Jenis: boolean Dapat diubah: Tidak Nama sebelumnya: slave-lazy-flush | Melakukan flushDB asinkron selama sinkronisasi replika. |
| client-output-buffer-limit-replica-hard-limit | Default: Untuk nilai, lihat [Parameter spesifik tipe node Redis OSS](#ParameterGroups.Redis.NodeSpecific) Jenis: integer Dapat Diubah: Tidak Nama sebelumnya: client-output-buffer-limit - slave-hard-limit | Untuk Redis OSS baca replika: Jika buffer keluaran klien mencapai jumlah byte yang ditentukan, klien akan terputus. |
| client-output-buffer-limit-replica-soft-limit | Default: Untuk nilai, lihat [Parameter spesifik tipe node Redis OSS](#ParameterGroups.Redis.NodeSpecific) Jenis: integer Dapat Diubah: Tidak Nama sebelumnya: client-output-buffer-limit - slave-soft-limit | Untuk Redis OSS baca replika: Jika buffer keluaran klien mencapai jumlah byte yang ditentukan, klien akan terputus, tetapi hanya jika kondisi ini berlanjut. client-output-buffer-limit-replica-soft-seconds |
| client-output-buffer-limit-replica-soft-seconds | Default: 60 Jenis: integer Dapat Diubah: Tidak Nama sebelumnya: client-output-buffer-limit - slave-soft-seconds | Untuk Redis OSS baca replika: Jika buffer keluaran klien tetap pada client-output-buffer-limit-replica-soft-limit byte lebih lama dari jumlah detik ini, klien akan terputus. |
| replica-allow-chaining | Default: no Jenis: string Dapat diubah: Tidak Nama sebelumnya: slave-allow-chaining | Menentukan apakah replika baca di Redis OSS dapat membaca replika sendiri. |
| min-replicas-to-write | Default: 0 Jenis: integer Dapat diubah: Ya Nama sebelumnya: min-slaves-to-write Perubahan berlaku: Segera | Jumlah minimum replika baca yang harus tersedia agar simpul primer dapat menerima penulisan dari klien. Jika jumlah replika yang tersedia di bawah jumlah ini, maka simpul primer tidak akan lagi menerima permintaan tulis. Jika parameter min-replicas-max-lag ini atau 0, maka node utama akan selalu menerima permintaan penulisan, bahkan jika tidak ada replika yang tersedia. |
| min-replicas-max-lag | Default: 10 Jenis: integer Dapat diubah: Ya Nama sebelumnya: min-slaves-max-lag Perubahan Berlaku: Segera | Jumlah detik saat simpul primer harus menerima permintaan ping dari replika baca. Jika jumlah waktu ini berlalu dan primer tidak menerima ping, maka replika tidak lagi dianggap tersedia. Jika jumlah replika yang tersedia turun di bawah min-replicas-to-write, maka primer akan berhenti menerima penulisan pada saat itu. Jika salah satu parameter min-replicas-to-write ini atau 0, maka node utama akan selalu menerima permintaan tulis, bahkan jika tidak ada replika yang tersedia. |
| close-on-replica-write | Default: yes Jenis: boolean Dapat Diubah: Ya Nama sebelumnya: close-on-slave-write Perubahan Berlaku: Segera | Jika diaktifkan, klien yang mencoba menulis ke replika hanya baca akan terputus. |
**Parameter dihapus di Redis OSS 5.0**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| repl-timeout | Default: 60 Dapat diubah: Tidak | Parameter tidak tersedia dalam versi ini. |
### Redis OSS 4.0.10 perubahan parameter
**Keluarga grup parameter:** redis4.0
Redis OSS 4.0.x grup parameter default
+ `default.redis4.0`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dan grup replikasi.
+ `default.redis4.0.cluster.on`— Gunakan grup parameter ini, atau yang diturunkan darinya, untuk cluster Valkey atau Redis OSS (mode cluster diaktifkan) dan grup replikasi.
**Parameter berubah di Redis OSS 4.0.10**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| maxmemory-policy | Nilai yang diizinkan: `allkeys-lru`, `volatile-lru`, **allkeys-lfu**, **volatile-lfu**, `allkeys-random`, `volatile-random`, `volatile-ttl`, `noeviction` Default: volatile-lru Jenis: string Dapat diubah: Ya Perubahan berlaku: segera | maxmemory-policy telah ditambahkan dalam versi 2.6.13. Dalam versi 4.0.10 ditambahkan dua nilai baru yang diizinkan: allkeys-lfu, yang akan mengosongkan setiap kunci menggunakan LFU yang diperkirakan, dan volatile-lfu, yang akan mengosongkan kunci dengan set yang kedaluwarsa menggunakan LFU yang diperkirakan. Dalam versi 6.2, ketika keluarga simpul r6gd diperkenalkan untuk digunakan dengan tingkatan data, hanya kebijakan max-memory noeviction, volatile-lru dan allkeys-lru yang didukung dengan jenis simpul r6gd. |
**Parameter ditambahkan di Redis OSS 4.0.10**
| Nama | Detail | Deskripsi |
| --- |--- |--- |
| **Parameter penghapusan asinkron** |
| --- |
| lazyfree-lazy-eviction | Nilai yang diizinkan: ya/tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron pada pengosongan. |
| lazyfree-lazy-expire | Nilai yang diizinkan: ya/tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron pada kunci kedaluwarsa. |
| lazyfree-lazy-server-del | Nilai yang diizinkan: ya/tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan akan diterapkan: segera | Melakukan penghapusan asinkron untuk perintah yang memperbarui nilai. |
| slave-lazy-flush | Nilai yang diizinkan: N/A Default: no Jenis: boolean Dapat Diubah: Tidak Perubahan akan diterapkan: N/A | Melakukan FlushDB asinkron selama sinkronisasi slave. |
| **Parameter LFU** |
| --- |
| lfu-log-factor | Nilai yang diizinkan: semua integer > 0 Default: 10 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Mengatur faktor log, yang menentukan jumlah temuan kunci untuk memenuhi penghitung kunci. |
| lfu-decay-time | Nilai yang diizinkan: integer apa pun Default: 1 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Jumlah waktu dalam menit untuk mengurangi penghitung kunci. |
| **Parameter defragmentasi aktif** |
| --- |
| activedefrag | Nilai yang diizinkan: ya/tidak Default: no Jenis: boolean Dapat diubah: Ya Perubahan berlaku: segera | Mengaktifkan defragmentasi aktif. Dalam Valkey dan Redis OSS versi 7.0 dan di atas, secara otomatis AWS dapat melakukan defragmentasi bila diperlukan secara operasional, terlepas dari pengaturan ini. |
| active-defrag-ignore-bytes | Nilai yang diizinkan: 10485760-104857600 Default: 104857600 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Jumlah minimum sisa fragmentasi untuk memulai defrag aktif. |
| active-defrag-threshold-lower | Nilai yang diizinkan: 1-100 Default: 10 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Persentase minimum fragmentasi untuk memulai defrag aktif. |
| active-defrag-threshold-upper | Nilai yang diizinkan: 1-100 Default: 100 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Persentase maksimum fragmentasi yang mana kita menggunakan upaya maksimal. |
| active-defrag-cycle-min | Nilai yang diizinkan: 1-75 Default: 25 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Upaya minimal untuk defrag dalam persentase CPU. |
| active-defrag-cycle-max | Nilai yang diizinkan: 1-75 Default: 75 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Upaya maksimal untuk defrag dalam persentase CPU. |
| **Parameter buffer output klien** |
| --- |
| client-query-buffer-limit | Nilai yang diizinkan: 1048576-1073741824 Default: 1073741824 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Ukuran maks buffer kueri klien tunggal. |
| proto-max-bulk-len | Nilai yang diizinkan: 1048576-536870912 Default: 536870912 Jenis: integer Dapat diubah: Ya Perubahan akan diterapkan: segera | Ukuran maks dari permintaan elemen tunggal. |
### Redis OSS 3.2.10 perubahan parameter
**Keluarga grup parameter: **redis3.2
ElastiCache untuk Redis OSS 3.2.10 tidak ada parameter tambahan yang didukung.
### Redis OSS 3.2.6 perubahan parameter
**Keluarga grup parameter: **redis3.2
Untuk Redis OSS 3.2.6 tidak ada parameter tambahan yang didukung.
### Redis OSS 3.2.4 perubahan parameter
**Keluarga grup parameter: **redis3.2
Dimulai dengan Redis OSS 3.2.4 ada dua kelompok parameter default.
+ `default.redis3.2`— Saat menjalankan Redis OSS 3.2.4, tentukan grup parameter ini atau yang diturunkan darinya, jika Anda ingin membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) dan masih menggunakan fitur tambahan Redis OSS 3.2.4.
+ `default.redis3.2.cluster.on`— Tentukan grup parameter ini atau yang diturunkan darinya, saat Anda ingin membuat grup replikasi Valkey atau Redis OSS (mode cluster diaktifkan).
**Topics**
+ [Parameter baru untuk Redis OSS 3.2.4](#ParameterGroups.Redis.3-2-4.New)
+ [Parameter berubah di Redis OSS 3.2.4 (ditingkatkan)](#ParameterGroups.Redis.3-2-4.Changed)
#### Parameter baru untuk Redis OSS 3.2.4
**Keluarga grup parameter: **redis3.2
Untuk Redis OSS 3.2.4 parameter tambahan berikut didukung.
****
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| list-max-ziplist-size | Default: -2 Jenis: integer Dapat diubah: Tidak | Daftar dikodekan dengan cara khusus untuk menghemat ruang. Jumlah entri yang diizinkan per simpul daftar internal dapat ditentukan sebagai ukuran maksimum tetap atau jumlah maksimum elemen. Untuk ukuran maksimum tetap, gunakan -5 hingga -1, yang berarti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) |
| list-compress-depth | Default: 0 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Daftar juga dapat dikompresi. Kedalaman kompresi adalah jumlah simpul quicklist ziplist dari setiap sisi daftar yang akan dikecualikan dari kompresi. Kepala dan ekor dari daftar selalu tidak dikompresi untuk operasi "fast push and pop". Pengaturannya adalah: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) |
| cluster-enabled | Default: no/yes \$1 Jenis: string Dapat diubah: Tidak | Menunjukkan apakah ini adalah grup replikasi Valkey atau Redis OSS (mode cluster diaktifkan) dalam mode cluster (ya) atau grup replikasi Valkey atau Redis OSS (mode cluster diaktifkan) dalam mode non-cluster (tidak). Grup replikasi Valkey atau Redis OSS (mode cluster enabled) dalam mode cluster dapat mempartisi data mereka hingga 500 grup node. \$1 Redis OSS 3.2. *x* memiliki dua kelompok parameter default. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html). |
| cluster-require-full-coverage | Default: no Jenis: boolean Dapat diubah: ya Perubahan Berlaku: Segera | Ketika diatur ke`yes`, node Valkey atau Redis OSS (mode cluster diaktifkan) dalam mode cluster berhenti menerima kueri jika mereka mendeteksi setidaknya ada satu slot hash yang ditemukan (tidak ada node yang tersedia yang menyajikannya). Dengan cara ini jika sebagian klaster berhenti, klaster menjadi tidak tersedia. Klaster secara otomatis menjadi tersedia lagi begitu semua slot tercakup lagi. Namun, terkadang Anda ingin subset klaster yang berfungsi terus menerima permintaan untuk bagian dari ruang kunci yang masih tercakup. Untuk melakukannya, cukup atur opsi `cluster-require-full-coverage` ke `no`. |
| hll-sparse-max-bytes | Default: 3000 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | HyperLogLog batas byte representasi jarang. Batas termasuk header 16 byte. Ketika HyperLogLog menggunakan representasi jarang melintasi batas ini, itu diubah menjadi representasi padat. Nilai yang lebih besar dari 16000 tidak disarankan karena pada titik tersebut dense representation lebih hemat memori. Kami merekomendasikan nilai sekitar 3000 untuk mendapatkan manfaat dari pengenkodean hemat ruang tanpa terlalu memperlambat PFADD, yaitu O(N) dengan sparse encoding. Nilai dapat dinaikkan menjadi \$1 10000 ketika CPU tidak menjadi perhatian, tetapi ruang adalah, dan kumpulan data terdiri dari banyak HyperLogLogs dengan kardinalitas dalam kisaran 0 - 15000. |
| reserved-memory-percent | Default: 25 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Persentase memori simpul yang dicadangkan untuk penggunaan nondata. Secara default, jejak data Redis OSS tumbuh hingga menghabiskan semua memori node. Jika ini terjadi, maka performa simpul kemungkinan akan terdampak negatif karena memory paging yang berlebihan. Dengan memesan memori, Anda dapat menyisihkan beberapa memori yang tersedia untuk tujuan OSS non-Redis untuk membantu mengurangi jumlah paging. Parameter ini khusus untuk ElastiCache, dan bukan bagian dari distribusi OSS Redis standar. Untuk informasi selengkapnya, lihat `reserved-memory` dan [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md). |
#### Parameter berubah di Redis OSS 3.2.4 (ditingkatkan)
**Keluarga grup parameter: **redis3.2
Untuk Redis OSS 3.2.4 parameter berikut diubah.
****
| Nama | Detail | Ubah |
| --- | --- | --- |
| activerehashing | Dapat dimodifikasi: Ya jika grup parameter tidak terkait dengan cluster apa pun. Jika sebaliknya, tidak. | Dapat diubah adalah Tidak. |
| databases | Dapat dimodifikasi: Ya jika grup parameter tidak terkait dengan cluster apa pun. Jika sebaliknya, tidak. | Dapat diubah adalah Tidak. |
| appendonly | Default: nonaktif Dapat diubah: Tidak | Jika Anda ingin memutakhirkan dari versi Redis OSS sebelumnya, Anda harus mematikan `appendonly` terlebih dahulu. |
| appendfsync | Default: nonaktif Dapat diubah: Tidak | Jika Anda ingin memutakhirkan dari versi Redis OSS sebelumnya, Anda harus mematikan `appendfsync` terlebih dahulu. |
| repl-timeout | Default: 60 Dapat diubah: Tidak | Sekarang tidak dapat diubah dengan default 60. |
| tcp-keepalive | Default: 300 | Default adalah 0. |
| list-max-ziplist-entries | | Parameter tidak lagi tersedia. |
| list-max-ziplist-value | | Parameter tidak lagi tersedia. |
### Redis OSS 2.8.24 (ditingkatkan) menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.24 tidak ada parameter tambahan yang didukung.
### Redis OSS 2.8.23 (ditingkatkan) menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.23 parameter tambahan berikut didukung.
****
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| close-on-slave-write | Default: yes Jenis: string (ya/tidak) Dapat diubah: Ya Perubahan Berlaku: Segera | Jika diaktifkan, klien yang mencoba menulis ke replika hanya baca akan terputus. |
#### Cara kerja close-on-slave-write
`close-on-slave-write`Parameter ini diperkenalkan oleh Amazon ElastiCache untuk memberi Anda kontrol lebih besar atas bagaimana cluster Anda merespons saat node utama dan node replika baca bertukar peran karena mempromosikan replika baca ke primer.
![\[Gambar: close-on-replica-write, semuanya berfungsi dengan baik\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-01.png)
Jika klaster replika baca dipromosikan ke primer untuk alasan apa pun selain failover grup replikasi dengan Multi-AZ diaktifkan, klien akan terus mencoba menulis ke titik akhir A. Karena titik akhir A sekarang adalah titik akhir untuk replika baca, penulisan ini akan gagal. Ini adalah perilaku untuk Redis OSS sebelum ElastiCache memperkenalkan `close-on-replica-write` dan perilaku jika Anda menonaktifkan. `close-on-replica-write`
![\[Gambar: close-on-slave-write, menulis gagal\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-02.png)
Dengan `close-on-replica-write` diaktifkan, setiap kali klien mencoba menulis ke replika baca, koneksi klien ke klaster ditutup. Logika aplikasi Anda harus mendeteksi pemutusan koneksi, memeriksa tabel DNS, dan menghubungkan kembali ke titik akhir primer, yang sekarang akan menjadi titik akhir B.
![\[Gambar: close-on-slave-write, menulis ke cluster primer baru\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-03.png)
#### Kapan Anda mungkin menonaktifkan close-on-replica-write
Jika penonaktifan `close-on-replica-write` mengakibatkan gagalnya penulisan ke klaster, mengapa `close-on-replica-write` dinonaktifkan?
Seperti yang telah disebutkan, dengan mengaktifkan `close-on-replica-write`, setiap kali klien mencoba menulis ke replika baca, koneksi klien ke klaster akan ditutup. Pembuatan koneksi baru ke simpul membutuhkan waktu. Jadi, pemutusan koneksi dan pembuatan koneksi kembali sebagai akibat dari permintaan tulis ke replika juga memengaruhi latensi permintaan baca yang dilayani melalui koneksi yang sama. Efek ini tetap ada sampai dibuatnya koneksi baru. Jika aplikasi Anda sangat sarat dengan operasi baca atau sangat sensitif terhadap latensi, Anda dapat menjaga klien tetap terhubung untuk menghindari performa baca yang menurun.
### Redis OSS 2.8.22 (ditingkatkan) menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.22 tidak ada parameter tambahan yang didukung.
**penting**
Dimulai dengan Redis OSS versi 2.8.22, `repl-backlog-size` berlaku untuk cluster utama serta cluster replika.
Dimulai dengan Redis OSS versi 2.8.22, `repl-timeout` parameter tidak didukung. Jika diubah, ElastiCache akan menimpa dengan default (60an), seperti yang kita lakukan dengan`appendonly`.
Parameter berikut tidak lagi didukung.
+ *appendonly*
+ *appendfsync*
+ *repl-timeout*
### Redis OSS 2.8.21 menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.21, tidak ada parameter tambahan yang didukung.
### Redis OSS 2.8.19 menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.19 tidak ada parameter tambahan yang didukung.
### Redis OSS 2.8.6 menambahkan parameter
**Keluarga grup parameter:** redis2.8
Untuk Redis OSS 2.8.6 parameter tambahan berikut didukung.
****
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| min-slaves-max-lag | Default: 10 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Jumlah detik saat simpul primer harus menerima permintaan ping dari replika baca. Jika jumlah waktu ini berlalu dan primer tidak menerima ping, maka replika tidak lagi dianggap tersedia. Jika jumlah replika yang tersedia turun di bawah min-slaves-to-write, maka primer akan berhenti menerima penulisan pada saat itu. Jika parameter min-slaves-to-write ini atau 0, maka node utama akan selalu menerima permintaan penulisan, bahkan jika tidak ada replika yang tersedia. |
| min-slaves-to-write | Default: 0 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Jumlah minimum replika baca yang harus tersedia agar simpul primer dapat menerima penulisan dari klien. Jika jumlah replika yang tersedia di bawah jumlah ini, maka simpul primer tidak akan lagi menerima permintaan tulis. Jika parameter min-slaves-max-lag ini atau 0, maka node utama akan selalu menerima permintaan penulisan, bahkan jika tidak ada replika yang tersedia. |
| notify-keyspace-events | Default: (string kosong) Jenis: string Dapat diubah: Ya Perubahan Berlaku: Segera | Jenis-jenis acara keyspace yang Redis OSS dapat memberitahu klien. Setiap jenis peristiwa direpresentasikan oleh satu huruf: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) Anda dapat memiliki kombinasi semua jenis peristiwa ini. Misalnya, *AKE* berarti bahwa Redis OSS dapat mempublikasikan pemberitahuan dari semua jenis acara. Jangan gunakan karakter selain yang tercantum di atas; jika tidak, pesan kesalahan akan dihasilkan. Secara default, parameter ini diatur ke string kosong, yang berarti bahwa notifikasi peristiwa ruang kunci dinonaktifkan. |
| repl-backlog-size | Default: 1048576 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Ukuran, dalam byte, buffer backlog simpul primer. Backlog digunakan untuk mencatat pembaruan data pada simpul primer. Ketika replika baca terhubung ke primer, replika ini mencoba melakukan sinkronisasi parsial (`psync`), yang menerapkan data dari backlog untuk mengejar simpul primer. Jika `psync` gagal, maka sinkronisasi penuh diperlukan. Nilai minimum untuk parameter ini adalah 16384. Dimulai dengan Redis OSS 2.8.22, parameter ini berlaku untuk cluster primer serta replika baca. |
| repl-backlog-ttl | Default: 3600 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Jumlah detik saat simpul primer mempertahankan buffer backlog. Mulai dari waktu simpul replika terakhir terputus, data dalam backlog akan tetap utuh sampai `repl-backlog-ttl` kedaluwarsa. Jika replika tidak terhubung ke primer dalam waktu ini, maka primer akan melepaskan buffer backlog. Ketika replika akhirnya terhubung kembali, replikasi ini harus melakukan sinkronisasi penuh dengan primer. Jika parameter ini diatur ke 0, maka buffer backlog tidak akan pernah dilepas. |
| repl-timeout | Default: 60 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Segera | Merepresentasikan periode waktu habis, dalam detik, untuk: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) |
### Redis OSS 2.6.13 parameter
**Keluarga grup parameter:** redis2.6
Redis OSS 2.6.13 adalah versi pertama dari Redis OSS yang didukung oleh. ElastiCache Tabel berikut menunjukkan Redis OSS 2.6.13 parameter yang mendukung. ElastiCache
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html)
**catatan**
Jika Anda tidak menentukan grup parameter untuk cluster Redis OSS 2.6.13 Anda, maka grup parameter default (`default.redis2.6`) akan digunakan. Anda tidak dapat mengubah nilai parameter dalam grup parameter default; namun, Anda selalu dapat membuat grup parameter kustom dan menetapkannya ke klaster Anda setiap saat.
### Parameter spesifik tipe node Redis OSS
Meskipun sebagian besar parameter memiliki nilai tunggal, beberapa parameter memiliki nilai yang berbeda-beda bergantung pada jenis simpul yang digunakan. Tabel berikut menunjukkan nilai default untuk parameter `maxmemory`, `client-output-buffer-limit-slave-hard-limit`, dan `client-output-buffer-limit-slave-soft-limit` untuk setiap jenis simpul. Nilai `maxmemory` adalah jumlah maksimum byte yang tersedia untuk Anda gunakan, untuk data, dan untuk penggunaan lainnya, pada simpul. Untuk informasi selengkapnya, lihat [Memori yang tersedia](https://aws.amazon.com/premiumsupport/knowledge-center/available-memory-elasticache-redis-node/).
**catatan**
Parameter `maxmemory` tidak dapat diubah.
| Jenis simpul | Maxmemory | C lient-output-buffer-limit - slave-hard-limit | C lient-output-buffer-limit - slave-soft-limit |
| --- | --- | --- | --- |
| cache.t1.micro | 142606336 | 14260633 | 14260633 |
| cache.t2.micro | 581959680 | 58195968 | 58195968 |
| cache.t2.small | 1665138688 | 166513868 | 166513868 |
| cache.t2.medium | 3461349376 | 346134937 | 346134937 |
| cache.t3.micro | 536870912 | 53687091 | 53687091 |
| cache.t3.small | 1471026299 | 147102629 | 147102629 |
| cache.t3.medium | 3317862236 | 331786223 | 331786223 |
| cache.t4g.micro | 536870912 | 53687091 | 53687091 |
| cache.t4g.small | 1471026299 | 147102629 | 147102629 |
| cache.t4g.medium | 3317862236 | 331786223 | 331786223 |
| cache.m1.small | 943718400 | 94371840 | 94371840 |
| cache.m1.medium | 3093299200 | 309329920 | 309329920 |
| cache.m1.large | 7025459200 | 702545920 | 702545920 |
| cache.m1.xlarge | 14889779200 | 1488977920 | 1488977920 |
| cache.m2.xlarge | 17091788800 | 1709178880 | 1709178880 |
| cache.m2.2xlarge | 35022438400 | 3502243840 | 3502243840 |
| cache.m2.4xlarge | 70883737600 | 7088373760 | 7088373760 |
| cache.m3.medium | 2988441600 | 309329920 | 309329920 |
| cache.m3.large | 6501171200 | 650117120 | 650117120 |
| cache.m3.xlarge | 14260633600 | 1426063360 | 1426063360 |
| cache.m3.2xlarge | 29989273600 | 2998927360 | 2998927360 |
| cache.m4.large | 6892593152 | 689259315 | 689259315 |
| cache.m4.xlarge | 15328501760 | 1532850176 | 1532850176 |
| cache.m4.2xlarge | 31889126359 | 3188912636 | 3188912636 |
| cache.m4.4xlarge | 65257290629 | 6525729063 | 6525729063 |
| cache.m4.10xlarge | 166047614239 | 16604761424 | 16604761424 |
| cache.m5.large | 6854542746 | 685454275 | 685454275 |
| cache.m5.xlarge | 13891921715 | 1389192172 | 1389192172 |
| cache.m5.2xlarge | 27966669210 | 2796666921 | 2796666921 |
| cache.m5.4xlarge | 56116178125 | 5611617812 | 5611617812 |
| cache.m5.12xlarge | 168715971994 | 16871597199 | 16871597199 |
| cache.m5.24xlarge | 337500562842 | 33750056284 | 33750056284 |
| cache.m6g.large | 6854542746 | 685454275 | 685454275 |
| cache.m6g.xlarge | 13891921715 | 1389192172 | 1389192172 |
| cache.m6g.2xlarge | 27966669210 | 2796666921 | 2796666921 |
| cache.m6g.4xlarge | 56116178125 | 5611617812 | 5611617812 |
| cache.m6g.8xlarge | 111325552312 | 11132555231 | 11132555231 |
| cache.m6g.12xlarge | 168715971994 | 16871597199 | 16871597199 |
| cache.m6g.16xlarge | 225000375228 | 22500037523 | 22500037523 |
| cache.c1.xlarge | 6501171200 | 650117120 | 650117120 |
| cache.r3.large | 14470348800 | 1468006400 | 1468006400 |
| cache.r3.xlarge | 30513561600 | 3040870400 | 3040870400 |
| cache.r3.2xlarge | 62495129600 | 6081740800 | 6081740800 |
| cache.r3.4xlarge | 126458265600 | 12268339200 | 12268339200 |
| cache.r3.8xlarge | 254384537600 | 24536678400 | 24536678400 |
| cache.r4.large | 13201781556 | 1320178155 | 1320178155 |
| cache.r4.xlarge | 26898228839 | 2689822883 | 2689822883 |
| cache.r4.2xlarge | 54197537997 | 5419753799 | 5419753799 |
| cache.r4.4xlarge | 108858546586 | 10885854658 | 10885854658 |
| cache.r4.8xlarge | 218255432090 | 21825543209 | 21825543209 |
| cache.r4.16xlarge | 437021573120 | 43702157312 | 43702157312 |
| cache.r5.large | 14037181030 | 1403718103 | 1403718103 |
| cache.r5.xlarge | 28261849702 | 2826184970 | 2826184970 |
| cache.r5.2xlarge | 56711183565 | 5671118356 | 5671118356 |
| cache.r5.4xlarge | 113609865216 | 11360986522 | 11360986522 |
| cache.r5.12xlarge | 341206346547 | 34120634655 | 34120634655 |
| cache.r5.24xlarge | 682485973811 | 68248597381 | 68248597381 |
| cache.r6g.large | 14037181030 | 1403718103 | 1403718103 |
| cache.r6g.xlarge | 28261849702 | 2826184970 | 2826184970 |
| cache.r6g.2xlarge | 56711183565 | 5671118356 | 5671118356 |
| cache.r6g.4xlarge | 113609865216 | 11360986522 | 11360986522 |
| cache.r6g.8xlarge | 225000375228 | 22500037523 | 22500037523 |
| cache.r6g.12xlarge | 341206346547 | 34120634655 | 34120634655 |
| cache.r6g.16xlarge | 450000750456 | 45000075046 | 45000075046 |
| cache.r6gd.xlarge | 28261849702 | 2826184970 | 2826184970 |
| cache.r6gd.2xlarge | 56711183565 | 5671118356 | 5671118356 |
| cache.r6gd.4xlarge | 113609865216 | 11360986522 | 11360986522 |
| cache.r6gd.8xlarge | 225000375228 | 22500037523 | 22500037523 |
| cache.r6gd.12xlarge | 341206346547 | 34120634655 | 34120634655 |
| cache.r6gd.16xlarge | 450000750456 | 45000075046 | 45000075046 |
| cache.r7g.large | 14037181030 | 1403718103 | 1403718103 |
| cache.r7g.xlarge | 28261849702 | 2826184970 | 2826184970 |
| cache.r7g.2xlarge | 56711183565 | 5671118356 | 5671118356 |
| cache.r7g.4xlarge | 113609865216 | 11360986522 | 11360986522 |
| cache.r7g.8xlarge | 225000375228 | 22500037523 | 22500037523 |
| cache.r7g.12xlarge | 341206346547 | 34120634655 | 34120634655 |
| cache.r7g.16xlarge | 450000750456 | 45000075046 | 45000075046 |
| cache.m7g.large | 6854542746 | 685454275 | 685454275 |
| cache.m7g.xlarge | 13891921715 | 1389192172 | 1389192172 |
| cache.m7g.2xlarge | 27966669210 | 2796666921 | 2796666921 |
| cache.m7g.4xlarge | 56116178125 | 5611617812 | 5611617812 |
| cache.m7g.8xlarge | 111325552312 | 11132555231 | 11132555231 |
| cache.m7g.12xlarge | 168715971994 | 16871597199 | 16871597199 |
| cache.m7g.16xlarge | 225000375228 | 22500037523 | 22500037523 |
| cache.c7gn.large | 3317862236 | 1403718103 | 1403718103 |
| cache.c7gn.xlarge | 6854542746 | 2826184970 | 2826184970 |
| cache.c7gn.2xlarge | 13891921715 | 5671118356 | 5671118356 |
| cache.c7gn.4xlarge | 27966669210 | 11360986522 | 11360986522 |
| cache.c7gn.8xlarge | 56116178125 | 22500037523 | 22500037523 |
| cache.c7gn.12xlarge | 84357985997 | 34120634655 | 34120634655 |
| cache.c7gn.16xlarge | 113609865216 | 45000075046 | 45000075046 |
**catatan**
Semua jenis instans generasi saat ini dibuat di Amazon Virtual Private Cloud (VPC) secara default.
Instans T1 tidak mendukung Multi-AZ.
Instans T1 dan T2 tidak mendukung Redis OSS AOF.
Redis OSS variabel konfigurasi `appendonly` dan tidak `appendfsync` didukung pada Redis OSS versi 2.8.22 dan yang lebih baru.
## Parameter spesifik Memcached
**Memcache**
Jika Anda tidak menentukan grup parameter untuk klaster Memcached, maka grup parameter default yang sesuai dengan versi mesin Anda akan digunakan. Anda tidak dapat mengubah nilai parameter dalam grup parameter default. Namun, Anda dapat membuat grup parameter kustom dan menetapkannya ke klaster Anda kapan saja. Untuk informasi selengkapnya, lihat [Membuat grup ElastiCache parameter](ParameterGroups.Creating.md).
**Topics**
+ [Perubahan Memcached 1.6.17](#ParameterGroups.Memcached.1.6.17)
+ [Parameter yang ditambahkan di Memcached 1.6.6](#ParameterGroups.Memcached.1-6-6)
+ [Perubahan parameter Memcached 1.5.10](#ParameterGroups.Memcached.1-5-10)
+ [Parameter yang ditambahkan di Memcached 1.4.34](#ParameterGroups.Memcached.1-4-34)
+ [Parameter yang ditambahkan di Memcached 1.4.33](#ParameterGroups.Memcached.1-4-33)
+ [Parameter yang ditambahkan di Memcached 1.4.24](#ParameterGroups.Memcached.1-4-24)
+ [Parameter yang ditambahkan di Memcached 1.4.14](#ParameterGroups.Memcached.1-4-14)
+ [Parameter yang didukung Memcached 1.4.5](#ParameterGroups.Memcached.1-4-5)
+ [Overhead koneksi Memcached](#ParameterGroups.Memcached.Overhead)
+ [Parameter khusus jenis simpul Memcached](#ParameterGroups.Memcached.NodeSpecific)
### Perubahan Memcached 1.6.17
Mulai Memcached 1.6.17, kami tidak lagi mendukung perintah administratif ini: `lru_crawler`, `lru`, dan `slabs`. Dengan perubahan ini, Anda tidak akan dapat enable/disable `lru_crawler` saat runtime melalui perintah. Silakan enable/disable `lru_crawler` dengan memodifikasi grup parameter kustom Anda.
### Parameter yang ditambahkan di Memcached 1.6.6
Untuk Memcached 1.6.6, tidak ada parameter tambahan yang didukung.
**Keluarga grup parameter:** memcached1.6
### Perubahan parameter Memcached 1.5.10
Untuk Memcached 1.5.10, parameter tambahan berikut didukung.
**Keluarga grup parameter:** memcached1.5
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| no\$1modern | Default: 1 Jenis: boolean Dapat diubah: Ya Nilai yang Diizinkan: 0,1 Perubahan Berlaku: Saat peluncuran | Alias untuk menonaktifkan`slab_reassign`,, `lru_maintainer_thread``lru_segmented`, dan perintah. `maxconns_fast` Saat menggunakan Memcached 1.5 dan yang lebih tinggi, atur `no_modern` juga hash\$1algorithm ke. `jenkins` Selain itu, saat menggunakan Memcached 1.5.10, dikendalikan `inline_ascii_reponse` oleh parameter. `parallelly` Ini berarti bahwa jika `no_modern` dinonaktifkan maka `inline_ascii_reponse` dinonaktifkan. Dari mesin Memcached 1.5.16 dan seterusnya `inline_ascii_response` parameter tidak lagi berlaku, jadi `no_modern` dinonaktifkan atau dinonaktifkan tidak berpengaruh pada. `inline_ascii_reponse` Jika `no_modern` dinonaktifkan, maka `slab_reassign``lru_maintainer_thread`,`lru_segmented`,, dan `maxconns_fast` AKAN diaktifkan. Karena `slab_automove` dan `hash_algorithm` parameter bukan parameter SWITCH, pengaturannya didasarkan pada konfigurasi dalam grup parameter. Jika Anda ingin menonaktifkan `no_modern` dan kembali ke`modern`, Anda harus mengonfigurasi grup parameter khusus untuk menonaktifkan parameter ini dan kemudian reboot agar perubahan ini diterapkan. Nilai konfigurasi default untuk parameter ini telah diubah dari 0 ke 1 mulai 20 Agustus 2021. Nilai default yang diperbarui akan diambil secara otomatis oleh ElastiCache pengguna baru untuk setiap wilayah setelah 20 Agustus 2021. ElastiCache Pengguna yang ada di wilayah sebelum 20 Agustus 2021 perlu memodifikasi grup parameter khusus mereka secara manual untuk mengambil perubahan baru ini. |
| inline\$1ascii\$1resp | Default: 0 Jenis: boolean Dapat diubah: Ya Nilai yang Diizinkan: 0,1 Perubahan Berlaku: Saat peluncuran | Menyimpan angka dari respons `VALUE`, dalam item, menggunakan hingga 24 byte. Perlambatan kecil untuk `get` ASCII, `faster` ditetapkan. |
Untuk Memcached 1.5.10, parameter berikut dihapus.
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| expirezero\$1does\$1not\$1evict | Default: 0 Jenis: boolean Dapat diubah: Ya Nilai yang Diizinkan: 0,1 Perubahan Berlaku: Saat peluncuran | Tidak lagi didukung di versi ini. |
| modern | Default: 1 Jenis: boolean Dapat Diubah: Ya (memerlukan peluncuran ulang jika diatur ke `no_modern`) Nilai yang Diizinkan: 0,1 Perubahan Berlaku: Saat peluncuran | Tidak lagi didukung di versi ini. Dimulai dari versi ini, `no-modern` diaktifkan secara default pada setiap peluncuran atau peluncuran ulang. |
### Parameter yang ditambahkan di Memcached 1.4.34
Untuk Memcached 1.4.34, tidak ada parameter tambahan yang didukung.
**Keluarga grup parameter:** memcached1.4
### Parameter yang ditambahkan di Memcached 1.4.33
Untuk Memcached 1.4.33, parameter tambahan berikut didukung.
**Keluarga grup parameter:** memcached1.4
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| modern | Default: diaktifkan Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Saat peluncuran | Alias untuk beberapa fitur. Pengaktifan `modern` setara dengan mengaktifkan perintah berikut dan menggunakan algoritma hash murmur3: `slab_reassign`, `slab_automove`, `lru_crawler`, `lru_maintainer`, `maxconns_fast`, dan `hash_algorithm=murmur3`. |
| watch | Default: diaktifkan Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Segera Log dapat dihapus jika pengguna mencapai batas `watcher_logbuf_size` dan `worker_logbuf_size` mereka. | Pengambilan, pengosongan, dan mutasi log. Ketika, misalnya, pengguna mengaktifkan `watch`, mereka dapat melihat log saat `get`, `set`, `delete`, atau `update` terjadi. |
| idle\$1timeout | Default: 0 (dinonaktifkan) Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Saat Peluncuran | Jumlah minimum detik saat klien akan diizinkan untuk idle sebelum diminta agar ditutup. Rentang nilai: 0 hingga 86400. |
| track\$1sizes | Default: dinonaktifkan Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Saat Peluncuran | Menunjukkan ukuran setiap grup slab yang telah dikonsumsi. Pengaktifan `track_sizes` memungkinkan Anda menjalankan `stats sizes` tanpa perlu menjalankan `stats sizes_enable`. |
| watcher\$1logbuf\$1size | Default: 256 (KB) Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Saat Peluncuran | Perintah `watch` mengaktifkan pencatatan log stream untuk Memcached. Namun `watch` dapat menghapus log jika tingkat pengosongan, mutasi, atau pengambilan cukup tinggi untuk menyebabkan buffer pencatatan log menjadi penuh. Dalam situasi tersebut, pengguna dapat meningkatkan ukuran buffer untuk mengurangi kemungkinan kehilangan log. |
| worker\$1logbuf\$1size | Default: 64 (KB) Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Saat Peluncuran | Perintah `watch` mengaktifkan pencatatan log stream untuk Memcached. Namun `watch` dapat menghapus log jika tingkat pengosongan, mutasi, atau pengambilan cukup tinggi untuk menyebabkan buffer pencatatan log menjadi penuh. Dalam situasi tersebut, pengguna dapat meningkatkan ukuran buffer untuk mengurangi kemungkinan kehilangan log. |
| slab\$1chunk\$1max | Default: 524288 (byte) Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Saat Peluncuran | Menentukan ukuran maksimum slab. Mengatur ukuran slab lebih kecil membuat penggunaan memori lebih efisien. Item yang lebih besar dari `slab_chunk_max` akan dibagi menjadi beberapa slab. |
| lru\$1crawler metadump [all\$11\$12\$13] | Default: dinonaktifkan Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Segera | jika lru\$1crawler diaktifkan, perintah ini menghapus semua kunci. `all\|1\|2\|3` - semua slab, atau tentukan nomor slab tertentu |
### Parameter yang ditambahkan di Memcached 1.4.24
Untuk Memcached 1.4.24, parameter tambahan berikut didukung.
**Keluarga grup parameter:** memcached1.4
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| disable\$1flush\$1all | Default: 0 (dinonaktifkan) Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Saat peluncuran | Tambahkan parameter (`-F`) untuk menonaktifkan flush\$1all. Berguna jika Anda tidak ingin dapat menjalankan flush penuh pada instans produksi. Nilai: 0, 1 (pengguna dapat melakukan `flush_all` jika nilai adalah 0). |
| hash\$1algorithm | Default: jenkins Jenis: string Dapat diubah: Ya Perubahan Berlaku: Saat peluncuran | Algoritma hash yang akan digunakan. Nilai yang diizinkan: murmur3 dan jenkins. |
| lru\$1crawler | Default: 0 (dinonaktifkan) Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Setelah mulai ulang Anda dapat mengaktifkan `lru_crawler` untuk sementara pada saat runtime dari baris perintah. Untuk informasi selengkapnya, lihat kolom Deskripsi. | Membersihkan kelas slab item yang telah kedaluwarsa. Ini adalah proses berdampak rendah yang berjalan di latar belakang. Saat ini memerlukan inisiasi perayapan menggunakan perintah manual. Untuk mengaktifkan sementara, jalankan `lru_crawler enable` di baris perintah. `lru_crawler 1,3,5` merayapi kelas slab 1, 3, 5 dengan mencari item yang kedaluwarsa untuk ditambahkan ke daftar bebas. Nilai: 0,1 Mengaktifkan `lru_crawler` pada baris perintah akan mengaktifkan perayap hingga dinonaktifkan pada baris perintah atau boot ulang berikutnya. Untuk mengaktifkan secara permanen, Anda harus mengubah nilai parameter. Untuk informasi selengkapnya, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md). |
| lru\$1maintainer | Default: 0 (dinonaktifkan) Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Saat peluncuran | Benang latar belakang yang mengacak item di antara kapasitas LRUs as tercapai. Nilai: 0, 1. |
| expirezero\$1does\$1not\$1evict | Default: 0 (dinonaktifkan) Jenis: boolean Dapat diubah: Ya Perubahan Berlaku: Saat peluncuran | Ketika digunakan dengan `lru_maintainer`, menjadikan item yang memiliki waktu kedaluwarsa 0 tidak dapat dikosongkan. Hal ini dapat memenuhi memori yang tersedia untuk item lainnya yang dapat dikosongkan. Dapat diatur untuk mengabaikan `lru_maintainer`. |
### Parameter yang ditambahkan di Memcached 1.4.14
Untuk Memcached 1.4.14, parameter tambahan berikut didukung.
**Keluarga grup parameter:** memcached1.4
**Parameter yang ditambahkan dalam Memcached 1.4.14**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| config\$1max | Default: 16 Jenis: integer Dapat Diubah: Tidak | Jumlah maksimum entri ElastiCache konfigurasi. |
| config\$1size\$1max | Default: 65536 Jenis: integer Dapat diubah: Tidak | Ukuran maksimum entri konfigurasi, dalam byte. |
| hashpower\$1init | Default: 16 Jenis: integer Dapat Diubah: Tidak | Ukuran awal tabel ElastiCache hash, dinyatakan sebagai kekuatan dua. Default-nya adalah 16 (2^16), atau 65536 kunci. |
| maxconns\$1fast | Default: 0 (salah) Jenis: Boolean Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Mengubah cara permintaan koneksi baru ditangani ketika batas koneksi maksimum tercapai. Jika parameter ini diatur ke 0 (nol), koneksi baru ditambahkan ke antrean backlog dan akan menunggu sampai koneksi lain ditutup. Jika parameter diatur ke 1, ElastiCache mengirimkan kesalahan ke klien dan segera menutup koneksi. |
| slab\$1automove | Default: 0 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Menyesuaikan algoritma automove slab: Jika parameter ini diatur ke 0 (nol), algoritma automove dinonaktifkan. Jika diatur ke 1, ElastiCache membutuhkan pendekatan konservatif yang lambat untuk memindahkan slab secara otomatis. Jika diatur ke 2, gerakkan lempengan ElastiCache secara agresif setiap kali ada penggusuran. (Mode ini tidak direkomendasikan kecuali untuk tujuan pengujian.) |
| slab\$1reassign | Default: 0 (salah) Jenis: Boolean Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Mengaktifkan atau menonaktifkan penetapan ulang slab. Jika parameter ini diatur ke 1, Anda dapat menggunakan perintah "slab reassign" untuk secara manual menetapkan ulang memori. |
### Parameter yang didukung Memcached 1.4.5
**Keluarga grup parameter:** memcached1.4
Untuk Memcached 1.4.5, parameter tambahan berikut didukung.
**Parameter yang ditambahkan di Memcached 1.4.5**
| Nama | Detail | Deskripsi |
| --- | --- | --- |
| backlog\$1queue\$1limit | Default: 1024 Jenis: integer Dapat diubah: Tidak | Batas antrean backlog. |
| binding\$1protocol | Default: otomatis Jenis: string Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Protokol pengikatan. Nilai yang diizinkan adalah `ascii` dan `auto`. Untuk panduan dalam mengubah nilai `binding_protocol`, lihat [Memodifikasi grup ElastiCache parameter](ParameterGroups.Modifying.md). |
| cas\$1disabled | Default: 0 (salah) Jenis: Boolean Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Jika 1 (benar), operasi periksa dan atur (CAS) akan dinonaktifkan, dan item yang disimpan akan menggunakan 8 byte lebih sedikit dibandingkan dengan CAS diaktifkan. |
| chunk\$1size | Default: 48 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Jumlah minimum, dalam byte, ruang untuk mengalokasikan kunci, nilai, dan bendera item terkecil. |
| chunk\$1size\$1growth\$1factor | Default: 1,25 Jenis: float Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Faktor pertumbuhan yang mengontrol ukuran setiap potongan Memcached berturut-turut; setiap potongan akan chunk\$1size\$1growth\$1factor kali lebih besar dari potongan sebelumnya. |
| error\$1on\$1memory\$1exhausted | Default: 0 (salah) Jenis: Boolean Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Jika 1 (benar), ketika tidak ada lagi memori untuk menyimpan item, Memcached akan menampilkan kesalahan dan bukan mengosongkan item. |
| large\$1memory\$1pages | Default: 0 (salah) Jenis: Boolean Dapat diubah: Tidak | Jika 1 (true), ElastiCache akan mencoba untuk menggunakan halaman memori besar. |
| lock\$1down\$1paged\$1memory | Default: 0 (salah) Jenis: Boolean Dapat diubah: Tidak | Jika 1 (true), ElastiCache akan mengunci semua memori halaman. |
| max\$1item\$1size | Default: 1048576 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Ukuran, dalam byte, item terbesar yang dapat disimpan dalam klaster. |
| max\$1simultaneous\$1connections | Default: 65000 Jenis: integer Dapat diubah: Tidak | Jumlah maksimum koneksi bersamaan. |
| maximize\$1core\$1file\$1limit | Default: 0 (salah) Jenis: Boolean Dapat diubah: Perubahan Berlaku: Setelah pengaktifan ulang | Jika 1 (true), ElastiCache akan memaksimalkan batas file inti. |
| memcached\$1connections\$1overhead | Default: 100 Jenis: integer Dapat diubah: Ya Perubahan Berlaku: Setelah pengaktifan ulang | Jumlah memori yang akan dicadangkan untuk koneksi Memcached dan berbagai overhead lainnya. Untuk informasi tentang parameter ini, lihat [Overhead koneksi Memcached](#ParameterGroups.Memcached.Overhead). |
| requests\$1per\$1event | Default: 20 Jenis: integer Dapat diubah: Tidak | Jumlah maksimum permintaan per peristiwa untuk koneksi tertentu. Batas ini diperlukan untuk mencegah kekurangan sumber daya. |
### Overhead koneksi Memcached
Pada setiap simpul, memori yang tersedia untuk menyimpan item adalah total memori yang tersedia pada simpul tersebut (yang disimpan dalam parameter `max_cache_memory`) dikurangi memori yang digunakan untuk koneksi dan overhead lainnya (yang disimpan dalam parameter `memcached_connections_overhead`). Misalnya, sebuah simpul jenis `cache.m1.small` memiliki `max_cache_memory` sebesar 1.300 MB. Dengan nilai `memcached_connections_overhead` default 100 MB, proses Memcached akan memiliki 1.200 MB yang tersedia untuk menyimpan item.
Nilai default untuk parameter `memcached_connections_overhead` memenuhi sebagian besar kasus penggunaan; namun, jumlah alokasi yang diperlukan untuk overhead koneksi dapat bervariasi bergantung pada beberapa faktor, termasuk tingkat permintaan, ukuran muatan, dan jumlah koneksi.
Anda dapat mengubah nilai `memcached_connections_overhead` agar lebih sesuai dengan kebutuhan aplikasi Anda. Misalnya, peningkatan nilai parameter `memcached_connections_overhead` akan mengurangi jumlah memori yang tersedia untuk menyimpan item dan memberikan buffer yang lebih besar untuk overhead koneksi. Pengurangan nilai parameter `memcached_connections_overhead` akan memberi Anda lebih banyak memori untuk menyimpan item, tetapi dapat meningkatkan risiko penggunaan swap dan penurunan performa. Jika Anda melihat penggunaan swap dan penurunan performa, coba tingkatkan nilai parameter `memcached_connections_overhead`.
**penting**
Untuk jenis simpul `cache.t1.micro`, nilai untuk `memcached_connections_overhead` ditentukan sebagai berikut:
Jika cluster Anda menggunakan grup parameter default, ElastiCache akan menetapkan nilai `memcached_connections_overhead` untuk 13MB.
Jika klaster menggunakan grup parameter yang telah Anda buat sendiri, nilai `memcached_connections_overhead` dapat diatur ke nilai pilihan Anda.
### Parameter khusus jenis simpul Memcached
Meskipun sebagian besar parameter memiliki nilai tunggal, beberapa parameter memiliki nilai yang berbeda-beda bergantung pada jenis simpul yang digunakan. Tabel berikut menunjukkan nilai default untuk parameter `max_cache_memory` dan `num_threads` untuk tiap jenis simpul. Nilai pada parameter ini tidak dapat diubah.
| Jenis simpul | max\$1cache\$1memory (dalam megabyte) | num\$1threads |
| --- | --- | --- |
| cache.t1.micro | 213 | 1 |
| cache.t2.micro | 555 | 1 |
| cache.t2.small | 1588 | 1 |
| cache.t2.medium | 3301 | 2 |
| cache.t3.micro | 512 | 2 |
| cache.t3.small | 1402 | 2 |
| cache.t3.medium | 3364 | 2 |
| cache.t4g.micro | 512 | 2 |
| cache.t4g.small | 1402 | 2 |
| cache.t4g.medium | 3164 | 2 |
| cache.m1.small | 1301 | 1 |
| cache.m1.medium | 3350 | 1 |
| cache.m1.large | 7100 | 2 |
| cache.m1.xlarge | 14600 | 4 |
| cache.m2.xlarge | 33800 | 2 |
| cache.m2.2xlarge | 30412 | 4 |
| cache.m2.4xlarge | 68000 | 16 |
| cache.m3.medium | 2850 | 1 |
| cache.m3.large | 6200 | 2 |
| cache.m3.xlarge | 13600 | 4 |
| cache.m3.2xlarge | 28600 | 8 |
| cache.m4.large | 6573 | 2 |
| cache.m4.xlarge | 11496 | 4 |
| cache.m4.2xlarge | 30412 | 8 |
| cache.m4.4xlarge | 62234 | 16 |
| cache.m4.10xlarge | 158355 | 40 |
| cache.m5.large | 6537 | 2 |
| cache.m5.xlarge | 13248 | 4 |
| cache.m5.2xlarge | 26671 | 8 |
| cache.m5.4xlarge | 53516 | 16 |
| cache.m5.12xlarge | 160900 | 48 |
| cache.m5.24xlarge | 321865 | 96 |
| cache.m6g.large | 6537 | 2 |
| cache.m6g.xlarge | 13248 | 4 |
| cache.m6g.2xlarge | 26671 | 8 |
| cache.m6g.4xlarge | 53516 | 16 |
| cache.m6g.8xlarge | 107000 | 32 |
| cache.m6g.12xlarge | 160900 | 48 |
| cache.m6g.16xlarge | 214577 | 64 |
| cache.c1.xlarge | 6600 | 8 |
| cache.r3.large | 13800 | 2 |
| cache.r3.xlarge | 29100 | 4 |
| cache.r3.2xlarge | 59600 | 8 |
| cache.r3.4xlarge | 120600 | 16 |
| cache.r3.8xlarge | 120600 | 32 |
| cache.r4.large | 12590 | 2 |
| cache.r4.xlarge | 25652 | 4 |
| cache.r4.2xlarge | 51686 | 8 |
| cache.r4.4xlarge | 103815 | 16 |
| cache.r4.8xlarge | 208144 | 32 |
| cache.r4.16xlarge | 416776 | 64 |
| cache.r5.large | 13387 | 2 |
| cache.r5.xlarge | 26953 | 4 |
| cache.r5.2xlarge | 54084 | 8 |
| cache.r5.4xlarge | 108347 | 16 |
| cache.r5.12xlarge | 325400 | 48 |
| cache.r5.24xlarge | 650869 | 96 |
| cache.r6g.large | 13387 | 2 |
| cache.r6g.xlarge | 26953 | 4 |
| cache.r6g.2xlarge | 54084 | 8 |
| cache.r6g.4xlarge | 108347 | 16 |
| cache.r6g.8xlarge | 214577 | 32 |
| cache.r6g.12xlarge | 325400 | 48 |
| cache.r6g.16xlarge | 429154 | 64 |
| cache.c7gn.large | 3164 | 2 |
| cache.c7gn.xlarge | 6537 | 4 |
| cache.c7gn.2xlarge | 13248 | 8 |
| cache.c7gn.4xlarge | 26671 | 16 |
| cache.c7gn.8xlarge | 53516 | 32 |
| cache.c7gn.12xlarge | 325400 | 48 |
| cache.c7gn.16xlarge | 108347 | 64 |
**catatan**
Semua instans T2 dibuat di Amazon Virtual Private Cloud (Amazon VPC).
# Menghubungkan EC2 instance dan ElastiCache cache secara otomatis
Anda dapat menggunakan ElastiCache konsol untuk menyederhanakan pengaturan koneksi antara instans Amazon Elastic Compute Cloud EC2 (Amazon) dan cache. ElastiCache Seringkali, cache Anda berada di subnet pribadi dan EC2 instance Anda berada di subnet publik dalam VPC. Anda dapat menggunakan klien SQL pada EC2 instance Anda untuk terhubung ke ElastiCache cache Anda. EC2 Instance ini juga dapat menjalankan server web atau aplikasi yang mengakses ElastiCache cache pribadi Anda.
![\[Secara otomatis menghubungkan ElastiCache cache dengan sebuah EC2 instance.\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ec2-elasticache-connect-network_diagram.png)
**Topics**
+ [Konektivitas otomatis dengan sebuah EC2 instance](#ec2-elc-connect-overview)
+ [Melihat sumber daya komputasi terhubung](#ec2-elc-connect-viewing)
## Konektivitas otomatis dengan sebuah EC2 instance
Ketika Anda mengatur koneksi antara EC2 instance dan ElastiCache cache, ElastiCache secara otomatis mengkonfigurasi grup keamanan VPC untuk instance EC2 Anda dan untuk ElastiCache cache Anda.
Berikut ini adalah persyaratan untuk menghubungkan EC2 instance dengan ElastiCache cache:
+ EC2 Instance harus ada di VPC yang sama dengan cache. ElastiCache
Jika tidak ada EC2 instance di VPC yang sama, maka konsol menyediakan tautan untuk membuatnya.
+ Pengguna yang mengatur konektivitas harus memiliki izin untuk melakukan EC2 operasi Amazon berikut. Permisiosn ini umumnya ditambahkan ke EC2 akun saat dibuat. Untuk informasi selengkapnya tentang EC2 izin, lihat [Memberikan izin yang diperlukan untuk sumber daya Amazon](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/ec2-api-permissions.html). EC2
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateSecurityGroup`
+ `ec2:DescribeInstances`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:ModifyNetworkInterfaceAttribute`
+ `ec2:RevokeSecurityGroupEgress`
Saat Anda mengatur sambungan ke EC2 instance, ElastiCache bertindak sesuai dengan konfigurasi grup keamanan saat ini yang terkait dengan ElastiCache cache dan EC2 instance, seperti yang dijelaskan dalam tabel berikut.
****
| Konfigurasi grup ElastiCache keamanan saat ini | Konfigurasi grup EC2 keamanan saat ini | ElastiCache aksi |
| --- | --- | --- |
| Ada satu atau lebih grup keamanan yang terkait dengan ElastiCache cache dengan nama yang cocok dengan pola`elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan yang cocok dengan pola belum diubah. Grup keamanan ini hanya memiliki satu aturan masuk dengan grup keamanan VPC dari instance sebagai EC2 sumbernya. | Ada satu atau lebih grup keamanan yang terkait dengan EC2 instance dengan nama yang cocok dengan pola`elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan yang cocok dengan pola belum diubah. Grup keamanan ini hanya memiliki satu aturan keluar dengan grup keamanan VPC cache sebagai ElastiCache sumbernya. | ElastiCache tidak mengambil tindakan. Koneksi sudah dikonfigurasi secara otomatis antara EC2 instance dan ElastiCache cache. Karena koneksi sudah ada antara EC2 instance dan ElastiCache cache, grup keamanan tidak dimodifikasi. |
| Salah satu syarat berikut berlaku: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/compute-connection.html) | Salah satu syarat berikut dipenuhi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/compute-connection.html) | [ELC action: create new security groups](#elc-action-create-new-security-groups) |
| Ada satu atau lebih grup keamanan yang terkait dengan ElastiCache cache dengan nama yang cocok dengan pola`elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan yang cocok dengan pola belum diubah. Grup keamanan ini hanya memiliki satu aturan masuk dengan grup keamanan VPC dari instance sebagai EC2 sumbernya. | Ada satu atau lebih grup keamanan yang terkait dengan EC2 instance dengan nama yang cocok dengan pola`elasticache-ec2-${cacheId}:${ec2InstanceId}`. Namun, tidak ElastiCache dapat menggunakan salah satu grup keamanan ini untuk koneksi dengan ElastiCache cache. ElastiCache tidak dapat menggunakan grup keamanan yang tidak memiliki satu aturan keluar dengan grup keamanan VPC cache sebagai ElastiCache sumbernya. ElastiCache juga tidak dapat menggunakan grup keamanan yang telah dimodifikasi. | [ELC action: create new security groups](#elc-action-create-new-security-groups) |
| Ada satu atau lebih grup keamanan yang terkait dengan ElastiCache cache dengan nama yang cocok dengan pola`elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan yang cocok dengan pola belum diubah. Grup keamanan ini hanya memiliki satu aturan masuk dengan grup keamanan VPC dari instance sebagai EC2 sumbernya. | Grup EC2 keamanan yang valid untuk koneksi ada, tetapi tidak terkait dengan EC2 instance. Grup keamanan ini memiliki nama yang cocok dengan pola `ec2-elasticache-${ec2InstanceId}:${cacheId}`. Grup tersebut belum diubah. Ini hanya memiliki satu aturan keluar dengan grup keamanan VPC cache sebagai theElastiCache sumbernya. | [ELC action: associate EC2 security group](#elc-action-associate-ec2-security-group) |
| Salah satu syarat berikut berlaku: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/compute-connection.html) | Ada satu atau lebih grup keamanan yang terkait dengan EC2 instance dengan nama yang cocok dengan pola`ec2-elasticache-${ec2InstanceId}:${cacheId}`. Grup keamanan yang cocok dengan pola belum diubah. Grup keamanan ini hanya memiliki satu aturan keluar dengan grup keamanan VPC cache sebagai ElastiCache sumbernya. | [ELC action: create new security groups](#elc-action-create-new-security-groups) |
**ElastiCachetindakan: buat grup keamanan baru**
ElastiCache mengambil tindakan berikut:
+ Membuat grup keamanan baru yang cocok dengan pola `elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan ini memiliki aturan masuk dengan grup keamanan VPC dari instance sebagai EC2 sumbernya. Grup keamanan ini dikaitkan dengan ElastiCache cache dan memungkinkan EC2 instance untuk mengaksesnya.
+ Membuat grup keamanan baru yang cocok dengan pola `elasticache-ec2-${cacheId}:${ec2InstanceId}`. Grup keamanan ini memiliki aturan keluar dengan grup keamanan VPC cache sebagai target. ElastiCache Grup keamanan ini dikaitkan dengan EC2 instance dan memungkinkan EC2 instance untuk mengirim lalu lintas ke ElastiCache cache.
**ElastiCache tindakan: kelompok EC2 keamanan asosiasi**
ElastiCachemengaitkan grup EC2 keamanan yang valid dan sudah ada dengan EC2 instance. Grup keamanan ini memungkinkan EC2 instance untuk mengirim lalu lintas ke ElastiCache cache.
## Melihat sumber daya komputasi terhubung
Anda dapat menggunakan Konsol Manajemen AWS untuk melihat sumber daya komputasi yang terhubung ke ElastiCache cache. Sumber daya yang ditampilkan meliputi koneksi sumber daya komputasi yang disiapkan secara otomatis. Misalnya, Anda dapat mengizinkan sumber daya komputasi untuk mengakses cache secara manual dengan menambahkan aturan ke grup keamanan VPC yang terkait dengan cache. Sumber daya ini tidak akan muncul dalam daftar sumber daya komputasi yang terhubung.
Agar sumber daya komputasi dicantumkan, kondisi yang sama harus diterapkan seperti saat menghubungkan EC2 instance dan ElastiCache cache secara otomatis.
**Untuk melihat sumber daya komputasi yang terhubung ke cache ElastiCache**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol
1. Di panel navigasi, pilih **Cache, lalu pilih cache** Valkey atau Redis OSS.
1. Pada tab **Konektivitas & keamanan**, lihat sumber daya komputasi di Koneksi **Mengatur komputasi**.
![\[Sumber daya komputasi terhubung.\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ec2-elasticache-connected_resources.png)
# Penskalaan ElastiCache
Anda dapat menskalakan ElastiCache cache Anda sesuai dengan kebutuhan Anda. Cache tanpa server dan cluster berbasis node menawarkan beberapa opsi penskalaan yang berbeda.
## Penskalaan Tanpa Server ElastiCache
ElastiCache Tanpa server secara otomatis mengakomodasi lalu lintas beban kerja Anda saat naik atau turun. Untuk setiap cache ElastiCache Tanpa Server, ElastiCache terus melacak pemanfaatan sumber daya seperti CPU, memori, dan jaringan. Ketika salah satu sumber daya ini dibatasi, ElastiCache Serverless menskalakan dengan menambahkan pecahan baru dan mendistribusikan ulang data ke pecahan baru, tanpa waktu henti apa pun ke aplikasi Anda. Anda dapat memantau sumber daya yang dikonsumsi oleh cache Anda CloudWatch dengan memantau `BytesUsedForCache` metrik untuk penyimpanan data cache dan `ElastiCacheProcessingUnits` (ECPU) untuk penggunaan komputasi.
## Menetapkan batas penskalaan untuk mengelola biaya
Anda dapat memilih untuk mengonfigurasi penggunaan maksimum pada penyimpanan data cache dan cache Anda ECPU/second untuk mengontrol biaya cache. Tindakan ini akan memastikan bahwa penggunaan cache Anda tidak pernah melebihi jumlah maksimum yang dikonfigurasi.
Jika Anda menetapkan penskalaan maksimum maka aplikasi Anda mungkin mengalami penurunan kinerja cache saat cache mencapai maksimum. Ketika Anda mengatur penyimpanan data cache maksimum dan penyimpanan data cache Anda mencapai maksimum, ElastiCache akan mulai mengusir data dalam cache Anda yang memiliki set Time-To-Live (TTL), menggunakan logika LRU. Jika tidak ada data yang dapat dikosongkan, maka permintaan untuk menulis data tambahan akan menerima pesan kesalahan Out Of Memory (OOM). Bila Anda menetapkan ECPU/second maksimum dan penggunaan komputasi beban kerja Anda melebihi nilai ini, ElastiCache akan mulai membatasi permintaan.
Jika Anda mengatur batas maksimum pada `BytesUsedForCache` atau`ElastiCacheProcessingUnits`, kami sangat menyarankan untuk menyiapkan CloudWatch alarm pada nilai yang lebih rendah dari batas maksimum sehingga Anda diberi tahu saat cache Anda beroperasi mendekati batas ini. Sebaiknya atur alarm pada 75% dari batas maksimum yang Anda tetapkan. Lihat dokumentasi tentang cara mengatur CloudWatch alarm.
## Pra-penskalaan dengan Tanpa Server ElastiCache
**ElastiCache Pra-penskalaan tanpa server**
Dengan pra-penskalaan, juga disebut pra-pemanasan, Anda dapat menetapkan batas minimum yang didukung untuk cache Anda. ElastiCache Anda dapat mengatur minimum ini untuk Unit ElastiCache Pemrosesan (ECPUs) per detik atau penyimpanan data. Ini dapat berguna dalam persiapan untuk acara penskalaan yang diantisipasi. Misalnya, jika perusahaan game mengharapkan peningkatan 5x dalam login dalam menit pertama game baru mereka diluncurkan, mereka dapat menyiapkan cache mereka untuk lonjakan penggunaan yang signifikan ini.
Anda dapat melakukan pra-penskalaan menggunakan ElastiCache konsol, CLI, atau API. ElastiCache Tanpa server memperbarui yang tersedia ECPUs/second di cache dalam waktu 60 menit, dan mengirimkan pemberitahuan acara ketika pembaruan batas minimum selesai.
**Cara kerja pra-penskalaan**
Ketika batas minimum untuk ECPUs/second atau penyimpanan data diperbarui melalui konsol, CLI, atau API, batas baru itu tersedia dalam 1 jam. ElastiCache Tanpa server mendukung 30K ECPUs/second pada cache kosong, dan hingga 90K ECPUs/sec saat menggunakan fitur Baca dari Replika. ElastiCache Tanpa server untuk Valkey 8.0 dapat menggandakan permintaan per detik (RPS) yang didukung setiap 2-3 menit, mencapai 5M RPS per cache dari nol dalam waktu kurang dari 13 menit, dengan latensi baca p50 sub-milidetik yang konsisten. Jika Anda mengantisipasi bahwa acara penskalaan yang akan datang mungkin melebihi tingkat ini, maka sebaiknya atur minimum ECPUs/second ke puncak yang ECPUs/sec Anda harapkan setidaknya 60 menit sebelum acara puncak. Jika tidak, aplikasi mungkin mengalami peningkatan latensi dan pembatasan permintaan.
Setelah pembaruan batas minimum selesai, ElastiCache Tanpa Server akan mulai mengukur Anda untuk minimum baru ECPUs per detik atau penyimpanan minimum baru. Hal ini terjadi bahkan jika aplikasi Anda tidak mengeksekusi permintaan pada cache, atau jika penggunaan penyimpanan data Anda di bawah minimum. Saat Anda menurunkan batas minimum dari pengaturan saat ini, pembaruan segera dilakukan sehingga ElastiCache Tanpa Server akan segera mulai mengukur pada batas minimum yang baru.
**catatan**
Ketika Anda menetapkan batas penggunaan minimum, Anda dikenakan biaya untuk batas tersebut meskipun penggunaan aktual Anda lebih rendah dari batas penggunaan minimum. ECPU atau penggunaan penyimpanan data yang melebihi batas penggunaan minimum dikenakan tarif reguler. Misalnya, jika Anda menetapkan batas penggunaan minimum 100.000 ECPUs/second maka Anda akan dikenakan biaya setidaknya \$11,224 per jam (menggunakan harga ECPU di us-east-1), bahkan jika penggunaan Anda lebih rendah dari minimum yang ditetapkan.
ElastiCache Tanpa server mendukung skala minimum yang diminta pada tingkat agregat pada cache. ElastiCache Serverless juga mendukung maksimum 30K ECPUs/second per slot (90K ECPUs/second saat menggunakan Read from Replica menggunakan koneksi READONLY). Sebagai praktik terbaik, aplikasi Anda harus memastikan bahwa distribusi kunci di seluruh slot Valkey atau Redis OSS dan lalu lintas lintas kunci seragam mungkin.
## Mengatur batas penskalaan menggunakan konsol dan AWS CLI
*Menyetel batas penskalaan menggunakan Konsol AWS*
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi, pilih mesin yang berjalan pada cache yang ingin Anda modifikasi.
1. Daftar cache yang menjalankan mesin yang dipilih akan muncul.
1. Pilih cache yang akan diubah dengan memilih tombol radio di sebelah kiri nama cache.
1. Pilih **Tindakan**, lalu pilih **Ubah**.
1. Di bawah **batas Penggunaan**, tetapkan batas **Memori** atau **Komputasi** yang sesuai.
1. Klik **Pratinjau** perubahan lalu **Simpan** perubahan.
**Menetapkan batas penskalaan menggunakan AWS CLI**
Untuk mengubah batas penskalaan menggunakan CLI, gunakan modify-serverless-cache API.
**Linux:**
```
aws elasticache modify-serverless-cache --serverless-cache-name \
--cache-usage-limits 'DataStorage={Minimum=10,Maximum=100,Unit=GB}, ECPUPerSecond={Minimum=1000,Maximum=100000}'
```
**Windows:**
```
aws elasticache modify-serverless-cache --serverless-cache-name ^
--cache-usage-limits 'DataStorage={Minimum=10,Maximum=100,Unit=GB}, ECPUPerSecond={Minimum=1000,Maximum=100000}'
```
**Menghapus batas penskalaan menggunakan CLI**
Untuk menghapus batas penskalaan menggunakan CLI, atur parameter batas Minimum dan Maksimum ke 0.
**Linux:**
```
aws elasticache modify-serverless-cache --serverless-cache-name \
--cache-usage-limits 'DataStorage={Minimum=0,Maximum=0,Unit=GB}, ECPUPerSecond={Minimum=0,Maximum=0}'
```
**Windows:**
```
aws elasticache modify-serverless-cache --serverless-cache-name ^
--cache-usage-limits 'DataStorage={Minimum=0,Maximum=0,Unit=GB}, ECPUPerSecond={Minimum=0,Maximum=0}'
```
# Penskalaan cluster berbasis node
Jumlah data yang perlu diproses oleh aplikasi Anda jarang bersifat statis. Jumlahnya meningkat dan menurun sejalan dengan bisnis Anda yang bertumbuh atau mengalami fluktuasi permintaan yang normal. Jika cache Anda dikelola sendiri, Anda perlu menyediakan perangkat keras yang memadai untuk puncak permintaan. Hal ini dapat memakan banyak biaya. Dengan menggunakan Amazon, ElastiCache Anda dapat menskalakan untuk memenuhi permintaan saat ini, hanya membayar untuk apa yang Anda gunakan. ElastiCache memungkinkan Anda untuk menskalakan cache Anda agar sesuai dengan permintaan.
**catatan**
Jika cluster Valkey atau Redis OSS direplikasi di satu atau lebih Wilayah, maka Wilayah tersebut diskalakan secara berurutan. Saat meningkatkan, Wilayah sekunder diskalakan terlebih dahulu dan kemudian Wilayah primer. Saat menurunkan skala, Wilayah primer adalah yang pertama dan kemudian setiap Wilayah sekunder mengikuti.
Saat memperbarui versi mesin, urutannya adalah Wilayah sekunder dan kemudian Wilayah primer.
**Topics**
+ [Penskalaan sesuai permintaan untuk cluster Memcached](Scaling-self-designed.mem-heading.md)
+ [Penskalaan manual untuk cluster Memcached](Scaling.Memcached.manually.md)
+ [Penskalaan untuk cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](scaling-redis-classic.md)
+ [Menskalakan node replika untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Scaling.RedisReplGrps.md)
+ [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
# Penskalaan sesuai permintaan untuk cluster Memcached
ElastiCache untuk Memcached menawarkan layanan caching dalam memori yang dikelola sepenuhnya yang menyebarkan, mengoperasikan, dan menskalakan Memcached secara vertikal di cloud.AWS
**Penskalaan vertikal sesuai permintaan**
Dengan penskalaan vertikal, ElastiCache untuk Memcached menyediakan sistem caching memori terdistribusi berkinerja tinggi yang banyak digunakan untuk mempercepat aplikasi dinamis dengan mengurangi beban database. Ini menyimpan data dan objek dalam RAM, mengurangi kebutuhan untuk membaca dari sumber data eksternal.
Anda dapat menerapkan penskalaan vertikal ke cluster berbasis node yang ada serta yang baru. Ini dapat memberikan fleksibilitas dalam alokasi sumber daya, memungkinkan pengguna untuk secara efisien beradaptasi dengan perubahan beban kerja tanpa mengubah arsitektur cluster. Kemampuan untuk menskalakan ini meningkatkan kinerja dengan meningkatkan kapasitas cache selama periode permintaan tinggi, dan mengurangi untuk mengoptimalkan biaya selama periode permintaan rendah. Ini menyederhanakan operasi, menghilangkan kebutuhan untuk membuat cluster baru untuk menggeser kebutuhan sumber daya, dan memungkinkan respons cepat terhadap fluktuasi lalu lintas. Secara keseluruhan, penskalaan vertikal untuk cluster berbasis node Memcached dapat membantu meningkatkan efisiensi biaya, meningkatkan pemanfaatan sumber daya, dan bahkan memungkinkan pengguna mengubah jenis instance Memcached mereka. Semua memudahkan pengguna untuk menyelaraskan infrastruktur caching mereka dengan kebutuhan aplikasi yang sebenarnya.
**catatan**
Modifikasi tipe node hanya tersedia untuk cluster Memcached berbasis node dengan versi engine 1.5 atau yang lebih baru.
Penemuan Otomatis harus diaktifkan untuk memanfaatkan penskalaan vertikal.
## Menyiapkan penskalaan vertikal sesuai permintaan untuk cluster Memcached berbasis node
Anda dapat mengonfigurasi penskalaan vertikal sesuai permintaan untuk Memcached with`scale-config`, yang berisi dua parameter:
1. **ScaleIntervalMinutes:** Waktu (dalam hitungan menit) antara penskalaan batch selama proses upgrade Memcached
1. **ScalePercentage:** Persentase node untuk diskalakan secara bersamaan selama proses pemutakhiran Memcached
**Mengonversi tipe node Memcached yang ada ke cache yang dapat menskalakan secara vertikal melalui CLI**
Untuk mengonversi cluster berbasis node Memcached yang ada ke cache yang dapat menskalakan secara vertikal, Anda dapat menggunakan melalui CLI. `elasticache modify-cache-cluster`
```
aws elasticache modify-cache-cluster \
--cache-cluster-id \
--cache-node-type \
--scale-config \
--apply-immediately
```
**Menyiapkan penskalaan vertikal dengan CLI**
Untuk mengatur penskalaan vertikal untuk cluster Memcached berbasis node melalui CLI, gunakan dengan dan parameternya dan. `elasticache modify-cache-cluster` `scale-config` `ScalePercentage` `ScaleIntervalMinutes`
+ **scale-interval-minutes:** Ini menentukan waktu (dalam menit) antara batch penskalaan. Pengaturan ini dapat berkisar dari 2-30 menit. Jika tidak ada nilai yang ditentukan, nilai default 5 menit diterapkan.
+ **scale-percentage:** Ini menentukan persentase node untuk skala secara bersamaan di setiap batch. Pengaturan ini dapat berkisar dari 10-100. Pengaturan dibulatkan saat membagi, jadi misalnya jika hasilnya adalah 49,5 pengaturan 50 diterapkan. Jika tidak ada nilai yang ditentukan, nilai default 20 diterapkan.
Opsi konfigurasi ini akan memungkinkan Anda untuk menyempurnakan proses penskalaan sesuai dengan kebutuhan spesifik Anda, menyeimbangkan antara meminimalkan gangguan cluster dan mengoptimalkan kecepatan penskalaan. Parameter scale-config hanya akan berlaku untuk tipe engine Memcached dan akan diabaikan untuk mesin cache lainnya, memastikan kompatibilitas mundur dengan penggunaan API yang ada untuk cluster lain.
**Panggilan API**
```
aws elasticache modify-cache-cluster \
--cache-cluster-id \
--cache-node-type \
--scale-config '{
"ScalePercentage": 30,
"ScaleIntervalMinutes": 2
}'
--apply-immediately
```
**Hasil:**
Mengembalikan ID cluster dan perubahan yang tertunda.
```
{
"CacheCluster": {
"CacheNodeType": "old_insance_type",
...
...
"PendingModifiedValues": {
"CacheNodeType": "new_instance_type"
},
}
}
```
**Buat daftar pengaturan penskalaan vertikal cache Memcached Anda**
Anda dapat mengambil opsi penskalaan untuk cache Memcached Anda, dan melihat opsi mereka saat ini untuk penskalaan vertikal.
**Panggilan API**
```
aws elasticache list-allowed-node-type-modifications --cache-cluster-id
```
**Hasil:**
```
{
"ScaleUpModifications": [
"cache.x.xxxx",
"cache.x.xxxx"
],
"ScaleDownModifications": [
"cache.x.xxxx",
"cache.x.xxxx",
"cache.x.xxxx"
]
}
```
**Penskalaan vertikal untuk Memcached dengan Konsol Manajemen AWS**
Ikuti langkah-langkah berikut untuk menggunakannya Konsol Manajemen AWS untuk mengonversi cluster Memcached berbasis node menjadi cluster yang dapat diskalakan secara vertikal.
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pilih cluster Memcached untuk dikonversi.
1. Pilih tab **Modify**.
1. Buka bagian **Pengaturan cache**, dan pilih **jenis Node** yang diinginkan.
1. Pilih **Pratinjau perubahan**, dan tinjau perubahannya.
1. Pilih **Ubah**.
## Penskalaan horizontal otomatis untuk Memcached
ElastiCache sekarang terintegrasi dengan layanan AWS Application Auto Scaling (AAS) untuk menyertakan penskalaan horizontal otomatis untuk cluster Memcached. Anda dapat menentukan kebijakan penskalaan melalui layanan AWS Application Auto Scaling, dan secara otomatis menyesuaikan jumlah node dalam klaster Memcached sesuai kebutuhan, berdasarkan metrik atau jadwal yang telah ditentukan sebelumnya.
**catatan**
Penskalaan horizontal otomatis saat ini tidak tersedia di Wilayah Beijing dan Ningxia.
Ini adalah metode yang tersedia untuk secara otomatis menskalakan cluster berbasis node Anda secara horizontal.
+ **Penskalaan Terjadwal:** Penskalaan berdasarkan jadwal memungkinkan Anda mengatur jadwal penskalaan Anda sendiri untuk perubahan beban yang dapat diprediksi. Misalnya, setiap pekan lalu lintas ke aplikasi web Anda mulai meningkat pada hari Rabu, tetap tinggi pada hari Kamis, dan mulai berkurang pada hari Jumat. Anda dapat mengonfigurasi Auto Scaling untuk meningkatkan kapasitas pada hari Rabu dan mengurangi kapasitas pada hari Jumat.
+ **Pelacakan Target:** Dengan kebijakan penskalaan pelacakan target, Anda memilih metrik penskalaan dan menetapkan nilai target. Application Auto Scaling membuat dan mengelola CloudWatch alarm yang memicu kebijakan penskalaan dan menghitung penyesuaian penskalaan berdasarkan metrik dan nilai target. Kebijakan penskalaan menambah atau menghapus kapasitas yang diperlukan untuk menjaga metrik berada pada, atau mendekati, nilai target yang ditentukan.
**Cara mengatur penskalaan horizontal untuk cluster Memcached berbasis node melalui CLI**
Saat menskalakan horizontal klaster Memcached berbasis simpul, Anda dapat menggunakan kebijakan pelacakan target, kebijakan terjadwal, atau keduanya.
1. **Daftarkan sumber daya sebagai target yang dapat diskalakan**
Panggil `RegisterScalableTarget` API di AWS Application Auto Scaling untuk mendaftarkan target untuk dimensi yang dapat diskalakan. `elasticache:cache-cluster:Nodes`
**API: ApplicationAutoScaling. RegisterScalableTarget**
Masukan:
```
{
"ScalableDimension": "elasticache:cache-cluster:Nodes",
"ResourceId": "cache-cluster/test-cluster-1",
"ServiceNamespace": "elasticache",
"MinCapacity": 20,
"MaxCapacity": 50
}
```
1. **Membuat kebijakan penskalaan pelacakan Target**
Selanjutnya, Anda dapat membuat kebijakan penskalaan pelacakan target untuk sumber daya dengan memanggil API kebijakan penskalaan put.
1. **Metrik yang telah ditentukan**
Berikut ini adalah kebijakan yang menskalakan sepanjang dimensi Cache Node, menggunakan metrik yang telah ditentukan` ElastiCacheCPUUtilization`, ditetapkan pada 50 untuk cluster test-cluster-1. Saat menghapus node untuk scale-in, n node terakhir akan dihapus.
API: ApplicationAutoScaling. PutScalingPolicy
Masukan:
```
{
"PolicyName": "cpu50-target-tracking-scaling-policy",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 50,
"PredefinedMetricSpecification": {
"PredefinedMetricType": "ElastiCacheCPUUtilization"
},
"ScaleOutCooldown": 600,
"ScaleInCooldown": 600
},
"ServiceNamespace": "elasticache",
"ScalableDimension": "elasticache:cache-cluster:Nodes",
"ResourceId": "cache-cluster/test-cluster-1"
}
```
Output:
```
{
"PolicyARN": "arn:aws:autoscaling:us-west-2:012345678910:scalingPolicy:6d8972f3-efc8-437c-92d1-6270f29a66e7:resource/elasticache/cache-cluster/test-cluster-1:policyName/cpu50-target-tracking-scaling-policy",
"Alarms": [
{
"AlarmARN": "arn:aws:cloudwatch:us-west-2:012345678910:alarm:TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca",
"AlarmName": "TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca"
},
{
"AlarmARN": "arn:aws:cloudwatch:us-west-2:012345678910:alarm:TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmLow-1b437334-d19b-4a63-a812-6c67aaf2910d",
"AlarmName": "TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmLow-1b437334-d19b-4a63-a812-6c67aaf2910d"
}
]
}
```
1. **Metrik Kustom**
Anda juga dapat menyetel kebijakan penskalaan pada dimensi dengan menggunakan persentase kustom yang didasarkan pada metrik Cloudwatch.
Masukan:
```
{
"PolicyName": "cpu50-target-tracking-scaling-policy",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"CustomizedMetricSpecification": {
"Dimensions": [
{
"Name": "MyMetricDimension",
"Value": "DimensionValue"
}
],
"MetricName": "MyCustomMetric",
"Namespace": "MyNamespace",
"Statistic": "Average",
"Unit": "Percent"
},
"TargetValue": 40,
"ScaleOutCooldown": 600,
"ScaleInCooldown": 600
},
"ServiceNamespace": "elasticache",
"ScalableDimension": "elasticache:cache-cluster:Nodes",
"ResourceId": "cache-cluster/test-cluster-1"
}
```
1. **Tindakan Terjadwal**
Saat Anda perlu skala untuk acara tertentu dan kemudian menskalakan setelah acara, Anda dapat membuat dua tindakan terjadwal dengan memanggil `PutScheduledAction` API.
**Kebijakan 1: Penskalaan**
`at`Perintah dalam `--schedule` menjadwalkan tindakan yang akan dijalankan sekali pada tanggal dan waktu yang ditentukan di masa depan. Bidang jadwal juga mendukung laju (menit, jam, hari dll) dan cron (untuk ekspresi cron).
Pada tanggal dan waktu yang ditentukan, Application Auto Scaling memperbarui nilai `MinCapacity` dan `MaxCapacity`. Application Auto Scaling MinCapacity menskalakan untuk menempatkan node cache ke 70.
**API: ApplicationAutoScaling. PutScheduledAction**
Masukan:
```
{
"ResourceId": "elasticache:ache-cluster:test-cluster-1",
"ScalableDimension": "elasticache:cache-cluster:Nodes",
"ScalableTargetAction": {
"MaxCapacity": 100,
"MinCapacity": 70
},
"Schedule": "at(2020-05-20T17:05:00)",
"ScheduledActionName": "ScalingOutScheduledAction",
"ServiceNamespace": "elasticache",
}
```
**Kebijakan 2: Penskalaan**
Pada tanggal dan waktu yang ditentukan, Application Auto Scaling memperbarui tabel `MinCapacity` dan`MaxCapacity`, dan skala `MaxCapacity` untuk mengembalikan node cache ke 60.
**API: ApplicationAutoScaling. PutScheduledAction**
Masukan:
```
{
"ResourceId": "elasticache:cache-cluster:test-cluster-1",
"ScalableDimension": "elasticache:cache-cluster:Nodes",
"ScalableTargetAction": {
"MaxCapacity": 60,
"MinCapacity": 40
},
"Schedule": "at(2020-05-21T17:05:00)",
"ScheduledActionName": "ScalingInScheduledAction",
"ServiceNamespace": "elasticache",
}
```
1. **Lihat Aktivitas Penskalaan**
Anda dapat melihat aktivitas penskalaan menggunakan `DescribeScalingActivities` API.
**API: ApplicationAutoScaling. DescribeScalingActivities**
Output:
```
{
"ScalingActivities": [
{
"ScalableDimension": "elasticache:elasticache:DesiredCount",
"Description": "Setting desired count to 30.",
"ResourceId": "elasticache/cache-cluster/test-cluster-1",
"ActivityId": "4d759079-a31f-4d0c-8468-504c56e2eecf",
"StartTime": 1462574194.658,
"elasticacheNamespace": "elasticache",
"EndTime": 1462574276.686,
"Cause": "monitor alarm TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca in state ALARM triggered policy cpu50-target-tracking-scaling-policy",
"StatusMessage": "Failed to set desired count to 30",
"StatusCode": "Failed"
},
{
"ScalableDimension": "elasticache:elasticache:DesiredCount",
"Description": "Setting desired count to 25.",
"ResourceId": "elasticache/cache-cluster/test-cluster-1",
"ActivityId": "90aff0eb-dd6a-443c-889b-b809e78061c1",
"StartTime": 1462574254.223,
"elasticacheNamespace": "elasticache",
"EndTime": 1462574333.492,
"Cause": "monitor alarm TargetTracking-elasticache/cache-cluster/test-cluster-1-AlarmHigh-d4f0770c-b46e-434a-a60f-3b36d653feca in state ALARM triggered policy cpu50-target-tracking-scaling-policy",
"StatusMessage": "Successfully set desired count to 25. Change successfully fulfilled by elasticache.",
"StatusCode": "Successful"
}
]
}
```
1. **Edit/Hapus Kebijakan Penskalaan**
Anda dapat mengedit atau menghapus kebijakan dengan memanggil `PutScalingPolicy` API lagi, atau dengan memanggil `DeleteScalingPolicy` atau `DeleteScheduled` Tindakan.
1. **De-register target yang dapat diskalakan**
Anda dapat membatalkan pendaftaran target yang dapat diskalakan melalui API. `DeregisterScalableTarget` Membatalkan pendaftaran target yang dapat diskalakan akan menghapus kebijakan penskalaan dan tindakan terjadwal yang terkait dengannya.
**API: ApplicationAutoScaling. DeregisterScalableTarget**
Masukan:
```
{
"ResourceId": "elasticache/cache-cluster/test-cluster-1",
"ServiceNamespace": "elasticache",
"ScalableDimension": "elasticache:cache-cluster:Nodes"
}
```
1. **Pembersihan Kebijakan Penskalaan**
1. **Beberapa Kebijakan Penskalaan**
Anda dapat membuat beberapa kebijakan penskalaan. Berikut ini adalah info kunci tentang perilaku dari pelacakan [target penskalaan otomatis](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
+ Anda dapat memiliki beberapa kebijakan penskalaan pelacakan target untuk target yang dapat diskalakan, asalkan setiapnya menggunakan metrik yang berbeda.
+ Tujuan Application Auto Scaling adalah untuk selalu memprioritaskan ketersediaan, sehingga perilakunya berbeda tergantung pada apakah kebijakan pelacakan target siap untuk diperkecil atau diperbesar. Hal ini akan memperkecil skala target yang dapat diskala jika salah satu kebijakan pelacakan target siap untuk diperkecil skalanya, tetapi hanya akan memperbesar skala jika semua kebijakan pelacakan target (dengan penskalaan dalam porsi aktif) siap untuk diperbesar skalanya.
+ Jika beberapa kebijakan menginstruksikan target yang dapat diskalakan untuk memperbesar atau memperkecil skalanya di saat yang sama, Application Auto Scaling akan menskalakan berdasarkan kebijakan yang menyediakan kapasitas terbesar untuk pembesaran dan pengecilan skala. Hal ini memberikan fleksibilitas yang lebih besar untuk mencakup beberapa skenario dan memastikan bahwa selalu ada kapasitas yang cukup untuk memproses beban kerja aplikasi Anda.
**catatan**
AWS Application Auto Scaling tidak mengantri kebijakan penskalaan. Application Auto Scaling akan menunggu penskalaan pertama selesai, lalu cooldown, dan kemudian ulangi algoritma di atas.
**Secara otomatis menskalakan cluster Memcached berbasis node secara horizontal melalui Konsol Manajemen AWS**
Ikuti langkah-langkah berikut untuk menggunakan Konsol Manajemen AWS untuk mengonversi cluster Memcached berbasis node yang ada menjadi cluster yang dapat diskalakan secara horizontal.
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Pilih cache Memcached untuk dikonversi.
1. Buka tab **Autoscaling**.
1. Pilih kebijakan penskalaan yang akan diterapkan, dengan memilih Tambahkan **penskalaan dinamis atau Tambahkan penskalaan** **terjadwal**.
1. Isi detail untuk kebijakan yang dipilih sesuai kebutuhan.
1. Klik **Buat**.
# Penskalaan manual untuk cluster Memcached
Menskalakan cluster Memcached masuk atau keluar secara horizontal secara manual semudah menambahkan atau menghapus node dari cluster. Cluster memcache terdiri dari 1 hingga 60 node.
Karena Anda dapat mempartisi data di semua simpul dalam klaster Memcached, menaikkan skala ke jenis simpul dengan memori yang lebih besar jarang diperlukan. Namun, karena mesin Memcached tidak menyimpan data, jika Anda melakukan skala ke jenis node yang berbeda maka cluster baru Anda mulai kosong kecuali aplikasi Anda mengisinya.
Untuk menskalakan cluster Memcached secara manual secara vertikal, Anda harus membuat cluster baru. Klaster Memcached selalu dimulai dalam kondisi kosong kecuali jika aplikasi Anda mengisinya.
**Penskalaan cluster Memcached secara manual**
| Tindakan | Topik |
| --- | --- |
| Menskalakan ke luar | [Menambahkan simpul ke klaster](Clusters.html#AddNode) |
| Menskalakan ke dalam | [Menghapus simpul dari klaster](Clusters.html#DeleteNode) |
| Mengubah jenis simpul | [Menskalakan cluster Memcached berbasis node secara manual secara vertikal](#Scaling.Memcached.Vertically) |
**Topics**
+ [Menskalakan cluster Memcached berbasis node secara manual secara horizontal](#Scaling.Memcached.Horizontally)
+ [Menskalakan cluster Memcached berbasis node secara manual secara vertikal](#Scaling.Memcached.Vertically)
## Menskalakan cluster Memcached berbasis node secara manual secara horizontal
Mesin Memcached mendukung partisi data Anda di beberapa simpul. Oleh karena itu, klaster Memcached dapat diskalakan secara horizontal dengan mudah. Untuk menskalakan klaster Memcached Anda secara horizontal, cukup tambahkan atau hapus simpul.
Topik berikut memberikan detail cara menskalakan klaster Memcached Anda ke luar atau ke dalam dengan menambahkan atau menghapus simpul.
+ [Menambahkan simpul ke klaster](Clusters.html#AddNode)
+ [Menghapus simpul dari klaster](Clusters.html#AddNode)
Setiap kali Anda mengubah jumlah simpul dalam klaster Memcached, Anda harus memetakan ulang setidaknya beberapa ruang kunci agar dipetakan ke simpul yang benar. Untuk informasi lebih detail tentang penyeimbangan beban klaster Memcached Anda, lihat [Mengkonfigurasi ElastiCache klien Anda untuk penyeimbangan beban yang efisien (Memcached)](BestPractices.LoadBalancing.md).
Jika Anda menggunakan penemuan otomatis pada klaster Memcached, Anda tidak perlu mengubah titik akhir dalam aplikasi saat Anda menambahkan atau menghapus simpul. Untuk informasi selengkapnya tentang penemuan otomatis, lihat [Secara otomatis mengidentifikasi node di cluster Anda (Memcached)](AutoDiscovery.md). Jika Anda tidak menggunakan penemuan otomatis, setiap kali Anda mengubah jumlah simpul dalam klaster Memcached, Anda harus memperbarui titik akhir dalam aplikasi.
## Menskalakan cluster Memcached berbasis node secara manual secara vertikal
Saat Anda menskalakan cluster Memcached secara manual ke atas atau ke bawah, Anda harus membuat klaster baru. Klaster Memcached selalu dimulai dalam kondisi kosong kecuali jika aplikasi Anda mengisinya.
**penting**
Jika Anda menskalakan ke bawah ke tipe simpul yang lebih kecil, pastikan bahwa tipe simpul yang lebih kecil memadai untuk data dan overhead Anda. Untuk informasi selengkapnya, lihat [Memilih ukuran simpul Anda](CacheNodes.SelectSize.md).
**Topics**
+ [Menskalakan cluster Memcached berbasis node secara vertikal (Konsol)](#Scaling.Memcached.Vertically.CON)
+ [Menskalakan cluster Memcached berbasis node secara vertikal ()AWS CLI](#Scaling.Memcached.Vertically.CLI)
+ [Menskalakan cluster Memcached berbasis node secara vertikal (API) ElastiCache](#Scaling.Memcached.Vertically.API)
### Menskalakan cluster Memcached berbasis node secara vertikal (Konsol)
Prosedur berikut memandu Anda melalui penskalaan cluster Memcached berbasis node secara vertikal menggunakan.Konsol Manajemen AWS
1. Buat klaster baru dengan jenis simpul baru. Untuk informasi selengkapnya, lihat [Membuat klaster Memcached (konsol)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
1. Dalam aplikasi Anda, perbarui titik akhir ke titik akhir klaster baru. Untuk informasi selengkapnya, lihat [Menemukan Titik Akhir Cluster (Konsol) (Memcached)](Endpoints.md#Endpoints.Find.Memcached).
1. Hapus klaster lama. Untuk informasi selengkapnya, lihat [Menghapus simpul baru di Memcached](Clusters.html#Delete.CON.Memcached).
### Menskalakan cluster Memcached berbasis node secara vertikal ()AWS CLI
Prosedur berikut memandu Anda melalui penskalaan cluster Memcached berbasis node secara vertikal menggunakan.AWS CLI
1. Buat klaster baru dengan jenis simpul baru. Untuk informasi selengkapnya, lihat [Membuat klaster (AWS CLI)](Clusters.Create.md#Clusters.Create.CLI).
1. Dalam aplikasi Anda, perbarui titik akhir ke titik akhir klaster baru. Untuk informasi selengkapnya, lihat [Menemukan Titik Akhir (AWS CLI)](Endpoints.md#Endpoints.Find.CLI).
1. Hapus klaster lama. Untuk informasi selengkapnya, lihat [Menggunakan AWS CLI untuk menghapus ElastiCache cluster](Clusters.Delete.md#Clusters.Delete.CLI).
### Menskalakan cluster Memcached berbasis node secara vertikal (API) ElastiCache
Prosedur berikut memandu Anda melalui penskalaan cluster Memcached berbasis node secara vertikal menggunakan API. ElastiCache
1. Buat klaster baru dengan jenis simpul baru. Untuk informasi selengkapnya, lihat [Membuat cluster untuk Memcached (API) ElastiCache](Clusters.Create-mc.md#Clusters.Create.API.mem-heading)
1. Dalam aplikasi Anda, perbarui titik akhir ke titik akhir klaster baru. Untuk informasi selengkapnya, lihat [Menemukan Titik Akhir (ElastiCache API)](Endpoints.md#Endpoints.Find.API).
1. Hapus klaster lama. Lihat informasi yang lebih lengkap di [Menggunakan ElastiCache API](Clusters.Delete.md#Clusters.Delete.API).
# Penskalaan untuk cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dapat berupa cluster simpul tunggal dengan 0 pecahan atau cluster multi-node dengan 1 pecahan. Klaster simpul tunggal menggunakan satu simpul untuk operasi baca dan tulis. Cluster multi-node selalu memiliki 1 node sebagai node read/write utama dengan 0 hingga 5 node replika read-only.
**Topics**
+ [Penskalaan untuk cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](#Scaling.RedisStandalone)
**Penskalaan cluster Valkey atau Redis OSS**
| Tindakan | Valkey atau Redis OSS (mode cluster dinonaktifkan) | Valkey atau Redis OSS (mode cluster diaktifkan) |
| --- | --- | --- |
| Menskalakan ke dalam | [Menghapus node dari ElastiCache cluster](Clusters.DeleteNode.md) | [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md) |
| Menskalakan ke luar | [Menambahkan simpul ke klaster](Clusters.html#AddNode) | [Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online) |
| Mengubah jenis simpul | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/scaling-redis-classic.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/scaling-redis-classic.html) | [Penskalaan vertikal online dengan mengubah jenis simpul](redis-cluster-vertical-scaling.md) |
| Mengubah jumlah grup simpul | Tidak didukung untuk klaster Valkey atau Redis OSS (mode cluster dinonaktifkan) | [Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md) |
**Contents**
+ [Penskalaan untuk cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](#Scaling.RedisStandalone)
+ [Meningkatkan kluster Valkey atau Redis OSS node tunggal](#Scaling.RedisStandalone.ScaleUp)
+ [Meningkatkan kluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol) simpul tunggal](#Scaling.RedisStandalone.ScaleUp.CON)
+ [Meningkatkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI](#Scaling.RedisStandalone.ScaleUp.CLI)
+ [Meningkatkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache](#Scaling.RedisStandalone.ScaleUp.API)
+ [Menurunkan kluster Valkey atau Redis OSS simpul tunggal](#Scaling.RedisStandalone.ScaleDown)
+ [Menurunkan cluster Valkey atau Redis OSS simpul tunggal (Konsol)](#Scaling.RedisStandalone.ScaleDown.CON)
+ [Menurunkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI](#Scaling.RedisStandalone.ScaleUpDown-Modify.CLI)
+ [Menurunkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache](#Scaling.RedisStandalone.ScaleDown.API)
## Penskalaan untuk cluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Node Valkey atau Redis OSS (mode cluster dinonaktifkan) harus cukup besar untuk menampung semua data cache ditambah overhead Valkey atau Redis OSS. Untuk mengubah kapasitas data cluster Valkey atau Redis OSS (mode cluster disabled) Anda, Anda harus menskalakan secara vertikal; meningkatkan ke tipe node yang lebih besar untuk meningkatkan kapasitas data, atau memperkecil ke tipe node yang lebih kecil untuk mengurangi kapasitas data.
Proses ElastiCache penskalaan dirancang untuk melakukan upaya terbaik untuk mempertahankan data Anda yang ada dan membutuhkan replikasi Valkey atau Redis OSS yang sukses. Untuk cluster Valkey atau Redis OSS (mode cluster dinonaktifkan), kami merekomendasikan agar memori yang cukup tersedia untuk Valkey atau Redis OSS.
Anda tidak dapat mempartisi data Anda di beberapa cluster Valkey atau Redis OSS (mode cluster dinonaktifkan). Namun, jika Anda hanya perlu menambah atau mengurangi kapasitas baca cluster Anda, Anda dapat membuat cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan node replika dan menambah atau menghapus replika baca. Untuk membuat cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan node replika menggunakan cluster Valkey atau Redis OSS simpul tunggal Anda sebagai cluster utama, lihat. [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
Setelah membuat klaster dengan replika, Anda dapat meningkatkan kapasitas baca dengan menambahkan replika baca. Jika diperlukan, Anda dapat mengurangi kapasitas baca dengan menghapus replika baca di lain waktu. Untuk informasi selengkapnya, lihat [Meningkatkan kapasitas baca](Scaling.RedisReplGrps.md#Scaling.RedisReplGrps.ScaleOut) atau [Mengurangi kapasitas baca](Scaling.RedisReplGrps.md#Scaling.RedisReplGrps.ScaleIn).
Selain mampu menskalakan kapasitas baca, Valkey atau Redis OSS (cluster mode disabled) cluster dengan replika memberikan keuntungan bisnis lainnya. Untuk informasi selengkapnya, lihat [Ketersediaan tinggi menggunakan grup replikasi](Replication.md).
**penting**
Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, sebelum Anda mulai menskalakan pastikan bahwa Anda memiliki grup parameter khusus yang menyimpan jumlah memori yang benar untuk jenis node baru Anda. Sebagai alternatif, Anda dapat mengubah grup parameter kustom agar menggunakan `reserved-memory-percent` dan menggunakan grup parameter tersebut untuk klaster baru Anda.
Jika menggunakan `reserved-memory-percent`, Anda tidak perlu melakukan ini.
Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
**Topics**
+ [Meningkatkan kluster Valkey atau Redis OSS node tunggal](#Scaling.RedisStandalone.ScaleUp)
+ [Menurunkan kluster Valkey atau Redis OSS simpul tunggal](#Scaling.RedisStandalone.ScaleDown)
### Meningkatkan kluster Valkey atau Redis OSS node tunggal
Saat Anda meningkatkan kluster Valkey atau Redis OSS simpul tunggal, ElastiCache lakukan proses berikut, baik Anda menggunakan ElastiCache konsol,, atau API AWS CLI. ElastiCache
1. Cluster baru dengan tipe node baru diputar di Availability Zone yang sama dengan cluster yang ada.
1. Data cache di cluster yang ada disalin ke cluster baru. Berapa lama proses ini tergantung pada jenis node Anda dan berapa banyak data yang ada di cluster.
1. Membaca dan menulis sekarang disajikan menggunakan cluster baru. Karena titik akhir cluster baru sama dengan cluster lama, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Anda akan merasakan gangguan singkat (beberapa detik) pada operasi baca dan tulis dari simpul primer saat entri DNS diperbarui.
1. ElastiCache menghapus cluster lama. Anda akan merasakan gangguan singkat (beberapa detik) pada operasi baca dan tulis dari simpul lama karena koneksi ke simpul lama akan terputus.
**catatan**
Untuk klaster yang menjalankan simpul jenis r6gd, Anda hanya dapat menskalakan ke ukuran simpul dalam keluarga simpul r6gd.
Seperti yang ditunjukkan pada tabel berikut, operasi penskalaan Valkey atau Redis OSS Anda diblokir jika Anda memiliki pemutakhiran mesin yang dijadwalkan untuk jendela pemeliharaan berikutnya. Untuk informasi selengkapnya tentang Periode Pemeliharaan, lihat [Mengelola pemeliharaan ElastiCache cluster](maintenance-window.md).
**Operasi Valkey atau Redis OSS yang diblokir**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/scaling-redis-classic.html)
Jika memiliki operasi tertunda yang memblokir, Anda dapat melakukan salah satu hal berikut.
+ Jadwalkan operasi penskalaan Valkey atau Redis OSS Anda untuk jendela pemeliharaan berikutnya dengan membersihkan kotak **centang Terapkan** segera (penggunaan CLI:, Penggunaan API:). `--no-apply-immediately` `ApplyImmediately=false`
+ Tunggu hingga jendela pemeliharaan berikutnya (atau setelahnya) untuk melakukan operasi penskalaan Valkey atau Redis OSS Anda.
+ Tambahkan upgrade mesin Valkey atau Redis OSS ke modifikasi cluster ini dengan kotak centang **Terapkan Segera** yang dipilih (CLI use:`--apply-immediately`, API use:). `ApplyImmediately=true` Tindakan ini akan membuka blokir operasi penaikan skala dengan memicu agar peningkatan mesin segera dilakukan.
Anda dapat meningkatkan klaster Valkey atau Redis OSS (mode cluster dinonaktifkan) node tunggal menggunakan ElastiCache konsol, the AWS CLI, atau API. ElastiCache
**penting**
Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, sebelum Anda mulai menskalakan pastikan bahwa Anda memiliki grup parameter khusus yang menyimpan jumlah memori yang benar untuk jenis node baru Anda. Sebagai alternatif, Anda dapat mengubah grup parameter kustom agar menggunakan `reserved-memory-percent` dan menggunakan grup parameter tersebut untuk klaster baru Anda.
Jika menggunakan `reserved-memory-percent`, Anda tidak perlu melakukan ini.
Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
#### Meningkatkan kluster Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (Konsol) simpul tunggal
Prosedur berikut menjelaskan cara meningkatkan cluster Valkey atau Redis OSS node tunggal menggunakan Management Console. ElastiCache Selama proses ini, klaster Valkey atau Redis OSS Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk meningkatkan cluster Valkey atau Redis OSS node tunggal (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau Redis** OSS.
1. Dari daftar cluster, pilih cluster yang ingin Anda tingkatkan (harus menjalankan mesin Valkey atau Redis OSS, bukan mesin Valkey atau Redis OSS yang berkerumun).
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul sebagai tujuan penskalaan dari daftar **Jenis simpul**.
1. Jika Anda menggunakan `reserved-memory` untuk mengelola memori, dari daftar **Grup Parameter**, pilih grup parameter kustom yang mencadangkan jumlah memori yang benar untuk jenis simpul baru Anda.
1. Jika Anda ingin segera menaikkan skala, pilih kotak **Terapkan segera**. Jika kotak **Terapkan segera** tidak dipilih, proses menaikkan skala dilakukan selama periode pemeliharaan berikutnya dari klaster ini.
1. Pilih **Ubah**.
Jika Anda memilih **Terapkan segera** pada langkah sebelumnya, status klaster berubah ke *mengubah*. Ketika status berubah ke *tersedia*, pengubahan selesai dan Anda dapat mulai menggunakan klaster baru tersebut.
#### Meningkatkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI
Prosedur berikut menjelaskan cara meningkatkan cluster Valkey atau Redis OSS simpul tunggal menggunakan.AWS CLI Selama proses ini, klaster Valkey atau Redis OSS Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk meningkatkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI**
1. Tentukan jenis node yang dapat Anda tingkatkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
+ `--cache-cluster-id`
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--cache-cluster-id my-cache-cluster-id
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--cache-cluster-id my-cache-cluster-id
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ScaleUpModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
"ScaleDownModifications": [
"cache.t2.micro",
"cache.t2.small ",
"cache.t2.medium ",
"cache.t1.small ",
],
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Ubah cluster Anda yang ada yang menentukan klaster untuk ditingkatkan dan tipe node baru yang lebih besar, menggunakan AWS CLI`modify-cache-cluster` perintah dan parameter berikut.
+ `--cache-cluster-id`— Nama cluster yang Anda tingkatkan.
+ `--cache-node-type`— Jenis node baru yang ingin Anda skalakan cluster. Nilai ini harus berupa salah satu dari jenis simpul yang dihasilkan oleh perintah `list-allowed-node-type-modifications` di langkah 1.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan operasi penaikan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya untuk klaster, gunakan parameter `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-redis-cache-cluster \
--cache-node-type cache.m3.xlarge \
--cache-parameter-group-name redis32-m2-xl \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-redis-cache-cluster ^
--cache-node-type cache.m3.xlarge ^
--cache-parameter-group-name redis32-m2-xl ^
--apply-immediately
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"CacheCluster": {
"Engine": "redis",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis6.x",
"ParameterApplyStatus": "in-sync"
},
"SnapshotRetentionLimit": 1,
"CacheClusterId": "my-redis-cache-cluster",
"CacheSecurityGroups": [],
"NumCacheNodes": 1,
"SnapshotWindow": "00:00-01:00",
"CacheClusterCreateTime": "2017-02-21T22:34:09.645Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"PreferredAvailabilityZone": "us-west-2a",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "6.0",
"PendingModifiedValues": {
"CacheNodeType": "cache.m3.2xlarge"
},
"PreferredMaintenanceWindow": "tue:11:30-tue:12:30",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled"
}
}
```
Untuk informasi selengkapnya, lihat [modify-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan`--apply-immediately`, periksa status cluster baru menggunakan AWS CLI`describe-cache-clusters` perintah dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan cluster baru yang lebih besar.
+ `--cache-cluster-id`— Nama cluster Valkey atau Redis OSS simpul tunggal Anda. Gunakan parameter ini untuk menggambarkan cluster tertentu daripada semua cluster.
```
aws elasticache describe-cache-clusters --cache-cluster-id my-redis-cache-cluster
```
Untuk informasi selengkapnya, lihat [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html) dalam *Referensi AWS CLI*.
#### Meningkatkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache
Prosedur berikut menjelaskan cara meningkatkan cluster Valkey atau Redis OSS node tunggal menggunakan API. ElastiCache Selama proses ini, klaster Valkey atau Redis OSS Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk meningkatkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache**
1. Tentukan tipe node yang dapat Anda tingkatkan dengan menjalankan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `CacheClusterId`— Nama cluster Valkey atau Redis OSS simpul tunggal yang ingin Anda tingkatkan.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&CacheClusterId=MyRedisCacheCluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Ubah klaster Anda yang sudah ada yang menentukan klaster untuk ditingkatkan dan tipe node baru yang lebih besar, menggunakan aksi `ModifyCacheCluster` ElastiCache API dan parameter berikut.
+ `CacheClusterId`— Nama cluster yang Anda tingkatkan.
+ `CacheNodeType`— Jenis node baru yang lebih besar yang ingin Anda skalakan cluster. Nilai ini harus menjadi salah satu jenis node yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penaikan skala segera diterapkan. Untuk menunda proses menaikkan skala ke periode pemeliharaan berikutnya dari klaster, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&CacheClusterId=MyRedisCacheCluster
&CacheNodeType=cache.m3.xlarge
&CacheParameterGroupName redis32-m2-xl
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ModifyCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html) di *Referensi Amazon ElastiCache API*.
1. Jika Anda menggunakan `ApplyImmediately``=true`, periksa status klaster baru menggunakan `DescribeCacheClusters` aksi ElastiCache API dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan cluster baru yang lebih besar.
+ `CacheClusterId`— Nama cluster Valkey atau Redis OSS simpul tunggal Anda. Gunakan parameter ini untuk menggambarkan cluster tertentu daripada semua cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=MyRedisCacheCluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [DescribeCacheClusters](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html) di *Referensi Amazon ElastiCache API*.
### Menurunkan kluster Valkey atau Redis OSS simpul tunggal
Bagian berikut memandu Anda melalui cara menskalakan cluster Valkey atau Redis OSS node tunggal ke tipe node yang lebih kecil. Memastikan bahwa tipe node baru yang lebih kecil cukup besar untuk mengakomodasi semua data dan overhead Valkey atau Redis OSS penting untuk kesuksesan jangka panjang cluster Valkey atau Redis OSS baru Anda. Untuk informasi selengkapnya, lihat [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md).
**catatan**
Untuk klaster yang menjalankan simpul jenis r6gd, Anda hanya dapat menskalakan ke ukuran simpul dalam keluarga simpul r6gd.
**Topics**
+ [Menurunkan cluster Valkey atau Redis OSS simpul tunggal (Konsol)](#Scaling.RedisStandalone.ScaleDown.CON)
+ [Menurunkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI](#Scaling.RedisStandalone.ScaleUpDown-Modify.CLI)
+ [Menurunkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache](#Scaling.RedisStandalone.ScaleDown.API)
#### Menurunkan cluster Valkey atau Redis OSS simpul tunggal (Konsol)
Prosedur berikut memandu Anda melalui penskalaan cluster Valkey atau Redis OSS node tunggal Anda ke tipe node yang lebih kecil menggunakan konsol. ElastiCache
**penting**
Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, sebelum Anda mulai menskalakan pastikan bahwa Anda memiliki grup parameter khusus yang menyimpan jumlah memori yang benar untuk jenis node baru Anda. Sebagai alternatif, Anda dapat mengubah grup parameter kustom agar menggunakan `reserved-memory-percent` dan menggunakan grup parameter tersebut untuk klaster baru Anda.
Jika menggunakan `reserved-memory-percent`, Anda tidak perlu melakukan ini.
Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
**Untuk mengurangi kluster Valkey atau Redis OSS node tunggal Anda (konsol)**
1. Pastikan bahwa jenis simpul yang lebih kecil memadai untuk data dan kebutuhan overhead Anda.
1. Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, pastikan Anda memiliki grup parameter khusus untuk menyisihkan jumlah memori yang benar untuk jenis node baru Anda.
Sebagai alternatif, Anda dapat mengubah grup parameter kustom untuk menggunakan `reserved-memory-percent`. Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari daftar klaster, pilih klaster yang ingin Anda turunkan skalanya. Cluster ini harus menjalankan mesin Valkey atau Redis OSS dan bukan mesin Valkey atau Redis OSS yang berkerumun.
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul yang Anda inginkan untuk penurunan skala dari daftar **Jenis simpul**.
1. Jika Anda menggunakan `reserved-memory` untuk mengelola memori, dari daftar **Grup Parameter**, pilih grup parameter kustom yang mencadangkan jumlah memori yang benar untuk jenis simpul baru Anda.
1. Jika Anda ingin segera menurunkan skala, pilih kotak centang **Terapkan segera**. Jika kotak centang **Terapkan segera** tidak dipilih, proses penurunan skala akan dilakukan selama periode pemeliharaan berikutnya dari klaster ini.
1. Pilih **Ubah**.
1. Ketika status klaster berubah dari *mengubah* ke *tersedia*, artinya klaster Anda telah diskalakan ke jenis simpul baru. Tidak perlu memperbarui titik akhir dalam aplikasi Anda.
#### Menurunkan cluster Valkey atau Redis OSS node tunggal ()AWS CLI
Prosedur berikut menjelaskan cara menurunkan cluster Valkey atau Redis OSS node tunggal menggunakan.AWS CLI
**Untuk mengurangi cluster Valkey atau Redis OSS node tunggal ()AWS CLI**
1. Tentukan jenis node yang dapat Anda turunkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
+ `--cache-cluster-id`
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--cache-cluster-id my-cache-cluster-id
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--cache-cluster-id my-cache-cluster-id
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ScaleUpModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
"ScaleDownModifications": [
"cache.t2.micro",
"cache.t2.small ",
"cache.t2.medium ",
"cache.t1.small ",
],
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Ubah cluster Anda yang ada yang menentukan cluster untuk menurunkan skala dan tipe node baru yang lebih kecil, menggunakan AWS CLI`modify-cache-cluster` perintah dan parameter berikut.
+ `--cache-cluster-id`— Nama cluster yang Anda perkecil.
+ `--cache-node-type`— Jenis node baru yang ingin Anda skalakan cluster. Nilai ini harus berupa salah satu dari jenis simpul yang dihasilkan oleh perintah `list-allowed-node-type-modifications` di langkah 1.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan proses penurunan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya untuk klaster, gunakan parameter `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-redis-cache-cluster \
--cache-node-type cache.m3.xlarge \
--cache-parameter-group-name redis32-m2-xl \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-redis-cache-cluster ^
--cache-node-type cache.m3.xlarge ^
--cache-parameter-group-name redis32-m2-xl ^
--apply-immediately
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"CacheCluster": {
"Engine": "redis",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis6,x",
"ParameterApplyStatus": "in-sync"
},
"SnapshotRetentionLimit": 1,
"CacheClusterId": "my-redis-cache-cluster",
"CacheSecurityGroups": [],
"NumCacheNodes": 1,
"SnapshotWindow": "00:00-01:00",
"CacheClusterCreateTime": "2017-02-21T22:34:09.645Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"PreferredAvailabilityZone": "us-west-2a",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "6.0",
"PendingModifiedValues": {
"CacheNodeType": "cache.m3.2xlarge"
},
"PreferredMaintenanceWindow": "tue:11:30-tue:12:30",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled"
}
}
```
Untuk informasi selengkapnya, lihat [modify-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan`--apply-immediately`, periksa status cluster baru menggunakan AWS CLI`describe-cache-clusters` perintah dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan cluster baru yang lebih besar.
+ `--cache-cluster-id`— Nama cluster Valkey atau Redis OSS simpul tunggal Anda. Gunakan parameter ini untuk menggambarkan cluster tertentu daripada semua cluster.
```
aws elasticache describe-cache-clusters --cache-cluster-id my-redis-cache-cluster
```
Untuk informasi selengkapnya, lihat [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html) dalam *Referensi AWS CLI*.
#### Menurunkan cluster Valkey atau Redis OSS node tunggal (API) ElastiCache
Prosedur berikut menjelaskan cara menskalakan updown cluster Valkey atau Redis OSS node tunggal menggunakan API. ElastiCache
**Untuk menurunkan skala cluster Valkey atau Redis OSS node tunggal (API) ElastiCache**
1. Tentukan tipe node yang dapat Anda turunkan dengan menjalankan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `CacheClusterId`— Nama cluster Valkey atau Redis OSS simpul tunggal yang ingin Anda turunkan.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&CacheClusterId=MyRedisCacheCluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Ubah klaster Anda yang sudah ada yang menentukan klaster untuk ditingkatkan dan tipe node baru yang lebih besar, menggunakan aksi `ModifyCacheCluster` ElastiCache API dan parameter berikut.
+ `CacheClusterId`— Nama cluster yang Anda perkecil.
+ `CacheNodeType`— Tipe node baru yang lebih kecil yang ingin Anda turunkan ke cluster. Nilai ini harus menjadi salah satu jenis node yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penurunan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya dari klaster, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&CacheClusterId=MyRedisCacheCluster
&CacheNodeType=cache.m3.xlarge
&CacheParameterGroupName redis32-m2-xl
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ModifyCacheCluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html) di *Referensi Amazon ElastiCache API*.
1. Jika Anda menggunakan `ApplyImmediately``=true`, periksa status klaster baru menggunakan `DescribeCacheClusters` aksi ElastiCache API dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan cluster baru yang lebih kecil.
+ `CacheClusterId`— Nama cluster Valkey atau Redis OSS simpul tunggal Anda. Gunakan parameter ini untuk menggambarkan cluster tertentu daripada semua cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=MyRedisCacheCluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [DescribeCacheClusters](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html) di *Referensi Amazon ElastiCache API*.
# Menskalakan node replika untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Cluster Valkey atau Redis OSS dengan node replika (disebut *grup replikasi di API/CLI) menyediakan ketersediaan tinggi melalui replikasi* yang memiliki multi-AZ dengan failover otomatis diaktifkan. Cluster dengan node replika adalah kumpulan logis hingga enam node Valkey atau Redis OSS di mana satu node, Primer, dapat melayani permintaan baca dan tulis. Semua simpul lain dalam klaster adalah replika hanya-baca dari Primer. Data yang ditulis ke Primer direplikasi secara asinkron ke semua replika baca di klaster. Karena Valkey atau Redis OSS (mode cluster dinonaktifkan) tidak mendukung partisi data Anda di beberapa cluster, setiap node dalam grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) berisi seluruh kumpulan data cache. Cluster Valkey atau Redis OSS (mode cluster enabled) mendukung partisi data Anda hingga 500 pecahan.
Untuk mengubah kapasitas data klaster, Anda harus menaikkan skalanya ke jenis simpul yang lebih besar, atau menurunkan skalanya ke jenis simpul yang lebih kecil.
Untuk mengubah kapasitas baca klaster Anda, tambahkan lebih banyak replika baca, hingga maksimum 5, atau hapus replika baca.
Proses ElastiCache penskalaan dirancang untuk melakukan upaya terbaik untuk mempertahankan data Anda yang ada dan membutuhkan replikasi Valkey atau Redis OSS yang sukses. Untuk cluster Valkey atau Redis OSS dengan replika, kami merekomendasikan agar memori yang cukup tersedia untuk Valkey atau Redis OSS.
**Topics**
+ [Meningkatkan klaster Valkey atau Redis OSS dengan replika](#Scaling.RedisReplGrps.ScaleUp)
+ [Menskalakan cluster Valkey atau Redis OSS dengan replika](#Scaling.RedisReplGrps.ScaleDown)
+ [Meningkatkan kapasitas baca](#Scaling.RedisReplGrps.ScaleOut)
+ [Mengurangi kapasitas baca](#Scaling.RedisReplGrps.ScaleIn)
**Topik Terkait**
+ [Ketersediaan tinggi menggunakan grup replikasi](Replication.md)
+ [Replikasi: Mode Cluster Valkey dan Redis OSS Dinonaktifkan vs Diaktifkan](Replication.Redis-RedisCluster.md)
+ [Meminimalkan downtime ElastiCache dengan menggunakan Multi-AZ dengan Valkey dan Redis OSS](AutoFailover.md)
+ [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md)
**Topics**
+ [Meningkatkan klaster Valkey atau Redis OSS dengan replika](#Scaling.RedisReplGrps.ScaleUp)
+ [Menskalakan cluster Valkey atau Redis OSS dengan replika](#Scaling.RedisReplGrps.ScaleDown)
+ [Meningkatkan kapasitas baca](#Scaling.RedisReplGrps.ScaleOut)
+ [Mengurangi kapasitas baca](#Scaling.RedisReplGrps.ScaleIn)
## Meningkatkan klaster Valkey atau Redis OSS dengan replika
Amazon ElastiCache menyediakan dukungan konsol, CLI, dan API untuk menskalakan grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) Anda.
Ketika proses peningkatan skala dimulai, ElastiCache lakukan hal berikut:
1. Meluncurkan grup replikasi menggunakan jenis simpul baru.
1. Menyalin semua data dari simpul primer saat ini ke simpul primer baru.
1. Menyinkronkan replika baca baru dengan simpul primer baru.
1. Memperbarui entri DNS sehingga mengarah ke simpul baru. Karena hal ini, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Untuk Valkey 7.2 dan yang lebih baru atau Redis OSS 5.0.5 ke atas, Anda dapat menskalakan cluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada Redis OSS versi 4.0.10 dan di bawahnya, Anda mungkin melihat gangguan singkat membaca dan menulis pada versi sebelumnya dari node utama saat entri DNS diperbarui.
1. Menghapus simpul lama (CLI/API: grup replikasi). Anda akan merasakan gangguan singkat (beberapa detik) pada operasi baca dan tulis dari simpul lama karena koneksi ke simpul lama akan terputus.
Seberapa lama proses ini berjalan bergantung pada jenis simpul dan jumlah data dalam klaster Anda.
Seperti yang ditunjukkan pada tabel berikut, operasi penskalaan Valkey atau Redis OSS Anda diblokir jika Anda memiliki pemutakhiran mesin yang dijadwalkan untuk jendela pemeliharaan cluster berikutnya.
**Operasi Valkey atau Redis OSS yang diblokir**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/Scaling.RedisReplGrps.html)
Jika memiliki operasi tertunda yang memblokir, Anda dapat melakukan salah satu hal berikut.
+ Jadwalkan operasi penskalaan Valkey atau Redis OSS Anda untuk jendela pemeliharaan berikutnya dengan membersihkan kotak **centang Terapkan** segera (penggunaan CLI:, Penggunaan API:). `--no-apply-immediately` `ApplyImmediately=false`
+ Tunggu hingga jendela pemeliharaan berikutnya (atau setelahnya) untuk melakukan operasi penskalaan Valkey atau Redis OSS Anda.
+ Tambahkan upgrade mesin Valkey atau Redis OSS ke modifikasi cluster ini dengan kotak centang **Terapkan Segera** yang dipilih (CLI use:`--apply-immediately`, API use:). `ApplyImmediately=true` Tindakan ini akan membuka blokir operasi penaikan skala dengan memicu peningkatan mesin agar segera dilakukan.
Bagian berikut menjelaskan cara menskalakan cluster Valkey atau Redis OSS Anda dengan replika menggunakan ElastiCache konsol, the AWS CLI, dan API. ElastiCache
**penting**
Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, sebelum Anda mulai menskalakan pastikan bahwa Anda memiliki grup parameter khusus yang menyimpan jumlah memori yang benar untuk jenis node baru Anda. Sebagai alternatif, Anda dapat mengubah grup parameter kustom agar menggunakan `reserved-memory-percent` dan menggunakan grup parameter tersebut untuk klaster baru Anda.
Jika menggunakan `reserved-memory-percent`, Anda tidak perlu melakukan ini.
Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
### Meningkatkan klaster Valkey atau Redis OSS dengan replika (Konsol)
Jumlah waktu yang dibutuhkan untuk menaikkan skala ke jenis simpul yang lebih besar bervariasi, bergantung pada jenis simpul dan jumlah data dalam klaster Anda saat ini.
Proses berikut menskalakan klaster Anda dengan replika dari tipe node saat ini ke tipe node baru yang lebih besar menggunakan ElastiCache konsol. Selama proses ini, mungkin ada gangguan singkat terhadap operasi baca dan tulis untuk versi lain dari simpul primer saat entri DNS diperbarui. Anda mungkin akan mengalami waktu henti kurang dari 1 detik untuk simpul yang menjalankan versi 5.0.6 ke atas dan beberapa detik untuk versi yang lebih lama.
**Untuk meningkatkan klaster Valkey atau Redis OSS dengan replika (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. **Dari panel navigasi, pilih cluster **Valkey atau cluster Redis** OSS**
1. Dari daftar klaster, pilih klaster yang ingin Anda naikkan skalanya. Cluster ini harus menjalankan mesin Valkey atau Redis OSS dan bukan mesin Valkey atau Redis OSS yang berkerumun.
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul sebagai tujuan penskalaan dari daftar **Jenis simpul**. Perhatikan bahwa tidak semua jenis simpul tersedia sebagai pilihan penurunan skala.
1. Jika Anda menggunakan `reserved-memory` untuk mengelola memori, dari daftar **Grup Parameter**, pilih grup parameter kustom yang mencadangkan jumlah memori yang benar untuk jenis simpul baru Anda.
1. Jika Anda ingin segera melakukan proses penaikan skala, centang kotak **Terapkan segera**. Jika kotak centang **Terapkan segera** tidak dipilih, proses penaikan skala akan dilakukan selama periode pemeliharaan berikutnya untuk klaster ini.
1. Pilih **Ubah**.
1. Ketika status klaster berubah dari *mengubah* ke *tersedia*, artinya klaster Anda telah diskalakan ke jenis simpul baru. Tidak perlu memperbarui titik akhir dalam aplikasi Anda.
### Meningkatkan grup replikasi Valkey atau Redis OSS ()AWS CLI
Proses berikut menskalakan grup replikasi dari jenis simpul saat ini ke jenis simpul baru yang lebih besar menggunakan AWS CLI. Selama proses ini, ElastiCache update entri DNS sehingga mereka menunjuk ke node baru. Karena hal ini, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Untuk Valkey 7.2 dan yang lebih baru atau Redis OSS 5.0.5 ke atas, Anda dapat menskalakan cluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada versi 4.0.10 ke bawah, Anda mungkin merasakan gangguan singkat terhadap operasi baca dan tulis pada versi sebelumnya dari simpul primer saat entri DNS diperbarui.
Jumlah waktu yang diperlukan untuk menskalakan hingga tipe node yang lebih besar bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Untuk meningkatkan Grup Replikasi Valkey atau Redis OSS ()AWS CLI**
1. Tentukan jenis node mana yang dapat Anda tingkatkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
+ `--replication-group-id` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--replication-group-id my-repl-group
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--replication-group-id my-repl-group
```
Output dari operasi ini terlihat seperti berikut (format JSON).
```
{
"ScaleUpModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Skala grup replikasi Anda saat ini hingga tipe node baru menggunakan AWS CLI`modify-replication-group` perintah dengan parameter berikut.
+ `--replication-group-id` – nama grup replikasi.
+ `--cache-node-type`— tipe node baru yang lebih besar dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `list-allowed-node-type-modifications` perintah pada langkah sebelumnya.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan operasi penaikan skala segera diterapkan. Untuk menunda operasi penaikan skala ke periode pemeliharaan berikutnya, gunakan `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id my-repl-group \
--cache-node-type cache.m3.xlarge \
--cache-parameter-group-name redis32-m3-2xl \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id my-repl-group ^
--cache-node-type cache.m3.xlarge ^
--cache-parameter-group-name redis32-m3-2xl \
--apply-immediately
```
Output dari perintah ini terlihat seperti berikut (format JSON).
```
{
"ReplicationGroup": {
"Status": "available",
"Description": "Some description",
"NodeGroups": [{
"Status": "available",
"NodeGroupMembers": [{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "my-repl-group-001.8fdx4s.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "my-repl-group-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "my-repl-group-002.8fdx4s.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "my-repl-group-002"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "my-repl-group.8fdx4s.ng.0001.usw2.cache.amazonaws.com"
}
}],
"ReplicationGroupId": "my-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "disabled",
"SnapshotWindow": "12:00-13:00",
"SnapshottingClusterId": "my-repl-group-002",
"MemberClusters": [
"my-repl-group-001",
"my-repl-group-002"
],
"PendingModifiedValues": {}
}
}
```
Untuk informasi selengkapnya, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan `--apply-immediately` parameter, pantau status grup replikasi menggunakan AWS CLI`describe-replication-group` perintah dengan parameter berikut. Saat status masih *mengubah*, Anda mungkin akan merasakan waktu henti kurang dari 1 detik untuk simpul yang berjalan di versi 5.0.6 ke atas dan gangguan singkat pada operasi baca dan tulis untuk simpul primer versi lebih lama saat entri DNS diperbarui.
+ `--replication-group-id` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-replication-groups \
--replication-group-id my-replication-group
```
Untuk Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id my-replication-group
```
Untuk informasi selengkapnya, lihat [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) dalam *Referensi AWS CLI*.
### Meningkatkan grup replikasi Valkey atau Redis OSS (API) ElastiCache
Proses berikut menskalakan grup replikasi Anda dari tipe node saat ini ke tipe node baru yang lebih besar menggunakan ElastiCache API. Untuk Valkey 7.2 dan yang lebih baru atau Redis OSS 5.0.5 ke atas, Anda dapat menskalakan cluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada versi Redis OSS 4.0.10 dan di bawahnya, Anda mungkin melihat gangguan singkat membaca dan menulis pada versi sebelumnya dari node utama saat entri DNS diperbarui.
Jumlah waktu yang diperlukan untuk menskalakan hingga tipe node yang lebih besar bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Untuk meningkatkan Grup Replikasi Valkey atau Redis OSS (API) ElastiCache**
1. Tentukan tipe node mana yang dapat Anda tingkatkan untuk menggunakan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Skalakan grup replikasi Anda saat ini hingga tipe node baru menggunakan aksi `ModifyReplicationGroup` ElastiCache API dan dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi.
+ `CacheNodeType`— tipe node baru yang lebih besar dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penaikan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ApplyImmediately=true
&CacheNodeType=cache.m3.2xlarge
&CacheParameterGroupName=redis32-m3-2xl
&ReplicationGroupId=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) di *Referensi Amazon ElastiCache API*.
1. Jika Anda menggunakan `ApplyImmediately``=true`, pantau status grup replikasi menggunakan `DescribeReplicationGroups` aksi ElastiCache API dengan parameter berikut. Ketika status berubah dari *mengubah* ke *tersedia*, Anda dapat mulai menulis ke grup replikasi baru yang telah dinaikkan skalanya.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html) di *Referensi Amazon ElastiCache API*.
## Menskalakan cluster Valkey atau Redis OSS dengan replika
Bagian berikut memandu Anda melalui cara menskalakan cluster Valkey atau Redis OSS (mode cluster dinonaktifkan) dengan node replika ke tipe node yang lebih kecil. Untuk meraih keberhasilan, sangat penting untuk memastikan bahwa jenis simpul baru yang lebih kecil memiliki kapasitas cukup besar untuk mengakomodasi semua data dan overhead. Untuk informasi selengkapnya, lihat [Memastikan Anda memiliki cukup memori untuk membuat snapshot Valkey atau Redis OSS](BestPractices.BGSAVE.md).
**catatan**
Untuk klaster yang menjalankan simpul jenis r6gd, Anda hanya dapat menskalakan ke ukuran simpul dalam keluarga simpul r6gd.
**penting**
Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, sebelum Anda mulai menskalakan pastikan bahwa Anda memiliki grup parameter khusus yang menyimpan jumlah memori yang benar untuk jenis node baru Anda. Sebagai alternatif, Anda dapat mengubah grup parameter kustom agar menggunakan `reserved-memory-percent` dan menggunakan grup parameter tersebut untuk klaster baru Anda.
Jika menggunakan `reserved-memory-percent`, Anda tidak perlu melakukan ini.
Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
**Topics**
### Menskalakan cluster Valkey atau Redis OSS dengan replika (Konsol)
Proses berikut menskalakan cluster Valkey atau Redis OSS Anda dengan node replika ke tipe node yang lebih kecil menggunakan konsol. ElastiCache
**Untuk menurunkan kluster Valkey atau Redis OSS dengan node replika (konsol)**
1. Pastikan bahwa jenis simpul yang lebih kecil memadai untuk data dan kebutuhan overhead Anda.
1. Jika grup parameter Anda menggunakan `reserved-memory` untuk menyisihkan memori untuk overhead Valkey atau Redis OSS, pastikan Anda memiliki grup parameter khusus untuk menyisihkan jumlah memori yang benar untuk jenis node baru Anda.
Sebagai alternatif, Anda dapat mengubah grup parameter kustom untuk menggunakan `reserved-memory-percent`. Untuk informasi selengkapnya, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari daftar klaster, pilih klaster yang ingin Anda turunkan skalanya. Cluster ini harus menjalankan mesin Valkey atau Redis OSS dan bukan mesin Valkey atau Redis OSS yang berkerumun.
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul yang Anda inginkan untuk penurunan skala dari daftar **Jenis simpul**.
1. Jika Anda menggunakan `reserved-memory` untuk mengelola memori, dari daftar **Grup Parameter**, pilih grup parameter kustom yang mencadangkan jumlah memori yang benar untuk jenis simpul baru Anda.
1. Jika Anda ingin segera menurunkan skala, pilih kotak centang **Terapkan segera**. Jika kotak centang **Terapkan segera** tidak dipilih, proses penurunan skala akan dilakukan selama periode pemeliharaan berikutnya dari klaster ini.
1. Pilih **Ubah**.
1. Ketika status klaster berubah dari *mengubah* ke *tersedia*, artinya klaster Anda telah diskalakan ke jenis simpul baru. Tidak perlu memperbarui titik akhir dalam aplikasi Anda.
### Menskalakan grup replikasi Valkey atau Redis OSS ()AWS CLI
Proses berikut menskalakan grup replikasi Anda dari jenis simpul saat ini ke jenis simpul baru yang lebih kecil menggunakan AWS CLI. Selama proses ini, ElastiCache update entri DNS sehingga mereka menunjuk ke node baru. Karena hal ini, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Untuk Valkey 7.2 di atas atau Redis OSS 5.0.5 ke atas, Anda dapat menskalakan kluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada versi 4.0.10 ke bawah, Anda mungkin merasakan gangguan singkat terhadap operasi baca dan tulis pada versi sebelumnya dari simpul primer saat entri DNS diperbarui.
Namun, pembacaan dari cluster replika baca terus tanpa gangguan.
Jumlah waktu yang diperlukan untuk menurunkan ke tipe node yang lebih kecil bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Untuk menurunkan Grup Replikasi Valkey atau Redis OSS ()AWS CLI**
1. Tentukan jenis node mana yang dapat Anda turunkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
+ `--replication-group-id` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--replication-group-id my-repl-group
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--replication-group-id my-repl-group
```
Output dari operasi ini terlihat seperti berikut (format JSON).
```
{
"ScaleDownModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Skala grup replikasi Anda saat ini hingga tipe node baru menggunakan AWS CLI`modify-replication-group` perintah dengan parameter berikut.
+ `--replication-group-id` – nama grup replikasi.
+ `--cache-node-type`— tipe node baru yang lebih kecil dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `list-allowed-node-type-modifications` perintah pada langkah sebelumnya.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan operasi penaikan skala segera diterapkan. Untuk menunda operasi penaikan skala ke periode pemeliharaan berikutnya, gunakan `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id my-repl-group \
--cache-node-type cache.t2.small \
--cache-parameter-group-name redis32-m3-2xl \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id my-repl-group ^
--cache-node-type cache.t2.small ^
--cache-parameter-group-name redis32-m3-2xl \
--apply-immediately
```
Output dari perintah ini terlihat seperti berikut (format JSON).
```
{"ReplicationGroup": {
"Status": "available",
"Description": "Some description",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "my-repl-group-001.8fdx4s.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "my-repl-group-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "my-repl-group-002.8fdx4s.0001.usw2.cache.amazonaws.com"
},
"CacheClusterId": "my-repl-group-002"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "my-repl-group.8fdx4s.ng.0001.usw2.cache.amazonaws.com"
}
}
],
"ReplicationGroupId": "my-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "disabled",
"SnapshotWindow": "12:00-13:00",
"SnapshottingClusterId": "my-repl-group-002",
"MemberClusters": [
"my-repl-group-001",
"my-repl-group-002",
],
"PendingModifiedValues": {}
}
}
```
Untuk informasi selengkapnya, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan `--apply-immediately` parameter, pantau status grup replikasi menggunakan AWS CLI`describe-replication-group` perintah dengan parameter berikut. Ketika status berubah dari *mengubah* ke *tersedia*, Anda dapat mulai menulis ke grup replikasi baru yang telah diturunkan skalanya.
+ `--replication-group-id` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache describe-replication-group \
--replication-group-id my-replication-group
```
Untuk Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id my-replication-group
```
Untuk informasi selengkapnya, lihat [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) dalam *Referensi AWS CLI*.
### Memperkecil grup replikasi Valkey atau Redis OSS (API) ElastiCache
Proses berikut menskalakan grup replikasi Anda dari tipe node saat ini ke tipe node baru yang lebih kecil menggunakan ElastiCache API. Selama proses ini, ElastiCache update entri DNS sehingga mereka menunjuk ke node baru. Karena hal ini, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Untuk Valkey 7.2 dan yang lebih baru atau Redis OSS 5.0.5 ke atas, Anda dapat menskalakan cluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada Redis OSS versi 4.0.10 dan di bawahnya, Anda mungkin melihat gangguan singkat membaca dan menulis pada versi sebelumnya dari node utama saat entri DNS diperbarui.. Namun, pembacaan dari cluster replika baca terus tanpa gangguan.
Jumlah waktu yang diperlukan untuk menurunkan ke tipe node yang lebih kecil bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Untuk mengurangi Grup Replikasi Valkey atau Redis OSS (API) ElastiCache**
1. Tentukan tipe node mana yang dapat Anda turunkan untuk menggunakan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Skalakan grup replikasi Anda saat ini hingga tipe node baru menggunakan aksi `ModifyReplicationGroup` ElastiCache API dan dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi.
+ `CacheNodeType`— tipe node baru yang lebih kecil dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penaikan skala segera diterapkan. Untuk menunda proses penurunan skala ke periode pemeliharaan berikutnya, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ApplyImmediately=true
&CacheNodeType=cache.m3.2xlarge
&CacheParameterGroupName=redis32-m3-2xl
&ReplicationGroupId=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) di *Referensi Amazon ElastiCache API*.
1. Jika Anda menggunakan `ApplyImmediately``=true`, pantau status grup replikasi menggunakan `DescribeReplicationGroups` aksi ElastiCache API dengan parameter berikut. Ketika status berubah dari *mengubah* ke *tersedia*, Anda dapat mulai menulis ke grup replikasi baru yang telah diturunkan skalanya.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html) di *Referensi Amazon ElastiCache API*.
## Meningkatkan kapasitas baca
Untuk meningkatkan kapasitas baca, tambahkan replika baca (hingga maksimal lima) ke grup replikasi Valkey atau Redis OSS Anda.
Anda dapat menskalakan kapasitas baca cluster Valkey atau Redis OSS Anda menggunakan ElastiCache konsol, the AWS CLI, atau API. ElastiCache Untuk informasi selengkapnya, lihat [Menambahkan replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Replication.AddReadReplica.md).
## Mengurangi kapasitas baca
Untuk mengurangi kapasitas baca, hapus satu atau lebih replika baca dari cluster Valkey atau Redis OSS Anda dengan replika (disebut grup replikasi di API/CLI)*.* Jika klaster adalah Multi-AZ yang mengaktifkan failover otomatis, Anda tidak dapat menghapus replika baca terakhir tanpa menonaktifkan Multi-AZ terlebih dahulu. Untuk informasi selengkapnya, lihat [Mengubah grup replikasi](Replication.Modify.md).
Lihat informasi yang lebih lengkap di [Menghapus replika baca untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)](Replication.RemoveReadReplica.md).
# Penskalaan klaster Valkey atau Redis OSS (Mode Cluster Diaktifkan)
Saat permintaan pada klaster Anda berubah, Anda mungkin memutuskan untuk meningkatkan kinerja atau mengurangi biaya dengan mengubah jumlah pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda. Sebaiknya gunakan penskalaan horizontal online untuk melakukan tindakan tersebut. Dengan begitu, klaster Anda dapat terus melayani permintaan selama proses penskalaan.
Kondisi berikut dapat menjadi faktor yang membuat Anda memutuskan menskalakan ulang klaster:
+ **Tekanan memori:**
Jika simpul di klaster Anda mengalami tekanan memori, sebaiknya pertimbangkan untuk menskalakan ke luar agar memiliki lebih banyak sumber daya untuk menyimpan data dan melayani permintaan dengan lebih baik.
Anda dapat menentukan apakah node Anda berada di bawah tekanan memori dengan memantau metrik berikut: *FreeableMemory*, *SwapUsage*, dan *BytesUsedForCache*.
+ **Hambatan CPU atau jaringan:**
Jika latency/throughput masalah mengganggu klaster Anda, Anda mungkin perlu meningkatkan skala untuk menyelesaikan masalah.
Anda dapat memantau tingkat latensi dan throughput Anda dengan memantau metrik berikut: *CPUUtilization*,,, *NetworkBytesIn*NetworkBytesOut**, *CurrConnections*dan. *NewConnections*
+ **Klaster Anda diskalakan berlebih:**
Permintaan saat ini pada klaster Anda dalam kondisi yang membuat penskalaan ke dalam tidak mengganggu performa dan mengurangi biaya.
Anda dapat memantau penggunaan klaster untuk menentukan apakah Anda dapat menskalakan dengan aman menggunakan metrik berikut: *FreeableMemory*,,, *SwapUsage*, *BytesUsedForCache*, *CPUUtilization*, *NetworkBytesIn*, *NetworkBytesOut*CurrConnections**, dan *NewConnections*.
**Dampak Performa dari Penskalaan**
Ketika Anda menskalakan menggunakan proses offline, klaster akan offline selama sebagian besar proses dan dengan demikian tidak dapat melayani permintaan. Ketika Anda menskalakan menggunakan metode online, karena penskalaan adalah operasi sarat komputasi, ada beberapa penurunan dalam performa, namun, klaster Anda terus melayani permintaan selama operasi penskalaan. Berapa banyak penurunan yang Anda alami bergantung pada pemanfaatan CPU normal dan data Anda.
Ada dua cara untuk menskalakan cluster Valkey atau Redis OSS (mode cluster enabled) Anda; penskalaan horizontal dan vertikal.
+ Penskalaan horizontal mengizinkan Anda mengubah jumlah grup simpul (serpihan) dalam grup replikasi dengan menambahkan atau menghapus grup simpul (serpihan). Proses resharding online memungkinkan penskalaan in/out sementara klaster terus melayani permintaan yang masuk.
Konfigurasikan slot di klaster baru Anda secara berbeda dari slot yang berada di klaster lama. Metode offline saja.
+ Penskalaan Vertikal - Ubah jenis simpul untuk mengubah ukuran klaster. Penskalaan vertikal online memungkinkan penskalaan up/down sementara klaster terus melayani permintaan yang masuk.
Jika Anda mengurangi ukuran dan kapasitas memori cluster, baik dengan skala atau scaling down, pastikan bahwa konfigurasi baru memiliki memori yang cukup untuk data Anda dan Valkey atau Redis OSS overhead.
Untuk informasi selengkapnya, lihat [Memilih ukuran simpul Anda](CacheNodes.SelectSize.md).
**Contents**
+ [Resharding offline untuk Valkey atau Redis OSS (mode cluster diaktifkan)](#redis-cluster-resharding-offline)
+ [Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)](#redis-cluster-resharding-online)
+ [Menambahkan serpihan dengan resharding online](#redis-cluster-resharding-online-add)
+ [Menghapus serpihan dengan resharding online](#redis-cluster-resharding-online-remove)
+ [Menghapus serpihan (Konsol)](#redis-cluster-resharding-online-remove-console)
+ [Menghapus serpihan (AWS CLI)](#redis-cluster-resharding-online-remove-cli)
+ [Menghapus serpihan (API ElastiCache)](#redis-cluster-resharding-online-remove-api)
+ [Penyeimbangan ulang serpihan secara online](#redis-cluster-resharding-online-rebalance)
+ [Penyeimbangan Ulang Serpihan Secara Online (Konsol)](#redis-cluster-resharding-online-rebalance-console)
+ [Penyeimbangan ulang serpihan secara online (AWS CLI)](#redis-cluster-resharding-online-rebalance-cli)
+ [Penyeimbangan kembali pecahan online (API) ElastiCache](#redis-cluster-resharding-online-rebalance-api)
+ [Penskalaan vertikal online dengan mengubah jenis simpul](redis-cluster-vertical-scaling.md)
+ [Penskalaan ke atas secara online](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-scaling-up)
+ [Meningkatkan klaster Valkey atau Redis OSS (Konsol)](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-console)
+ [Meningkatkan klaster Valkey atau Redis OSS ()AWS CLI](redis-cluster-vertical-scaling.md#Scaling.RedisStandalone.ScaleUp.CLI)
+ [Meningkatkan klaster Valkey atau Redis OSS (API) ElastiCache](redis-cluster-vertical-scaling.md#VeticalScaling.RedisReplGrps.ScaleUp.API)
+ [Penskalaan ke bawah secara online](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-scaling-down)
+ [Menskalakan cluster Valkey atau Redis OSS (Konsol)](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-down-console)
+ [Menskalakan cluster Valkey atau Redis OSS ()AWS CLI](redis-cluster-vertical-scaling.md#Scaling.RedisStandalone.ScaleDown.CLI)
+ [Memperkecil klaster Valkey atau Redis OSS (API) ElastiCache](redis-cluster-vertical-scaling.md#Scaling.Vertical.ScaleDown.API)
## Resharding offline untuk Valkey atau Redis OSS (mode cluster diaktifkan)
Keuntungan utama yang Anda dapatkan dari konfigurasi ulang serpihan secara offline adalah bahwa Anda dapat melakukan lebih dari sekadar menambahkan atau menghapus serpihan dari grup replikasi Anda. Saat Anda melakukan reshard dan menyeimbangkan ulang secara offline, selain mengubah jumlah pecahan di grup replikasi Anda, Anda dapat melakukan hal berikut:
**catatan**
Resharding offline tidak didukung pada cluster Valkey atau Redis OSS dengan tiering data diaktifkan. Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
+ Ubah jenis simpul grup replikasi Anda.
+ Tentukan Zona Ketersediaan untuk setiap simpul dalam grup replikasi.
+ Tingkatkan ke versi mesin yang lebih baru.
+ Tentukan jumlah simpul replika di setiap serpihan secara independen.
+ Tentukan ruang kunci untuk setiap serpihan.
Kekurangan utama dari konfigurasi ulang serpihan secara offline adalah bahwa klaster Anda offline dimulai dari bagian pemulihan dari proses berlanjut sampai Anda memperbarui titik akhir dalam aplikasi Anda. Durasi offline klaster Anda akan bervariasi tergantung jumlah data dalam klaster Anda.
**Untuk mengkonfigurasi ulang pecahan Anda Valkey atau Redis OSS (mode cluster diaktifkan) cluster offline**
1. Buat cadangan manual dari cluster Valkey atau Redis OSS Anda yang ada. Untuk informasi selengkapnya, lihat [Membuat cadangan manual](backups-manual.md).
1. Buat klaster baru dengan memulihkan dari cadangan. Untuk informasi selengkapnya, lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
1. Perbarui titik akhir dalam aplikasi Anda untuk titik akhir klaster baru. Untuk informasi selengkapnya, lihat [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md).
## Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)
Dengan menggunakan resharding online dan shard rebalancing dengan ElastiCache Valkey 7.2 atau yang lebih baru, atau Redis OSS versi 3.2.10 atau yang lebih baru, Anda dapat menskalakan cluster Valkey atau Redis OSS (mode cluster enabled) secara dinamis tanpa downtime. Pendekatan ini berarti bahwa klaster Anda dapat terus melayani permintaan bahkan saat penskalaan atau penyeimbangan ulang sedang dalam proses.
Anda dapat melakukan tindakan berikut:
+ **Tingkatkan kapasitas baca dan tulis dengan menambahkan pecahan (grup simpul) ke cluster Valkey atau Redis OSS (mode cluster diaktifkan) Anda (grup replikasi).**
Jika Anda menambahkan satu atau beberapa serpihan ke grup replikasi, simpul di setiap serpihan baru memiliki jumlah sama dengan jumlah simpul dalam serpihan terkecil yang ada.
+ **Skala** - Kurangi kapasitas baca dan tulis, dan dengan demikian biayanya, dengan menghapus pecahan dari cluster Valkey atau Redis OSS (mode cluster enabled) Anda.
+ **Rebalance** — Pindahkan ruang kunci di antara pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda sehingga mereka didistribusikan secara merata di antara pecahan mungkin.
Anda tidak dapat melakukan hal berikut:
+ **Mengonfigurasi serpihan secara independen:**
Anda tidak dapat menentukan ruang kunci untuk serpihan secara independen. Untuk melakukan tindakan ini, Anda harus menggunakan proses offline.
Saat ini, batasan berikut berlaku untuk resharding dan rebalancing ElastiCache online:
+ Proses ini membutuhkan Valkey 7.2 dan yang lebih baru atau Redis OSS 3.2.10 atau yang lebih baru. Untuk informasi selengkapnya tentang cara meningkatkan versi mesin, lihat [Manajemen Versi untuk ElastiCache](VersionManagement.md).
+ Terdapat batasan dengan slot atau ruang kunci dan item besar:
Jika salah satu kunci dalam serpihan berisi item besar, kunci tersebut tidak dimigrasikan ke serpihan baru ketika penskalaan ke luar atau penyeimbangan ulang dilakukan. Fungsi ini dapat menghasilkan serpihan yang tidak seimbang.
Jika salah satu kunci dalam serpihan berisi item besar (item yang lebih besar dari 256 MB setelah serialisasi), serpihan tersebut tidak dihapus ketika penskalaan ke dalam dilakukan. Fungsi ini dapat mengakibatkan beberapa serpihan tidak dihapus.
+ Ketika menskalakan ke luar, jumlah simpul dalam serpihan baru sama dengan jumlah simpul dalam serpihan terkecil yang ada.
+ Ketika menskalakan ke luar, setiap tag yang umum untuk semua serpihan yang ada akan disalin ke serpihan baru.
+ Saat menskalakan cluster Global Data Store, tidak ElastiCache akan secara otomatis mereplikasi Fungsi dari salah satu node yang ada ke node baru. Sebaiknya muat Fungsi Anda di serpihan baru setelah menskalakan klaster ke luar sehingga setiap serpihan memiliki fungsi yang sama.
**catatan**
ElastiCache Untuk Valkey 7.2 dan di atasnya, dan ElastiCache untuk Redis OSS versi 7 ke atas: Saat menskalakan cluster Anda, ElastiCache akan secara otomatis mereplikasi Fungsi yang dimuat di salah satu node yang ada (dipilih secara acak) ke node baru. Jika aplikasi Anda menggunakan [Functions](https://valkey.io/topics/functions-intro/), kami sarankan memuat semua fungsi Anda ke semua pecahan sebelum melakukan scaling out sehingga cluster Anda tidak berakhir dengan definisi fungsi yang berbeda pada pecahan yang berbeda.
Untuk informasi selengkapnya, lihat [Perubahan ukuran klaster online](best-practices-online-resharding.md).
Anda dapat menskalakan atau menyeimbangkan kembali cluster Valkey atau Redis OSS (mode cluster enabled) secara horizontal menggunakan Konsol Manajemen AWS, the, dan API.AWS CLI ElastiCache
### Menambahkan serpihan dengan resharding online
Anda dapat menambahkan pecahan ke cluster Valkey atau Redis OSS (mode cluster enabled) menggunakan Konsol Manajemen AWS,,AWS CLI atau API. ElastiCache Saat Anda menambahkan pecahan ke cluster Valkey atau Redis OSS (mode cluster enabled), tag apa pun pada pecahan yang ada disalin ke pecahan baru.
**Topics**
#### Menambahkan serpihan (Konsol)
Anda dapat menggunakan Konsol Manajemen AWS untuk menambahkan satu atau lebih pecahan ke cluster Valkey atau Redis OSS (mode cluster enabled) Anda. Prosedur berikut menjelaskan prosesnya.
**Untuk menambahkan pecahan ke klaster Valkey atau Redis OSS (mode cluster diaktifkan)**
1. Buka ElastiCache konsol di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau cluster** **Redis** OSS.
1. Cari dan pilih nama, bukan kotak di sebelah kiri nama cluster, dari cluster Valkey atau Redis OSS (mode cluster enabled) yang ingin Anda tambahkan pecahan.
**Tip**
**Valkey atau Redis OSS (mode cluster diaktifkan) menunjukkan **Clustered Valkey atau Clustered** Redis OSS di **kolom** Mode**
1. Pilih **Tambahkan serpihan**.
1. Untuk **Jumlah serpihan yang akan ditambahkan**, pilih jumlah serpihan yang ingin Anda tambahkan ke klaster ini.
1. Untuk **Zona Ketersediaan**, pilih **Tidak ada preferensi** atau **Tentukan zona ketersediaan**.
1. Jika Anda memilih **Tentukan zona ketersediaan**, untuk setiap simpul dalam setiap serpihan, pilih Zona Ketersediaan simpul dari daftar Zona Ketersediaan.
1. Pilih **Tambahkan**.
#### Menambahkan serpihan (AWS CLI)
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menambahkan pecahan menggunakan file.AWS CLI
Gunakan parameter berikut dengan `modify-replication-group-shard-configuration`.
**Parameter**
+ `--apply-immediately` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `--replication-group-id` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `--node-group-count` – Wajib. Menentukan jumlah serpihan (grup simpul) yang ada ketika operasi selesai. Saat menambahkan serpihan, nilai `--node-group-count` harus lebih besar dari jumlah serpihan saat ini.
Jika perlu, Anda dapat menentukan Zona Ketersediaan untuk setiap simpul dalam grup replikasi menggunakan `--resharding-configuration`.
+ `--resharding-configuration` – Opsional. Daftar Zona Ketersediaan pilihan untuk setiap simpul di setiap serpihan dalam grup replikasi. Gunakan parameter ini hanya jika nilai `--node-group-count` lebih besar dari jumlah serpihan saat ini. Jika parameter ini dihilangkan saat menambahkan pecahan, Amazon ElastiCache memilih Availability Zones untuk node baru.
Contoh berikut mengkonfigurasi ulang ruang kunci di atas empat pecahan dalam klaster Valkey atau Redis OSS (mode cluster enabled) bernama. `my-cluster` Contoh ini juga menentukan Zona Ketersediaan untuk setiap simpul di setiap serpihan. Operasi segera dimulai.
**Example - Menambahkan Serpihan**
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group-shard-configuration \
--replication-group-id my-cluster \
--node-group-count 4 \
--resharding-configuration \
"PreferredAvailabilityZones=us-east-2a,us-east-2c" \
"PreferredAvailabilityZones=us-east-2b,us-east-2a" \
"PreferredAvailabilityZones=us-east-2c,us-east-2d" \
"PreferredAvailabilityZones=us-east-2d,us-east-2c" \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group-shard-configuration ^
--replication-group-id my-cluster ^
--node-group-count 4 ^
--resharding-configuration ^
"PreferredAvailabilityZones=us-east-2a,us-east-2c" ^
"PreferredAvailabilityZones=us-east-2b,us-east-2a" ^
"PreferredAvailabilityZones=us-east-2c,us-east-2d" ^
"PreferredAvailabilityZones=us-east-2d,us-east-2c" ^
--apply-immediately
```
Untuk informasi selengkapnya, lihat [modify-replication-group-shard-konfigurasi](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group-shard-configuration.html) dalam AWS CLI dokumentasi.
#### Menambahkan pecahan (ElastiCache API)
Anda dapat menggunakan ElastiCache API untuk mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda secara online dengan menggunakan operasi. `ModifyReplicationGroupShardConfiguration`
Gunakan parameter berikut dengan `ModifyReplicationGroupShardConfiguration`.
**Parameter**
+ `ApplyImmediately=true` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `ReplicationGroupId` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `NodeGroupCount` – Wajib. Menentukan jumlah serpihan (grup simpul) yang ada ketika operasi selesai. Saat menambahkan serpihan, nilai `NodeGroupCount` harus lebih besar dari jumlah serpihan saat ini.
Jika perlu, Anda dapat menentukan Zona Ketersediaan untuk setiap simpul dalam grup replikasi menggunakan `ReshardingConfiguration`.
+ `ReshardingConfiguration` – Opsional. Daftar Zona Ketersediaan pilihan untuk setiap simpul di setiap serpihan dalam grup replikasi. Gunakan parameter ini hanya jika nilai `NodeGroupCount` lebih besar dari jumlah serpihan saat ini. Jika parameter ini dihilangkan saat menambahkan pecahan, Amazon ElastiCache memilih Availability Zones untuk node baru.
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menambahkan pecahan menggunakan API. ElastiCache
**Example - Menambahkan Serpihan**
Contoh berikut menambahkan grup node ke cluster Valkey atau Redis OSS (mode cluster enabled)`my-cluster`, sehingga ada total empat kelompok node ketika operasi selesai. Contoh ini juga menentukan Zona Ketersediaan untuk setiap simpul di setiap serpihan. Operasi segera dimulai.
```
https://elasticache.us-east-2.amazonaws.com/
?Action=ModifyReplicationGroupShardConfiguration
&ApplyImmediately=true
&NodeGroupCount=4
&ReplicationGroupId=my-cluster
&ReshardingConfiguration.ReshardingConfiguration.1.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2a
&ReshardingConfiguration.ReshardingConfiguration.1.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2c
&ReshardingConfiguration.ReshardingConfiguration.2.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2b
&ReshardingConfiguration.ReshardingConfiguration.2.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2a
&ReshardingConfiguration.ReshardingConfiguration.3.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2c
&ReshardingConfiguration.ReshardingConfiguration.3.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2d
&ReshardingConfiguration.ReshardingConfiguration.4.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2d
&ReshardingConfiguration.ReshardingConfiguration.4.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2c
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20171002T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ModifyReplicationGroupShardConfiguration](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html)di Referensi ElastiCache API.
### Menghapus serpihan dengan resharding online
Anda dapat menghapus pecahan dari cluster Valkey atau Redis OSS (mode cluster enabled) menggunakan Konsol Manajemen AWS,,AWS CLI atau API. ElastiCache
**Topics**
+ [Menghapus serpihan (Konsol)](#redis-cluster-resharding-online-remove-console)
+ [Menghapus serpihan (AWS CLI)](#redis-cluster-resharding-online-remove-cli)
+ [Menghapus serpihan (API ElastiCache)](#redis-cluster-resharding-online-remove-api)
#### Menghapus serpihan (Konsol)
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menghapus pecahan menggunakan file.Konsol Manajemen AWS
Sebelum menghapus grup node (pecahan) dari grup replikasi Anda, ElastiCache pastikan semua data Anda sesuai dengan pecahan yang tersisa. Jika data tercakup, serpihan yang ditentukan akan dihapus dari grup replikasi seperti yang diminta. Jika data tidak tercakup di grup simpul yang tersisa, proses akan dihentikan dan grup replikasi memiliki konfigurasi grup simpul yang sama seperti sebelum permintaan dibuat.
Anda dapat menggunakan Konsol Manajemen AWS untuk menghapus satu atau lebih pecahan dari cluster Valkey atau Redis OSS (mode cluster enabled) Anda. Anda tidak dapat menghapus semua serpihan dalam grup replikasi. Sebaliknya, Anda harus menghapus grup replikasi. Untuk informasi selengkapnya, lihat [Menghapus grup replikasi](Replication.DeletingRepGroup.md). Prosedur berikut menjelaskan proses untuk menghapus satu atau lebih serpihan.
**Untuk menghapus pecahan dari cluster Valkey atau Redis OSS (mode cluster diaktifkan)**
1. Buka ElastiCache konsol di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau cluster** **Redis** OSS.
1. Cari dan pilih nama, bukan kotak di sebelah kiri nama cluster, dari cluster Valkey atau Redis OSS (mode cluster diaktifkan) yang ingin Anda hapus dari pecahan.
**Tip**
**Cluster Valkey atau Redis OSS (mode cluster enabled) memiliki nilai 1 atau lebih besar di kolom Shards.**
1. Dari daftar serpihan, pilih kotak di sebelah kiri nama setiap serpihan yang ingin Anda hapus.
1. Pilih **Hapus serpihan**.
#### Menghapus serpihan (AWS CLI)
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menghapus pecahan menggunakan file.AWS CLI
**penting**
Sebelum menghapus grup node (pecahan) dari grup replikasi Anda, ElastiCache pastikan semua data Anda sesuai dengan pecahan yang tersisa. Jika data tercakup, serpihan yang ditentukan (`--node-groups-to-remove`) akan dihapus dari grup replikasi seperti yang diminta dan ruang kunci terkait akan dipetakan ke serpihan yang tersisa. Jika data tidak tercakup di grup simpul yang tersisa, proses akan dihentikan dan grup replikasi yang tersisa memiliki konfigurasi grup simpul yang sama seperti sebelum permintaan dibuat.
Anda dapat menggunakan AWS CLI untuk menghapus satu atau lebih pecahan dari cluster Valkey atau Redis OSS (mode cluster enabled) Anda. Anda tidak dapat menghapus semua serpihan dalam grup replikasi. Sebaliknya, Anda harus menghapus grup replikasi. Untuk informasi selengkapnya, lihat [Menghapus grup replikasi](Replication.DeletingRepGroup.md).
Gunakan parameter berikut dengan `modify-replication-group-shard-configuration`.
**Parameter**
+ `--apply-immediately` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `--replication-group-id` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `--node-group-count` – Wajib. Menentukan jumlah serpihan (grup simpul) yang ada ketika operasi selesai. Saat menghapus serpihan, nilai `--node-group-count` harus kurang dari jumlah serpihan saat ini.
+ `--node-groups-to-remove` – Wajib jika `--node-group-count` kurang dari jumlah grup simpul (serpihan) saat ini. Daftar pecahan (grup simpul) IDs untuk dihapus dari grup replikasi.
Prosedur berikut menjelaskan proses untuk menghapus satu atau beberapa serpihan.
**Example - Menghapus Serpihan**
Contoh berikut menghapus dua kelompok node dari Valkey atau Redis OSS (cluster mode enabled) cluster`my-cluster`, sehingga ada total dua kelompok node ketika operasi selesai. Ruang Kunci dari serpihan yang dihapus didistribusikan secara merata ke serpihan yang tersisa.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group-shard-configuration \
--replication-group-id my-cluster \
--node-group-count 2 \
--node-groups-to-remove "0002" "0003" \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group-shard-configuration ^
--replication-group-id my-cluster ^
--node-group-count 2 ^
--node-groups-to-remove "0002" "0003" ^
--apply-immediately
```
#### Menghapus serpihan (API ElastiCache)
Anda dapat menggunakan ElastiCache API untuk mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda secara online dengan menggunakan operasi. `ModifyReplicationGroupShardConfiguration`
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menghapus pecahan menggunakan API. ElastiCache
**penting**
Sebelum menghapus grup node (pecahan) dari grup replikasi Anda, ElastiCache pastikan semua data Anda sesuai dengan pecahan yang tersisa. Jika data tercakup, serpihan yang ditentukan (`NodeGroupsToRemove`) akan dihapus dari grup replikasi seperti yang diminta dan ruang kunci terkait akan dipetakan ke serpihan yang tersisa. Jika data tidak tercakup di grup simpul yang tersisa, proses akan dihentikan dan grup replikasi yang tersisa memiliki konfigurasi grup simpul yang sama seperti sebelum permintaan dibuat.
Anda dapat menggunakan ElastiCache API untuk menghapus satu atau beberapa pecahan dari klaster Valkey atau Redis OSS (mode cluster enabled). Anda tidak dapat menghapus semua serpihan dalam grup replikasi. Sebaliknya, Anda harus menghapus grup replikasi. Untuk informasi selengkapnya, lihat [Menghapus grup replikasi](Replication.DeletingRepGroup.md).
Gunakan parameter berikut dengan `ModifyReplicationGroupShardConfiguration`.
**Parameter**
+ `ApplyImmediately=true` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `ReplicationGroupId` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `NodeGroupCount` – Wajib. Menentukan jumlah serpihan (grup simpul) yang ada ketika operasi selesai. Saat menghapus serpihan, nilai `NodeGroupCount` harus kurang dari jumlah serpihan saat ini.
+ `NodeGroupsToRemove` – Wajib jika `--node-group-count` kurang dari jumlah grup simpul (serpihan) saat ini. Daftar pecahan (grup simpul) IDs untuk dihapus dari grup replikasi.
Prosedur berikut menjelaskan proses untuk menghapus satu atau beberapa serpihan.
**Example - Menghapus Serpihan**
Contoh berikut menghapus dua kelompok node dari Valkey atau Redis OSS (cluster mode enabled) cluster`my-cluster`, sehingga ada total dua kelompok node ketika operasi selesai. Ruang Kunci dari serpihan yang dihapus didistribusikan secara merata ke serpihan yang tersisa.
```
https://elasticache.us-east-2.amazonaws.com/
?Action=ModifyReplicationGroupShardConfiguration
&ApplyImmediately=true
&NodeGroupCount=2
&ReplicationGroupId=my-cluster
&NodeGroupsToRemove.member.1=0002
&NodeGroupsToRemove.member.2=0003
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20171002T192317Z
&X-Amz-Credential=
```
### Penyeimbangan ulang serpihan secara online
Anda dapat menyeimbangkan kembali pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) menggunakan,, atau API.Konsol Manajemen AWSAWS CLI ElastiCache
**Topics**
+ [Penyeimbangan Ulang Serpihan Secara Online (Konsol)](#redis-cluster-resharding-online-rebalance-console)
+ [Penyeimbangan ulang serpihan secara online (AWS CLI)](#redis-cluster-resharding-online-rebalance-cli)
+ [Penyeimbangan kembali pecahan online (API) ElastiCache](#redis-cluster-resharding-online-rebalance-api)
#### Penyeimbangan Ulang Serpihan Secara Online (Konsol)
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menyeimbangkan kembali pecahan menggunakan file.Konsol Manajemen AWS
**Untuk menyeimbangkan kembali ruang kunci di antara pecahan pada klaster Valkey atau Redis OSS (mode cluster diaktifkan)**
1. Buka ElastiCache konsol di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau cluster** **Redis** OSS.
1. Pilih nama, bukan kotak di sebelah kiri nama, dari cluster Valkey atau Redis OSS (mode cluster enabled) yang ingin Anda seimbangkan kembali.
**Tip**
**Cluster Valkey atau Redis OSS (mode cluster enabled) memiliki nilai 1 atau lebih besar di kolom Shards.**
1. Pilih **Seimbangkan ulang**.
1. Saat diminta, pilih **Seimbangkan ulang**. Anda mungkin melihat pesan yang mirip dengan yang ini:*Slots in the replication group are uniformly distributed. Nothing to do. (Service: AmazonElastiCache; Status Code: 400; Error Code: InvalidReplicationGroupState; Request ID: 2246cebd-9721-11e7-8d5b-e1b0f086c8cf)*. Jika melihat pesan di atas, pilih **Batalkan**.
#### Penyeimbangan ulang serpihan secara online (AWS CLI)
Gunakan parameter berikut dengan `modify-replication-group-shard-configuration`.
**Parameter**
+ `-apply-immediately` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `--replication-group-id` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `--node-group-count` – Wajib. Untuk menyeimbangkan ulang ruang kunci di semua serpihan dalam klaster, nilai ini harus sama dengan jumlah serpihan saat ini.
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di cluster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menyeimbangkan kembali pecahan menggunakan file.AWS CLI
**Example - Menyeimbangkan ulang serpihan dalam Klaster**
Contoh berikut menyeimbangkan kembali slot di cluster Valkey atau Redis OSS (mode cluster enabled) `my-cluster` sehingga slot didistribusikan sama mungkin. Nilai dari `--node-group-count` (`4`) adalah jumlah serpihan saat ini dalam klaster.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group-shard-configuration \
--replication-group-id my-cluster \
--node-group-count 4 \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group-shard-configuration ^
--replication-group-id my-cluster ^
--node-group-count 4 ^
--apply-immediately
```
#### Penyeimbangan kembali pecahan online (API) ElastiCache
Anda dapat menggunakan ElastiCache API untuk mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda secara online dengan menggunakan operasi. `ModifyReplicationGroupShardConfiguration`
Gunakan parameter berikut dengan `ModifyReplicationGroupShardConfiguration`.
**Parameter**
+ `ApplyImmediately=true` – Wajib. Menentukan operasi konfigurasi ulang serpihan yang akan segera dimulai.
+ `ReplicationGroupId` – Wajib. Menentukan grup replikasi (klaster) mana tempat operasi konfigurasi ulang serpihan akan dilakukan.
+ `NodeGroupCount` – Wajib. Untuk menyeimbangkan ulang ruang kunci di semua serpihan dalam klaster, nilai ini harus sama dengan jumlah serpihan saat ini.
Proses berikut menjelaskan cara mengkonfigurasi ulang pecahan di klaster Valkey atau Redis OSS (mode cluster enabled) Anda dengan menyeimbangkan kembali pecahan menggunakan API. ElastiCache
**Example - Menyeimbangkan Ulang Klaster**
Contoh berikut menyeimbangkan kembali slot di cluster Valkey atau Redis OSS (mode cluster enabled) `my-cluster` sehingga slot didistribusikan sama mungkin. Nilai dari `NodeGroupCount` (`4`) adalah jumlah serpihan saat ini dalam klaster.
```
https://elasticache.us-east-2.amazonaws.com/
?Action=ModifyReplicationGroupShardConfiguration
&ApplyImmediately=true
&NodeGroupCount=4
&ReplicationGroupId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20171002T192317Z
&X-Amz-Credential=
```
# Penskalaan vertikal online dengan mengubah jenis simpul
Dengan menggunakan penskalaan vertikal online dengan Valkey versi 7.2 atau yang lebih baru, atau Redis OSS versi 3.2.10 atau yang lebih baru, Anda dapat menskalakan cluster Valkey atau Redis OSS Anda secara dinamis dengan waktu henti minimal. Ini memungkinkan cluster Valkey atau Redis OSS Anda untuk melayani permintaan bahkan saat penskalaan.
**catatan**
Penskalaan tidak didukung antara klaster tingkatan data (misalnya, klaster yang menggunakan jenis simpul r6gd) dan klaster yang tidak menggunakan tingkatan data (misalnya, klaster yang menggunakan jenis simpul r6g). Untuk informasi selengkapnya, lihat [Tingkatan data di ElastiCache](data-tiering.md).
Anda dapat melakukan tindakan berikut:
+ **Tingkatkan** kapasitas baca dan tulis dengan menyesuaikan tipe node cluster Valkey atau Redis OSS Anda untuk menggunakan tipe node yang lebih besar.
ElastiCache mengubah ukuran cluster Anda secara dinamis sambil tetap online dan melayani permintaan.
+ **Menurunkan skala** – Mengurangi kapasitas baca dan tulis dengan menyesuaikan jenis simpul agar menggunakan simpul yang lebih kecil. Sekali lagi, mengubah ukuran cluster Anda ElastiCache secara dinamis sambil tetap online dan melayani permintaan. Dalam hal ini, Anda mengurangi biaya dengan menurunkan ukuran simpul.
**catatan**
Proses penaikan dan penurunan skala bergantung pada pembuatan klaster dengan jenis simpul yang baru dipilih dan sinkronisasi simpul baru dengan yang sebelumnya. Untuk memastikan up/down aliran skala yang lancar, lakukan hal berikut:
Pastikan Anda memiliki kapasitas ENI (Elastic Network Interface) yang cukup. Jika menurunkan skala, pastikan simpul yang lebih kecil memiliki memori yang cukup untuk menyerap lalu lintas yang diperkirakan.
Untuk praktik terbaik tentang manajemen memori, lihat [Mengelola memori cadangan untuk Valkey dan Redis OSS](redis-memory-management.md).
Sementara proses penskalaan vertikal dirancang untuk tetap sepenuhnya online, hal ini tidak bergantung pada sinkronisasi data antara simpul lama dan simpul baru. Sebaiknya mulai penaikan/penurunan skala selama jam ketika lalu lintas data diperkirakan berada pada tingkat minimum.
Uji perilaku aplikasi Anda selama penskalaan ke dalam di lingkungan persiapan, jika memungkinkan.
**Contents**
+ [Penskalaan ke atas secara online](#redis-cluster-vertical-scaling-scaling-up)
+ [Meningkatkan klaster Valkey atau Redis OSS (Konsol)](#redis-cluster-vertical-scaling-console)
+ [Meningkatkan klaster Valkey atau Redis OSS ()AWS CLI](#Scaling.RedisStandalone.ScaleUp.CLI)
+ [Meningkatkan klaster Valkey atau Redis OSS (API) ElastiCache](#VeticalScaling.RedisReplGrps.ScaleUp.API)
+ [Penskalaan ke bawah secara online](#redis-cluster-vertical-scaling-scaling-down)
+ [Menskalakan cluster Valkey atau Redis OSS (Konsol)](#redis-cluster-vertical-scaling-down-console)
+ [Menskalakan cluster Valkey atau Redis OSS ()AWS CLI](#Scaling.RedisStandalone.ScaleDown.CLI)
+ [Memperkecil klaster Valkey atau Redis OSS (API) ElastiCache](#Scaling.Vertical.ScaleDown.API)
## Penskalaan ke atas secara online
**Topics**
+ [Meningkatkan klaster Valkey atau Redis OSS (Konsol)](#redis-cluster-vertical-scaling-console)
+ [Meningkatkan klaster Valkey atau Redis OSS ()AWS CLI](#Scaling.RedisStandalone.ScaleUp.CLI)
+ [Meningkatkan klaster Valkey atau Redis OSS (API) ElastiCache](#VeticalScaling.RedisReplGrps.ScaleUp.API)
### Meningkatkan klaster Valkey atau Redis OSS (Konsol)
Prosedur berikut menjelaskan cara meningkatkan klaster Valkey atau Redis OSS menggunakan Management Console. ElastiCache Selama proses ini, klaster Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk meningkatkan cluster Valkey atau Redis OSS (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau cluster** **Redis** OSS.
1. Pada daftar klaster, pilih klaster tersebut.
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul sebagai tujuan penskalaan dari daftar **Jenis simpul**. Untuk menaikkan skala, pilih jenis simpul yang lebih besar dari simpul saat ini.
1. Jika Anda ingin segera melakukan proses peningkatan skala, pilih kotak **Terapkan segera**. Jika kotak centang **Terapkan segera** tidak dipilih, proses peningkatan skala akan dilakukan selama periode pemeliharaan berikutnya dari klaster ini.
1. Pilih **Ubah**.
Jika Anda memilih **Terapkan segera** pada langkah sebelumnya, status klaster berubah ke *mengubah*. Ketika status berubah ke *tersedia*, pengubahan selesai dan Anda dapat mulai menggunakan klaster baru tersebut.
### Meningkatkan klaster Valkey atau Redis OSS ()AWS CLI
Prosedur berikut menjelaskan cara meningkatkan cluster Valkey atau Redis OSS menggunakan.AWS CLI Selama proses ini, klaster Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk meningkatkan cluster Valkey atau Redis OSS ()AWS CLI**
1. Tentukan jenis node yang dapat Anda tingkatkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--replication-group-id my-replication-group-id
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--replication-group-id my-replication-group-id
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ScaleUpModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
"ScaleDownModifications": [
"cache.t2.micro",
"cache.t2.small ",
"cache.t2.medium",
"cache.t1.small "
],
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Ubah grup replikasi Anda untuk meningkatkan ke tipe node baru yang lebih besar, menggunakan AWS CLI`modify-replication-group` perintah dan parameter berikut.
+ `--replication-group-id` – Nama grup replikasi yang menjadi tujuan penaikan skala.
+ `--cache-node-type`— Jenis node baru yang ingin Anda skalakan cluster. Nilai ini harus berupa salah satu dari jenis simpul yang dihasilkan oleh perintah `list-allowed-node-type-modifications` di langkah 1.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan operasi penaikan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya untuk klaster, gunakan parameter `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id my-redis-cluster \
--cache-node-type cache.m3.xlarge \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id my-redis-cluster ^
--cache-node-type cache.m3.xlarge ^
--apply-immediately
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ReplicationGroup": {
"Status": "modifying",
"Description": "my-redis-cluster",
"NodeGroups": [
{
"Status": "modifying",
"Slots": "0-16383",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-east-1f",
"CacheNodeId": "0001",
"CacheClusterId": "my-redis-cluster-0001-001"
},
{
"PreferredAvailabilityZone": "us-east-1d",
"CacheNodeId": "0001",
"CacheClusterId": "my-redis-cluster-0001-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "my-redis-cluster.r7gdfi.clustercfg.use1.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "my-redis-cluster",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "07:30-08:30",
"MemberClusters": [
"my-redis-cluster-0001-001",
"my-redis-cluster-0001-002"
],
"CacheNodeType": "cache.m3.xlarge",
"DataTiering": "disabled"
"PendingModifiedValues": {}
}
}
```
Untuk informasi selengkapnya, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan`--apply-immediately`, periksa status cluster menggunakan AWS CLI`describe-cache-clusters` perintah dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan node cluster baru yang lebih besar.
### Meningkatkan klaster Valkey atau Redis OSS (API) ElastiCache
Proses berikut menskalakan klaster Anda dari tipe node saat ini ke tipe node baru yang lebih besar menggunakan ElastiCache API. Selama proses ini, ElastiCache update entri DNS sehingga mereka menunjuk ke node baru. Karena hal ini, Anda tidak perlu memperbarui titik akhir dalam aplikasi Anda. Untuk Valkey 7.2 dan di atasnya Redis OSS 5.0.5 dan yang lebih baru, Anda dapat menskalakan cluster yang diaktifkan failover otomatis sementara cluster terus online dan melayani permintaan yang masuk. Pada versi Redis OSS 4.0.10 dan di bawahnya, Anda mungkin melihat gangguan singkat membaca dan menulis pada versi sebelumnya dari node utama saat entri DNS diperbarui..
Jumlah waktu yang diperlukan untuk menskalakan hingga tipe node yang lebih besar bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Untuk meningkatkan Valkey atau Redis OSS Cache Cluster (API) ElastiCache**
1. Tentukan tipe node mana yang dapat Anda tingkatkan untuk menggunakan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Skalakan grup replikasi Anda saat ini hingga tipe node baru menggunakan aksi `ModifyReplicationGroup` ElastiCache API dan dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi.
+ `CacheNodeType`— tipe node baru yang lebih besar dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penaikan skala segera diterapkan. Untuk menunda proses penaikan skala ke periode pemeliharaan berikutnya, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ApplyImmediately=true
&CacheNodeType=cache.m3.2xlarge
&CacheParameterGroupName=redis32-m3-2xl
&ReplicationGroupId=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) di *Referensi Amazon ElastiCache API*.
1. Jika Anda menggunakan `ApplyImmediately``=true`, pantau status grup replikasi menggunakan `DescribeReplicationGroups` aksi ElastiCache API dengan parameter berikut. Ketika status berubah dari *mengubah* ke *tersedia*, Anda dapat mulai menulis ke grup replikasi baru yang telah dinaikkan skalanya.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html) di *Referensi Amazon ElastiCache API*.
## Penskalaan ke bawah secara online
**Topics**
+ [Menskalakan cluster Valkey atau Redis OSS (Konsol)](#redis-cluster-vertical-scaling-down-console)
+ [Menskalakan cluster Valkey atau Redis OSS ()AWS CLI](#Scaling.RedisStandalone.ScaleDown.CLI)
+ [Memperkecil klaster Valkey atau Redis OSS (API) ElastiCache](#Scaling.Vertical.ScaleDown.API)
### Menskalakan cluster Valkey atau Redis OSS (Konsol)
Prosedur berikut menjelaskan cara menurunkan klaster Valkey atau Redis OSS menggunakan Management Console. ElastiCache Selama proses ini, cluster Valkey atau Redis OSS Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk menurunkan kluster Valkey atau Redis OSS (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dari panel navigasi, pilih cluster **Valkey atau cluster** **Redis** OSS.
1. Dari daftar klaster, pilih klaster pilihan Anda.
1. Pilih **Ubah**.
1. Di wizard **Ubah Klaster**:
1. Pilih jenis simpul sebagai tujuan penskalaan dari daftar **Jenis simpul**. Untuk menurunkan skala, pilih jenis simpul yang lebih kecil dari simpul saat ini. Perhatikan bahwa tidak semua jenis simpul tersedia sebagai pilihan penurunan skala.
1. Jika Anda ingin segera melakukan proses penurunan skala, pilih kotak **Terapkan segera**. Jika kotak **Terapkan segera** tidak dipilih, proses penurunan skala dilakukan selama periode pemeliharaan berikutnya dari klaster ini.
1. Pilih **Ubah**.
Jika Anda memilih **Terapkan segera** pada langkah sebelumnya, status klaster berubah ke *mengubah*. Ketika status berubah ke *tersedia*, pengubahan selesai dan Anda dapat mulai menggunakan klaster baru tersebut.
### Menskalakan cluster Valkey atau Redis OSS ()AWS CLI
Prosedur berikut menjelaskan cara menurunkan cluster Valkey atau Redis OSS menggunakan.AWS CLI Selama proses ini, klaster Anda akan terus melayani permintaan dengan waktu henti minimal.
**Untuk mengurangi cluster Valkey atau Redis OSS ()AWS CLI**
1. Tentukan jenis node yang dapat Anda turunkan dengan menjalankan AWS CLI`list-allowed-node-type-modifications` perintah dengan parameter berikut.
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-allowed-node-type-modifications \
--replication-group-id my-replication-group-id
```
Untuk Windows:
```
aws elasticache list-allowed-node-type-modifications ^
--replication-group-id my-replication-group-id
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ScaleUpModifications": [
"cache.m3.2xlarge",
"cache.m3.large",
"cache.m3.xlarge",
"cache.m4.10xlarge",
"cache.m4.2xlarge",
"cache.m4.4xlarge",
"cache.m4.large",
"cache.m4.xlarge",
"cache.r3.2xlarge",
"cache.r3.4xlarge",
"cache.r3.8xlarge",
"cache.r3.large",
"cache.r3.xlarge"
]
"ScaleDownModifications": [
"cache.t2.micro",
"cache.t2.small ",
"cache.t2.medium ",
"cache.t1.small"
]
}
```
Untuk informasi selengkapnya, lihat [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) dalam *Referensi AWS CLI*.
1. Ubah grup replikasi Anda untuk menurunkan ke tipe node baru yang lebih kecil, menggunakan AWS CLI`modify-replication-group` perintah dan parameter berikut.
+ `--replication-group-id` – Nama grup replikasi yang menjadi tujuan penurunan skala.
+ `--cache-node-type`— Jenis node baru yang ingin Anda skalakan cluster. Nilai ini harus berupa salah satu dari jenis simpul yang dihasilkan oleh perintah `list-allowed-node-type-modifications` di langkah 1.
+ `--cache-parameter-group-name` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `--apply-immediately` – Menyebabkan operasi penaikan skala segera diterapkan. Guna menunda proses penurunan skala ke periode pemeliharaan berikutnya untuk klaster, gunakan parameter `--no-apply-immediately`.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id my-redis-cluster \
--cache-node-type cache.t2.micro \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id my-redis-cluster ^
--cache-node-type cache.t2.micro ^
--apply-immediately
```
Output dari perintah di atas terlihat seperti berikut (format JSON).
```
{
"ReplicationGroup": {
"Status": "modifying",
"Description": "my-redis-cluster",
"NodeGroups": [
{
"Status": "modifying",
"Slots": "0-16383",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-east-1f",
"CacheNodeId": "0001",
"CacheClusterId": "my-redis-cluster-0001-001"
},
{
"PreferredAvailabilityZone": "us-east-1d",
"CacheNodeId": "0001",
"CacheClusterId": "my-redis-cluster-0001-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "my-redis-cluster.r7gdfi.clustercfg.use1.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "my-redis-cluster",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "07:30-08:30",
"MemberClusters": [
"my-redis-cluster-0001-001",
"my-redis-cluster-0001-002"
],
"CacheNodeType": "cache.t2.micro",
"DataTiering": "disabled"
"PendingModifiedValues": {}
}
}
```
Untuk informasi selengkapnya, lihat [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) dalam *Referensi AWS CLI*.
1. Jika Anda menggunakan`--apply-immediately`, periksa status cluster menggunakan AWS CLI`describe-cache-clusters` perintah dengan parameter berikut. Ketika status berubah menjadi *tersedia*, Anda dapat mulai menggunakan node cluster baru yang lebih kecil.
### Memperkecil klaster Valkey atau Redis OSS (API) ElastiCache
Proses berikut menskalakan grup replikasi Anda dari tipe node saat ini ke tipe node baru yang lebih kecil menggunakan ElastiCache API. Selama proses ini, cluster Valkey atau Redis OSS Anda akan terus melayani permintaan dengan waktu henti minimal.
Jumlah waktu yang diperlukan untuk menurunkan ke tipe node yang lebih kecil bervariasi, tergantung pada jenis node Anda dan jumlah data di cluster Anda saat ini.
**Penskalaan ke bawah (ElastiCache API)**
1. Tentukan tipe node mana yang dapat Anda turunkan untuk menggunakan `ListAllowedNodeTypeModifications` aksi ElastiCache API dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi. Gunakan parameter ini untuk mendeskripsikan grup replikasi tertentu, bukan semua grup replikasi.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListAllowedNodeTypeModifications
&ReplicationGroupId=MyReplGroup
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) di *Referensi Amazon ElastiCache API*.
1. Skalakan grup replikasi Anda saat ini ke tipe node baru menggunakan aksi `ModifyReplicationGroup` ElastiCache API dan dengan parameter berikut.
+ `ReplicationGroupId` – nama grup replikasi.
+ `CacheNodeType`— tipe node baru yang lebih kecil dari cluster dalam grup replikasi ini. Nilai ini harus menjadi salah satu jenis instance yang dikembalikan oleh `ListAllowedNodeTypeModifications` tindakan pada langkah sebelumnya.
+ `CacheParameterGroupName` – [Opsional] Gunakan parameter ini jika Anda menggunakan `reserved-memory` untuk mengelola memori cadangan klaster. Tentukan grup parameter cache kustom yang mencadangkan jumlah memori yang sesuai untuk jenis simpul yang baru. Jika menggunakan `reserved-memory-percent`, Anda dapat menghilangkan parameter ini.
+ `ApplyImmediately` – Tetapkan ke `true` agar proses penurunan skala segera diterapkan. Untuk menunda proses penurunan skala ke periode pemeliharaan berikutnya, gunakan `ApplyImmediately``=false`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyReplicationGroup
&ApplyImmediately=true
&CacheNodeType=cache.t2.micro
&CacheParameterGroupName=redis32-m3-2xl
&ReplicationGroupId=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Untuk informasi selengkapnya, lihat [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) di *Referensi Amazon ElastiCache API*.
# Memulai dengan filter Bloom
ElastiCache mendukung struktur data filter Bloom, yang menyediakan struktur data probabilistik ruang yang efisien untuk memeriksa apakah suatu elemen adalah anggota dari suatu set. Saat menggunakan filter Bloom, positif palsu dimungkinkan — filter dapat salah menunjukkan bahwa elemen ada, meskipun elemen itu tidak ditambahkan ke himpunan. Namun, menggunakan filter Bloom akan mencegah *negatif* palsu — indikasi salah bahwa elemen *tidak* ada, meskipun elemen itu ditambahkan ke set.
Anda dapat mengatur persentase potensi positif palsu ke tingkat yang diinginkan untuk beban kerja Anda, dengan menyesuaikan tingkat fp. Anda juga dapat mengonfigurasi kapasitas (jumlah item yang dapat disimpan oleh filter Bloom), properti penskalaan dan non-penskalaan, dan banyak lagi.
Setelah Anda membuat cluster dengan versi engine yang didukung, tipe data Bloom dan perintah terkait akan tersedia secara otomatis. Tipe `bloom` data kompatibel dengan API dengan sintaks perintah filter Bloom dari pustaka klien Valkey resmi termasuk`valkey-py`,, `valkey-java` dan. `valkey-go` Anda dapat dengan mudah memigrasikan aplikasi Valkey dan Redis OSS berbasis Bloom yang ada ke dalam. ElastiCache Untuk daftar lengkap perintah lihat[Perintah filter Bloom](#SupportedCommandsBloom).
Metrik terkait Bloom`BloomFilterBasedCmds`,`BloomFilterBasedCmdsLatency`, dan `BloomFilterBasedCmdsECPUs` dimasukkan ke dalam CloudWatch untuk memantau penggunaan tipe data ini. Untuk informasi selengkapnya, lihat [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md).
**catatan**
Untuk menggunakan filter Bloom, Anda harus menjalankan ElastiCache Valkey 8.1 dan yang lebih baru.
Tipe data bloom tidak kompatibel dengan RDB dengan penawaran mekar berbasis non-Valkey lainnya.
## Ikhtisar tipe data filter Bloom
Filter Bloom adalah struktur data probabilistik hemat ruang yang memungkinkan penambahan elemen dan memeriksa apakah ada elemen. Positif palsu dimungkinkan di mana filter salah menunjukkan bahwa suatu elemen ada, meskipun tidak ditambahkan. Namun, Filter Bloom menjamin bahwa negatif palsu (salah menunjukkan bahwa suatu elemen tidak ada, meskipun ditambahkan) tidak terjadi.
Sumber utama dokumentasi untuk filter mekar dapat ditemukan di halaman dokumentasi valkey.io. Ini berisi informasi berikut:
+ [Kasus penggunaan umum untuk filter mekar](https://valkey.io/topics/bloomfilters/#common-use-cases-for-bloom-filters)
+ Iklan/Deduplikasi acara
+ Deteksi penipuan
+ Memfilter konten berbahaya/spam
+ Deteksi pengguna yang unik
+ [Perbedaan antara filter mekar penskalaan dan non-penskalaan](https://valkey.io/topics/bloomfilters/#scaling-and-non-scaling-bloom-filters)
+ Cara memutuskan antara filter mekar penskalaan dan non-penskalaan
+ [Properti mekar](https://valkey.io/topics/bloomfilters/#bloom-properties)
+ Pelajari tentang properti filter Bloom yang dapat disetel. Ini termasuk tingkat positif palsu, kapasitas, penskalaan dan properti non-penskalaan, dan banyak lagi.
+ [Kinerja perintah mekar](https://valkey.io/topics/bloomfilters/#performance)
+ [Memantau statistik filter mekar secara keseluruhan](https://valkey.io/topics/bloomfilters/#monitoring)
+ [Menangani filter mekar besar](https://valkey.io/topics/bloomfilters/#handling-large-bloom-filters)
+ Rekomendasi dan detail tentang cara memeriksa apakah filter mekar mencapai batas penggunaan memorinya, dan apakah filter tersebut dapat diskalakan untuk mencapai kapasitas yang diinginkan.
+ Anda dapat secara khusus memeriksa jumlah memori yang dikonsumsi oleh dokumen filter mekar melalui penggunaan perintah [BF.INFO](https://valkey.io/commands/bf.info/).
## Batas ukuran mekar
Konsumsi memori oleh satu objek filter Bloom dibatasi hingga 128 MB. Anda dapat memeriksa jumlah memori yang dikonsumsi oleh filter Bloom dengan menggunakan `BF.INFO SIZE` perintah.
## Mekar ACLs
Mirip dengan kategori per-tipe data yang ada (@string, @hash, dll.) Kategori baru @bloom ditambahkan untuk menyederhanakan pengelolaan akses ke perintah dan data Bloom. Tidak ada perintah Valkey atau Redis OSS lain yang ada sebagai anggota kategori @bloom.
Ada 3 kategori ACL yang ada yang diperbarui untuk menyertakan perintah Bloom baru: @read, @write dan @fast. Tabel berikut menunjukkan pemetaan perintah Bloom ke kategori yang sesuai.
| Perintah Bloom | @read | @write | @fast | @bloom |
| --- | --- | --- | --- | --- |
| BF.ADD | | y | y | y |
| BF.KARTU | y | | y | y |
| BF.EXISTS | y | | y | y |
| BF.INFO | y | | y | y |
| BF.INSERT | | y | y | y |
| BF.MADD | | y | y | y |
| BF.MEXISTS | y | | y | y |
| BF.RESERVE | y | | y | y |
## Metrik terkait filter Bloom
CloudWatch Metrik berikut yang terkait dengan struktur data bloom disediakan:
| Metrik CW | Unit | Tanpa server/Berbasis Node | Deskripsi |
| --- | --- | --- | --- |
| BloomFilterBasedCmds | Hitungan | Keduanya | Jumlah total perintah filter Bloom, termasuk perintah baca dan tulis. |
| BloomFilterBasedCmdsLatency | Mikrodetik | swakelola | Latensi semua perintah filter Bloom, termasuk perintah baca dan tulis. |
| BloomFilterBasedCmdsECPUs | Hitungan | Nirserver | ECPUs dikonsumsi oleh semua perintah filter Bloom, termasuk perintah baca dan tulis. |
## Perintah filter Bloom
[Perintah Bloom Filter](https://valkey.io/commands/#bloom) didokumentasikan di situs web [Valkey.io.](https://valkey.io/) Setiap halaman perintah memberikan ikhtisar komprehensif tentang perintah bloom, termasuk sintaks, perilaku, nilai pengembalian, dan kondisi kesalahan potensial.
| Nama | Deskripsi |
| --- | --- |
| [BF.ADD](https://valkey.io/commands/bf.add/) | Menambahkan satu item ke filter mekar.Jika filter belum ada, itu dibuat. |
| [BF.CARD](https://valkey.io/commands/bf.card/) | Mengembalikan kardinalitas filter mekar. |
| [BF.EXISTS](https://valkey.io/commands/bf.exists/) | Menentukan apakah filter mekar berisi item yang ditentukan. |
| [BF.INFO](https://valkey.io/commands/bf.info/) | Mengembalikan informasi penggunaan dan properti dari filter mekar tertentu. |
| [BF. SISIPKAN](https://valkey.io/commands/bf.insert/) | Membuat filter mekar dengan 0 item atau lebih, atau menambahkan item ke filter mekar yang ada. |
| [BF.MADD](https://valkey.io/commands/bf.madd/) | Menambahkan satu atau lebih item ke filter mekar. |
| [BF.MEKSIKO](https://valkey.io/commands/bf.mexists/) | Menentukan apakah filter mekar berisi 1 item atau lebih. |
| [BF.RESERVE](https://valkey.io/commands/bf.reserve/) | Membuat filter mekar kosong dengan properti yang ditentukan. |
**catatan**
**BF.LOAD** tidak didukung oleh. ElastiCache Ini hanya relevan untuk penggunaan AOF, yang ElastiCache tidak mendukung.
# Memulai dengan Watch in Serverless
ElastiCache mendukung `WATCH` perintah, yang memungkinkan Anda untuk memantau kunci untuk perubahan dan menjalankan [transaksi](https://valkey.io/topics/transactions/) bersyarat. `WATCH`Perintah ini sangat berguna untuk aplikasi yang memerlukan kontrol konkurensi optimis, memastikan bahwa transaksi hanya dijalankan jika kunci yang dipantau belum dimodifikasi. Ini termasuk modifikasi yang dilakukan oleh klien, seperti perintah tulis, dan oleh Valkey sendiri, seperti kedaluwarsa atau penggusuran. Jika kunci dimodifikasi dari saat mereka dipasang `WATCH` dan pada saat `EXEC` diterima, seluruh transaksi akan dibatalkan.
Untuk ElastiCache Tanpa Server, kendala berikut diperkenalkan -
ElastiCache Tanpa server `WATCH` dicakup ke satu slot hash. Itu berarti hanya kunci yang memetakan ke slot hash yang sama yang dapat ditonton pada saat yang sama dengan koneksi yang sama, dan transaksi yang mengikuti perintah jam tangan hanya dapat beroperasi pada slot hash yang sama. Ketika aplikasi mencoba untuk menonton kunci dari slot hash yang berbeda, atau menjalankan perintah transaksi yang beroperasi pada kunci yang dipetakan ke slot hash yang berbeda dari tombol yang diawasi, `CROSSSLOT` kesalahan akan dikembalikan. [Tag hash](https://valkey.io/topics/cluster-spec/#hash-tags) dapat digunakan untuk memastikan beberapa kunci dipetakan ke slot hash yang sama.
Selain itu, `SCAN` perintah tidak dapat dijalankan di dalam koneksi dengan kunci yang ditonton dan akan mengembalikan `command not supported during watch state` kesalahan.
Transaksi akan dibatalkan (seolah-olah kunci yang ditonton disentuh) ketika ElastiCache Tanpa Server tidak memiliki kepastian apakah kunci telah dimodifikasi. Misalnya, ketika slot telah dimigrasikan dan kunci yang ditonton tidak dapat ditemukan pada node yang sama.
**Contoh Kode**
## Tonton dan Operasikan pada Tombol dari Slot Berbeda
Dalam contoh berikut, kunci yang ditonton dan kunci yang ditentukan dalam peta `SET` perintah ke slot hash yang berbeda. Eksekusi mengembalikan a`CROSSSLOT ERROR`.
```
> WATCH foo:{005119}
OK
> MULTI
OK
> SET bar:{011794} 1234
QUEUED
> EXEC
CROSSSLOT Keys in request don't hash to the same slot
```
## Tonton dan Operasikan pada Tombol dari Slot yang Sama
Contoh berikut menunjukkan transaksi yang berhasil, karena kunci yang disetel `WATCH` tidak berubah.
```
> WATCH foo:{005119}
OK
> MULTI
OK
> SET bar:{005119} 1234
QUEUED
> EXEC
1) OK
```
## Tonton kunci dari Slot Berbeda
Dalam contoh berikut, upaya untuk `WATCH` kunci dari slot yang berbeda secara bersamaan dalam koneksi klien yang sama mengembalikan file`CROSSSLOT ERROR`.
```
> WATCH foo:{005119}
OK
> WATCH bar:{123455}
CROSSSLOT Keys in request don't hash to the same slot
```
## Batas tontonan
Setiap koneksi klien dapat menonton hingga 1000 kunci secara bersamaan.
## Perintah yang didukung terkait dengan Watch
Perintah [WATCH](https://valkey.io/commands/watch/) dan [UNWATCH](https://valkey.io/commands/unwatch/) didokumentasikan di situs web [Valkey.io](https://valkey.io/). Ini memberikan gambaran komprehensif dari perintah, termasuk sintaks, perilaku, nilai pengembalian, dan kondisi kesalahan potensial.
# Memulai dengan Pencarian Vektor
Amazon ElastiCache untuk Valkey mendukung pencarian vektor, memungkinkan Anda menyimpan, mencari, dan memperbarui miliaran penyematan vektor dimensi tinggi dalam memori dengan latensi serendah mikrodetik dan mengingat lebih dari 99%. ElastiCache untuk Valkey menyediakan kemampuan untuk mengindeks, mencari, dan memperbarui miliaran penyematan vektor dimensi tinggi dari penyedia populer seperti Amazon Bedrock, Amazon, SageMaker Anthropic atau OpenAI untuk pencarian dan pengambilan cepat. Pencarian vektor untuk Amazon ElastiCache sangat ideal untuk kasus penggunaan di mana kinerja puncak dan skalabilitas adalah kriteria pemilihan yang paling penting. Ini termasuk caching semantik, generasi tambahan pengambilan, rekomendasi waktu nyata, personalisasi, dan deteksi anomali.
Pencarian vektor dapat digunakan bersama dengan ElastiCache fitur lain untuk meningkatkan aplikasi Anda. Pencarian vektor ElastiCache tersedia dalam Valkey versi 8.2 pada cluster berbasis node di semua [AWS Wilayah](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) tanpa biaya tambahan. Untuk memulai, buat cluster Valkey 8.2 baru menggunakan [Konsol Manajemen AWS](https://console.aws.amazon.com/elasticache/),AWS SDK, atau.AWS CLI[Anda juga dapat menggunakan pencarian vektor pada cluster yang ada dengan meningkatkan dari versi Valkey atau Redis OSS sebelumnya ke Valkey 8.2 dalam beberapa klik tanpa downtime.](VersionManagement.HowTo.md)
# Ikhtisar Pencarian Vektor
ElastiCache untuk Valkey menyediakan kemampuan untuk mengindeks, mencari, dan memperbarui miliaran penyematan vektor dimensi tinggi. Pencarian vektor memungkinkan Anda membuat, memelihara, dan menggunakan indeks sekunder untuk pencarian yang efisien dan terukur. Setiap operasi pencarian vektor berlaku untuk indeks tunggal. Operasi indeks hanya berlaku untuk indeks yang ditentukan. Sejumlah operasi dapat dikeluarkan terhadap indeks apa pun kapan saja dengan pengecualian operasi pembuatan dan penghapusan indeks. Pada tingkat cluster, beberapa operasi terhadap beberapa indeks mungkin sedang berlangsung secara bersamaan.
Dalam dokumen ini istilah kunci, baris, dan catatan identik dan digunakan secara bergantian. Demikian pula, istilah kolom, bidang, jalur dan anggota juga digunakan secara bergantian.
`FT.CREATE`Perintah ini dapat digunakan untuk membuat indeks untuk subset kunci dengan jenis indeks yang ditentukan. `FT.SEARCH`melakukan kueri pada indeks yang dibuat, dan `FT.DROPINDEX` menghapus indeks yang ada dan semua data terkait. Tidak ada perintah khusus untuk menambah, menghapus, atau memodifikasi data yang diindeks. `JSON`Perintah yang ada `HASH` atau yang memodifikasi kunci yang ada dalam indeks secara otomatis memperbarui indeks.
**Topics**
+ [Indeks dan ruang kunci Valkey OSS](#indexes-keyspace)
+ [Jenis bidang indeks](#index-field-types)
+ [Algoritma indeks vektor](#vector-index-algorithms)
+ [Keamanan pencarian vektor](#vector-search-security)
## Indeks dan ruang kunci Valkey OSS
Indeks dibangun dan dipelihara di atas subset dari keyspace Valkey OSS. Ruang kunci untuk setiap indeks ditentukan oleh daftar awalan kunci yang disediakan saat indeks dibuat. Daftar awalan adalah opsional dan jika dihilangkan, seluruh ruang kunci akan menjadi bagian dari indeks itu. Beberapa indeks dapat memilih subset ruang kunci yang terputus atau tumpang tindih tanpa batasan.
Indeks juga diketik karena hanya mencakup kunci yang memiliki tipe yang cocok. Saat ini, indeks hanya didukung pada `JSON` dan `HASH` jenis. `HASH`Indeks hanya mengindeks `HASH` kunci yang dicakup oleh daftar awalannya dan juga `JSON` indeks hanya mengindeks `JSON` kunci yang dicakup oleh daftar awalannya. Kunci dalam daftar awalan ruang kunci indeks yang tidak memiliki tipe yang ditentukan diabaikan dan tidak memengaruhi operasi pencarian.
Indeks diperbarui ketika perintah memodifikasi kunci apa pun yang ada di dalam ruang kunci indeks. Valkey secara otomatis mengekstrak bidang yang dideklarasikan untuk setiap indeks dan memperbarui indeks dengan nilai baru. Proses pembaruan memiliki tiga langkah. Pada langkah pertama, kunci HASH atau JSON dimodifikasi dan klien yang meminta diblokir. Langkah kedua dilakukan di latar belakang dan memperbarui setiap indeks yang berisi kunci yang dimodifikasi. Pada langkah ketiga, klien tidak diblokir. Jadi untuk operasi kueri yang dilakukan pada koneksi yang sama dengan mutasi, perubahan itu segera terlihat di hasil pencarian.
Pembuatan indeks adalah proses multi-langkah. Langkah pertama adalah menjalankan perintah FT.CREATE yang mendefinisikan indeks. Eksekusi yang berhasil membuat secara otomatis memulai langkah kedua - penimbunan ulang. Proses pengisian ulang berjalan di thread latar belakang dan memindai ruang kunci untuk kunci yang berada dalam daftar awalan indeks baru. Setiap kunci yang ditemukan ditambahkan ke indeks. Akhirnya seluruh keyspace dipindai, menyelesaikan proses pembuatan indeks. Perhatikan bahwa saat proses pengisian ulang berjalan, mutasi kunci yang diindeks diizinkan, tidak ada batasan, dan proses pengisian ulang indeks tidak akan selesai sampai semua kunci diindeks dengan benar. Operasi kueri yang dicoba saat indeks sedang menjalani pengisian ulang tidak diizinkan dan diakhiri dengan kesalahan. Perintah FT.INFO mengembalikan status proses backfill di bidang 'backfill\$1status'.
## Jenis bidang indeks
Setiap indeks memiliki jenis tertentu yang dideklarasikan ketika indeks dibuat bersama dengan lokasi bidang (kolom) yang akan diindeks. Untuk `HASH` kunci lokasi adalah nama bidang di dalam`HASH`. Untuk `JSON` kunci lokasi adalah deskripsi jalur JSON. Ketika kunci dimodifikasi, data yang terkait dengan bidang yang dideklarasikan diekstraksi, dikonversi ke tipe yang dideklarasikan dan disimpan dalam indeks. Jika data hilang atau tidak berhasil dikonversi ke tipe yang dideklarasikan, maka bidang tersebut dihilangkan dari indeks. Ada tiga jenis bidang, seperti yang dijelaskan sebagai berikut:
+ **Bidang vektor** berisi vektor angka yang juga dikenal sebagai embedding vektor. Bidang vektor dapat digunakan untuk menyaring vektor berdasarkan metrik jarak tertentu yang mengukur kesamaan. Untuk `HASH` indeks, bidang harus berisi seluruh vektor yang dikodekan dalam format biner (IEEE 754 endian kecil). Untuk `JSON` kunci, jalur harus mereferensikan array dengan ukuran yang benar yang diisi dengan angka. Perhatikan bahwa ketika array JSON digunakan sebagai bidang vektor, representasi internal array dalam kunci JSON diubah menjadi format yang diperlukan oleh algoritma yang dipilih, mengurangi konsumsi memori dan presisi. Operasi baca selanjutnya menggunakan perintah JSON akan menghasilkan nilai presisi yang berkurang.
+ **Bidang angka** berisi satu nomor. Bidang angka dapat digunakan dengan operator pencarian rentang. Untuk`HASH`, bidang ini diharapkan berisi teks ASCII dari angka yang ditulis dalam format standar angka tetap atau floating-point. Untuk `JSON` bidang, aturan numerik nomor JSON harus diikuti. Terlepas dari representasi dalam kunci, bidang ini dikonversi ke nomor floating point 64-bit untuk penyimpanan dalam indeks. Karena angka yang mendasarinya disimpan di floating point dengan keterbatasan presisi, aturan umum tentang perbandingan numerik untuk nomor floating point berlaku.
+ **Bidang tag** berisi nol atau lebih nilai tag yang dikodekan sebagai string UTF-8 tunggal. Bidang tag dapat digunakan untuk memfilter kueri untuk kesetaraan nilai tag dengan perbandingan case-sensitive atau case-insensitive. String diuraikan menjadi nilai tag menggunakan karakter pemisah (default adalah koma tetapi dapat diganti) dengan spasi putih depan dan belakang dihapus. Sejumlah nilai tag dapat terkandung dalam satu bidang tag.
## Algoritma indeks vektor
Dua algoritma indeks vektor didukung di Valkey:
+ **Flat** — Algoritma Flat adalah pemrosesan linier brute force dari setiap vektor dalam indeks, menghasilkan jawaban yang tepat dalam batas-batas ketepatan perhitungan jarak. Karena pemrosesan linier indeks, waktu berjalan untuk algoritma ini bisa sangat tinggi untuk indeks besar. Indeks datar mendukung kecepatan konsumsi yang lebih tinggi.
+ **Hierarchical Navigable Small Worlds (HNSW)** — Algoritma HNSW adalah alternatif yang menyediakan perkiraan kecocokan vektor terdekat dengan imbalan waktu eksekusi yang jauh lebih rendah. Algoritma dikendalikan oleh tiga parameter`M`, `EF_CONSTRUCTION` dan`EF_RUNTIME`. Dua parameter pertama ditentukan pada waktu pembuatan indeks dan tidak dapat diubah. `EF_RUNTIME`Parameter memiliki nilai default yang ditentukan pada pembuatan indeks tetapi dapat diganti pada setiap operasi kueri individu sesudahnya. Ketiga parameter ini berinteraksi untuk menyeimbangkan memori dan konsumsi CPU selama operasi konsumsi dan kueri serta mengontrol kualitas perkiraan pencarian KNN yang tepat (dikenal sebagai rasio recall).
Di HNSW, parameter M mengontrol jumlah maksimum tetangga yang dapat dihubungkan oleh setiap node, membentuk kepadatan indeks. M yang lebih tinggi, seperti 32 ke atas, menghasilkan grafik yang lebih terhubung, meningkatkan kecepatan penarikan dan kueri karena ada lebih banyak jalur untuk menjangkau tetangga yang relevan. Namun, ini meningkatkan ukuran indeks, penggunaan memori, dan memperlambat pengindeksan. M yang lebih rendah, seperti 8 dan di bawahnya, menghasilkan faster-to-build indeks yang lebih kecil dengan penggunaan memori yang lebih rendah, tetapi ingatan menurun dan kueri mungkin memakan waktu lebih lama karena koneksi yang lebih sedikit.
Parameter EF\$1Construction menentukan berapa banyak koneksi kandidat yang dievaluasi saat membangun indeks. EF\$1Construction yang lebih tinggi, seperti 400 ke atas, berarti pengindeks mempertimbangkan lebih banyak jalur sebelum memilih tetangga, yang mengarah ke grafik yang meningkatkan efisiensi penarikan dan kueri nanti, tetapi dengan biaya pengindeksan yang lebih lambat dan penggunaan CPU dan memori yang lebih tinggi selama konstruksi. EF\$1Construction rendah, seperti 64-120, mempercepat pengindeksan dan mengurangi penggunaan sumber daya, tetapi grafik yang dihasilkan dapat mengurangi penarikan dan memperlambat kueri meskipun EF\$1Runtime disetel tinggi.
Terakhir, EF\$1Runtime mengatur luasnya pencarian selama kueri, mengontrol berapa banyak calon tetangga yang dieksplorasi saat runtime. Mengaturnya tinggi meningkatkan daya ingat dan akurasi, tetapi dengan biaya latensi kueri dan penggunaan CPU. EF\$1Runtime yang rendah membuat kueri lebih cepat dan lebih ringan, tetapi dengan penarikan yang berkurang. Tidak seperti M atau EF\$1Construction, parameter ini tidak memengaruhi ukuran indeks atau waktu pembuatan, menjadikannya parameter untuk menyetel penarikan versus pertukaran latensi setelah indeks dibuat.
Kedua algoritma pencarian vektor (Flat dan HNSW) mendukung parameter opsional. `INITIAL_CAP` Ketika ditentukan, parameter ini mengalokasikan memori untuk indeks, sehingga mengurangi overhead manajemen memori dan peningkatan tingkat konsumsi vektor. Indeks datar mendukung kecepatan konsumsi yang lebih baik daripada HNSW.
Algoritma pencarian vektor seperti HNSW mungkin tidak efisien menangani penghapusan atau penimpaan vektor yang dimasukkan sebelumnya. Penggunaan operasi ini dapat mengakibatkan konsumsi memori indeks berlebih and/or menurunkan kualitas penarikan. Pengindeksan ulang adalah salah satu metode untuk memulihkan ingatan penggunaan memori yang optimal. and/or
## Keamanan pencarian vektor
Mekanisme keamanan [Valkey ACL (Access Control Lists)](https://valkey.io/topics/acl/) untuk kedua perintah dan akses data diperluas untuk mengontrol fasilitas pencarian. Kontrol ACL dari perintah pencarian individual didukung sepenuhnya. Kategori ACL baru,`@search`, disediakan dan banyak kategori yang ada (`@fast`,,, `@read``@write`, dll.) Diperbarui untuk menyertakan perintah baru. Perintah pencarian tidak memodifikasi data kunci, artinya mesin ACL yang ada untuk akses tulis dipertahankan. Aturan akses untuk `HASH` dan `JSON` operasi tidak dimodifikasi oleh kehadiran indeks; kontrol akses tingkat kunci normal masih diterapkan pada perintah tersebut.
Perintah pencarian dengan indeks juga memiliki akses mereka dikontrol melalui ACL. Pemeriksaan akses dilakukan pada tingkat seluruh indeks, bukan pada tingkat per-kunci. Ini berarti bahwa akses ke indeks diberikan kepada pengguna hanya jika pengguna tersebut memiliki izin untuk mengakses semua kunci yang mungkin dalam daftar awalan keyspace indeks tersebut. Dengan kata lain, konten sebenarnya dari indeks tidak mengontrol akses. Sebaliknya, itu adalah isi teoritis dari indeks seperti yang didefinisikan oleh daftar awalan yang digunakan untuk pemeriksaan keamanan. Situasi di mana pengguna telah membaca akses and/or tulis ke kunci tetapi tidak dapat mengakses indeks yang berisi kunci itu dimungkinkan. Perhatikan bahwa hanya akses baca ke ruang kunci yang diperlukan untuk membuat atau menggunakan indeks - ada atau tidak adanya akses tulis tidak dipertimbangkan
# Fitur pencarian vektor dan batas
## Ketersediaan pencarian vektor
Pencarian vektor untuk Amazon ElastiCache tersedia dengan Valkey versi 8.2 pada cluster berbasis node di semua AWS Wilayah tanpa biaya tambahan. [Anda juga dapat menggunakan pencarian vektor pada cluster yang ada dengan meningkatkan dari versi Valkey, atau Redis OSS ke Valkey 8.2, dalam beberapa klik tanpa downtime.](VersionManagement.HowTo.md)
Pencarian vektor saat ini tersedia pada semua jenis ElastiCache instance selain node dengan tiering data. Menggunakan pencarian vektor pada instans t2, t3, dan t4g memerlukan peningkatan cadangan memori hingga setidaknya 50% untuk mikro dan 30% untuk instance kecil. Lihat [halaman ini](redis-memory-management.md) untuk mengetahui lebih lanjut.
## Pembatasan parametrik
Tabel berikut menunjukkan batas untuk berbagai item pencarian vektor:
**Batas pencarian vektor**
| Item | Nilai maksimum |
| --- | --- |
| Jumlah dimensi dalam vektor | 32768 |
| Jumlah indeks yang dapat dibuat | 10 |
| Jumlah bidang dalam indeks | 50 |
| Klausa FT.SEARCH TIMEOUT (milidetik) | 60000 |
| Jumlah maksimum awalan yang diizinkan per indeks | 16 |
| Panjang maksimum kolom tag | 10000 |
| Panjang maksimum bidang numerik | 256 |
| Parameter HNSW M | 2000000 |
| Parameter HNSW EF\$1CONSTRUCTION | 4096 |
| Parameter HNSW EF\$1RUNTIME | 4096 |
## Pembatasan operasional
### Indeks Persistensi dan Penimbunan Ulang
Proses pembaruan memiliki tiga langkah. Pada langkah pertama, kunci HASH atau JSON dimodifikasi dan klien yang meminta diblokir. Langkah kedua dilakukan di latar belakang dan memperbarui setiap indeks yang berisi kunci yang dimodifikasi. Pada langkah ketiga, klien tidak diblokir. Jadi, untuk operasi kueri yang dilakukan pada koneksi yang sama dengan mutasi, perubahan itu segera terlihat di hasil pencarian. Namun, penyisipan atau pembaruan kunci mungkin tidak terlihat dalam hasil pencarian untuk klien lain untuk waktu yang singkat. Selama periode beban sistem berat mutasi data yang and/or berat, penundaan visibilitas bisa menjadi lebih lama.
Fitur pencarian vektor mempertahankan definisi indeks, dan isi indeks. Indeks untuk bidang vektor disimpan tetapi indeks untuk TAGS dan NUMERIK tidak disimpan, artinya indeks tersebut harus dibangun kembali saat dimuat secara eksternal (sinkronisasi penuh atau muat ulang). Ini berarti bahwa selama permintaan operasional atau peristiwa apa pun yang menyebabkan node memulai atau memulai ulang, definisi indeks dan konten untuk vektor dipulihkan dari snapshot terbaru. Tidak ada tindakan pengguna yang diperlukan untuk memulai ini. Namun untuk indeks TAGS dan NUMERIC, pembangunan kembali dilakukan sebagai operasi pengisian ulang segera setelah data dipulihkan. Ini secara fungsional setara dengan sistem yang secara otomatis menjalankan perintah FT.CREATE untuk setiap indeks yang ditentukan. Perhatikan bahwa node menjadi tersedia untuk operasi aplikasi segera setelah data dipulihkan, tetapi kemungkinan sebelum pengurukan indeks selesai, yang berarti bahwa operasi pengurukan akan kembali terlihat oleh aplikasi.
Penyelesaian isi ulang indeks tidak disinkronkan antara primer dan replika. Kurangnya sinkronisasi ini secara tak terduga dapat terlihat oleh aplikasi, sehingga disarankan agar aplikasi memverifikasi penyelesaian pengisian ulang pada primer dan semua replika sebelum memulai operasi pencarian.
### Batas penskalaan
Selama peristiwa penskalaan, indeks dapat mengalami pengisian ulang saat data dimigrasikan. Ini akan menghasilkan penarikan yang berkurang untuk kueri penelusuran.
### Snapshot import/export dan Migrasi Langsung
File RDB dari satu cluster dengan indeks pencarian dapat diimpor ke cluster ElastiCache Valkey lain dengan versi 8.2 atau lebih tinggi. Cluster baru akan membangun kembali konten indeks saat memuat file RDB. Namun, keberadaan indeks pencarian dalam file RDB membatasi kompatibilitas data tersebut dengan versi Valkey sebelumnya. Format indeks pencarian yang ditentukan oleh fungsi pencarian vektor hanya dipahami oleh ElastiCache cluster lain dengan Valkey versi 8.2 atau lebih tinggi. Namun, file RDB yang tidak mengandung indeks tidak dibatasi dengan cara ini.
### Keluar dari Memori saat mengisi ulang
Mirip dengan operasi penulisan Valkey OSS, isi ulang indeks dikenakan batasan. out-of-memory Jika memori mesin terisi saat pengisian ulang sedang berlangsung, semua isi ulang dijeda. Jika memori tersedia, proses pengurukan dilanjutkan. Dimungkinkan untuk menghapus indeks saat pengisian ulang dijeda karena kehabisan memori.
### Transaksi
Perintah`FT.CREATE`,`FT.DROPINDEX`,`FT.ALIASADD`,`FT.ALIASDEL`, dan `FT.ALIASUPDATE` tidak dapat dieksekusi dalam konteks transaksional, yaitu, tidak dalam `MULTI/EXEC` blok atau dalam LUA atau skrip FUNGSI.
# Memilih konfigurasi yang sesuai
Dalam pengalaman konsol, ElastiCache menawarkan cara mudah untuk memilih jenis instans yang tepat berdasarkan kebutuhan memori dan cpu dari beban kerja vektor Anda.
## Konsumsi memori
Konsumsi memori didasarkan pada jumlah vektor, jumlah dimensi, nilai-M, dan jumlah data non-vektor, seperti metadata yang terkait dengan vektor atau data lain yang disimpan dalam instance. Total memori yang dibutuhkan adalah kombinasi dari ruang yang dibutuhkan untuk data vektor aktual, dan ruang yang diperlukan untuk indeks vektor. Ruang yang diperlukan untuk data Vektor dihitung dengan mengukur kapasitas aktual yang diperlukan untuk menyimpan vektor di dalam `HASH` atau struktur `JSON` data dan overhead ke pelat memori terdekat, untuk alokasi memori yang optimal. Masing-masing indeks vektor menggunakan referensi ke data vektor yang disimpan dalam struktur data ini serta salinan tambahan vektor dalam indeks. Disarankan untuk merencanakan konsumsi ruang tambahan ini dengan indeks.
Jumlah vektor tergantung pada bagaimana Anda memutuskan untuk mewakili data Anda sebagai vektor. Misalnya, Anda dapat memilih untuk mewakili satu dokumen menjadi beberapa potongan, di mana setiap potongan mewakili vektor. Atau, Anda dapat memilih untuk mewakili seluruh dokumen sebagai vektor tunggal. Jumlah dimensi vektor Anda tergantung pada model penyematan yang Anda pilih. Misalnya, jika Anda memilih untuk menggunakan model embedding AWS Titan maka jumlah dimensi akan menjadi 1536. Perhatikan bahwa Anda harus menguji jenis instance untuk memastikannya sesuai dengan kebutuhan Anda.
## Menskalakan beban kerja Anda
Pencarian vektor mendukung ketiga metode penskalaan: horizontal, vertikal, dan replika. Saat menskalakan kapasitas, pencarian vektor berperilaku seperti Valkey biasa, yaitu, meningkatkan memori node individu (penskalaan vertikal) atau meningkatkan jumlah node (penskalaan horizontal) akan meningkatkan kapasitas keseluruhan. Dalam mode cluster, `FT.CREATE` perintah dapat dikirim ke node utama cluster dan sistem akan secara otomatis mendistribusikan definisi indeks baru ke semua anggota cluster.
Namun, dari perspektif kinerja, pencarian vektor berperilaku sangat berbeda dari Valkey biasa. Implementasi multi-threaded dari pencarian vektor berarti bahwa CPUs hasil tambahan hingga peningkatan linier dalam throughput kueri dan konsumsi. Penskalaan horizontal menghasilkan peningkatan linier dalam throughput konsumsi tetapi dapat mengurangi throughput kueri. Jika throughput kueri tambahan diperlukan, penskalaan melalui replika atau tambahan CPUs diperlukan.
# Perintah Pencarian Vektor
Berikut ini adalah daftar perintah yang didukung untuk pencarian vektor.
**Topics**
+ [FT.CREATE](vector-search-commands-ft.create.md)
+ [FT.SEARCH](vector-search-commands-ft.search.md)
+ [FT.DROPINDEX](vector-search-commands-ft.dropindex.md)
+ [FT.INFO](vector-search-commands-ft.info.md)
+ [KAKI. \$1DAFTAR](vector-search-commands-ft.list.md)
# FT.CREATE
`FT.CREATE`Perintah membuat indeks kosong dan memulai proses pengisian ulang. Setiap indeks terdiri dari sejumlah definisi bidang. Setiap definisi bidang menentukan nama bidang, jenis bidang, dan jalur dalam setiap kunci yang diindeks untuk menemukan nilai dari jenis yang dideklarasikan. Beberapa definisi tipe bidang memiliki penentu sub-tipe tambahan.
Untuk indeks pada kunci HASH, jalurnya sama dengan nama anggota hash. `AS`Klausa opsional dapat digunakan untuk mengganti nama bidang jika diinginkan. Mengganti nama bidang sangat berguna ketika nama anggota berisi karakter khusus.
Untuk indeks pada kunci JSON, jalurnya adalah jalur JSON ke data dari tipe yang dideklarasikan. Karena jalur JSON selalu berisi karakter khusus, `AS` klausa diperlukan.
**Sintaksis**
```
FT.CREATE
ON HASH | JSON
[PREFIX [...]]
SCHEMA
( [AS ]
| VECTOR [HNSW|FLAT] [])
| TAG [SEPARATOR ] [CASESENSITIVE]
| NUMERIC
)+
```
**(wajib):** Ini adalah nama yang Anda berikan ke indeks Anda. Jika indeks dengan nama yang sama sudah ada, kesalahan dikembalikan.
**ON HASH \$1 JSON (opsional):** Hanya kunci yang cocok dengan tipe tertentu yang disertakan dalam indeks ini. Jika dihilangkan, HASH diasumsikan.
**PREFIX (opsional):** Jika klausa ini ditentukan, maka hanya kunci yang dimulai dengan byte yang sama dengan satu atau lebih awalan yang ditentukan akan disertakan dalam indeks ini. Jika klausa ini dihilangkan, semua kunci dari jenis yang benar akan disertakan. Awalan panjang nol juga akan cocok dengan semua kunci dari tipe yang benar.
**Jenis bidang:**
+ TAG: Bidang tag adalah string yang berisi satu atau lebih nilai tag.
+ SEPARATOR (opsional): Salah satu karakter yang `,.<>{}[]"':;!@#$%^&*()-+=~` digunakan untuk membatasi tag individual. Jika dihilangkan, nilai defaultnya adalah. `,`
+ CASESENSITIVE (opsional): Jika ada, perbandingan tag akan peka huruf besar/kecil. Defaultnya adalah bahwa perbandingan tag TIDAK peka huruf besar/kecil.
+ NUMERIK: Bidang numerik berisi angka.
+ VECTOR: Bidang vektor berisi vektor. Dua algoritma pengindeksan vektor saat ini didukung: HNSW (Hierarchical Navigable Small World) dan FLAT (brute force). Setiap algoritma memiliki satu set atribut tambahan, beberapa diperlukan dan opsional lainnya.
+ FLAT: Algoritma Flat memberikan jawaban yang tepat, tetapi memiliki runtime sebanding dengan jumlah vektor yang diindeks dan dengan demikian mungkin tidak sesuai untuk kumpulan data besar.
+ DIM (wajib): Menentukan jumlah dimensi dalam vektor.
+ TYPE FLOAT32 (wajib): Tipe data, saat FLOAT32 ini hanya didukung.
+ DISTANCE\$1METRIC [L2 \$1 IP \$1 COSINE] (wajib): Menentukan algoritma jarak.
+ INITIAL\$1CAP (opsional): Ukuran indeks awal.
+ HNSW: Algoritma HNSW memberikan jawaban perkiraan, tetapi beroperasi jauh lebih cepat daripada FLAT.
+ DIM (wajib): Menentukan jumlah dimensi dalam vektor.
+ TYPE FLOAT32 (wajib): Tipe data, saat FLOAT32 ini hanya didukung.
+ DISTANCE\$1METRIC [L2 \$1 IP \$1 COSINE] (wajib): Menentukan algoritma jarak.
+ INITIAL\$1CAP (opsional): Ukuran indeks awal.
+ M (opsional): Jumlah tepi keluar maksimum yang diizinkan untuk setiap node dalam grafik di setiap lapisan. Pada lapisan nol, jumlah maksimal tepi keluar akan menjadi 2\$1 M. Default adalah 16, maksimum adalah 512.
+ EF\$1CONSTRUCTION (opsional): Mengontrol jumlah vektor yang diperiksa selama konstruksi indeks. Nilai yang lebih tinggi untuk parameter ini akan meningkatkan rasio penarikan dengan mengorbankan waktu pembuatan indeks yang lebih lama. Nilai default adalah 200. Nilai maksimum adalah 4096.
+ EF\$1RUNTIME (opsional): Mengontrol jumlah vektor yang akan diperiksa selama operasi kueri. Defaultnya adalah 10, dan maksnya adalah 4096. Anda dapat mengatur nilai parameter ini untuk setiap kueri yang Anda jalankan. Nilai yang lebih tinggi meningkatkan waktu kueri, tetapi meningkatkan penarikan kueri.
**TANGGAPAN:** OK atau kesalahan.
# FT.SEARCH
Melakukan pencarian indeks yang ditentukan. Kunci yang cocok dengan ekspresi kueri dikembalikan.
```
FT.SEARCH
[NOCONTENT]
[RETURN ( [AS ])+]
[TIMEOUT timeout]
[PARAMS []]
[LIMIT ]
```
+ (wajib): Nama indeks yang ingin Anda kueri.
+ (wajib): String kueri, lihat di bawah untuk detailnya.
+ NOCONTENT (opsional): Saat ada, hanya nama kunci yang dihasilkan yang dikembalikan, tidak ada nilai kunci yang disertakan.
+ TIMEOUT (opsional): Memungkinkan Anda menetapkan nilai batas waktu untuk perintah pencarian. Ini harus berupa bilangan bulat dalam milidetik.
+ PARAMS... (opsional): `count` adalah jumlah argumen, yaitu dua kali jumlah pasangan nama nilai. Lihat string kueri untuk detail penggunaan.
+ KEMBALI ... (opsional): hitung adalah jumlah bidang yang akan dikembalikan. Menentukan bidang yang ingin Anda ambil dari dokumen Anda, bersama dengan alias apa pun untuk nilai yang dikembalikan. Secara default, semua bidang dikembalikan kecuali opsi NOCONTENT disetel, dalam hal ini tidak ada bidang yang dikembalikan. Jika hitungan disetel ke 0, ia berperilaku sama dengan NOCONTENT.
+ BATAS: : Memungkinkan Anda memilih sebagian dari hasil. Tombol pertama dilewati dan hanya maksimum kunci yang disertakan. Defaultnya adalah LIMIT 0 10, yang mengembalikan paling banyak 10 kunci.
+ PARAMS: Dua kali jumlah pasangan nilai kunci. key/value Pasangan param dapat direferensikan dari dalam ekspresi kueri. Untuk informasi selengkapnya, lihat [Ekspresi kueri penelusuran vektor](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-overview.html#vector-search-query-expression).
+ DIALEK: (opsional): Menentukan dialek Anda. Satu-satunya dialek yang didukung adalah 2.
**RESPON**
Perintah mengembalikan baik array jika berhasil atau kesalahan.
Setelah berhasil, entri pertama dalam array respons mewakili jumlah kunci yang cocok, diikuti oleh satu entri array untuk setiap kunci yang cocok. Perhatikan bahwa jika `LIMIT` opsi ditentukan, itu hanya akan mengontrol jumlah kunci yang dikembalikan dan tidak akan mempengaruhi nilai entri pertama.
Kapan `NOCONTENT` ditentukan, setiap entri dalam respons hanya berisi nama kunci yang cocok. Jika tidak, setiap entri menyertakan nama kunci yang cocok, diikuti oleh array bidang yang dikembalikan. Bidang hasil untuk kunci terdiri dari satu set name/value pasangan. name/value Pasangan pertama adalah untuk jarak yang dihitung. Nama pasangan ini dibangun dari nama bidang vektor yang ditambahkan dengan “\$1\$1”, dan ditambahkan dengan “\$1score” dan nilainya adalah jarak yang dihitung. name/value Pasangan yang tersisa adalah anggota dan nilai kunci yang dikendalikan oleh `RETURN` klausa.
String kueri sesuai dengan sintaks ini:
```
=>[ KNN @ $ ]
```
Di mana:
+ : Apakah ekspresi \$1 atau filter. A \$1 menunjukkan tidak ada penyaringan dan dengan demikian semua vektor dalam indeks dicari. Ekspresi filter dapat disediakan untuk menunjuk subset dari vektor yang akan dicari.
+ : Nama bidang vektor dalam indeks yang ditentukan.
+ : Jumlah vektor tetangga terdekat yang akan dikembalikan.
+ : Nama PARAM yang nilainya sesuai menyediakan vektor kueri untuk algoritma KNN. Perhatikan bahwa parameter ini harus dikodekan sebagai floating point biner IEEE 754 32-bit dalam format endian kecil.
+ : (Opsional) Daftar keyword/value pasangan yang memodifikasi pencarian KNN khusus ini. Saat ini, dua kata kunci didukung:
+ EF\$1RUNTIME: Kata kunci ini disertai dengan nilai integer yang mengesampingkan nilai default EF\$1RUNTIME yang ditentukan saat indeks dibuat.
+ AS: Kata kunci ini disertai dengan nilai string yang menjadi nama bidang skor dalam hasilnya, mengesampingkan algoritme pembuatan nama bidang skor default.
**Ekspresi filter**
Ekspresi filter dibangun sebagai kombinasi logis dari Tag dan operator pencarian Numerik yang terkandung dalam tanda kurung.
**Tag**
Operator pencarian tag ditentukan dengan satu atau lebih string yang dipisahkan oleh karakter \$1. Kunci akan memuaskan operator pencarian tag jika bidang yang ditunjukkan berisi salah satu string yang ditentukan.
```
@:{}
or
@:{ | }
or
@:{ | | ...}
```
Misalnya, kueri berikut akan mengembalikan dokumen dengan warna biru ATAU hitam ATAU hijau.
`@color:{blue | black | green}`
Sebagai contoh lain, query berikut akan mengembalikan dokumen yang berisi “hello world” atau “hello universe”.
`@description:{hello world | hello universe}`
**Rentang numerik**
Operator rentang numerik memungkinkan untuk memfilter kueri untuk hanya mengembalikan nilai yang berada di antara nilai awal dan akhir yang diberikan. Kueri jangkauan inklusif dan eksklusif didukung. Untuk perbandingan relasional sederhana, \$1inf, -inf dapat digunakan dengan kueri rentang. Sintaks untuk operator pencarian rentang adalah:
```
@:[ [(] [(] ]
```
... di mana adalah angka atau \$1inf atau -inf. Batas tanpa paren terbuka terkemuka bersifat inklusif, sedangkan batas dengan paren terbuka terkemuka bersifat eksklusif.
Gunakan tabel berikut sebagai panduan untuk memetakan ekspresi matematika untuk memfilter kueri:
```
min <= field <= max @field:[min max]
min < field <= max @field:[(min max]
min <= field < max @field:[min (max]
min < field < max @field:[(min (max]
field >= min @field:[min +inf]
field > min @field:[(min +inf]
field <= max @field:[-inf max]
field < max @field:[-inf (max]
field == val @field:[val val]
```
**Operator logis**
Beberapa tag dan operator pencarian numerik dapat digunakan untuk membangun kueri kompleks menggunakan operator logis.
**Logis DAN**
Untuk mengatur AND logis, gunakan spasi di antara predikat. Contoh:
`query1 query2 query3`
**Logis ATAU**
Untuk mengatur OR logis, gunakan spasi di antara predikat. Contoh:
`query1 | query2 | query3`
**Negasi logis**
Kueri apa pun dapat dinegasikan dengan mendahului `-` karakter sebelum setiap kueri. Kueri negatif mengembalikan semua entri yang tidak cocok dengan kueri. Ini juga termasuk kunci yang tidak memiliki bidang.
Misalnya, kueri negatif pada @genre: \$1comedy\$1 akan mengembalikan semua buku yang bukan komedi DAN semua buku yang tidak memiliki bidang genre.
Kueri berikut akan mengembalikan semua buku dengan genre “komedi” yang tidak diterbitkan antara 2015 dan 2024, atau yang tidak memiliki bidang tahun: @genre: [komedi] - @year: [2015 2024]
**Prioritas operator**
Aturan prioritas operator tipikal berlaku, yaitu, negate logis adalah prioritas tertinggi, diikuti oleh logis DAN kemudian logis OR dengan prioritas terendah. Tanda kurung dapat digunakan untuk mengganti aturan prioritas default.
*Contoh menggabungkan operator logis*
Operator logika dapat digabungkan untuk membentuk ekspresi filter yang kompleks.
Pertanyaan berikut akan mengembalikan semua buku dengan genre “komedi” atau “horor” (AND) yang diterbitkan antara 2015 dan 2024: `@genre:[comedy|horror] @year:[2015 2024]`
Kueri berikut akan mengembalikan semua buku dengan genre “komedi” atau “horor” (OR) yang diterbitkan antara 2015 dan 2024: `@genre:[comedy|horror] | @year:[2015 2024]`
Kueri berikut akan mengembalikan semua buku yang tidak memiliki bidang genre, atau memiliki bidang genre yang tidak sama dengan “komedi”, yang diterbitkan antara 2015 dan 2024: `-@genre:[comedy] @year:[2015 2024]`
# FT.DROPINDEX
**Sintaksis**
```
FT.DROPINDEX
```
Indeks yang ditentukan dihapus. Mengembalikan OK atau kesalahan jika indeks itu tidak ada.
+ (wajib): Nama indeks yang akan dihapus.
# FT.INFO
**Sintaksis**
```
FT.INFO
```
Pencarian vektor menambah perintah [FT.INFO](https://valkey.io/commands/info/) dengan beberapa bagian statistik dan penghitung tambahan. Permintaan untuk mengambil bagian SEARCH akan mengambil semua statistik berikut:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| index\$1name | string | Nama indeks |
| index\$1options | string | Dicadangkan. Saat ini diatur ke “0" |
| index\$1definition | array | Lihat di bawah untuk definisi elemen array ini. |
| atribut | array informasi atribut | Satu elemen dalam array ini untuk setiap atribut didefinisikan, lihat di bawah untuk definisi informasi atribut. |
| num\$1docs | integer | Jumlah kunci yang saat ini terdapat dalam indeks |
| num\$1terms | integer | Dicadangkan. Saat ini diatur ke “0". |
| record\$1count | integer | Jumlah bidang “ukuran” untuk setiap atribut. |
| hash\$1indexing\$1failure | integer | Berapa kali atribut tidak dapat dikonversi ke tipe atribut yang dideklarasikan. Terlepas dari namanya, ini juga berlaku untuk kunci JSON. |
| backfill\$1in\$1progress | integer | Jika pengisian ulang sedang berlangsung, ini akan menjadi '1' jika tidak maka akan menjadi '0' |
| backfill\$1percent\$1complete | float | Perkiraan penyelesaian isi ulang, angka pecahan dalam kisaran [0.. 1] |
| mutation\$1queue\$1size | integer | Jumlah kunci yang menunggu untuk memperbarui indeks. |
| recent\$1mutations\$1queue\$1delay | integer | Perkiraan penundaan (dalam detik) pembaruan indeks. 0 jika tidak ada pembaruan yang sedang berlangsung. |
| status | string | Status isi ulang: “siap” menunjukkan bahwa pengisian ulang berhasil diselesaikan. “backfill\$1in\$1progress” menunjukkan bahwa pengisian ulang sedang berlangsung. “backfill\$1paused\$1by\$1oom” berarti pengisian ulang telah dijeda karena kondisi memori yang rendah. Setelah kondisi memori rendah teratasi, backill akan berlanjut. |
Struktur index\$1definition adalah array key/value pasangan yang didefinisikan sebagai:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| key\$1type | string | Entah string 'JSON' atau string 'HASH' |
| prefiks | array | Setiap elemen dalam array adalah awalan yang ditentukan untuk indeks. Jika tidak ada awalan yang ditentukan saat indeks dibuat, array ini akan memiliki 0 entri. |
| default\$1score | string | Dicadangkan. Saat ini diatur ke “1" |
Informasi atribut: Informasi atribut adalah tipe spesifik.
Atribut numerik:
| Key | Tipe nilai | Deskripsi |
| --- | --- | --- |
| pengenal | string | Lokasi atribut dalam kunci. Nama anggota hash atau jalur JSON |
| alias | string | Nama atribut yang digunakan dalam deskripsi query. |
| jenis | string | String “NUMERIK” |
| ukuran | integer | Jumlah kunci dengan nilai numerik yang valid dalam atribut ini. |
Atribut tag:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| pengenal | string | Lokasi atribut dalam kunci. Nama anggota hash atau jalur JSON |
| alias | string | Nama atribut yang digunakan dalam deskripsi query. |
| jenis | string | String “TAG” |
| PEMISAH | karakter | Karakter pemisah didefinisikan ketika indeks dibuat |
| KASESENSITIF | T/A | Kunci ini tidak memiliki nilai terkait. Ini hadir hanya jika atribut dibuat dengan opsi ini. |
| ukuran | integer | Jumlah kunci dengan nilai tag yang valid dalam atribut ini |
Atribut vektor:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| pengenal | string | Lokasi atribut dalam kunci. Nama anggota hash atau jalur JSON |
| alias | string | Nama atribut yang digunakan dalam deskripsi query. |
| jenis | string | String “VECTOR” |
| indeks | karakter | Untuk deskripsi lebih lanjut tentang indeks vektor, lihat di bawah. |
Deskripsi indeks vektor:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| kapasitas | string | Kapasitas indeks saat ini |
| dimensi | string | Jumlah elemen dalam setiap vektor |
| distance\$1metric | string | Salah satu “COSINE”, “L2" atau “IP” |
| ukuran | array | Deskripsi indeks vektor, lihat di bawah. |
| data\$1type | string | Jenis data yang dideklarasikan. Hanya "FLOAT32" yang saat ini didukung. |
| algoritma | array | Deskripsi lebih lanjut tentang algoritma pencarian vektor. |
Algoritma pencarian Vektor FLAT Deskripsi:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| nama | string | Nama algoritma: FLAT |
| block\$1size | number | Ukuran blok indeks FLAT. |
Deskripsi Indeks Vektor HNSW:
| Nama kunci | Tipe nilai | Deskripsi |
| --- | --- | --- |
| nama | string | Nama algoritma: HNSW |
| m | number | Parameter “M” untuk HNSW |
| ef\$1konstruksi | number | Parameter “ef\$1construction” untuk HNSW |
| ef\$1runtime | number | Parameter “ef\$1runtime” untuk HNSW. |
# KAKI. \$1DAFTAR
Daftar semua indeks.
**Sintaksis**
```
FT._LIST
```
Mengembalikan array string yang nama-nama indeks saat ini didefinisikan.
# Memulai dengan JSON untuk Valkey dan Redis OSS
ElastiCache mendukung format asli JavaScript Object Notation (JSON), yang merupakan cara sederhana dan tanpa skema untuk menyandikan kumpulan data kompleks di dalam cluster Valkey dan Redis OSS. Anda dapat menyimpan dan mengakses data secara native menggunakan format JavaScript Object Notation (JSON) di dalam cluster, dan memperbarui data JSON yang disimpan dalam cluster tersebut—tanpa perlu mengelola kode kustom untuk membuat serial dan deserialisasinya.
Selain menggunakan operasi Valkey dan Redis OSS API untuk aplikasi yang beroperasi melalui JSON, Anda sekarang dapat secara efisien mengambil dan memperbarui bagian tertentu dari dokumen JSON tanpa perlu memanipulasi seluruh objek. Hal ini dapat meningkatkan performa dan mengurangi biaya. Anda juga dapat menelusuri konten dokumen JSON Anda menggunakan kueri `JSONPath` [bergaya Goessner](https://goessner.net/articles/JsonPath/).
Setelah Anda membuat klaster dengan versi mesin yang didukung, jenis data JSON dan perintah terkait akan tersedia secara otomatis. Kompatibel dengan API dan RDB kompatibel dengan versi 2 modul JSON, sehingga Anda dapat dengan mudah memigrasikan aplikasi Valkey dan Redis OSS berbasis JSON yang ada ke dalam. ElastiCache Untuk informasi selengkapnya tentang perintah yang didukung, lihat[Perintah Valkey dan Redis OSS yang didukungPerintah JSON](json-list-commands.md).
Metrik terkait JSON `JsonBasedCmds` dan `JsonBasedCmdsLatency` dimasukkan ke dalam CloudWatch untuk memantau penggunaan tipe data ini. Untuk informasi lebih lanjut, lihat [Metrik untuk Valkey dan Redis](CacheMetrics.Redis.md) OSS.
**catatan**
Untuk menggunakan JSON, Anda harus menjalankan Valkey 7.2 dan yang lebih baru, atau Redis OSS 6.2.6 atau yang lebih baru.
**Topics**
+ [Ikhtisar tipe data JSON](json-document-overview.md)
+ [Perintah Valkey dan Redis OSS yang didukung](json-list-commands.md)
# Ikhtisar tipe data JSON
ElastiCache mendukung sejumlah perintah Valkey dan Redis OSS untuk bekerja dengan tipe data JSON. Berikut ini adalah ikhtisar tipe data JSON dan daftar rinci perintah yang didukung.
## Terminologi
****
| Istilah | Deskripsi |
| --- | --- |
| Dokumen JSON | Mengacu pada nilai kunci JSON. |
| Nilai JSON | Mengacu pada subset dari dokumen JSON, termasuk root yang merepresentasikan seluruh dokumen. Nilai bisa berupa kontainer atau entri dalam kontainer. |
| Elemen JSON | Setara dengan nilai JSON. |
## Standar JSON yang didukung
Format JSON sesuai dengan standar pertukaran data JSON [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) dan [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt). Mendukung UTF-8 [Unicode](https://www.unicode.org/standard/WhatIsUnicode.html) pada teks JSON.
## Elemen root
Elemen root dapat berupa jenis data JSON apa pun. Perhatikan bahwa di RFC 4627 sebelumnya, hanya objek atau array yang diizinkan sebagai nilai root. Sejak pembaruan ke RFC 7159, root dokumen JSON dapat berupa jenis data JSON apa pun.
## Batas ukuran dokumen
Dokumen JSON disimpan secara internal dalam format yang dioptimalkan untuk perubahan dan akses cepat. Format ini biasanya menimbulkan konsumsi cukup banyak memori daripada representasi terserialisasi yang setara dari dokumen yang sama.
Konsumsi memori oleh satu dokumen JSON dibatasi hingga 64 MB, yang merupakan ukuran struktur data dalam memori, bukan string JSON. Anda dapat memeriksa jumlah memori yang dikonsumsi oleh dokumen JSON menggunakan perintah `JSON.DEBUG MEMORY`.
## JSON ACLs
+ Serupa dengan kategori per jenis data yang ada (@string, @hash, dll.), kategori baru @json ditambahkan untuk menyederhanakan manajemen akses ke perintah dan data JSON. Tidak ada perintah Valkey atau Redis OSS lain yang ada sebagai anggota kategori @json. Semua perintah JSON memberlakukan batasan dan izin ruang kunci atau perintah apa pun.
+ Ada lima kategori Valkey dan Redis OSS ACL yang diperbarui untuk menyertakan perintah JSON baru: @read, @write, @fast, @slow dan @admin. Tabel berikut menunjukkan pemetaan perintah JSON ke kategori yang sesuai.
**ACL**
| Perintah JSON | @read | @write | @fast | @slow | @admin |
| --- | --- | --- | --- | --- | --- |
| JSON.ARRAPPEND | | y | y | | |
| JSON.ARRINDEX | y | | y | | |
| JSON.ARRINSERT | | y | y | | |
| JSON.ARRLEN | y | | y | | |
| JSON.ARRPOP | | y | y | | |
| JSON.ARRTRIM | | y | y | | |
| JSON.CLEAR | | y | y | | |
| JSON.DEBUG | y | | | y | y |
| JSON.DEL | | y | y | | |
| JSON.FORGET | | y | y | | |
| JSON.GET | y | | y | | |
| JSON.MGET | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
| JSON.NUMMULTBY | | y | y | | |
| JSON.OBJKEYS | y | | y | | |
| JSON.OBJLEN | y | | y | | |
| JSON.RESP | y | | y | | |
| JSON.SET | | y | | y | |
| JSON.STRAPPEND | | y | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.TOGGLE | | y | y | | |
| JSON.TYPE | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
## Batas kedalaman sarang
Ketika objek atau array JSON memiliki elemen yang merupakan objek atau array JSON lain, objek dalam atau array dianggap "bersarang" dalam objek luar atau array. Batas kedalaman sarang maksimum adalah 128. Setiap percobaan untuk membuat dokumen yang berisi kedalaman bersarang lebih dari 128 akan ditolak dengan kesalahan.
## Sintaksis perintah
Kebanyakan perintah memerlukan nama kunci sebagai argumen pertama. Beberapa perintah juga memiliki argumen jalur. Argumen jalur ditetapkan secara default ke root jika bersifat opsional dan tidak disediakan.
Notasi:
+ Argumen wajib diapit oleh tanda kurung sudut. Misalnya:
+ Argumen opsional diapit oleh tanda kurung siku. Misalnya: [path]
+ Argumen opsional tambahan ditunjukkan oleh elipsis ("..."). Misalnya: [json...]
## Sintaksis jalur
Redis JSON mendukung dua jenis sintaksis jalur:
+ **Sintaks yang disempurnakan** - Mengikuti JSONPath sintaks yang dijelaskan oleh [Goessner](https://goessner.net/articles/JsonPath/), seperti yang ditunjukkan pada tabel berikut. Kami telah menyusun ulang dan mengubah deskripsi dalam tabel agar jelas.
+ **Sintaksis terbatas** – Memiliki kemampuan kueri terbatas.
**catatan**
Hasil dari beberapa perintah bersifat sensitif terhadap jenis sintaksis jalur yang digunakan.
Jika jalur kueri diawali dengan '\$1', kueri tersebut menunjukkan penggunaan sintaksis yang ditingkatkan. Jika tidak, maka kueri tersebut menggunakan sintaksis terbatas.
**Sintaksis yang ditingkatkan**
****
| Simbol/Ekspresi | Deskripsi |
| --- | --- |
| \$1 | Elemen root. |
| . atau [] | Operator turunan. |
| .. | Penurunan rekursif. |
| \$1 | Wildcard. Semua elemen dalam sebuah objek atau array. |
| [] | Operator subskrip array. Indeks berbasis 0. |
| [,] | Operator Union. |
| [start:end:step] | Operator irisan array. |
| ?() | Menerapkan ekspresi filter (skrip) ke array atau objek saat ini. |
| () | Ekspresi filter. |
| @ | Digunakan dalam ekspresi filter yang merujuk ke simpul saat ini yang sedang diproses. |
| == | Sama dengan, digunakan dalam ekspresi filter. |
| \$1= | Tidak sama dengan, digunakan dalam ekspresi filter. |
| > | Lebih dari, digunakan dalam ekspresi filter. |
| >= | Lebih dari atau sama dengan, digunakan dalam ekspresi filter. |
| < | Kurang dari, digunakan dalam ekspresi filter. |
| <= | Kurang dari atau sama dengan, digunakan dalam ekspresi filter. |
| && | Logika AND, digunakan untuk menggabungkan beberapa ekspresi filter. |
| \$1\$1 | Logika OR, digunakan untuk menggabungkan beberapa ekspresi filter. |
**Contoh**
Contoh-contoh berikut dibuat berdasarkan contoh data XML [Goessner](https://goessner.net/articles/JsonPath/), yang telah kami perubahan dengan menambahkan bidang tambahan.
```
{ "store": {
"book": [
{ "category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95,
"in-stock": true,
"sold": true
},
{ "category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99,
"in-stock": false,
"sold": true
},
{ "category": "fiction",
"author": "Herman Melville",
"title": "Moby Dick",
"isbn": "0-553-21311-3",
"price": 8.99,
"in-stock": true,
"sold": false
},
{ "category": "fiction",
"author": "J. R. R. Tolkien",
"title": "The Lord of the Rings",
"isbn": "0-395-19395-8",
"price": 22.99,
"in-stock": false,
"sold": false
}
],
"bicycle": {
"color": "red",
"price": 19.95,
"in-stock": true,
"sold": false
}
}
}
```
****
| Jalur | Deskripsi |
| --- | --- |
| \$1.store.book[\$1].author | Penulis semua buku di toko. |
| \$1..author | Semua penulis. |
| \$1.store.\$1 | Semua anggota toko. |
| \$1["store"].\$1 | Semua anggota toko. |
| \$1.store..price | Harga semua yang ada di toko. |
| \$1..\$1 | Semua anggota rekursif dari struktur JSON. |
| \$1..book[\$1] | Semua buku. |
| \$1..book[0] | Buku pertama. |
| \$1..book[-1] | Buku terakhir. |
| \$1..book[0:2] | Dua buku pertama. |
| \$1..book[0,1] | Dua buku pertama. |
| \$1..book[0:4] | Buku dari indeks 0 hingga 3 (indeks akhir tidak inklusif). |
| \$1..book[0:4:2] | Buku pada indeks 0, 2. |
| \$1..book[?(@.isbn)] | Semua buku dengan nomor ISBN. |
| \$1..book[?(@.price<10)] | Semua buku yang lebih murah dari \$110. |
| ‘\$1..book[?(@.price < 10)]’ | Semua buku yang lebih murah dari \$110. (Jalur harus diberi tanda kutip jika berisi spasi.) |
| ‘\$1..book[?(@.["price"] < 10)]’ | Semua buku yang lebih murah dari \$110. |
| '\$1..book[?(@.["price"] < 10)]' | Semua buku yang lebih murah dari \$110. |
| \$1..book[?(@.price>=10&&@.price<=100)] | Semua buku dalam kisaran harga \$110 hingga \$1100, inklusif. |
| '\$1..book[?(@.price>=10 && @.price<=100)]' | Semua buku dalam kisaran harga \$110 hingga \$1100, inklusif. (Jalur harus diberi tanda kutip jika berisi spasi.) |
| \$1..book[?(@.sold==true\$1\$1@.in-stock==false)] | Semua buku yang terjual atau habis. |
| '\$1..book[?(@.sold == true \$1\$1 @.in-stock == false)]' | Semua buku yang terjual atau habis. (Jalur harus diberi tanda kutip jika berisi spasi.) |
| '\$1.store.book[?(@.["category"] == "fiction")]' | Semua buku dalam kategori fiksi. |
| '\$1.store.book[?(@.["category"] \$1= "fiction")]' | Semua buku dalam kategori nonfiksi. |
Contoh ekspresi filter tambahan:
```
127.0.0.1:6379> JSON.SET k1 . '{"books": [{"price":5,"sold":true,"in-stock":true,"title":"foo"}, {"price":15,"sold":false,"title":"abc"}]}'
OK
127.0.0.1:6379> JSON.GET k1 $.books[?(@.price>1&&@.price<20&&@.in-stock)]
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.price>1 && @.price<20 && @.in-stock)]'
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?((@.price>1 && @.price<20) && (@.sold==false))]'
"[{\"price\":15,\"sold\":false,\"title\":\"abc\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.title == "abc")]'
[{"price":15,"sold":false,"title":"abc"}]
127.0.0.1:6379> JSON.SET k2 . '[1,2,3,4,5]'
127.0.0.1:6379> JSON.GET k2 $.*.[?(@>2)]
"[3,4,5]"
127.0.0.1:6379> JSON.GET k2 '$.*.[?(@ > 2)]'
"[3,4,5]"
127.0.0.1:6379> JSON.SET k3 . '[true,false,true,false,null,1,2,3,4]'
OK
127.0.0.1:6379> JSON.GET k3 $.*.[?(@==true)]
"[true,true]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ == true)]'
"[true,true]"
127.0.0.1:6379> JSON.GET k3 $.*.[?(@>1)]
"[2,3,4]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ > 1)]'
"[2,3,4]"
```
**Sintaksis terbatas**
****
| Simbol/Ekspresi | Deskripsi |
| --- | --- |
| . atau [] | Operator turunan. |
| [] | Operator subskrip array. Indeks berbasis 0. |
**Contoh**
****
| Jalur | Deskripsi |
| --- | --- |
| .store.book[0].author | Penulis dari buku pertama. |
| .store.book[-1].author | Penulis dari buku terakhir. |
| .address.city | Nama kota. |
| ["store"]["book"][0]["title"] | Judul buku pertama. |
| ["store"]["book"][-1]["title"] | Judul buku terakhir. |
**catatan**
Semua konten [Goessner](https://goessner.net/articles/JsonPath/) yang dikutip dalam dokumentasi ini diatur dengan [Lisensi Creative Commons](https://creativecommons.org/licenses/by/2.5/).
## Awalan kesalahan umum
Setiap pesan kesalahan memiliki awalan. Berikut ini adalah daftar awalan kesalahan umum.
****
| Awalan | Deskripsi |
| --- | --- |
| ERR | Kesalahan umum. |
| LIMIT | Kesalahan yang terjadi ketika batas ukuran terlampaui. Misalnya, batas ukuran dokumen atau batas kedalaman sarang telah terlampaui. |
| NONEXISTENT | Kunci atau jalur tidak ada. |
| OUTOFBOUNDARIES | Indeks array di luar batas. |
| SYNTAXERR | Kesalahan sintaksis. |
| WRONGTYPE | Jenis nilai yang salah. |
## Metrik terkait JSON
Tersedia metrik info JSON berikut:
****
| Info | Deskripsi |
| --- | --- |
| json\$1total\$1memory\$1bytes | Total memori yang dialokasikan untuk objek JSON. |
| json\$1num\$1documents | Jumlah total dokumen di Valkey atau Redis OSS. |
Untuk menanyakan metrik inti, jalankan perintah berikut:
```
info json_core_metrics
```
## Bagaimana ElastiCache Valkey dan Redis OSS berinteraksi dengan JSON
Bagian berikut menjelaskan bagaimana ElastiCache Valkey dan Redis OSS berinteraksi dengan tipe data JSON.
### Prasyarat operator
Saat mengevaluasi ekspresi bersyarat untuk pemfilteran, &&s diutamakan terlebih dahulu, lalu \$1\$1s dievaluasi, seperti yang umum di sebagian besar bahasa. Operasi dalam tanda kurung dijalankan terlebih dahulu.
### Perilaku batas bersarang jalur maksimum
Batas bersarang jalur maksimum ElastiCache untuk Redis OSS adalah 128. Jadi nilai seperti `$.a.b.c.d...` hanya bisa mencapai 128 tingkat.
### Menangani nilai numerik
JSON tidak memiliki jenis data terpisah untuk angka integer dan floating point. Semuanya disebut angka.
Representasi numerik:
Ketika angka JSON diterima pada input, angka tersebut diubah menjadi salah satu dari dua representasi biner internal: integer bertanda 64-bit atau floating point presisi ganda IEEE 64-bit. String asli dan semua formatnya tidak dipertahankan. Jadi, ketika angka dihasilkan sebagai bagian dari respons JSON, angka tersebut dikonversi dari representasi biner internal ke string yang dapat dicetak yang menggunakan aturan pemformatan generik. Aturan-aturan ini dapat menghasilkan string yang berbeda dari string yang diterima.
Perintah aritmetika `NUMINCRBY` dan `NUMMULTBY`:
+ Jika kedua angka ini adalah integer dan hasilnya berada di luar rentang `int64`, maka angka tersebut secara otomatis akan menjadi angka floating point presisi ganda IEEE 64-bit.
+ Jika minimal salah satu angkanya adalah floating point, hasilnya adalah angka floating point presisi ganda IEEE 64-bit.
+ Jika hasilnya melebihi rentang IEEE 64-bit ganda, perintah ini menampilkan kesalahan `OVERFLOW`.
Untuk daftar lengkap perintah yang tersedia, lihat [Perintah Valkey dan Redis OSS yang didukungPerintah JSON](json-list-commands.md).
### Pemfilteran array langsung
ElastiCache untuk Valkey atau Redis OSS menyaring objek array secara langsung.
Untuk data seperti `[0,1,2,3,4,5,6]` dan kueri jalur seperti`$[?(@<4)]`, atau data seperti `{"my_key":[0,1,2,3,4,5,6]}` dan kueri jalur seperti`$.my_key[?(@<4)]`, ElastiCache akan mengembalikan [1,2,3] dalam kedua keadaan.
### Perilaku pengindeksan array
ElastiCache untuk Valkey atau Redis OSS memungkinkan indeks positif dan negatif untuk array. Untuk array dengan panjang lima, 0 akan mengueri elemen pertama, 1 yang kedua, dan seterusnya. Angka negatif dimulai pada akhir array, jadi -1 akan mengueri elemen kelima, -2 akan mengueri elemen keempat, dan seterusnya.
Untuk memastikan perilaku yang dapat diprediksi bagi pelanggan, ElastiCache tidak membulatkan indeks array ke bawah atau ke atas, jadi jika Anda memiliki array dengan panjang 5, memanggil indeks 5 atau lebih tinggi, atau -6 atau lebih rendah, tidak akan menghasilkan hasil.
### Evaluasi sintaksis yang ketat
MemoryDB tidak mengizinkan jalur JSON dengan sintaksis yang tidak valid, bahkan jika subset dari jalur berisi jalur yang valid. Hal ini dimaksudkan untuk menjaga perilaku yang benar bagi pelanggan kami.
# Perintah Valkey dan Redis OSS yang didukung
ElastiCache mendukung perintah Valkey dan Redis OSS JSON berikut:
**Topics**
+ [JSON.ARRAPPEND](json-arrappend.md)
+ [JSON.ARRINDEX](json-arrindex.md)
+ [JSON.ARRINSERT](json-arrinsert.md)
+ [JSON.ARRLEN](json-arrlen.md)
+ [JSON.ARRPOP](json-arrpop.md)
+ [JSON.ARRTRIM](json-arrtrim.md)
+ [JSON.CLEAR](json-clear.md)
+ [JSON.DEBUG](json-debug.md)
+ [JSON.DEL](json-del.md)
+ [JSON.FORGET](json-forget.md)
+ [JSON.GET](json-get.md)
+ [JSON.MGET](json-mget.md)
+ [JSON.MSET](json-mset.md)
+ [JSON.NUMINCRBY](json-numincrby.md)
+ [JSON.NUMMULTBY](json-nummultby.md)
+ [JSON.OBJLEN](json-objlen.md)
+ [JSON.OBJKEYS](json-objkeys.md)
+ [JSON.RESP](json-resp.md)
+ [JSON.SET](json-set.md)
+ [JSON.STRAPPEND](json-strappend.md)
+ [JSON.STRLEN](json-strlen.md)
+ [JSON.TOGGLE](json-toggle.md)
+ [JSON.TYPE](json-type.md)
# JSON.ARRAPPEND
Menambahkan satu atau beberapa nilai ke nilai array di jalur.
Sintaksis
```
JSON.ARRAPPEND [json ...]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ json (wajib) - Nilai JSON yang akan ditambahkan ke array.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang baru array di setiap jalur.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
+ Kesalahan `NONEXISTENT` jika jalur tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang baru array.
+ Jika beberapa nilai array dipilih, perintah mengembalikan panjang baru dari array yang diperbarui pertama.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
+ Kesalahan `SYNTAXERR` jika salah satu argumen input json bukan string JSON yang valid.
+ Kesalahan `NONEXISTENT` jika jalur tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 $[*] '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"a\",\"c\"],[\"a\",\"b\",\"c\"]]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 [-1] '"c"'
(integer) 3
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\",\"c\"]]"
```
# JSON.ARRINDEX
Mencari kemunculan pertama dari nilai JSON skalar dalam array di jalur.
+ Kesalahan di luar jangkauan diatasi dengan membulatkan indeks ke awal dan akhir array.
+ Jika awal > akhir, mengembalikan -1 (tidak ditemukan).
Sintaksis
```
JSON.ARRINDEX [start [end]]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ json-skalar (wajib) - Nilai skalar yang dicari. Skalar JSON mengacu pada nilai yang bukan merupakan objek atau array. Artinya, string, angka, Boolean, dan kosong (null) adalah nilai skalar.
+ awal (opsional) – Indeks awal, inklusif. Default ke 0 jika tidak disediakan.
+ akhir (opsional) - Indeks akhir, eksklusif. Default ke 0 jika tidak disediakan, yang berarti bahwa elemen terakhir disertakan. 0 atau -1 berarti elemen terakhir disertakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer. Setiap nilai adalah indeks dari elemen yang cocok dalam array di jalur. Nilainya -1 jika tidak ditemukan.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
Jika jalur adalah sintaksis terbatas:
+ Integer, indeks elemen yang cocok, atau -1 jika tidak ditemukan.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 $[*] '"b"'
1) (integer) -1
2) (integer) -1
3) (integer) 1
4) (integer) 1
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 .children '"Tom"'
(integer) 2
```
# JSON.ARRINSERT
Menyisipkan satu atau beberapa nilai ke dalam nilai array di jalur sebelum indeks.
Sintaksis
```
JSON.ARRINSERT [json ...]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ index (wajib) – Sebuah indeks array yang dimasukkan setelah nilai.
+ json (wajib) - Nilai JSON yang akan ditambahkan ke array.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang baru array di setiap jalur.
+ Jika nilai adalah array kosong, nilai yang akan dikembalikan adalah kosong.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
+ Kesalahan `OUTOFBOUNDARIES` jika argumen indeks di luar batas.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang baru array.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
+ Kesalahan `OUTOFBOUNDARIES` jika argumen indeks di luar batas.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 $[*] 0 '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"c\",\"a\"],[\"c\",\"a\",\"b\"]]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 . 0 '"c"'
(integer) 4
127.0.0.1:6379> JSON.GET k1
"[\"c\",[],[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRLEN
Mendapatkan panjang nilai array di jalur.
Sintaksis
```
JSON.ARRLEN [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang array di setiap jalur.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
+ Kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang array.
+ Jika memilih beberapa objek, perintah ini mengembalikan panjang array pertama.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
+ Kesalahan `NONEXISTENT JSON` jika jalur tidak ada.
+ Kosong jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 $[*]
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 $[*]
1) (integer) 0
2) (nil)
3) (integer) 2
4) (integer) 3
5) (nil)
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 [*]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k1 [1]
(integer) 1
127.0.0.1:6379> JSON.ARRLEN k1 [2]
(integer) 2
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 [1]
(error) WRONGTYPE JSON element is not an array
127.0.0.1:6379> JSON.ARRLEN k2 [0]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k2 [6]
(error) OUTOFBOUNDARIES Array index is out of bounds
127.0.0.1:6379> JSON.ARRLEN k2 a.b
(error) NONEXISTENT JSON path does not exist
```
# JSON.ARRPOP
Menghapus dan mengembalikan elemen pada indeks dari array. Popping array kosong akan menampilkan null.
Sintaksis
```
JSON.ARRPOP [path [index]]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Default ke root jika tidak disediakan.
+ indeks (opsional) – Posisi dalam array tempat popping dimulai.
+ Default ke -1 jika tidak disediakan, yang berarti elemen terakhir.
+ Nilai negatif berarti posisi dari elemen terakhir.
+ Indeks di luar batas akan dibulatkan ke batas array masing-masing.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array string massal yang merepresentasikan nilai yang di-popping di setiap jalur.
+ Jika nilai adalah array kosong, nilai yang akan dikembalikan adalah kosong.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
Jika jalur adalah sintaksis terbatas:
+ String massal, yang merepresentasikan nilai JSON yang di-popping.
+ Null jika array kosong.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1 $[*]
1) (nil)
2) "\"a\""
3) "\"b\""
127.0.0.1:6379> JSON.GET k1
"[[],[],[\"a\"]]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1
"[\"a\",\"b\"]"
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"]]"
127.0.0.1:6379> JSON.SET k2 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k2 . 0
"[]"
127.0.0.1:6379> JSON.GET k2
"[[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRTRIM
Memangkas array di jalur sehingga menjadi subarray [awal, akhir], keduanya inklusif.
+ Jika array kosong, tidak melakukan apa pun, mengembalikan 0.
+ Jika awal <0, perlakukan itu sebagai 0.
+ Jika akhir >= ukuran (ukuran array), perlakukan itu sebagai ukuran-1.
+ Jika awal >= ukuran atau awal > akhir, mengosongkan array dan menampilkan 0.
Sintaksis
```
JSON.ARRTRIM
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ Awal (wajib) – Indeks awal, inklusif.
+ akhir (wajib) – Indeks akhir, inklusif.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang baru array di setiap jalur.
+ Jika nilai adalah array kosong, nilai yang akan dikembalikan adalah kosong.
+ Jika nilai bukan array, nilai yang akan dikembalikan adalah kosong.
+ Kesalahan `OUTOFBOUNDARIES` jika argumen indeks di luar batas.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang baru array.
+ Null jika array kosong.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan array.
+ Kesalahan `OUTOFBOUNDARIES` jika argumen indeks di luar batas.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 $[*] 0 1
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 2
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\"],[\"a\",\"b\"]]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 .children 0 1
(integer) 2
127.0.0.1:6379> JSON.GET k1 .children
"[\"John\",\"Jack\"]"
```
# JSON.CLEAR
Membersihkan array atau objek di jalur.
Sintaksis
```
JSON.CLEAR [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
+ Integer, jumlah kontainer dihapus.
+ Menghapus array kosong atau akun objek untuk 1 kontainer yang dihapus.
+ Menghapus nilai non-kontainer mengembalikan 0.
**Contoh**
```
127.0.0.1:6379> JSON.SET k1 . '[[], [0], [0,1], [0,1,2], 1, true, null, "d"]'
OK
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 7
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 4
127.0.0.1:6379> JSON.SET k2 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.CLEAR k2 .children
(integer) 1
127.0.0.1:6379> JSON.GET k2 .children
"[]"
```
# JSON.DEBUG
Melaporkan informasi. Subperintah yang didukung adalah:
+ MEMORY [path] – Melaporkan penggunaan memori dalam byte dari nilai JSON. Jalur akan diatur secara default ke root jika tidak disediakan.
+ FIELDS [path] – Melaporkan jumlah bidang di jalur dokumen yang ditentukan. Jalur akan diatur secara default ke root jika tidak disediakan. Setiap nilai JSON non-kontainer dihitung sebagai satu bidang. Objek dan array secara rekursif menghitung satu bidang untuk masing-masing nilai JSON. Setiap nilai kontainer, kecuali kontainer root, dihitung sebagai satu bidang tambahan.
+ HELP – Mencetak pesan bantuan dari perintah.
Sintaksis
```
JSON.DEBUG
```
Tergantung pada subperintah:
MEMORY
+ Jika jalur adalah sintaksis yang ditingkatkan:
+ Menampilkan array integer yang merepresentasikan ukuran memori (dalam byte) dari nilai JSON di setiap jalur.
+ Mengembalikan array kosong jika kunci Valkey atau Redis OSS tidak ada.
+ Jika jalur adalah sintaksis terbatas:
+ Menampilkan integer, ukuran memori, dan nilai JSON dalam byte.
+ Mengembalikan null jika kunci Valkey atau Redis OSS tidak ada.
FIELD
+ Jika jalur adalah sintaksis yang ditingkatkan:
+ Menampilkan array integer yang merepresentasikan jumlah bidang nilai JSON di setiap jalur.
+ Mengembalikan array kosong jika kunci Valkey atau Redis OSS tidak ada.
+ Jika jalur adalah sintaksis terbatas:
+ Menampilkan integer, jumlah bidang nilai JSON.
+ Mengembalikan null jika kunci Valkey atau Redis OSS tidak ada.
HELP – Menampilkan array pesan bantuan.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, [], {"a":1, "b":2}, [1,2,3]]'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1 $[*]
1) (integer) 16
2) (integer) 16
3) (integer) 19
4) (integer) 16
5) (integer) 16
6) (integer) 16
7) (integer) 16
8) (integer) 50
9) (integer) 64
127.0.0.1:6379> JSON.DEBUG FIELDS k1 $[*]
1) (integer) 1
2) (integer) 1
3) (integer) 1
4) (integer) 1
5) (integer) 1
6) (integer) 0
7) (integer) 0
8) (integer) 2
9) (integer) 3
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1
(integer) 632
127.0.0.1:6379> JSON.DEBUG MEMORY k1 .phoneNumbers
(integer) 166
127.0.0.1:6379> JSON.DEBUG FIELDS k1
(integer) 19
127.0.0.1:6379> JSON.DEBUG FIELDS k1 .address
(integer) 4
127.0.0.1:6379> JSON.DEBUG HELP
1) JSON.DEBUG MEMORY [path] - report memory size (bytes) of the JSON element. Path defaults to root if not provided.
2) JSON.DEBUG FIELDS [path] - report number of fields in the JSON element. Path defaults to root if not provided.
3) JSON.DEBUG HELP - print help message.
```
# JSON.DEL
Menghapus nilai JSON pada jalur dalam kunci dokumen. Jika jalurnya adalah root, itu setara dengan menghapus kunci dari Valkey atau Redis OSS.
Sintaksis
```
JSON.DEL [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
+ Jumlah elemen yang dihapus.
+ 0 jika kunci Valkey atau Redis OSS tidak ada.
+ 0 jika jalur JSON tidak valid atau tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 $.d.*
(integer) 3
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 $.e[*]
(integer) 5
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 .d.*
(integer) 3
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 .e[*]
(integer) 5
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
# JSON.FORGET
Sebuah alias dari [JSON.DEL](json-del.md).
# JSON.GET
Menampilkan JSON terserialisasi pada satu atau beberapa jalur.
Sintaksis
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ INDENT/NEWLINE/SPACE(opsional) - Mengontrol format string JSON yang dikembalikan, yaitu, “cetak cantik”. Nilai default masing-masing adalah string kosong. Nilai dapat diganti dalam kombinasi apa pun. Nilai dapat ditentukan dalam urutan apa pun.
+ NOESCAPE – Opsional, boleh ada untuk kompatibilitas lama dan tidak memiliki efek lain.
+ jalur (opsional) - Nol atau lebih jalur JSON, default ke root jika tidak ada yang diberikan. Argumen jalur harus ditempatkan di akhir.
**Nilai yang ditampilkan**
Sintaksis jalur yang ditingkatkan:
Jika disediakan satu jalur:
+ Mengembalikan string terserialisasi dari array nilai.
+ Jika tidak ada nilai yang dipilih, perintah ini mengembalikan array kosong.
Jika beberapa jalur diberikan:
+ Menampilkan objek JSON yang di-stringify, di mana setiap jalur adalah kunci.
+ Jika terdapat campuran sintaksis jalur yang ditingkatkan dan dibatasi, hasilnya sesuai dengan sintaksis yang ditingkatkan.
+ Jika jalur tidak ada, nilai yang sesuai adalah array kosong.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 $.address.*
"[\"21 2nd Street\",\"New York\",\"NY\",\"10021-3100\"]"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" $.address.*
"[\n\t\"21 2nd Street\",\n\t\"New York\",\n\t\"NY\",\n\t\"10021-3100\"\n]"
127.0.0.1:6379> JSON.GET k1 $.firstName $.lastName $.age
"{\"$.firstName\":[\"John\"],\"$.lastName\":[\"Smith\"],\"$.age\":[27]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}}'
OK
127.0.0.1:6379> json.get k2 $..*
"[{},{\"a\":1},{\"a\":1,\"b\":2},1,1,2]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 .address
"{\"street\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"zipcode\":\"10021-3100\"}"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" .address
"{\n\t\"street\": \"21 2nd Street\",\n\t\"city\": \"New York\",\n\t\"state\": \"NY\",\n\t\"zipcode\": \"10021-3100\"\n}"
127.0.0.1:6379> JSON.GET k1 .firstName .lastName .age
"{\".firstName\":\"John\",\".lastName\":\"Smith\",\".age\":27}"
```
# JSON.MGET
Diserialisasi JSONs di jalur dari beberapa kunci dokumen. Perintah ini menampilkan kosong untuk kunci atau jalur JSON yang tidak ada.
**Sintaksis**
```
JSON.MGET [key ...]
```
+ kunci (wajib) - Satu atau lebih kunci Valkey atau Redis OSS dari jenis dokumen.
+ jalur (wajib) – Sebuah jalur JSON.
**Nilai yang ditampilkan**
+ Array string massal. Ukuran array sama dengan jumlah kunci dalam perintah. Setiap elemen array diisi dengan (a) JSON terserialisasi seperti yang dapat ditemukan melalui jalur atau (b) null jika kunci tidak ada, jalur tidak ada dalam dokumen, atau jalur tidak valid (kesalahan sintaksis).
+ Jika salah satu kunci yang ditentukan ada dan bukan kunci JSON, perintah ini mengembalikan kesalahan `WRONGTYPE`.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 $.address.city
1) "[\"New York\"]"
2) "[\"Boston\"]"
3) "[\"Seattle\"]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 .address.city
1) "\"New York\""
2) "\"Seattle\""
3) "\"Seattle\""
```
# JSON.MSET
Didukung untuk Valkey versi 8.1 dan di atas.
Tetapkan nilai JSON untuk beberapa kunci. Operasi adalah atom. Entah semua nilai ditetapkan atau tidak ada yang disetel.
**Sintaksis**
```
JSON.MSET key path json [ key path json ... ]
```
+ Jika jalur memanggil anggota objek:
+ Jika elemen induk tidak ada, perintah akan mengembalikan kesalahan NONEXISTENT.
+ Jika elemen induk ada tetapi bukan objek, perintah akan mengembalikan ERROR.
+ Jika elemen induk ada dan merupakan objek:
+ Jika anggota tidak ada, anggota baru akan ditambahkan ke objek induk jika dan hanya jika objek induk adalah turunan terakhir di jalur. Jika tidak, perintah akan mengembalikan kesalahan NONEXISTENT.
+ Jika anggota ada, nilainya akan diganti dengan nilai JSON.
+ Jika jalur memanggil indeks array:
+ Jika elemen induk tidak ada, perintah akan mengembalikan kesalahan NONEXISTENT.
+ Jika elemen induk ada tetapi bukan array, perintah akan mengembalikan ERROR.
+ Jika elemen induk ada tetapi indeks berada di luar batas, perintah akan mengembalikan kesalahan OUTOFBORDIES.
+ Jika elemen induk ada dan indeks valid, elemen akan diganti dengan nilai JSON baru.
+ Jika jalur memanggil objek atau array, nilai (objek atau array) akan digantikan oleh nilai JSON baru.
**Nilai yang ditampilkan**
+ Balasan string sederhana: 'OK' jika operasi berhasil.
+ Balasan kesalahan sederhana: Jika operasi gagal.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.MSET k1 . '[1,2,3,4,5]' k2 . '{"a":{"a":1, "b":2, "c":3}}' k3 . '{"a": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.GET k1
"[1,2,3,4,5]"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.MSET k2 $.a.* '0' k3 $.a[*] '0'
OK
127.0.0.1:6379> JSON.GET k2
"{\"a\":{\"a\":0,\"b\":0,\"c\":0}}"
127.0.0.1:6379> JSON.GET k3
"{\"a\":[0,0,0,0,0]}"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.MSET k1 . '{"name": "John","address": {"street": "123 Main St","city": "Springfield"},"phones": ["555-1234","555-5678"]}'
OK
127.0.0.1:6379> JSON.MSET k1 .address.street '"21 2nd Street"' k1 .address.city '"New York"'
OK
127.0.0.1:6379> JSON.GET k1 .address.street
"\"21 2nd Street\""
127.0.0.1:6379> JSON.GET k1 .address.city
"\"New York\""
```
# JSON.NUMINCRBY
Menambah nilai angka di jalur sebanyak sebuah angka tertentu.
Sintaksis
```
JSON.NUMINCRBY
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ angka (wajib) – Sebuah angka.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array string massal yang merepresentasikan nilai yang dihasilkan di setiap jalur.
+ Jika nilai bukan angka, nilai yang akan ditampilkan adalah kosong.
+ Kesalahan `WRONGTYPE` jika angka tidak dapat diuraikan.
+ Kesalahan `OVERFLOW` jika hasilnya di luar rentang double 64-bit IEEE.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ String massal yang merepresentasikan nilai yang dikembalikan.
+ Jika memilih beberapa nilai, perintah ini mengembalikan hasil nilai yang terakhir diperbarui.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan angka.
+ Kesalahan `WRONGTYPE` jika angka tidak dapat diuraikan.
+ Kesalahan `OVERFLOW` jika hasilnya di luar rentang double 64-bit IEEE.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 10
"[11,12,13]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[11,12,13]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.a[*] 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.b[*] 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.c[*] 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 $.a.* 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.b.* 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.c.* 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.d.* 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 $.a.* 1
"[null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.b.* 1
"[null,2]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.c.* 1
"[null,null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.d.* 1
"[2,null,4]"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":4}}"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[1] 10
"12"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,12,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .a[*] 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k1 .b[*] 1
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .c[*] 1
"3"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[*] 1
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 .a.* 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k2 .b.* 1
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .c.* 1
"3"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .d.* 1
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 .a.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .b.* 1
"2"
127.0.0.1:6379> JSON.NUMINCRBY k3 .c.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .d.* 1
"4"
```
# JSON.NUMMULTBY
Mengalikan nilai angka di jalur dengan angka tertentu.
Sintaksis
```
JSON.NUMMULTBY
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON.
+ angka (wajib) – Sebuah angka.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array string massal yang merepresentasikan nilai yang dihasilkan di setiap jalur.
+ Jika nilai bukan angka, nilai yang akan ditampilkan adalah kosong.
+ Kesalahan `WRONGTYPE` jika angka tidak dapat diuraikan.
+ Kesalahan `OVERFLOW` jika hasilnya di luar rentang angka floating point presisi ganda 64-bit IEEE.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ String massal yang merepresentasikan nilai yang dikembalikan.
+ Jika memilih beberapa nilai, perintah ini mengembalikan hasil nilai yang terakhir diperbarui.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan angka.
+ Kesalahan `WRONGTYPE` jika angka tidak dapat diuraikan.
+ Kesalahan `OVERFLOW` jika hasilnya di luar rentang double 64-bit IEEE.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.a[*] 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.b[*] 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.c[*] 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 $.a.* 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.b.* 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.c.* 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.d.* 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 $.a.* 2
"[null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.b.* 2
"[null,2]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.c.* 2
"[null,null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.d.* 2
"[2,null,6]"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[1] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,4,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .a[*] 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k1 .b[*] 2
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .c[*] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[*] 2
"6"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 .a.* 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k2 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .c.* 2
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":2,\"b\":4,\"c\":6}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 .a.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":1,\"b\":\"b\",\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k3 .c.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":6}}"
```
# JSON.OBJLEN
Mendapatkan jumlah kunci dalam nilai objek di jalur.
Sintaksis
```
JSON.OBJLEN [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang array di setiap jalur.
+ Jika nilai bukan objek, nilai yang akan dikembalikan adalah nilai yang kosong.
+ Kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Integer, jumlah kunci dalam objek.
+ Jika memilih beberapa objek, perintah ini mengembalikan panjang objek pertama.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan objek.
+ Kesalahan `NONEXISTENT JSON` jika jalur tidak ada.
+ Kosong jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 $.a
1) (integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 $.a.*
(empty array)
127.0.0.1:6379> JSON.OBJLEN k1 $.b
1) (integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 $.b.*
1) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.c
1) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.c.*
1) (nil)
2) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.d
1) (integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 $.d.*
1) (nil)
2) (nil)
3) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.*
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
5) (nil)
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 .a
(integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 .a.*
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.OBJLEN k1 .b
(integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 .b.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .c
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .c.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .d
(integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 .d.*
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .*
(integer) 0
```
# JSON.OBJKEYS
Mendapatkan nama kunci pada nilai objek di jalur.
Sintaksis
```
JSON.OBJKEYS [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array string massal. Setiap elemen adalah array kunci dalam objek yang cocok.
+ Jika nilai bukan objek, nilai yang akan dikembalikan adalah nilai yang kosong.
+ Kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Array string massal. Setiap elemen adalah nama kunci dalam objek.
+ Jika memilih beberapa objek, perintah ini mengembalikan kunci objek pertama.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan objek.
+ Kosong jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 $.*
1) (empty array)
2) 1) "a"
3) 1) "a"
2) "b"
4) 1) "a"
2) "b"
3) "c"
5) (empty array)
127.0.0.1:6379> JSON.OBJKEYS k1 $.d
1) 1) "a"
2) "b"
3) "c"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 .*
1) "a"
127.0.0.1:6379> JSON.OBJKEYS k1 .d
1) "a"
2) "b"
3) "c"
```
# JSON.RESP
Mengembalikan nilai JSON pada jalur yang diberikan di Valkey atau Redis OSS Serialization Protocol (RESP). Jika nilainya adalah kontainer, responsnya adalah array RESP atau array bersarang.
+ JSON kosong dipetakan ke String Massal Kosong RESP.
+ Nilai JSON Boolean dipetakan ke masing-masing String Sederhana RESP.
+ Angka integer dipetakan ke Integer RESP.
+ Nomor floating point ganda IEEE 64-bit dipetakan ke String Massal RESP.
+ String JSON dipetakan ke String Massal RESP.
+ Array JSON direpresentasikan sebagai Array RESP, dengan elemen pertama adalah string sederhana [, diikuti oleh elemen array.
+ Objek JSON direpresentasikan sebagai Array RESP, dengan elemen pertama adalah string sederhana \$1, diikuti oleh pasangan kunci-nilai, yang masing-masing adalah string massal RESP.
Sintaksis
```
JSON.RESP [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array dari array. Setiap elemen array merepresentasikan bentuk RESP dari nilai pada satu jalur.
+ Array kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Array yang merepresentasikan format RESP dari nilai pada jalur.
+ Kosong jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 $.address
1) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.address.*
1) "21 2nd Street"
2) "New York"
3) "NY"
4) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers
1) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "555 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers[*]
1) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
2) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 .address
1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1
1) {
2) 1) "firstName"
2) "John"
3) 1) "lastName"
2) "Smith"
4) 1) "age"
2) (integer) 27
5) 1) "weight"
2) "135.25"
6) 1) "isAlive"
2) true
7) 1) "address"
2) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
8) 1) "phoneNumbers"
2) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
9) 1) "children"
2) 1) [
10) 1) "spouse"
2) (nil)
```
# JSON.SET
Menetapkan nilai JSON di jalur.
Jika jalur memanggil anggota objek:
+ Jika elemen induk tidak ada, perintah ini mengembalikan kesalahan NONEXISTENT.
+ Jika elemen induk ada, tetapi bukan objek, perintah ini menampilkan ERROR.
+ Jika elemen induk ada dan merupakan objek:
+ Jika anggota tidak ada, anggota baru akan ditambahkan ke objek induk jika dan hanya jika objek induk adalah turunan terakhir di jalur. Jika tidak, perintah ini mengembalikan kesalahan NONEXISTENT.
+ Jika anggota ada, nilainya akan diganti dengan nilai JSON.
Jika jalur memanggil indeks array:
+ Jika elemen induk tidak ada, perintah ini mengembalikan kesalahan NONEXISTENT.
+ Jika elemen induk ada tetapi bukan array, perintah ini mengembalikan ERROR.
+ Jika elemen induk ada tetapi indeks di luar batas, perintah ini mengembalikan kesalahan OUTOFBOUNDARIES.
+ Jika elemen induk ada dan indeks valid, elemen akan diganti dengan nilai JSON baru.
Jika jalur memanggil objek atau array, nilai (objek atau array) akan digantikan oleh nilai JSON baru.
Sintaksis
```
JSON.SET [NX | XX]
```
[NX \$1 XX] Di mana Anda dapat memiliki 0 atau 1 pengidentifikasi [NX \$1 XX].
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (wajib) – Sebuah jalur JSON. Untuk kunci baru, jalur JSON harus menjadi root “.”.
+ NX (opsional) - Jika jalurnya adalah root, tetapkan nilainya hanya jika kuncinya tidak ada. Artinya, masukkan dokumen baru. Jika jalur bukan root, atur nilainya hanya jika jalur tidak ada. Artinya, masukkan nilai ke dalam dokumen.
+ XX (opsional) - Jika jalurnya adalah root, tetapkan nilainya hanya jika kuncinya ada. Artinya, ganti dokumen yang ada. Jika jalur bukan root, atur nilainya hanya jika jalur ada. Artinya, perbarui nilai yang ada.
**Nilai yang ditampilkan**
+ String sederhana 'OK' jika berhasil.
+ Kosong jika kondisi NX atau XX tidak terpenuhi.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.SET k1 $.a.* '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"a\":{\"a\":0,\"b\":0,\"c\":0}}"
127.0.0.1:6379> JSON.SET k2 . '{"a": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k2 $.a[*] '0'
OK
127.0.0.1:6379> JSON.GET k2
"{\"a\":[0,0,0,0,0]}"
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"c":{"a":1, "b":2}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k1 .c.a '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.SET k1 .e[-1] '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,0]}"
127.0.0.1:6379> JSON.SET k1 .e[5] '0'
(error) OUTOFBOUNDARIES Array index is out of bounds
```
# JSON.STRAPPEND
Menambahkan string ke string JSON di jalur.
Sintaksis
```
JSON.STRAPPEND [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Default ke root jika tidak disediakan.
+ json\$1string (wajib) - Representasi JSON dari string. Perhatikan bahwa string JSON harus diberi tanda kutip. Misalnya: '"contoh string"'.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang baru string di setiap jalur.
+ Jika nilai di jalur bukan string, nilai yang akan dikembalikan adalah kosong.
+ Kesalahan `SYNTAXERR` jika argumen input json bukan string JSON yang valid.
+ Kesalahan `NONEXISTENT` jika jalur tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang baru string.
+ Jika memilih beberapa nilai string, perintah ini mengembalikan panjang baru dari string yang terakhir diperbarui.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan string.
+ Kesalahan `WRONGTYPE` jika argumen input json bukan string JSON yang valid.
+ Kesalahan `NONEXISTENT` jika jalur tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.a '"a"'
1) (integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.* '"a"'
1) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.b.* '"a"'
1) (integer) 2
2) (nil)
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.* '"a"'
1) (integer) 2
2) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.b '"a"'
1) (integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 $.d.* '"a"'
1) (nil)
2) (integer) 2
3) (nil)
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 .a.a '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .a.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .b.* '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .c.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .c.b '"a"'
(integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 .d.* '"a"'
(integer) 2
```
# JSON.STRLEN
Mendapatkan panjang nilai string JSON di jalur.
Sintaksis
```
JSON.STRLEN [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer yang merepresentasikan panjang nilai array di setiap jalur.
+ Jika nilai bukan string, nilai yang akan dikembalikan adalah kosong.
+ Kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ Integer, panjang string.
+ Jika memilih beberapa nilai string, perintah ini mengembalikan panjang string pertama.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan string.
+ Kesalahan `NONEXISTENT` jika jalur tidak ada.
+ Kosong jika kunci dokumen tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 $.a.a
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.a.*
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.c.*
1) (integer) 1
2) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.c.b
1) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.d.*
1) (nil)
2) (integer) 1
3) (nil)
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 .a.a
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .a.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.b
(integer) 2
127.0.0.1:6379> JSON.STRLEN k1 .d.*
(integer) 1
```
# JSON.TOGGLE
Mengalihkan nilai Boolean antara true dan false di jalur.
Sintaksis
```
JSON.TOGGLE [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array integer (0 – false, 1 – true) yang merepresentasikan nilai Boolean yang dihasilkan di setiap jalur.
+ Jika nilai bukan nilai Boolean, nilai yang akan dikembalikan adalah kosong.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ String ("true" /"false") yang merepresentasikan nilai Boolean yang dihasilkan.
+ `NONEXISTENT` jika kunci dokumen tidak ada.
+ Kesalahan `WRONGTYPE` jika nilai di jalur bukan nilai Boolean.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '{"a":true, "b":false, "c":1, "d":null, "e":"foo", "f":[], "g":{}}'
OK
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 0
2) (integer) 1
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 1
2) (integer) 0
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . true
OK
127.0.0.1:6379> JSON.TOGGLE k1
"false"
127.0.0.1:6379> JSON.TOGGLE k1
"true"
127.0.0.1:6379> JSON.SET k2 . '{"isAvailable": false}'
OK
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"true"
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"false"
```
# JSON.TYPE
Melaporkan jenis nilai di jalur yang diberikan.
Sintaksis
```
JSON.TYPE [path]
```
+ kunci (wajib) - Kunci Valkey atau Redis OSS dari jenis dokumen JSON.
+ jalur (opsional) – Sebuah jalur JSON. Diatur secara default ke root jika tidak disediakan.
**Nilai yang ditampilkan**
Jika jalur adalah sintaksis yang ditingkatkan:
+ Array string yang merepresentasikan jenis nilai di setiap jalur. Jenisnya adalah salah satu dari \$1"null", "boolean", "string", "number", "integer", "object" dan "array"\$1.
+ Jika jalur tidak ada, nilai yang ditampilkan adalah kosong.
+ Array kosong jika kunci dokumen tidak ada.
Jika jalur adalah sintaksis terbatas:
+ String, jenis nilai
+ Kosong jika kunci dokumen tidak ada.
+ Kosong jika jalur JSON tidak valid atau tidak ada.
**Contoh**
Sintaksis jalur yang ditingkatkan:
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, []]'
OK
127.0.0.1:6379> JSON.TYPE k1 $[*]
1) integer
2) number
3) string
4) boolean
5) null
6) object
7) array
```
Sintaksis jalur terbatas:
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.TYPE k1
object
127.0.0.1:6379> JSON.TYPE k1 .children
array
127.0.0.1:6379> JSON.TYPE k1 .firstName
string
127.0.0.1:6379> JSON.TYPE k1 .age
integer
127.0.0.1:6379> JSON.TYPE k1 .weight
number
127.0.0.1:6379> JSON.TYPE k1 .isAlive
boolean
127.0.0.1:6379> JSON.TYPE k1 .spouse
null
```
# Menandai sumber daya Anda ElastiCache
Untuk membantu mengelola cluster dan ElastiCache sumber daya lainnya, Anda dapat menetapkan metadata Anda sendiri ke setiap sumber daya dalam bentuk tag. Tag memungkinkan Anda untuk mengkategorikan AWS sumber daya Anda dengan cara yang berbeda, misalnya, berdasarkan tujuan, pemilik, atau lingkungan. Hal ini berguna ketika Anda memiliki banyak sumber daya dengan jenis yang sama—Anda dapat dengan cepat mengidentifikasi sumber daya tertentu berdasarkan tag yang telah Anda tetapkan. Topik ini menjelaskan tag dan menunjukkan cara membuatnya.
**Awas**
Sebagai praktik terbaik, sebaiknya Anda tidak menyertakan data sensitif ke dalam tag.
## Dasar-dasar tag
Tag adalah label yang Anda tetapkan ke AWS sumber daya. Setiap tanda terdiri dari kunci dan nilai opsional, yang keduanya Anda tetapkan. Tag memungkinkan Anda untuk mengkategorikan AWS sumber daya Anda dengan cara yang berbeda, misalnya, berdasarkan tujuan atau pemilik. Misalnya, Anda dapat menentukan satu set tag untuk ElastiCache klaster akun Anda yang membantu Anda melacak pemilik dan grup pengguna setiap instans.
Sebaiknya rancang serangkaian kunci tag yang memenuhi kebutuhan setiap jenis sumber daya. Penggunaan set kunci tag yang konsisten akan memudahkan manajemen sumber daya Anda. Anda dapat mencari dan memfilter sumber daya berdasarkan tag yang Anda tambahkan. Untuk informasi selengkapnya tentang cara mengimplementasikan strategi pemberian tag sumber daya yang efektif, lihat [Laporan resmi AWS Praktik Terbaik Pemberian Tag](https://d1.awsstatic.com/whitepapers/aws-tagging-best-practices.pdf).
Tag tidak memiliki arti semantik ElastiCache dan ditafsirkan secara ketat sebagai serangkaian karakter. Selain itu, tag tidak secara otomatis ditetapkan ke sumber daya Anda. Anda dapat mengedit kunci dan nilai tag, serta menghapus tag dari sumber daya kapan saja. Anda dapat menetapkan nilai tag ke `null`. Jika Anda menambahkan tag yang memiliki kunci yang sama dengan tag yang sudah ada di sumber daya tersebut, nilai yang baru akan menimpa nilai yang lama. Jika Anda menghapus sumber daya, semua tag untuk sumber daya tersebut juga akan dihapus. Selain itu, jika Anda menambahkan atau menghapus tag di grup replikasi, semua simpul dalam grup replikasi itu juga akan mendapatkan penambahan atau penghapusan tag yang sama.
Anda dapat bekerja dengan tag menggunakan Konsol Manajemen AWS, the AWS CLI, dan ElastiCache API.
Jika Anda menggunakan IAM, Anda dapat mengontrol pengguna mana di AWS akun Anda yang memiliki izin untuk membuat, mengedit, atau menghapus tag. Untuk informasi selengkapnya, lihat [Izin tingkat sumber daya](IAM.ResourceLevelPermissions.md).
## Sumber daya yang dapat Anda beri tag
Anda dapat menandai sebagian besar ElastiCache sumber daya yang sudah ada di akun Anda. Tabel di bawah ini mencantumkan sumber daya yang mendukung pemberian tag. Jika Anda menggunakan Konsol Manajemen AWS, Anda dapat menerapkan tag ke sumber daya dengan menggunakan [Editor Tag](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html). Beberapa layar sumber daya memungkinkan Anda menentukan tag untuk sebuah sumber daya saat sumber daya tersebut dibuat; misalnya, tag dengan kunci Nama dan nilai yang Anda tentukan. Dalam kebanyakan kasus, konsol menerapkan tag segera setelah sumber daya dibuat (bukan selama pembuatan sumber daya). Konsol dapat mengatur sumber daya sesuai dengan tag **Nama**, tetapi tag ini tidak memiliki arti semantik untuk layanan. ElastiCache
Selain itu, beberapa tindakan pembuatan sumber daya memungkinkan Anda menentukan tag untuk sumber daya saat sumber daya tersebut dibuat. Jika tag tidak dapat diterapkan selama pembuatan sumber daya, kami akan mengembalikan proses pembuatan sumber daya. Hal ini untuk memastikan bahwa sumber daya dibuat dengan tag atau tidak akan dibuat sama sekali, dan tidak akan ada sumber daya yang dibiarkan tidak bertanda. Dengan memberikan tag pada sumber daya saat pembuatan, Anda tidak perlu menjalankan skrip pemberian tag kustom setelah pembuatan sumber daya.
Jika Anda menggunakan Amazon ElastiCache API,AWS CLI, atau AWS SDK, Anda dapat menggunakan `Tags` parameter pada tindakan ElastiCache API yang relevan untuk menerapkan tag. File tersebut adalah:
+ `CreateServerlessCache`
+ `CreateCacheCluster`
+ `CreateReplicationGroup`
+ `CopyServerlessCacheSnapshot`
+ `CopySnapshot`
+ `CreateCacheParameterGroup`
+ `CreateCacheSecurityGroup`
+ `CreateCacheSubnetGroup`
+ `CreateServerlessCacheSnapshot`
+ `CreateSnapshot`
+ `CreateUserGroup`
+ `CreateUser`
+ `PurchaseReservedCacheNodesOffering`
Tabel berikut menjelaskan ElastiCache sumber daya yang dapat diberi tag, dan sumber daya yang dapat diberi tag saat pembuatan menggunakan ElastiCache API,AWS CLI, atau SDK.AWS
**Menandai dukungan untuk sumber daya ElastiCache**
| Sumber daya | Mendukung tag | Mendukung pemberian tag saat pembuatan |
| --- | --- | --- |
| serverlesscache | Ya | Ya |
| parametergroup | Ya | Ya |
| securitygroup | Ya | Ya |
| subnetgroup | Ya | Ya |
| replicationgroup | Ya | Ya |
| cluster | Ya | Ya |
| reserved-instance | Ya | Ya |
| serverlesscachesnapshot | Ya | Ya |
| snapshot | Ya | Ya |
| user | Ya | Ya |
| usergroup | Ya | Ya |
**catatan**
Anda tidak dapat memberikan tag pada Penyimpanan Data Global.
Anda dapat menerapkan izin tingkat sumber daya berbasis tag dalam kebijakan IAM Anda ke tindakan ElastiCache API yang mendukung penandaan pada pembuatan untuk menerapkan kontrol terperinci atas pengguna dan grup yang dapat menandai sumber daya saat pembuatan. Sumber daya Anda diamankan secara tepat sejak pembuatan—tag yang diterapkan segera ke sumber daya Anda. Oleh karena itu, izin tingkat sumber daya berbasis tag apa pun yang mengontrol penggunaan sumber daya akan langsung diterapkan. Sumber daya Anda dapat dilacak dan dilaporkan dengan lebih akurat. Anda dapat menerapkan penggunaan pemberian tag pada sumber daya baru serta mengontrol kunci dan nilai tag mana yang ditetapkan pada sumber daya Anda.
Untuk informasi selengkapnya, lihat [Contoh pemberian tag sumber daya](#Tagging-your-resources-example).
Untuk informasi selanjutnya tentang pemberian tag sumber daya Anda untuk penagihan, lihat [Memantau biaya dengan tag alokasi biaya](Tagging.md).
## Memberi tag pada cache dan snapshot
Aturan berikut berlaku untuk pemberian tag sebagai bagian dari operasi permintaan:
+ **CreateReplicationGroup**:
+ Jika `--tags` parameter `--primary-cluster-id` dan disertakan dalam permintaan, tag permintaan akan ditambahkan ke grup replikasi dan disebarkan ke semua cluster dalam grup replikasi. Jika cluster utama memiliki tag yang ada, ini akan ditimpa dengan tag permintaan untuk memiliki tag yang konsisten di semua node.
Jika tidak ada tag permintaan, tag cluster utama akan ditambahkan ke grup replikasi dan disebarkan ke semua cluster.
+ Jika `--snapshot-name` atau `--serverless-cache-snapshot-name` disediakan:
Jika tag disertakan dalam permintaan, grup replikasi hanya akan ditandai dengan tag tersebut. Jika tidak ada tag yang disertakan dalam permintaan, tag snapshot akan ditambahkan ke grup replikasi.
+ Jika `--global-replication-group-id` disediakan:
Jika tag disertakan dalam permintaan, tag permintaan akan ditambahkan ke grup replikasi dan disebarkan ke semua cluster.
+ **CreateCacheCluster** :
+ Jika `--replication-group-id` disediakan:
Jika tag disertakan dalam permintaan, cluster hanya akan diberi tag dengan tag tersebut. Jika tidak ada tag yang disertakan dalam permintaan, cluster akan mewarisi tag grup replikasi alih-alih tag cluster utama.
+ Jika `--snapshot-name` disediakan:
Jika tag disertakan dalam permintaan, cluster hanya akan diberi tag dengan tag tersebut. Jika tidak ada tag yang disertakan dalam permintaan, tag snapshot akan ditambahkan ke cluster.
+ **CreateServerlessCache** :
+ Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke cache nirserver.
+ **CreateSnapshot** :
+ Jika `--replication-group-id` disediakan:
Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke snapshot. Jika tidak ada tag yang disertakan dalam permintaan, tag grup replikasi akan ditambahkan ke snapshot.
+ Jika `--cache-cluster-id` disediakan:
Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke snapshot. Jika tidak ada tag yang disertakan dalam permintaan, tag cluster akan ditambahkan ke snapshot.
+ Untuk snapshot otomatis:
Tag akan disebarkan dari tag grup replikasi.
+ **CreateServerlessCacheSnapshot** :
+ Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke snapshot cache nirserver.
+ **CopySnapshot** :
+ Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke snapshot. Jika tidak ada tag yang disertakan dalam permintaan, tag snapshot sumber akan ditambahkan ke snapshot salinan.
+ **CopyServerlessCacheSnapshot** :
+ Jika tag disertakan dalam permintaan, hanya tag permintaan yang akan ditambahkan ke snapshot cache nirserver.
+ **AddTagsToResource**dan **RemoveTagsFromResource**:
+ Tag akan added/removed berasal dari grup replikasi dan tindakan akan disebarkan ke semua cluster di grup replikasi.
**catatan**
**AddTagsToResource**dan **RemoveTagsFromResource**tidak dapat digunakan untuk parameter default dan grup keamanan.
+ **IncreaseReplicaCount** dan **ModifyReplicationGroupShardConfiguration**:
+ Semua klaster baru yang ditambahkan ke grup replikasi akan memiliki tag yang sama dengan grup replikasi.
## Batasan tag
Batasan dasar berikut berlaku untuk tag:
+ Jumlah maksimum tag per sumber daya – 50
+ Untuk setiap sumber daya, setiap kunci tag harus unik, dan setiap kunci tag hanya dapat memiliki satu nilai.
+ Panjang kunci maksimum – 128 karakter Unicode dalam UTF-8.
+ Panjang nilai maksimum – 256 karakter Unicode dalam UTF-8.
+ Meskipun ElastiCache memungkinkan karakter apa pun dalam tagnya, layanan lain dapat membatasi. Karakter yang diizinkan di semua layanan adalah huruf, angka, dan spasi yang dapat direpresentasikan dalam UTF-8, serta karakter berikut: \$1 - = . \$1 : / @
+ Kunci dan nilai tag peka huruf besar dan kecil.
+ `aws:`Awalan dicadangkan untuk AWS digunakan. Jika tag memiliki kunci tag dengan awalan ini, Anda tidak dapat mengedit atau menghapus kunci atau nilai tag tersebut. Tag dengan awalan `aws:` tidak dihitung terhadap tag per batas sumber daya.
Anda tidak dapat mengakhiri, menghentikan, atau menghapus sumber daya berdasarkan tandanya saja; Anda harus menentukan pengidentifikasi sumber daya tersebut. Misalnya, untuk menghapus snapshot yang Anda beri tag dengan tag kunci yang disebut `DeleteMe`, Anda harus menggunakan tindakan `DeleteSnapshot` dengan pengidentifikasi sumber daya snapshot tersebut, seperti `snap-1234567890abcdef0`.
Untuk informasi selengkapnya tentang ElastiCache sumber daya yang dapat Anda beri tag, lihat[Sumber daya yang dapat Anda beri tag](#Tagging-your-resources).
## Contoh pemberian tag sumber daya
+ Membuat cache tanpa server menggunakan tag. Contoh ini menggunakan Memcached sebagai mesin.
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
--tags Key="Cost Center", Value="1110001" Key="project",Value="XYZ"
```
+ Menambahkan tag ke cache nirserver
```
aws elasticache add-tags-to-resource \
--resource-name arn:aws:elasticache:us-east-1:111111222233:serverlesscache:my-cache \
--tags Key="project",Value="XYZ" Key="Elasticache",Value="Service"
```
+ Menambahkan tanda ke Grup Replikasi.
```
aws elasticache add-tags-to-resource \
--resource-name arn:aws:elasticache:us-east-1:111111222233:replicationgroup:my-rg \
--tags Key="project",Value="XYZ" Key="Elasticache",Value="Service"
```
+ Membuat Klaster Cache menggunakan tanda.
```
aws elasticache create-cache-cluster \
--cluster-id testing-tags \
--cluster-description cluster-test \
--cache-subnet-group-name test \
--cache-node-type cache.t2.micro \
--engine valkey \
--tags Key="project",Value="XYZ" Key="Elasticache",Value="Service"
```
+ Membuat Klaster Cache menggunakan tag. Contoh ini menggunakan Redis sebagai mesin.
```
aws elasticache create-cache-cluster \
--cluster-id testing-tags \
--cluster-description cluster-test \
--cache-subnet-group-name test \
--cache-node-type cache.t2.micro \
--engine valkey \
--tags Key="project",Value="XYZ" Key="Elasticache",Value="Service"
```
+ Membuat snapshot nirserver dengan tag. Contoh ini menggunakan Memcached sebagai mesin.
```
aws elasticache create-serverless-cache-snapshot \
--serverless-cache-name testing-tags \
--serverless-cache-snapshot-name bkp-testing-tags-scs \
--tags Key="work",Value="foo"
```
+ Membuat Snapshot dengan tag.
Snapshot saat ini hanya tersedia untuk Redis. Untuk kasus ini, jika Anda menambahkan tag pada permintaan, bahkan jika grup replikasi berisi tag, snapshot hanya akan menerima tag permintaan.
```
aws elasticache create-snapshot \
--replication-group-id testing-tags \
--snapshot-name bkp-testing-tags-rg \
--tags Key="work",Value="foo"
```
## Contoh kebijakan kontrol akses Berbasis Tag
1. Mengizinkan tindakan `AddTagsToResource` untuk klaster hanya jika klaster memiliki tag Project=XYZ.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticache:AddTagsToResource",
"Resource": [
"arn:aws:elasticache:*:*:cluster:*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Project": "XYZ"
}
}
}
]
}
```
------
1. Mengizinkan tindakan `RemoveTagsFromResource` dari grup replikasi jika grup berisi tag Project dan Service serta kunci yang berbeda dari Project dan Service.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticache:RemoveTagsFromResource",
"Resource": [
"arn:aws:elasticache:*:*:replicationgroup:*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Service": "Elasticache",
"aws:ResourceTag/Project": "XYZ"
},
"ForAnyValue:StringNotEqualsIgnoreCase": {
"aws:TagKeys": [
"Project",
"Service"
]
}
}
}
]
}
```
------
1. Mengizinkan `AddTagsToResource` untuk sumber daya apa pun hanya jika tag berbeda dari Project dan Service.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticache:AddTagsToResource",
"Resource": [
"arn:aws:elasticache:*:*:*:*"
],
"Condition": {
"ForAnyValue:StringNotEqualsIgnoreCase": {
"aws:TagKeys": [
"Service",
"Project"
]
}
}
}
]
}
```
------
1. Menolak tindakan `CreateReplicationGroup` jika permintaan memiliki `Tag Project=Foo`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "elasticache:CreateReplicationGroup",
"Resource": [
"arn:aws:elasticache:*:*:replicationgroup:*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/Project": "Foo"
}
}
}
]
}
```
------
1. Menolak tindakan `CopySnapshot` jika sumber snapshot memiliki tag Project=XYZ dan tag permintaan adalah Service=Elasticache.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "elasticache:CopySnapshot",
"Resource": [
"arn:aws:elasticache:*:*:snapshot:*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Project": "XYZ",
"aws:RequestTag/Service": "Elasticache"
}
}
}
]
}
```
------
1. Menolak `CreateCacheCluster` tindakan jika tag permintaan `Project` hilang atau tidak sama dengan `Dev`, `QA` atau `Prod`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticache:CreateCacheCluster"
],
"Resource": [
"arn:aws:elasticache:*:*:parametergroup:*",
"arn:aws:elasticache:*:*:subnetgroup:*",
"arn:aws:elasticache:*:*:securitygroup:*",
"arn:aws:elasticache:*:*:replicationgroup:*"
]
},
{
"Effect": "Deny",
"Action": [
"elasticache:CreateCacheCluster"
],
"Resource": [
"arn:aws:elasticache:*:*:cluster:*"
],
"Condition": {
"Null": {
"aws:RequestTag/Project": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"elasticache:CreateCacheCluster",
"elasticache:AddTagsToResource"
],
"Resource": "arn:aws:elasticache:*:*:cluster:*",
"Condition": {
"StringEquals": {
"aws:RequestTag/Project": [
"Dev",
"Prod",
"QA"
]
}
}
}
]
}
```
------
Untuk informasi terkait kunci kondisi ini, lihat [Menggunakan kunci kondisi](IAM.ConditionKeys.md).
# Memantau biaya dengan tag alokasi biaya
Saat menambahkan tag alokasi biaya ke sumber daya di Amazon ElastiCache, Anda dapat melacak biaya dengan mengelompokkan pengeluaran pada faktur berdasarkan nilai tag sumber daya.
Tag alokasi ElastiCache biaya adalah pasangan nilai kunci yang Anda tentukan dan kaitkan dengan sumber daya. ElastiCache Kunci dan nilai peka terhadap huruf besar dan kecil. Anda dapat menggunakan kunci tag untuk menentukan kategori, dan nilai tag dapat berupa item dalam kategori tersebut. Misalnya, Anda dapat menentukan kunci tag `CostCenter` dan nilai tag `10010`, yang menunjukkan bahwa sumber daya tersebut ditetapkan ke pusat pembiayaan 10010. Anda juga dapat menggunakan tag untuk menunjukkan bahwa sumber daya sedang digunakan untuk pengujian atau produksi menggunakan kunci seperti `Environment` dan nilai seperti `test` atau `production`. Sebaiknya gunakan kumpulan kunci tag yang konsisten untuk mempermudah pelacakan biaya yang terkait dengan sumber daya Anda.
Gunakan tag alokasi biaya untuk mengatur AWS tagihan Anda untuk mencerminkan struktur biaya Anda sendiri. Untuk melakukan ini, daftar untuk mendapatkan tagihan AWS akun Anda dengan nilai kunci tag disertakan. Kemudian, untuk melihat biaya sumber daya gabungan, atur informasi penagihan Anda sesuai dengan sumber daya Anda dengan nilai kunci tag yang sama. Misalnya, Anda dapat memberikan tag pada beberapa sumber daya dengan nama aplikasi tertentu, kemudian mengatur informasi penagihan untuk melihat biaya total aplikasi tersebut pada beberapa layanan.
Anda juga dapat menggabungkan tag untuk melacak biaya dengan tingkat detail yang lebih besar. Misalnya, untuk melacak biaya layanan Anda menurut wilayah, Anda dapat menggunakan kunci tag `Service` dan `Region`. Di salah satu sumber daya Anda mungkin memiliki nilai `ElastiCache` dan `Asia Pacific (Singapore)`, serta di sumber daya lain Anda mempunyai nilai `ElastiCache` dan `Europe (Frankfurt)`. Anda kemudian dapat melihat total ElastiCache biaya Anda dipecah berdasarkan wilayah. Untuk informasi selengkapnya, lihat [Menggunakan Tag Alokasi Biaya](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) dalam *Panduan Pengguna AWS Billing*.
Anda dapat menambahkan tag alokasi ElastiCache biaya ke cluster berbasis ElastiCache node. Saat Anda menambahkan, menampilkan daftar, mengubah, menyalin, atau menghapus tag, operasi tersebut hanya akan diterapkan ke klaster yang ditentukan.
**Karakteristik ElastiCache tag alokasi biaya**
+ Tag alokasi biaya diterapkan ke ElastiCache sumber daya yang ditentukan dalam operasi CLI dan API sebagai ARN. Jenis sumber daya akan berupa "klaster".
Contoh ARN: `arn:aws:elasticache::::`
Contoh arn: `arn:aws:elasticache:us-west-2:1234567890:cluster:my-cluster`
+ Kunci tag adalah nama tag yang wajib diisi. Nilai string kunci dapat terdiri dari 1 hingga 128 karakter Unicode dan tidak boleh diawali dengan `aws:`. String dapat berisi hanya kumpulan huruf Unicode, angka, spasi kosong, garis bawah (\$1), titik (.), titik dua (:), garis miring terbalik (\$1), tanda sama dengan (=), tanda plus (\$1), tanda hubung (-), atau tanda at (@).
+ Nilai tag adalah nilai tag opsional. Nilai string dari nilai dapat terdiri dari 1 hingga 256 karakter Unicode dan tidak boleh diawali dengan `aws:`. String dapat berisi hanya kumpulan huruf Unicode, angka, spasi kosong, garis bawah (\$1), titik (.), titik dua (:), garis miring terbalik (\$1), tanda sama dengan (=), tanda plus (\$1), tanda hubung (-), atau tanda at (@).
+ ElastiCache Sumber daya dapat memiliki maksimal 50 tag.
+ Nilai tidak harus unik dalam kumpulan tag. Misalnya, Anda dapat memiliki kumpulan tag dengan kunci `Service` dan `Application` yang memiliki nilai `ElastiCache`.
AWS tidak menerapkan makna semantik apa pun pada tag Anda. Tag ditafsirkan secara ketat sebagai string karakter.AWS tidak secara otomatis mengatur tag apa pun pada ElastiCache sumber daya apa pun.
# Mengelola tag alokasi biaya Anda menggunakan AWS CLI
Anda dapat menggunakan AWS CLI untuk menambah, memodifikasi, atau menghapus tag alokasi biaya.
Tag alokasi biaya diterapkan ke ElastiCache cluster. Klaster yang akan diberi tag ditentukan menggunakan ARN (Amazon Resource Name).
arn Sampel: `arn:aws:elasticache:us-west-2:1234567890:cluster:my-cluster`
**Topics**
+ [Listing tag menggunakan AWS CLI](#Tagging.Managing.CLI.List)
+ [Menambahkan tag menggunakan AWS CLI](#Tagging.Managing.CLI.Add)
+ [Memodifikasi tag menggunakan AWS CLI](#Tagging.Managing.CLI.Modify)
+ [Menghapus tag menggunakan AWS CLI](#Tagging.Managing.CLI.Remove)
## Listing tag menggunakan AWS CLI
Anda dapat menggunakan tag AWS CLI untuk daftar pada ElastiCache sumber daya yang ada dengan menggunakan [list-tags-for-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-tags-for-resource.html) operasi.
Kode berikut menggunakan daftar tag pada cluster Memcached di wilayah `my-cluster` us-west-2. AWS CLI
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-tags-for-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster
```
Untuk Windows:
```
aws elasticache list-tags-for-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster
```
Kode berikut menggunakan AWS CLI untuk daftar tag pada node Valkey atau Redis OSS di `my-cluster` cluster `my-cluster-001` di wilayah us-west-2.
Untuk Linux, macOS, atau Unix:
```
aws elasticache list-tags-for-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001
```
Untuk Windows:
```
aws elasticache list-tags-for-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001
```
Output dari operasi ini akan terlihat seperti berikut ini, daftar semua tag pada sumber daya.
```
{
"TagList": [
{
"Value": "10110",
"Key": "CostCenter"
},
{
"Value": "EC2",
"Key": "Service"
}
]
}
```
Jika tidak ada tag pada sumber daya, output akan kosong TagList.
```
{
"TagList": []
}
```
Untuk informasi lebih lanjut, lihat AWS CLI untuk ElastiCache [list-tags-for-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-tags-for-resource.html).
## Menambahkan tag menggunakan AWS CLI
Anda dapat menggunakan AWS CLI untuk menambahkan tag ke ElastiCache sumber daya yang ada dengan menggunakan operasi [add-tags-to-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/add-tags-to-resource.html) CLI. Jika kunci tag tidak ada di sumber daya, kunci dan nilai akan ditambahkan ke sumber daya. Jika kunci sudah ada di sumber daya, nilai yang terkait dengan kunci tersebut akan diperbarui ke nilai yang baru.
Kode berikut menggunakan AWS CLI untuk menambahkan kunci `Service` dan `Region` dengan nilai-nilai `elasticache` dan `us-west-2` masing-masing ke node di cluster `my-cluster-001` `my-cluster` di wilayah us-west-2.
**Memcache**
Untuk Linux, macOS, atau Unix:
```
aws elasticache add-tags-to-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster \
--tags Key=Service,Value=elasticache \
Key=Region,Value=us-west-2
```
Untuk Windows:
```
aws elasticache add-tags-to-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster ^
--tags Key=Service,Value=elasticache ^
Key=Region,Value=us-west-2
```
**Redis**
Untuk Linux, macOS, atau Unix:
```
aws elasticache add-tags-to-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001 \
--tags Key=Service,Value=elasticache \
Key=Region,Value=us-west-2
```
Untuk Windows:
```
aws elasticache add-tags-to-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001 ^
--tags Key=Service,Value=elasticache ^
Key=Region,Value=us-west-2
```
Output dari operasi ini akan terlihat seperti berikut ini, daftar semua tag pada sumber daya mengikuti operasi tersebut.
```
{
"TagList": [
{
"Value": "elasticache",
"Key": "Service"
},
{
"Value": "us-west-2",
"Key": "Region"
}
]
}
```
Untuk informasi lebih lanjut, lihat AWS CLI untuk ElastiCache [add-tags-to-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/add-tags-to-resource.html).
Anda juga dapat menggunakan AWS CLI untuk menambahkan tag ke cluster saat Anda membuat cluster baru dengan menggunakan operasi[create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html). Anda tidak dapat menambahkan tag saat membuat klaster menggunakan konsol ElastiCache manajemen. Setelah klaster dibuat, Anda kemudian dapat menggunakan konsol untuk menambahkan tag pada klaster tersebut.
## Memodifikasi tag menggunakan AWS CLI
Anda dapat menggunakan AWS CLI untuk memodifikasi tag pada ElastiCache cluster.
Untuk mengubah tag:
+ Gunakan [add-tags-to-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/add-tags-to-resource.html) untuk menambahkan tag dan nilai baru atau untuk mengubah nilai yang terkait dengan tag yang ada.
+ Gunakan [remove-tags-from-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/remove-tags-from-resource.html) untuk menghapus tag tertentu dari sumber daya.
Output dari kedua operasi tersebut akan berupa daftar tag dan nilai-nilainya di klaster yang ditentukan.
## Menghapus tag menggunakan AWS CLI
Anda dapat menggunakan AWS CLI untuk menghapus tag dari cluster yang ada ElastiCache untuk Memcached dengan menggunakan operasi. [remove-tags-from-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/remove-tags-from-resource.html)
Untuk Memcached, kode berikut menggunakan AWS CLI untuk menghapus tag dengan kunci `Service` dan `Region` dari node `my-cluster-001` di cluster `my-cluster` di wilayah us-west-2.
Untuk Linux, macOS, atau Unix:
```
aws elasticache remove-tags-from-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster \
--tag-keys PM Service
```
Untuk Windows:
```
aws elasticache remove-tags-from-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster ^
--tag-keys PM Service
```
Untuk Redis OSS, kode berikut menggunakan AWS CLI untuk menghapus tag dengan kunci `Service` dan `Region` dari node `my-cluster-001` di cluster `my-cluster` di wilayah us-west-2.
Untuk Linux, macOS, atau Unix:
```
aws elasticache remove-tags-from-resource \
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001 \
--tag-keys PM Service
```
Untuk Windows:
```
aws elasticache remove-tags-from-resource ^
--resource-name arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001 ^
--tag-keys PM Service
```
Output dari operasi ini akan terlihat seperti berikut ini, daftar semua tag pada sumber daya mengikuti operasi tersebut.
```
{
"TagList": []
}
```
Untuk informasi lebih lanjut, lihat AWS CLI untuk ElastiCache [remove-tags-from-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticache/remove-tags-from-resource.html).
# Mengelola tag alokasi biaya Anda menggunakan API ElastiCache
Anda dapat menggunakan ElastiCache API untuk menambahkan, memodifikasi, atau menghapus tag alokasi biaya.
Tag alokasi biaya diterapkan ElastiCache untuk cluster Memcached. Klaster yang akan diberi tag ditentukan menggunakan ARN (Amazon Resource Name).
arn Sampel: `arn:aws:elasticache:us-west-2:1234567890:cluster:my-cluster`
**Topics**
+ [Listing tag menggunakan ElastiCache API](#Tagging.Managing.API.List)
+ [Menambahkan tag menggunakan ElastiCache API](#Tagging.Managing.API.Add)
+ [Memodifikasi tag menggunakan API ElastiCache](#Tagging.Managing.API.Modify)
+ [Menghapus tag menggunakan ElastiCache API](#Tagging.Managing.API.Remove)
## Listing tag menggunakan ElastiCache API
Anda dapat menggunakan ElastiCache API untuk mencantumkan tag pada sumber daya yang ada dengan menggunakan [ListTagsForResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListTagsForResource.html) operasi.
Untuk Memcached, kode berikut menggunakan ElastiCache API untuk mencantumkan tag pada sumber daya `my-cluster` di wilayah us-west-2.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListTagsForResource
&ResourceName=arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Version=2015-02-02
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk Redis OSS, kode berikut menggunakan ElastiCache API untuk mencantumkan tag pada sumber daya `my-cluster-001` di wilayah us-west-2.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ListTagsForResource
&ResourceName=arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Version=2015-02-02
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
## Menambahkan tag menggunakan ElastiCache API
Anda dapat menggunakan ElastiCache API untuk menambahkan tag ke ElastiCache cluster yang ada dengan menggunakan [AddTagsToResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_AddTagsToResource.html) operasi. Jika kunci tag tidak ada di sumber daya, kunci dan nilai akan ditambahkan ke sumber daya. Jika kunci sudah ada di sumber daya, nilai yang terkait dengan kunci tersebut akan diperbarui ke nilai yang baru.
Kode berikut menggunakan ElastiCache API untuk menambahkan kunci `Service` dan `Region` dengan nilai `elasticache` dan `us-west-2` masing-masing. Untuk Memcached, ini diterapkan ke sumber daya. `my-cluster` Untuk Redis OSS, ini diterapkan pada sumber daya `my-cluster-001` di wilayah us-west-2.
**Memcache**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=AddTagsToResource
&ResourceName=arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Tags.member.1.Key=Service
&Tags.member.1.Value=elasticache
&Tags.member.2.Key=Region
&Tags.member.2.Value=us-west-2
&Version=2015-02-02
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
**Redis**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=AddTagsToResource
&ResourceName=arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Tags.member.1.Key=Service
&Tags.member.1.Value=elasticache
&Tags.member.2.Key=Region
&Tags.member.2.Value=us-west-2
&Version=2015-02-02
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat [AddTagsToResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_AddTagsToResource.html) di *Referensi Amazon ElastiCache API*.
## Memodifikasi tag menggunakan API ElastiCache
Anda dapat menggunakan ElastiCache API untuk memodifikasi tag pada sebuah ElastiCache cluster.
Untuk mengubah nilai tag:
+ Gunakan operasi [AddTagsToResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_AddTagsToResource.html) untuk menambahkan tag dan nilai baru atau untuk mengubah nilai tag yang ada.
+ Gunakan [RemoveTagsFromResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_RemoveTagsFromResource.html) untuk menghapus tag dari sumber daya.
Hasil dari kedua operasi tersebut akan berupa daftar tag dan nilai-nilainya di sumber daya yang ditentukan.
Gunakan [RemoveTagsFromResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_RemoveTagsFromResource.html) untuk menghapus tag dari sumber daya.
## Menghapus tag menggunakan ElastiCache API
Anda dapat menggunakan ElastiCache API untuk menghapus tag dari cluster yang sudah ada ElastiCache untuk Memcached dengan menggunakan operasi. [RemoveTagsFromResource](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_RemoveTagsFromResource.html)
Kode berikut menggunakan ElastiCache API untuk menghapus tag dengan kunci `Service` dan `Region` dari node di cluster `my-cluster-001` `my-cluster` di wilayah us-west-2.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=RemoveTagsFromResource
&ResourceName=arn:aws:elasticache:us-west-2:0123456789:cluster:my-cluster-001
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&TagKeys.member.1=Service
&TagKeys.member.2=Region
&Version=2015-02-02
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
# Menggunakan Lensa Amazon ElastiCache Well-Architected
Bagian ini menjelaskan Amazon ElastiCache Well-Architected Lens, kumpulan prinsip desain dan panduan untuk merancang beban kerja yang dirancang dengan baik. ElastiCache
+ ElastiCache Lensa bersifat aditif untuk [AWS Well-Architected](https://docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html) Framework.
+ Setiap Pilar memiliki serangkaian pertanyaan untuk membantu memulai diskusi seputar ElastiCache Arsitektur.
+ Setiap pertanyaan memiliki sejumlah praktik terkemuka bersama dengan skornya untuk pelaporan.
+ *Wajib* - Diperlukan sebelum mulai ke prod (tidak memenuhinya menimbulkan risiko tinggi)
+ *Terbaik* - Kemungkinan kondisi terbaik yang dapat dimiliki pelanggan
+ *Bagus* - Apa yang kami rekomendasikan untuk dimiliki pelanggan (tidak memenuhinya menimbulkan risiko sedang)
+ Terminology Well-Architected
+ [Komponen](https://docs.aws.amazon.com/wellarchitected/latest/framework/definitions.html) — Kode, konfigurasi, dan AWS Sumber Daya yang bersama-sama memenuhi persyaratan. Komponen berinteraksi dengan komponen lain, dan sering disamakan dengan layanan dalam arsitektur microservice.
+ [Beban Kerja](https://docs.aws.amazon.com/wellarchitected/latest/framework/definitions.html) - Satu set komponen yang bersama-sama memberikan nilai bisnis. Contoh beban kerja adalah situs web pemasaran, situs web e-commerce, back-end untuk aplikasi seluler, platform analitik, dll.
**catatan**
Panduan ini belum diperbarui untuk menyertakan informasi tentang caching ElastiCache tanpa server dan mesin Valkey baru.
**Topics**
+ [Pilar ElastiCache Keunggulan Operasional Lensa Well-Architected Amazon](OperationalExcellencePillar.md)
+ [Pilar Keamanan Lensa ElastiCache Well-Architected Amazon](SecurityPillar.md)
+ [Pilar Keandalan Lensa ElastiCache Well-Architected Amazon](ReliabilityPillar.md)
+ [Pilar ElastiCache Efisiensi Kinerja Lensa Well-Architected Amazon](PerformanceEfficiencyPillar.md)
+ [Pilar ElastiCache Pengoptimalan Biaya Lensa Well-Architected Amazon](CostOptimizationPillar.md)
# Pilar ElastiCache Keunggulan Operasional Lensa Well-Architected Amazon
Pilar keunggulan operasional berfokus untuk menjalankan dan memantau sistem guna memberikan nilai bisnis, dan terus meningkatkan proses dan prosedur. Topik utamanya meliputi mengotomatisasi perubahan, menanggapi peristiwa, dan mendefinisikan standar untuk mengelola operasi harian.
**Topics**
+ [OE 1: Bagaimana Anda memahami dan menanggapi peringatan dan peristiwa yang dipicu oleh cluster Anda? ElastiCache](#OperationalExcellencePillarOE1)
+ [OE 2: Kapan dan bagaimana Anda menskalakan ElastiCache cluster yang ada?](#OperationalExcellencePillarOE2)
+ [OE 3: Bagaimana Anda mengelola sumber daya ElastiCache cluster dan memelihara cluster Anda? up-to-date](#OperationalExcellencePillarOE3)
+ [OE 4: Bagaimana Anda mengelola koneksi klien ke cluster Anda? ElastiCache](#OperationalExcellencePillarOE4)
+ [OE 5: Bagaimana Anda menerapkan ElastiCache Komponen untuk Beban Kerja?](#OperationalExcellencePillarOE5)
+ [OE 6: Bagaimana cara merencanakan dan mengurangi kegagalan?](#OperationalExcellencePillarOE6)
+ [OE 7: Bagaimana Anda memecahkan masalah peristiwa mesin Valkey atau Redis OSS?](#OperationalExcellencePillarOE7)
## OE 1: Bagaimana Anda memahami dan menanggapi peringatan dan peristiwa yang dipicu oleh cluster Anda? ElastiCache
**Pengenalan tingkat pertanyaan:** Saat Anda mengoperasikan ElastiCache kluster, Anda dapat menerima pemberitahuan dan peringatan secara opsional saat peristiwa tertentu terjadi. ElastiCache, secara default, mencatat [peristiwa](ECEvents.md) yang berhubungan dengan sumber daya Anda, seperti failover, penggantian node, operasi penskalaan, pemeliharaan terjadwal, dan banyak lagi. Setiap peristiwa mencakup tanggal dan waktu, nama sumber dan jenis sumber, dan deskripsi.
**Manfaat tingkat pertanyaan: **Mampu memahami dan mengelola alasan mendasar di balik peristiwa yang memicu peringatan yang dihasilkan oleh klaster Anda memungkinkan Anda beroperasi lebih efektif dan merespons peristiwa dengan tepat.
+ **[Diperlukan]** [Tinjau peristiwa yang dihasilkan oleh ElastiCache di ElastiCache konsol (setelah memilih wilayah Anda) atau menggunakan [perintah mendeskripsikan peristiwa Amazon Command Line Interface](https://aws.amazon.com/cli)[(AWS CLI) dan API](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-events.html). ElastiCache ](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEvents.html) Konfigurasikan ElastiCache untuk mengirim notifikasi untuk peristiwa kluster penting menggunakan Amazon Simple Notification Service (Amazon SNS). Menggunakan Amazon SNS dengan cluster Anda memungkinkan Anda untuk secara terprogram mengambil tindakan atas peristiwa. ElastiCache
+ Ada dua kategori besar peristiwa: peristiwa terkini dan terjadwal. Daftar peristiwa terkini meliputi: pembuatan dan penghapusan sumber daya, operasi penskalaan, failover, boot ulang simpul, snapshot dibuat, perubahan parameter klaster, pembaruan sertifikat CA, peristiwa kegagalan (kegagalan penyediaan klaster - VPC atau ENI-, kegagalan penskalaan - ENI-, dan kegagalan snapshot). Daftar peristiwa terjadwal meliputi: simpul yang dijadwalkan akan diganti selama periode pemeliharaan dan penggantian simpul yang dijadwalkan ulang.
+ Meskipun Anda mungkin tidak perlu segera bereaksi terhadap beberapa peristiwa ini, penting untuk terlebih dahulu melihat semua peristiwa kegagalan:
+ ElastiCache:AddCacheNodeFailed
+ ElastiCache:CacheClusterProvisioningFailed
+ ElastiCache:CacheClusterScalingFailed
+ ElastiCache:CacheNodesRebooted
+ ElastiCache: SnapshotFailed (Valkey atau Redis OSS saja)
+ **[Sumber Daya]:**
+ [Mengelola ElastiCache notifikasi Amazon SNS](ECEvents.SNS.md)
+ [Notifikasi Peristiwa dan Amazon SNS](ElastiCacheSNS.md)
+ **[Terbaik]** Untuk mengotomatiskan respons terhadap peristiwa, manfaatkan kemampuan AWS produk dan layanan seperti SNS dan Fungsi Lambda. Ikuti praktik terbaik dengan membuat perubahan yang kecil, sering, dan dapat dikembalikan, sebagai kode untuk mengembangkan operasi Anda dari waktu ke waktu. Anda harus menggunakan CloudWatch metrik Amazon untuk memantau cluster Anda.
**[Sumber Daya]:** [Monitor ElastiCache (mode cluster dinonaktifkan) baca titik akhir replika menggunakan AWS Lambda, Amazon Route 53, dan Amazon SNS untuk kasus penggunaan yang menggunakan Lambda dan SNS](https://aws.amazon.com/blogs/database/monitor-amazon-elasticache-for-redis-cluster-mode-disabled-read-replica-endpoints-using-aws-lambda-amazon-route-53-and-amazon-sns/).
## OE 2: Kapan dan bagaimana Anda menskalakan ElastiCache cluster yang ada?
**Pengenalan tingkat pertanyaan:** Ukuran kanan ElastiCache klaster Anda adalah tindakan penyeimbangan yang perlu dievaluasi setiap kali ada perubahan pada jenis beban kerja yang mendasarinya. Tujuan Anda adalah beroperasi dengan lingkungan yang telah di-rightsizing untuk beban kerja Anda.
**Manfaat tingkat pertanyaan: **Pemanfaatan sumber daya Anda yang berlebihan dapat mengakibatkan peningkatan latensi dan penurunan performa secara keseluruhan. Kurangnya pemanfaatan, di sisi lain, dapat mengakibatkan sumber daya yang disediakan secara berlebihan dengan optimisasi biaya yang tidak optimal. Dengan melakukan rightsizing lingkungan, Anda dapat mencapai keseimbangan antara efisiensi performa dan optimisasi biaya. Untuk memulihkan di atas atau di bawah pemanfaatan sumber daya Anda, ElastiCache dapat skala dalam dua dimensi. Anda dapat menskalakan secara vertikal dengan menambah atau mengurangi kapasitas simpul. Anda juga dapat menskalakan secara horizontal dengan menambahkan dan menghapus simpul.
+ **[Wajib]** Pemanfaatan CPU dan jaringan yang berlebihan pada simpul primer harus diatasi dengan memindahkan dan mengarahkan ulang operasi baca ke simpul replika. Gunakan simpul replika untuk operasi baca guna mengurangi pemanfaatan simpul primer. Ini dapat dikonfigurasi di pustaka klien Valkey atau Redis OSS Anda dengan menghubungkan ke titik akhir ElastiCache pembaca untuk mode cluster dinonaktifkan, atau dengan menggunakan perintah READONLY untuk mode cluster diaktifkan.
**[Sumber Daya]:**
+ [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md)
+ [Rightsizing Klaster](https://aws.amazon.com/blogs/database/five-workload-characteristics-to-consider-when-right-sizing-amazon-elasticache-redis-clusters/)
+ [Perintah READONLY](https://valkey.io/commands/readonly)
+ **[Wajib]** Pantau pemanfaatan sumber daya klaster penting seperti CPU, memori, dan jaringan. Pemanfaatan sumber daya klaster khusus ini perlu dilacak untuk mematangkan keputusan Anda dalam penskalaan, dan jenis operasi penskalaan. Untuk mode ElastiCache cluster dinonaktifkan, node primer dan replika dapat menskalakan secara vertikal. Simpul replika juga dapat diskalakan secara horizontal dari 0 ke 5 simpul. Untuk mode klaster diaktifkan, hal yang sama berlaku dalam setiap serpihan klaster. Selain itu, Anda dapat menambah atau mengurangi jumlah serpihan.
**[Sumber Daya]:**
+ [Memantau praktik terbaik dengan ElastiCache menggunakan Amazon CloudWatch](https://aws.amazon.com/blogs/database/monitoring-best-practices-with-amazon-elasticache-for-redis-using-amazon-cloudwatch/)
+ [Penskalaan ElastiCache Cluster untuk Valkey dan Redis OSS](Scaling.md)
+ [Penskalaan ElastiCache Cluster untuk Memcached](Scaling.md)
+ **[Terbaik]** Memantau tren dari waktu ke waktu dapat membantu Anda mendeteksi perubahan beban kerja yang akan luput dari perhatian jika dipantau pada titik waktu tertentu. Untuk mendeteksi tren jangka panjang, gunakan CloudWatch metrik untuk memindai rentang waktu yang lebih lama. Pembelajaran dari mengamati CloudWatch metrik periode yang diperpanjang harus menginformasikan perkiraan Anda seputar pemanfaatan sumber daya cluster. CloudWatch Titik data dan metrik tersedia hingga 455 hari.
**[Sumber Daya]:**
+ [Pemantauan ElastiCache dengan CloudWatch Metrik](CacheMetrics.md)
+ [Memantau Memcached dengan Metrik CloudWatch ](CacheMetrics.md)
+ [Memantau praktik terbaik dengan ElastiCache menggunakan Amazon CloudWatch](https://aws.amazon.com/blogs/database/monitoring-best-practices-with-amazon-elasticache-for-redis-using-amazon-cloudwatch/)
+ **[Terbaik]** Jika ElastiCache sumber daya Anda dibuat dengan CloudFormation itu adalah praktik terbaik untuk melakukan perubahan menggunakan CloudFormation template untuk menjaga konsistensi operasional dan menghindari perubahan konfigurasi yang tidak dikelola dan penyimpangan tumpukan.
**[Sumber Daya]:**
+ [ElastiCache referensi tipe sumber daya untuk CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_ElastiCache.html)
+ **[Terbaik]** Otomatiskan operasi penskalaan Anda menggunakan data operasional klaster dan tentukan ambang batas untuk menyiapkan alarm. CloudWatch Gunakan CloudWatch Events and Simple Notification Service (SNS) untuk memicu fungsi Lambda dan menjalankan ElastiCache API untuk menskalakan cluster Anda secara otomatis. Contohnya adalah menambahkan serpihan ke klaster Anda ketika metrik `EngineCPUUtilization` mencapai 80% untuk jangka waktu yang lama. Pilihan lain adalah menggunakan `DatabaseMemoryUsedPercentages` untuk ambang batas berbasis memori.
**[Sumber Daya]:**
+ [Menggunakan CloudWatch Alarm Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)
+ [Apa itu CloudWatch acara Amazon?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html)
+ [Menggunakan AWS Lambda dengan Amazon Simple Notification Service](https://docs.aws.amazon.com/lambda/latest/dg/with-sns.html)
+ [Referensi ElastiCache API](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/Welcome.html)
## OE 3: Bagaimana Anda mengelola sumber daya ElastiCache cluster dan memelihara cluster Anda? up-to-date
**Pengenalan tingkat pertanyaan:** Saat beroperasi dalam skala besar, penting bagi Anda untuk dapat menentukan dan mengidentifikasi semua sumber daya Anda. ElastiCache Saat meluncurkan fitur aplikasi baru, Anda perlu membuat simetri versi cluster di semua jenis ElastiCache lingkungan Anda: dev, testing, dan production. Atribut sumber daya memungkinkan Anda memisahkan lingkungan untuk tujuan operasional yang berbeda-beda, seperti saat meluncurkan fitur baru dan mengaktifkan mekanisme keamanan baru.
**Manfaat tingkat pertanyaan: **Memisahkan lingkungan pengembangan, pengujian, dan produksi Anda adalah praktik operasional terbaik. Praktik terbaik lainnya adalah klaster dan simpul Anda di seluruh lingkungan memiliki patch perangkat lunak terbaru yang diterapkan menggunakan proses yang dipahami dan terdokumentasi dengan baik. Mengambil keuntungan dari ElastiCache fitur asli memungkinkan tim teknik Anda untuk fokus pada memenuhi tujuan bisnis dan bukan pada ElastiCache pemeliharaan.
+ **[Terbaik]** Jalankan pada versi mesin terbaru yang tersedia dan terapkan Pembaruan Layanan Mandiri secepat tersedia. ElastiCache secara otomatis memperbarui infrastruktur dasarnya selama jendela pemeliharaan cluster yang Anda tentukan. Namun, simpul yang berjalan di klaster Anda diperbarui melalui Pembaruan Layanan Mandiri. Pembaruan ini dapat terdiri dari dua jenis: patch keamanan atau pembaruan perangkat lunak minor. Pastikan Anda memahami perbedaan berbagai jenis patch dan waktu penerapannya.
**[Sumber Daya]:**
+ [Pembaruan Layanan Mandiri di Amazon ElastiCache](Self-Service-Updates.md)
+ [Halaman Bantuan Pemeliharaan dan Pembaruan Layanan ElastiCache Terkelola Amazon](https://aws.amazon.com/elasticache/elasticache-maintenance/)
+ **[Terbaik]** Atur ElastiCache sumber daya Anda menggunakan tag. Gunakan tag pada grup replikasi dan bukan pada simpul individual. Anda dapat mengonfigurasi tag agar ditampilkan saat Anda mengueri sumber daya dan Anda dapat menggunakan tag untuk melakukan pencarian dan menerapkan filter. Anda harus menggunakan Grup Sumber Daya agar dapat dengan mudah membuat dan memelihara kumpulan sumber daya yang memiliki set tag yang sama.
**[Sumber Daya]:**
+ [Praktik Terbaik Pemberian Tag](https://d1.awsstatic.com/whitepapers/aws-tagging-best-practices.pdf)
+ [ElastiCache referensi tipe sumber daya untuk CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_ElastiCache.html)
+ [Grup Parameter](ParameterGroups.Engine.md#ParameterGroups.Redis)
## OE 4: Bagaimana Anda mengelola koneksi klien ke cluster Anda? ElastiCache
**Pengenalan tingkat pertanyaan:** Saat beroperasi dalam skala besar, Anda perlu memahami bagaimana klien Anda terhubung dengan ElastiCache klaster untuk mengelola aspek operasional aplikasi Anda (seperti waktu respons).
**Manfaat tingkat pertanyaan: **Memilih mekanisme koneksi yang paling tepat memastikan bahwa aplikasi Anda tidak terputus karena kesalahan konektivitas, seperti waktu habis.
+ **[Wajib]** Pisahkan operasi baca dari tulis dan hubungkan ke simpul replika untuk menjalankan operasi baca. Namun, ketahuilah ketika Anda memisahkan tulisan dari bacaan, Anda akan kehilangan kemampuan untuk membaca kunci segera setelah menulisnya karena sifat asinkron dari replikasi Valkey dan Redis OSS. Perintah WAIT dapat dimanfaatkan untuk meningkatkan keamanan data dunia nyata dan memaksa replika mengonfirmasi penulisan sebelum merespons klien, dengan mengorbankan performa secara keseluruhan. Menggunakan node replika untuk operasi baca dapat dikonfigurasi di pustaka ElastiCache klien Anda menggunakan endpoint ElastiCache pembaca untuk mode cluster dinonaktifkan. Untuk mode cluster diaktifkan, gunakan perintah READONLY. Untuk banyak pustaka ElastiCache klien, READONLY diimplementasikan secara default atau melalui pengaturan konfigurasi.
**[Sumber Daya]:**
+ [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md)
+ [READONLY](https://valkey.io/commands/readonly)
+ **[Wajib] **Gunakan pooling koneksi. Pembuatan koneksi TCP akan menghabiskan waktu CPU di sisi klien dan server dan pooling memungkinkan Anda menggunakan kembali koneksi TCP.
Untuk mengurangi overhead koneksi, Anda harus menggunakan pooling koneksi. Dengan pool koneksi, aplikasi Anda dapat menggunakan kembali dan melepaskan koneksi 'sesuka hati', tanpa perlu membuat koneksi. Anda dapat menerapkan penyatuan koneksi melalui pustaka ElastiCache klien Anda (jika didukung), dengan Framework yang tersedia untuk lingkungan aplikasi Anda, atau membangunnya dari bawah ke atas.
+ **[Terbaik]** Pastikan waktu habis soket klien diatur ke setidaknya satu detik (vs. default "tidak ada" di beberapa klien).
+ Mengatur nilai waktu habis terlalu rendah dapat menyebabkan kemungkinan waktu habis ketika beban server tinggi. Pengaturan yang terlalu tinggi dapat mengakibatkan aplikasi Anda membutuhkan waktu lama untuk mendeteksi masalah koneksi.
+ Kendalikan volume koneksi baru dengan menerapkan pooling koneksi di aplikasi klien Anda. Ini mengurangi latensi dan pemanfaatan CPU yang diperlukan untuk membuka dan menutup koneksi, dan melakukan handshake TLS jika TLS diaktifkan di klaster.
**[Sumber Daya]:** [Konfigurasikan ElastiCache untuk ketersediaan yang lebih tinggi](https://aws.amazon.com/blogs/database/configuring-amazon-elasticache-for-redis-for-higher-availability/)
+ **[Baik]** Menggunakan pipelining (jika kasus penggunaan Anda memungkinkannya) dapat meningkatkan performa secara signifikan.
+ Dengan pipelining, Anda akan mengurangi Waktu Pulang Pergi (RTT) antara klien aplikasi dan klaster serta permintaan baru dapat diproses bahkan jika klien belum membaca respons sebelumnya.
+ Dengan pipelining Anda dapat mengirim beberapa perintah ke server tanpa menunggu replies/ack. Kelemahan dari pipelining adalah ketika Anda akhirnya mengambil semua respons secara massal, mungkin ada kesalahan yang tidak akan Anda temukan sampai akhir.
+ Terapkan metode untuk mencoba kembali permintaan ketika ditampilkan kesalahan yang menghilangkan permintaan buruk.
**[Sumber Daya]:** [Pipelining](https://valkey.io/topics/pipelining/)
## OE 5: Bagaimana Anda menerapkan ElastiCache Komponen untuk Beban Kerja?
**Pengenalan tingkat pertanyaan:** ElastiCache lingkungan dapat digunakan secara manual melalui AWS Konsol, atau secara terprogram melalui, CLI, toolkitAPIs, dll. Praktik terbaik Keunggulan Operasional menyarankan untuk mengotomatiskan deployment melalui kode jika memungkinkan. Selain itu, ElastiCache cluster dapat diisolasi oleh beban kerja atau digabungkan untuk tujuan pengoptimalan biaya.
**Manfaat tingkat pertanyaan:** Memilih mekanisme penyebaran yang paling tepat untuk ElastiCache lingkungan Anda dapat meningkatkan Keunggulan Operasi dari waktu ke waktu. Sebaiknya lakukan operasi sebagai kode jika memungkinkan untuk meminimalkan kesalahan manusia dan meningkatkan pengulangan, fleksibilitas, dan waktu respons terhadap peristiwa.
Dengan memahami persyaratan isolasi beban kerja, Anda dapat memilih untuk memiliki ElastiCache lingkungan khusus per beban kerja atau menggabungkan beberapa beban kerja menjadi satu cluster, atau kombinasinya. Memahami kompromi dapat membantu mencapai keseimbangan antara Keunggulan Operasional dan Optimalisasi Biaya
+ **[Wajib]** Pahami opsi penerapan yang tersedia ElastiCache, dan otomatiskan prosedur ini bila memungkinkan. Kemungkinan jalan otomatisasi termasuk CloudFormation, AWS CLI/SDK, dan. APIs
**[Sumber Daya]: **
+ [Referensi jenis ElastiCache sumber daya Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_ElastiCache.html)
+ [elasticache](https://docs.aws.amazon.com/cli/latest/reference/elasticache/index.html)
+ [Amazon ElastiCache API Referensi](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/Welcome.html)
+ **[Wajib]** Untuk semua beban kerja, tentukan tingkat isolasi klaster yang diperlukan.
+ **[Terbaik]:** Isolasi Tinggi – pemetaan beban kerja ke klaster 1:1. Memungkinkan kontrol berbutir terbaik atas akses, ukuran, penskalaan, dan pengelolaan ElastiCache sumber daya berdasarkan per beban kerja.
+ **[Lebih Baik]:** Isolasi Sedang – M:1 diisolasi berdasarkan tujuan tetapi mungkin dibagi di beberapa beban kerja (misalnya klaster yang dikhususkan untuk caching beban kerja, dan yang lain dikhususkan untuk pesan).
+ **[Baik]:** Isolasi Rendah - M:1 semua tujuan, dibagikan sepenuhnya. Direkomendasikan untuk beban kerja di mana akses bersama dapat diterima.
## OE 6: Bagaimana cara merencanakan dan mengurangi kegagalan?
**Pengenalan tingkat pertanyaan:** Keunggulan Operasional mencakup mengantisipasi kegagalan dengan melakukan latihan “pra-mortem” reguler untuk mengidentifikasi sumber kegagalan potensial sehingga dapat dihilangkan atau dikurangi. ElastiCache menawarkan API Failover yang memungkinkan simulasi kejadian kegagalan node, untuk tujuan pengujian.
**Manfaat tingkat pertanyaan: **Dengan menguji skenario kegagalan lebih dahulu, Anda dapat mempelajari bagaimana pengaruhnya terhadap beban kerja Anda. Ini memungkinkan pengujian prosedur respons yang aman dan efektivitasnya, serta membuat tim Anda terbiasa dengan eksekusinya.
**[Diperlukan]** Secara teratur melakukan pengujian failover di akun dev/test. [TestFailover](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_TestFailover.html)
## OE 7: Bagaimana Anda memecahkan masalah peristiwa mesin Valkey atau Redis OSS?
**Pengenalan tingkat pertanyaan:** Keunggulan Operasional membutuhkan kemampuan untuk menyelidiki informasi tingkat layanan dan tingkat mesin untuk menganalisis kesehatan dan status cluster Anda. ElastiCache dapat memancarkan log mesin Valkey atau Redis OSS ke Amazon CloudWatch dan Amazon Kinesis Data Firehose.
**Manfaat tingkat pertanyaan:** Mengaktifkan log mesin Valkey atau Redis OSS pada ElastiCache cluster memberikan wawasan tentang peristiwa yang berdampak pada kesehatan dan kinerja cluster. Log mesin Valkey atau Redis OSS menyediakan data langsung dari mesin yang tidak tersedia melalui mekanisme kejadian. ElastiCache Melalui pengamatan yang cermat terhadap kedua ElastiCache peristiwa (lihat OE-1 sebelumnya) dan log mesin, dimungkinkan untuk menentukan urutan peristiwa saat pemecahan masalah dari perspektif layanan dan perspektif mesin. ElastiCache
+ **[Wajib]** Pastikan fungsionalitas pencatatan mesin Redis OSS diaktifkan, yang tersedia pada ElastiCache versi 6.2 untuk Redis OSS dan yang lebih baru. Ini dapat dilakukan selama pembuatan klaster atau dengan mengubah klaster setelah pembuatan.
+ Tentukan apakah Amazon CloudWatch Log atau Amazon Kinesis Data Firehose adalah target yang tepat untuk log mesin Redis OSS.
+ Pilih log target yang sesuai dalam salah satu CloudWatch atau Kinesis Data Firehose untuk mempertahankan log. Jika Anda memiliki beberapa klaster, pertimbangkan log target yang berbeda untuk setiap klaster karena ini akan membantu mengisolasi data saat pemecahan masalah.
**[Sumber Daya]:**
+ Pengiriman log: [Pengiriman log](Log_Delivery.md)
+ Tujuan pencatatan: [Amazon CloudWatch Logs](Logging-destinations.md#Destination_Specs_CloudWatch_Logs)
+ Pengenalan Amazon CloudWatch Logs: [Apa itu Amazon CloudWatch Logs?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)
+ Pengenalan Amazon Kinesis Data Firehose: [Apa Itu Amazon Kinesis Data Firehose?](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html)
+ **[Terbaik]** Jika menggunakan CloudWatch Log Amazon, pertimbangkan untuk memanfaatkan Amazon CloudWatch Logs Insights untuk menanyakan log mesin Valkey atau Redis OSS untuk informasi penting.
Sebagai contoh, buat kueri terhadap grup CloudWatch Log yang berisi log mesin Valkey atau Redis OSS yang akan mengembalikan peristiwa dengan 'PERINGATAN', seperti: LogLevel
```
fields @timestamp, LogLevel, Message
| sort @timestamp desc
| filter LogLevel = "WARNING"
```
**[Sumber Daya]:** [Menganalisis data log dengan Wawasan CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html)
# Pilar Keamanan Lensa ElastiCache Well-Architected Amazon
Pilar keamanan berfokus pada perlindungan informasi dan sistem. Topik utama yang dibahas meliputi kerahasiaan dan integritas data, mengidentifikasi dan mengelola "siapa yang dapat melakukan apa" dengan manajemen berbasis hak akses, melindungi sistem, dan menetapkan kontrol untuk mendeteksi peristiwa keamanan.
**Topics**
+ [SEC 1: Langkah apa yang Anda ambil dalam mengendalikan akses resmi ke ElastiCache data?](#SecurityPillarSEC1)
+ [SEC 2: Apakah aplikasi Anda memerlukan otorisasi tambahan untuk kontrol berbasis jaringan di ElastiCache atas dan di atas?](#SecurityPillarSEC2)
+ [SEC 3: Apakah ada risiko bahwa perintah dapat dijalankan secara tidak sengaja yang menyebabkan kehilangan atau kegagalan data?](#SecurityPillarSEC3)
+ [SEC 4: Bagaimana Anda memastikan enkripsi data saat istirahat ElastiCache](#SecurityPillarSEC4)
+ [SEC 5: Bagaimana Anda mengenkripsi data dalam transit? ElastiCache](#SecurityPillarSEC5)
+ [SEC 6: Bagaimana Anda membatasi akses untuk bidang kontrol sumber daya?](#SecurityPillarSEC6)
+ [SEC 7: Bagaimana Anda mendeteksi dan menanggapi peristiwa keamanan?](#SecurityPillarSEC7)
## SEC 1: Langkah apa yang Anda ambil dalam mengendalikan akses resmi ke ElastiCache data?
**Pengenalan tingkat pertanyaan:** Semua ElastiCache cluster dirancang untuk diakses dari instans Amazon Elastic Compute Cloud dalam VPC, fungsi tanpa server (), atau wadah (Amazon Elastic Container Service AWS Lambda). Skenario yang paling sering ditemui adalah mengakses ElastiCache cluster dari instans Amazon Elastic Compute Cloud dalam Amazon Virtual Private Cloud yang sama (Amazon Virtual Private Cloud). Sebelum dapat terhubung ke cluster dari EC2 instans Amazon, Anda harus mengotorisasi EC2 instans Amazon untuk mengakses klaster. Untuk mengakses ElastiCache cluster yang berjalan di VPC, perlu untuk memberikan masuknya jaringan ke cluster.
**Manfaat tingkat pertanyaan: **Lalu lintas masuk jaringan ke dalam klaster dikendalikan melalui grup keamanan VPC. Grup keamanan bertindak sebagai firewall virtual untuk EC2 instans Amazon Anda untuk mengontrol lalu lintas masuk dan keluar. Aturan masuk mengontrol lalu lintas yang masuk ke instans Anda, dan aturan keluar mengontrol lalu lintas yang keluar dari instans Anda. Dalam kasus ElastiCache, ketika meluncurkan cluster, itu membutuhkan asosiasi grup keamanan. Hal ini memastikan bahwa aturan lalu lintas masuk dan keluar berlaku untuk semua simpul yang membentuk klaster. Selain itu, ElastiCache dikonfigurasi untuk menyebarkan pada subnet pribadi secara eksklusif sehingga mereka hanya dapat diakses dari melalui jaringan pribadi VPC.
+ **[Wajib] **Grup keamanan yang dikaitkan dengan klaster Anda mengontrol lalu lintas masuk dan akses jaringan ke klaster. Secara default, grup keamanan tidak akan memiliki aturan masuk yang ditentukan dan, oleh karena itu, tidak ada jalur masuk ke. ElastiCache Untuk mengaktifkan ini, konfigurasikan aturan masuk pada grup keamanan yang menentukan alamat/rentang IP sumber, lalu lintas jenis TCP dan port untuk ElastiCache cluster Anda (port default 6379 untuk Valkey dan Redis OSS misalnya ElastiCache ). Meskipun dimungkinkan untuk mengizinkan serangkaian sumber masuk yang sangat luas, seperti semua sumber daya dalam VPC (0.0.0.0/0), disarankan untuk sedetail mungkin dalam mendefinisikan aturan masuk seperti hanya mengotorisasi akses masuk ke klien Valkey atau Redis OSS yang berjalan di Amazon Amazon Amazon yang terkait dengan grup keamanan tertentu. EC2
**[Sumber Daya]: **
+ [Subnet dan grup subnet](SubnetGroups.md)
+ [Mengakses klaster atau grup replikasi Anda](accessing-elasticache.md)
+ [Mengontrol lalu lintas ke sumber daya menggunakan grup keamanan](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html#DefaultSecurityGroupdefault%20security%20group)
+ [Grup keamanan Amazon Elastic Compute Cloud untuk instans Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#creating-your-own-security-groups)
+ AWS Identity and Access Management Kebijakan **[Wajib]** dapat ditetapkan ke AWS Lambda fungsi yang memungkinkan mereka mengakses ElastiCache data. Untuk mengaktifkan fitur ini, buat peran eksekusi IAM dengan `AWSLambdaVPCAccessExecutionRole` izin, lalu tetapkan peran ke fungsi tersebut AWS Lambda .
**[Sumber Daya]:** Mengonfigurasi fungsi Lambda untuk mengakses Amazon di VPC ElastiCache Amazon: [Tutorial: Mengonfigurasi fungsi Lambda untuk](https://docs.aws.amazon.com/lambda/latest/dg/services-elasticache-tutorial.html) mengakses Amazon di VPC Amazon ElastiCache
## SEC 2: Apakah aplikasi Anda memerlukan otorisasi tambahan untuk kontrol berbasis jaringan di ElastiCache atas dan di atas?
**Pengenalan tingkat pertanyaan:** Dalam skenario di mana perlu untuk membatasi atau mengontrol akses ke cluster pada tingkat klien individu, disarankan untuk mengautentikasi melalui perintah AUTH. ElastiCache token otentikasi, dengan manajemen pengguna dan grup pengguna opsional, memungkinkan ElastiCache untuk memerlukan kata sandi sebelum mengizinkan klien menjalankan perintah dan kunci akses, sehingga meningkatkan keamanan bidang data.
**Manfaat tingkat pertanyaan:** Untuk membantu menjaga keamanan data Anda, ElastiCache sediakan mekanisme untuk melindungi terhadap akses data Anda yang tidak sah. Ini termasuk menegakkan ROLE-Based Access Control (RBAC) AUTH, atau token AUTH (kata sandi) yang digunakan oleh klien untuk terhubung sebelum melakukan perintah resmi. ElastiCache
+ **[Terbaik]** Untuk ElastiCache versi 6.x dan lebih tinggi untuk Redis OSS, dan ElastiCache versi 7.2 dan lebih tinggi untuk Valkey, tentukan kontrol otentikasi dan otorisasi dengan mendefinisikan grup pengguna, pengguna, dan string akses. Tetapkan pengguna ke grup pengguna, lalu tetapkan grup pengguna ke klaster. Untuk memanfaatkan RBAC, pemilihan harus dilakukan pada pembuatan klaster, dan enkripsi bergerak harus diaktifkan. Pastikan Anda menggunakan klien Valkey atau Redis OSS yang mendukung TLS untuk dapat memanfaatkan RBAC.
**[Sumber Daya]: **
+ [Menerapkan RBAC ke Grup Replikasi untuk ElastiCache](Clusters.RBAC.md#rbac-using)
+ [Menentukan Izin Menggunakan String Akses](Clusters.RBAC.md#Access-string)
+ [ACL](https://valkey.io/topics/acl/)
+ [ ElastiCache Versi yang didukung](VersionManagement.md#supported-engine-versions)
+ **[Terbaik]** Untuk ElastiCache versi sebelum 6.x untuk Redis OSS, selain menetapkan kuat token/password dan mempertahankan kebijakan kata sandi yang ketat untuk AUTH, praktik terbaik adalah memutar kata sandi/token. ElastiCache dapat mengelola hingga dua (2) token otentikasi pada waktu tertentu. Anda juga dapat mengubah klaster untuk secara eksplisit mewajibkan penggunaan token autentikasi.
**[Sumber Daya]:** [Memodifikasi token AUTH pada cluster yang ada ElastiCache](auth.md#auth-modifyng-token)
## SEC 3: Apakah ada risiko bahwa perintah dapat dijalankan secara tidak sengaja yang menyebabkan kehilangan atau kegagalan data?
**Pengenalan tingkat pertanyaan:** Ada sejumlah perintah Valkey atau Redis OSS yang dapat berdampak buruk pada operasi jika dijalankan secara tidak sengaja atau oleh aktor jahat. Perintah ini dapat memiliki konsekuensi yang tidak diinginkan dari perspektif performa dan keamanan data. Misalnya developer dapat secara rutin memanggil perintah FLUSHALL di lingkungan pengembangan, dan karena kesalahan mungkin secara tidak sengaja mencoba memanggil perintah ini pada sistem produksi, yang mengakibatkan kehilangan data yang tidak disengaja.
**Manfaat tingkat pertanyaan:** Dimulai dengan ElastiCache versi 5.0.3 untuk Redis OSS, Anda memiliki kemampuan untuk mengganti nama perintah tertentu yang mungkin mengganggu beban kerja Anda. Mengganti nama perintah dapat membantu mencegahnya dieksekusi secara tidak sengaja di klaster.
+ **[Wajib] **
**[Sumber Daya]: **
+ [ElastiCache versi 5.0.3 untuk Redis OSS (usang, gunakan versi 5.0.6)](engine-versions.md#redis-version-5-0.3)
+ [ElastiCache versi 5.0.3 untuk perubahan parameter Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.5-0-3)
+ [Keamanan Redis OSS](https://redis.io/docs/management/security/)
## SEC 4: Bagaimana Anda memastikan enkripsi data saat istirahat ElastiCache
**Pengenalan tingkat pertanyaan:** Meskipun ElastiCache merupakan penyimpanan data dalam memori, dimungkinkan untuk mengenkripsi data apa pun yang mungkin disimpan (pada penyimpanan) sebagai bagian dari operasi standar cluster. Hal ini termasuk pencadangan terjadwal dan manual yang ditulis ke Amazon S3, serta data yang disimpan ke penyimpanan disk sebagai hasil dari operasi sinkronisasi dan swap. Jenis instans dalam keluarga M6g dan R6g juga memiliki fitur enkripsi dalam memori yang selalu aktif.
**Manfaat tingkat pertanyaan:** ElastiCache menyediakan enkripsi opsional saat istirahat untuk meningkatkan keamanan data.
+ **[Diperlukan]** Enkripsi AT-rest dapat diaktifkan pada ElastiCache cluster (grup replikasi) hanya ketika dibuat. Klaster yang ada tidak dapat diubah untuk mulai mengenkripsi data diam. Secara default, ElastiCache akan menyediakan dan mengelola kunci yang digunakan dalam enkripsi saat istirahat.
**[Sumber Daya]: **
+ [Kendala Enkripsi At-Rest](at-rest-encryption.md#at-rest-encryption-constraints)
+ [Mengaktifkan Enkripsi Diam](at-rest-encryption.md#at-rest-encryption-enable)
+ **[Terbaik]** Manfaatkan jenis EC2 instans Amazon yang mengenkripsi data saat berada di memori (seperti M6g atau R6g). Jika memungkinkan, pertimbangkan untuk mengelola kunci Anda sendiri untuk enkripsi diam. Untuk lingkungan keamanan data yang lebih ketat, AWS Key Management Service (KMS) dapat digunakan untuk mengelola sendiri Customer Master Keys (CMK). Melalui ElastiCache integrasi dengan AWS Key Management Service, Anda dapat membuat, memiliki, dan mengelola kunci yang digunakan untuk enkripsi data saat istirahat untuk ElastiCache cluster Anda.
**[Sumber Daya]: **
+ [Menggunakan kunci yang dikelola pelanggan dari AWS Key Management Service](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security)
+ [AWS Layanan Manajemen Kunci](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)
+ [Konsep AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)
## SEC 5: Bagaimana Anda mengenkripsi data dalam transit? ElastiCache
**Pengantar tingkat pertanyaan:** Adalah persyaratan umum untuk memitigasi risiko data disusupi saat bergerak. Ini mewakili data dalam komponen sistem terdistribusi, serta antara klien aplikasi dan node cluster. ElastiCache mendukung persyaratan ini dengan memungkinkan untuk mengenkripsi data dalam transit antara klien dan cluster, dan antara node cluster itu sendiri. Jenis instans dalam keluarga M6g dan R6g juga memiliki fitur enkripsi dalam memori yang selalu aktif.
**Manfaat tingkat pertanyaan: Enkripsi ElastiCache in-transit Amazon** adalah fitur opsional yang memungkinkan Anda meningkatkan keamanan data Anda di titik-titik yang paling rentan, ketika sedang dalam perjalanan dari satu lokasi ke lokasi lain.
+ **[Wajib]** Enkripsi dalam transit hanya dapat diaktifkan pada klaster (grup replikasi) setelah pembuatan. Perlu diketahui bahwa karena pemrosesan tambahan yang diperlukan untuk mengenkripsi/mendekripsi data, penerapan enkripsi bergerak akan memiliki beberapa dampak terhadap performa. Untuk memahami dampaknya, disarankan untuk membandingkan beban kerja Anda sebelum dan sesudah mengaktifkan. encryption-in-transit
**[Sumber Daya]: **
+ [Gambaran umum enkripsi bergerak](in-transit-encryption.md#in-transit-encryption-overview)
## SEC 6: Bagaimana Anda membatasi akses untuk bidang kontrol sumber daya?
**Pengenalan tingkat pertanyaan:** Kebijakan IAM dan ARN memungkinkan kontrol akses berbutir halus ElastiCache untuk Valkey dan Redis OSS, memungkinkan kontrol yang lebih ketat untuk mengelola pembuatan, modifikasi, dan penghapusan cluster.
**Manfaat tingkat pertanyaan:** Pengelolaan ElastiCache sumber daya Amazon, seperti grup replikasi, node, dll. Dapat dibatasi ke AWS akun yang memiliki izin khusus berdasarkan kebijakan IAM, meningkatkan keamanan dan keandalan sumber daya.
+ **[Diperlukan]** Kelola akses ke ElastiCache sumber daya Amazon dengan menetapkan AWS Identity and Access Management kebijakan khusus kepada AWS pengguna, memungkinkan kontrol yang lebih baik atas akun mana yang dapat melakukan tindakan apa pada klaster.
**[Sumber Daya]: **
+ [Ikhtisar mengelola izin akses ke sumber daya Anda ElastiCache](IAM.Overview.md)
+ [Menggunakan kebijakan berbasis identitas (kebijakan IAM) untuk Amazon ElastiCache](IAM.IdentityBasedPolicies.md)
## SEC 7: Bagaimana Anda mendeteksi dan menanggapi peristiwa keamanan?
**Pengenalan tingkat pertanyaan:**ElastiCache, saat diterapkan dengan RBAC diaktifkan, mengekspor CloudWatch metrik untuk memberi tahu pengguna tentang peristiwa keamanan. Metrik ini membantu mengidentifikasi percobaan gagal untuk melakukan autentikasi, mengakses kunci, atau menjalankan perintah yang tidak diizinkan bagi pengguna RBAC yang melakukan koneksi.
Selain itu, sumber daya AWS produk dan layanan membantu mengamankan beban kerja Anda secara keseluruhan dengan mengotomatiskan penerapan dan mencatat semua tindakan dan modifikasi untuk peninjauan/audit nanti.
**Manfaat tingkat pertanyaan:** Dengan memantau peristiwa, Anda memungkinkan organisasi Anda untuk merespons sesuai dengan persyaratan, kebijakan, dan prosedur Anda. Mengotomatiskan pemantauan dan respons terhadap peristiwa keamanan ini memperkuat postur keamanan Anda secara keseluruhan.
+ **[Wajib]** Biasakan diri Anda dengan CloudWatch Metrik yang diterbitkan yang berkaitan dengan otentikasi RBAC dan kegagalan otorisasi.
+ AuthenticationFailures = Upaya gagal untuk mengautentikasi ke Valkey atau Redis OSS
+ KeyAuthorizationFailures = Upaya gagal oleh pengguna untuk mengakses kunci tanpa izin
+ CommandAuthorizationFailures = Upaya gagal oleh pengguna untuk menjalankan perintah tanpa izin
**[Sumber Daya]: **
+ [Metrik untuk Valkey atau Redis OSS](CacheMetrics.Redis.md)
+ **[Terbaik] **Sebaiknya siapkan peringatan dan notifikasi pada metrik ini dan respons sesuai kebutuhan.
**[Sumber Daya]: **
+ [Menggunakan CloudWatch alarm Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)
+ **[Terbaik]** Gunakan perintah Valkey atau Redis OSS ACL LOG untuk mengumpulkan rincian lebih lanjut
**[Sumber Daya]: **
+ [ACL LOG](https://valkey.io/commands/acl-log/)
+ **[Terbaik]** Biasakan diri Anda dengan kemampuan AWS produk dan layanan yang berkaitan dengan pemantauan, pencatatan, dan analisis ElastiCache penyebaran dan peristiwa
**[Sumber Daya]: **
+ [Mencatat panggilan ElastiCache API Amazon dengan AWS CloudTrail](logging-using-cloudtrail.md)
+ [elasticache-redis-cluster-automatic-backup-periksa](https://docs.aws.amazon.com/config/latest/developerguide/elasticache-redis-cluster-automatic-backup-check.html)
+ [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md)
# Pilar Keandalan Lensa ElastiCache Well-Architected Amazon
Pilar keandalan berfokus pada beban kerja yang menjalankan fungsi yang dimaksudkan dan bagaimana memulihkan dengan cepat dari kegagalan untuk memenuhi tuntutan. Topik utama meliputi desain sistem terdistribusi, perencanaan pemulihan, dan beradaptasi dengan perubahan persyaratan.
**Topics**
+ [REL 1: Bagaimana Anda mendukung deployment arsitektur ketersediaan tinggi (HA)?](#ReliabilityPillarREL1)
+ [REL 2: Bagaimana Anda memenuhi Tujuan Titik Pemulihan (RPOs) AndaElastiCache?](#ReliabilityPillarREL2)
+ [REL 3: Bagaimana Anda mendukung persyaratan pemulihan bencana (DR)?](#ReliabilityPillarREL3)
+ [REL 4: Bagaimana Anda merencanakan failover secara efektif?](#ReliabilityPillarREL4)
+ [REL 5: Apakah ElastiCache komponen Anda dirancang untuk skala?](#ReliabilityPillarREL5)
## REL 1: Bagaimana Anda mendukung deployment arsitektur ketersediaan tinggi (HA)?
**Pengenalan tingkat pertanyaan:** Memahami arsitektur ketersediaan tinggi Amazon ElastiCache akan memungkinkan Anda beroperasi dalam keadaan tangguh selama acara ketersediaan.
**Manfaat tingkat pertanyaan:** Merancang ElastiCache cluster Anda agar tahan terhadap kegagalan memastikan ketersediaan yang lebih tinggi untuk penerapan Anda. ElastiCache
+ **[Wajib]** Tentukan tingkat keandalan yang Anda butuhkan untuk ElastiCache klaster Anda. Beban kerja yang berbeda memiliki standar ketahanan yang berbeda, dari beban kerja yang sepenuhnya sementara hingga beban kerja krusial. Tentukan kebutuhan untuk setiap jenis lingkungan yang Anda operasikan seperti dev, test, dan production.
Mesin caching: ElastiCache untuk Memcached vs ElastiCache untuk Valkey dan Redis OSS
1. ElastiCache untuk Memcached tidak menyediakan mekanisme replikasi apa pun dan digunakan terutama untuk beban kerja sementara.
1. ElastiCache untuk Valkey dan Redis OSS menawarkan fitur HA dibahas di bawah ini
+ **[Terbaik]** Untuk beban kerja yang membutuhkan HA, gunakan ElastiCache dalam mode cluster dengan minimal dua replika per pecahan, bahkan untuk beban kerja persyaratan throughput kecil yang hanya membutuhkan satu pecahan.
1. Untuk mode klaster diaktifkan, Multi-AZ diaktifkan secara otomatis.
Multi-AZ meminimalkan waktu henti dengan melakukan failover otomatis dari simpul primer ke replika, jika terjadi pemeliharaan yang direncanakan atau tidak direncanakan serta mengurangi kegagalan AZ.
1. Untuk beban kerja sharded, minimal tiga pecahan memberikan pemulihan yang lebih cepat selama peristiwa failover karena Protokol Cluster Valkey atau Redis OSS memerlukan mayoritas node primer tersedia untuk mencapai kuorum.
1. Siapkan dua replika atau lebih di seluruh Zona Ketersediaan.
Memiliki dua replika memberikan peningkatan skalabilitas baca dan juga ketersediaan baca dalam skenario di mana satu replika sedang menjalani pemeliharaan.
1. Gunakan jenis simpul berbasis Graviton2 (simpul default di sebagian besar wilayah).
ElastiCache telah menambahkan kinerja yang dioptimalkan pada node ini. Hasilnya, Anda mendapatkan performa replikasi dan sinkronisasi yang lebih baik, sehingga meningkatkan ketersediaan secara keseluruhan.
1. Monitor dan ukuran yang tepat untuk menangani puncak lalu lintas yang diantisipasi: di bawah beban berat, mesin mungkin menjadi tidak responsif, yang memengaruhi ketersediaan. `BytesUsedForCache`dan `DatabaseMemoryUsagePercentage` merupakan indikator yang baik dari penggunaan memori Anda, sedangkan `ReplicationLag` merupakan indikator kesehatan replikasi Anda berdasarkan tingkat tulis Anda. Anda dapat menggunakan metrik ini untuk memicu penskalaan klaster.
1. Pastikan ketahanan sisi klien dengan melakukan pengujian dengan [API Failover sebelum peristiwa failover di lingkungan produksi](https://docs.amazonaws.cn/en_us/AmazonElastiCache/latest/APIReference/API_TestFailover.html).
**[Sumber Daya]: **
+ [Konfigurasikan ElastiCache untuk Redis OSS untuk ketersediaan yang lebih tinggi](https://aws.amazon.com/blogs/database/configuring-amazon-elasticache-for-redis-for-higher-availability/)
+ [Ketersediaan tinggi menggunakan grup replikasi](Replication.md)
## REL 2: Bagaimana Anda memenuhi Tujuan Titik Pemulihan (RPOs) AndaElastiCache?
**Pengenalan tingkat pertanyaan:** Memahami RPO beban kerja untuk menginformasikan keputusan tentang ElastiCache strategi pencadangan dan pemulihan.
**Manfaat tingkat pertanyaan: **Dengan menerapkan strategi RPO, Anda dapat meningkatkan kelangsungan bisnis jika terjadi skenario pemulihan bencana. Merancang kebijakan pencadangan dan pemulihan dapat membantu Anda memenuhi Tujuan Titik Pemulihan (RPO) untuk ElastiCache data Anda. ElastiCache menawarkan kemampuan snapshot yang disimpan di Amazon S3, bersama dengan kebijakan retensi yang dapat dikonfigurasi. Snapshot ini diambil selama periode pencadangan yang ditentukan dan ditangani oleh layanan secara otomatis. Jika beban kerja Anda memerlukan perincian pencadangan tambahan, Anda memiliki opsi untuk membuat hingga 20 pencadangan manual per hari. Pencadangan yang dibuat secara manual tidak memiliki kebijakan retensi layanan dan dapat disimpan tanpa batas waktu.
+ **[Wajib]** Memahami dan mendokumentasikan RPO ElastiCache penerapan Anda.
+ Perlu diketahui bahwa Memcached tidak menawarkan proses pencadangan apa pun.
+ Tinjau kemampuan fitur ElastiCache Backup dan Restore.
+ **[Terbaik] **Terapkan proses yang dikomunikasikan dengan baik untuk mencadangkan klaster Anda.
+ Mulai pencadangan manual sesuai kebutuhan.
+ Tinjau kebijakan retensi untuk pencadangan otomatis.
+ Perhatikan bahwa cadangan manual akan dipertahankan tanpa batas waktu.
+ Jadwalkan pencadangan otomatis Anda selama periode penggunaan rendah.
+ Lakukan operasi pencadangan terhadap replika baca untuk memastikan Anda meminimalkan dampak pada performa klaster.
+ **[Bagus]** Manfaatkan fitur pencadangan terjadwal ElastiCache untuk mencadangkan data Anda secara teratur selama jendela yang ditentukan.
+ Tes secara berkala pemulihan dari cadangan Anda.
+ **[Sumber Daya]: **
+ [Redis OSS](https://aws.amazon.com/elasticache/faqs/#Redis)
+ [Backup dan restore untuk ElastiCache](backups.md)
+ [Membuat pencadangan manual](backups-manual.md)
+ [Menjadwalkan pencadangan otomatis](backups-automatic.md)
+ [Cadangkan dan Kembalikan ElastiCache Cluster](https://aws.amazon.com/blogs/aws/backup-and-restore-elasticache-redis-nodes/)
## REL 3: Bagaimana Anda mendukung persyaratan pemulihan bencana (DR)?
**Pengenalan tingkat pertanyaan:** Pemulihan bencana adalah aspek penting dari setiap perencanaan beban kerja. ElastiCache menawarkan beberapa opsi untuk menerapkan pemulihan bencana berdasarkan persyaratan ketahanan beban kerja. Dengan Amazon ElastiCache Global Datastore, Anda dapat menulis ke klaster Anda di satu Wilayah dan memiliki data yang tersedia untuk dibaca dari dua klaster replika Lintas wilayah lainnya, sehingga memungkinkan pembacaan latensi rendah dan pemulihan bencana di seluruh wilayah.
**Manfaat tingkat pertanyaan:** Memahami dan merencanakan berbagai skenario bencana dapat memastikan kelangsungan bisnis. Strategi DR harus seimbang dengan biaya, dampak performa, dan potensi kehilangan data.
+ **[Wajib]** Kembangkan dan dokumentasikan strategi DR untuk semua ElastiCache komponen Anda berdasarkan persyaratan beban kerja. ElastiCache unik karena beberapa kasus penggunaan sepenuhnya fana dan tidak memerlukan strategi DR apa pun, sedangkan yang lain berada di ujung spektrum yang berlawanan dan memerlukan strategi DR yang sangat kuat. Semua opsi harus ditimbang dalam kaitannya dengan Optimalisasi Biaya - ketahanan yang lebih kuat membutuhkan jumlah infrastruktur yang lebih besar.
Memahami opsi DR yang tersedia di tingkat regional dan multi-wilayah.
+ Deployment Multi-AZ direkomendasikan untuk mencegah kegagalan AZ. Pastikan untuk menerapkan dengan Cluster-Mode diaktifkan dalam arsitektur Multi-AZ, dengan minimal 3 tersedia. AZs
+ Penyimpanan Data Global direkomendasikan untuk memberikan perlindungan terhadap kegagalan regional.
+ **[Terbaik] **Aktifkan Penyimpanan Data Global untuk beban kerja yang membutuhkan ketahanan tingkat wilayah.
+ Siapkan rencana untuk melakukan failover ke wilayah sekunder jika terjadi degradasi primer.
+ Uji proses failover multi-wilayah sebelum melakukan failover dalam lingkungan produksi.
+ Pantau metrik `ReplicationLag` untuk memahami potensi dampak kehilangan data selama peristiwa failover.
+ **[Sumber Daya]: **
+ [Memitigasi Kegagalan](disaster-recovery-resiliency.md#FaultTolerance)
+ [Replikasi lintas AWS Wilayah menggunakan datastores global](Redis-Global-Datastore.md)
+ [Memulihkan dari cadangan dengan opsi perubahan ukuran klaster](backups-restoring.md)
+ [Meminimalkan waktu henti ElastiCache untuk Valkey dan Redis OSS dengan Multi-AZ](AutoFailover.md)
## REL 4: Bagaimana Anda merencanakan failover secara efektif?
**Pengenalan tingkat pertanyaan:** Mengaktifkan Multi-AZ dengan failover otomatis adalah praktik terbaik. ElastiCache Dalam kasus tertentu, ElastiCache untuk Valkey dan Redis OSS menggantikan node primer sebagai bagian dari operasi layanan. Contohnya termasuk peristiwa pemeliharaan yang direncanakan dan kasus yang tidak diharapkan seperti kegagalan simpul atau masalah zona ketersediaan. Failover yang berhasil bergantung pada keduanya ElastiCache dan konfigurasi pustaka klien Anda.
**Manfaat tingkat pertanyaan:** Mengikuti praktik terbaik untuk ElastiCache kegagalan bersama dengan pustaka ElastiCache klien spesifik Anda membantu Anda meminimalkan potensi waktu henti selama peristiwa failover.
+ **[Wajib] **Untuk mode klaster dinonaktifkan, gunakan waktu tunggu sehingga klien dapat mendeteksi jika perlu memutuskan koneksi dari simpul primer lama dan terhubung kembali ke simpul primer baru, menggunakan alamat IP titik akhir primer yang diperbarui. Untuk mode klaster diaktifkan, pustaka klien bertanggung jawab untuk mendeteksi perubahan dalam topologi klaster yang mendasarinya. Ini paling sering dilakukan dengan pengaturan konfigurasi di pustaka ElastiCache klien, yang juga memungkinkan Anda untuk mengkonfigurasi frekuensi dan metode penyegaran. Setiap pustaka klien menawarkan pengaturannya sendiri dan detail lebih lanjut tersedia dalam dokumentasi yang sesuai.
**[Sumber Daya]: **
+ [Meminimalkan waktu henti ElastiCache untuk Valkey dan Redis OSS dengan Multi-AZ](AutoFailover.md)
+ Tinjau praktik terbaik perpustakaan ElastiCache klien Anda.
+ **[Wajib]** Failover yang berhasil bergantung pada lingkungan replikasi yang berkondisi baik antara simpul primer dan replika. Tinjau dan pahami sifat asinkron replikasi Valkey dan Redis OSS, serta CloudWatch metrik yang tersedia untuk melaporkan jeda replikasi antara node primer dan replika. Untuk kasus penggunaan yang membutuhkan keamanan data yang lebih besar, manfaatkan perintah WAIT untuk memaksa replika mengakui penulisan sebelum menanggapi klien yang terhubung.
**[Sumber Daya]: **
+ [Metrik untuk Valkey atau Redis OSS](CacheMetrics.Redis.md)
+ [Memantau praktik terbaik dengan ElastiCache menggunakan Amazon CloudWatch](https://aws.amazon.com/blogs/database/monitoring-best-practices-with-amazon-elasticache-for-redis-using-amazon-cloudwatch/)
+ **[Terbaik]** Secara teratur memvalidasi respons aplikasi Anda selama failover menggunakan ElastiCache Test Failover API.
**[Sumber Daya]: **
+ [Menguji Failover Otomatis ke Read Replica ElastiCache](https://aws.amazon.com/blogs/database/testing-automatic-failover-to-a-read-replica-on-amazon-elasticache-for-redis/)
+ [Menguji failover otomatis](AutoFailover.md#auto-failover-test)
## REL 5: Apakah ElastiCache komponen Anda dirancang untuk skala?
**Pengenalan tingkat pertanyaan:** Dengan memahami kemampuan penskalaan dan topologi penerapan yang tersedia, ElastiCache komponen Anda dapat menyesuaikan dari waktu ke waktu untuk memenuhi persyaratan beban kerja yang berubah. ElastiCachemenawarkan penskalaan 4 arah: in/out (horizontal) serta up/down (vertikal).
**Manfaat tingkat pertanyaan:** Mengikuti praktik terbaik untuk ElastiCache penerapan memberikan fleksibilitas penskalaan terbesar, serta memenuhi prinsip penskalaan yang dirancang dengan baik secara horizontal untuk meminimalkan dampak kegagalan.
+ **[Wajib] **Memahami perbedaan antara topologi Mode Klaster Diaktifkan dan Mode Klaster Dinonaktifkan. Dalam hampir semua kasus, sebaiknya lakukan deployment dengan mode Klaster diaktifkan karena memungkinkan skalabilitas yang lebih besar dari waktu ke waktu. Komponen mode klaster dinonaktifkan memiliki kemampuan terbatas untuk menskalakan secara horizontal dengan menambahkan replika baca.
+ **[Wajib] **Memahami kapan dan bagaimana melakukan penskalaan.
+ Untuk meningkatkan READIOPS: tambahkan replika
+ Untuk meningkatkan WRITEOPS: tambahkan serpihan (menskalakan ke luar)
+ Untuk meningkatkan IO jaringan - gunakan instans yang dioptimalkan jaringan (menaikkan skala)
+ **[Terbaik]** Terapkan ElastiCache komponen Anda dengan mode Cluster diaktifkan, dengan bias terhadap lebih banyak node yang lebih kecil daripada lebih sedikit, node yang lebih besar. Opsi ini secara efektif membatasi radius ledakan kegagalan simpul.
+ **[Terbaik] **Sertakan replika di klaster Anda untuk meningkatkan respons selama peristiwa penskalaan
+ **[Bagus]** Untuk mode cluster dinonaktifkan, manfaatkan replika baca untuk meningkatkan kapasitas baca secara keseluruhan. ElastiCache memiliki dukungan hingga 5 replika baca dalam mode cluster dinonaktifkan, serta penskalaan vertikal.
+ **[Sumber Daya]: **
+ [Cluster penskalaan ElastiCache ](Scaling.md)
+ [Menaikkan skala secara online](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-scaling-up)
# Pilar ElastiCache Efisiensi Kinerja Lensa Well-Architected Amazon
Pilar efisiensi performa berfokus pada penggunaan sumber daya TI dan komputasi secara efisien. Topik utamanya meliputi pemilihan jenis dan ukuran sumber daya yang tepat berdasarkan persyaratan beban kerja, pemantauan performa, dan pembuatan keputusan berdasarkan informasi untuk mempertahankan efisiensi seiring dengan berkembangnya kebutuhan bisnis.
**Topics**
+ [PE 1: Bagaimana Anda memantau kinerja ElastiCache cluster Amazon Anda?](#PerformanceEfficiencyPillarPE1)
+ [PE 2: Bagaimana Anda mendistribusikan pekerjaan di seluruh node ElastiCache Cluster Anda?](#PerformanceEfficiencyPillarPE2)
+ [PE 3: Untuk beban kerja caching, bagaimana cara melacak dan melaporkan efektivitas dan performa cache Anda?](#PerformanceEfficiencyPillarPE3)
+ [PE 4: Bagaimana beban kerja Anda mengoptimalkan penggunaan sumber daya dan koneksi jaringan?](#PerformanceEfficiencyPillarPE4)
+ [PE 5: Bagaimana Anda mengelola penggusuran penghapusan and/or kunci?](#PerformanceEfficiencyPillarPE5)
+ [PE 6: Bagaimana Anda memodelkan dan berinteraksi dengan data ElastiCache?](#PerformanceEfficiencyPillarPE6)
+ [PE 7: Bagaimana Anda mencatat perintah yang berjalan lambat di ElastiCache cluster Amazon Anda?](#PerformanceEfficiencyPillarPE7)
+ [PE8: Bagaimana Auto Scaling membantu dalam meningkatkan kinerja cluster? ElastiCache](#PerformanceEfficiencyPillarPE8)
## PE 1: Bagaimana Anda memantau kinerja ElastiCache cluster Amazon Anda?
**Pengantar tingkat pertanyaan: **Dengan memahami metrik pemantauan yang ada, Anda dapat mengidentifikasi pemanfaatan saat ini. Pemantauan yang tepat dapat membantu mengidentifikasi potensi hambatan yang memengaruhi performa klaster Anda.
**Manfaat tingkat pertanyaan: **Memahami metrik yang terkait dengan klaster Anda dapat membantu memandu teknik pengoptimalan yang dapat mengurangi latensi dan meningkatkan throughput.
+ **[Wajib] **Pengujian performa dasar menggunakan subset beban kerja Anda.
+ Anda harus memantau performa beban kerja aktual menggunakan mekanisme seperti pengujian beban.
+ Pantau CloudWatch metrik saat menjalankan tes ini untuk mendapatkan pemahaman tentang metrik yang tersedia, dan untuk menetapkan garis dasar kinerja.
+ **[Terbaik]** ElastiCache Untuk beban kerja Valkey dan Redis OSS, ganti nama perintah yang mahal secara komputasi, seperti`KEYS`, untuk membatasi kemampuan pengguna menjalankan perintah pemblokiran pada cluster produksi.
+ ElastiCache beban kerja yang menjalankan engine 6.x untuk Redis OSS dapat memanfaatkan kontrol akses berbasis peran untuk membatasi perintah tertentu. Akses ke perintah dapat dikontrol dengan membuat Pengguna dan Grup Pengguna dengan AWS Konsol atau CLI, dan mengaitkan Grup Pengguna ke klaster. Di Redis OSS 6, ketika RBAC diaktifkan, kita dapat menggunakan “- @dangerous" dan itu akan melarang perintah mahal seperti KEYS, MONITOR, SORT, dll. untuk pengguna itu.
+ Untuk engine versi 5.x, ganti nama perintah menggunakan `rename-commands` parameter pada grup parameter cluster.
+ **[Lebih Baik] **Analisis kueri lambat dan cari teknik pengoptimalan.
+ ElastiCache Untuk beban kerja Valkey dan Redis OSS, pelajari lebih lanjut tentang kueri Anda dengan menganalisis Log Lambat. Misalnya, Anda dapat menggunakan perintah berikut, `valkey-cli slowlog get 10` untuk menampilkan 10 perintah terakhir yang melebihi ambang batas latensi (10 milidetik secara default).
+ Kueri tertentu dapat dilakukan lebih efisien menggunakan kompleks ElastiCache untuk struktur data Valkey dan Redis OSS. Sebagai contoh, untuk pencarian rentang gaya numerik, aplikasi dapat mengimplementasikan indeks numerik sederhana dengan Sorted Set. Mengelola indeks ini dapat mengurangi pemindaian yang dilakukan pada set data, dan menampilkan data dengan efisiensi performa yang lebih baik.
+ ElastiCache Untuk beban kerja Valkey dan Redis OSS, `redis-benchmark` menyediakan antarmuka sederhana untuk menguji kinerja perintah yang berbeda menggunakan input yang ditentukan pengguna seperti jumlah klien, dan ukuran data.
+ Karena Memcached hanya mendukung perintah tingkat kunci sederhana, pertimbangkan untuk membangun kunci tambahan sebagai indeks untuk menghindari iterasi melalui ruang kunci untuk melayani kueri klien.
+ **[Sumber Daya]: **
+ [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md)
+ [Menggunakan CloudWatch alarm Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)
+ [Parameter spesifik Valkey dan Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis)
+ [SLOWLOG](https://valkey.io/commands/slowlog/)
+ [tolok ukur](https://valkey.io/topics/benchmark/)
## PE 2: Bagaimana Anda mendistribusikan pekerjaan di seluruh node ElastiCache Cluster Anda?
**Pengenalan tingkat pertanyaan:** Cara aplikasi Anda terhubung ke ElastiCache node Amazon dapat memengaruhi kinerja dan skalabilitas klaster.
**Manfaat tingkat pertanyaan:** Memanfaatkan simpul yang tersedia di klaster dengan tepat akan memastikan bahwa pekerjaan didistribusikan ke seluruh sumber daya yang tersedia. Teknik-teknik berikut juga membantu menghindari sumber daya idle.
+ **[Wajib]** Minta klien terhubung ke ElastiCache titik akhir yang tepat.
+ ElastiCache untuk Valkey dan Redis OSS mengimplementasikan titik akhir yang berbeda berdasarkan mode cluster yang digunakan. Untuk mode cluster diaktifkan, ElastiCache akan menyediakan titik akhir konfigurasi. Untuk mode cluster dinonaktifkan, ElastiCache menyediakan titik akhir utama, biasanya digunakan untuk menulis, dan titik akhir pembaca untuk menyeimbangkan pembacaan di seluruh replika. Menerapkan titik akhir ini dengan tepat akan menghasilkan performa yang lebih baik, dan operasi penskalaan yang lebih mudah. Hindari menghubungkan ke titik akhir simpul individual kecuali jika ada persyaratan khusus untuk melakukan tindakan ini.
+ Untuk cluster Memcached multi-node, ElastiCache menyediakan titik akhir konfigurasi yang memungkinkan Auto Discovery. Sebaiknya gunakan algoritma hashing untuk mendistribusikan pekerjaan secara merata di seluruh simpul cache. Banyak pustaka klien Memcached menerapkan hashing yang konsisten. Periksa dokumentasi untuk pustaka yang Anda gunakan untuk melihat apakah pustaka tersebut mendukung hashing konsisten dan cara menerapkannya. Anda dapat menemukan informasi selengkapnya tentang penerapan fitur-fitur ini [di sini](BestPractices.LoadBalancing.md).
+ **[Lebih baik]** Manfaatkan ElastiCache untuk cluster yang mengaktifkan mode cluster Valkey dan Redis OSS untuk meningkatkan skalabilitas.
+ ElastiCache untuk cluster Valkey dan Redis OSS (mode cluster enabled) mendukung [operasi penskalaan online (out/in and up/down) untuk membantu mendistribusikan](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online) data secara dinamis di seluruh pecahan. Menggunakan Titik Akhir Konfigurasi akan memastikan klaster Anda yang sadar klien dapat menyesuaikan perubahan dalam topologi klaster.
+ Anda juga dapat menyeimbangkan kembali cluster dengan memindahkan hashslots antara pecahan yang tersedia di cluster ElastiCache for Valkey dan Redis OSS (mode cluster enabled) Anda. Tindakan ini membantu mendistribusikan pekerjaan secara lebih efisien di seluruh serpihan yang tersedia.
+ **[Lebih Baik] **Terapkan strategi untuk mengidentifikasi dan memulihkan hot key dalam beban kerja Anda.
+ Pertimbangkan dampak struktur data Valkey atau Redis OSS multi-dimensi seperti daftar, aliran, set, dll. Struktur data ini disimpan dalam Keys tunggal, yang berada pada satu node. Kunci multi-dimensi yang sangat besar memiliki potensi untuk memanfaatkan lebih banyak kapasitas jaringan dan memori daripada jenis data lainnya dan dapat menyebabkan penggunaan simpul yang tidak proporsional. Jika memungkinkan, rancang beban kerja Anda untuk menyebarkan akses data di banyak Kunci diskrit.
+ Hot key dalam beban kerja dapat memengaruhi performa simpul yang digunakan. ElastiCache Untuk beban kerja Valkey dan Redis OSS, Anda dapat mendeteksi tombol pintas menggunakan `valkey-cli --hotkeys` jika kebijakan memori maksimum LFU diberlakukan.
+ Pertimbangkan untuk mereplikasi hot key di beberapa simpul untuk mendistribusikan akses ke sana secara lebih merata. Pendekatan ini mengharuskan klien untuk menulis ke beberapa node primer (node Valkey atau Redis OSS itu sendiri tidak akan menyediakan fungsi ini) dan untuk mempertahankan daftar nama kunci untuk dibaca, selain nama kunci asli.
+ ElastiCache [engine 7.2 untuk Valkey dan di atasnya, dan ElastiCache versi 6 untuk Redis OSS dan yang lebih tinggi, semuanya mendukung caching sisi klien yang dibantu server.](https://valkey.io/topics/client-side-caching/) Hal ini memungkinkan aplikasi untuk menunggu perubahan pada kunci sebelum membuat panggilan jaringan kembali keElastiCache.
+ **[Sumber Daya]: **
+ [Konfigurasikan ElastiCache untuk Valkey dan Redis OSS untuk ketersediaan yang lebih tinggi](https://aws.amazon.com/blogs/database/configuring-amazon-elasticache-for-redis-for-higher-availability/)
+ [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md)
+ [Praktik terbaik penyeimbangan beban](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/BestPractices.LoadBalancing.html)
+ [Resharding online untuk Valkey atau Redis OSS (mode cluster diaktifkan)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online)
+ [Caching sisi klien di Valkey dan Redis OSS](https://valkey.io/topics/client-side-caching/)
## PE 3: Untuk beban kerja caching, bagaimana cara melacak dan melaporkan efektivitas dan performa cache Anda?
**Pengenalan tingkat pertanyaan:** Caching adalah beban kerja yang umum ditemui ElastiCache dan penting bagi Anda untuk memahami cara mengelola efektivitas dan kinerja cache Anda.
**Manfaat tingkat pertanyaan: **Aplikasi Anda mungkin menunjukkan tanda-tanda performa yang lamban. Kemampuan Anda untuk menggunakan metrik khusus cache untuk menginformasikan keputusan Anda tentang cara meningkatkan performa aplikasi sangat penting untuk beban kerja cache Anda.
+ **[Wajib] **Ukur dan lacak dari waktu ke waktu rasio hit cache. Efisiensi cache Anda ditentukan oleh 'rasio cache hit'. Rasio cache hit ditentukan oleh total hit kunci dibagi dengan total hit dan miss. Semakin dekat ke 1 rasionya, semakin efektif cache Anda. Rasio cache hit yang rendah disebabkan oleh volume cache miss. Cache miss terjadi ketika kunci yang diminta tidak ditemukan di cache. Kunci tidak ada dalam cache karena telah dikosongkan atau dihapus, telah habis masa berlakunya, atau tidak pernah ada. Pahami mengapa kunci tidak ada dalam cache dan kembangkan strategi yang tepat untuk menyimpan kunci dalam cache.
**[Sumber Daya]: **
+ [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md)
+ **[Wajib]** Ukur dan kumpulkan kinerja cache aplikasi Anda bersama dengan nilai latensi dan pemanfaatan CPU untuk memahami apakah Anda perlu melakukan penyesuaian pada komponen aplikasi Anda time-to-live atau lainnya. ElastiCache menyediakan satu set CloudWatch metrik untuk latensi agregat untuk setiap struktur data. Metrik latensi ini dihitung menggunakan statistik commandstats dari perintah INFO dan tidak menyertakan jaringan dan waktu I/O. Ini hanya waktu yang dihabiskan ElastiCache untuk memproses operasi.
**[Sumber Daya]: **
+ [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md)
+ [Memantau praktik terbaik dengan ElastiCache menggunakan Amazon CloudWatch](https://aws.amazon.com/blogs/database/monitoring-best-practices-with-amazon-elasticache-for-redis-using-amazon-cloudwatch/)
+ **[Terbaik] **Pilih strategi caching yang tepat untuk kebutuhan Anda. Rasio cache hit yang rendah disebabkan oleh volume cache miss. Jika beban kerja Anda dirancang untuk memiliki volume cache miss yang rendah (seperti komunikasi waktu nyata), sebaiknya tinjau strategi caching Anda dan terapkan solusi yang paling tepat untuk beban kerja Anda, seperti instrumentasi kueri untuk mengukur memori dan performa. Strategi aktual yang Anda gunakan untuk mengisi dan memelihara cache Anda akan tergantung pada data apa yang perlu di-cache oleh klien dan pola akses ke data tersebut. Misalnya, Anda cenderung tidak akan menggunakan strategi yang sama untuk rekomendasi yang dipersonalisasi pada aplikasi streaming, dan untuk berita yang sedang tren.
**[Sumber Daya]: **
+ [Strategi cache untuk Memcached](Strategies.md)
+ [Praktik Terbaik Caching](https://aws.amazon.com/caching/best-practices/)
+ [Kinerja dalam Skala dengan ElastiCache Whitepaper Amazon](https://d0.awsstatic.com/whitepapers/performance-at-scale-with-amazon-elasticache.pdf)
## PE 4: Bagaimana beban kerja Anda mengoptimalkan penggunaan sumber daya dan koneksi jaringan?
**Pengenalan tingkat pertanyaan:** ElastiCache untuk Valkey, Memcached, dan Redis OSS didukung oleh banyak klien aplikasi, dan implementasi dapat bervariasi. Anda perlu memahami manajemen jaringan dan koneksi yang diterapkan untuk menganalisis potensi dampak performa.
**Manfaat tingkat pertanyaan: **Penggunaan sumber daya jaringan yang efisien dapat meningkatkan efisiensi performa klaster Anda. Rekomendasi berikut dapat mengurangi tuntutan jaringan, dan meningkatkan latensi dan throughput klaster.
+ **[Wajib]** Secara proaktif mengelola koneksi ke ElastiCache klaster Anda.
+ Pooling koneksi dalam aplikasi mengurangi jumlah overhead pada klaster yang dibuat dengan membuka dan menutup koneksi. Pantau perilaku koneksi di Amazon CloudWatch menggunakan `CurrConnections` dan`NewConnections`.
+ Hindari kebocoran koneksi dengan menutup koneksi klien dengan benar sesuai keperluan. Strategi manajemen koneksi termasuk menutup dengan benar koneksi yang tidak digunakan, dan pengaturan waktu habis koneksi.
+ Untuk beban kerja Memcached, ada jumlah memori yang dapat dikonfigurasi yang dicadangkan untuk menangani koneksi yang disebut, `memcached_connections_overhead`.
+ **[Lebih Baik] **Kompres objek besar untuk mengurangi memori, dan meningkatkan throughput jaringan.
+ Kompresi data dapat mengurangi jumlah throughput jaringan yang diperlukan (Gbps), tetapi meningkatkan jumlah pekerjaan pada aplikasi untuk mengompres dan mendekompresi data.
+ Kompresi juga mengurangi jumlah memori yang dikonsumsi oleh kunci
+ Berdasarkan kebutuhan aplikasi Anda, pertimbangkan kompromi antara rasio kompresi dan kecepatan kompresi.
+ **[Sumber Daya]: **
+ [ElastiCache - Datastore Global](https://aws.amazon.com/elasticache/redis/global-datastore/)
+ [Parameter spesifik Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached)
+ [ElastiCache versi 5.0.3 untuk Redis OSS meningkatkan penanganan untuk meningkatkan kinerja I/O ](https://aws.amazon.com/about-aws/whats-new/2019/03/amazon-elasticache-for-redis-503-enhances-io-handling-to-boost-performance/)
+ [Metrik untuk Valkey dan Redis OSS](CacheMetrics.Redis.md)
+ [Konfigurasikan ElastiCache untuk ketersediaan yang lebih tinggi](https://aws.amazon.com/blogs/database/configuring-amazon-elasticache-for-redis-for-higher-availability/)
## PE 5: Bagaimana Anda mengelola penggusuran penghapusan and/or kunci?
**Pengenalan tingkat pertanyaan:** Beban kerja memiliki persyaratan yang berbeda, dan perilaku yang diharapkan saat node cluster mendekati batas konsumsi memori. ElastiCache memiliki kebijakan yang berbeda untuk menangani situasi ini.
**Manfaat tingkat pertanyaan:** Manajemen yang tepat atas memori yang tersedia, dan pemahaman tentang kebijakan pengosongan akan membantu memastikan kesadaran perilaku klaster ketika batas memori instans terlampaui.
+ **[Wajib] **Instrumentasi akses data untuk mengevaluasi kebijakan mana yang akan diterapkan. Identifikasi kebijakan max-memory yang sesuai untuk mengontrol apakah dan bagaimana pengosongan dilakukan di klaster.
+ Pengosongan terjadi ketika max-memory pada klaster dikonsumsi dan kebijakan diberlakukan untuk memungkinkan pengosongan. Perilaku klaster dalam situasi ini tergantung pada kebijakan pengosongan yang ditentukan. Kebijakan ini dapat dikelola menggunakan grup parameter `maxmemory-policy` pada klaster.
+ Kebijakan default `volatile-lru` mengosongkan memori dengan mengosongkan kunci dengan waktu kedaluwarsa yang ditetapkan (nilai TTL). Kebijakan least frequently used (LFU) dan least recently used (LRU) menghapus kunci berdasarkan penggunaan.
+ Untuk beban kerja Memcached, ada kebijakan LRU default yang mengendalikan pengosongan di setiap simpul. Jumlah penggusuran di ElastiCache klaster Amazon Anda dapat dipantau menggunakan metrik Penggusuran di Amazon. CloudWatch
+ **[Lebih Baik] **Lakukan standarisasi perilaku penghapusan untuk mengontrol dampak performa pada klaster Anda untuk menghindari kemacetan performa yang tidak terduga.
+ ElastiCache Untuk beban kerja Valkey dan Redis OSS, ketika secara eksplisit menghapus kunci dari cluster, seperti`DEL`: menghapus kunci yang `UNLINK` ditentukan. Namun, perintah ini mengklaim kembali memori yang sebenarnya di thread yang berbeda, sehingga tidak memblokir, sedangkan `DEL` memblokir. Penghapusan yang sebenarnya akan terjadi nanti secara asinkron.
+ Untuk ElastiCache versi 6.x untuk beban kerja Redis OSS, perilaku `DEL` perintah dapat dimodifikasi dalam grup parameter menggunakan parameter. `lazyfree-lazy-user-del`
+ **[Sumber Daya]: **
+ [Mengkonfigurasi parameter mesin menggunakan grup ElastiCache parameter](ParameterGroups.md)
+ [UNLINK](https://valkey.io/commands/unlink/)
+ [Manajemen Keuangan Cloud dengan AWS](https://aws.amazon.com/aws-cost-management/)
## PE 6: Bagaimana Anda memodelkan dan berinteraksi dengan data ElastiCache?
**Pengenalan tingkat pertanyaan:** ElastiCache sangat bergantung pada struktur data dan model data yang digunakan, tetapi juga perlu mempertimbangkan penyimpanan data yang mendasarinya (jika ada). Pahami struktur data yang tersedia dan pastikan Anda menggunakan struktur data yang paling tepat untuk kebutuhan Anda.
**Manfaat tingkat pertanyaan:** Pemodelan data ElastiCache memiliki beberapa lapisan, termasuk kasus penggunaan aplikasi, tipe data, dan hubungan antar elemen data. Selain itu, setiap tipe data dan perintah memiliki tanda tangan kinerja mereka sendiri yang terdokumentasi dengan baik.
+ **[Terbaik] **Praktik terbaiknya adalah mengurangi penimpaan data yang tidak disengaja. Gunakan konvensi penamaan yang meminimalkan tumpang-tindih nama kunci. Penamaan struktur data secara konvensional menggunakan metode hierarkis seperti: `APPNAME:CONTEXT:ID`, misalnya `ORDER-APP:CUSTOMER:123`.
**[Sumber Daya]: **
+ [Key naming](https://docs.gitlab.com/ee/development/redis.html#key-naming)
+ **[Terbaik]** ElastiCache untuk perintah Valkey dan Redis OSS memiliki kompleksitas waktu yang ditentukan oleh notasi Big O. Kompleksitas perintah kali ini merupakan algorithmic/mathematical representasi dari dampaknya. Saat memperkenalkan jenis data baru dalam aplikasi, Anda perlu meninjau kompleksitas waktu perintah terkait dengan cermat. Perintah dengan kompleksitas waktu O(1) bersifat konstan dalam waktu dan tidak bergantung pada ukuran input, namun perintah dengan kompleksitas waktu O(N) bersifat linier dalam waktu dan menyesuaikan ukuran input. Karena desain ulir tunggal ElastiCache untuk Valkey dan Redis OSS, volume besar operasi kompleksitas waktu tinggi akan menghasilkan kinerja yang lebih rendah dan potensi batas waktu operasi.
**[Sumber Daya]: **
+ [Commands](https://valkey.io/commands/)
+ **[Terbaik]** Gunakan APIs untuk mendapatkan visibilitas GUI ke dalam model data di cluster Anda.
**[Sumber Daya]: **
+ [Komandan Redis OSS](https://www.npmjs.com/package/ElastiCache for Redis-commander)
+ [Browser Redis OSS](https://github.com/humante/redis-browser)
+ [Redsmin](https://www.redsmin.com/)
## PE 7: Bagaimana Anda mencatat perintah yang berjalan lambat di ElastiCache cluster Amazon Anda?
**Pengantar tingkat pertanyaan: **Manfaat penyesuaian performa melalui pengambilan, agregasi, dan notifikasi perintah yang berjalan lama. Dengan memahami berapa lama waktu yang dibutuhkan untuk menjalankan perintah, Anda dapat menentukan perintah mana yang menghasilkan kinerja yang buruk serta perintah yang menghalangi mesin agar tidak berkinerja optimal. ElastiCache juga memiliki kemampuan untuk meneruskan informasi ini ke Amazon CloudWatch atau Amazon Kinesis Data Firehose.
**Manfaat tingkat pertanyaan: **Pencatatan log ke lokasi permanen khusus dan penyediaan peristiwa notifikasi untuk perintah lambat dapat membantu analisis performa terperinci dan dapat digunakan untuk memicu peristiwa otomatis.
+ **[Diperlukan]** ElastiCache menjalankan mesin Valkey 7.2 atau yang lebih baru, atau menjalankan mesin Redis OSS versi 6.0 atau yang lebih baru, grup parameter yang dikonfigurasi dengan benar dan logging SLOWLOG diaktifkan di cluster.
+ Parameter yang diperlukan hanya tersedia ketika kompatibilitas versi mesin diatur ke Valkey 7.2 dan lebih tinggi, atau Redis OSS versi 6.0 atau lebih tinggi.
+ Pencatatan log SLOWLOG terjadi ketika waktu eksekusi server terhadap suatu perintah membutuhkan waktu lebih lama dari nilai yang ditentukan. Perilaku klaster tergantung pada parameter Grup Parameter terkait yaitu `slowlog-log-slower-than` dan `slowlog-max-len`.
+ Perubahan akan diterapkan segera.
+ **[Terbaik]** Manfaatkan CloudWatch atau kemampuan Kinesis Data Firehose.
+ Gunakan kemampuan pemfilteran dan alarm, Wawasan CloudWatch Log CloudWatch, dan Layanan Pemberitahuan Sederhana Amazon untuk mencapai pemantauan kinerja dan pemberitahuan peristiwa.
+ Gunakan kemampuan streaming Kinesis Data Firehose untuk mengarsipkan log SLOWLOG ke penyimpanan permanen atau untuk memicu penyesuaian parameter klaster otomatis.
+ Tentukan apakah JSON atau format TEXT biasa yang paling sesuai dengan kebutuhan Anda.
+ Berikan izin IAM untuk mempublikasikan ke CloudWatch atau Kinesis Data Firehose.
+ **[Lebih Baik] **Konfigurasikan `slowlog-log-slower-than` ke nilai selain default.
+ Parameter ini menentukan berapa lama perintah dapat dijalankan untuk dalam mesin Valkey atau Redis OSS sebelum dicatat sebagai perintah berjalan lambat. Nilai default-nya adalah 10.000 mikrodetik (10 milidetik). Nilai default mungkin terlalu tinggi untuk beberapa beban kerja.
+ Tentukan nilai yang lebih sesuai untuk beban kerja Anda berdasarkan kebutuhan aplikasi dan hasil pengujian; namun, nilai yang terlalu rendah dapat menghasilkan data yang berlebihan.
+ **[Lebih Baik] **Biarkan `slowlog-max-len` pada nilai default.
+ Parameter ini menentukan batas atas berapa banyak perintah yang berjalan lambat ditangkap dalam memori Valkey atau Redis OSS pada waktu tertentu. Nilai 0 secara efektif menonaktifkan penangkapan. Semakin tinggi nilainya, semakin banyak entri yang akan disimpan dalam memori, sehingga mengurangi kemungkinan informasi penting dikosongkan sebelum dapat ditinjau. Nilai default-nya adalah 128.
+ Nilai default tersebut sesuai untuk sebagian besar beban kerja. Jika ada kebutuhan untuk menganalisis data dalam jendela waktu yang diperluas dari valkey-cli melalui perintah SLOWLOG, pertimbangkan untuk meningkatkan nilai ini. Ini memungkinkan lebih banyak perintah untuk tetap berada di memori Valkey atau Redis OSS.
Jika Anda memancarkan data SLOWLOG ke Log atau Kinesis Data Firehose, data akan bertahan dan dapat dianalisis di luar sistem, mengurangi kebutuhan untuk menyimpan sejumlah besar perintah yang berjalan lambat di memori Valkey atau Redis OSS. CloudWatch ElastiCache
+ **[Sumber Daya]: **
+ [Bagaimana cara mengaktifkan log lambat di cluster?](https://repost.aws/knowledge-center/elasticache-turn-on-slow-log)
+ [Pengiriman log](Log_Delivery.md)
+ [Parameter khusus Redis OS](ParameterGroups.Engine.md#ParameterGroups.Redis)
+ [https://aws.amazon.com/cloudwatch/](https://aws.amazon.com/cloudwatch/)Amazon CloudWatch
+ [Amazon Kinesis Data Firehose](https://aws.amazon.com/kinesis/data-firehose/)
## PE8: Bagaimana Auto Scaling membantu dalam meningkatkan kinerja cluster? ElastiCache
**Pengenalan tingkat pertanyaan:** Dengan menerapkan fitur penskalaan otomatis Valkey atau Redis OSS, ElastiCache komponen Anda dapat menyesuaikan dari waktu ke waktu untuk menambah atau mengurangi pecahan atau replika yang diinginkan secara otomatis. Ini dapat dilakukan dengan menerapkan kebijakan pelacakan target atau penskalaan terjadwal.
**Manfaat tingkat pertanyaan:** Memahami dan merencanakan lonjakan beban kerja dapat memastikan peningkatan kinerja caching dan kelangsungan bisnis. ElastiCache Auto Scaling terus memantau pemanfaatan CPU/memori Anda untuk memastikan klaster Anda beroperasi pada tingkat kinerja yang Anda inginkan.
+ **[Diperlukan]** Saat meluncurkan cluster ElastiCache untuk Valkey atau Redis OSS:
1. Pastikan mode Klaster diaktifkan
1. Pastikan instans berasal dari keluarga jenis dan ukuran tertentu yang mendukung Auto Scaling
1. Pastikan klaster tidak berjalan di Penyimpanan Data Global, Outposts, atau Zona Lokal
**[Sumber Daya]: **
+ [Penskalaan cluster di Valkey dan Redis OSS (Mode Cluster Diaktifkan)](scaling-redis-cluster-mode-enabled.md)
+ [Menggunakan Auto Scaling dengan serpihan](AutoScaling-Using-Shards.md)
+ [Menggunakan Auto Scaling dengan replika](AutoScaling-Using-Replicas.md)
+ **[Terbaik] **Identifikasi apakah beban kerja Anda menjalankan operasi baca atau tulis yang berat untuk menentukan kebijakan penskalaan. Untuk performa terbaik, gunakan hanya satu metrik pelacakan. Sebaiknya hindari beberapa kebijakan untuk setiap dimensi, karena kebijakan Auto Scaling akan menskalakan keluar saat target tercapai, namun menskalakan masuk hanya jika semua kebijakan pelacakan target siap untuk diskalakan.
**[Sumber Daya]: **
+ [Kebijakan Auto Scaling](AutoScaling-Policies.md)
+ [Menetapkan kebijakan penskalaan](AutoScaling-Scaling-Defining-Policy-API.md)
+ **[Terbaik] **Memantau performa dari waktu ke waktu dapat membantu Anda mendeteksi perubahan beban kerja yang tidak akan terdeteksi jika dipantau pada titik waktu tertentu. Anda dapat menganalisis CloudWatch metrik yang sesuai untuk pemanfaatan klaster selama periode empat minggu untuk menentukan ambang nilai target. Jika Anda masih tidak yakin nilai apa yang harus dipilih, sebaiknya mulai dengan nilai metrik standar minimum yang didukung.
**[Sumber Daya]: **
+ [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md)
+ **[Lebih baik]** Kami menyarankan untuk menguji aplikasi Anda dengan beban kerja minimum dan maksimum yang diharapkan, untuk mengidentifikasi jumlah pasti yang shards/replicas diperlukan kluster untuk mengembangkan kebijakan penskalaan dan mengurangi masalah ketersediaan.
**[Sumber Daya]: **
+ [Mendaftarkan Target yang Dapat Diskalakan](AutoScaling-Register-Policy.md)
+ [Mendaftarkan Target yang Dapat Diskalakan menggunakan AWS CLI](AutoScaling-Scaling-Registering-Policy-CLI.md)
# Pilar ElastiCache Pengoptimalan Biaya Lensa Well-Architected Amazon
Pilar optimisasi biaya berfokus untuk menghindari biaya yang tidak perlu. Topik utamanya termasuk memahami dan mengendalikan ke mana biaya dihabiskan, memilih jenis simpul yang paling tepat (menggunakan instans yang mendukung tingkatan data berdasarkan kebutuhan beban kerja), jumlah jenis sumber daya yang tepat (berapa banyak replika baca), menganalisis pengeluaran dari waktu ke waktu, dan penskalaan untuk memenuhi kebutuhan bisnis tanpa pengeluaran berlebihan.
**Topics**
+ [BIAYA 1: Bagaimana Anda mengidentifikasi dan melacak biaya yang terkait dengan ElastiCache sumber daya Anda? Bagaimana Anda mengembangkan mekanisme untuk memungkinkan pengguna membuat, mengelola, dan menghapus sumber daya yang dibuat?](#CostOptimizationPillarCOST1)
+ [BIAYA 2: Bagaimana Anda menggunakan alat pemantauan berkelanjutan untuk membantu Anda mengoptimalkan biaya yang terkait dengan ElastiCache sumber daya Anda?](#CostOptimizationPillarCOST2)
+ [BIAYA 3: Haruskah Anda menggunakan jenis instans yang mendukung tingkatan data? Apa keuntungan dari tingkatan data? Kapan sebaiknya tidak menggunakan instans tingkatan data?](#CostOptimizationPillarCOST3)
## BIAYA 1: Bagaimana Anda mengidentifikasi dan melacak biaya yang terkait dengan ElastiCache sumber daya Anda? Bagaimana Anda mengembangkan mekanisme untuk memungkinkan pengguna membuat, mengelola, dan menghapus sumber daya yang dibuat?
**Pengantar tingkat pertanyaan: **Untuk memahami metrik biaya, diperlukan partisipasi dan kolaborasi berbagai tim: rekayasa perangkat lunak, manajemen data, pemilik produk, keuangan, dan pimpinan. Untuk mengidentifikasi pendorong biaya utama, semua pihak yang terlibat harus memahami pemicu penggunaan layanan dan kompromi manajemen biaya. Hal ini juga sering kali menjadi perbedaan utama antara upaya optimisasi biaya yang berhasil dan kurang berhasil. Memastikan Anda memiliki proses dan alat untuk melacak sumber daya yang dibuat dari pengembangan hingga produksi dan pensiun membantu Anda mengelola biaya yang terkait dengannyaElastiCache.
**Manfaat tingkat pertanyaan:** Pelacakan terus menerus dari semua biaya yang terkait dengan beban kerja Anda membutuhkan pemahaman mendalam tentang arsitektur yang termasuk ElastiCache sebagai salah satu komponennya. Selain itu, Anda harus memiliki rencana manajemen biaya untuk mengumpulkan dan membandingkan data penggunaan dengan anggaran Anda.
+ **[Diperlukan]** Lengkapi Cloud Center of Excellence (CCoE) dengan salah satu piagam pendirinya untuk menentukan, melacak, dan mengambil tindakan pada metrik seputar penggunaan organisasi Anda. ElastiCache Jika CCo E ada dan berfungsi, pastikan ia tahu cara membaca dan melacak biaya yang terkait dengannya ElastiCache. Saat sumber daya dibuat, gunakan peran dan kebijakan IAM untuk memvalidasi bahwa hanya tim dan grup tertentu yang dapat melakukan instansiasi sumber daya. Hal ini memastikan bahwa biaya yang terkait dengan hasil bisnis dan garis akuntabilitas yang jelas ditetapkan, dari perspektif biaya.
1. CCoE harus mengidentifikasi, mendefinisikan, dan mempublikasikan metrik biaya yang diperbarui secara reguler -bulanan seputar ElastiCache penggunaan utama di seluruh data kategoris seperti:
1. Jenis simpul yang digunakan dan atributnya: standar vs. memori dioptimalkan, instans sesuai permintaan vs. terpesan, wilayah, dan zona ketersediaan
1. Jenis lingkungan: gratis, developer, pengujian, dan produksi
1. Strategi penyimpanan dan retensi cadangan
1. Transfer data dalam dan lintas wilayah
1. Instans yang berjalan di Amazon Outposts
1. CCoE terdiri dari tim lintas fungsi dengan representasi non-eksklusif dari rekayasa perangkat lunak, manajemen data, tim produk, keuangan, dan tim kepemimpinan di organisasi Anda.
**[Sumber Daya]: **
+ [Buat Pusat Keunggulan Cloud](https://docs.aws.amazon.com/whitepapers/latest/cost-optimization-laying-the-foundation/cloud-center-of-excellence.html)
+ [ ElastiCacheHarga Amazon](https://aws.amazon.com/elasticache/pricing/)
+ **[Wajib] **Gunakan tag alokasi biaya untuk memantau biaya pada tingkat granularitas yang rendah. Gunakan Manajemen AWS Biaya untuk memvisualisasikan, memahami, dan mengelola AWS biaya dan penggunaan Anda dari waktu ke waktu.
1. Gunakan tag untuk mengatur sumber daya Anda, dan tag alokasi biaya untuk melacak AWS biaya Anda pada tingkat terperinci. Setelah Anda mengaktifkan tag alokasi biaya, AWS gunakan tag alokasi biaya untuk mengatur biaya sumber daya Anda pada laporan alokasi biaya Anda, untuk memudahkan Anda mengkategorikan dan melacak biaya Anda. AWS AWS menyediakan dua jenis tag alokasi biaya, tag yang AWS dihasilkan dan tag yang ditentukan pengguna. AWS mendefinisikan, membuat, dan menerapkan tag yang AWS dihasilkan untuk Anda, dan Anda menentukan, membuat, dan menerapkan tag yang ditentukan pengguna. Anda harus mengaktifkan kedua jenis tag ini secara terpisah sebelum tag tersebut dapat muncul di Manajemen Biaya atau laporan alokasi biaya.
1. Gunakan tag alokasi biaya untuk mengatur AWS tagihan Anda untuk mencerminkan struktur biaya Anda sendiri. Ketika Anda menambahkan tag alokasi biaya ke sumber daya Anda di Amazon ElastiCache, Anda akan dapat melacak biaya dengan mengelompokkan pengeluaran pada faktur Anda berdasarkan nilai tag sumber daya. Anda sebaiknya mengombinasikan beberapa tag untuk melacak biaya secara lebih mendetail.
**[Sumber Daya]: **
+ [Menggunakan AWS tag alokasi biaya](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)
+ [Memantau biaya dengan tag alokasi biaya](Tagging.md)
+ [AWS Cost Explorer](https://aws.amazon.com/aws-cost-management/aws-cost-explorer/)
+ **[Terbaik]** Connect ElastiCache biaya ke metrik yang menjangkau seluruh organisasi.
1. Pertimbangkan metrik bisnis serta metrik operasional seperti latensi - konsep apa dalam model bisnis Anda yang dapat dimengerti di seluruh peran? Metrik harus dapat dipahami oleh sebanyak mungkin peran dalam organisasi.
1. Contoh - pengguna yang dilayani secara simultan, latensi maks dan rata-rata per operasi dan pengguna, skor keterlibatan pengguna, pengembalian pengguna, tingkat pengabaianrates/week, session length/user, tingkat hit cache, dan kunci yang dilacak
**[Sumber Daya]: **
+ [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md)
+ **[Baik]** Pertahankan visibilitas up-to-date arsitektur dan operasional pada metrik dan biaya di seluruh beban kerja yang digunakan. ElastiCache
1. Pahami seluruh ekosistem solusi Anda, ElastiCache cenderung menjadi bagian dari ekosistem AWS layanan lengkap dalam rangkaian teknologinya, dari klien hingga API Gateway, Redshift, dan QuickSight untuk alat pelaporan (misalnya).
1. Petakan komponen solusi Anda dari klien, koneksi, keamanan, operasi dalam memori, penyimpanan, otomatisasi sumber daya, akses, dan manajemen data, di diagram arsitektur Anda. Setiap lapisan terhubung ke seluruh solusi dan memiliki kebutuhan dan kemampuan sendiri yang menambah untuk and/or membantu Anda mengelola biaya keseluruhan.
1. Diagram Anda harus mencakup penggunaan komputasi, jaringan, penyimpanan, kebijakan siklus hidup, pengumpulan metrik serta elemen operasional dan fungsional ElastiCache aplikasi Anda
1. Persyaratan beban kerja Anda cenderung berubah dari waktu ke waktu dan penting bagi Anda untuk terus memelihara dan mendokumentasikan pemahaman Anda tentang komponen yang mendasarinya serta tujuan fungsional utama Anda agar tetap proaktif dalam manajemen biaya beban kerja Anda.
1. Dukungan eksekutif untuk visibilitas, akuntabilitas, prioritas, dan sumber daya sangat penting bagi Anda untuk memiliki strategi manajemen biaya yang efektif untuk Anda. ElastiCache
## BIAYA 2: Bagaimana Anda menggunakan alat pemantauan berkelanjutan untuk membantu Anda mengoptimalkan biaya yang terkait dengan ElastiCache sumber daya Anda?
**Pengenalan tingkat pertanyaan:** Anda perlu membidik keseimbangan yang tepat antara metrik ElastiCache biaya dan kinerja aplikasi Anda. Amazon CloudWatch menyediakan visibilitas ke metrik operasional utama yang dapat membantu Anda menilai apakah ElastiCache sumber daya Anda terlalu banyak atau kurang digunakan, relatif terhadap kebutuhan Anda. Dari perspektif pengoptimalan biaya, Anda perlu memahami kapan Anda dilebih-lebihkan dan dapat mengembangkan mekanisme yang tepat untuk mengubah ukuran ElastiCache sumber daya Anda sambil mempertahankan kebutuhan operasional, ketersediaan, ketahanan, dan kinerja Anda.
**Manfaat tingkat pertanyaan: **Dalam keadaan yang ideal, Anda akan menyediakan sumber daya yang cukup untuk memenuhi kebutuhan operasional beban kerja Anda dan tidak memiliki sumber daya yang kurang dimanfaatkan yang dapat mengakibatkan situasi biaya yang kurang optimal. Anda harus dapat mengidentifikasi dan menghindari pengoperasian ElastiCache sumber daya yang terlalu besar untuk jangka waktu yang lama.
+ **[Wajib]** Gunakan CloudWatch untuk memantau ElastiCache klaster Anda dan menganalisis bagaimana metrik ini berhubungan dengan dasbor AWS Cost Explorer Anda.
1. ElastiCache menyediakan metrik tingkat host (misalnya, penggunaan CPU) dan metrik yang khusus untuk perangkat lunak mesin cache (misalnya, cache mendapat dan kehilangan cache). Metrik ini diukur dan dipublikasikan untuk setiap simpul cache dalam interval 60 detik.
1. ElastiCache metrik kinerja (CPUUtilization,, EngineUtilization, SwapUsage CurrConnections, dan Penggusuran) dapat menunjukkan bahwa Anda perlu menskalakan up/down (menggunakan jenis node larger/smaller cache) atau in/out (add more/less pecahan). Pahami implikasi biaya dari keputusan penskalaan dengan membuat matriks buku pedoman yang memperkirakan biaya tambahan dan lama waktu min dan maks yang diperlukan untuk mencapai ambang batas performa aplikasi Anda.
**[Sumber Daya]: **
+ [Pemantauan penggunaan dengan CloudWatch Metrik](CacheMetrics.md)
+ [Metrik Apa yang Harus Saya Pantau?](CacheMetrics.WhichShouldIMonitor.md)
+ [ ElastiCacheHarga Amazon](https://aws.amazon.com/elasticache/pricing/)
+ **[Wajib] **Pahami dan dokumentasikan strategi pencadangan dan implikasi biaya Anda.
1. Dengan ElastiCache, cadangan disimpan di Amazon S3, yang menyediakan penyimpanan tahan lama. Anda perlu memahami implikasi biaya dalam kaitannya dengan kemampuan Anda untuk pulih dari kegagalan.
1. Aktifkan pencadangan otomatis yang akan menghapus file cadangan yang melewati batas retensi.
**[Sumber Daya]: **
+ [Menjadwalkan pencadangan otomatis](backups-automatic.md)
+ [Harga Amazon Simple Storage Service](https://aws.amazon.com/s3/pricing/)
+ **[Terbaik] **Gunakan Simpul Terpesan untuk instans Anda sebagai strategi yang disengaja untuk mengelola biaya beban kerja yang dipahami dan didokumentasikan dengan baik. Simpul terpesan dikenai biaya di muka dan bergantung pada jenis simpul dan durasi pemesanan—satu atau tiga tahun. Biaya ini jauh lebih kecil daripada biaya penggunaan per jam yang dikenakan untuk simpul sesuai permintaan.
1. Anda mungkin perlu mengoperasikan ElastiCache klaster Anda menggunakan node sesuai permintaan sampai Anda mengumpulkan data yang cukup untuk memperkirakan persyaratan instance yang dicadangkan. Rencanakan dan dokumentasikan sumber daya yang diperlukan untuk memenuhi kebutuhan Anda dan membandingkan biaya yang diharapkan di seluruh jenis instans (sesuai permintaan vs. terpesan)
1. Evaluasi secara rutin jenis simpul cache baru yang tersedia dan nilai apakah masuk akal, dari perspektif metrik biaya dan operasional, untuk memigrasikan armada instans Anda ke jenis simpul cache baru
## BIAYA 3: Haruskah Anda menggunakan jenis instans yang mendukung tingkatan data? Apa keuntungan dari tingkatan data? Kapan sebaiknya tidak menggunakan instans tingkatan data?
**Pengantar tingkat pertanyaan: **Memilih jenis instans yang sesuai tidak hanya dapat memiliki dampak performa dan tingkat layanan, tetapi juga dampak finansial. Jenis instans memiliki biaya berbeda yang terkait dengannya. Memilih satu atau beberapa jenis instans besar yang dapat mengakomodasi semua kebutuhan penyimpanan dalam memori mungkin merupakan keputusan yang wajar. Namun, hal ini dapat memiliki dampak biaya yang signifikan seiring proyek berkembang. Memastikan bahwa jenis instance yang benar dipilih memerlukan pemeriksaan periodik waktu idle ElastiCache objek.
**Manfaat tingkat pertanyaan: **Anda harus memiliki pemahaman yang jelas tentang bagaimana berbagai jenis instans memengaruhi biaya Anda saat ini dan di masa depan. Perubahan beban kerja marginal atau berkala seharusnya tidak menyebabkan perubahan biaya yang tidak proporsional. Jika beban kerja mengizinkannya, jenis instans yang mendukung tingkatan data menawarkan harga yang lebih baik per penyimpanan yang tersedia. Karena penyimpanan SSD yang tersedia per instans, instans tingkatan data mendukung kemampuan total data per instans yang jauh lebih tinggi.
+ **[Wajib] **Pahami batasan instans tingkatan data
1. Hanya tersedia ElastiCache untuk klaster Valkey atau Redis OSS.
1. Hanya jenis instans tertentu yang mendukung tingkatan data.
1. Hanya ElastiCache versi 6.2 untuk Redis OSS dan di atasnya yang didukung
1. Item besar tidak ditukar ke SSD. Objek di atas 128 MiB dipertahankan dalam memori.
**[Sumber Daya]: **
+ [Tingkatan data](data-tiering.md)
+ [ ElastiCacheHarga Amazon](https://aws.amazon.com/elasticache/pricing/)
+ **[Wajib] **Pahami berapa persentase basis data Anda yang secara teratur diakses oleh beban kerja Anda.
1. Instans tingkatan data ideal untuk beban kerja yang sering mengakses sebagian kecil dari keseluruhan set data Anda, tetapi masih memerlukan akses cepat ke data yang tersisa. Dengan kata lain, rasio data panas ke hangat adalah sekitar 20:80.
1. Kembangkan pelacakan tingkat klaster terhadap waktu idle objek.
1. Implementasi besar lebih dari 500 Gb data merupakan kandidat yang baik
+ **[Wajib] **Pahami bahwa instans tingkatan data tidak bersifat opsional untuk beban kerja tertentu.
1. Ada biaya performa kecil untuk mengakses objek yang jarang digunakan karena objek ini ditukar ke SSD lokal. Jika aplikasi Anda sensitif terhadap waktu respons, uji dampaknya terhadap beban kerja Anda.
1. Tidak cocok untuk cache yang menyimpan sebagian besar objek berukuran lebih dari 128 MiB.
**[Sumber Daya]: **
+ [Batasan](data-tiering.md#data-tiering-prerequisites)
+ **[Terbaik] **Jenis instans terpesan mendukung tingkatan data. Hal ini menjamin biaya terendah dalam hal jumlah penyimpanan data per instans.
1. Anda mungkin perlu mengoperasikan ElastiCache cluster Anda menggunakan instance tiering non-data sampai Anda memiliki pemahaman yang lebih baik tentang kebutuhan Anda.
1. Analisis pola penggunaan data ElastiCache cluster Anda.
1. Buat pekerjaan otomatis yang secara berkala mengumpulkan waktu idle objek.
1. Jika Anda melihat bahwa persentase besar (sekitar 80%) objek berada dalam kondisi idle untuk jangka waktu yang dianggap sesuai untuk beban kerja Anda, dokumentasikan temuan tersebut dan sarankan untuk memigrasikan klaster ke instans yang mendukung tingkatan data.
1. Evaluasi secara rutin jenis simpul cache baru yang tersedia dan nilai apakah masuk akal, dari perspektif metrik biaya dan operasional, untuk memigrasikan armada instans Anda ke jenis simpul cache baru.
**[Sumber Daya]: **
+ [OBJECT IDLETIME](https://valkey.io/commands/object-idletime/)
+ [ ElastiCacheHarga Amazon](https://aws.amazon.com/elasticache/pricing/)
# Langkah-langkah pemecahan masalah umum dan praktik terbaik dengan ElastiCache
Topik berikut memberikan saran pemecahan masalah untuk kesalahan dan masalah yang mungkin Anda temui saat menggunakan. ElastiCache Jika Anda menemukan masalah yang tidak tercantum di sini, Anda dapat menggunakan tombol umpan balik di halaman ini untuk melaporkannya.
[Untuk saran pemecahan masalah lainnya dan jawaban atas pertanyaan dukungan umum, kunjungi Pusat Pengetahuan AWS](https://aws.amazon.com/premiumsupport/knowledge-center/)
**Topics**
+ [Masalah koneksi](#wwe-troubleshooting.connection)
+ [Kesalahan klien Valkey atau Redis OSS](#wwe-troubleshooting.clienterrors)
+ [Memecahkan masalah latensi tinggi di Tanpa Server ElastiCache](#wwe-troubleshooting.latency)
+ [Memecahkan masalah pembatasan di Tanpa Server ElastiCache](#wwe-troubleshooting.throttling)
+ [Masalah koneksi persisten](TroubleshootingConnections.md)
+ [Topik Terkait](#wwe-troubleshooting.related)
## Masalah koneksi
Jika Anda tidak dapat terhubung ke ElastiCache cache Anda, pertimbangkan salah satu dari berikut ini:
1. **Menggunakan TLS:** Jika Anda mengalami koneksi macet saat mencoba terhubung ke ElastiCache titik akhir Anda, Anda mungkin tidak menggunakan TLS di klien Anda. Jika Anda menggunakan ElastiCache Tanpa Server, enkripsi dalam perjalanan selalu diaktifkan. Pastikan klien Anda menggunakan TLS untuk terhubung ke cache. [Pelajari lebih lanjut tentang menghubungkan ke cache yang diaktifkan TLS](connect-tls.md).
1. **VPC:** ElastiCache cache hanya dapat diakses dari dalam VPC. Pastikan bahwa EC2 instance dari mana Anda mengakses cache dan ElastiCache cache dibuat dalam VPC yang sama. Atau, Anda harus mengaktifkan [peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) antara VPC tempat instance Anda EC2 berada dan VPC tempat Anda membuat cache.
1. **Grup keamanan:** ElastiCache menggunakan grup keamanan untuk mengontrol akses ke cache Anda. Pertimbangkan hal berikut:
1. Pastikan bahwa grup keamanan yang digunakan oleh ElastiCache cache Anda memungkinkan akses masuk ke sana dari EC2 instance Anda. Lihat [di sini](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) untuk mempelajari cara mengatur aturan masuk di grup keamanan Anda dengan benar.
1. Pastikan bahwa grup keamanan yang digunakan oleh ElastiCache cache Anda memungkinkan akses ke port cache Anda (6379 dan 6380 untuk tanpa server, dan 6379 secara default untuk cluster berbasis node). ElastiCache menggunakan port ini untuk menerima perintah Valkey atau Redis OSS. Pelajari lebih lanjut tentang cara mengatur akses port [di sini](set-up.md#elasticache-install-grant-access-VPN).
Jika koneksi terus sulit, lihat [Masalah koneksi persisten](TroubleshootingConnections.md) langkah-langkah lain.
## Kesalahan klien Valkey atau Redis OSS
ElastiCache Tanpa server hanya dapat diakses menggunakan klien yang mendukung protokol mode cluster Valkey atau Redis OSS. Cluster berbasis node dapat diakses dari klien dalam mode mana pun, tergantung pada konfigurasi cluster.
Jika Anda mengalami kesalahan pada klien Anda, pertimbangkan hal berikut:
1. **Mode cluster:** Jika Anda mengalami kesalahan atau kesalahan CROSSLOT dengan perintah [SELECT](https://valkey.io/commands/select/), Anda mungkin mencoba mengakses cache Cluster Mode Enabled dengan klien Valkey atau Redis OSS yang tidak mendukung protokol Cluster. ElastiCache Tanpa server hanya mendukung klien yang mendukung protokol cluster Valkey atau Redis OSS. Jika Anda ingin menggunakan Valkey atau Redis OSS di “Cluster Mode Disabled” (CMD), maka Anda harus membuat cluster berbasis node.
1. **Kesalahan CROSSLOT:** Jika Anda mengalami `ERR CROSSLOT Keys in request don't hash to the same slot` kesalahan, Anda mungkin mencoba mengakses kunci yang tidak termasuk dalam slot yang sama dalam cache mode Cluster. Sebagai pengingat, ElastiCache Serverless selalu beroperasi dalam Mode Cluster. Operasi multi-kunci, transaksi, atau skrip Lua yang melibatkan beberapa kunci hanya diperbolehkan jika semua kunci yang terlibat berada dalam slot hash yang sama.
[Untuk praktik terbaik tambahan seputar mengonfigurasi klien Valkey atau Redis OSS, silakan tinjau posting blog ini.](https://aws.amazon.com/blogs/database/best-practices-redis-clients-and-amazon-elasticache-for-redis/)
## Memecahkan masalah latensi tinggi di Tanpa Server ElastiCache
Jika beban kerja Anda tampaknya mengalami latensi tinggi, Anda dapat menganalisis CloudWatch `SuccessfulReadRequestLatency` dan `SuccessfulWriteRequestLatency` metrik untuk memeriksa apakah latensi terkait dengan Tanpa Server. ElastiCache Metrik ini mengukur latensi yang bersifat internal untuk ElastiCache Tanpa Server - latensi sisi klien dan waktu perjalanan jaringan antara klien Anda dan titik akhir Tanpa ElastiCache Server tidak disertakan.
**Memecahkan masalah latensi sisi klien**
Jika Anda melihat peningkatan latensi di sisi klien tetapi tidak ada peningkatan `` CloudWatch `SuccessfulReadRequestLatency` dan `SuccessfulWriteRequestLatency` metrik yang sesuai yang mengukur latensi sisi server, pertimbangkan hal berikut:
+ **Pastikan grup keamanan memungkinkan akses ke port 6379 dan 6380:** ElastiCache Tanpa server menggunakan port 6379 untuk titik akhir primer dan port 6380 untuk titik akhir pembaca. Beberapa klien membuat konektivitas ke kedua port untuk setiap koneksi baru, bahkan jika aplikasi Anda tidak menggunakan fitur Baca dari Replika. Jika grup keamanan Anda tidak mengizinkan akses masuk ke kedua port, maka pembentukan koneksi dapat memakan waktu lebih lama. Pelajari lebih lanjut tentang cara mengatur akses port [di sini](set-up.md#elasticache-install-grant-access-VPN).
**Memecahkan masalah latensi sisi server**
Beberapa variabilitas dan lonjakan sesekali seharusnya tidak menjadi perhatian. Namun, jika `Average` statistik menunjukkan peningkatan tajam dan berlanjut, Anda harus memeriksa Dasbor Health dan Dashboard Personal Health Anda untuk informasi lebih lanjut. Jika perlu, pertimbangkan untuk membuka kasus dukungan dengan Dukungan.
Pertimbangkan praktik dan strategi terbaik berikut untuk mengurangi latensi:
+ **Aktifkan Baca dari Replika:** Jika aplikasi Anda mengizinkannya, sebaiknya aktifkan fitur “Baca dari Replika” di klien Valkey atau Redis OSS Anda untuk menskalakan pembacaan dan mencapai latensi yang lebih rendah. Saat diaktifkan, ElastiCache Serverless mencoba merutekan permintaan baca Anda ke replika node cache yang berada di Availability Zone (AZ) yang sama dengan klien Anda, sehingga menghindari latensi jaringan lintas-AZ. Perhatikan, bahwa mengaktifkan fitur Baca dari Replika di klien Anda menandakan bahwa aplikasi Anda akhirnya menerima konsistensi data. Aplikasi Anda mungkin menerima data lama untuk beberapa waktu jika Anda mencoba membaca setelah menulis ke kunci.
+ **Pastikan aplikasi Anda di-deploy AZs sama dengan cache Anda: Anda** dapat mengamati latensi sisi klien yang lebih tinggi jika aplikasi Anda tidak di-deploy AZs sama dengan cache Anda. Saat Anda membuat cache tanpa server, Anda dapat menyediakan subnet dari mana aplikasi Anda akan mengakses cache, dan ElastiCache Tanpa Server membuat VPC Endpoint di subnet tersebut. Pastikan aplikasi Anda di-deploy dalam hal yang sama AZs. Jika tidak, aplikasi Anda mungkin mengalami lompatan lintas-AZ saat mengakses cache yang menghasilkan latensi sisi klien yang lebih tinggi.
+ **Gunakan kembali koneksi:** Permintaan ElastiCache tanpa server dibuat melalui koneksi TCP yang diaktifkan TLS menggunakan protokol RESP. Memulai koneksi (termasuk mengautentikasi koneksi, jika dikonfigurasi) membutuhkan waktu sehingga latensi permintaan pertama lebih tinggi dari biasanya. Permintaan melalui koneksi yang sudah diinisialisasi memberikan ElastiCache latensi rendah yang konsisten. Untuk alasan ini, Anda harus mempertimbangkan untuk menggunakan penyatuan koneksi atau menggunakan kembali koneksi Valkey atau Redis OSS yang ada.
+ **Kecepatan penskalaan:** ElastiCache Tanpa server secara otomatis menskalakan seiring dengan bertambahnya tingkat permintaan Anda. Peningkatan besar secara tiba-tiba dalam tingkat permintaan, lebih cepat daripada kecepatan skala ElastiCache Tanpa Server, dapat mengakibatkan peningkatan latensi untuk beberapa waktu. ElastiCache Tanpa server biasanya dapat meningkatkan tingkat permintaan yang didukung dengan cepat, membutuhkan waktu hingga 10-12 menit untuk menggandakan tingkat permintaan.
+ **Periksa perintah yang berjalan lama: Beberapa perintah** Valkey atau Redis OSS, termasuk skrip Lua atau perintah pada struktur data besar, dapat berjalan untuk waktu yang lama. Untuk mengidentifikasi perintah ini, ElastiCache menerbitkan metrik tingkat perintah. Dengan [ElastiCache Tanpa Server](serverless-metrics-events-redis.md#serverless-metrics) Anda dapat menggunakan metrik. `BasedECPUs`
+ **Permintaan Terbatas:** Saat permintaan dibatasi di ElastiCache Tanpa Server, Anda mungkin mengalami peningkatan latensi sisi klien dalam aplikasi Anda. [Saat permintaan dibatasi di ElastiCache Tanpa Server, Anda akan melihat peningkatan metrik Tanpa Server. `ThrottledRequests` ElastiCache ](serverless-metrics-events-redis.md#serverless-metrics) Tinjau bagian di bawah ini untuk memecahkan masalah permintaan yang dibatasi.
+ **Distribusi kunci dan permintaan yang seragam:** ElastiCache Untuk Valkey dan Redis OSS, distribusi kunci atau permintaan per slot yang tidak merata dapat menghasilkan slot panas yang dapat menghasilkan latensi tinggi. ElastiCache Tanpa server mendukung hingga 30.000 ECPUs/second (90.000 ECPUs/second saat menggunakan Read from Replica) pada satu slot, dalam beban kerja yang menjalankan perintah sederhana. SET/GET Sebaiknya evaluasi distribusi kunci dan permintaan Anda di seluruh slot dan memastikan distribusi yang seragam jika tingkat permintaan Anda melebihi batas ini.
## Memecahkan masalah pembatasan di Tanpa Server ElastiCache
Dalam arsitektur berorientasi layanan dan sistem terdistribusi, membatasi kecepatan pemrosesan panggilan API oleh berbagai komponen layanan disebut throttling. Ini menghaluskan lonjakan, mengontrol ketidakcocokan dalam throughput komponen, dan memungkinkan pemulihan yang lebih dapat diprediksi ketika ada peristiwa operasional yang tidak terduga. ElastiCache Tanpa server dirancang untuk jenis arsitektur ini, dan sebagian besar klien Valkey atau Redis OSS memiliki percobaan ulang bawaan untuk permintaan yang dibatasi. Throttling pada tingkat tertentu belum tentu menjadi masalah bagi aplikasi Anda, tetapi throttling yang terus-menerus pada bagian alur kerja data Anda yang sensitif terhadap latensi dapat berdampak negatif terhadap pengalaman pengguna dan mengurangi efisiensi sistem secara keseluruhan.
[Saat permintaan dibatasi di ElastiCache Tanpa Server, Anda akan melihat peningkatan metrik Tanpa Server. `ThrottledRequests` ElastiCache ](serverless-metrics-events-redis.md#serverless-metrics) Jika Anda melihat sejumlah besar permintaan terbatas, pertimbangkan hal berikut:
+ **Kecepatan penskalaan:** ElastiCache Tanpa server secara otomatis menskalakan saat Anda menelan lebih banyak data atau meningkatkan tingkat permintaan Anda. Jika aplikasi Anda menskalakan lebih cepat daripada kecepatan skala Tanpa Server, permintaan Anda mungkin terhambat saat ElastiCache Tanpa Server menskalakan untuk mengakomodasi beban kerja Anda. ElastiCache ElastiCache Tanpa server biasanya dapat meningkatkan ukuran penyimpanan dengan cepat, membutuhkan waktu hingga 10-12 menit untuk menggandakan ukuran penyimpanan di cache Anda.
+ **Distribusi kunci dan permintaan yang seragam:** ElastiCache Untuk Valkey dan Redis OSS, distribusi kunci atau permintaan per slot yang tidak merata dapat menghasilkan slot panas. Slot panas dapat mengakibatkan pembatasan permintaan, jika tingkat permintaan ke satu slot melebihi 30.000 ECPUs/second dan berada dalam beban kerja yang mengeksekusi perintah sederhana. SET/GET Demikian pula, dengan ElastiCache untuk Memcached, tombol pintas dapat mengakibatkan pembatasan permintaan jika tingkat permintaan melebihi 30.000 /detik. ECPUs
+ **Baca dari Replika:** Jika aplikasi Anda mengizinkannya, pertimbangkan untuk menggunakan fitur “Baca dari Replika”. Sebagian besar klien Valkey atau Redis OSS dapat dikonfigurasi ke” pembacaan skala “untuk mengarahkan pembacaan ke node replika. Fitur ini memungkinkan Anda untuk menskalakan lalu lintas baca. Selain itu ElastiCache Tanpa Server secara otomatis merutekan pembacaan dari permintaan replika ke node di Availability Zone yang sama dengan aplikasi Anda sehingga latensi lebih rendah. Ketika Read from Replica diaktifkan, Anda dapat mencapai hingga 90.000 ECPUs/second pada satu slot, untuk beban kerja dengan perintah sederhana. SET/GET
# Masalah koneksi persisten
Item berikut harus diverifikasi saat memecahkan masalah konektivitas persisten dengan: ElastiCache
**Topics**
+ [Grup keamanan](#Security_groups)
+ [Jaringan ACLs](#Network_ACLs)
+ [Tabel rute](#Route_tables)
+ [Resolusi DNS](#DNS_Resolution)
+ [Mengidentifikasi masalah dengan diagnostik sisi server](#Diagnostics)
+ [Validasi konektivitas jaringan](#Connectivity)
+ [Batas terkait jaringan](#Network-limits)
+ [Penggunaan CPU](#CPU-Usage)
+ [Koneksi yang dihentikan dari sisi server](#Connections-server)
+ [Pemecahan masalah sisi klien untuk instans Amazon EC2](#Connections-client)
+ [Membedah waktu yang dibutuhkan untuk menyelesaikan satu permintaan tunggal](#Dissecting-time)
## Grup keamanan
Grup Keamanan adalah firewall virtual yang melindungi ElastiCache klien Anda (EC2 misalnya, AWS Lambda fungsi, wadah Amazon ECS, dll.) dan ElastiCache cache. Grup keamanan bersifat stateful, artinya bahwa setelah lalu lintas masuk atau keluar diizinkan, maka tanggapan untuk lalu lintas itu akan secara otomatis mendapatkan otorisasi dalam konteks grup keamanan tertentu itu.
Fitur stateful mensyaratkan grup keamanan melacak semua koneksi yang diberikan otorisasi, dan terdapat batasan untuk koneksi dilacak. Jika batas itu tercapai, maka koneksi baru akan gagal. Silakan merujuk ke bagian pemecahan masalah untuk bantuan tentang cara mengidentifikasi apakah batas telah tercapai pada klien atau ElastiCache sisi.
Anda dapat memiliki satu grup keamanan yang ditetapkan secara bersamaan ke klien dan ElastiCache klaster, atau grup keamanan individual untuk masing-masing grup.
Untuk kedua kasus, Anda perlu mengizinkan lalu lintas keluar TCP di ElastiCache port dari sumber dan lalu lintas masuk pada port yang sama. ElastiCache Port default adalah 11211 untuk Memcached, dan 6379 untuk Valkey atau Redis OSS. Secara default, grup keamanan mengizinkan semua lalu lintas ke luar. Dalam kasus ini, hanya aturan masuk di target grup keamanan yang diperlukan.
Untuk informasi selengkapnya, lihat [Pola akses untuk mengakses ElastiCache klaster di VPC Amazon](elasticache-vpc-accessing.md).
## Jaringan ACLs
Network Access Control Lists (ACLs) adalah aturan stateless. Lalu lintas harus diizinkan di kedua arah (masuk dan keluar) agar koneksi berhasil. Jaringan ACLs ditugaskan ke subnet, bukan sumber daya khusus. Dimungkinkan untuk memiliki ACL yang sama yang ditugaskan ke ElastiCache dan sumber daya klien, terutama jika mereka berada di subnet yang sama.
Secara default, jaringan ACLs memungkinkan semua lintasan. Namun, dimungkinkan untuk menyesuaikan ACL agar menolak atau mengizinkan lalu lintas. Selain itu, evaluasi aturan ACL adalah berurutan, yang berarti bahwa aturan dengan nomor terendah yang cocok dengan lalu lintas yang akan mengizinkan atau menolak lalu lintas itu. Konfigurasi minimum untuk memungkinkan lalu lintas Valkey atau Redis OSS adalah:
ACL Jaringan sisi klien:
+ **Aturan Masuk:**
+ Nomor aturan: sebaiknya lebih rendah dari semua aturan menolak;
+ Jenis: Aturan TCP Kustom;
+ Protokol: TCP
+ Rentang Port: 1024-65535
+ Sumber: 0.0.0.0/0 (atau buat aturan individual untuk subnet cluster) ElastiCache
+ Izinkan/Tolak: Izinkan
+ **Aturan keluar:**
+ Nomor aturan: sebaiknya lebih rendah dari semua aturan menolak;
+ Jenis: Aturan TCP Kustom;
+ Protokol: TCP
+ Rentang Port: 6379
+ Sumber: 0.0.0.0/0 (atau subnet cluster. ElastiCache Ingatlah bahwa menggunakan spesifik IPs dapat menimbulkan masalah jika terjadi failover atau penskalaan cluster)
+ Izinkan/Tolak: Izinkan
ElastiCache Jaringan ACL:
+ **Aturan Masuk:**
+ Nomor aturan: sebaiknya lebih rendah dari semua aturan menolak;
+ Jenis: Aturan TCP Kustom;
+ Protokol: TCP
+ Rentang Port: 6379
+ Sumber: 0.0.0.0/0 (atau buat aturan individual untuk subnet cluster) ElastiCache
+ Izinkan/Tolak: Izinkan
+ **Aturan keluar:**
+ Nomor aturan: sebaiknya lebih rendah dari semua aturan menolak;
+ Jenis: Aturan TCP Kustom;
+ Protokol: TCP
+ Rentang Port: 1024-65535
+ Sumber: 0.0.0.0/0 (atau subnet cluster. ElastiCache Ingatlah bahwa menggunakan spesifik IPs dapat menimbulkan masalah jika terjadi failover atau penskalaan cluster)
+ Izinkan/Tolak: Izinkan
Untuk informasi selengkapnya, lihat [Jaringan ACLs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html).
## Tabel rute
Sama halnya dengan Network ACLs, setiap subnet dapat memiliki tabel rute yang berbeda. Jika klien dan ElastiCache cluster berada dalam subnet yang berbeda, pastikan bahwa tabel rute mereka memungkinkan mereka untuk mencapai satu sama lain.
Lingkungan yang lebih kompleks, yang melibatkan beberapa VPCs, perutean dinamis, atau firewall jaringan, mungkin menjadi sulit untuk dipecahkan. Lihat [Validasi konektivitas jaringan](#Connectivity) untuk mengonfirmasi bahwa pengaturan jaringan Anda sesuai.
## Resolusi DNS
ElastiCache menyediakan titik akhir layanan berdasarkan nama DNS. Titik akhir yang tersedia adalah `Configuration`, `Primary`, `Reader`, dan titik akhir `Node`. Untuk informasi selengkapnya, lihat [Menemukan Titik Akhir Koneksi](Endpoints.md).
Dalam hal failover atau perubahan klaster, alamat yang terkait dengan nama titik akhir mungkin berubah dan akan diperbarui secara otomatis.
Pengaturan DNS khusus (yaitu, tidak menggunakan layanan DNS VPC) mungkin tidak mengetahui nama DNS ElastiCache yang disediakan. Pastikan sistem Anda berhasil menyelesaikan ElastiCache titik akhir menggunakan alat sistem seperti `dig` (seperti yang ditunjukkan berikut) atau`nslookup`.
```
$ dig +short example.xxxxxx.ng.0001.use1.cache.amazonaws.com
example-001.xxxxxx.0001.use1.cache.amazonaws.com.
1.2.3.4
```
Anda juga dapat memaksakan resolusi nama melalui layanan DNS VPC:
```
$ dig +short example.xxxxxx.ng.0001.use1.cache.amazonaws.com @169.254.169.253
example-001.tihewd.0001.use1.cache.amazonaws.com.
1.2.3.4
```
## Mengidentifikasi masalah dengan diagnostik sisi server
CloudWatch metrik dan informasi run-time dari ElastiCache mesin adalah sumber umum atau informasi untuk mengidentifikasi potensi sumber masalah koneksi. Analisis yang baik biasanya dimulai dengan item berikut:
+ Penggunaan CPU: Valkey dan Redis OSS adalah aplikasi multi-threaded. Namun, pelaksanaan dari setiap perintah terjadi dalam satu thread tunggal (utama). Untuk alasan ini, ElastiCache berikan metrik `CPUUtilization` dan`EngineCPUUtilization`. `EngineCPUUtilization`menyediakan pemanfaatan CPU yang didedikasikan untuk proses Valkey atau Redis OSS, dan penggunaan `CPUUtilization` di semua v. CPUs Node dengan lebih dari satu vCPU biasanya memiliki nilai yang berbeda untuk `CPUUtilization` dan`EngineCPUUtilization`, yang kedua biasanya lebih tinggi. `EngineCPUUtilization` yang tinggi dapat disebabkan oleh peningkatan jumlah permintaan atau operasi kompleks yang membutuhkan waktu CPU yang besar untuk diselesaikan. Anda dapat mengidentifikasi keduanya dengan berikut ini:
+ Peningkatan jumlah permintaan: Periksa peningkatan pada metrik lain yang cocok dengan pola `EngineCPUUtilization`. Metrik yang berguna adalah:
+ `CacheHits` dan `CacheMisses`: jumlah permintaan berhasil atau permintaan yang tidak menemukan item yang valid dalam cache. Jika rasio dari yang meleset lebih tinggi dibandingkan yang berhasil, maka aplikasi memboroskan waktu dan sumber daya dengan permintaan yang tidak membuahkan hasil.
+ `SetTypeCmds` dan `GetTypeCmds`: Kedua metrik ini yang berhubungan dengan `EngineCPUUtilization` dapat membantu untuk memahami jika beban secara signifikan lebih tinggi untuk permintaan tulis, diukur oleh `SetTypeCmds`, atau lebih tinggi untuk permintaan baca, diukur oleh `GetTypeCmds`. Jika yang lebih banyak adalah beban baca, maka menggunakan beberapa replika baca dapat menyeimbangkan permintaan di beberapa simpul sehingga simpul primer dapat melayani permintaan tulis saja. Dalam cluster yang dinonaktifkan mode cluster, penggunaan replika baca dapat dilakukan dengan membuat konfigurasi koneksi tambahan dalam aplikasi menggunakan endpoint pembaca. ElastiCache Untuk informasi selengkapnya, lihat [Menemukan Titik Akhir Koneksi](Endpoints.md). Operasi baca harus dikirimkan ke koneksi tambahan ini. Operasi tulis akan dilakukan melalui titik akhir primer biasa. Pada mode klaster diaktifkan, sebaiknya menggunakan pustaka yang mendukung replika baca secara native. Dengan flag yang tepat, perpustakaan akan dapat secara otomatis menemukan topologi cluster, node replika, mengaktifkan operasi baca melalui perintah [READONLY Valkey atau Redis](https://valkey.io/commands/readonly) OSS, dan mengirimkan permintaan baca ke replika.
+ Jumlah koneksi yang meningkat:
+ `CurrConnections` dan `NewConnections`: `CurrConnection` adalah jumlah koneksi yang dibuat pada saat pengumpulan titik data, sementara `NewConnections` menunjukkan jumlah koneksi yang dibuat pada periode itu.
Membuat dan menangani koneksi menyebabkan overhead CPU yang cukup besar. Selain itu, proses handshake tiga arah TCP yang diperlukan untuk membuat koneksi baru akan berdampak secara negatif pada waktu respons secara keseluruhan.
Sebuah ElastiCache node dengan ribuan `NewConnections` per menit menunjukkan bahwa koneksi dibuat dan digunakan hanya dengan beberapa perintah, yang tidak optimal. Menjaga koneksi selalu tersedia dan menggunakan kembali koneksi itu untuk operasi baru adalah praktik terbaik. Hal ini dimungkinkan jika aplikasi klien mendukung dan menerapkan dengan baik pooling koneksi atau koneksi yang persisten. Dengan pooling koneksi, angka `currConnections` tidak akan memiliki variasi besar, dan `NewConnections` seharusnya menjadi serendah mungkin. Valkey dan Redis OSS memberikan kinerja optimal dengan sejumlah kecil CurrConnections. Menjaga currConnection dalam kelompok puluhan atau ratusan meminimalkan penggunaan sumber daya untuk mendukung koneksi tersendiri seperti buffer klien dan siklus CPU untuk melayani koneksi.
+ Throughput jaringan:
+ Tentukan bandwidth: ElastiCache node memiliki bandwidth jaringan yang sebanding dengan ukuran node. Karena aplikasi memiliki karakteristik yang berbeda, hasilnya dapat bervariasi sesuai dengan beban kerja. Sebagai contoh, aplikasi dengan permintaan kecil dengan laju yang tinggi cenderung menyebabkan pemanfaatan CPU lebih besar daripada throughput jaringan sementara kunci yang lebih besar akan menyebabkan pemanfaatan jaringan yang lebih tinggi. Untuk alasan itu, sebaiknya menguji simpul dengan beban kerja yang sebenarnya untuk pemahaman yang lebih baik tentang batasan.
Mensimulasi beban dari aplikasi akan memberikan hasil yang lebih akurat. Namun, alat tolok ukur dapat memberikan gambaran yang baik tentang batasan.
+ Untuk kasus di mana permintaan didominasi oleh operasi baca, menggunakan replika untuk operasi baca akan mengurangi beban pada simpul primer. Jika kasus penggunaan didominasi operasi tulis, digunakannya banyak replika akan memperkuat penggunaan jaringan. Untuk setiap byte yang ditulis ke simpul primer, N byte akan dikirim ke replika, di mana N adalah jumlah replika. Praktik terbaik untuk menulis beban kerja intensif digunakan ElastiCache untuk Redis OSS dengan mode cluster yang diaktifkan sehingga penulisan dapat diseimbangkan di beberapa pecahan, atau ditingkatkan ke tipe node dengan lebih banyak kemampuan jaringan.
+ CloudWatchmetrics `NetworkBytesIn`Dan `NetworkBytesOut` memberikan jumlah data yang masuk atau keluar dari node, masing-masing. `ReplicationBytes`adalah lalu lintas yang didedikasikan untuk replikasi data.
Untuk informasi selengkapnya, lihat [Batas terkait jaringan](#Network-limits).
+ Perintah kompleks: Perintah Redis OSS disajikan pada satu utas, yang berarti bahwa permintaan disajikan secara berurutan. Perintah tunggal yang lambat dapat memengaruhi permintaan lain dan koneksi, yang berpuncak pada terjadinya waktu habis. Penggunaan perintah yang bertindak pada beberapa nilai, kunci, atau jenis data harus dilakukan dengan hati-hati. Koneksi dapat diblokir atau dihentikan tergantung pada jumlah parameter, atau ukuran nilai input atau output-nya.
Contoh yang terkenal buruk adalah perintah `KEYS`. Perintah ini menyapu seluruh ruang kunci untuk mencari pola tertentu dan memblokir pelaksanaan dari perintah lain selama pelaksanaannya. Redis OSS menggunakan notasi “Big O” untuk menggambarkan kompleksitas perintahnya.
Perintah keys memiliki O(N) kali kompleksitas, N menjadi jumlah kunci dalam basis data. Oleh karena itu, semakin besar jumlah kunci, semakin lambat perintahnya. `KEYS` dapat menyebabkan masalah dengan cara yang berbeda: Jika tidak menggunakan pola pencarian, perintah ini akan menghasilkan semua nama kunci yang tersedia. Dalam basis data dengan ribuan atau jutaan item, output yang besar akan tercipta dan membanjiri buffer jaringan.
Jika pola pencarian digunakan, hanya kunci yang cocok dengan pola yang akan dikembalikan ke klien. Namun, mesin masih akan menyapu ke seluruh ruang kunci untuk mencarinya, dan waktu untuk menyelesaikan perintah akan sama.
Alternatif untuk `KEYS` adalah perintah `SCAN`. Perintah ini melakukan iterasi atas ruang kunci dan membatasi iterasi dalam jumlah tertentu dari item, menghindari pemblokiran yang berkepanjangan pada mesin.
Scan memiliki parameter `COUNT`, digunakan untuk mengatur ukuran dari blok iterasi. Nilai default-nya adalah 10 (10 item per iterasi).
Tergantung pada jumlah item dalam basis data, blok dengan nilai `COUNT` yang kecil akan membutuhkan lebih banyak iterasi untuk menyelesaikan perintah scan penuh, dan nilai yang lebih besar ini akan membuat mesin sibuk lebih lama di setiap iterasi. Sementara nilai count yang kecil akan membuat `SCAN` lebih lambat pada basis data yang besar, nilai yang lebih besar dapat menyebabkan masalah yang sama seperti disebutkan untuk `KEYS`.
Sebagai contoh, menjalankan perintah `SCAN` dengan nilai count sebesar 10 akan membutuhkan 100.000 pengulangan pada basis data dengan 1 juta kunci. Jika waktu pulang pergi jaringan rata-rata adalah 0,5 milidetik, sekitar 50.000 milidetik (50 detik) akan dihabiskan untuk mengirimkan permintaan ini.
Di sisi lain, jika nilai count adalah 100,0000, iterasi tunggal akan diperlukan dan hanya 0,5 milidetik yang akan dihabiskan untuk mengirimnya. Namun, mesin akan sepenuhnya terblokir untuk operasi lain sampai perintah itu selesai menyapu semua ruang kunci.
Selain `KEYS`, beberapa perintah lain berpotensi membahayakan jika tidak digunakan dengan benar. Untuk melihat daftar semua perintah dan kompleksitas waktu masing-masing, buka perintah [Valkey dan Redis OSS](https://valkey.io/commands).
Contoh potensi masalah:
+ Skrip Lua: Valkey dan Redis OSS menyediakan penerjemah Lua tertanam, memungkinkan eksekusi skrip di sisi server. Skrip Lua pada Valkey dan Redis OSS dieksekusi pada tingkat mesin dan bersifat atomik menurut definisi, yang berarti bahwa tidak ada perintah atau skrip lain yang diizinkan untuk dijalankan saat skrip sedang dieksekusi. Skrip Lua memberikan kemungkinan menjalankan beberapa perintah, algoritme pengambilan keputusan, penguraian data, dan lainnya langsung di mesin. Meskipun sifat atom dari skrip dan kemungkinan melepaskan aplikasi cukup menarik, skrip harus digunakan dengan hati-hati dan untuk operasi yang kecil. ElastiCacheAktif, waktu eksekusi skrip Lua dibatasi hingga 5 detik. Skrip yang belum ditulis ke ruang kunci akan secara otomatis dihentikan setelah periode 5 detik. Untuk menghindari kerusakan dan inkonsistensi data, simpul akan melakukan failover jika pelaksanaan skrip belum selesai dalam 5 detik dan tetap menjalankan operasi tulis apa pun selama pelaksanaan skrip. [Transaksi](https://valkey.io/topics/transactions) adalah alternatif untuk menjamin konsistensi beberapa modifikasi kunci terkait di Redis OSS. Perintah transaction memungkinkan eksekusi dari suatu blok perintah, memperhatikan perubahan pada kunci yang sudah ada. Jika salah satu kunci yang diperhatikan berubah sebelum selesainya transaksi, maka semua perubahan akan dibuang.
+ Penghapusan item secara massal: perintah `DEL` menerima beberapa parameter, yang merupakan nama kunci yang akan dihapus. Operasi penghapusan bersifat sinkron dan akan mengambil waktu CPU yang signifikan jika daftar parameter besar, atau berisi daftar yang panjang, set, sorted set, atau hash yang besar (struktur data memegang beberapa sub-item). Dengan kata lain, bahkan penghapusan satu kunci pun dapat memakan waktu lama jika kunci itu memiliki banyak elemen. Alternatifnya `DEL` adalah`UNLINK`, yang merupakan perintah asinkron yang tersedia sejak Redis OSS 4. `UNLINK`harus lebih disukai daripada `DEL` bila memungkinkan. Mulai ElastiCache untuk Redis OSS 6x, `lazyfree-lazy-user-del` parameter membuat `DEL` perintah berperilaku seperti `UNLINK` saat diaktifkan. Untuk informasi selengkapnya, lihat [Redis OSS 6.0](ParameterGroups.Engine.md#ParameterGroups.Redis.6-x) Perubahan Parameter.
+ Perintah yang bekerja pada beberapa kunci: `DEL` disebutkan sebelumnya sebagai perintah yang menerima beberapa argumen dan waktu pelaksanaannya akan berbanding lurus dengan itu. Namun, Redis OSS menyediakan lebih banyak perintah yang bekerja sama. Sebagai contoh, `MSET` dan `MGET` memungkinkan penyisipan atau pengambilan beberapa kunci String sekaligus. Penggunaannya mungkin bermanfaat untuk mengurangi latensi jaringan yang terjadi pada beberapa perintah tersendiri `SET` atau `GET`. Namun, daftar parameter yang panjang akan memengaruhi penggunaan CPU.
Sementara pemanfaatan CPU sendiri bukan penyebab untuk masalah konektivitas, menghabiskan terlalu banyak waktu untuk memproses satu atau beberapa perintah atas beberapa kunci dapat menyebabkan kegagalan permintaan lain dan meningkatkan pemanfaatan CPU secara keseluruhan.
Jumlah kunci dan ukurannya akan memengaruhi kompleksitas perintah dan karena itu berpengaruh pada waktu penyelesaian.
Contoh lain dari perintah yang dapat bertindak atas beberapa kunci: `HMGET`, `HMSET`, `MSETNX`, `PFCOUNT`, `PFMERGE`, `SDIFF`, `SDIFFSTORE`, `SINTER`, `SINTERSTORE`, `SUNION`, `SUNIONSTORE`, `TOUCH`, `ZDIFF`, `ZDIFFSTORE`, `ZINTER` atau `ZINTERSTORE`.
+ Perintah yang bekerja pada beberapa tipe data: Redis OSS juga menyediakan perintah yang bertindak atas satu atau beberapa kunci, terlepas dari tipe datanya. ElastiCache untuk Redis OSS menyediakan metrik `KeyBasedCmds` untuk memantau perintah tersebut. Metrik ini menjumlahkan eksekusi dari perintah berikut pada periode yang dipilih:
+ Kompleksitas O(N):
+ `KEYS`
+ O(1)
+ `EXISTS`
+ `OBJECT`
+ `PTTL`
+ `RANDOMKEY`
+ `TTL`
+ `TYPE`
+ `EXPIRE`
+ `EXPIREAT`
+ `MOVE`
+ `PERSIST`
+ `PEXPIRE`
+ `PEXPIREAT`
+ `UNLINK (O(N)` untuk mengeklaim kembali memori. Namun tugas mengeklaim kembali memori itu terjadi di thread yang terpisah dan tidak memblokir mesin
+ Waktu kompleksitas yang berbeda akan tergantung pada jenis data:
+ `DEL`
+ `DUMP`
+ `RENAME` dianggap perintah dengan kompleksitas O(1), tetapi menjalankan `DEL` secara internal. Waktu pelaksanaan akan bervariasi tergantung pada ukuran kunci yang diganti namanya.
+ `RENAMENX`
+ `RESTORE`
+ `SORT`
+ Hash besar: Hash adalah jenis data yang memungkinkan satu kunci dengan beberapa sub-item nilai kunci. Setiap hash dapat menyimpan 4.294.967.295 item dan operasi pada hash yang besar dapat menghabiskan banyak daya komputasi. Sama dengan `KEYS`, hash mempunyai perintah `HKEYS` dengan kompleksitas waktu O(N), N adalah jumlah item dalam hash. `HSCAN` seharusnya lebih dipilih dibandingkan `HKEYS` untuk menghindari perintah yang berjalan lama. `HDEL`, `HGETALL`, `HMGET`, `HMSET` dan `HVALS` adalah perintah yang harus digunakan dengan hati-hati pada hash besar.
+ Struktur big data lainnya: Selain hash, struktur data lainnya dapat memakan waktu CPU. Set, List, Sorted Set, dan Hyperloglog juga dapat memakan waktu yang lama untuk dimanipulasi tergantung pada ukuran dan perintah yang digunakan. Untuk informasi lebih lanjut tentang perintah tersebut, lihat perintah [Valkey dan Redis OSS](https://valkey.io/commands).
## Validasi konektivitas jaringan
Setelah meninjau konfigurasi jaringan yang terkait dengan resolusi DNS, grup keamanan, jaringan ACLs, dan tabel rute, konektivitas dapat divalidasi dengan VPC Reachability Analyzer dan alat sistem.
Reachability Analyzer akan menguji konektivitas jaringan dan mengonfirmasi jika semua persyaratan dan izin terpenuhi. Untuk tes di bawah ini Anda akan memerlukan ID ENI (Elastic Network Interface Identification) dari salah satu ElastiCache node yang tersedia di VPC Anda. Anda dapat menemukannya dengan melakukan hal berikut:
1. Pergi ke [https://console.aws.amazon.com/ec2/v2/home? \$1NIC:](https://console.aws.amazon.com/ec2/v2/home?#NIC)
1. Filter daftar antarmuka dengan nama ElastiCache cluster Anda atau alamat IP yang didapat dari validasi DNS sebelumnya.
1. Tuliskan atau simpan ENI ID. Jika beberapa antarmuka ditampilkan, tinjau deskripsi untuk mengonfirmasi bahwa mereka termasuk dalam ElastiCache cluster yang tepat dan pilih salah satunya.
1. Lanjutkan ke langkah berikutnya.
1. Buat jalur analisis di [https://console.aws.amazon.com/vpc/rumah? ](https://console.aws.amazon.com/vpc/home?#ReachabilityAnalyzer)\$1 ReachabilityAnalyzer dan pilih opsi berikut:
+ **Jenis Sumber**: Pilih **instance** jika ElastiCache klien Anda berjalan pada EC2 instans Amazon atau **Antarmuka Jaringan** jika menggunakan layanan lain, seperti AWS Fargate Amazon ECS dengan jaringan awsvpc, dll) AWS Lambda, dan ID sumber daya masing-masing (EC2 instance atau ID ENI);
+ **Jenis Tujuan**: Pilih **Antarmuka Jaringan** dan pilih **ElastiCache ENI** dari daftar.
+ **Port tujuan**: tentukan 6379 untuk Redis OSS atau 11211 ElastiCache untuk untuk Memcached. ElastiCache Itu adalah port yang ditetapkan dengan konfigurasi default dan contoh ini mengasumsikan bahwa port tersebut tidak berubah.
+ **Protokol**: TCP
Buat jalur analisis dan tunggu beberapa saat untuk hasilnya. Jika status tidak terjangkau, buka detail analisis dan tinjau **Penjelajah analisis** untuk detail di mana permintaan diblokir.
Jika tes penjangkauan sudah lulus, lanjutkan ke verifikasi di tingkat OS.
Untuk memvalidasi konektivitas TCP pada port ElastiCache layanan: Di Amazon Linux, `Nping` tersedia dalam paket `nmap` dan dapat menguji konektivitas TCP pada ElastiCache port, serta menyediakan waktu pulang-pergi jaringan untuk membuat koneksi. Gunakan ini untuk memvalidasi konektivitas jaringan dan latensi saat ini ke ElastiCache cluster, seperti yang ditunjukkan berikut:
```
$ sudo nping --tcp -p 6379 example.xxxxxx.ng.0001.use1.cache.amazonaws.com
Starting Nping 0.6.40 ( http://nmap.org/nping ) at 2020-12-30 16:48 UTC
SENT (0.0495s) TCP ...
(Output suppressed )
Max rtt: 0.937ms | Min rtt: 0.318ms | Avg rtt: 0.449ms
Raw packets sent: 5 (200B) | Rcvd: 5 (220B) | Lost: 0 (0.00%)
Nping done: 1 IP address pinged in 4.08 seconds
```
Secara default, `nping` mengirimkan 5 paket penyelidikan dengan waktu tunda 1 detik di antara paket itu. Anda dapat menggunakan opsi "-c" untuk menambah jumlah paket penyelidikan dan "--delay " untuk mengubah waktu untuk mengirim pengujian baru.
Jika pengujian dengan `nping` gagal dan pengujian *VPC Reachability Analyzer* lulus, mintalah administrator sistem Anda untuk meninjau kemungkinan aturan firewall berbasis Host, aturan perutean asimetris, atau batasan lain yang dimungkinkan di tingkat sistem operasi.
Di ElastiCache konsol, periksa apakah **Enkripsi dalam transit** diaktifkan di detail ElastiCache klaster Anda. Jika enkripsi bergerak diaktifkan, lakukan konfirmasi jika sesi TLS dapat dibuat dengan perintah berikut:
```
openssl s_client -connect example.xxxxxx.use1.cache.amazonaws.com:6379
```
Output yang panjang akan keluar jika koneksi dan negosiasi TLS berhasil. Periksa kode yang dihasilkan yang terdapat di baris terakhir, nilainya harus `0 (ok)`. [Jika openssl mengembalikan sesuatu yang berbeda, periksa alasan kesalahan di https://www.openssl.org/docs/man1.0.2/man1/verify.html \$1DIAGNOSTICS.](https://www.openssl.org/docs/man1.0.2/man1/verify.html#DIAGNOSTICS)
Jika semua pengujian infrastruktur dan sistem operasi lulus tetapi aplikasi Anda masih tidak dapat terhubung ElastiCache, periksa apakah konfigurasi aplikasi sesuai dengan pengaturan. ElastiCache Kesalahan yang umum adalah:
+ Aplikasi Anda tidak mendukung mode ElastiCache cluster, dan ElastiCache mengaktifkan mode cluster;
+ Aplikasi Anda tidak mendukung TLS/SSL, dan ElastiCache memiliki enkripsi dalam transit yang diaktifkan;
+ Aplikasi mendukung TLS/SSL tetapi tidak memiliki bendera konfigurasi yang tepat atau otoritas sertifikasi tepercaya;
## Batas terkait jaringan
+ Jumlah maksimum koneksi: Ada batas keras untuk koneksi secara serentak. Setiap ElastiCache node memungkinkan hingga 65.000 koneksi simultan di semua klien. Batas ini dapat dipantau melalui metrik `CurrConnections` di CloudWatch. Namun, klien juga memiliki batas untuk koneksi keluar. Pada Linux, periksa rentang port ephemeral yang diizinkan dengan perintah:
```
# sysctl net.ipv4.ip_local_port_range
net.ipv4.ip_local_port_range = 32768 60999
```
Pada contoh sebelumnya, 28231 koneksi akan diizinkan dari sumber yang sama, ke IP tujuan (ElastiCache node) dan port yang sama. Perintah berikut menunjukkan berapa banyak koneksi yang ada untuk ElastiCache node tertentu (IP 1.2.3.4):
```
ss --numeric --tcp state connected "dst 1.2.3.4 and dport == 6379" | grep -vE '^State' | wc -l
```
Jika jumlahnya terlalu tinggi, sistem Anda mungkin menjadi kelebihan beban mencoba memproses permintaan koneksi. Sebaiknya mempertimbangkan menerapkan teknik seperti pooling koneksi atau koneksi persisten untuk menangani koneksi itu dengan lebih baik. Jika memungkinkan, lakukan konfigurasi pool koneksi untuk membatasi jumlah maksimum koneksi hanya beberapa ratus. Selain itu, logika back-off untuk menangani masalah waktu habis atau pengecualian koneksi lain juga dianjurkan untuk menghindari masalah koneksi churn.
+ Batas lalu lintas jaringan: Periksa [CloudWatch metrik berikut untuk Redis OSS](CacheMetrics.Redis.md) untuk mengidentifikasi kemungkinan batas jaringan yang terkena pada node: ElastiCache
+ `NetworkBandwidthInAllowanceExceeded` / `NetworkBandwidthOutAllowanceExceeded`: Paket jaringan yang ditunda karena throughput melebihi batas agregasi bandwidth.
Penting untuk dicatat bahwa setiap byte yang ditulis ke simpul primer akan direplikasi ke N replika, di mana N adalah jumlah replika. Klaster dengan jenis simpul kecil, beberapa replika, dan permintaan sarat operasi tulis mungkin tidak mampu mengatasi backlog replikasi. Untuk kasus seperti itu, praktik terbaiknya adalah menaikkan skala (mengubah jenis simpul), menskalakan ke luar (menambahkan serpihan dalam klaster dengan mode klaster diaktifkan), mengurangi jumlah replika, atau meminimalkan jumlah operasi tulis.
+ `NetworkConntrackAllowanceExceeded`: Paket yang ditunda karena telah terlampauinya jumlah maksimum koneksi yang dilacak di seluruh grup keamanan yang ditetapkan ke simpul. Koneksi baru kemungkinan akan gagal selama periode ini.
+ `NetworkPackets PerSecondAllowanceExceeded`: Jumlah maksimum paket per detik terlampaui. Beban kerja berdasarkan laju yang tinggi dari permintaan yang sangat kecil dapat mencapai batas ini sebelum bandwidth mencapai maksimum.
Metrik di atas adalah cara ideal untuk mengonfirmasi simpul yang mencapai batas jaringannya. Namun, batas juga dapat diidentifikasi dengan bentuk plato pada metrik jaringan.
Jika dataran tinggi teramati untuk waktu yang lama, kemungkinan akan diikuti oleh lag replikasi, peningkatan byte yang Digunakan untuk cache, penurunan memori yang dapat dikosongkan, swap tinggi, dan penggunaan CPU. EC2 Instans Amazon juga memiliki batas jaringan yang dapat dilacak melalui metrik [driver ENA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-network-performance-ena.html). Instans Linux dengan dukungan jaringan yang ditingkatkan dan penggerak ENA 2.2.10 atau yang lebih baru dapat meninjau penghitung batas dengan perintah:
```
# ethtool -S eth0 | grep "allowance_exceeded"
```
## Penggunaan CPU
Metrik penggunaan CPU adalah titik awal penyelidikan, dan item berikut dapat membantu mempersempit kemungkinan masalah di ElastiCache samping:
+ Redis OSS SlowLogs: Konfigurasi ElastiCache default mempertahankan 128 perintah terakhir yang membutuhkan waktu lebih dari 10 milidetik untuk diselesaikan. Riwayat perintah lambat disimpan selama runtime mesin dan akan hilang jika terjadi kegagalan atau mulai ulang. Jika daftar mencapai 128 entri, maka peristiwa lama akan dihapus untuk memberikan tempat untuk peristiwa baru. Ukuran dari daftar peristiwa lambat dan waktu pelaksanaan yang dianggap lambat dapat diubah melalui parameter `slowlog-max-len` dan `slowlog-log-slower-than` dalam [grup parameter kustom](ParameterGroups.md). Daftar slowlogs dapat diambil dengan menjalankan `SLOWLOG GET 128` pada mesin, 128 adalah 128 perintah lambat terakhir yang dilaporkan. Setiap entri memiliki bidang berikut:
```
1) 1) (integer) 1 -----------> Sequential ID
2) (integer) 1609010767 --> Timestamp (Unix epoch time)of the Event
3) (integer) 4823378 -----> Time in microseconds to complete the command.
4) 1) "keys" -------------> Command
2) "*" ----------------> Arguments
5) "1.2.3.4:57004"-> Source
```
Peristiwa di atas terjadi pada tanggal 26 Desember pukul 19:26:07 UTC, membutuhkan 4,8 detik (4,823ms) untuk diselesaikan dan disebabkan oleh perintah `KEYS` yang diminta dari klien 1.2.3.4.
Di Linux, stempel waktu dapat dikonversi dengan perintah tanggal:
```
$ date --date='@1609010767'
Sat Dec 26 19:26:07 UTC 2020
```
Pada Python:
```
>>> from datetime import datetime
>>> datetime.fromtimestamp(1609010767)
datetime.datetime(2020, 12, 26, 19, 26, 7)
```
Atau di Windows dengan PowerShell:
```
PS D:\Users\user> [datetimeoffset]::FromUnixTimeSeconds('1609010767')
DateTime : 12/26/2020 7:26:07 PM
UtcDateTime
: 12/26/2020 7:26:07 PM
LocalDateTime : 12/26/2020 2:26:07 PM
Date : 12/26/2020 12:00:00 AM
Day : 26
DayOfWeek
: Saturday
DayOfYear : 361
Hour : 19
Millisecond : 0
Minute : 26
Month
: 12
Offset : 00:00:00Ticks : 637446075670000000
UtcTicks
: 637446075670000000
TimeOfDay : 19:26:07
Year : 2020
```
Banyak perintah lambat dalam waktu singkat (menit yang sama atau kurang) menjadi hal yang dikhawatirkan. Tinjau sifat dari perintah dan bagaimana perintah itu dapat dioptimalkan (lihat contoh sebelumnya). Jika perintah dengan kompleksitas waktu O(1) sering dilaporkan, periksa faktor lain yang menyebabkan penggunaan CPU tinggi yang disebutkan sebelumnya.
+ Metrik latensi: ElastiCache untuk Redis OSS menyediakan CloudWatch metrik untuk memantau latensi rata-rata untuk berbagai kelas perintah. Titik data dihitung dengan membagi jumlah pelaksanaan perintah dalam kategori dengan total waktu pelaksanaan pada periode tersebut. Penting untuk dipahami bahwa hasil metrik latensi merupakan kumpulan dari beberapa perintah. Satu perintah dapat menyebabkan hasil tidak terduga, seperti waktu habis, tanpa dampak signifikan pada metrik. Untuk kasus seperti ini, peristiwa slowlog akan menjadi sumber informasi yang lebih akurat. Daftar berikut berisi metrik latensi yang tersedia dan perintah terkait yang memengaruhinya.
+ EvalBasedCmdsLatency: terkait dengan perintah Lua Script,`eval`,`evalsha`;
+ GeoSpatialBasedCmdsLatency: `geodist`, `geohash`, `geopos`, `georadius`, `georadiusbymember`, `geoadd`;
+ GetTypeCmdsLatency: Baca perintah, terlepas dari tipe data;
+ HashBasedCmdsLatency: `hexists`, `hget`, `hgetall`, `hkeys`, `hlen`, `hmget`, `hvals`, `hstrlen`, `hdel`, `hincrby`, `hincrbyfloat`, `hmset`, `hset`, `hsetnx`;
+ HyperLogLogBasedCmdsLatency: `pfselftest`, `pfcount`, `pfdebug`, `pfadd`, `pfmerge`;
+ KeyBasedCmdsLatency: Perintah yang dapat bertindak atas tipe data yang berbeda: `dump` `exists``keys`,`object`,`pttl`,,`randomkey`,`ttl`,`type`,`del`,`expire`,`expireat`,`move`,`persist`,`pexpire`,`pexpireat`,`rename`,`renamenx`,`restoreK`,`sort`,`unlink`;
+ ListBasedCmdsLatency: lindex, llen, lrange, blpop, brpop, brpoplpush, linsert, lpop, lpush, lpushx, lrem, lset, ltrim, rpop, rpoplpush, rpush, rpushx;
+ PubSubBasedCmdsLatency: psubscribe, publish, pubsub, punsubscribe, subscribe, unsubscribe;
+ SetBasedCmdsLatency: `scard`, `sdiff`, `sinter`, `sismember`, `smembers`, `srandmember`, `sunion`, `sadd`, `sdiffstore`, `sinterstore`, `smove`, `spop`, `srem`, `sunionstore`;
+ SetTypeCmdsLatency: Menulis perintah, terlepas dari tipe data;
+ SortedSetBasedCmdsLatency: `zcard`, `zcount`, `zrange`, `zrangebyscore`, `zrank`, `zrevrange`, `zrevrangebyscore`, `zrevrank`, `zscore`, `zrangebylex`, `zrevrangebylex`, `zlexcount`, `zadd`. `zincrby`, `zinterstore`, `zrem`, `zremrangebyrank`, `zremrangebyscore`, `zunionstore`, `zremrangebylex`, `zpopmax`, `zpopmin`, `bzpopmin`, `bzpopmax`;
+ StringBasedCmdsLatency: `bitcount`, `get`, `getbit`, `getrange`, `mget`, `strlen`, `substr`, `bitpos`, `append`, `bitop`, `bitfield`, `decr`, `decrby`, `getset`, `incr`, `incrby`, `incrbyfloat`, `mset`, `msetnx`, `psetex`, `set`, `setbit`, `setex`, `setnx`, `setrange`;
+ StreamBasedCmdsLatency: `xrange`, `xrevrange`, `xlen`, `xread`, `xpending`, `xinfo`, `xadd`, `xgroup`, `readgroup`, `xack`, `xclaim`, `xdel`, `xtrim`, `xsetid`;
+ Perintah runtime Redis OSS:
+ info commandstats: Menyediakan daftar perintah yang dijalankan sejak mesin dihidupkan, jumlah eksekusi kumulatifnya, total waktu eksekusi, dan waktu eksekusi rata-rata per perintah;
+ client list: Menyediakan daftar klien yang saat ini terhubung dan informasi yang relevan seperti penggunaan buffer, perintah yang dilaksanakan terakhir, dll;
+ Backup dan replikasi: ElastiCache untuk versi Redis OSS lebih awal dari 2.8.22 gunakan proses bercabang untuk membuat cadangan dan memproses sinkronisasi penuh dengan replika. Metode ini mungkin menyebabkan overhead memori yang besar untuk kasus penggunaan sarat operasi tulis.
Dimulai dengan ElastiCache Redis OSS 2.8.22, AWS memperkenalkan metode pencadangan dan replikasi tanpa garpu. Metode yang baru dapat menunda operasi tulis untuk mencegah kegagalan. Kedua metode dapat menyebabkan periode pemanfaatan CPU yang lebih tinggi, yang menyebabkan waktu respons lebih tinggi dan akibatnya menyebabkan klien mengalami waktu habis selama melaksanakan perintah. Selalu periksa apakah kegagalan klien terjadi selama periode pencadangan atau metrik `SaveInProgress` bernilai 1 pada periode tersebut. Sebaiknya menjadwalkan periode pencadangan untuk periode pemanfaatan yang rendah untuk meminimalkan kemungkinan masalah dengan klien atau kegagalan proses pencadangan.
## Koneksi yang dihentikan dari sisi server
Default ElastiCache untuk konfigurasi Redis OSS membuat koneksi klien dibuat tanpa batas waktu. Namun, dalam beberapa kasus penghentian koneksi mungkin diinginkan. Misalnya:
+ Bug dalam aplikasi klien dapat menyebabkan koneksi dilupakan dan tetap terhubung dengan keadaan idle. Ini disebut “kebocoran koneksi “ dan konsekuensinya adalah peningkatan yang tetap pada jumlah koneksi terhubung yang diamati pada metrik `CurrConnections`. Perilaku ini dapat mengakibatkan kejenuhan pada klien atau ElastiCache sisi. Ketika perbaikan langsung tidak dimungkinkan dari sisi klien, beberapa administrator menetapkan nilai” batas waktu “dalam grup ElastiCache parameter mereka. Waktu habis adalah waktu dalam detik yang diizinkan bagi koneksi idle untuk bertahan. Jika klien tidak mengirimkan permintaan apa pun dalam periode tersebut, mesin akan menghentikan koneksi segera setelah koneksi mencapai nilai batas waktu. Nilai waktu habis yang kecil dapat mengakibatkan pemutusan koneksi yang tidak perlu dan klien akan perlu menangani ini dengan tepat dan menghubungkan kembali, yang menyebabkan penundaan.
+ Memori yang digunakan untuk menyimpan kunci dibagikan dengan buffer klien. Klien lambat dengan permintaan atau tanggapan besar mungkin menuntut sejumlah besar memori untuk menangani buffer. Default ElastiCache untuk konfigurasi Redis OSS tidak membatasi ukuran buffer keluaran klien biasa. Jika batas `maxmemory` tercapai, mesin akan mencoba mengosongkan item untuk memenuhi penggunaan buffer. Dalam kondisi memori yang sangat rendah, ElastiCache untuk Redis OSS mungkin memilih untuk memutuskan klien yang mengkonsumsi buffer keluaran klien besar untuk membebaskan memori dan mempertahankan kesehatan cluster.
Dimungkinkan untuk membatasi ukuran buffer klien dengan konfigurasi kustom dan klien yang mencapai batas ini akan terputus. Namun, klien harus dapat menangani pemutusan yang tidak terduga. Parameter untuk menangani ukuran buffer untuk klien biasa adalah sebagai berikut:
+ client-query-buffer-limit: Ukuran maksimum permintaan input tunggal;
+ client-output-buffer-limit-normal-soft-limit: Batas lunak untuk koneksi klien. Koneksi akan dihentikan jika tetap di atas batas lunak selama lebih dari waktu dalam detik yang ditentukan pada client-output-buffer-limit - normal-soft-seconds atau jika mencapai batas keras;
+ client-output-buffer-limit-normal-soft-seconds: Waktu yang diizinkan untuk koneksi melebihi client-output-buffer-limit -normal-soft-limit;
+ client-output-buffer-limit-normal-hard-limit: Koneksi yang mencapai batas ini akan segera dihentikan.
Selain buffer klien reguler, opsi berikut mengontrol buffer untuk node replika dan klien Pub/Sub (Publish/Subscribe):
+ client-output-buffer-limit-replica-hard-limit;
+ client-output-buffer-limit-replica-soft-seconds;
+ client-output-buffer-limit-replica-hard-limit;
+ client-output-buffer-limit-pubsub-soft-limit;
+ client-output-buffer-limit-pubsub-soft-seconds;
+ client-output-buffer-limit-pubsub-hard-limit;
## Pemecahan masalah sisi klien untuk instans Amazon EC2
Beban dan daya tanggap di sisi klien juga dapat memengaruhi permintaan. ElastiCache EC2 instance dan batas sistem operasi perlu ditinjau dengan cermat saat memecahkan masalah konektivitas intermiten atau batas waktu. Beberapa poin penting untuk diamati:
+ CPU:
+ EC2 penggunaan CPU misalnya: Pastikan CPU belum jenuh atau mendekati 100 persen. Analisis historis dapat dilakukan melalui CloudWatch, namun perlu diingat bahwa perincian titik data adalah 1 menit (dengan pemantauan terperinci diaktifkan) atau 5 menit;
+ Jika menggunakan [ EC2 instans burstable](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html), pastikan saldo kredit CPU mereka belum habis. Informasi ini tersedia pada `CPUCreditBalance` CloudWatch metrik.
+ Periode pendek penggunaan CPU yang tinggi dapat menyebabkan waktu habis tanpa mencerminkan 100 persen pemanfaatan pada CloudWatch. Kasus seperti itu memerlukan pemantauan waktu nyata dengan peralatan sistem operasi seperti `top`, `ps`, dan `mpstat`.
+ Jaringan
+ Periksa apakah throughput Jaringan berada di bawah nilai yang dapat diterima sesuai dengan kemampuan instans. Untuk informasi selengkapnya, lihat [Jenis EC2 Instans Amazon](https://aws.amazon.com/ec2/instance-types/)
+ Pada instans dengan `ena` penggerak Jaringan yang Ditingkatkan, periksa [statistik ena](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/troubleshooting-ena.html#statistics-ena) untuk waktu habis habis atau batas yang terlampaui. Statistik berikut berguna untuk mengonfirmasi kejenuhan batas jaringan:
+ `bw_in_allowance_exceeded` / `bw_out_allowance_exceeded`: jumlah paket yang ditunda karena kelebihan throughput masuk atau keluar;
+ `conntrack_allowance_exceeded`: jumlah paket yang tidak diteruskan karena [batas pelacakan koneksi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html#connection-tracking-throttling) dari grup keamanan. Koneksi baru akan gagal saat batas ini jenuh;
+ `linklocal_allowance_exceeded`: jumlah paket yang tidak diteruskan karena permintaan berlebihan untuk metadata dari instans, NTP melalui DNS VPC. Batasnya adalah 1024 paket per detik untuk semua layanan;
+ `pps_allowance_exceeded`: jumlah paket yang tidak diteruskan karena rasio paket per detik yang berlebihan. Batas paket per detik dapat tercapai jika lalu lintas jaringan terdiri dari ribuan atau jutaan permintaan yang sangat kecil per detik. Lalu lintas ElastiCache dapat dioptimalkan untuk memanfaatkan paket jaringan lebih baik melalui alur atau perintah yang melakukan beberapa operasi sekaligus seperti `MGET` alih-alih `GET`.
## Membedah waktu yang dibutuhkan untuk menyelesaikan satu permintaan tunggal
+ Di jaringan: `Tcpdump` dan `Wireshark` (tshark pada baris perintah) adalah alat yang berguna untuk memahami berapa banyak waktu yang dibutuhkan permintaan untuk melakukan perjalanan jaringan, menekan ElastiCache mesin dan mendapatkan pengembalian. Contoh berikut menyorot satu permintaan tunggal yang dibuat dengan perintah berikut:
```
$ echo ping | nc example.xxxxxx.ng.0001.use1.cache.amazonaws.com 6379
+PONG
```
Sejajar dengan perintah di atas, tcpdump dijalankan dan menghasilkan:
```
$ sudo tcpdump -i any -nn port 6379 -tt
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on any, link-type LINUX_SLL (Linux cooked), capture size 262144 bytes
1609428918.917869 IP 172.31.11.142.40966
> 172.31.11.247.6379: Flags [S], seq 177032944, win 26883, options [mss 8961,sackOK,TS val 27819440 ecr 0,nop,wscale 7], length 0
1609428918.918071 IP 172.31.11.247.6379 > 172.31.11.142.40966: Flags [S.], seq 53962565, ack 177032945, win
28960, options [mss 1460,sackOK,TS val 3788576332 ecr 27819440,nop,wscale 7], length 0
1609428918.918091 IP 172.31.11.142.40966 > 172.31.11.247.6379: Flags [.], ack 1, win 211, options [nop,nop,TS val 27819440 ecr 3788576332], length 0
1609428918.918122
IP 172.31.11.142.40966 > 172.31.11.247.6379: Flags [P.], seq 1:6, ack 1, win 211, options [nop,nop,TS val 27819440 ecr 3788576332], length 5: RESP "ping"
1609428918.918132 IP 172.31.11.142.40966 > 172.31.11.247.6379: Flags [F.], seq 6, ack
1, win 211, options [nop,nop,TS val 27819440 ecr 3788576332], length 0
1609428918.918240 IP 172.31.11.247.6379 > 172.31.11.142.40966: Flags [.], ack 6, win 227, options [nop,nop,TS val 3788576332 ecr 27819440], length 0
1609428918.918295
IP 172.31.11.247.6379 > 172.31.11.142.40966: Flags [P.], seq 1:8, ack 7, win 227, options [nop,nop,TS val 3788576332 ecr 27819440], length 7: RESP "PONG"
1609428918.918300 IP 172.31.11.142.40966 > 172.31.11.247.6379: Flags [.], ack 8, win
211, options [nop,nop,TS val 27819441 ecr 3788576332], length 0
1609428918.918302 IP 172.31.11.247.6379 > 172.31.11.142.40966: Flags [F.], seq 8, ack 7, win 227, options [nop,nop,TS val 3788576332 ecr 27819440], length 0
1609428918.918307
IP 172.31.11.142.40966 > 172.31.11.247.6379: Flags [.], ack 9, win 211, options [nop,nop,TS val 27819441 ecr 3788576332], length 0
^C
10 packets captured
10 packets received by filter
0 packets dropped by kernel
```
Dari output di atas kita dapat mengonfirmasi bahwa handshake tiga arah TCP diselesaikan dalam 222 mikrodetik (918091 - 917869) dan perintah ping dikirim dan dikembalikan dalam 173 mikrodetik (918295 - 918122).
Dibutuhkan waktu 438 mikrodetik (918307 - 917869) mulai dari membuat permintaan hingga koneksi ditutup. Hasil tersebut akan memastikan bahwa waktu respons jaringan dan mesin adalah baik dan penyelidikan dapat berfokus pada komponen lainnya.
+ Pada sistem operasi: `Strace` dapat membantu mengidentifikasi kesenjangan waktu pada tingkat OS. Analisis aplikasi aktual akan jauh lebih luas dan dianjurkan menggunakan alat profil khusus untuk aplikasi atau debugger. Contoh berikut hanya menunjukkan jika komponen sistem operasi dasar berfungsi seperti yang diharapkan, jika tidak, penyelidikan lebih lanjut mungkin diperlukan. Menggunakan `PING` perintah Redis OSS yang sama dengan `strace` kita mendapatkan:
```
$ echo ping | strace -f -tttt -r -e trace=execve,socket,open,recvfrom,sendto nc example.xxxxxx.ng.0001.use1.cache.amazonaws.com (http://example.xxxxxx.ng.0001.use1.cache.amazonaws.com/)
6379
1609430221.697712 (+ 0.000000) execve("/usr/bin/nc", ["nc", "example.xxxxxx.ng.0001.use"..., "6379"], 0x7fffede7cc38 /* 22 vars */) = 0
1609430221.708955 (+ 0.011231) socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3
1609430221.709084
(+ 0.000124) socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3
1609430221.709258 (+ 0.000173) open("/etc/nsswitch.conf", O_RDONLY|O_CLOEXEC) = 3
1609430221.709637 (+ 0.000378) open("/etc/host.conf", O_RDONLY|O_CLOEXEC) = 3
1609430221.709923
(+ 0.000286) open("/etc/resolv.conf", O_RDONLY|O_CLOEXEC) = 3
1609430221.711365 (+ 0.001443) open("/etc/hosts", O_RDONLY|O_CLOEXEC) = 3
1609430221.713293 (+ 0.001928) socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 3
1609430221.717419
(+ 0.004126) recvfrom(3, "\362|\201\200\0\1\0\2\0\0\0\0\rnotls20201224\6tihew"..., 2048, 0, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr("172.31.0.2")}, [28->16]) = 155
1609430221.717890 (+ 0.000469) recvfrom(3, "\204\207\201\200\0\1\0\1\0\0\0\0\rnotls20201224\6tihew"...,
65536, 0, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr("172.31.0.2")}, [28->16]) = 139
1609430221.745659 (+ 0.027772) socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) = 3
1609430221.747548 (+ 0.001887) recvfrom(0, 0x7ffcf2f2ca50, 8192,
0, 0x7ffcf2f2c9d0, [128]) = -1 ENOTSOCK (Socket operation on non-socket)
1609430221.747858 (+ 0.000308) sendto(3, "ping\n", 5, 0, NULL, 0) = 5
1609430221.748048 (+ 0.000188) recvfrom(0, 0x7ffcf2f2ca50, 8192, 0, 0x7ffcf2f2c9d0, [128]) = -1 ENOTSOCK
(Socket operation on non-socket)
1609430221.748330 (+ 0.000282) recvfrom(3, "+PONG\r\n", 8192, 0, 0x7ffcf2f2c9d0, [128->0]) = 7
+PONG
1609430221.748543 (+ 0.000213) recvfrom(3, "", 8192, 0, 0x7ffcf2f2c9d0, [128->0]) = 0
1609430221.752110
(+ 0.003569) +++ exited with 0 +++
```
Pada contoh di atas, perintah ini membutuhkan waktu sekitar 54 milidetik untuk diselesaikan (752110 - 697712 = 54398 mikrodetik).
Lama waktu yang signifikan, sekitar 20 ms, dibutuhkan untuk membuat instans nc dan melakukan resolusi nama (dari 697712 hingga 717890), setelah itu, waktu 2 ms diperlukan untuk membuat soket TCP (745659 hingga 747858), dan waktu 0,4 ms (747858 hingga 748330) dibutuhkan untuk mengirimkan dan menerima respons untuk permintaan.
## Topik Terkait
+ [ElastiCache praktik terbaik dan strategi caching](BestPractices.md)