Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Keamanan data di Amazon ElastiCache
Untuk membantu menjaga keamanan data Anda, Amazon ElastiCache dan Amazon EC2 menyediakan mekanisme untuk mencegah akses data Anda yang tidak sah di server.
Amazon ElastiCache untuk Memcached menyediakan fitur enkripsi untuk data pada cache yang menjalankan Memcached versi 1.6.12 atau yang lebih baru.
[Amazon ElastiCache dengan Valkey dan Redis OSS menyediakan fitur enkripsi untuk data pada cache yang menjalankan Valkey 7.2 atau yang lebih baru, dan Redis OSS versi 3.2.6 (dijadwalkan untuk EOL, lihat jadwal akhir masa pakai versi Redis OSS), 4.0.10 atau yang lebih baru.](engine-versions.md#deprecated-engine-versions) Amazon ElastiCache juga mendukung otentikasi pengguna dengan IAM atau Valkey dan Redis OSS AUTH, dan mengotorisasi operasi pengguna menggunakan Role-Based Access Control (RBAC).
+ Enkripsi bergerak mengenkripsi data Anda setiap kali data bergerak dari satu tempat ke tempat lain, misalnya antara simpul di klaster atau antara cache dan aplikasi Anda.
+ Enkripsi diam mengenkripsi data pada disk Anda selama operasi sinkronisasi dan pencadangan.
ElastiCache mendukung otentikasi pengguna menggunakan IAM dan perintah Valkey dan Redis OSS AUTH, dan mengotorisasi operasi pengguna menggunakan Role-Based Access Control (RBAC).
![\[Gambar: ElastiCache untuk Diagram Keamanan Valkey dan Redis OSS\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/images/ElastiCache-Redis-Secure-Compliant.png)
*ElastiCache untuk Diagram Keamanan Valkey dan Redis OSS*
**Topics**
+ [ElastiCache enkripsi dalam transit (TLS)](in-transit-encryption.md)
+ [Enkripsi At-Rest di ElastiCache](at-rest-encryption.md)
+ [Autentikasi dan Otorisasi](auth-redis.md)
# ElastiCache enkripsi dalam transit (TLS)
Untuk membantu menjaga keamanan data Anda, Amazon ElastiCache dan Amazon EC2 menyediakan mekanisme untuk mencegah akses data Anda yang tidak sah di server. Dengan menyediakan kemampuan enkripsi dalam perjalanan, ElastiCache memberi Anda alat yang dapat Anda gunakan untuk membantu melindungi data Anda saat berpindah dari satu lokasi ke lokasi lain.
Semua cache tanpa server Valkey atau Redis OSS memiliki enkripsi dalam transit yang diaktifkan. Untuk cluster berbasis node, Anda dapat mengaktifkan enkripsi dalam transit pada grup replikasi dengan menyetel parameter ke `TransitEncryptionEnabled` (`true`CLI:`--transit-encryption-enabled`) saat Anda membuat grup replikasi. Anda dapat melakukan ini apakah Anda membuat grup replikasi menggunakan Konsol Manajemen AWS, the AWS CLI, atau ElastiCache API.
Semua cache nirserver memiliki enkripsi bergerak yang aktif. Untuk cluster berbasis node, Anda dapat mengaktifkan enkripsi in-transit pada cluster dengan menyetel parameter ke `TransitEncryptionEnabled` (`true`CLI:`--transit-encryption-enabled`) saat Anda membuat cluster menggunakan operasi (`CreateCacheCluster`CLI:). `create-cache-cluster`
**Topics**
+ [Gambaran umum enkripsi bergerak](#in-transit-encryption-overview)
+ [Kondisi enkripsi dalam transit (Valkey dan Redis OSS)](#in-transit-encryption-constraints)
+ [Kondisi enkripsi dalam transit (Memcached)](#in-transit-encryption-constraints)
+ [Praktik terbaik enkripsi bergerak](#in-transit-encryption-best-practices)
+ [Opsi Valkey dan Redis OSS lebih lanjut](#in-transit-encryption-see-also)
+ [Mengaktifkan enkripsi dalam transit untuk Memcached](#in-transit-encryption-enable-existing-mc)
+ [Mengaktifkan enkripsi bergerak](in-transit-encryption-enable.md)
+ [Menghubungkan ke ElastiCache (Valkey) atau Amazon ElastiCache untuk Redis OSS dengan enkripsi dalam transit menggunakan valkey-cli](connect-tls.md)
+ [Mengaktifkan enkripsi dalam transit pada cluster Redis OSS berbasis node menggunakan Python](in-transit-encryption-enable-python.md)
+ [Praktik terbaik saat mengaktifkan enkripsi bergerak](enable-python-best-practices.md)
+ [Menghubungkan ke node diaktifkan dengan enkripsi dalam transit menggunakan Openssl (Memcached)](#in-transit-encryption-connect-mc)
+ [Membuat klien Memcached TLS menggunakan Java](#in-transit-encryption-connect-java)
+ [Membuat klien Memcached TLS menggunakan PHP](#in-transit-encryption-connect-php-mc)
## Gambaran umum enkripsi bergerak
Enkripsi ElastiCache in-transit Amazon adalah fitur yang memungkinkan Anda meningkatkan keamanan data Anda di titik yang paling rentan — saat transit dari satu lokasi ke lokasi lain. Karena diperlukan beberapa pemrosesan untuk mengenkripsi dan mendekripsi data di titik akhir, mengaktifkan enkripsi bergerak dapat memberikan beberapa dampak pada performa. Anda harus menolok ukur data Anda dengan dan tanpa enkripsi bergerak untuk menentukan dampak terhadap performa pada kasus penggunaan Anda.
ElastiCache enkripsi in-transit mengimplementasikan fitur-fitur berikut:
+ **Koneksi klien terenkripsi**—koneksi klien ke simpul cache dienkripsi TLS.
+ **Koneksi server terenkripsi—**data yang bergerak antarsimpul dalam klaster dienkripsi.
+ **Autentikasi server**—Klien dapat mengautentikasi bahwa koneksinya dilakukan ke server yang benar.
+ **Otentikasi klien** —menggunakan fitur Valkey dan Redis OSS AUTH, server dapat mengautentikasi klien.
## Kondisi enkripsi dalam transit (Valkey dan Redis OSS)
Kendala berikut pada enkripsi ElastiCache in-transit Amazon harus diingat saat Anda merencanakan implementasi cluster berbasis node:
+ Enkripsi dalam transit didukung pada grup replikasi yang menjalankan Valkey 7.2 dan yang lebih baru, dan Redis OSS versi 3.2.6, 4.0.10 dan yang lebih baru.
+ Memodifikasi pengaturan enkripsi dalam transit, untuk klaster yang ada, didukung pada grup replikasi yang menjalankan Valkey 7.2 dan yang lebih baru, dan Redis OSS versi 7 dan yang lebih baru.
+ Enkripsi bergerak didukung hanya untuk grup replikasi yang berjalan di Amazon VPC.
+ Enkripsi dalam transit tidak didukung untuk grup replikasi yang menjalankan tipe node berikut: M1, M2.
Untuk informasi selengkapnya, lihat [Jenis simpul yang didukung](CacheNodes.SupportedTypes.md).
+ Enkripsi in-transit diaktifkan dengan menetapkan parameter `TransitEncryptionEnabled` menjadi `true` secara eksplisit.
+ Pastikan klien cache Anda mendukung konektivitas TLS dan Anda telah mengaktifkannya dalam konfigurasi klien.
+ Mulai 26 Januari 2026,AWS akan memperbarui versi TLS minimum yang didukung ke 1.2 aktif ElastiCache untuk Valkey versi 7.2 ke atas, dan ElastiCache untuk Redis OSS versi 6 ke atas. Pelanggan harus memperbarui perangkat lunak klien mereka sebelum tanggal tersebut. Pembaruan ini membantu Anda memenuhi kebutuhan keamanan, kepatuhan, dan peraturan.
## Kondisi enkripsi dalam transit (Memcached)
Kendala berikut pada enkripsi ElastiCache in-transit Amazon harus diingat saat Anda merencanakan implementasi cluster berbasis node:
+ Enkripsi bergerak didukung pada klaster yang menjalankan Memcached versi 1.6.12 atau yang lebih baru.
+ Enkripsi bergerak mendukung Keamanan Lapisan Pengangkutan (TLS) versi 1.2 dan 1.3.
+ Enkripsi bergerak didukung hanya untuk klaster yang berjalan di Amazon VPC.
+ Enkripsi dalam transit tidak didukung untuk grup replikasi yang menjalankan jenis node berikut: M1, M2, M3, R3, T2.
Untuk informasi selengkapnya, lihat [Jenis simpul yang didukung](CacheNodes.SupportedTypes.md).
+ Enkripsi bergerak diaktifkan dengan menetapkan parameter `TransitEncryptionEnabled` ke `true` secara eksplisit.
+ Anda dapat mengaktifkan enkripsi bergerak pada klaster hanya saat pembuatan klaster. Anda tidak dapat mengaktifkan dan menonaktifkan enkripsi bergerak dengan mengubah klaster.
+ Pastikan klien cache Anda mendukung konektivitas TLS dan Anda telah mengaktifkannya dalam konfigurasi klien.
## Praktik terbaik enkripsi bergerak
+ Karena pemrosesan diperlukan untuk mengenkripsi dan mendekripsi data di titik akhir, menerapkan enkripsi bergerak dapat mengurangi performa. Lakukan tolok ukur terhadap enkripsi bergerak dibandingkan dengan tanpa enkripsi pada data Anda sendiri untuk menentukan dampaknya terhadap performa untuk implementasi Anda.
+ Karena membuat koneksi baru bisa menghabiskan banyak daya komputasi, Anda dapat mengurangi dampak enkripsi bergerak pada performa dengan mempersistensi koneksi TLS Anda.
## Opsi Valkey dan Redis OSS lebih lanjut
Untuk informasi lebih lanjut tentang opsi yang tersedia untuk Valkey dan Redis OSS, lihat tautan berikut.
+ [Enkripsi At-Rest di ElastiCache](at-rest-encryption.md)
+ [Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH](auth.md)
+ [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md)
+ [Amazon VPCs dan ElastiCache keamanan](VPCs.md)
+ [Identity and Access Management untuk Amazon ElastiCache](IAM.md)
## Mengaktifkan enkripsi dalam transit untuk Memcached
Untuk mengaktifkan enkripsi bergerak saat membuat klaster Memcached menggunakan Konsol Manajemen AWS, buat pilihan berikut:
+ Pilih Memcached sebagai mesin Anda.
+ Pilih versi mesin 1.6.12 atau yang lebih baru.
+ Pada **Enkripsi bergerak**, pilih **Aktifkan**.
Untuk step-by-step prosesnya, lihat[Membuat cluster untuk Valkey atau Redis OSS](Clusters.Create.md).
# Mengaktifkan enkripsi bergerak
Semua cache nirserver memiliki enkripsi bergerak yang aktif. Pada cluster berbasis node, Anda dapat mengaktifkan enkripsi dalam transit menggunakan,AWS CLI Konsol Manajemen AWS, atau API. ElastiCache
## Mengaktifkan enkripsi dalam transit menggunakan Konsol Manajemen AWS
### Mengaktifkan enkripsi dalam transit untuk cluster berbasis node baru menggunakan Konsol Manajemen AWS
Saat merancang klaster Anda sendiri, konfigurasi 'Dev/Test' dan 'Produksi' dengan metode 'Mudah dibuat' akan mengaktifkan enkripsi bergerak. Saat memilih konfigurasi sendiri, buat pilihan berikut:
+ Pilih versi mesin 3.2.6, 4.0.10 atau yang lebih baru.
+ Klik kotak centang di samping **Aktifkan** untuk opsi **Enkripsi bergerak**.
Untuk step-by-step prosesnya, lihat yang berikut ini:
+ [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
### Mengaktifkan enkripsi dalam transit untuk klaster berbasis node yang ada menggunakan Konsol Manajemen AWS
Mengaktifkan enkripsi bergerak, adalah proses dua langkah, Anda harus terlebih dahulu mengatur mode enkripsi bergerak ke `preferred`. Mode ini memungkinkan klien Valkey atau Redis OSS Anda untuk terhubung menggunakan koneksi terenkripsi dan tidak terenkripsi. Setelah Anda memigrasikan semua klien Valkey atau Redis OSS Anda untuk menggunakan koneksi terenkripsi, Anda kemudian dapat memodifikasi konfigurasi cluster Anda untuk mengatur mode enkripsi transit ke. `required` Mengatur mode enkripsi bergerak ke `required` akan menghentikan semua koneksi yang tidak terenkripsi dan hanya akan mengizinkan koneksi terenkripsi.
**Setel **mode enkripsi Transit** Anda ke **Preferred****
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. Pilih cache **Valkey atau cache** **Redis OSS** dari ElastiCache **Sumber daya** yang tercantum di panel navigasi, hadir di sebelah kiri.
1. Pilih cache yang ingin Anda perbarui.
1. Pilih drop-down **Tindakan**, lalu pilih **Ubah**.
1. Pilih **Aktifkan** pada **Enkripsi bergerak** di bagian **Keamanan**.
1. Klik **Pilihan** sebagai **Mode enkripsi bergerak**.
1. Pilih **Pratinjau perubahan** dan simpan perubahan Anda.
Setelah Anda memigrasikan semua klien Valkey atau Redis OSS Anda untuk menggunakan koneksi terenkripsi:
**Setel **mode enkripsi Transit** Anda ke **Wajib****
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. Pilih cache **Valkey atau cache** **Redis OSS** dari ElastiCache **Sumber daya** yang tercantum di panel navigasi, hadir di sebelah kiri.
1. Pilih cache yang ingin Anda perbarui.
1. Pilih drop-down **Tindakan**, lalu pilih **Ubah**.
1. Pilih **Wajib** sebagai **Mode enkripsi bergerak**, di bagian **Keamanan**.
1. Pilih **Pratinjau perubahan** dan simpan perubahan Anda.
## Mengaktifkan enkripsi dalam transit menggunakan AWS CLI
Untuk mengaktifkan enkripsi dalam transit saat membuat grup replikasi Valkey atau Redis OSS menggunakan, gunakan parameter.AWS CLI`transit-encryption-enabled`
### Mengaktifkan enkripsi dalam transit pada cluster berbasis node baru untuk Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) (CLI)
Gunakan AWS CLI operasi `create-replication-group` dan parameter berikut untuk membuat grup replikasi Valkey atau Redis OSS dengan replika yang mengaktifkan enkripsi in-transit:
**Parameter kunci:**
+ **--engine**—Harus `valkey` atau`redis`.
+ **--engine-version**—Jika mesinnya Redis OSS, ini harus 3.2.6, 4.0.10 atau yang lebih baru.
+ **--transit-encryption-enabled**—Wajib. Jika Anda mengaktifkan enkripsi bergerak, Anda juga harus menyediakan nilai untuk parameter `--cache-subnet-group`.
+ **--num-cache-clusters**—Minimal bernilai 1. Nilai maksimum untuk parameter ini adalah enam.
Untuk informasi selengkapnya, lihat berikut ini:
+ [Membuat grup replikasi Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dari awal ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
### Mengaktifkan enkripsi dalam transit pada cluster berbasis node baru untuk Valkey atau Redis OSS (Mode Cluster Diaktifkan) (CLI)
Gunakan AWS CLI operasi `create-replication-group` dan parameter berikut untuk membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) yang mengaktifkan enkripsi in-transit:
**Parameter kunci:**
+ **--engine**—Harus `valkey` atau`redis`.
+ **--engine-version**—Jika mesinnya Redis OSS, ini harus 3.2.6, 4.0.10 atau yang lebih baru.
+ **--transit-encryption-enabled**—Wajib. Jika Anda mengaktifkan enkripsi bergerak, Anda juga harus menyediakan nilai untuk parameter `--cache-subnet-group`.
+ Gunakan salah satu set parameter berikut untuk menentukan konfigurasi grup simpul dari grup replikasi:
+ **--num-node-groups**—Menentukan jumlah serpihan (grup simpul) dalam grup replikasi ini. Nilai maksimum untuk parameter ini adalah 500.
**--replicas-per-node-group**—Menentukan jumlah simpul replika di setiap grup simpul. Nilai yang ditentukan di sini berlaku untuk semua serpihan dalam grup replikasi ini. Nilai maksimum untuk parameter ini adalah 5.
+ **--node-group-configuration**—Menentukan konfigurasi dari setiap serpihan secara independen.
Untuk informasi selengkapnya, lihat berikut ini:
+ [Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Enabled) dari awal ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
### Mengaktifkan enkripsi bergerak pada klaster yang sudah ada menggunakan AWS CLI
Mengaktifkan enkripsi bergerak, adalah proses dua langkah, Anda harus terlebih dahulu mengatur mode enkripsi bergerak ke `preferred`. Mode ini memungkinkan klien Valkey atau Redis OSS Anda untuk terhubung menggunakan koneksi terenkripsi dan tidak terenkripsi. Setelah Anda memigrasikan semua klien Valkey atau Redis OSS Anda untuk menggunakan koneksi terenkripsi, Anda kemudian dapat memodifikasi konfigurasi cluster Anda untuk mengatur mode enkripsi transit ke. `required` Mengatur mode enkripsi bergerak ke `required` akan menghentikan semua koneksi yang tidak terenkripsi dan hanya akan mengizinkan koneksi terenkripsi.
Gunakan AWS CLI operasi `modify-replication-group` dan parameter berikut untuk memperbarui grup replikasi Valkey atau Redis OSS (mode cluster enabled) yang memiliki enkripsi in-transit dinonaktifkan.
**Untuk mengaktifkan enkripsi bergerak**
1. Setel transit-encryption-mode ke`preferred`, menggunakan parameter berikut
+ **--transit-encryption-enabled**—Wajib.
+ **--transit-encryption-mode**—Harus diatur ke `preferred`.
1. Setel transit-encryption-mode ke`required`, menggunakan parameter berikut:
+ **--transit-encryption-enabled**—Wajib.
+ **--transit-encryption-mode**—Harus diatur ke `required`.
# Menghubungkan ke ElastiCache (Valkey) atau Amazon ElastiCache untuk Redis OSS dengan enkripsi dalam transit menggunakan valkey-cli
Untuk mengakses data dari ElastiCache cache Redis OSS yang diaktifkan dengan enkripsi dalam transit, Anda menggunakan klien yang bekerja dengan Secure Socket Layer (SSL). Anda juga dapat menggunakan valkey-cli dengan di TLS/SSL Amazon Linux dan Amazon Linux 2. Jika klien Anda tidak mendukung TLS, Anda dapat menggunakan `stunnel` perintah pada host klien Anda untuk membuat terowongan SSL ke node Redis OSS.
## Koneksi terenkripsi dengan Linux
Untuk menggunakan valkey-cli untuk terhubung ke klaster Valkey atau Redis OSS yang diaktifkan dengan enkripsi dalam transit di Amazon Linux 2 atau Amazon Linux, ikuti langkah-langkah berikut.
1. Unduh dan kompilasi utilitas valkey-cli. Utilitas ini termasuk dalam distribusi perangkat lunak Valkey.
1. Pada prompt perintah EC2 instance Anda, ketikkan perintah yang sesuai untuk versi Linux yang Anda gunakan.
**Amazon Linux 2**
Jika menggunakan Amazon Linux 2, masukkan ini:
```
sudo yum -y install openssl-devel gcc
wget https://github.com/valkey-io/valkey/archive/refs/tags/7.2.6.tar.gz
tar xvzf valkey-7.2.6.tar.gz
cd valkey-7.2.6
make distclean
make valkey-cli BUILD_TLS=yes
sudo install -m 755 src/valkey-cli /usr/local/bin/
```
**Amazon Linux**
Jika menggunakan Amazon Linux, masukkan ini:
```
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel clang wget
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make valkey-cli CC=clang BUILD_TLS=yes
sudo install -m 755 src/valkey-cli /usr/local/bin/
```
Di Amazon Linux, Anda mungkin perlu menjalankan langkah tambahan berikut:
```
sudo yum install clang
CC=clang make
sudo make install
```
1. Setelah Anda mengunduh dan menginstal utilitas valkey-cli, Anda disarankan untuk menjalankan perintah opsional. `make-test`
1. Untuk terhubung ke cluster dengan enkripsi dan otentikasi diaktifkan, masukkan perintah ini:
```
valkey-cli -h Primary or Configuration Endpoint --tls -a 'your-password' -p 6379
```
**catatan**
Jika Anda menginstal redis6 di Amazon Linux 2023, Anda sekarang dapat menggunakan `redis6-cli` perintah alih-alih: `valkey-cli`
```
redis6-cli -h Primary or Configuration Endpoint --tls -p 6379
```
## Koneksi terenkripsi dengan stunnel
Untuk menggunakan valkey-cli untuk terhubung ke cluster Redis OSS yang diaktifkan dengan enkripsi dalam transit menggunakan stunnel, ikuti langkah-langkah berikut.
1. Gunakan SSH untuk menghubungkan ke klien Anda dan instal `stunnel`.
```
sudo yum install stunnel
```
1. Jalankan perintah berikut untuk membuat dan mengedit file `'/etc/stunnel/valkey-cli.conf'` secara bersamaan untuk menambahkan titik akhir cluster Redis OSS untuk satu atau lebih parameter koneksi, menggunakan output yang disediakan di bawah ini sebagai template. ElastiCache
```
vi /etc/stunnel/valkey-cli.conf
fips = no
setuid = root
setgid = root
pid = /var/run/stunnel.pid
debug = 7
delay = yes
options = NO_SSLv2
options = NO_SSLv3
[valkey-cli]
client = yes
accept = 127.0.0.1:6379
connect = primary.ssltest.wif01h.use1.cache.amazonaws.com:6379
[valkey-cli-replica]
client = yes
accept = 127.0.0.1:6380
connect = ssltest-02.ssltest.wif01h.use1.cache.amazonaws.com:6379
```
Dalam contoh ini, file config memiliki dua koneksi, `valkey-cli` dan `valkey-cli-replica`. Parameternya ditetapkan sebagai berikut:
+ **client** ditetapkan ke ya untuk menentukan bahwa instans stunnel ini adalah klien.
+ **accept** ditetapkan ke IP klien. Dalam contoh ini, primer diatur ke default Redis OSS 127.0.0.1 pada port 6379. Replika harus memanggil port yang berbeda dan ditetapkan ke 6380. Anda dapat menggunakan port sementara 1024–65535. Untuk informasi selengkapnya, lihat [Port sementara](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html#VPC_ACLs_Ephemeral_Ports) dalam *Panduan Pengguna Amazon VPC.*
+ **connect** diatur ke titik akhir server Redis OSS. Untuk informasi selengkapnya, lihat [Menemukan titik akhir koneksi di ElastiCache](Endpoints.md).
1. Mulai `stunnel`.
```
sudo stunnel /etc/stunnel/valkey-cli.conf
```
Gunakan perintah `netstat` untuk mengonfirmasi bahwa tunnel dimulai.
```
sudo netstat -tulnp | grep -i stunnel
tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 3189/stunnel
tcp 0 0 127.0.0.1:6380 0.0.0.0:* LISTEN 3189/stunnel
```
1. Connect ke node Redis OSS terenkripsi menggunakan endpoint lokal terowongan.
+ Jika tidak ada kata sandi AUTH yang digunakan ElastiCache selama pembuatan klaster Redis OSS, contoh ini menggunakan valkey-cli untuk terhubung ke server Redis OSS untuk menggunakan jalur lengkap ElastiCache untuk valkey-cli, di Amazon Linux:
```
/home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379
```
Jika kata sandi AUTH digunakan selama pembuatan klaster Redis OSS, contoh ini menggunakan valkey-cli untuk terhubung ke server Redis OSS menggunakan jalur lengkap untuk valkey-cli, di Amazon Linux:
```
/home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 -a my-secret-password
```
ATAU
+ Ubah direktori ke redis-7.2.5 dan lakukan hal berikut:
Jika tidak ada kata sandi AUTH yang digunakan ElastiCache selama pembuatan klaster Redis OSS, contoh ini menggunakan valkey-cli untuk terhubung ke server Redis OSS untuk menggunakan jalur lengkap ElastiCache untuk valkey-cli, di Amazon Linux:
```
src/valkey-cli -h localhost -p 6379
```
Jika kata sandi AUTH digunakan selama pembuatan cluster Redis OSS, contoh ini menggunakan valkey-cli untuk terhubung ke server Valkey atau Redis OSS menggunakan jalur lengkap untuk valkey-cli, di Amazon Linux:
```
src/valkey-cli -h localhost -p 6379 -a my-secret-password
```
Contoh ini menggunakan Telnet untuk terhubung ke server Valkey Redis OSS.
```
telnet localhost 6379
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
auth MySecretPassword
+OK
get foo
$3
bar
```
1. Untuk menghentikan dan menutup tunnel SSL, jalankan `pkill` terhadap proses stunnel.
```
sudo pkill stunnel
```
# Mengaktifkan enkripsi dalam transit pada cluster Redis OSS berbasis node menggunakan Python
Panduan berikut akan menunjukkan cara mengaktifkan enkripsi dalam transit pada cluster Redis OSS 7.0 yang awalnya dibuat dengan enkripsi in-transit dinonaktifkan. Klien TCP dan TLS akan terus berkomunikasi dengan klaster selama proses ini tanpa waktu henti.
Boto3 akan mendapatkan kredensial yang dibutuhkannya (`aws_access_key_id`, `aws_secret_access_key`, dan `aws_session_token`) dari variabel lingkungan. Kredensial tersebut akan ditempelkan terlebih dahulu di terminal bash yang sama di tempat kita menjalankan `python3` untuk memproses kode Python yang ditunjukkan dalam panduan ini. Kode dalam contoh di bawah ini adalah proses dari sebuah EC2 instance yang diluncurkan di VPC yang sama yang akan digunakan untuk membuat ElastiCache Redis OSS Cluster di dalamnya.
**catatan**
Contoh berikut menggunakan boto3 SDK untuk operasi ElastiCache manajemen (kluster atau pembuatan pengguna) dan redis-py-cluster redis-py/ untuk penanganan data.
Anda harus menggunakan setidaknya boto3 versi (=\$1) 1.26.39 untuk menggunakan migrasi TLS online dengan API perubahan klaster.
ElastiCache mendukung migrasi TLS online hanya untuk cluster dengan Valkey versi 7.2 ke atas atau Redis OSS versi 7.0 atau lebih tinggi. Jadi jika Anda memiliki cluster yang menjalankan versi Redis OSS lebih awal dari 7.0, Anda harus memutakhirkan versi Redis OSS dari cluster Anda. Untuk informasi selengkapnya tentang perbedaan versi, lihat [Perilaku versi mesin utama dan perbedaan kompatibilitas dengan Redis OSS](VersionManagementConsiderations.md).
**Topics**
+ [Tentukan konstanta string yang akan meluncurkan ElastiCache Valkey atau Redis OSS Cluster](#enable-python-define-constants)
+ [Tentukan kelas untuk konfigurasi klaster](#enable-python-define-classes)
+ [Mendefinisikan kelas yang akan merepresentasikan klaster itu sendiri](#enable-python-define-classes-cluster)
+ [(Opsional) Buat kelas pembungkus untuk demo koneksi klien ke Valkey atau Redis OSS cluster](#enable-python-create-wrapper)
+ [Membuat fungsi utama yang mendemonstrasikan proses pengubahan konfigurasi enkripsi bergerak](#enable-python-main-function)
## Tentukan konstanta string yang akan meluncurkan ElastiCache Valkey atau Redis OSS Cluster
Pertama, mari kita mendefinisikan beberapa konstanta string Python sederhana yang akan menampung nama-nama AWS entitas yang diperlukan untuk membuat ElastiCache cluster seperti`security-group`,`Cache Subnet group`, dan a. `default parameter group` Semua AWS entitas ini harus dibuat terlebih dahulu di AWS akun Anda di Wilayah yang ingin Anda gunakan.
```
#Constants definitions
SECURITY_GROUP = "sg-0492aa0a29c558427"
CLUSTER_DESCRIPTION = "This cluster has been launched as part of the online TLS migration user guide"
EC_SUBNET_GROUP = "client-testing"
DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED = "default.redis7.cluster.on"
```
## Tentukan kelas untuk konfigurasi klaster
Sekarang, mari kita definisikan beberapa kelas Python sederhana yang akan mewakili konfigurasi cluster, yang akan menyimpan metadata tentang cluster seperti versi Valkey atau Redis OSS, jenis instance, dan apakah enkripsi in-transit (TLS) diaktifkan atau dinonaktifkan.
```
#Class definitions
class Config:
def __init__(
self,
instance_type: str = "cache.t4g.small",
version: str = "7.0",
multi_az: bool = True,
TLS: bool = True,
name: str = None,
):
self.instance_type = instance_type
self.version = version
self.multi_az = multi_az
self.TLS = TLS
self.name = name or f"tls-test"
def create_base_launch_request(self):
return {
"ReplicationGroupId": self.name,
"TransitEncryptionEnabled": self.TLS,
"MultiAZEnabled": self.multi_az,
"CacheNodeType": self.instance_type,
"Engine": "redis",
"EngineVersion": self.version,
"CacheSubnetGroupName": EC_SUBNET_GROUP ,
"CacheParameterGroupName": DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED ,
"ReplicationGroupDescription": CLUSTER_DESCRIPTION,
"SecurityGroupIds": [SECURITY_GROUP],
}
class ConfigCME(Config):
def __init__(
self,
instance_type: str = "cache.t4g.small",
version: str = "7.0",
multi_az: bool = True,
TLS: bool = True,
name: str = None,
num_shards: int = 2,
num_replicas_per_shard: int = 1,
):
super().__init__(instance_type, version, multi_az, TLS, name)
self.num_shards = num_shards
self.num_replicas_per_shard = num_replicas_per_shard
def create_launch_request(self) -> dict:
launch_request = self.create_base_launch_request()
launch_request["NumNodeGroups"] = self.num_shards
launch_request["ReplicasPerNodeGroup"] = self.num_replicas_per_shard
return launch_request
```
## Mendefinisikan kelas yang akan merepresentasikan klaster itu sendiri
Sekarang, mari kita mendefinisikan beberapa kelas Python sederhana yang akan mewakili ElastiCache Valkey atau Redis OSS Cluster itu sendiri. Kelas ini akan memiliki bidang klien yang akan menampung klien boto3 untuk operasi ElastiCache manajemen seperti membuat cluster dan query API. ElastiCache
```
import botocore.config
import boto3
# Create boto3 client
def init_client(region: str = "us-east-1"):
config = botocore.config.Config(retries={"max_attempts": 10, "mode": "standard"})
init_request = dict()
init_request["config"] = config
init_request["service_name"] = "elasticache"
init_request["region_name"] = region
return boto3.client(**init_request)
class ElastiCacheClusterBase:
def __init__(self, name: str):
self.name = name
self.elasticache_client = init_client()
def get_first_replication_group(self):
return self.elasticache_client.describe_replication_groups(
ReplicationGroupId=self.name
)["ReplicationGroups"][0]
def get_status(self) -> str:
return self.get_first_replication_group()["Status"]
def get_transit_encryption_enabled(self) -> bool:
return self.get_first_replication_group()["TransitEncryptionEnabled"]
def is_available(self) -> bool:
return self.get_status() == "available"
def is_modifying(self) -> bool:
return self.get_status() == "modifying"
def wait_for_available(self):
while True:
if self.is_available():
break
else:
time.sleep(5)
def wait_for_modifying(self):
while True:
if self.is_modifying():
break
else:
time.sleep(5)
def delete_cluster(self) -> bool:
self.elasticache_client.delete_replication_group(
ReplicationGroupId=self.name, RetainPrimaryCluster=False
)
def modify_transit_encryption_mode(self, new_transit_encryption_mode: str):
# generate api call to migrate the cluster to TLS preffered or to TLS required
self.elasticache_client.modify_replication_group(
ReplicationGroupId=self.name,
TransitEncryptionMode=new_transit_encryption_mode,
TransitEncryptionEnabled=True,
ApplyImmediately=True,
)
self.wait_for_modifying()
class ElastiCacheClusterCME(ElastiCacheClusterBase):
def __init__(self, name: str):
super().__init__(name)
@classmethod
def launch(cls, config: ConfigCME = None) -> ElastiCacheClusterCME:
config = config or ConfigCME()
print(config)
new_cluster = ElastiCacheClusterCME(config.name)
launch_request = config.create_launch_request()
new_cluster.elasticache_client.create_replication_group(**launch_request)
new_cluster.wait_for_available()
return new_cluster
def get_configuration_endpoint(self) -> str:
return self.get_first_replication_group()["ConfigurationEndpoint"]["Address"]
#Since the code can throw exceptions, we define this class to make the code more readable and
#so we won't forget to delete the cluster
class ElastiCacheCMEManager:
def __init__(self, config: ConfigCME = None):
self.config = config or ConfigCME()
def __enter__(self) -> ElastiCacheClusterCME:
self.cluster = ElastiCacheClusterCME.launch(self.config)
return self.cluster
def __exit__(self, exc_type, exc_val, exc_tb):
self.cluster.delete_cluster()
```
## (Opsional) Buat kelas pembungkus untuk demo koneksi klien ke Valkey atau Redis OSS cluster
Sekarang, mari kita buat kelas wrapper untuk klien `redis-py-cluster`. Kelas wrapper ini akan mendukung pra-pengisian klaster dengan beberapa kunci lalu melakukan perintah `get` acak berulang.
**catatan**
Ini adalah langkah opsional tetapi menyederhanakan kode fungsi utama yang muncul pada langkah selanjutnya.
```
import redis
improt random
from time import perf_counter_ns, time
class DowntimeTestClient:
def __init__(self, client):
self.client = client
# num of keys prefilled
self.prefilled = 0
# percent of get above prefilled
self.percent_get_above_prefilled = 10 # nil result expected when get hit above prefilled
# total downtime in nano seconds
self.downtime_ns = 0
# num of success and fail operations
self.success_ops = 0
self.fail_ops = 0
self.connection_errors = 0
self.timeout_errors = 0
def replace_client(self, client):
self.client = client
def prefill_data(self, timelimit_sec=60):
end_time = time() + timelimit_sec
while time() < end_time:
self.client.set(self.prefilled, self.prefilled)
self.prefilled += 1
# unsuccesful operations throw exceptions
def _exec(self, func):
try:
start_ns = perf_counter_ns()
func()
self.success_ops += 1
elapsed_ms = (perf_counter_ns() - start_ns) // 10 ** 6
# upon succesful execution of func
# reset random_key to None so that the next command
# will use a new random key
self.random_key = None
except Exception as e:
elapsed_ns = perf_counter_ns() - start_ns
self.downtime_ns += elapsed_ns
# in case of failure- increment the relevant counters so that we will keep track
# of how many connection issues we had while trying to communicate with
# the cluster.
self.fail_ops += 1
if e.__class__ is redis.exceptions.ConnectionError:
self.connection_errors += 1
if e.__class__ is redis.exceptions.TimeoutError:
self.timeout_errors += 1
def _repeat_exec(self, func, seconds):
end_time = time() + seconds
while time() < end_time:
self._exec(func)
def _new_random_key_if_needed(self, percent_above_prefilled):
if self.random_key is None:
max = int((self.prefilled * (100 + percent_above_prefilled)) / 100)
return random.randint(0, max)
return self.random_key
def _random_get(self):
key = self._new_random_key_if_needed(self.percent_get_above_prefilled)
result = self.client.get(key)
# we know the key was set for sure only in the case key < self.prefilled
if key < self.prefilled:
assert result.decode("UTF-8") == str(key)
def repeat_get(self, seconds=60):
self._repeat_exec(self._random_get, seconds)
def get_downtime_ms(self) -> int:
return self.downtime_ns // 10 ** 6
def do_get_until(self, cond_check):
while not cond_check():
self.repeat_get()
# do one more get cycle once condition is met
self.repeat_get()
```
## Membuat fungsi utama yang mendemonstrasikan proses pengubahan konfigurasi enkripsi bergerak
Sekarang, mari kita definisikan fungsi utama, yang akan melakukan hal berikut:
1. Buat cluster menggunakan klien boto3 ElastiCache .
1. Inisialisasi klien `redis-py-cluster` yang akan terhubung ke klaster dengan koneksi TCP yang jelas tanpa TLS.
1. klien `redis-py-cluster` mengisi klaster dengan beberapa data.
1. Klien boto3 akan memicu migrasi TLS dari tanpa TLS ke TLS diutamakan.
1. Sementara klaster sedang dimigrasikan ke TLS `Preferred`, klien `redis-py-cluster` TCP akan mengirim operasi `get` berulang ke klaster sampai migrasi selesai.
1. Setelah migrasi ke mode TLS `Preferred` selesai, kita akan memastikan bahwa klaster mendukung enkripsi bergerak. Setelah itu, kita akan membuat klien `redis-py-cluster` yang akan terhubung ke klaster dengan TLS.
1. Kita akan mengirim beberapa perintah `get` menggunakan klien TLS baru dan klien TCP lama.
1. Klien boto3 akan memicu migrasi TLS dari TLS `Preferred` ke TLS diperlukan.
1. Sementara cluster sedang dimigrasikan ke TLS diperlukan, klien redis-py-cluster TLS akan mengirim `get` operasi berulang ke cluster sampai migrasi selesai.
```
import redis
def init_cluster_client(
cluster: ElastiCacheClusterCME, prefill_data: bool, TLS: bool = True) -> DowntimeTestClient:
# we must use for the host name the cluster configuration endpoint.
redis_client = redis.RedisCluster(
host=cluster.get_configuration_endpoint(), ssl=TLS, socket_timeout=0.25, socket_connect_timeout=0.1
)
test_client = DowntimeTestClient(redis_client)
if prefill_data:
test_client.prefill_data()
return test_client
if __name__ == '__main__':
config = ConfigCME(TLS=False, instance_type="cache.m5.large")
with ElastiCacheCMEManager(config) as cluster:
# create a client that will connect to the cluster with clear tcp connection
test_client_tcp = init_cluster_client(cluster, prefill_data=True, TLS=False)
# migrate the cluster to TLS Preferred
cluster.modify_transit_encryption_mode(new_transit_encryption_mode="preferred")
# do repeated get commands until the cluster finishes the migration to TLS Preferred
test_client_tcp.do_get_until(cluster.is_available)
# verify that in transit encryption is enabled so that clients will be able to connect to the cluster with TLS
assert cluster.get_transit_encryption_enabled() == True
# create a client that will connect to the cluster with TLS connection.
# we must first make sure that the cluster indeed supports TLS
test_client_tls = init_cluster_client(cluster, prefill_data=True, TLS=True)
# by doing get commands with the tcp client for 60 more seconds
# we can verify that the existing tcp connection to the cluster still works
test_client_tcp.repeat_get(seconds=60)
# do get commands with the new TLS client for 60 more seconds
test_client_tcp.repeat_get(seconds=60)
# migrate the cluster to TLS required
cluster.modify_transit_encryption_mode(new_transit_encryption_mode="required")
# from this point the tcp clients will be disconnected and we must not use them anymore.
# do get commands with the TLS client until the cluster finishes migartion to TLS required mode.
test_client_tls.do_get_until(cluster.is_available)
```
# Praktik terbaik saat mengaktifkan enkripsi bergerak
## Sebelum mengaktifkan enkripsi bergerak: pastikan Anda memiliki penanganan catatan DNS yang tepat
**catatan**
Kita akan mengubah dan menghapus titik akhir lama selama proses ini. Penggunaan titik akhir yang salah dapat mengakibatkan klien Valkey atau Redis OSS menggunakan titik akhir lama dan yang dihapus yang akan mencegahnya terhubung ke cluster.
Sementara cluster sedang dimigrasikan dari No-TLS ke TLS-preferen, catatan DNS titik akhir konfigurasi cluster lama disimpan dan catatan DNS titik akhir konfigurasi cluster baru sedang dihasilkan dalam format yang berbeda. Cluster yang mendukung TLS menggunakan format catatan DNS yang berbeda dari kluster yang dinonaktifkan TLS. ElastiCache akan menyimpan kedua catatan DNS ketika cluster dikonfigurasi `encryption mode: Preferred` sehingga Aplikasi dan klien Valkey atau Redis OSS lainnya dapat beralih di antara mereka. Perubahan dalam catatan DNS berikut terjadi selama proses migrasi TLS:
### Deskripsi perubahan dalam catatan DNS yang terjadi saat mengaktifkan enkripsi bergerak
**Untuk klaster CME**
Ketika sebuah klaster diatur ke 'mode enkripsi bergerak: pilihan':
+ Titik akhir konfigurasi cluster asli untuk cluster No-TLS akan tetap aktif. Tidak akan ada waktu henti ketika klaster dikonfigurasi ulang dari mode enkripsi TLS 'tidak ada' ke 'diutamakan'.
+ Titik akhir TLS Valkey atau Redis OSS baru akan dihasilkan saat cluster diatur ke mode pilihan TLS. Titik akhir baru ini akan menyelesaikan IPs sama dengan yang lama (non-TLS).
+ Titik akhir konfigurasi TLS Valkey atau Redis OSS yang baru akan diekspos di ElastiCache Konsol dan sebagai respons terhadap API. `describe-replication-group`
Ketika sebuah klaster diatur ke 'mode enkripsi bergerak: wajib':
+ Titik akhir lama non-TLS akan dihapus. Tidak akan ada waktu henti pada titik akhir klaster TLS.
+ Anda dapat mengambil yang baru `cluster-configuration-endpoint` dari ElastiCache Console atau dari `describe-replication-group` API.
**Untuk klaster CMD dengan Failover Otomatis aktif atau Failover Otomatis nonaktif**
Ketika grup replikasi diatur ke 'mode enkripsi bergerak: pilihan':
+ Titik akhir primer asli dan titik akhir pembaca untuk klaster non-TLS akan tetap aktif.
+ Titik akhir primer dan pembaca TLS baru akan dihasilkan saat klaster diatur ke mode TLS `Preferred`. Titik akhir baru ini akan diresolusi ke IP yang sama dengan yang lama (non-TLS).
+ Titik akhir utama dan titik akhir pembaca yang baru akan diekspos di ElastiCache Konsol dan sebagai respons terhadap API. `describe-replication-group`
Ketika grup replikasi diatur ke 'mode enkripsi bergerak: wajib':
+ Titik akhir primer dan pembaca non-TLS lama akan dihapus. Tidak akan ada waktu henti pada titik akhir klaster TLS.
+ Anda dapat mengambil titik akhir primer dan pembaca baru dari ElastiCache Console atau dari API. `describe-replication-group`
### Penggunaan catatan DNS yang disarankan
**Untuk klaster CME**
+ Gunakan titik akhir konfigurasi klaster, bukan catatan DNS per simpul dalam kode aplikasi Anda. Menggunakan nama DNS per-node secara langsung tidak disarankan karena selama migrasi mereka akan berubah dan kode aplikasi akan memutuskan koneksi ke cluster.
+ Jangan hardcode endpoint konfigurasi cluster di aplikasi Anda, karena akan berubah selama proses ini.
+ Memiliki endpoint konfigurasi cluster yang di-hardcode dalam aplikasi Anda adalah praktik yang buruk, karena dapat diubah selama proses ini. Setelah enkripsi dalam transit selesai, kueri titik akhir konfigurasi cluster dengan `describe-replication-group` API (seperti yang ditunjukkan di atas (dalam huruf tebal)) dan gunakan DNS yang Anda dapatkan sebagai respons sejak saat itu.
**Untuk klaster CMD dengan Failover Otomatis aktif **
+ Gunakan titik akhir primer dan titik akhir pembaca, bukan nama DNS per simpul dalam kode aplikasi Anda karena nama DNS per simpul yang lama dihapus dan yang baru akan dihasilkan saat memigrasikan klaster dari mode tanpa TLS ke mode TLS diutamakan. Penggunaan nama DNS per simpul secara langsung tidak direkomendasikan karena Anda mungkin akan menambahkan replika ke klaster Anda nanti. Selain itu, ketika Failover Otomatis diaktifkan, peran klaster utama dan replika diubah secara otomatis oleh ElastiCache layanan, menggunakan titik akhir utama dan titik akhir pembaca disarankan untuk membantu Anda melacak perubahan tersebut. Terakhir, menggunakan titik akhir pembaca akan membantu Anda mendistribusikan operasi baca Anda dari replika secara merata di antara replika di klaster.
+ Memiliki titik akhir primer dan titik akhir pembaca yang di-hardcoding di aplikasi Anda adalah praktik yang buruk karena titik akhir tersebut dapat berubah selama proses migrasi TLS. Setelah perubahan migrasi ke pilihan TLS selesai, kueri titik akhir utama dan titik akhir pembaca dengan describe-replication-group API dan gunakan DNS yang Anda dapatkan sebagai tanggapan mulai saat ini. Dengan cara ini, Anda dapat melacak perubahan titik akhir secara dinamis.
**Untuk klaster CMD dengan Failover Otomatis nonaktif **
+ Gunakan titik akhir primer dan titik akhir pembaca, bukan nama DNS per simpul dalam kode aplikasi Anda. Saat Failover Otomatis dinonaktifkan, penskalaan, penambalan, failover, dan prosedur lain yang dikelola secara otomatis oleh ElastiCache layanan saat Failover Otomatis diaktifkan akan dilakukan oleh Anda. Hal ini memudahkan Anda untuk melacak titik akhir yang berbeda-beda secara manual. Karena nama DNS per simpul yang lama dihapus dan yang baru akan dihasilkan saat memigrasikan klaster dari mode tanpa TLS ke mode TLS diutamakan, jangan gunakan nama DNS per simpul secara langsung. Hal ini wajib dilakukan agar klien dapat terhubung ke klaster selama migrasi TLS. Selain itu, Anda akan mendapatkan manfaat dengan menyebarkan permintaan baca secara merata di antara replika saat menggunakan titik akhir pembaca dan melacak catatan DNS saat menambahkan atau menghapus replika dari klaster.
+ Memiliki titik akhir konfigurasi klaster yang di-hardcoding di aplikasi Anda adalah praktik yang buruk karena titik akhir tersebut dapat berubah selama proses migrasi TLS.
## Selama enkripsi bergerak: perhatikan kapan proses migrasi selesai
Perubahan mode enkripsi bergerak tidak diterapkan segera dan dapat memakan waktu. Hal ini terutama berlaku untuk klaster besar. Hanya setelah menyelesaikan migrasi ke mode TLS diutamakan, klaster ini dapat menerima dan melayani koneksi TCP dan TLS. Oleh karena itu, Anda sebaiknya tidak membuat klien yang akan mencoba membuat koneksi TLS ke klaster sampai enkripsi bergerak selesai.
Ada beberapa cara untuk mendapatkan notifikasi ketika enkripsi bergerak berhasil diselesaikan atau gagal: (Tidak ditampilkan dalam contoh kode di atas):
+ Menggunakan layanan SNS untuk mendapatkan notifikasi saat enkripsi selesai
+ Menggunakan API `describe-events` yang akan memublikasikan peristiwa saat enkripsi selesai
+ Melihat pesan di ElastiCache Konsol bahwa enkripsi selesai
Anda juga dapat menerapkan logika dalam aplikasi Anda untuk mengetahui apakah enkripsi selesai. Pada contoh di atas, kita melihat beberapa cara untuk memastikan klaster menyelesaikan migrasi:
+ Menunggu hingga proses migrasi dimulai (status klaster berubah menjadi "mengubah"), dan menunggu hingga perubahan selesai (status klaster berubah kembali ke "tersedia")
+ Memastikan bahwa klaster telah mengatur `transit_encryption_enabled` ke True dengan mengueri API `describe-replication-group`.
### Setelah mengaktifkan enkripsi bergerak: pastikan klien yang Anda gunakan dikonfigurasi dengan benar
Saat klaster berada dalam mode TLS diutamakan, aplikasi Anda harus membuka koneksi TLS ke klaster dan hanya menggunakan koneksi tersebut. Dengan begitu, aplikasi Anda tidak akan mengalami waktu henti saat sedang mengaktifkan enkripsi bergerak. Anda dapat memastikan bahwa tidak ada koneksi TCP yang lebih jelas ke mesin Valkey atau Redis OSS menggunakan perintah info di bawah bagian SSL.
```
# SSL
ssl_enabled:yes
ssl_current_certificate_not_before_date:Mar 20 23:27:07 2017 GMT
ssl_current_certificate_not_after_date:Feb 24 23:27:07 2117 GMT
ssl_current_certificate_serial:D8C7DEA91E684163
tls_mode_connected_tcp_clients:0 (should be zero)
tls_mode_connected_tls_clients:100
```
## Menghubungkan ke node diaktifkan dengan enkripsi dalam transit menggunakan Openssl (Memcached)
Untuk mengakses data dari ElastiCache node Memcached yang diaktifkan dengan enkripsi dalam transit, Anda perlu menggunakan klien yang bekerja dengan Secure Socket Layer (SSL). Anda juga dapat menggunakan s\$1client Openssl di Amazon Linux dan Amazon Linux 2.
Untuk menggunakan s\$1client Openssl untuk terhubung ke klaster Memcached dengan enkripsi bergerak diaktifkan di Amazon Linux 2 atau Amazon Linux:
```
/usr/bin/openssl s_client -connect memcached-node-endpoint:memcached-port
```
## Membuat klien Memcached TLS menggunakan Java
Untuk membuat klien dalam mode TLS, lakukan hal berikut untuk menginisialisasi klien dengan yang sesuai: SSLContext
```
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
public static void main(String[] args) throws Exception {
ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
// Build SSLContext
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init((KeyStore) null);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
// Create the client in TLS mode
connectionFactoryBuilder.setSSLContext(sslContext);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster.fnjyzo.cfg.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Membuat klien Memcached TLS menggunakan PHP
Untuk membuat klien dalam mode TLS, lakukan hal berikut untuk menginisialisasi klien dengan yang sesuai: SSLContext
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
/* Add the memcached's cluster server/s */
$tls_client->addServer($server_endpoint, $server_port);
/* Configure the client to use TLS */
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
/* Set your TLS context configurations values.
* See MemcachedTLSContextConfig in memcached-api.php for all configurations */
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.mycluster.fnjyzo.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
/* Use the created TLS context configuration object to create OpenSSL's SSL_CTX and set it to your client.
* Note: These TLS context configurations will be applied to all the servers connected to this client. */
$tls_client->createAndSetTLSContext((array)$tls_config);
/* test the TLS connection with set-get scenario: */
/* store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
if($tls_client->set('key', 'value', 60)) {
print "Successfully stored key\n";
} else {
echo "Failed to set key: ", $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
/* retrieve the key */
if ($tls_client->get('key') === 'value') {
print "Successfully retrieved key\n";
} else {
echo "Failed to get key: ", $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
```
Untuk informasi selengkapnya tentang menggunakan klien PHP, lihat [Menginstal klien ElastiCache cluster untuk PHP](Appendix.PHPAutoDiscoverySetup.md).
# Enkripsi At-Rest di ElastiCache
Untuk membantu menjaga keamanan data Anda, Amazon ElastiCache dan Amazon S3 menyediakan berbagai cara untuk membatasi akses ke data di cache Anda. Untuk informasi selengkapnya, lihat [Amazon VPCs dan ElastiCache keamanan](VPCs.md) dan [Identity and Access Management untuk Amazon ElastiCache](IAM.md).
ElastiCache enkripsi at-rest adalah fitur untuk meningkatkan keamanan data dengan mengenkripsi data on-disk. Fitur ini selalu diaktifkan di cache nirserver. Saat diaktifkan, fitur ini mengenkripsi aspek-aspek berikut:
+ Disk selama operasi sinkronisasi, pencadangan, dan swap
+ Cadangan yang disimpan di Amazon S3
Data yang disimpan pada SSDs (solid-state drive) dalam cluster yang diaktifkan tiering data selalu dienkripsi.
ElastiCache menawarkan enkripsi default (dikelola layanan) saat istirahat, serta kemampuan untuk menggunakan kunci KMS yang dikelola pelanggan simetris Anda sendiri di [Layanan Manajemen AWS Kunci (AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)). Saat cache dicadangkan, di bagian opsi enkripsi, pilih apakah akan menggunakan kunci enkripsi default atau kunci yang dikelola pelanggan. Untuk informasi selengkapnya, lihat [Mengaktifkan Enkripsi Diam](#at-rest-encryption-enable).
**penting**
Mengaktifkan Enkripsi At-Rest pada cluster Valkey atau Redis OSS berbasis node yang ada melibatkan penghapusan grup replikasi Anda yang ada, **setelah** menjalankan pencadangan dan pemulihan pada grup replikasi.
Enkripsi diam dapat diaktifkan di cache hanya pada saat pembuatannya. Karena diperlukan beberapa pemrosesan untuk mengenkripsi dan mendekripsi data, mengaktifkan enkripsi diam dapat berdampak pada performa selama operasi ini. Anda harus membandingkan data Anda menggunakan dan tidak menggunakan enkripsi diam untuk menentukan dampaknya terhadap performa untuk kasus penggunaan Anda.
**Topics**
+ [Kondisi Enkripsi Diam](#at-rest-encryption-constraints)
+ [Menggunakan kunci yang dikelola pelanggan dari AWS KMS](#using-customer-managed-keys-for-elasticache-security)
+ [Mengaktifkan Enkripsi Diam](#at-rest-encryption-enable)
+ [Lihat Juga](#at-rest-encryption-see-also)
## Kondisi Enkripsi Diam
Kendala berikut pada enkripsi ElastiCache saat istirahat harus diingat ketika Anda merencanakan implementasi enkripsi saat istirahat: ElastiCache
+ Enkripsi AT-rest didukung pada grup replikasi yang menjalankan Valkey 7.2 dan yang lebih baru, dan versi Redis OSS (3.2.6 dijadwalkan untuk EOL, lihat jadwal akhir masa pakai versi [Redis OSS](engine-versions.md#deprecated-engine-versions)), 4.0.10 atau yang lebih baru.
+ Enkripsi diam didukung hanya untuk grup replikasi yang berjalan di Amazon VPC.
+ Enkripsi diam hanya didukung untuk grup replikasi yang menjalankan jenis simpul berikut.
+ R7g, R6gd, R6g, R5, R4, R3
+ M7g, M6g, M5, M4, M3
+ T4g, T3, T2
+ C7gN
Untuk informasi selengkapnya, lihat [Jenis simpul yang didukung](CacheNodes.SupportedTypes.md)
+ Enkripsi diam diaktifkan dengan menetapkan parameter `AtRestEncryptionEnabled` ke `true` secara eksplisit.
+ Anda dapat mengaktifkan enkripsi diam pada grup replikasi hanya saat membuat grup replikasi. Anda tidak dapat mengaktifkan dan menonaktifkan enkripsi diam dengan mengubah grup replikasi. Untuk informasi tentang cara menerapkan enkripsi diam pada grup replikasi yang sudah ada, lihat [Mengaktifkan Enkripsi Diam](#at-rest-encryption-enable).
+ Jika klaster menggunakan jenis simpul dari keluarga r6gd, data yang disimpan di SSD dienkripsi baik apakah enkripsi diam diaktifkan atau tidak.
+ Opsi untuk menggunakan kunci terkelola pelanggan untuk enkripsi saat istirahat tidak tersedia di AWS GovCloud (us-gov-east-1 dan us-gov-west -1) wilayah.
+ Jika cluster menggunakan tipe node dari keluarga r6gd, data yang disimpan di SSD dienkripsi dengan kunci AWS KMS terkelola pelanggan yang dipilih (atau enkripsi yang dikelola layanan di Wilayah).AWS GovCloud
+ Dengan Memcached, enkripsi saat istirahat hanya didukung pada cache tanpa server.
+ Saat menggunakan Memcached, opsi untuk menggunakan kunci terkelola pelanggan untuk enkripsi saat istirahat tidak tersedia di AWS GovCloud (us-gov-east-1 dan us-gov-west -1) wilayah.
Menerapkan enkripsi diam dapat menurunkan performa selama operasi pencadangan dan sinkronisasi simpul. Lakukan tolok ukur enkripsi diam dibandingkan dengan tanpa enkripsi pada data Anda sendiri untuk menentukan dampaknya terhadap performa untuk implementasi Anda.
## Menggunakan kunci yang dikelola pelanggan dari AWS KMS
ElastiCache mendukung kunci AWS KMS yang dikelola pelanggan simetris (kunci KMS) untuk enkripsi saat istirahat. Kunci KMS yang dikelola pelanggan adalah kunci enkripsi yang Anda buat, miliki, dan kelola di akun Anda.AWS Untuk informasi selengkapnya, lihat [Kunci AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) dalam *Panduan Developer untuk AWS Key Management Service*. Kunci harus dibuat di AWS KMS sebelum dapat digunakan. ElastiCache
Untuk mempelajari cara membuat kunci root AWS KMS, lihat [Membuat Kunci](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) di *Panduan Pengembang Layanan Manajemen AWS Kunci*.
ElastiCache memungkinkan Anda untuk berintegrasi dengan AWS KMS. Untuk informasi selengkapnya, lihat [Menggunakan Grant](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) dalam *Panduan Developer AWS Key Management Service*. Tidak diperlukan tindakan pelanggan untuk mengaktifkan ElastiCache integrasi Amazon dengan AWS KMS.
Kunci `kms:ViaService` kondisi membatasi penggunaan kunci AWS KMS (kunci KMS) untuk permintaan dari layanan tertentu AWS. Untuk digunakan `kms:ViaService` dengan ElastiCache, sertakan kedua ViaService nama dalam nilai kunci kondisi: `elasticache.AWS_region.amazonaws.com` dan`dax.AWS_region.amazonaws.com`. Untuk informasi lebih lanjut, lihat [kms: ViaService](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service).
Anda dapat menggunakan [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)untuk melacak permintaan yang ElastiCache dikirimkan AWS Key Management Service Amazon atas nama Anda. Semua panggilan API yang AWS Key Management Service terkait dengan kunci yang dikelola pelanggan memiliki CloudTrail log yang sesuai. Anda juga dapat melihat hibah yang ElastiCache dibuat dengan memanggil panggilan API [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)KMS.
Setelah grup replikasi dienkripsi menggunakan kunci yang dikelola pelanggan, semua cadangan untuk grup replikasi akan dienkripsi sebagai berikut:
+ Cadangan harian otomatis dienkripsi menggunakan kunci yang dikelola pelanggan yang terkait dengan klaster.
+ Cadangan akhir yang dibuat saat grup replikasi dihapus, juga dienkripsi menggunakan kunci yang dikelola pelanggan yang terkait dengan grup replikasi.
+ Cadangan yang dibuat secara manual dienkripsi secara default untuk menggunakan kunci KMS yang terkait dengan grup replikasi. Anda dapat menggantinya dengan memilih kunci dikelola pelanggan yang lain.
+ Jika cadangan disalin, kunci yang dikelola pelanggan yang terkait dengan cadangan sumber akan secara default digunakan. Anda dapat menggantinya dengan memilih kunci dikelola pelanggan yang lain.
**catatan**
Kunci yang dikelola pelanggan tidak dapat digunakan saat mengekspor cadangan ke bucket Amazon S3 pilihan Anda. Namun, semua cadangan yang diekspor ke Amazon S3 akan dienkripsi menggunakan [Enkripsi sisi server.](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) Anda dapat memilih untuk menyalin file cadangan ke objek S3 baru dan mengenkripsi menggunakan kunci KMS yang dikelola pelanggan, menyalin file ke bucket S3 lain yang diatur dengan enkripsi default menggunakan kunci KMS atau mengubah opsi enkripsi dalam file itu sendiri.
Anda juga dapat menggunakan kunci yang dikelola pelanggan untuk mengenkripsi cadangan yang dibuat secara manual untuk grup replikasi yang tidak menggunakan kunci yang dikelola pelanggan untuk enkripsi. Dengan opsi ini, file cadangan yang disimpan di Amazon S3 akan dienkripsi menggunakan kunci KMS, meskipun data tersebut tidak dienkripsi pada grup replikasi yang asli.
Memulihkan dari cadangan memungkinkan Anda memilih opsi enkripsi yang tersedia, mirip dengan pilihan enkripsi yang tersedia saat membuat grup replikasi baru.
+ Jika Anda menghapus kunci atau [menonaktifkan](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) kunci dan [mencabut grant](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html) untuk kunci yang digunakan untuk mengenkripsi cache, cache menjadi tidak dapat dipulihkan. Dengan kata lain, itu tidak dapat dimodifikasi atau dipulihkan setelah kegagalan perangkat keras.AWS KMS menghapus kunci root hanya setelah masa tunggu setidaknya tujuh hari. Setelah kunci dihapus, Anda dapat menggunakan kunci yang dikelola pelanggan yang berbeda untuk membuat cadangan untuk tujuan pengarsipan.
+ Rotasi kunci otomatis mempertahankan properti kunci root AWS KMS Anda, sehingga rotasi tidak berpengaruh pada kemampuan Anda untuk mengakses data Anda ElastiCache . ElastiCache Cache Amazon terenkripsi tidak mendukung rotasi kunci manual, yang melibatkan pembuatan kunci root baru dan memperbarui referensi apa pun ke kunci lama. Untuk mempelajari selengkapnya, lihat [Memutar kunci AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) di Panduan *Pengembang Layanan Manajemen AWS Kunci*.
+ Mengenkripsi ElastiCache cache menggunakan kunci KMS memerlukan satu hibah per cache. Grant ini digunakan sepanjang masa pakai cache. Selain itu, satu grant per cadangan digunakan selama pembuatan cadangan. Grant ini dipensiunkan setelah cadangan dibuat.
+ Untuk informasi selengkapnya tentang AWS hibah dan batasan KMS, lihat [Batas](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) dalam Panduan *Pengembang Layanan Manajemen AWS Utama*.
## Mengaktifkan Enkripsi Diam
Semua cache nirserver memiliki enkripsi diam yang aktif.
Saat membuat cluster berbasis node, Anda dapat mengaktifkan enkripsi saat istirahat dengan menyetel parameter ke. `AtRestEncryptionEnabled` `true` Anda tidak dapat mengaktifkan enkripsi diam di grup replikasi yang ada.
Anda dapat mengaktifkan enkripsi saat Anda membuat ElastiCache cache. Anda dapat melakukannya dengan menggunakan Konsol Manajemen AWS, the AWS CLI, atau ElastiCache API.
Saat membuat cache, Anda dapat memilih salah satu opsi berikut:
+ **Default** – Opsi ini menggunakan enkripsi diam yang dikelola layanan.
+ **Kunci terkelola pelanggan** - Opsi ini memungkinkan Anda untuk memberikan Kunci ID/ARN dari AWS KMS untuk enkripsi saat istirahat.
Untuk mempelajari cara membuat kunci root AWS KMS, lihat [Membuat Kunci](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) di Panduan *Pengembang Layanan Manajemen AWS Kunci*
**Contents**
+ [Mengaktifkan Enkripsi At-Rest Menggunakan Konsol Manajemen AWS](#at-rest-encryption-enable-con)
+ [Mengaktifkan Enkripsi At-Rest Menggunakan AWS CLI](#at-rest-encryption-enable-cli)
### Mengaktifkan Enkripsi At-Rest pada Valkey atau Redis OSS Cluster berbasis node yang ada
Anda hanya dapat mengaktifkan enkripsi saat Anda membuat grup replikasi Valkey atau Redis OSS. Jika Anda memiliki grup replikasi yang ada tempat Anda ingin mengaktifkan enkripsi diam, lakukan hal berikut.
**Untuk mengaktifkan enkripsi diam pada grup replikasi yang ada**
1. Buat cadangan manual dari grup replikasi yang ada. Untuk informasi selengkapnya, lihat [Membuat cadangan manual](backups-manual.md).
1. Buat grup replikasi baru dengan memulihkan dari cadangan. Pada grup replikasi baru, aktifkan enkripsi diam. Untuk informasi selengkapnya, lihat [Melakukan pemulihan dari cadangan ke dalam cache baru](backups-restoring.md).
1. Perbarui titik akhir dalam aplikasi Anda untuk mengarah ke grup replikasi baru.
1. Hapus grup replikasi lama. Untuk informasi selengkapnya, lihat [Menghapus cluster di ElastiCache](Clusters.Delete.md) atau [Menghapus grup replikasi](Replication.DeletingRepGroup.md).
### Mengaktifkan Enkripsi At-Rest Menggunakan Konsol Manajemen AWS
#### Mengaktifkan Enkripsi Diam di Klaster Nirserver (Konsol)
Semua cache nirserver memiliki enkripsi diam yang aktif. Secara default, kunci KMS yang AWS dimiliki digunakan untuk mengenkripsi data. Untuk memilih AWS KMS kunci Anda sendiri, buat pilihan berikut:
+ Perluas bagian **Pengaturan default**.
+ Pilih **Sesuaikan pengaturan default** di bagian **Pengaturan default**.
+ Pilih **Sesuaikan pengaturan keamanan Anda** di bagian **Keamanan**.
+ Pilih **CMK yang dikelola pelanggan** di bagian pengaturan **Kunci enkripsi**.
+ Pilih kunci di bagian pengaturan **Kunci AWS KMS**.
#### Mengaktifkan Enkripsi At-Rest pada Cluster Berbasis Node (Konsol)
Saat merancang cache Anda sendiri, konfigurasi 'Dev/Test' dan 'Produksi' dengan metode 'Mudah dibuat' akan menjadikan enkripsi diam aktif menggunakan kunci **Default**. Saat memilih konfigurasi sendiri, buat pilihan berikut:
+ Pilih versi 3.2.6, 4.0.10 atau yang lebih baru sebagai versi mesin Anda.
+ Klik kotak centang di sebelah **Aktifkan** untuk opsi **Enkripsi diam**.
+ Pilih **Kunci default** atau **CMK yang dikelola pelanggan**.
Untuk step-by-step prosedurnya, lihat yang berikut ini:
+ [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
### Mengaktifkan Enkripsi At-Rest Menggunakan AWS CLI
Untuk mengaktifkan enkripsi saat membuat klaster Valkey atau Redis OSS menggunakan AWS CLI, gunakan at-rest-encryption-enabled parameter *--* saat membuat grup replikasi.
#### Mengaktifkan Enkripsi At-Rest pada Cluster (CLI) Valkey atau Redis OSS (Mode Cluster Dinonaktifkan)
Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster dinonaktifkan) `my-classic-rg` dengan tiga node (*-- num-cache-clusters*), replika utama dan dua baca. Enkripsi AT-rest diaktifkan untuk grup replikasi ini (*-- at-rest-encryption-enabled*).
Parameter berikut dan nilainya diperlukan untuk mengaktifkan enkripsi pada grup replikasi ini:
**Parameter Kunci**
+ **--engine**—Harus `valkey` atau`redis`.
+ **--engine-version**—Jika mesinnya Redis OSS, ini harus 3.2.6, 4.0.10 atau yang lebih baru.
+ **--at-rest-encryption-enabled**—Wajib untuk mengaktifkan enkripsi diam.
**Example 1: Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) Cluster dengan Replika**
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id my-classic-rg \
--replication-group-description "3 node replication group" \
--cache-node-type cache.m4.large \
--engine redis \
--at-rest-encryption-enabled \
--num-cache-clusters 3
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id my-classic-rg ^
--replication-group-description "3 node replication group" ^
--cache-node-type cache.m4.large ^
--engine redis ^
--at-rest-encryption-enabled ^
--num-cache-clusters 3 ^
```
Untuk informasi tambahan, lihat hal berikut:
+ [Membuat grup replikasi Valkey atau Redis OSS (Mode Cluster Dinonaktifkan) dari awal ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
#### Mengaktifkan Enkripsi At-Rest pada Cluster untuk Valkey atau Redis OSS (Mode Cluster Diaktifkan) (CLI)
*Operasi berikut membuat grup replikasi Valkey atau Redis OSS (mode cluster enabled) `my-clustered-rg` dengan tiga grup node atau pecahan (--). num-node-groups* Masing-masing memiliki tiga node, primer dan dua replika baca (*-- replicas-per-node-group*). Enkripsi AT-rest diaktifkan untuk grup replikasi ini (*-- at-rest-encryption-enabled*).
Parameter berikut dan nilainya diperlukan untuk mengaktifkan enkripsi pada grup replikasi ini:
**Parameter Kunci**
+ **--engine**—Harus `valkey` atau`redis`.
+ **--engine-version**—Jika mesinnya Redis OSS, ini harus 4.0.10 atau lebih baru.
+ **--at-rest-encryption-enabled**—Wajib untuk mengaktifkan enkripsi diam.
+ **--cache-parameter-group**—Harus `default-redis4.0.cluster.on` atau turunannya untuk membuat grup replikasi dengan mode klaster diaktifkan.
**Example 2: Cluster Valkey atau Redis OSS (Mode Cluster Diaktifkan)**
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id my-clustered-rg \
--replication-group-description "redis clustered cluster" \
--cache-node-type cache.m3.large \
--num-node-groups 3 \
--replicas-per-node-group 2 \
--engine redis \
--engine-version 6.2 \
--at-rest-encryption-enabled \
--cache-parameter-group default.redis6.x.cluster.on
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id my-clustered-rg ^
--replication-group-description "redis clustered cluster" ^
--cache-node-type cache.m3.large ^
--num-node-groups 3 ^
--replicas-per-node-group 2 ^
--engine redis ^
--engine-version 6.2 ^
--at-rest-encryption-enabled ^
--cache-parameter-group default.redis6.x.cluster.on
```
Untuk informasi tambahan, lihat hal berikut:
+ [Membuat grup replikasi Valkey atau Redis OSS (Cluster Mode Enabled) dari awal ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
## Lihat Juga
+ [Amazon VPCs dan ElastiCache keamanan](VPCs.md)
+ [Identity and Access Management untuk Amazon ElastiCache](IAM.md)
# Autentikasi dan Otorisasi
AWS Identity and Access Management (IAM) adalah layanan web yang membantu Anda mengontrol akses ke sumber daya dengan aman. AWS ElastiCache mendukung otentikasi pengguna menggunakan IAM dan perintah Valkey dan Redis OSS AUTH, dan mengotorisasi operasi pengguna menggunakan Role-Based Access Control (RBAC).
**Topics**
+ [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md)
+ [Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH](auth.md)
+ [Menonaktifkan kontrol akses pada cache ElastiCache Valkey atau Redis OSS](in-transit-encryption-disable.md)
# Kontrol Akses Berbasis Peran (RBAC)
Dengan perintah Valkey dan Redis OSS AUTH seperti yang dijelaskan dalam [Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH](auth.md) Anda dapat menggunakan Role-Based Access Control (RBAC). RBAC juga merupakan satu-satunya cara untuk mengontrol akses ke cache nirserver. Ini tersedia untuk Valkey 7.2 dan seterusnya, dan Redis OSS 6.0 hingga 7.2.
RBAC memungkinkan Anda untuk:
+ Kontrol akses cache melalui grup pengguna. Grup pengguna ini dirancang sebagai cara untuk mengatur akses ke cache.
+ Dengan *AuthN*, miliki kata sandi per pengguna sebagai lawan dari token autentikasi per cluster.
+ Dengan *AuthZ*, miliki izin pengguna yang berbutir halus.
+ Dasarkan akses klaster Anda ACLs.
Tidak seperti Valkey dan Redis OSS AUTH, di mana semua klien yang diautentikasi memiliki akses cache penuh jika token mereka diautentikasi, RBAC memungkinkan Anda untuk menetapkan pengguna ke set tergantung pada peran yang diinginkan pengguna. Set ini dirancang sebagai cara untuk mengatur akses ke cache.
Dengan RBAC, Anda membuat pengguna dan memberi mereka izin tertentu menggunakan string akses, seperti yang dijelaskan berikut. Anda menetapkan pengguna untuk menetapkan selaras dengan peran tertentu (administrator, sumber daya manusia) yang kemudian disebarkan ke satu atau beberapa cache. ElastiCache Dengan melakukan ini, Anda dapat menetapkan batas keamanan antara klien menggunakan cache atau cache Valkey atau Redis OSS yang sama, dan mencegah klien mengakses data satu sama lain.
RBAC dirancang untuk mendukung pengenalan [ACL](https://valkey.io/topics/acl/) di Redis OSS 6. Saat Anda menggunakan RBAC dengan cache ElastiCache Valkey atau Redis OSS Anda, ada beberapa batasan:
+ Grup pengguna yang dikonfigurasi untuk mesin “VALKEY” hanya dapat berisi pengguna yang menggunakan mekanisme otentikasi (baik kata sandi atau IAM). Ini berarti semua pengguna dengan mesin “VALKEY”, dan pengguna lain dengan mesin “Redis” yang memiliki pengaturan mereka dikonfigurasi untuk mengautentikasi dengan kata sandi atau IAM, dapat berada di grup pengguna ini.
+ Saat menggunakan RBAC dengan cluster Valkey, kedua grup pengguna dengan mesin “VALKEY” dan dengan mesin “REDIS” dapat digunakan.
+ Saat menggunakan RBAC dengan cluster Redis OSS, hanya grup pengguna dengan mesin “REDIS” yang dapat digunakan.
+ Anda tidak dapat menentukan kata sandi dalam string akses. Anda mengatur kata sandi dengan [CreateUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html)atau [ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html)panggilan.
+ Untuk hak pengguna, Anda mengaktifkan atau menonaktifkan pengguna dengan `on` dan `off` sebagai bagian dari string akses. Jika salah satu nilai tersebut tidak ditentukan dalam string akses, pengguna ditetapkan ke `off` dan tidak memiliki hak akses ke cache.
+ Anda tidak dapat menggunakan perintah terlarang dan berganti nama sebagai bagian dari string akses. Jika Anda menentukan perintah terlarang atau yang diubah namanya, pengecualian akan terjadi. Jika Anda ingin menggunakan daftar kontrol akses (ACLs) untuk perintah yang diganti namanya, tentukan nama asli perintah tersebut, dengan kata lain nama perintah sebelum diganti namanya.
+ Anda tidak dapat menggunakan perintah `reset` sebagai bagian dari string akses. Anda menentukan kata sandi dengan parameter API, dan ElastiCache untuk Valkey dan Redis OSS mengelola kata sandi. Dengan demikian, Anda tidak dapat menggunakan `reset` karena akan menghapus semua kata sandi untuk pengguna.
+ Redis OSS 6 memperkenalkan perintah [ACL](https://valkey.io/commands/acl-list) LIST. Perintah ini mengembalikan daftar pengguna bersama dengan aturan ACL yang diterapkan untuk setiap pengguna. ElastiCache mendukung `ACL LIST` perintah, tetapi tidak menyertakan dukungan untuk hash kata sandi seperti yang dilakukan Redis OSS. Dengan ElastiCache, Anda dapat menggunakan [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)operasi untuk mendapatkan informasi serupa, termasuk aturan yang terkandung dalam string akses. Namun, [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)tidak mengambil kata sandi pengguna.
+ [https://valkey.io/commands/acl-users](https://valkey.io/commands/acl-users) ElastiCache untuk Valkey dan Redis OSS tidak mendukung perintah ACL berbasis penulisan lainnya.
+ Batasan berikut berlaku:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/Clusters.RBAC.html)
**RBAC dengan Valkey**
Saat menggunakan Kontrol Akses Berbasis Peran dengan Valkey, pengguna dan grup pengguna dibuat dengan tipe mesin “VALKEY”. Ini direkomendasikan, karena secara default Valkey dengan RBAC memberikan peningkatan keamanan dibandingkan dengan Redis OSS. Kluster Valkey yang disediakan dan tanpa server mendukung asosiasi pengguna dan grup pengguna VALKEY.
Fitur utama dari Valkey Access Control meliputi:
+ Pengguna Valkey dibatasi hanya untuk asosiasi grup pengguna Valkey.
+ Grup pengguna Valkey dapat berisi pengguna Valkey, dan pengguna Redis OSS yang dilindungi kata sandi atau autentikasi IAM diaktifkan.
+ Pengguna Valkey harus menggunakan perlindungan kata sandi atau otentikasi IAM.
+ Grup pengguna VALKEY hanya dapat dikaitkan dengan cluster VALKEY
+ Tidak ada persyaratan pengguna default. Ketika grup pengguna Valkey dilampirkan ke cluster, persyaratan pengguna default secara otomatis dinonaktifkan. Pelanggan akan melihat bahwa pengguna default dimatikan saat menggunakan perintah ACL LIST.
Informasi lebih lanjut tentang penggunaan RBAC dengan ElastiCache untuk Valkey dan Redis OSS berikut.
**Topics**
+ [Menentukan Izin Menggunakan String Akses](#Access-string)
+ [Menerapkan RBAC ke Cache ElastiCache untuk Valkey atau Redis OSS](#rbac-using)
+ [Migrasi dari AUTH ke RBAC](#Migrate-From-RBAC-to-Auth)
+ [Migrasi dari RBAC ke AUTH](#Migrate-From-RBAC-to-AUTH-1)
+ [Merotasi kata sandi untuk pengguna secara otomatis](User-Secrets-Manager.md)
+ [Autentikasi dengan IAM](auth-iam.md)
## Menentukan Izin Menggunakan String Akses
Untuk menentukan izin ke cache ElastiCache Valkey atau Redis OSS, Anda membuat string akses dan menetapkannya ke pengguna melalui atau.AWS CLIKonsol Manajemen AWS
String akses didefinisikan sebagai daftar aturan yang dipisahkan spasi yang diterapkan pada pengguna. String akses menentukan perintah yang dapat dijalankan oleh pengguna dan kunci yang dapat dioperasikan oleh pengguna. Agar dapat menjalankan perintah, pengguna harus memiliki akses ke perintah yang dijalankan dan semua kunci yang diakses oleh perintah tersebut. Aturan diterapkan dari kiri ke kanan secara kumulatif, dan string yang lebih sederhana dapat digunakan sebagai pengganti yang disediakan jika ada kelebihan dalam string yang disediakan.
Untuk informasi tentang sintaksis aturan ACL, lihat [ACL](https://valkey.io/topics/acl/).
Pada contoh berikut, string akses merepresentasikan pengguna aktif dengan akses ke semua kunci dan perintah yang tersedia.
`on ~* +@all`
Sintaksis string akses diuraikan sebagai berikut:
+ `on` – Pengguna adalah pengguna yang aktif.
+ `~*` – Akses diberikan ke semua kunci yang tersedia.
+ `+@all` – Akses diberikan ke semua perintah yang tersedia.
Pengaturan di atas adalah pengaturan yang tidak terlalu membatasi. Anda dapat mengubah pengaturan ini untuk membuatnya lebih aman.
Pada contoh berikut, string akses merepresentasikan pengguna dengan akses yang dibatasi untuk akses baca pada kunci yang diawali dengan ruang kunci "app::"
`on ~app::* -@all +@read`
Anda dapat mempersempit izin ini lebih lanjut dengan menampilkan daftar perintah yang dapat diakses pengguna:
`+command1` – Akses pengguna ke perintah dibatasi pada *`command1`*.
`+@category` – Akses pengguna dibatasi pada kategori perintah.
Untuk informasi tentang cara menetapkan string akses ke pengguna, lihat [Membuat Pengguna dan Grup Pengguna dengan Konsol dan CLI](#Users-management).
Jika Anda memigrasikan beban kerja yang ada ke ElastiCache, Anda dapat mengambil string akses dengan menelepon`ACL LIST`, tidak termasuk pengguna dan hash kata sandi apa pun.
Untuk Redis OSS versi 6.2 dan di atas sintaks string akses berikut juga didukung:
+ `&*` – Akses diberikan ke semua saluran yang tersedia.
Untuk Redis OSS versi 7.0 dan di atas sintaks string akses berikut juga didukung:
+ `|` – Dapat digunakan untuk memblokir subperintah (misalnya "-config\$1set").
+ `%R~` – Menambahkan pola kunci baca yang ditentukan. Sintaksis ini berperilaku mirip dengan pola kunci biasa, tetapi hanya memberikan izin untuk membaca dari kunci yang cocok dengan pola yang diberikan. Lihat [izin kunci](https://valkey.io/topics/acl/) untuk informasi selengkapnya.
+ `%W~` – Menambahkan pola kunci tulis yang ditentukan. Sintaksis ini berperilaku mirip dengan pola kunci biasa, tetapi hanya memberikan izin untuk menulis dari kunci yang cocok dengan pola yang diberikan. Lihat [izin kunci ACL](https://valkey.io/topics/acl/) untuk informasi selengkapnya.
+ `%RW~` – Alias untuk `~`.
+ `()` – Membuat pemilih baru yang akan digunakan untuk mencocokkan aturan. Pemilih dievaluasi setelah izin pengguna, dan dievaluasi sesuai dengan urutan penentuannya. Perintah akan diizinkan jika cocok dengan izin pengguna atau pemilih apa pun. Lihat [pemilih ACL](https://valkey.io/topics/acl/) untuk informasi selengkapnya.
+ `clearselectors` – Menghapus semua pemilih yang dilampirkan pada pengguna.
## Menerapkan RBAC ke Cache ElastiCache untuk Valkey atau Redis OSS
Untuk digunakan ElastiCache untuk Valkey atau Redis OSS RBAC, Anda mengambil langkah-langkah berikut:
1. Buat satu atau beberapa pengguna.
1. Buat grup pengguna dan tambahkan pengguna ke grup tersebut.
1. Tentukan grup pengguna ke cache yang memiliki enkripsi bergerak yang aktif.
Langkah-langkah ini dijelaskan secara rinci sebagai berikut.
**Topics**
+ [Membuat Pengguna dan Grup Pengguna dengan Konsol dan CLI](#Users-management)
+ [Mengelola Grup Pengguna dengan Konsol dan CLI](#User-Groups)
+ [Menetapkan Grup Pengguna ke Cache Nirserver](#Users-groups-to-serverless-caches)
+ [Menetapkan Grup Pengguna ke Grup Replikasi](#Users-groups-to-RGs)
### Membuat Pengguna dan Grup Pengguna dengan Konsol dan CLI
Informasi pengguna untuk pengguna RBAC adalah ID pengguna, nama pengguna, serta secara opsional, kata sandi dan string akses. String akses menyediakan tingkat izin pada kunci dan perintah. ID pengguna bersifat unik untuk pengguna, dan nama pengguna adalah data yang diteruskan ke mesin.
Pastikan bahwa izin pengguna yang Anda berikan sesuai dengan tujuan yang dimaksud untuk grup pengguna. Misalnya, jika Anda membuat grup pengguna bernama `Administrators`, setiap pengguna yang Anda tambahkan ke grup tersebut akan memiliki string akses yang ditetapkan menjadi akses penuh ke kunci dan perintah. Untuk pengguna di grup pengguna `e-commerce`, Anda dapat mengatur string aksesnya menjadi akses hanya-baca.
ElastiCache secara otomatis mengkonfigurasi pengguna default dengan ID pengguna dan nama pengguna `"default"` dan menambahkannya ke semua grup pengguna. Anda tidak dapat mengubah atau menghapus pengguna ini. Pengguna ini dimaksudkan untuk kompatibilitas dengan perilaku default versi Redis OSS sebelumnya dan memiliki string akses yang memungkinkannya memanggil semua perintah dan mengakses semua kunci.
Untuk menambahkan kontrol akses yang tepat ke cache, ganti pengguna default ini dengan pengguna baru yang tidak diaktifkan atau menggunakan kata sandi yang kuat. Untuk mengubah pengguna default, buat pengguna baru dengan nama pengguna yang ditetapkan ke `default`. Anda kemudian dapat menukarnya dengan pengguna default yang asli.
Prosedur berikut menunjukkan cara untuk menukar pengguna `default` asli dengan pengguna `default` lain yang memiliki string akses yang sudah diubah.
**Untuk mengubah pengguna default di konsol**
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. Pilih **Manajemen grup pengguna** dari panel navigasi.
1. Untuk **ID grup pengguna**, pilih ID yang ingin Anda ubah. Pastikan bahwa Anda memilih tautan, bukan kotak centang.
1. Pilih **Ubah**.
1. Di jendela **Modify**, pilih **Manage**. Untuk “pilih pengguna yang Anda inginkan”, pilih pengguna dengan **nama Pengguna** sebagai default.
1. Pilih **Tutup**.
1. Pilih **Ubah**. Saat Anda melakukannya, koneksi apa pun yang ada ke cache yang dimiliki oleh pengguna default asli akan dihentikan.
**Untuk memodifikasi pengguna default dengan AWS CLI**
1. Buat pengguna baru dengan nama pengguna `default` menggunakan perintah berikut.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-user \
--user-id "new-default-user" \
--user-name "default" \
--engine "VALKEY" \
--passwords "a-str0ng-pa))word" \
--access-string "off +get ~keys*"
```
Untuk Windows:
```
aws elasticache create-user ^
--user-id "new-default-user" ^
--user-name "default" ^
--engine "VALKEY" ^
--passwords "a-str0ng-pa))word" ^
--access-string "off +get ~keys*"
```
1. Buat grup pengguna dan tambahkan pengguna yang telah Anda buat sebelumnya.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-2" \
--engine "VALKEY" \
--user-ids "new-default-user"
```
Untuk Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-2" ^
--engine "VALKEY" ^
--user-ids "new-default-user"
```
Saat membuat pengguna, Anda dapat menetapkan hingga dua kata sandi. Saat Anda mengubah kata sandi, koneksi apa pun yang ada ke cache akan dipertahankan.
Secara khusus, perhatikan kendala kata sandi pengguna ini saat menggunakan RBAC ElastiCache untuk Valkey dan Redis OSS:
+ Kata sandi harus terdiri dari 16–128 karakter yang dapat dicetak.
+ Karakter non-alfanumerik berikut tidak diizinkan: `,` `""` `/` `@`.
#### Mengelola Pengguna dengan Konsol dan CLI
Gunakan prosedur berikut untuk mengelola pengguna di konsol.
**Mengelola pengguna di konsol**
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 ElastiCache dasbor Amazon, pilih **Manajemen pengguna**. Pilihan berikut tersedia:
+ **Buat pengguna** – Saat membuat pengguna, Anda memasukkan ID pengguna, nama pengguna, mode autentikasi, dan string akses. String akses menetapkan tingkat izin untuk kunci dan perintah yang boleh digunakan pengguna.
Saat membuat pengguna, Anda dapat menetapkan hingga dua kata sandi. Saat Anda mengubah kata sandi, koneksi apa pun yang ada ke cache akan dipertahankan.
+ **Ubah pengguna** – Memungkinkan Anda memperbarui pengaturan autentikasi pengguna atau mengubah string aksesnya.
+ **Hapus pengguna** – Akun akan dihapus dari Grup Pengguna yang memiliki akun tersebut.
Gunakan prosedur berikut untuk mengelola pengguna dengan AWS CLI.
**Untuk mengubah pengguna menggunakan CLI**
+ Gunakan perintah `modify-user` untuk memperbarui satu atau beberapa kata sandi pengguna atau mengubah izin akses pengguna.
Saat pengguna diubah, grup pengguna yang terkait dengan pengguna akan diperbarui, beserta cache apa pun yang terkait dengan grup pengguna. Semua koneksi yang ada akan dipertahankan. Berikut ini adalah beberapa contohnya.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-user \
--user-id user-id-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode Type=iam
```
Untuk Windows:
```
aws elasticache modify-user ^
--user-id user-id-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode Type=iam
```
**catatan**
Sebaiknya jangan menggunakan opsi `nopass`. Jika Anda menggunakannya, sebaiknya tetapkan izin pengguna menjadi hanya-baca dengan akses ke kumpulan kunci yang terbatas.
**Untuk menghapus pengguna menggunakan CLI**
+ Gunakan perintah `delete-user` untuk menghapus pengguna. Akun dihapus dan dihilangkan dari grup pengguna yang memiliki akun tersebut. Berikut adalah contohnya.
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-user \
--user-id user-id-2
```
Untuk Windows:
```
aws elasticache delete-user ^
--user-id user-id-2
```
Untuk melihat daftar pengguna, panggil operasi [describe-users](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html).
```
aws elasticache describe-users
```
### Mengelola Grup Pengguna dengan Konsol dan CLI
Anda dapat membuat grup pengguna untuk mengatur dan mengontrol akses pengguna ke satu atau beberapa cache, seperti yang ditunjukkan berikut.
Gunakan prosedur berikut untuk mengelola grup pengguna menggunakan konsol.
**Mengelola grup pengguna menggunakan konsol**
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 ElastiCache dasbor Amazon, pilih **Manajemen grup pengguna**.
Operasi berikut tersedia untuk membuat grup pengguna baru:
+ **Buat** – Saat Anda membuat grup pengguna, Anda menambahkan pengguna, lalu menetapkan grup pengguna ke cache. Misalnya, Anda dapat membuat grup pengguna `Admin` untuk pengguna yang memiliki peran administratif pada cache.
**penting**
Jika Anda tidak menggunakan grup pengguna Valkey atau Redis OSS maka Anda harus menyertakan pengguna default saat membuat grup pengguna.
+ **Tambahkan Pengguna** – Menambahkan pengguna ke grup pengguna.
+ **Hapus Pengguna** – Menghapus pengguna dari grup pengguna. Saat pengguna dihapus dari grup pengguna, koneksi apa pun yang dimiliki grup tersebut ke sebuah cache akan dihentikan.
+ **Hapus** – Gunakan operasi ini untuk menghapus grup pengguna. Perhatikan bahwa grup pengguna itu sendiri, bukan pengguna yang terdapat dalam grup, yang akan dihapus.
Untuk grup pengguna yang ada, Anda dapat melakukan hal berikut:
+ **Tambahkan Pengguna** – Menambahkan pengguna yang ada ke grup pengguna.
+ **Hapus Pengguna** – Menghapus pengguna yang ada dari grup pengguna.
**catatan**
Pengguna dihilangkan dari grup pengguna, tetapi tidak dihapus dari sistem.
Gunakan prosedur berikut untuk mengelola grup pengguna menggunakan CLI.
**Untuk membuat grup pengguna baru dan menambahkan pengguna menggunakan CLI**
+ Gunakan perintah `create-user-group` seperti berikut ini.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-1" \
--engine "VALKEY" \
--user-ids user-id-1, user-id-2
```
Untuk Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-1" ^
--engine "VALKEY" ^
--user-ids user-id-1, user-id-2
```
**Untuk mengubah grup pengguna dengan menambahkan pengguna baru atau menghapus anggota saat ini menggunakan CLI**
+ Gunakan perintah `modify-user-group` seperti berikut ini.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-user-group --user-group-id new-group-1 \
--user-ids-to-add user-id-3 \
--user-ids-to-remove user-id-2
```
Untuk Windows:
```
aws elasticache modify-user-group --user-group-id new-group-1 ^
--user-ids-to-add user-id-3 ^
--user-ids-to-removere user-id-2
```
**catatan**
Koneksi terbuka milik pengguna yang dihapus dari sebuah grup pengguna akan diakhiri dengan perintah ini.
**Untuk menghapus grup pengguna menggunakan CLI**
+ Gunakan perintah `delete-user-group` seperti berikut ini. Grup pengguna itu sendiri, bukan pengguna yang terdapat dalam grup, yang akan dihapus.
Untuk Linux, macOS, atau Unix:
```
aws elasticache delete-user-group /
--user-group-id
```
Untuk Windows:
```
aws elasticache delete-user-group ^
--user-group-id
```
Untuk melihat daftar grup pengguna, Anda dapat memanggil [describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html)operasi.
```
aws elasticache describe-user-groups \
--user-group-id test-group
```
### Menetapkan Grup Pengguna ke Cache Nirserver
Setelah Anda membuat grup pengguna dan menambahkan pengguna, langkah terakhir dalam menerapkan RBAC adalah menetapkan grup pengguna ke cache nirserver.
#### Menetapkan Grup Pengguna ke Cache Nirserver Menggunakan Konsol
Untuk menambahkan grup pengguna ke cache tanpa server menggunakan Konsol Manajemen AWS, lakukan hal berikut:
+ Untuk mode klaster dinonaktifkan, lihat [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Untuk mode klaster diaktifkan, lihat [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Menetapkan Grup Pengguna ke Cache Tanpa Server Menggunakan AWS CLI
AWS CLI Operasi berikut membuat cache tanpa server menggunakan **user-group-id** parameter dengan nilai. `my-user-group-id` Ganti grup subnet `sng-test` dengan grup subnet yang ada.
**Parameter Kunci**
+ **--engine**Harus `VALKEY` atau`REDIS`.
+ **--user-group-id** – Nilai ini menyediakan ID grup pengguna, yang terdiri dari pengguna dengan izin akses yang ditentukan untuk cache.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-serverless-cache \
--serverless-cache-name "new-serverless-cache" \
--description "new-serverless-cache" \
--engine "VALKEY" \
--user-group-id "new-group-1"
```
Untuk Windows:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name "new-serverless-cache" ^
--description "new-serverless-cache" ^
--engine "VALKEY" ^
--user-group-id "new-group-1"
```
AWS CLI Operasi berikut memodifikasi cache tanpa server dengan **user-group-id** parameter dengan nilai. `my-user-group-id`
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-serverless-cache \
--serverless-cache-name serverless-cache-1 \
--user-group-id "new-group-2"
```
Untuk Windows:
```
aws elasticache modify-serverless-cache ^
--serverless-cache-name serverless-cache-1 ^
--user-group-id "new-group-2"
```
Perhatikan bahwa perubahan apa pun yang dibuat pada cache akan diperbarui secara asinkron. Anda dapat memantau progres ini dengan melihat peristiwa. Untuk informasi selengkapnya, lihat [Melihat ElastiCache acara](ECEvents.Viewing.md).
### Menetapkan Grup Pengguna ke Grup Replikasi
Setelah Anda membuat grup pengguna dan menambahkan pengguna, langkah terakhir dalam menerapkan RBAC adalah menetapkan grup pengguna ke grup replikasi.
#### Menetapkan Grup Pengguna ke Grup Replikasi Menggunakan Konsol
Untuk menambahkan grup pengguna ke replikasi menggunakan Konsol Manajemen AWS, lakukan hal berikut:
+ Untuk mode klaster dinonaktifkan, lihat [Membuat cluster Valkey (mode cluster dinonaktifkan) (Konsol)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Untuk mode klaster diaktifkan, lihat [Membuat cluster Valkey atau Redis OSS (mode cluster diaktifkan) (Konsol)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Menetapkan Grup Pengguna ke Grup Replikasi Menggunakan AWS CLI
AWS CLI Operasi berikut membuat grup replikasi dengan enkripsi dalam transit (TLS) diaktifkan dan **user-group-ids** parameter dengan nilai. `my-user-group-id` Ganti grup subnet `sng-test` dengan grup subnet yang ada.
**Parameter Kunci**
+ **--engine**Harus `valkey` atau`redis`.
+ **--engine-version** – Harus 6.0 atau yang lebih baru.
+ **--transit-encryption-enabled** – Wajib untuk autentikasi dan untuk mengaitkan grup pengguna.
+ **--user-group-ids** – Nilai ini menyediakan ID grup pengguna, yang terdiri dari pengguna dengan izin akses yang ditentukan untuk cache.
+ **--cache-subnet-group** – Wajib untuk mengaitkan grup pengguna.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id "new-replication-group" \
--replication-group-description "new-replication-group" \
--engine "VALKEY" \
--cache-node-type cache.m5.large \
--transit-encryption-enabled \
--user-group-ids "new-group-1" \
--cache-subnet-group "cache-subnet-group"
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id "new-replication-group" ^
--replication-group-description "new-replication-group" ^
--engine "VALKEY" ^
--cache-node-type cache.m5.large ^
--transit-encryption-enabled ^
--user-group-ids "new-group-1" ^
--cache-subnet-group "cache-subnet-group"
```
AWS CLI Operasi berikut memodifikasi grup replikasi dengan enkripsi dalam transit (TLS) diaktifkan dan **user-group-ids** parameter dengan nilai. `my-user-group-id`
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id replication-group-1 \
--user-group-ids-to-remove "new-group-1" \
--user-group-ids-to-add "new-group-2"
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id replication-group-1 ^
--user-group-ids-to-remove "new-group-1" ^
--user-group-ids-to-add "new-group-2"
```
Catat `PendingChanges` dalam respons. Perubahan apa pun yang dibuat pada cache akan diperbarui secara asinkron. Anda dapat memantau progres ini dengan melihat peristiwa. Untuk informasi selengkapnya, lihat [Melihat ElastiCache acara](ECEvents.Viewing.md).
## Migrasi dari AUTH ke RBAC
Jika Anda menggunakan AUTH seperti yang dijelaskan dalam [Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH](auth.md) dan ingin bermigrasi menggunakan RBAC, gunakan prosedur berikut.
Gunakan prosedur berikut untuk bermigrasi dari AUTH ke RBAC menggunakan konsol.
**Untuk bermigrasi dari Valkey atau Redis OSS AUTH ke RBAC menggunakan 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 daftar di sudut kanan atas, pilih AWS Wilayah tempat cache yang ingin Anda ubah berada.
1. Di panel navigasi, pilih mesin yang berjalan pada cache yang ingin Anda modifikasi.
Daftar cache mesin yang dipilih akan muncul.
1. Di daftar cache, pilih nama cache yang ingin diubah.
1. Untuk **Tindakan**, pilih **Ubah**.
Jendela **Ubah** muncul.
1. Untuk **Kontrol akses**, pilih **Daftar kontrol akses grup pengguna**.
1. Untuk **Daftar kontrol akses grup pengguna**, pilih grup pengguna.
1. Pilih **Pratinjau perubahan**, lalu di layar berikutnya, pilih **Ubah**.
Gunakan prosedur berikut untuk bermigrasi dari Valkey atau Redis OSS AUTH ke RBAC menggunakan CLI.
**Untuk bermigrasi dari AUTH ke RBAC menggunakan CLI**
+ Gunakan perintah `modify-replication-group` seperti berikut ini.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group --replication-group-id test \
--auth-token-update-strategy DELETE \
--user-group-ids-to-add user-group-1
```
Untuk Windows:
```
aws elasticache modify-replication-group --replication-group-id test ^
--auth-token-update-strategy DELETE ^
--user-group-ids-to-add user-group-1
```
## Migrasi dari RBAC ke AUTH
Jika Anda menggunakan RBAC dan ingin bermigrasi ke Redis OSS AUTH, lihat. [Migrasi dari RBAC ke AUTH](auth.md#Migrate-From-RBAC-to-AUTH)
**catatan**
Jika Anda perlu menonaktifkan kontrol akses pada ElastiCache cache, Anda harus melakukannya melalui file AWS CLI. Lihat informasi yang lebih lengkap di [Menonaktifkan kontrol akses pada cache ElastiCache Valkey atau Redis OSS](in-transit-encryption-disable.md).
# Merotasi kata sandi untuk pengguna secara otomatis
Dengan AWS Secrets Manager, Anda dapat mengganti kredensi hardcode dalam kode Anda (termasuk kata sandi) dengan panggilan API ke Secrets Manager untuk mengambil rahasia secara terprogram. Ini membantu memastikan bahwa rahasia tidak dapat dikompromikan oleh seseorang yang memeriksa kode Anda, karena rahasianya tidak ada di sana. Selain itu, Anda dapat mengonfigurasi Secrets Manager untuk merotasi rahasia secara otomatis sesuai dengan jadwal yang Anda tentukan. Ini memungkinkan Anda mengganti rahasia jangka panjang dengan rahasia jangka pendek, yang membantu mengurangi risiko kompromi secara signifikan.
Menggunakan Secrets Manager, Anda dapat secara otomatis memutar kata sandi Redis OSS Anda ElastiCache (yaitu, rahasia) menggunakan AWS Lambda fungsi yang disediakan Secrets Manager.
Untuk informasi lebih lanjut tentang AWS Secrets Manager, lihat [Apa itu AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
## Bagaimana ElastiCache menggunakan rahasia
Valkey 7.2 dan di atasnya memiliki fitur yang setara dengan Redis OSS 7.0. Dalam Redis OSS 6, ElastiCache diperkenalkan [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md) untuk mengamankan cluster Valkey atau Redis OSS. Fitur ini memungkinkan koneksi tertentu dibatasi dalam hal perintah yang dapat dijalankan dan kunci yang dapat diakses. Dengan RBAC, saat pelanggan membuat pengguna dengan kata sandi, nilai kata sandi harus dimasukkan secara manual dalam teks biasa dan terlihat oleh operator.
Dengan Secrets Manager, aplikasi mengambil kata sandi dari Secrets Manager bukannya memasukkannya secara manual dan menyimpannya dalam konfigurasi aplikasi. Untuk informasi tentang cara melakukannya, lihat [Bagaimana ElastiCache pengguna dikaitkan dengan rahasia](#How-User-Secrets-Manager-Associate).
Ada biaya yang dikeluarkan untuk menggunakan rahasia. Untuk informasi harga, lihat [Harga AWS Secrets Manager](https://aws.amazon.com/secrets-manager/pricing/).
## Bagaimana ElastiCache pengguna dikaitkan dengan rahasia
Secrets Manager akan menyimpan referensi untuk pengguna terkait di bidang `SecretString` rahasia. Tidak akan ada referensi ke rahasia dari ElastiCache samping.
```
{
"password": "strongpassword",
"username": "user1",
"user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user
}
```
## Fungsi rotasi Lambda
Untuk mengaktifkan rotasi kata sandi otomatis Secrets Manager, Anda akan membuat fungsi Lambda yang akan berinteraksi dengan API [modify-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html) untuk memperbarui kata sandi pengguna.
Untuk informasi tentang cara kerjanya, lihat [Cara kerja rotasi](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how).
**catatan**
Untuk beberapa AWS layanan, untuk menghindari skenario wakil yang membingungkan,AWS merekomendasikan agar Anda menggunakan kunci kondisi `aws:SourceAccount` global `aws:SourceArn` dan global. Namun, jika Anda menyertakan kondisi `aws:SourceArn` dalam kebijakan fungsi rotasi Anda, fungsi rotasi hanya dapat digunakan untuk merotasi rahasia yang ditentukan oleh ARN tersebut. Sebaiknya hanya sertakan kunci konteks `aws:SourceAccount` agar Anda dapat menggunakan fungsi rotasi untuk beberapa rahasia.
Untuk masalah apa pun yang mungkin Anda temui, lihat [Memecahkan masalah rotasi AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html).
## Cara membuat ElastiCache pengguna dan mengaitkannya dengan Secrets Manager
Langkah-langkah berikut menggambarkan cara membuat pengguna dan mengaitkannya dengan Secrets Manager:
1. **Buat pengguna yang tidak aktif**
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-user \
--user-id user1 \
--user-name user1 \
--engine "REDIS" \
--no-password \ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Untuk Windows:
```
aws elasticache create-user ^
--user-id user1 ^
--user-name user1 ^
--engine "REDIS" ^
--no-password ^ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Anda akan melihat respons yang mirip dengan berikut ini:
```
{
"UserId": "user1",
"UserName": "user1",
"Status": "active",
"Engine": "redis",
"AccessString": "off ~keys* -@all +get",
"UserGroupIds": [],
"Authentication": {
"Type": "no_password"
},
"ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1"
}
```
1. **Buat Rahasia**
Untuk Linux, macOS, atau Unix:
```
aws secretsmanager create-secret \
--name production/ec/user1 \
--secret-string \
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Untuk Windows:
```
aws secretsmanager create-secret ^
--name production/ec/user1 ^
--secret-string ^
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Anda akan melihat respons yang mirip dengan berikut ini:
```
{
"ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois",
"Name": "production/ec/user1",
"VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95"
}
```
1. **Konfigurasikan fungsi Lambda untuk merotasi kata sandi Anda **
1. Masuk ke Konsol Manajemen AWS dan buka konsol Lambda di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/)
1. Pilih **Fungsi** pada panel navigasi lalu pilih fungsi yang Anda buat. Pilih nama fungsi, bukan kotak centang di sebelah kirinya.
1. Pilih tab **Konfigurasi**.
1. Dalam **konfigurasi Umum**, pilih **Edit** lalu atur **Waktu habis** setidaknya 12 menit.
1. Pilih **Simpan**.
1. Pilih **Variabel lingkungan** lalu atur yang berikut:
1. SECRETS\$1MANAGER\$1ENDPOINT - https://secretsmanager.**REGION**.amazonaws.com
1. SECRET\$1ARN – Amazon Resource Name (ARN) dari rahasia yang Anda buat pada Langkah 2.
1. USER\$1NAME — Nama pengguna pengguna, ElastiCache
1. Pilih **Simpan**.
1. Pilih **Izin**.
1. Pada **Peran eksekusi**, pilih nama peran fungsi Lambda untuk dilihat di konsol IAM.
1. Fungsi Lambda akan memerlukan izin berikut untuk mengubah pengguna dan mengatur kata sandi:
ElastiCache
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticache:DescribeUsers",
"elasticache:ModifyUser"
],
"Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1"
}
]
}
```
------
Secrets Manager
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX"
},
{
"Effect": "Allow",
"Action": "secretsmanager:GetRandomPassword",
"Resource": "*"
}
]
}
```
------
1. Mengatur rotasi rahasia Secrets Manager
1. **Menggunakan Konsol Manajemen AWS, lihat [Mengatur rotasi otomatis untuk AWS rahasia Secrets Manager menggunakan konsol](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)**
Untuk informasi selengkapnya tentang mengatur jadwal rotasi, lihat [Menjadwalkan ekspresi di rotasi Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html).
1. **Menggunakan AWS CLI, lihat [Mengatur rotasi otomatis untuk AWS Secrets Manager menggunakan AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)**
# Autentikasi dengan IAM
**Topics**
+ [Gambaran umum](#auth-iam-overview)
+ [Batasan](#auth-iam-limits)
+ [Pengaturan](#auth-iam-setup)
+ [Terhubung](#auth-iam-Connecting)
## Gambaran umum
Dengan Autentikasi IAM Anda dapat mengautentikasi koneksi ElastiCache untuk Valkey atau Redis OSS menggunakan identitas AWS IAM, ketika cache Anda dikonfigurasi untuk menggunakan Valkey atau Redis OSS versi 7 atau lebih tinggi. Hal ini memungkinkan Anda memperkuat model keamanan Anda dan menyederhanakan banyak tugas keamanan administratif. Anda juga dapat menggunakan Autentikasi IAM untuk mengonfigurasi kontrol akses berbutir halus untuk setiap ElastiCache cache dan ElastiCache pengguna individual, mengikuti prinsip izin hak istimewa paling sedikit. Otentikasi IAM untuk ElastiCache bekerja dengan menyediakan token otentikasi IAM berumur pendek alih-alih kata sandi ElastiCache pengguna yang berumur panjang di Valkey atau Redis OSS atau perintah. `AUTH` `HELLO` Untuk informasi selengkapnya tentang token autentikasi IAM, lihat [proses penandatanganan Signature Version 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) di Panduan Referensi AWS Umum dan contoh kode di bawah ini.
Anda dapat menggunakan identitas IAM dan kebijakan terkait mereka untuk lebih membatasi akses Valkey atau Redis OSS. Anda juga dapat memberikan akses ke pengguna dari penyedia Identitas federasi mereka langsung ke cache Valkey atau Redis OSS.
Untuk menggunakan AWS IAM dengan ElastiCache, Anda harus terlebih dahulu membuat ElastiCache pengguna dengan mode otentikasi diatur ke IAM. Kemudian Anda dapat membuat atau menggunakan kembali identitas IAM. Identitas IAM memerlukan kebijakan terkait untuk memberikan `elasticache:Connect` tindakan ke ElastiCache cache dan ElastiCache pengguna. Setelah dikonfigurasi, Anda dapat membuat token otentikasi IAM menggunakan AWS kredensi pengguna atau peran IAM. Akhirnya Anda perlu memberikan token otentikasi IAM berumur pendek sebagai kata sandi di Klien Valkey atau Redis OSS Anda saat menghubungkan ke cache Anda. Klien Valkey atau Redis OSS dengan dukungan untuk penyedia kredensi dapat secara otomatis menghasilkan kredensi sementara secara otomatis untuk setiap koneksi baru. ElastiCache akan melakukan otentikasi IAM untuk permintaan koneksi ElastiCache pengguna yang mendukung IAM dan akan memvalidasi permintaan koneksi dengan IAM.
## Batasan
Saat menggunakan autentikasi IAM, batasan berikut berlaku:
+ Autentikasi IAM tersedia saat menggunakan ElastiCache untuk Valkey 7.2 dan di atasnya atau Redis OSS versi 7.0 dan di atasnya.
+ Untuk pengguna yang mendukung IAM, nama ElastiCache pengguna dan properti id pengguna harus identik.
+ Token autentikasi IAM berlaku selama 15 menit. Untuk koneksi yang berumur panjang, sebaiknya gunakan klien Valkey atau Redis OSS yang mendukung antarmuka penyedia kredensial.
+ Koneksi yang diautentikasi IAM ke ElastiCache Valkey atau Redis OSS akan secara otomatis terputus setelah 12 jam. Koneksi dapat diperpanjang selama 12 jam dengan mengirim perintah `AUTH` atau `HELLO` dengan token autentikasi IAM baru.
+ Autentikasi IAM tidak didukung dalam perintah `MULTI EXEC`.
+ Saat ini, autentikasi IAM mendukung kunci konteks kondisi global berikut ini:
+ Saat menggunakan autentikasi IAM dengan cache nirserver, `aws:VpcSourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:CurrentTime`, `aws:EpochTime`, dan `aws:ResourceTag/%s` (dari cache nirserver dan pengguna terkait) didukung.
+ Saat menggunakan autentikasi IAM dengan grup replikasi, `aws:SourceIp` dan `aws:ResourceTag/%s` (dari grup replikasi dan pengguna terkait) didukung.
Untuk informasi selengkapnya tentang kunci konteks kondisi global, lihat [Kunci konteks kondisi global AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dalam Panduan Pengguna IAM.
## Pengaturan
Untuk mengatur autentikasi IAM:
1. Buat cache
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine redis
```
1. Buat dokumen kebijakan kepercayaan IAM, seperti yang ditunjukkan di bawah ini, untuk peran Anda yang memungkinkan akun Anda mengambil peran baru. Simpan kebijakan ini ke file bernama *trust-policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. Buat dokumen kebijakan IAM, seperti yang ditunjukkan di bawah ini. Simpan kebijakan ke file bernama *policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"elasticache:Connect"
],
"Resource" : [
"arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
"arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
]
}
]
}
```
------
1. Buat peran IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Buat kebijakan IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Lampirkan kebijakan IAM ke peran tersebut.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
1. Buat pengguna baru yang didukung IAM.
```
aws elasticache create-user \
--user-name iam-user-01 \
--user-id iam-user-01 \
--authentication-mode Type=iam \
--engine redis \
--access-string "on ~* +@all"
```
1. Buat grup pengguna dan lampirkan pengguna.
```
aws elasticache create-user-group \
--user-group-id iam-user-group-01 \
--engine redis \
--user-ids default iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Terhubung
**Terhubung dengan token sebagai kata sandi**
Pertama-tama, Anda harus membuat token autentikasi IAM berumur pendek menggunakan [permintaan AWS SigV4 yang telah ditandatangani sebelumnya](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html). Setelah itu Anda memberikan token otentikasi IAM sebagai kata sandi saat menghubungkan ke cache Valkey atau Redis OSS, seperti yang ditunjukkan pada contoh di bawah ini.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userId, iamAuthToken)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
Di bawah ini adalah definisi untuk `IAMAuthTokenRequest`.
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String PARAM_RESOURCE_TYPE = "ResourceType";
private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "elasticache";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userId;
private final String cacheName;
private final String region;
private final boolean isServerless;
public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) {
this.userId = userId;
this.cacheName = cacheName;
this.region = region;
this.isServerless = isServerless;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userId));
if (isServerless) {
request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE));
}
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**Terhubung dengan penyedia kredensial**
Kode di bawah ini menunjukkan cara mengautentikasi dengan ElastiCache menggunakan penyedia kredensi otentikasi IAM.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
// Create a Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userId, iamAuthTokenRequest, awsCredentialsProvider);
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
Di bawah ini adalah contoh klien OSS Lettuce Redis yang membungkus penyedia kredensi IAMAuth TokenRequest dalam untuk menghasilkan kredensi sementara secara otomatis bila diperlukan.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userId;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userId,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
}
```
# Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH
**catatan**
Yang **AUTH** telah digantikan oleh. [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md) Semua cache nirserver harus menggunakan RBAC untuk autentikasi.
Token atau kata sandi otentikasi Valkey dan Redis OSS memungkinkan Valkey dan Redis OSS untuk meminta kata sandi sebelum mengizinkan klien menjalankan perintah, sehingga meningkatkan keamanan data. **AUTH**Ini tersedia untuk cluster berbasis node saja.
**Topics**
+ [Ikhtisar AUTH ElastiCache untuk Valkey dan Redis OSS](#auth-overview)
+ [Menerapkan otentikasi ke cluster ElastiCache untuk Valkey dan Redis OSS](#auth-using)
+ [Memodifikasi token AUTH pada klaster yang telah ada](#auth-modifyng-token)
+ [Migrasi dari RBAC ke AUTH](#Migrate-From-RBAC-to-AUTH)
## Ikhtisar AUTH ElastiCache untuk Valkey dan Redis OSS
Saat Anda menggunakan cluster ElastiCache for Valkey dan Redis OSS Anda, ada beberapa penyempurnaan. **AUTH**
Secara khusus, perhatikan kendala token atau kata sandi AUTH ini saat menggunakan AUTH:
+ Token, atau kata sandi, harus berisi 16–128 karakter yang dapat dicetak.
+ Karakter non-alfanumerik yang diizinkan adalah (\$1, &, \$1, \$1, ^, <, >, -).
+ AUTH hanya dapat diaktifkan untuk enkripsi in-transit yang diaktifkan Valkey atau Redis OSS cluster.
Untuk menyiapkan token yang kuat, sebaiknya ikuti kebijakan kata sandi yang ketat, seperti yang mewajibkan hal berikut:
+ Token atau kata sandi harus mencakup setidaknya tiga dari jenis karakter berikut:
+ Karakter huruf besar
+ Karakter huruf kecil
+ Angka
+ Karakter non-alfanumerik (`!`, `&`, `#`, `$`, `^`, `<`, `>`, `-`)
+ Token atau kata sandi tidak boleh mengandung kata kamus atau kata kamus yang sedikit dimodifikasi.
+ Token atau kata sandi tidak boleh sama dengan atau mirip dengan token yang baru digunakan.
## Menerapkan otentikasi ke cluster ElastiCache untuk Valkey dan Redis OSS
Anda dapat meminta pengguna memasukkan token (kata sandi) pada server Valkey atau Redis OSS yang dilindungi token. Untuk melakukannya, sertakan parameter `--auth-token` (API: `AuthToken`) dengan token yang tepat ketika Anda membuat grup replikasi atau klaster Anda. Sertakan juga ke dalamnya semua perintah berikutnya untuk grup replikasi atau klaster.
AWS CLI Operasi berikut membuat grup replikasi dengan enkripsi dalam transit (TLS) diaktifkan dan token. **AUTH** `This-is-a-sample-token` Ganti grup subnet `sng-test` dengan grup subnet yang ada.
**Parameter Kunci**
+ **--engine**Harus `valkey` atau`redis`.
+ **--engine-version**— Jika mesin Redis OSS, harus 3.2.6, 4.0.10, atau yang lebih baru.
+ **--transit-encryption-enabled** – Wajib untuk autentikasi dan kelayakan HIPAA.
+ **--auth-token** – Wajib untuk kelayakan HIPAA. Nilai ini harus menjadi token yang benar untuk server Valkey atau Redis OSS yang dilindungi token ini.
+ **--cache-subnet-group** – Wajib untuk kelayakan HIPAA.
Untuk Linux, macOS, atau Unix:
```
aws elasticache create-replication-group \
--replication-group-id authtestgroup \
--replication-group-description authtest \
--engine redis \
--cache-node-type cache.m4.large \
--num-node-groups 1 \
--replicas-per-node-group 2 \
--transit-encryption-enabled \
--auth-token This-is-a-sample-token \
--cache-subnet-group sng-test
```
Untuk Windows:
```
aws elasticache create-replication-group ^
--replication-group-id authtestgroup ^
--replication-group-description authtest ^
--engine redis ^
--cache-node-type cache.m4.large ^
--num-node-groups 1 ^
--replicas-per-node-group 2 ^
--transit-encryption-enabled ^
--auth-token This-is-a-sample-token ^
--cache-subnet-group sng-test
```
## Memodifikasi token AUTH pada klaster yang telah ada
Untuk mempermudah memperbarui otentikasi Anda, Anda dapat memodifikasi **AUTH** token yang digunakan pada klaster. Anda dapat melakukan modifikasi ini jika versi mesinnya Valkey 7.2 atau lebih tinggi atau Redis 5.0.6 atau lebih tinggi. ElastiCache juga harus mengaktifkan enkripsi saat transit.
Mengubah token auth mendukung dua strategi: ROTATE dan SET. Strategi ROTATE menambahkan token AUTH tambahan ke server sambil mempertahankan token sebelumnya. Strategi SET memperbarui server untuk mendukung hanya satu token AUTH. Buat panggilan perubahan ini dengan parameter `--apply-immediately` untuk menerapkan perubahan dengan segera.
### Merotasi token AUTH
Untuk memperbarui server Valkey atau Redis OSS dengan **token AUTH** baru, panggil `ModifyReplicationGroup` API dengan `--auth-token` parameter sebagai **AUTH** token baru dan `--auth-token-update-strategy` dengan nilai ROTATE. Setelah modifikasi ROTATE selesai, cluster akan mendukung token AUTH sebelumnya selain yang ditentukan dalam `auth-token` parameter. Jika tidak ada token AUTH yang dikonfigurasi pada grup replikasi sebelum rotasi token AUTH, cluster mendukung token AUTH yang ditentukan dalam `--auth-token` parameter selain mendukung koneksi tanpa otentikasi. Lihat [Mengatur token AUTH](#auth-modifying-set) untuk memperbarui token AUTH agar diperlukan menggunakan strategi pembaruan SET.
**catatan**
Jika Anda tidak mengonfigurasi token AUTH sebelumnya, setelah perubahan selesai, klaster akan mendukung token no AUTH selain token yang ditentukan dalam parameter auth-token.
Jika modifikasi ini dilakukan pada server yang sudah mendukung dua token AUTH, token AUTH tertua juga akan dihapus selama operasi ini. Ini memungkinkan server untuk mendukung hingga dua token AUTH terbaru pada waktu tertentu.
Pada titik ini, Anda dapat melanjutkan dengan memperbarui klien untuk menggunakan token AUTH terbaru. Setelah klien diperbarui, Anda dapat menggunakan strategi SET untuk rotasi token **AUTH** (dijelaskan pada bagian berikut) untuk secara khusus mulai menggunakan token baru.
AWS CLI Operasi berikut memodifikasi grup replikasi untuk memutar token. **AUTH** `This-is-the-rotated-token`
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id authtestgroup \
--auth-token This-is-the-rotated-token \
--auth-token-update-strategy ROTATE \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id authtestgroup ^
--auth-token This-is-the-rotated-token ^
--auth-token-update-strategy ROTATE ^
--apply-immediately
```
### Mengatur token AUTH
Untuk memperbarui server Valkey atau Redis OSS untuk mendukung satu **AUTH** token yang diperlukan, panggil operasi `ModifyReplicationGroup` API dengan `--auth-token` parameter dengan nilai yang sama dengan token AUTH terakhir dan `--auth-token-update-strategy` parameter dengan nilai. `SET` Strategi SET hanya dapat digunakan dengan cluster yang memiliki 2 token AUTH atau 1 token AUTH opsional dari menggunakan strategi ROTATE sebelumnya. Setelah modifikasi selesai, server hanya mendukung token AUTH yang ditentukan dalam parameter auth-token.
AWS CLI Operasi berikut memodifikasi grup replikasi untuk mengatur token AUTH ke. `This-is-the-set-token`
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id authtestgroup \
--auth-token This-is-the-set-token \
--auth-token-update-strategy SET \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id authtestgroup ^
--auth-token This-is-the-set-token ^
--auth-token-update-strategy SET ^
--apply-immediately
```
### Mengaktifkan autentikasi pada klaster yang telah ada
Untuk mengaktifkan otentikasi pada server Valkey atau Redis OSS yang ada, panggil operasi API. `ModifyReplicationGroup` Panggil `ModifyReplicationGroup` dengan parameter `--auth-token` sebagai token baru dan `--auth-token-update-strategy` dengan nilai ROTATE.
Setelah modifikasi ROTATE selesai, cluster mendukung **AUTH** token yang ditentukan dalam `--auth-token` parameter selain mendukung koneksi tanpa otentikasi. Setelah semua aplikasi klien diperbarui untuk mengautentikasi ke Valkey atau Redis OSS dengan token AUTH, gunakan strategi SET untuk menandai token AUTH sesuai kebutuhan. Mengaktifkan otentikasi hanya didukung pada server Valkey dan Redis OSS dengan enkripsi dalam transit (TLS) diaktifkan.
## Migrasi dari RBAC ke AUTH
Jika Anda mengautentikasi pengguna dengan Valkey atau Redis OSS Role-Based Access Control (RBAC) seperti yang dijelaskan dalam[Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md), dan Anda ingin bermigrasi ke AUTH, gunakan prosedur berikut. Anda dapat bermigrasi menggunakan konsol atau CLI.
**Untuk bermigrasi dari RBAC ke AUTH menggunakan 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 daftar di sudut kanan atas, pilih AWS Wilayah tempat cluster yang ingin Anda modifikasi berada.
1. Di panel navigasi, pilih mesin yang berjalan pada klaster yang ingin diubah.
Daftar klaster mesin yang dipilih akan muncul.
1. Dalam daftar klaster tersebut, pilih nama klaster yang ingin Anda ubah.
1. Untuk **Tindakan**, pilih **Ubah**.
Jendela **Ubah** muncul.
1. Untuk **kontrol Akses**, pilih akses pengguna default **Valkey AUTH atau akses pengguna default** **Redis OSS AUTH**.
1. Di bawah token **Valkey AUTH atau token** AUTH **Redis OSS, tetapkan token baru**.
1. Pilih **Pratinjau perubahan**, lalu di layar berikutnya, pilih **Ubah**.
**Untuk bermigrasi dari RBAC ke AUTH menggunakan AWS CLI**
Gunakan salah satu perintah berikut untuk mengonfigurasi **AUTH** token opsional baru untuk grup replikasi Valkey atau Redis OSS Anda. Perhatikan bahwa token Auth opsional akan memungkinkan akses tidak diautentikasi ke grup replikasi hingga token Auth ditandai sesuai kebutuhan, menggunakan strategi `SET` pembaruan pada langkah berikut.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id test \
--remove-user-groups \
--auth-token This-is-a-sample-token \
--auth-token-update-strategy ROTATE \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id test ^
--remove-user-groups ^
--auth-token This-is-a-sample-token ^
--auth-token-update-strategy ROTATE ^
--apply-immediately
```
Setelah menjalankan perintah di atas, Anda dapat memperbarui aplikasi Valkey atau Redis OSS Anda untuk mengautentikasi ke grup ElastiCache replikasi menggunakan token AUTH opsional yang baru dikonfigurasi. Untuk menyelesaikan rotasi token Auth, gunakan strategi pembaruan pada perintah berikutnya `SET` di bawah ini. Ini akan menandai token AUTH opsional sesuai kebutuhan. Ketika pembaruan token Auth selesai, status grup replikasi akan ditampilkan sebagai `ACTIVE` dan semua koneksi ke grup replikasi ini akan memerlukan otentikasi.
Untuk Linux, macOS, atau Unix:
```
aws elasticache modify-replication-group \
--replication-group-id test \
--auth-token This-is-a-sample-token \
--auth-token-update-strategy SET \
--apply-immediately
```
Untuk Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id test ^
--remove-user-groups ^
--auth-token This-is-a-sample-token ^
--auth-token-update-strategy SET ^
--apply-immediately
```
Untuk informasi selengkapnya, lihat [Mengautentikasi dengan perintah Valkey dan Redis OSS AUTH](#auth).
**catatan**
Jika Anda perlu menonaktifkan kontrol akses pada ElastiCache Cluster, lihat[Menonaktifkan kontrol akses pada cache ElastiCache Valkey atau Redis OSS](in-transit-encryption-disable.md).
# Menonaktifkan kontrol akses pada cache ElastiCache Valkey atau Redis OSS
Ikuti petunjuk di bawah ini untuk menonaktifkan kontrol akses pada cache Valkey atau Redis OSS TLS-enabled. Cache Anda akan memiliki salah satu dari dua jenis konfigurasi yang berbeda: AUTH default user access atau User group access control list (RBAC). Jika cache Anda dibuat dengan konfigurasi AUTH, Anda harus mengubahnya ke konfigurasi RBAC sebelum Anda dapat menonaktifkan cache dengan menghapus grup pengguna. Jika cache Anda dibuat dengan konfigurasi RBAC, Anda dapat langsung menonaktifkannya.
**Untuk menonaktifkan cache tanpa server Valkey atau Redis OSS yang dikonfigurasi dengan RBAC**
1. Hapus grup pengguna untuk menonaktifkan kontrol akses.
```
aws elasticache modify-serverless-cache --serverless-cache-name --remove-user-group
```
1. (Opsional) Pastikan bahwa tidak ada grup pengguna yang terkait dengan cache nirserver.
```
aws elasticache describe-serverless-caches --serverless-cache-name
{
"..."
"UserGroupId": ""
"..."
}
```
**Untuk menonaktifkan cache Valkey atau Redis OSS dengan dikonfigurasi dengan token AUTH**
1. Ubah token AUTH ke RBAC dan tentukan grup pengguna yang akan ditambahkan.
```
aws elasticache modify-replication-group --replication-group-id --auth-token-update-strategy DELETE --user-group-ids-to-add
```
1. Verifikasi bahwa token AUTH dinonaktifkan dan grup pengguna telah ditambahkan.
```
aws elasticache describe-replication-groups --replication-group-id
{
"..."
"AuthTokenEnabled": false,
"UserGroupIds": [
""
]
"..."
}
```
1. Hapus grup pengguna untuk menonaktifkan kontrol akses.
```
aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove
{
"..."
"PendingModifiedValues": {
"UserGroups": {
"UserGroupIdsToAdd": [],
"UserGroupIdsToRemove": [
""
]
}
"..."
}
```
1. (Opsional) Pastikan bahwa tidak ada grup pengguna yang terkait dengan klaster. Bidang `AuthTokenEnabled` juga harus menampilkan salah (false).
```
aws elasticache describe-replication-groups --replication-group-id
"AuthTokenEnabled": false
```
**Untuk menonaktifkan cluster Valkey atau Redis OSS yang dikonfigurasi dengan RBAC**
1. Hapus grup pengguna untuk menonaktifkan kontrol akses.
```
aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove
{
"..."
"PendingModifiedValues": {
"UserGroups": {
"UserGroupIdsToAdd": [],
"UserGroupIdsToRemove": [
""
]
}
"..."
}
```
1. (Opsional) Pastikan bahwa tidak ada grup pengguna yang terkait dengan klaster. Bidang `AuthTokenEnabled` juga harus menampilkan salah (false).
```
aws elasticache describe-replication-groups --replication-group-id
"AuthTokenEnabled": false
```