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