Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Perlindungan data di MemoryDB
[Model tanggung jawab AWS bersama model](https://aws.amazon.com/compliance/shared-responsibility-model/) berlaku untuk perlindungan data di. Seperti yang dijelaskan dalam model AWS ini, bertanggung jawab untuk melindungi infrastruktur global yang menjalankan semua AWS Cloud. Anda bertanggung jawab untuk mempertahankan kendali atas konten yang di-host pada infrastruktur ini. Anda juga bertanggung jawab atas tugas-tugas konfigurasi dan manajemen keamanan untuk Layanan AWS yang Anda gunakan. Lihat informasi yang lebih lengkap tentang privasi data dalam [Pertanyaan Umum Privasi Data](https://aws.amazon.com/compliance/data-privacy-faq/). Lihat informasi tentang perlindungan data di Eropa di pos blog [Model Tanggung Jawab Bersama dan GDPR AWS](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) di *Blog Keamanan AWS *.
Untuk tujuan perlindungan data, kami menyarankan Anda melindungi Akun AWS kredensil dan mengatur pengguna individu dengan AWS IAM Identity Center atau AWS Identity and Access Management (IAM). Dengan cara itu, setiap pengguna hanya diberi izin yang diperlukan untuk memenuhi tanggung jawab tugasnya. Kami juga menyarankan supaya Anda mengamankan data dengan cara-cara berikut:
+ Gunakan autentikasi multi-faktor (MFA) pada setiap akun.
+ Gunakan SSL/TLS untuk berkomunikasi dengan AWS sumber daya. Kami mensyaratkan TLS 1.2 dan menganjurkan TLS 1.3.
+ Siapkan API dan logging aktivitas pengguna dengan AWS CloudTrail. Untuk informasi tentang penggunaan CloudTrail jejak untuk menangkap AWS aktivitas, lihat [Bekerja dengan CloudTrail jejak](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) di *AWS CloudTrail Panduan Pengguna*.
+ Gunakan solusi AWS enkripsi, bersama dengan semua kontrol keamanan default di dalamnya Layanan AWS.
+ Gunakan layanan keamanan terkelola tingkat lanjut seperti Amazon Macie, yang membantu menemukan dan mengamankan data sensitif yang disimpan di Amazon S3.
+ Jika Anda memerlukan modul kriptografi tervalidasi FIPS 140-3 saat mengakses AWS melalui antarmuka baris perintah atau API, gunakan titik akhir FIPS. Lihat informasi selengkapnya tentang titik akhir FIPS yang tersedia di [Standar Pemrosesan Informasi Federal (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Kami sangat merekomendasikan agar Anda tidak pernah memasukkan informasi identifikasi yang sensitif, seperti nomor rekening pelanggan Anda, ke dalam tanda atau bidang isian bebas seperti bidang **Nama**. Ini termasuk saat Anda bekerja dengan atau lainnya Layanan AWS menggunakan konsol, API AWS CLI, atau AWS SDKs. Data apa pun yang Anda masukkan ke dalam tanda atau bidang isian bebas yang digunakan untuk nama dapat digunakan untuk log penagihan atau log diagnostik. Saat Anda memberikan URL ke server eksternal, kami sangat menganjurkan supaya Anda tidak menyertakan informasi kredensial di dalam URL untuk memvalidasi permintaan Anda ke server itu.
# Keamanan data di MemoryDB
Untuk membantu menjaga keamanan data Anda, MemoryDB dan Amazon EC2 menyediakan mekanisme untuk melindungi terhadap akses data Anda yang tidak sah di server.
MemoryDB juga menyediakan fitur enkripsi untuk data pada cluster:
+ Enkripsi in-transit mengenkripsi data Anda setiap kali data bergerak dari satu tempat ke tempat lain, misalnya antara beberapa simpul di klaster Anda atau antara klaster dan aplikasi Anda.
+ Enkripsi AT-rest mengenkripsi log transaksi dan data on-disk Anda selama operasi snapshot.
Anda juga dapat menggunakan [Mengautentikasi pengguna dengan Daftar Kontrol Akses () ACLs](clusters.acls.md) untuk mengontrol akses pengguna ke cluster Anda.
**Topics**
+ [Keamanan data di MemoryDB](encryption.md)
+ [Enkripsi At-Rest di MemoryDB](at-rest-encryption.md)
+ [Enkripsi dalam transit (TLS) di MemoryDB](in-transit-encryption.md)
+ [Mengautentikasi pengguna dengan Daftar Kontrol Akses () ACLs](clusters.acls.md)
+ [Autentikasi dengan IAM](auth-iam.md)
# Enkripsi At-Rest di MemoryDB
Untuk membantu menjaga keamanan data Anda, MemoryDB dan Amazon S3 menyediakan berbagai cara untuk membatasi akses ke data di cluster Anda. Untuk informasi selengkapnya, lihat [MemoryDB dan Amazon VPC](vpcs.md) dan [Manajemen identitas dan akses di MemoryDB](iam.md).
Enkripsi saat istirahat MemoryDB selalu diaktifkan untuk meningkatkan keamanan data dengan mengenkripsi data persisten. Ini mengenkripsi aspek-aspek berikut:
+ Data dalam log transaksi
+ Disk selama operasi sinkronisasi, snapshot, dan swap
+ Snapshot disimpan di Amazon S3
MemoryDB menawarkan enkripsi default (dikelola layanan) saat istirahat, serta kemampuan untuk menggunakan kunci root pelanggan yang dikelola pelanggan simetris Anda sendiri di [AWS Key Management Service (](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)KMS).
Data yang disimpan pada SSDs (solid-state drive) dalam cluster yang diaktifkan tingkat data selalu dienkripsi secara default.
Untuk informasi tentang enkripsi in-transit, lihat [Enkripsi dalam transit (TLS) di MemoryDB](in-transit-encryption.md)
**Topics**
+ [Menggunakan Customer Managed Keys dari AWS KMS](#using-customer-managed-keys-for-memorydb-security)
+ [Lihat Juga](#at-rest-encryption-see-also)
## Menggunakan Customer Managed Keys dari AWS KMS
MemoryDB mendukung kunci root terkelola 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 Root Pelanggan](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) di *Panduan Pengembang Layanan Manajemen AWS Kunci*. Kunci harus dibuat di AWS KMS sebelum dapat digunakan dengan MemoryDB.
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*.
MemoryDB 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 integrasi MemoryDB dengan AWS KMS.
Kunci `kms:ViaService` kondisi membatasi penggunaan kunci AWS KMS untuk permintaan dari AWS layanan tertentu. Untuk digunakan `kms:ViaService` dengan MemoryDB, sertakan kedua ViaService nama dalam nilai kunci kondisi:. `memorydb.amazon_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 dikirimkan MemoryDB AWS Key Management Service 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 dibuat oleh MemoryDB dengan memanggil panggilan API [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)KMS.
Setelah cluster dienkripsi menggunakan kunci yang dikelola pelanggan, semua snapshot untuk cluster dienkripsi sebagai berikut:
+ Snapshot harian otomatis dienkripsi menggunakan kunci yang dikelola pelanggan yang terkait dengan cluster.
+ Snapshot akhir yang dibuat saat cluster dihapus, juga dienkripsi menggunakan kunci terkelola pelanggan yang terkait dengan cluster.
+ Snapshot yang dibuat secara manual dienkripsi secara default untuk menggunakan kunci KMS yang terkait dengan cluster. Anda dapat menggantinya dengan memilih kunci dikelola pelanggan yang lain.
+ Menyalin snapshot secara default menggunakan kunci terkelola pelanggan yang terkait dengan snapshot sumber. Anda dapat menggantinya dengan memilih kunci dikelola pelanggan yang lain.
**catatan**
Kunci terkelola pelanggan tidak dapat digunakan saat mengekspor snapshot ke bucket Amazon S3 yang Anda pilih. [Namun, semua snapshot yang diekspor ke Amazon S3 dienkripsi menggunakan enkripsi sisi Server.](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) Anda dapat memilih untuk menyalin file snapshot 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 snapshot yang dibuat secara manual yang tidak menggunakan kunci yang dikelola pelanggan untuk enkripsi. Dengan opsi ini, file snapshot yang disimpan di Amazon S3 dienkripsi menggunakan kunci KMS, meskipun data tidak dienkripsi pada cluster asli.
Memulihkan dari snapshot memungkinkan Anda memilih dari opsi enkripsi yang tersedia, mirip dengan pilihan enkripsi yang tersedia saat membuat cluster baru.
+ Jika Anda menghapus kunci atau [menonaktifkan](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) kunci dan [mencabut hibah](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html) untuk kunci yang Anda gunakan untuk mengenkripsi klaster, cluster 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 snapshot untuk tujuan arsip.
+ Rotasi kunci otomatis mempertahankan properti kunci root AWS KMS Anda, sehingga rotasi tidak berpengaruh pada kemampuan Anda untuk mengakses data MemoryDB Anda. Cluster MemoryDB 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 Root Pelanggan](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) di *Panduan Pengembang Layanan Manajemen AWS Kunci*.
+ Mengenkripsi cluster MemoryDB menggunakan kunci KMS memerlukan satu hibah per cluster. Hibah ini digunakan sepanjang umur cluster. Selain itu, satu hibah per snapshot digunakan selama pembuatan snapshot. Hibah ini dihentikan setelah snapshot dibuat.
+ Untuk informasi selengkapnya tentang AWS hibah dan batasan KMS, lihat [Kuota di Panduan](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) Pengembang *Layanan Manajemen AWS Utama*.
## Lihat Juga
+ [Enkripsi dalam transit (TLS) di MemoryDB](in-transit-encryption.md)
+ [MemoryDB dan Amazon VPC](vpcs.md)
+ [Manajemen identitas dan akses di MemoryDB](iam.md)
# Enkripsi dalam transit (TLS) di MemoryDB
Untuk membantu menjaga keamanan data Anda, MemoryDB dan Amazon EC2 menyediakan mekanisme untuk melindungi terhadap akses data Anda yang tidak sah di server. Dengan menyediakan kemampuan enkripsi dalam perjalanan, MemoryDB memberi Anda alat yang dapat Anda gunakan untuk membantu melindungi data Anda saat berpindah dari satu lokasi ke lokasi lain. Misalnya, Anda dapat memindahkan data dari node utama ke node replika baca di dalam klaster, atau antara cluster dan aplikasi Anda.
**Topics**
+ [Gambaran umum enkripsi bergerak](#in-transit-encryption-overview)
+ [Lihat juga](#in-transit-encryption-see-also)
## Gambaran umum enkripsi bergerak
Enkripsi dalam transit MemoryDB adalah fitur yang meningkatkan keamanan data Anda pada titik yang paling rentan — saat transit dari satu lokasi ke lokasi lain.
Enkripsi dalam transit MemoryDB mengimplementasikan fitur-fitur berikut:
+ Koneksi **terenkripsi — baik koneksi** server dan klien dienkripsi Transport Layer Security (TLS).
+ **Replikasi terenkripsi—** data yang bergerak antara node primer dan node replika dienkripsi.
+ **Autentikasi server**—Klien dapat mengautentikasi bahwa koneksinya dilakukan ke server yang benar.
Mulai 07/20/2023, TLS 1.2 adalah versi minimum yang didukung untuk cluster baru dan yang sudah ada. Gunakan [tautan](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/) ini untuk mempelajari lebih lanjut tentang TLS 1.2 di AWS.
Untuk informasi lebih lanjut tentang menghubungkan ke cluster MemoryDB, lihat. [Menghubungkan ke node MemoryDB menggunakan redis-cli](getting-started.md#connect-tls)
## Lihat juga
+ [Enkripsi At-Rest di MemoryDB](at-rest-encryption.md)
+ [Mengautentikasi Pengguna dengan Daftar Kontrol Akses () ACLs](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html)
+ [MemoryDB dan Amazon VPC](vpcs.md)
+ [Manajemen identitas dan akses di MemoryDB](iam.md)
# Mengautentikasi pengguna dengan Daftar Kontrol Akses () ACLs
Anda dapat mengautentikasi pengguna dengan daftar kontrol Access (ACLs).
ACLs memungkinkan Anda untuk mengontrol akses cluster dengan mengelompokkan pengguna. Daftar kontrol Access ini dirancang sebagai cara untuk mengatur akses ke cluster.
Dengan ACLs, Anda membuat pengguna dan menetapkan mereka izin tertentu dengan menggunakan string akses, seperti yang dijelaskan di bagian berikutnya. Anda menetapkan pengguna ke daftar kontrol Access selaras dengan peran tertentu (administrator, sumber daya manusia) yang kemudian disebarkan ke satu atau beberapa cluster MemoryDB. Dengan melakukan ini, Anda dapat menetapkan batas keamanan antara klien menggunakan cluster atau cluster MemoryDB yang sama dan mencegah klien mengakses data satu sama lain.
ACLs dirancang untuk mendukung pengenalan [ACL](https://valkey.io/docs/topics/acl/) di Redis OSS 6. Bila Anda menggunakan ACLs dengan cluster MemoryDB Anda, ada beberapa batasan:
+ Anda tidak dapat menentukan kata sandi dalam string akses. Anda mengatur kata sandi dengan [CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html)atau [UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html)panggilan.
+ Untuk hak pengguna, Anda meneruskan `on` dan `off` sebagai bagian dari string akses. Jika keduanya tidak ditentukan dalam string akses, pengguna ditugaskan `off` dan tidak memiliki hak akses ke cluster.
+ Anda tidak dapat menggunakan perintah terlarang. Jika Anda menentukan perintah terlarang, pengecualian akan dilemparkan. Untuk daftar perintah tersebut, lihat[Perintah terbatas](restrictedcommands.md).
+ Anda tidak dapat menggunakan perintah `reset` sebagai bagian dari string akses. Anda menentukan kata sandi dengan parameter API, dan MemoryDB 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 menampilkan daftar pengguna beserta aturan ACL yang berlaku untuk setiap pengguna. MemoryDB mendukung `ACL LIST` perintah, tetapi tidak menyertakan dukungan untuk hash kata sandi seperti yang dilakukan Redis OSS. Dengan MemoryDB, Anda dapat menggunakan [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)operasi untuk mendapatkan informasi serupa, termasuk aturan yang terkandung dalam string akses. Namun, [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)tidak mengambil kata sandi pengguna.
[Perintah read-only lainnya yang didukung oleh MemoryDB termasuk [ACL WHOAMI, ACL](https://valkey.io/commands/acl-whoami) USERS, dan [ACL](https://valkey.io/commands/acl-users) CAT.](https://valkey.io/commands/acl-cat) MemoryDB tidak mendukung perintah ACL berbasis tulis lainnya.
Menggunakan ACLs dengan MemoryDB dijelaskan secara lebih rinci berikut.
**Topics**
+ [Menentukan Izin Menggunakan String Akses](#access-string)
+ [Kemampuan pencarian vektor](#access-vss)
+ [Menerapkan ACLs ke cluster untuk MemoryDB](#rbac-using)
## Menentukan Izin Menggunakan String Akses
Untuk menentukan izin ke cluster MemoryDB, Anda membuat string akses dan menetapkannya ke pengguna, menggunakan salah satu atau. AWS CLI Konsol 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. Untuk dapat menjalankan perintah, pengguna harus memiliki akses ke perintah yang dijalankan dan semua kunci yang diakses oleh perintah itu. 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 sintaks 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.
+ `&*`— Akses diberikan ke semua saluran pubsub.
+ `+@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 Daftar Kontrol Akses dengan Konsol dan CLI](#users-management).
Jika Anda memigrasikan beban kerja yang ada ke MemoryDB, Anda dapat mengambil string akses dengan menelepon`ACL LIST`, tidak termasuk pengguna dan hash kata sandi apa pun.
## Kemampuan pencarian vektor
Untuk[Pencarian vektor](vector-search.md), semua perintah pencarian termasuk dalam `@search` kategori dan kategori yang ada `@read``@write`, `@fast` dan `@slow` diperbarui untuk menyertakan perintah pencarian. Jika pengguna tidak memiliki akses ke kategori, maka pengguna tidak memiliki akses ke perintah apa pun dalam kategori tersebut. Misalnya, jika pengguna tidak memiliki akses ke`@search`, maka pengguna tidak dapat menjalankan perintah terkait pencarian.
Tabel berikut menunjukkan pemetaan perintah pencarian ke kategori yang sesuai.
| Perintah VSS | @read | @write | @fast | @slow |
| --- | --- | --- | --- | --- |
| FT.CREATE | | Y | Y | |
| FT.DROPINDEX | | Y | Y | |
| FT.LIST | Y | | | Y |
| FT.INFO | Y | | Y | |
| FT.SEARCH | Y | | | Y |
| FT.AGGREGATE | Y | | | Y |
| FT.PROFILE | Y | | | Y |
| FT.ALIASADD | | Y | Y | |
| FT.ALIASDEL | | Y | Y | |
| FT.ALIASUPDATE | | Y | Y | |
| FT.\$1ALIASLIST | Y | | | Y |
| FT.EXPLAIN | Y | | Y | |
| FT.EXPLAINCLI | Y | | Y | |
| FT.CONFIG | Y | | Y | |
## Menerapkan ACLs ke cluster untuk MemoryDB
Untuk menggunakan MemoryDB ACLs, Anda mengambil langkah-langkah berikut:
1. Buat satu atau beberapa pengguna.
1. Buat ACL dan tambahkan pengguna ke daftar.
1. Tetapkan ACL ke cluster.
Langkah ini dijelaskan secara mendetail di bagian berikut.
**Topics**
+ [Membuat Pengguna dan Daftar Kontrol Akses dengan Konsol dan CLI](#users-management)
+ [Mengelola Daftar Kontrol Akses dengan Konsol dan CLI](#user-groups)
+ [Menetapkan daftar kontrol Akses ke cluster](#users-groups-to-clusterss)
### Membuat Pengguna dan Daftar Kontrol Akses dengan Konsol dan CLI
Informasi pengguna untuk ACLs pengguna adalah nama pengguna, dan secara opsional kata sandi dan string akses. String akses menyediakan tingkat izin pada kunci dan perintah. Nama ini unik untuk pengguna dan itulah yang diteruskan ke mesin.
Pastikan bahwa izin pengguna yang Anda berikan masuk akal dengan tujuan ACL yang dimaksudkan. Misalnya, jika Anda membuat ACL yang dipanggil`Administrators`, setiap pengguna yang Anda tambahkan ke grup itu harus memiliki string aksesnya disetel ke akses penuh ke kunci dan perintah. Untuk pengguna di `e-commerce` ACL, Anda dapat mengatur string akses mereka ke akses hanya-baca.
MemoryDB secara otomatis mengkonfigurasi pengguna default per akun dengan nama pengguna. `"default"` Ini tidak akan dikaitkan dengan cluster apa pun kecuali eksplisit ditambahkan ke ACL. 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.
ACL “akses terbuka” yang tidak dapat diubah akan dibuat untuk setiap akun yang berisi pengguna default. Ini adalah satu-satunya ACL pengguna default dapat menjadi anggota. Saat Anda membuat cluster, Anda harus memilih ACL untuk dikaitkan dengan cluster. Meskipun Anda memiliki opsi untuk menerapkan ACL “akses terbuka” dengan pengguna default, kami sangat menyarankan untuk membuat ACL dengan pengguna yang memiliki izin terbatas pada kebutuhan bisnis mereka.
Cluster yang tidak mengaktifkan TLS harus menggunakan ACL “akses terbuka” untuk memberikan otentikasi terbuka.
ACLs dapat dibuat tanpa pengguna. ACL kosong tidak akan memiliki akses ke cluster dan hanya dapat dikaitkan dengan cluster yang mendukung TLS.
Saat membuat pengguna, Anda dapat menetapkan hingga dua kata sandi. Saat Anda memodifikasi kata sandi, koneksi apa pun yang ada ke cluster dipertahankan.
Secara khusus, perhatikan kendala kata sandi pengguna ini saat menggunakan ACLs untuk MemoryDB:
+ Kata sandi harus terdiri dari 16–128 karakter yang dapat dicetak.
+ Karakter non-alfanumerik berikut tidak diizinkan: `,` `""` `/` `@`.
#### Mengelola Pengguna dengan Konsol dan CLI
##### Membuat pengguna (Konsol)
**Untuk membuat pengguna di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Pengguna**.
1. Pilih **Buat pengguna**
1. Pada halaman **Buat pengguna**, masukkan **Nama**.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
1. Di bawah **Kata Sandi**, Anda dapat memasukkan hingga dua kata sandi.
1. Di bawah **Access string**, masukkan string akses. String akses menetapkan tingkat izin untuk kunci dan perintah yang boleh digunakan pengguna.
1. Untuk **Tag**, Anda dapat menerapkan tag secara opsional untuk mencari dan memfilter pengguna Anda atau melacak AWS biaya Anda.
1. Pilih **Buat**.
##### Membuat pengguna menggunakan AWS CLI
**Untuk membuat pengguna dengan menggunakan CLI**
+ Gunakan perintah [create-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-user.html) untuk membuat pengguna.
Untuk Linux, macOS, atau Unix:
```
aws memorydb create-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode \
Passwords="abc",Type=password
```
Untuk Windows:
```
aws memorydb create-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode \
Passwords="abc",Type=password
```
##### Memodifikasi pengguna (Konsol)
**Untuk memodifikasi pengguna di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Pengguna**.
1. Pilih tombol radio di sebelah pengguna yang ingin Anda modifikasi dan kemudian pilih **Tindakan** -> **Ubah**
1. Jika Anda ingin mengubah kata sandi, pilih tombol radio **Ubah kata sandi**. Perhatikan bahwa jika Anda memiliki dua kata sandi, Anda harus memasukkan keduanya saat memodifikasi salah satunya.
1. Jika Anda memperbarui string akses, masukkan yang baru.
1. Pilih **Ubah**.
##### Memodifikasi pengguna menggunakan AWS CLI
**Untuk mengubah pengguna menggunakan CLI**
1. Gunakan perintah [update-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-user.html) untuk memodifikasi pengguna.
1. Ketika pengguna dimodifikasi, daftar kontrol Access yang terkait dengan pengguna diperbarui, bersama dengan cluster apa pun yang terkait dengan ACL. Semua koneksi yang ada akan dipertahankan. Berikut ini adalah beberapa contohnya.
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*"
```
Untuk Windows:
```
aws memorydb update-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*"
```
##### Melihat detail pengguna (Konsol)
**Untuk melihat detail pengguna di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Pengguna**.
1. Pilih pengguna di bawah **Nama pengguna** atau gunakan kotak pencarian untuk menemukan pengguna.
1. Di bawah **Pengaturan pengguna**, Anda dapat meninjau string akses pengguna, jumlah kata sandi, status, dan Nama Sumber Daya Amazon (ARN).
1. Di bawah **Daftar kontrol akses (ACL)** Anda dapat meninjau ACL milik pengguna.
1. Di bawah **Tag**, Anda dapat meninjau tag apa pun yang terkait dengan pengguna.
##### Melihat detail pengguna menggunakan AWS CLI
Gunakan [perintah deskripsikan pengguna](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-users.html) untuk melihat detail pengguna.
```
aws memorydb describe-users \
--user-name my-user-name
```
##### Menghapus pengguna (Konsol)
**Untuk menghapus pengguna di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Pengguna**.
1. Pilih tombol radio di sebelah pengguna yang ingin Anda modifikasi dan kemudian pilih **Tindakan** -> **Hapus**
1. Untuk mengonfirmasi, masukkan `delete` di kotak teks konfirmasi dan kemudian pilih **Hapus**.
1. Untuk membatalkan, pilih **Batalkan**.
##### Menghapus pengguna menggunakan AWS CLI
**Untuk menghapus pengguna menggunakan CLI**
+ Gunakan perintah [delete-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-user.html) untuk menghapus pengguna.
Akun dihapus dan dihapus dari daftar kontrol Akses apa pun yang menjadi miliknya. Berikut adalah contohnya.
Untuk Linux, macOS, atau Unix:
```
aws memorydb delete-user \
--user-name user-name-2
```
Untuk Windows:
```
aws memorydb delete-user ^
--user-name user-name-2
```
### Mengelola Daftar Kontrol Akses dengan Konsol dan CLI
Anda dapat membuat daftar kontrol Access untuk mengatur dan mengontrol akses pengguna ke satu atau beberapa cluster, seperti yang ditunjukkan berikut.
Gunakan prosedur berikut untuk mengelola daftar kontrol Access menggunakan konsol.
#### Membuat Daftar Kontrol Akses (ACL) (Konsol)
**Untuk membuat daftar kontrol Access menggunakan konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Daftar kontrol akses (ACL**).
1. Pilih **Buat ACL**.
1. Pada halaman **Create Access Control List (ACL)**, masukkan nama ACL.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
1. Di bawah **Pengguna terpilih** melakukan salah satu hal berikut:
1. Buat pengguna baru dengan memilih **Buat pengguna**
1. Tambahkan pengguna dengan memilih **Kelola** lalu pilih pengguna dari dialog **Kelola pengguna** lalu pilih **Pilih**.
1. Untuk **Tag**, Anda dapat menerapkan tag secara opsional untuk mencari dan memfilter ACLs atau melacak AWS biaya Anda.
1. Pilih **Buat**.
#### Membuat Access Control List (ACL) menggunakan AWS CLI
Gunakan prosedur berikut untuk membuat daftar kontrol Akses menggunakan CLI.
**Untuk membuat ACL baru dan menambahkan pengguna dengan menggunakan CLI**
+ Gunakan perintah [create-acl untuk membuat ACL](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-acl.html).
Untuk Linux, macOS, atau Unix:
```
aws memorydb create-acl \
--acl-name "new-acl-1" \
--user-names "user-name-1" "user-name-2"
```
Untuk Windows:
```
aws memorydb create-acl ^
--acl-name "new-acl-1" ^
--user-names "user-name-1" "user-name-2"
```
#### Memodifikasi Daftar Kontrol Akses (ACL) (konsol)
**Untuk mengubah daftar kontrol Access menggunakan konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Daftar kontrol akses (ACL**).
1. **Pilih ACL yang ingin Anda ubah dan kemudian pilih Modify**
1. Pada halaman **Ubah**, di bawah **Pengguna yang dipilih** lakukan salah satu hal berikut:
1. Buat pengguna baru dengan memilih **Buat pengguna** untuk ditambahkan ke ACL.
1. Menambah atau menghapus pengguna dengan memilih **Kelola** lalu memilih atau menghapus pilihan pengguna dari dialog **Kelola pengguna** lalu memilih **Pilih**.
1. Pada halaman **Create Access Control List (ACL)**, masukkan nama ACL.
Batasan penamaan klaster adalah sebagai berikut:
+ Harus berisi 1–40 karakter alfanumerik atau tanda hubung.
+ Harus diawali dengan huruf.
+ Tidak boleh berisi dua tanda hubung berurutan.
+ Tidak boleh diakhiri dengan tanda hubung.
1. Di bawah **Pengguna terpilih** melakukan salah satu hal berikut:
1. Buat pengguna baru dengan memilih **Buat pengguna**
1. Tambahkan pengguna dengan memilih **Kelola** lalu pilih pengguna dari dialog **Kelola pengguna** lalu pilih **Pilih**.
1. Pilih **Ubah** untuk menyimpan perubahan Anda atau **Batalkan** untuk membuangnya.
#### Memodifikasi Access Control List (ACL) menggunakan AWS CLI
**Untuk memodifikasi ACL dengan menambahkan pengguna baru atau menghapus anggota saat ini dengan menggunakan CLI**
+ Gunakan perintah [update-acl untuk memodfikasi ACL](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-acl.html).
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-acl --acl-name new-acl-1 \
--user-names-to-add user-name-3 \
--user-names-to-remove user-name-2
```
Untuk Windows:
```
aws memorydb update-acl --acl-name new-acl-1 ^
--user-names-to-add user-name-3 ^
--user-names-to-remove user-name-2
```
**catatan**
Setiap koneksi terbuka milik pengguna yang dihapus dari ACL diakhiri dengan perintah ini.
#### Melihat detail Daftar Kontrol Akses (ACL) (Konsol)
**Untuk melihat detail ACL di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Daftar kontrol akses (ACL**).
1. Pilih ACL di bawah **nama ACL** atau gunakan kotak pencarian untuk menemukan ACL.
1. Di bawah **Pengguna**, Anda dapat meninjau daftar pengguna yang terkait dengan ACL.
1. Di bawah **Kluster terkait**, Anda dapat meninjau klaster tempat ACL berada.
1. Di bawah **Tag** Anda dapat meninjau tag apa pun yang terkait dengan ACL.
#### Melihat Daftar Kontrol Akses (ACL) menggunakan AWS CLI
Gunakan perintah [describe-acls](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-acls.html) untuk melihat detail ACL.
```
aws memorydb describe-acls \
--acl-name test-group
```
#### Menghapus Daftar Kontrol Akses (ACL) (konsol)
**Untuk menghapus daftar kontrol Access menggunakan konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Di panel navigasi kiri, pilih **Daftar kontrol akses (ACL**).
1. **Pilih ACL yang ingin Anda ubah dan kemudian pilih Hapus**
1. Pada halaman **Hapus**, masukkan `delete` di kotak konfirmasi dan pilih **Hapus** atau **Batal** untuk menghindari penghapusan ACL.
ACL itu sendiri, bukan pengguna yang termasuk dalam grup, dihapus.
#### Menghapus Access Control List (ACL) menggunakan AWS CLI
**Untuk menghapus ACL dengan menggunakan CLI**
+ Gunakan perintah [delete-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-acl.html) untuk menghapus ACL.
Untuk Linux, macOS, atau Unix:
```
aws memorydb delete-acl /
--acl-name
```
Untuk Windows:
```
aws memorydb delete-acl ^
--acl-name
```
Contoh sebelumnya menghasilkan respons berikut.
```
aws memorydb delete-acl --acl-name "new-acl-1"
{
"ACLName": "new-acl-1",
"Status": "deleting",
"EngineVersion": "6.2",
"UserNames": [
"user-name-1",
"user-name-3"
],
"clusters": [],
"ARN":"arn:aws:memorydb:us-east-1:493071037918:acl/new-acl-1"
}
```
### Menetapkan daftar kontrol Akses ke cluster
Setelah Anda membuat ACL dan menambahkan pengguna, langkah terakhir dalam mengimplementasikan ACLs adalah menetapkan ACL ke cluster.
#### Menetapkan daftar kontrol Access ke cluster Menggunakan Konsol
Untuk menambahkan ACL ke cluster menggunakan Konsol Manajemen AWS, lihat[Membuat cluster MemoryDB](getting-started.md#clusters.create).
#### Menetapkan daftar kontrol Access ke cluster Menggunakan AWS CLI
AWS CLI Operasi berikut membuat cluster dengan enkripsi dalam transit (TLS) diaktifkan dan **acl-name** parameter dengan nilai`my-acl-name`. Ganti grup subnet `subnet-group` dengan grup subnet yang ada.
**Parameter Kunci**
+ **--engine-version**Harus 6.2.
+ **--tls-enabled**— Digunakan untuk otentikasi dan untuk mengaitkan ACL.
+ **--acl-name**— Nilai ini menyediakan daftar kontrol Access yang terdiri dari pengguna dengan izin akses tertentu untuk cluster.
Untuk Linux, macOS, atau Unix:
```
aws memorydb create-cluster \
--cluster-name "new-cluster" \
--description "new-cluster" \
--engine-version "6.2" \
--node-type db.r6g.large \
--tls-enabled \
--acl-name "new-acl-1" \
--subnet-group-name "subnet-group"
```
Untuk Windows:
```
aws memorydb create-cluster ^
--cluster-name "new-cluster" ^
--cluster-description "new-cluster" ^
--engine-version "6.2" ^
--node-type db.r6g.large ^
--tls-enabled ^
--acl-name "new-acl-1" ^
--subnet-group-name "subnet-group"
```
AWS CLI Operasi berikut memodifikasi cluster dengan enkripsi dalam transit (TLS) diaktifkan dan **acl-name** parameter dengan nilai. `new-acl-2`
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-cluster \
--cluster-name cluster-1 \
--acl-name "new-acl-2"
```
Untuk Windows:
```
aws memorydb update-cluster ^
--cluster-name cluster-1 ^
--acl-name "new-acl-2"
```
# 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 ke MemoryDB menggunakan identitas AWS IAM, ketika cluster 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. Dengan Autentikasi IAM Anda dapat mengonfigurasi kontrol akses berbutir halus untuk setiap cluster MemoryDB individu dan pengguna MemoryDB dan mengikuti prinsip izin hak istimewa paling sedikit. Otentikasi IAM untuk MemoryDB bekerja dengan menyediakan token otentikasi IAM berumur pendek alih-alih kata sandi pengguna MemoryDB yang berumur panjang di perintah atau. `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 cluster MemoryDB.
Untuk menggunakan AWS IAM dengan MemoryDB, Anda harus terlebih dahulu membuat pengguna MemoryDB dengan mode otentikasi diatur ke IAM, kemudian Anda dapat membuat atau menggunakan kembali identitas IAM. Identitas IAM memerlukan kebijakan terkait untuk memberikan `memorydb:Connect` tindakan kepada cluster MemoryDB dan pengguna MemoryDB. Setelah dikonfigurasi, Anda dapat membuat token otentikasi IAM menggunakan AWS kredensil 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 node cluster MemoryDB Anda. Klien dengan dukungan untuk penyedia kredensi dapat secara otomatis menghasilkan kredenal sementara secara otomatis untuk setiap koneksi baru. MemoryDB akan melakukan otentikasi IAM untuk permintaan koneksi pengguna MemoryDB yang mendukung IAM dan akan memvalidasi permintaan koneksi dengan IAM.
## Batasan
Saat menggunakan autentikasi IAM, batasan berikut berlaku:
+ Otentikasi IAM tersedia saat menggunakan mesin Valkey atau Redis OSS versi 7.0 atau lebih tinggi.
+ Token autentikasi IAM berlaku selama 15 menit. Untuk koneksi yang berumur panjang, sebaiknya gunakan klien Redis OSS yang mendukung antarmuka penyedia kredensial.
+ Koneksi yang diautentikasi IAM ke MemoryDB 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 tidak mendukung semua kunci konteks kondisi global. 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 klaster
```
aws memorydb create-cluster \
--cluster-name cluster-01 \
--description "MemoryDB IAM auth application"
--node-type db.r6g.large \
--engine-version 7.0 \
--acl-name open-access
```
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" : [
"memorydb:connect"
],
"Resource" : [
"arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
"arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
]
}
]
}
```
------
1. Buat peran IAM.
```
aws iam create-role \
--role-name "memorydb-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Buat kebijakan IAM.
```
aws iam create-policy \
--policy-name "memorydb-allow-all" \
--policy-document file://policy.json
```
1. Lampirkan kebijakan IAM ke peran tersebut.
```
aws iam attach-role-policy \
--role-name "memorydb-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all"
```
1. Buat pengguna baru yang didukung IAM.
```
aws memorydb create-user \
--user-name iam-user-01 \
--authentication-mode Type=iam \
--access-string "on ~* +@all"
```
1. Buat ACL dan lampirkan pengguna.
```
aws memorydb create-acl \
--acl-name iam-acl-01 \
--user-names iam-user-01
aws memorydb update-cluster \
--cluster-name cluster-01 \
--acl-name iam-acl-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 cluster MemoryDB, seperti yang ditunjukkan pada contoh di bawah ini.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userName, iamAuthToken)
.build();
// Create a new Lettuce client
RedisClusterClient client = RedisClusterClient.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 ACTION_NAME = "connect";
private static final String SERVICE_NAME = "memorydb";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userName;
private final String clusterName;
private final String region;
public IAMAuthTokenRequest(String userName, String clusterName, String region) {
this.userName = userName;
this.clusterName = clusterName;
this.region = region;
}
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(userName));
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
}
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 MemoryDB menggunakan penyedia kredensi otentikasi IAM.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
// Create a credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userName, iamAuthTokenRequest, awsCredentialsProvider);
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
Di bawah ini adalah contoh klien klaster Lettuce yang membungkus penyedia kredensi IAMAuth TokenRequest dalam untuk menghasilkan kredensil sementara secara otomatis saat diperlukan.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userName;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userName,
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(userName, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
```