Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai dengan Amazon ElastiCache
Gunakan tutorial langsung di bagian ini untuk membantu Anda memulai dan mempelajari lebih lanjut tentang menggunakan. ElastiCache
**Topics**
+ [Menyiapkan ElastiCache](set-up.md)
+ [Buat cache tanpa server Valkey](GettingStarted.serverless-valkey.step1.md)
+ [Buat cache tanpa server Redis OSS](GettingStarted.serverless-redis.step1.md)
+ [Buat cache tanpa server Memcached](create-serverless-cache-mem.md)
+ [Tutorial: Memulai dengan Python dan ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutorial: Mengkonfigurasi Lambda untuk ElastiCache mengakses di VPC](LambdaRedis.md)
# Menyiapkan ElastiCache
Untuk menggunakan layanan ElastiCache web, ikuti langkah-langkah ini.
**Topics**
+ [Mendaftar untuk Akun AWS](#sign-up-for-aws)
+ [Buat pengguna dengan akses administratif](#create-an-admin)
+ [Memberikan akses programatis](#elasticache-set-up-access-key)
+ [Menyiapkan izin](#elasticache-set-up-permissions)
+ [Mengatur EC2](#elasticache-install-configure-ec2)
+ [Memberikan akses jaringan](#elasticache-install-grant-access-VPN)
+ [Mengatur akses baris perintah](#Download-and-install-cli)
## Mendaftar untuk Akun AWS
Jika Anda tidak memiliki Akun AWS, selesaikan langkah-langkah berikut untuk membuatnya.
**Untuk mendaftar untuk Akun AWS**
1. Buka [https://portal.aws.amazon.com/billing/pendaftaran.](https://portal.aws.amazon.com/billing/signup)
1. Ikuti petunjuk online.
Bagian dari prosedur pendaftaran melibatkan menerima panggilan telepon atau pesan teks dan memasukkan kode verifikasi pada keypad telepon.
Saat Anda mendaftar untuk sebuah Akun AWS, sebuah *Pengguna root akun AWS*dibuat. Pengguna root memiliki akses ke semua Layanan AWS dan sumber daya di akun. Sebagai praktik keamanan terbaik, tetapkan akses administratif ke pengguna, dan gunakan hanya pengguna root untuk melakukan [tugas yang memerlukan akses pengguna root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS mengirimi Anda email konfirmasi setelah proses pendaftaran selesai. Kapan saja, Anda dapat melihat aktivitas akun Anda saat ini dan mengelola akun Anda dengan masuk [https://aws.amazon.com.rproxy.goskope.comke/](https://aws.amazon.com/) dan memilih **Akun Saya**.
## Buat pengguna dengan akses administratif
Setelah Anda mendaftar Akun AWS, amankan Pengguna root akun AWS, aktifkan AWS IAM Identity Center, dan buat pengguna administratif sehingga Anda tidak menggunakan pengguna root untuk tugas sehari-hari.
**Amankan Anda Pengguna root akun AWS**
1. Masuk ke [Konsol Manajemen AWS](https://console.aws.amazon.com/)sebagai pemilik akun dengan memilih **pengguna Root** dan memasukkan alamat Akun AWS email Anda. Di laman berikutnya, masukkan kata sandi.
Untuk bantuan masuk dengan menggunakan pengguna root, lihat [Masuk sebagai pengguna root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) di *AWS Sign-In Panduan Pengguna*.
1. Mengaktifkan autentikasi multi-faktor (MFA) untuk pengguna root Anda.
Untuk petunjuk, lihat [Mengaktifkan perangkat MFA virtual untuk pengguna Akun AWS root (konsol) Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) di Panduan Pengguna *IAM*.
**Buat pengguna dengan akses administratif**
1. Aktifkan Pusat Identitas IAM.
Untuk mendapatkan petunjuk, silakan lihat [Mengaktifkan AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) di *Panduan Pengguna AWS IAM Identity Center*.
1. Di Pusat Identitas IAM, berikan akses administratif ke pengguna.
Untuk tutorial tentang menggunakan Direktori Pusat Identitas IAM sebagai sumber identitas Anda, lihat [Mengkonfigurasi akses pengguna dengan default Direktori Pusat Identitas IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) di *Panduan AWS IAM Identity Center Pengguna*.
**Masuk sebagai pengguna dengan akses administratif**
+ Untuk masuk dengan pengguna Pusat Identitas IAM, gunakan URL masuk yang dikirim ke alamat email saat Anda membuat pengguna Pusat Identitas IAM.
Untuk bantuan masuk menggunakan pengguna Pusat Identitas IAM, lihat [Masuk ke portal AWS akses](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) di *Panduan AWS Sign-In Pengguna*.
**Tetapkan akses ke pengguna tambahan**
1. Di Pusat Identitas IAM, buat set izin yang mengikuti praktik terbaik menerapkan izin hak istimewa paling sedikit.
Untuk petunjuknya, lihat [Membuat set izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) di *Panduan AWS IAM Identity Center Pengguna*.
1. Tetapkan pengguna ke grup, lalu tetapkan akses masuk tunggal ke grup.
Untuk petunjuk, lihat [Menambahkan grup](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) di *Panduan AWS IAM Identity Center Pengguna*.
## Memberikan akses programatis
Pengguna membutuhkan akses terprogram jika mereka ingin berinteraksi dengan AWS luar.Konsol Manajemen AWS Cara untuk memberikan akses terprogram tergantung pada jenis pengguna yang mengakses AWS.
Untuk memberi pengguna akses programatis, pilih salah satu opsi berikut.
****
| Pengguna mana yang membutuhkan akses programatis? | Untuk | Oleh |
| --- | --- | --- |
| IAM | (Disarankan) Gunakan kredenal konsol sebagai kredensional sementara untuk menandatangani permintaan terprogram ke,, atau.AWS CLIAWS SDKs AWS APIs | Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/set-up.html) |
| Identitas tenaga kerja (Pengguna yang dikelola di Pusat Identitas IAM) | Gunakan kredensyal sementara untuk menandatangani permintaan terprogram ke AWS CLI,,AWS SDKs atau.AWS APIs | Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Gunakan kredensyal sementara untuk menandatangani permintaan terprogram ke AWS CLI,,AWS SDKs atau.AWS APIs | Mengikuti petunjuk dalam [Menggunakan kredensi sementara dengan AWS sumber daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) di Panduan Pengguna IAM. |
| IAM | (Tidak direkomendasikan)Gunakan kredensyal jangka panjang untuk menandatangani permintaan terprogram ke AWS CLI,,AWS SDKs atau.AWS APIs | Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonElastiCache/latest/dg/set-up.html) |
**Topik terkait:**
+ [Apa itu IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) dalam *Panduan Pengguna IAM*.
+ [AWS Kredensyal Keamanan dalam Referensi AWS](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html) *Umum*.
## Siapkan izin Anda (hanya ElastiCache pengguna baru)
Untuk memberikan akses dan menambahkan izin bagi pengguna, grup, atau peran Anda:
+ Pengguna dan grup di AWS IAM Identity Center:
Buat rangkaian izin. Ikuti instruksi di [Buat rangkaian izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) dalam *Panduan Pengguna AWS IAM Identity Center*.
+ Pengguna yang dikelola di IAM melalui penyedia identitas:
Buat peran untuk federasi identitas. Ikuti instruksi dalam [Buat peran untuk penyedia identitas pihak ketiga (federasi)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) dalam *Panduan Pengguna IAM*.
+ Pengguna IAM:
+ Buat peran yang dapat diambil pengguna Anda. Ikuti instruksi dalam [Buat peran untuk pengguna IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) dalam *Panduan Pengguna IAM*.
+ (Tidak disarankan) Lampirkan kebijakan langsung ke pengguna atau tambahkan pengguna ke grup pengguna. Ikuti petunjuk dalam [Menambahkan izin ke pengguna (konsol)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) dalam *Panduan Pengguna IAM*.
Amazon ElastiCache membuat dan menggunakan peran terkait layanan untuk menyediakan sumber daya dan mengakses sumber AWS daya dan layanan lain atas nama Anda. ElastiCache Untuk membuat peran terkait layanan untuk Anda, gunakan kebijakan AWS-managed bernama. `AmazonElastiCacheFullAccess` Peran ini dilengkapi sebelumnya dengan izin yang diperlukan layanan untuk membuat peran terkait layanan untuk Anda.
Anda mungkin memutuskan untuk tidak menggunakan kebijakan default dan sebagai gantinya menggunakan kebijakan terkelola khusus. Dalam hal ini, pastikan bahwa Anda memiliki izin untuk memanggil `iam:createServiceLinkedRole` atau Anda telah membuat peran tertaut layanan ElastiCache.
Untuk informasi lain, lihat yang berikut ini:
+ [Membuat Kebijakan Baru](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS kebijakan terkelola untuk Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Menggunakan Peran Tertaut Layanan untuk Amazon ElastiCache](using-service-linked-roles.md)
## Mengatur EC2
Anda perlu mengatur EC2 instance dari mana Anda akan terhubung ke cache Anda.
+ Jika Anda belum memiliki EC2 instance, pelajari cara menyiapkan EC2 instance di sini: [Panduan EC2 Memulai Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
+ EC2 Instans Anda harus dalam VPC yang sama dan memiliki pengaturan grup keamanan yang sama dengan cache Anda. Secara default, Amazon ElastiCache membuat cache di VPC default Anda dan menggunakan grup keamanan default. Untuk mengikuti tutorial ini, pastikan EC2 instans Anda ada di VPC default dan memiliki grup keamanan default.
## Berikan akses jaringan dari grup keamanan Amazon VPC ke cache Anda
ElastiCache Cluster berbasis node menggunakan port 6379 untuk perintah Valkey dan Redis OSS, dan tanpa ElastiCache server menggunakan port 6379 dan port 6380. Agar berhasil menghubungkan dan menjalankan perintah Valkey atau Redis OSS dari EC2 instans Anda, grup keamanan Anda harus mengizinkan akses ke port ini sesuai kebutuhan.
ElastiCache untuk Memcached menggunakan port 11211 dan 11212 untuk menerima perintah Memcached. Agar berhasil menghubungkan dan menjalankan perintah Memcached dari EC2 instans Anda, grup keamanan Anda harus mengizinkan akses ke port ini.
1. Masuk ke AWS Command Line Interface dan buka [ EC2 konsol Amazon](https://console.aws.amazon.com/ec2/).
1. Pada panel navigasi, di bagian **Jaringan & Keamanan**, pilih **Grup Keamanan**.
1. Dari daftar grup keamanan, pilih grup keamanan untuk Amazon VPC Anda. Kecuali Anda membuat grup keamanan untuk ElastiCache digunakan, grup keamanan ini akan diberi nama *default*.
1. Pilih tab Inbound, lalu:
1. Pilih **Edit**.
1. Pilih **Tambahkan aturan**.
1. Pada kolom Jenis, pilih **Aturan TCP kustom**.
1. Jika menggunakan Valkey atau Redis OSS, maka di kotak **rentang Port**, ketik. `6379`
Jika menggunakan Memcached, maka di kotak **rentang Port**, ketik. `11211`
1. Di kotak **Sumber**, pilih Di **mana saja** yang memiliki rentang port (0.0.0.0/0) sehingga EC2 instans Amazon apa pun yang Anda luncurkan dalam VPC Amazon Anda dapat terhubung ke cache Anda.
1. Jika Anda menggunakan ElastiCache tanpa server, tambahkan aturan lain dengan memilih **Tambahkan** aturan.
1. Di kolom **Jenis**, pilih **Aturan TCP kustom**.
1. Jika menggunakan ElastiCache untuk Redis OSS, maka di kotak **rentang Port**, ketik. `6380`
Jika menggunakan ElastiCache untuk Memcached, maka di kotak **rentang Port**, ketik. `11212`
1. Di kotak **Sumber**, pilih Di **mana saja** yang memiliki rentang port (0.0.0.0/0) sehingga EC2 instans Amazon apa pun yang Anda luncurkan dalam VPC Amazon Anda dapat terhubung ke cache Anda.
1. Pilih **Simpan**.
## Unduh dan atur akses baris perintah
**Unduh dan instal *utilitas valkey-cli*.**
Jika Anda menggunakan ElastiCache untuk Valkey, maka Anda mungkin menemukan utilitas valkey-cli berguna. Jika Anda menggunakan Redis OSS dengan redis-cli, pertimbangkan ElastiCache untuk beralih ke valkey-cli karena berfungsi untuk Redis OSS juga.
1. Connect ke EC2 instans Amazon Anda menggunakan utilitas koneksi pilihan Anda. Untuk petunjuk tentang cara menyambung ke EC2 instans Amazon, lihat [Panduan EC2 Memulai Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
1. Unduh dan instal utilitas valkey-cli dengan menjalankan perintah yang sesuai untuk pengaturan Anda.
**Amazon Linux 2**
```
sudo amazon-linux-extras install epel -y
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel -y
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make BUILD_TLS=yes
```
**catatan**
Ketika Anda menginstal paket redis6, paket ini akan menginstal redis6-cli dengan dukungan enkripsi default.
Penting untuk memiliki dukungan build untuk TLS saat menginstal valkey-cli atau redis-cli. ElastiCache Tanpa server hanya dapat diakses saat TLS diaktifkan.
Jika Anda terhubung ke klaster yang tidak terenkripsi, Anda tidak memerlukan opsi `Build_TLS=yes`.
# Buat cache tanpa server Valkey
Pada langkah ini, Anda membuat cache baru di Amazon ElastiCache.
**Konsol Manajemen AWS**
Untuk membuat cache baru menggunakan ElastiCache konsol:
1. Masuk ke Konsol Manajemen AWS dan buka [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi di sisi kiri konsol, pilih cache **Valkey**.
1. Di sisi kanan konsol, pilih **Buat cache Valkey**
1. Pada **Pengaturan cache**, masukkan **Nama**. Anda juga dapat memasukkan **deskripsi** untuk cache.
1. Biarkan pengaturan default dipilih.
1. Klik **Buat** untuk membuat cache.
1. Setelah cache berada dalam status "AKTIF", Anda dapat mulai melakukan operasi baca dan tulis ke cache.
**AWS CLI**
AWS CLI Contoh berikut membuat cache baru menggunakan create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine valkey
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine valkey
```
Perhatikan bahwa nilai bidang Status diatur ke `CREATING`.
Untuk memverifikasi bahwa ElastiCache telah selesai membuat cache, gunakan `describe-serverless-caches` perintah.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Setelah membuat cache baru, lanjutkan ke [Membaca dan menulis data ke cache](GettingStarted.serverless-valkey.step2.md).
# Membaca dan menulis data ke cache
Bagian ini mengasumsikan bahwa Anda telah membuat EC2 instance Amazon dan dapat terhubung dengannya. Untuk petunjuk tentang cara melakukannya, lihat [Panduan EC2 Memulai Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
Bagian ini juga mengasumsikan bahwa Anda memiliki pengaturan akses VPC dan pengaturan grup keamanan untuk EC2 instance dari mana Anda terhubung ke cache Anda, dan mengatur valkey-cli pada instance Anda. EC2 Untuk informasi selengkapnya tentang langkah tersebut lihat [Menyiapkan ElastiCache](set-up.md).
Selain langkah-langkah di bawah ini, jika Anda memiliki aplikasi besar atau global, Anda dapat sangat meningkatkan kinerja baca dengan membuat dan membaca dari replika. Untuk informasi lebih lanjut tentang langkah yang lebih maju ini lihat[Praktik Terbaik untuk menggunakan Read Replicas](ReadReplicas.md).
**Menemukan titik akhir cache Anda**
**Konsol Manajemen AWS**
Untuk menemukan titik akhir cache Anda menggunakan ElastiCache 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 panel navigasi di sisi kiri konsol, pilih cache **Valkey**.
1. Di sisi kanan konsol, klik nama cache yang baru saja Anda buat.
1. Dalam **Detail cache**, cari dan salin titik akhir cache.
**AWS CLI**
AWS CLI Contoh berikut menunjukkan untuk menemukan titik akhir untuk cache baru Anda menggunakan describe-serverless-caches perintah. Setelah Anda menjalankan perintah, cari bidang "Titik Akhir".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect ke Valkey Cache (Linux)
Sekarang setelah Anda memiliki titik akhir yang Anda butuhkan, Anda dapat masuk ke EC2 instance Anda dan terhubung ke cache. Dalam contoh berikut, Anda menggunakan utilitas *valkey-cli* untuk terhubung ke cluster. Perintah berikut menghubungkan ke cache (catatan: ganti cache-endpoint dengan titik akhir yang Anda ambil pada langkah sebelumnya).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect ke Valkey Cache (Windows)
Sekarang setelah Anda memiliki titik akhir yang Anda butuhkan, Anda dapat masuk ke EC2 instance Anda dan terhubung ke cache. Dalam contoh berikut, Anda menggunakan utilitas *valkey-cli* untuk terhubung ke cluster. Perintah berikut terhubung ke cache. Buka Command Prompt dan ubah ke direktori Valkey atau Redis OSS dan jalankan perintah (catatan: ganti Cache\$1Endpoint dengan titik akhir yang Anda ambil pada langkah sebelumnya).
```
c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Sekarang Anda dapat melanjutkan ke [(Opsional) Bersihkan](GettingStarted.serverless-valkey.step3.md).
# (Opsional) Bersihkan
Jika Anda tidak lagi membutuhkan ElastiCache cache Amazon yang Anda buat, Anda dapat menghapusnya. Langkah ini membantu memastikan bahwa Anda tidak akan dikenai biaya untuk sumber daya yang tidak Anda gunakan. Anda dapat menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API untuk menghapus cache Anda.
**Konsol Manajemen AWS**
Untuk menghapus cache Anda 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 panel navigasi di sisi kiri konsol, pilih **Valkey Caches**.
1. Pilih tombol radio di samping cache yang ingin Anda hapus.
1. Pilih **Tindakan** di kanan atas lalu pilih **Hapus**.
1. Anda dapat memilih untuk mengambil snapshot terakhir sebelum menghapus cache Anda.
1. Pada layar konfirmasi **Hapus**, masukkan kembali nama cache dan pilih **Hapus** untuk menghapus klaster, atau pilih **Batal** untuk mempertahankan klaster.
Setelah cache Anda masuk ke status **DELETING**, Anda tidak lagi dikenai biaya untuk itu.
**AWS CLI**
AWS CLI Contoh berikut menghapus cache menggunakan delete-serverless-cache perintah.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Perhatikan bahwa nilai bidang **Status** diatur ke **DELETING**.
Sekarang Anda dapat melanjutkan ke [Langkah Berikutnya](GettingStarted.serverless-valkey.next-steps.md).
# Langkah Berikutnya
Untuk informasi lebih lanjut tentang ElastiCache lihat halaman berikut:
+ [Bekerja dengan ElastiCache](WorkingWithElastiCache.md)
+ [Penskalaan ElastiCache](Scaling.md)
+ [Pencatatan dan pemantauan di Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache praktik terbaik dan strategi caching](BestPractices.md)
+ [Melakukan snapshot dan pemulihan](backups.md)
+ [Pemantauan acara Amazon SNS ElastiCache](ECEvents.md)
# Buat cache tanpa server Redis OSS
Pada langkah ini, Anda membuat cache baru di Amazon ElastiCache.
**Konsol Manajemen AWS**
Untuk membuat cache baru menggunakan ElastiCache konsol:
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi di sisi kiri konsol, pilih cache **Redis OSS**.
1. Di sisi kanan konsol, pilih **Buat cache Redis OSS**
1. Pada **Pengaturan cache**, masukkan **Nama**. Anda juga dapat memasukkan **deskripsi** untuk cache.
1. Biarkan pengaturan default dipilih.
1. Klik **Buat** untuk membuat cache.
1. Setelah cache berada dalam status "AKTIF", Anda dapat mulai melakukan operasi baca dan tulis ke cache.
**AWS CLI**
AWS CLI Contoh berikut membuat cache baru menggunakan create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis
```
Perhatikan bahwa nilai bidang Status diatur ke `CREATING`.
Untuk memverifikasi bahwa ElastiCache telah selesai membuat cache, gunakan `describe-serverless-caches` perintah.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Setelah membuat cache baru, lanjutkan ke [Membaca dan menulis data ke cache](GettingStarted.serverless-redis.step2.md).
# Membaca dan menulis data ke cache
Bagian ini mengasumsikan bahwa Anda telah membuat EC2 instance Amazon dan dapat terhubung dengannya. Untuk petunjuk tentang cara melakukannya, lihat [Panduan EC2 Memulai Amazon](https://aws.amazon.com/ec2/getting-started/).
Bagian ini juga mengasumsikan bahwa Anda memiliki pengaturan akses VPC dan pengaturan grup keamanan untuk EC2 instance dari mana Anda terhubung ke cache Anda, dan mengatur valkey-cli pada instance Anda. EC2 Untuk informasi selengkapnya tentang langkah tersebut lihat [Menyiapkan ElastiCache](set-up.md).
**Menemukan titik akhir cache Anda**
**Konsol Manajemen AWS**
Untuk menemukan titik akhir cache Anda menggunakan ElastiCache 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 panel navigasi di sisi kiri konsol, pilih **Valkey cache cache** **Redis** OSS.
1. Di sisi kanan konsol, klik nama cache yang baru saja Anda buat.
1. Dalam **Detail cache**, cari dan salin titik akhir cache.
**AWS CLI**
AWS CLI Contoh berikut menunjukkan untuk menemukan titik akhir untuk cache baru Anda menggunakan describe-serverless-caches perintah. Setelah Anda menjalankan perintah, cari bidang "Titik Akhir".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect ke Valkey atau Redis OSS Cache (Linux)
Sekarang setelah Anda memiliki titik akhir yang Anda butuhkan, Anda dapat masuk ke EC2 instance Anda dan terhubung ke cache. Dalam contoh berikut, Anda menggunakan utilitas *valkey-cli* untuk terhubung ke cluster. Perintah berikut menghubungkan ke cache (catatan: ganti cache-endpoint dengan titik akhir yang Anda ambil pada langkah sebelumnya).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect ke Valkey atau Redis OSS Cache (Windows)
Sekarang setelah Anda memiliki titik akhir yang Anda butuhkan, Anda dapat masuk ke EC2 instance Anda dan terhubung ke cache. Dalam contoh berikut, Anda menggunakan utilitas *valkey-cli* untuk terhubung ke cluster. Perintah berikut terhubung ke cache. Buka Command Prompt dan ubah ke direktori Valkey dan jalankan perintah (catatan: ganti Cache\$1Endpoint dengan titik akhir yang Anda ambil pada langkah sebelumnya).
```
c:\Redis>valkey-cli -h Redis_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Sekarang Anda dapat melanjutkan ke [(Opsional) Bersihkan](GettingStarted.serverless-redis.step3.md).
# (Opsional) Bersihkan
Jika Anda tidak lagi membutuhkan ElastiCache cache Amazon yang Anda buat, Anda dapat menghapusnya. Langkah ini membantu memastikan bahwa Anda tidak akan dikenai biaya untuk sumber daya yang tidak Anda gunakan. Anda dapat menggunakan ElastiCache konsol, file AWS CLI, atau ElastiCache API untuk menghapus cache Anda.
**Konsol Manajemen AWS**
Untuk menghapus cache Anda 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 panel navigasi di sisi kiri konsol, pilih **Valkey atau Redis** OSS Cache.
1. Pilih tombol radio di samping cache yang ingin Anda hapus.
1. Pilih **Tindakan** di kanan atas lalu pilih **Hapus**.
1. Anda dapat memilih untuk mengambil snapshot terakhir sebelum menghapus cache Anda.
1. Pada layar konfirmasi **Hapus**, masukkan kembali nama cache dan pilih **Hapus** untuk menghapus klaster, atau pilih **Batal** untuk mempertahankan klaster.
Setelah cache Anda masuk ke status **DELETING**, Anda tidak lagi dikenai biaya untuk itu.
**AWS CLI**
AWS CLI Contoh berikut menghapus cache menggunakan delete-serverless-cache perintah.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Perhatikan bahwa nilai bidang **Status** diatur ke **DELETING**.
Sekarang Anda dapat melanjutkan ke [Langkah Berikutnya](GettingStarted.serverless-redis.next-steps.md).
# Langkah Berikutnya
Untuk informasi lebih lanjut tentang ElastiCache lihat halaman berikut:
+ [Bekerja dengan ElastiCache](WorkingWithElastiCache.md)
+ [Penskalaan ElastiCache](Scaling.md)
+ [Pencatatan dan pemantauan di Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache praktik terbaik dan strategi caching](BestPractices.md)
+ [Melakukan snapshot dan pemulihan](backups.md)
+ [Pemantauan acara Amazon SNS ElastiCache](ECEvents.md)
# Buat cache tanpa server Memcached
**Konsol Manajemen AWS**
Untuk membuat cache tanpa server Memcached baru menggunakan konsol: ElastiCache
1. Masuk ke Konsol Manajemen AWS dan buka ElastiCache konsol di [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Di panel navigasi di sisi kiri konsol, pilih **Cache Memcached**.
1. Di bagian kanan konsol, pilih **Buat cache Memcached**.
1. Pada **Pengaturan cache**, masukkan **Nama**. Anda juga dapat memasukkan **deskripsi** untuk cache.
1. Biarkan pengaturan default dipilih.
1. Klik **Buat** untuk membuat cache.
1. Setelah cache berada dalam status "AKTIF", Anda dapat mulai melakukan operasi pembacaan dan penulisan ke cache.
Untuk membuat cache baru menggunakan AWS CLI
AWS CLI Contoh berikut membuat cache baru menggunakan create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine memcached
```
Perhatikan bahwa nilai bidang Status diatur ke `CREATING`.
Untuk memverifikasi bahwa ElastiCache telah selesai membuat cache, gunakan `describe-serverless-caches` perintah.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Setelah membuat cache baru, lanjutkan ke [Membaca dan menulis data ke cache](read-write-cache-mem.md).
# Membaca dan menulis data ke cache
Bagian ini mengasumsikan bahwa Anda telah membuat EC2 instance Amazon dan dapat terhubung dengannya. Untuk petunjuk tentang cara melakukannya, lihat [Panduan EC2 Memulai Amazon](https://aws.amazon.com/ec2/getting-started/).
Secara default, ElastiCache buat cache di VPC default Anda. Pastikan EC2 instance Anda juga dibuat di VPC default, sehingga dapat terhubung ke cache.
**Menemukan titik akhir cache Anda**
**Konsol Manajemen AWS**
Untuk menemukan titik akhir cache Anda menggunakan ElastiCache 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 panel navigasi di sisi kiri konsol, pilih **Cache Memcached**.
1. Di sisi kanan konsol, klik nama cache yang baru saja Anda buat.
1. Dalam **Detail cache**, cari dan salin titik akhir cache.
**AWS CLI**
AWS CLI Contoh berikut menunjukkan untuk menemukan titik akhir untuk cache baru Anda menggunakan describe-serverless-caches perintah. Setelah Anda menjalankan perintah, cari bidang "Titik Akhir".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Menghubungkan menggunakan OpenSSL
Untuk informasi tentang cara menghubungkan menggunakan OpenSSL, lihat [ElastiCache enkripsi dalam transit (TLS)](in-transit-encryption.md)
## Menghubungkan menggunakan klien Java Memcached
```
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.FailureMode;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
public static void main(String[] args) throws Exception {
ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
// Build SSLContext
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init((KeyStore) null);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
// Create the client in TLS mode
connectionFactoryBuilder.setSSLContext(sslContext);
// Set Failure Mode to Retry
connectionFactoryBuilder.setFailureMode(FailureMode.Retry);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Menghubungkan menggunakan klien PHP Memcached
```
addServer($cluster_endpoint, $server_port);
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.serverless.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
$tls_client->createAndSetTLSContext((array)$tls_config);
/* store the data for 60 seconds in the cluster */
$tls_client->set('key', 'value', 60);
?>
```
## Menghubungkan menggunakan klien Python Memcached (Pymemcache)
Lihat [https://pymemcache.readthedocs. io/en/latest/getting](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.html
```
import ssl
from pymemcache.client.base import Client
context = ssl.create_default_context()
cluster_endpoint =
target_port = 11211
memcached_client = Client(("{cluster_endpoint}", target_port), tls_context=context)
memcached_client.set("key", "value", expire=500, noreply=False)
assert self.memcached_client.get("key").decode() == "value"
```
## Connect menggunakan NodeJS/TS klien Memcached (Electrode-io memcache)
[Lihat [https://github.com/electrode-io/memcache dan https://www.npmjs.com/package/ memcache-client](https://github.com/electrode-io/memcache)](https://www.npmjs.com/package/memcache-client)
Instal melalui `npm i memcache-client`
Dalam aplikasi, buat klien TLS memcache sebagai berikut:
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Menghubungkan menggunakan klien Rust Memcached (rust-memcache)
Lihat [https://crates. io/crates/memcache](https://crates.io/crates/memcache)dan [https://github.com/aisk/rust-memcache](https://github.com/aisk/rust-memcache).
```
// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://:11211?verify_mode=none").unwrap();
// set a string value
client.set("foo", "bar", 0).unwrap();
```
## Menghubungkan menggunakan klien Go Memcached (Gomemcache)
Lihat [https://github.com/bradfitz/gomemcache](https://github.com/bradfitz/gomemcache)
```
c := New(net.JoinHostPort("{cluster_endpoint}", strconv.Itoa(port)))
c.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
var td tls.Dialer
td.Config = &tls.Config{}
return td.DialContext(ctx, network, addr)
}
foo := &Item{Key: "foo", Value: []byte("fooval"), Flags: 123}
err := c.Set(foo)
```
## Menghubungkan menggunakan klien Ruby Memcached (Dalli)
Lihat [https://github.com/petergoldstein/dalli](https://github.com/petergoldstein/dalli)
```
require 'dalli'
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.ssl_version = :SSLv23
ssl_context.verify_hostname = true
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
client = Dalli::Client.new(":11211", :ssl_context => ssl_context);
client.get("abc")
```
## Connect menggunakan Memcached .NET client () EnyimMemcachedCore
Lihat [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore)
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Sekarang Anda dapat melanjutkan ke [(Opsional) Bersihkan](read-write-cleanup-mem.md).
# (Opsional) Bersihkan
**Menggunakan Konsol Manajemen AWS**
Prosedur berikut menghapus satu cache dari deployment Anda. Untuk menghapus beberapa cache, ulangi prosedur untuk setiap cache yang ingin dihapus. Anda tidak perlu menunggu satu cache selesai dihapus untuk memulai prosedur penghapusan cache lainnya.
**Untuk menghapus cache**
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 dasbor ElastiCache konsol, pilih mesin yang berjalan pada cache yang ingin Anda hapus. Daftar semua cache yang menjalankan mesin tersebut akan muncul.
1. Untuk memilih cache yang akan dihapus, pilih nama cache dari daftar cache.
**penting**
Anda hanya dapat menghapus satu cache pada satu waktu dari ElastiCache konsol. Memilih beberapa cache akan menonaktifkan operasi hapus.
1. Untuk **Tindakan**, pilih **Hapus**.
1. Pada layar konfirmasi **Hapus Cache**, pilih **Hapus** untuk menghapus cache, atau pilih **Batal** untuk mempertahankan klaster.
1. Jika Anda memilih **Hapus**, status cache berubah menjadi *menghapus*.
Setelah cache Anda masuk ke status **DELETING**, Anda tidak lagi dikenai biaya untuk itu.
**Menggunakan AWS CLI**
Kode berikut menghapus cache my-cache.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
Tindakan delete-serverless-cache CLI hanya menghapus satu cache tanpa server. Untuk menghapus beberapa cache, panggil delete-serverless-cache setiap cache tanpa server yang ingin Anda hapus. Anda tidak perlu menunggu satu cache nirserver selesai dihapus untuk menghapus cache yang lain.
**Untuk Linux, macOS, atau Unix:**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Untuk Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Untuk informasi selengkapnya, lihat ElastiCache topik AWS CLI untuk delete-serverless-cache.
Sekarang Anda dapat melanjutkan ke [Langkah Berikutnya](next-steps-mem.md).
# Langkah Berikutnya
Untuk informasi lebih lanjut tentang ElastiCache lihat:
+ [Bekerja dengan ElastiCache](WorkingWithElastiCache.md)
+ [Penskalaan ElastiCache](Scaling.md)
+ [Kuota untuk ElastiCache](quota-limits.md)
+ [ElastiCache praktik terbaik dan strategi caching](BestPractices.md)
+ [Melihat ElastiCache acara](ECEvents.Viewing.md)
# Tutorial: Memulai dengan Python dan ElastiCache
Bagian ini berisi tutorial langsung untuk membantu Anda mempelajari tentang Valkey dan ElastiCache Redis OSS. Kami mendorong Anda untuk mengikuti salah satu tutorial dengan bahasa yang sesuai.
**catatan**
AWS SDKs tersedia untuk berbagai bahasa. Untuk daftar yang lengkapnya, lihat [Alat untuk Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python dan ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python dan ElastiCache
Dalam tutorial ini, Anda menggunakan AWS SDK for Python (Boto3) untuk menulis program sederhana untuk melakukan operasi berikut: ElastiCache
+ Buat ElastiCache untuk cluster Redis OSS (mode cluster diaktifkan dan mode cluster dinonaktifkan)
+ Periksa apakah pengguna atau grup pengguna ada, jika tidak, buat mereka. (Fitur ini tersedia dengan Valkey 7.2 dan seterusnya, dan dengan Redis OSS 6.0 hingga 7.1.)
+ Connect ke ElastiCache
+ Lakukan operasi seperti pengaturan dan mendapatkan string, membaca dari dan menulis ke steam dan menerbitkan dan berlangganan dari saluran. Pub/Sub
Saat Anda mengerjakan tutorial ini, Anda dapat merujuk ke dokumentasi AWS SDK untuk Python (Boto). Bagian berikut khusus untuk ElastiCache: klien [ElastiCache tingkat rendah](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Prasyarat Tutorial
+ Siapkan kunci AWS akses untuk menggunakan file AWS SDKs. Untuk informasi selengkapnya, lihat [Menyiapkan ElastiCache](set-up.md).
+ Instal Python 3.0 atau yang lebih baru. Untuk informasi selengkapnya, lihat [https://www.python.org/downloads](https://www.python.org/downloads). Untuk petunjuk, lihat [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) dalam dokumentasi Boto 3.
**Topics**
+ [Prasyarat Tutorial](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutorial: Membuat ElastiCache cluster dan pengguna](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutorial: Menghubungkan ke ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Contoh penggunaan](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutorial: Membuat ElastiCache cluster dan pengguna
Contoh berikut menggunakan boto3 SDK ElastiCache untuk operasi manajemen Redis OSS (kluster atau pembuatan pengguna) dan redis-py/ untuk penanganan data. redis-py-cluster
**Topics**
+ [Buat klaster dengan mode klaster dinonaktifkan](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Membuat klaster dengan mode klaster dinonaktifkan dengan TLS dan RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Membuat klaster dengan mode klaster diaktifkan](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Membuat klaster dengan mode klaster diaktifkan dengan TLS dan RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Periksa apakah users/usergroup ada, jika tidak, buat](#ElastiCache-Getting-Started-Tutorials-Users)
### Buat klaster dengan mode klaster dinonaktifkan
Salin program berikut dan tempel ke file bernama *CreateClusterModeDisabledCluster.py.*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode disabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
NumCacheClusters=NumCacheClusters,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
SnapshotRetentionLimit=30,
)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas
elasticacheResponse = create_cluster_mode_disabled(
#CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104053'
)
logging.info(elasticacheResponse)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python CreateClusterModeDisabledCluster.py`
Untuk informasi selengkapnya, lihat [Mengelola cluster di ElastiCache](Clusters.md).
### Membuat klaster dengan mode klaster dinonaktifkan dengan TLS dan RBAC
Untuk memastikan keamanan, Anda dapat menggunakan Keamanan Lapisan Pengangkutan (TLS) dan Kontrol Akses Berbasis Peran (RBAC) saat membuat klaster dengan mode klaster dinonaktifkan. Tidak seperti Valkey atau Redis OSS AUTH, di mana semua klien yang diautentikasi memiliki akses grup replikasi penuh jika token mereka diautentikasi, RBAC memungkinkan Anda untuk mengontrol akses cluster melalui grup pengguna. Grup pengguna ini dirancang sebagai cara untuk mengatur akses ke grup replikasi. Untuk informasi selengkapnya, lihat [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md).
Salin program berikut dan tempel ke file bernama *ClusterModeDisabledWithRBAC.py*.
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled_rbac(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None, UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None):
"""Creates an ElastiCache Cluster with cluster mode disabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Mandatory name for the cluster.
:param UserGroupIds: The ID of the user group to be assigned to the cluster.
:param SecurityGroupIds: List of security groups to be assigned. If not defined, default will be used
:param CacheSubnetGroupName: subnet group where the cluster will be placed. If not defined, default will be used.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return {'Error': 'ReplicationGroupId parameter is required'}
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'NumCacheClusters': NumCacheClusters,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas.
# Assigns the existent user group "mygroup" for RBAC authentication
response=create_cluster_mode_disabled_rbac(
CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104',
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ClusterModeDisabledWithRBAC.py`
Untuk informasi selengkapnya, lihat [Mengelola cluster di ElastiCache](Clusters.md).
### Membuat klaster dengan mode klaster diaktifkan
Salin program berikut dan tempel ke file bernama *ClusterModeEnabled.py.*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode enabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary node (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=NumNodeGroups,
ReplicasPerNodeGroup=ReplicasPerNodeGroup,
CacheParameterGroupName='default.valkey7.2.cluster.on'
)
return response
# Creates a cluster mode enabled
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='6.0',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey20210',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
)
logging.info(response)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ClusterModeEnabled.py`
Untuk informasi selengkapnya, lihat [Mengelola cluster di ElastiCache](Clusters.md).
### Membuat klaster dengan mode klaster diaktifkan dengan TLS dan RBAC
Untuk memastikan keamanan, Anda dapat menggunakan Keamanan Lapisan Pengangkutan (TLS) dan Kontrol Akses Berbasis Peran (RBAC) saat membuat klaster dengan mode klaster diaktifkan. Tidak seperti Valkey atau Redis OSS AUTH, di mana semua klien yang diautentikasi memiliki akses grup replikasi penuh jika token mereka diautentikasi, RBAC memungkinkan Anda untuk mengontrol akses cluster melalui grup pengguna. Grup pengguna ini dirancang sebagai cara untuk mengatur akses ke grup replikasi. Untuk informasi selengkapnya, lihat [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md).
Salin program berikut dan tempel ke file bernama *ClusterModeEnabledWithRBAC.py*.
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None,UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None,CacheParameterGroupName='default.valkey7.2.cluster.on'):
"""Creates an ElastiCache Cluster with cluster mode enabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster.
:param CacheParameterGroupName: Parameter group to be used. Must be compatible with the engine version and cluster mode enabled.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds,
'NumNodeGroups': NumNodeGroups,
'ReplicasPerNodeGroup': ReplicasPerNodeGroup,
'CacheParameterGroupName': CacheParameterGroupName
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates a cluster mode enabled cluster
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='7.2',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey2021',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ClusterModeEnabledWithRBAC.py`
Untuk informasi selengkapnya, lihat [Mengelola cluster di ElastiCache](Clusters.md).
### Periksa apakah users/usergroup ada, jika tidak, buat
Dengan RBAC, Anda membuat pengguna dan memberi mereka izin tertentu menggunakan string akses. Anda menetapkan pengguna ke grup pengguna yang selaras dengan peran tertentu (administrator, sumber daya manusia) yang kemudian disebarkan ke satu atau lebih ElastiCache untuk grup replikasi Redis OSS. Dengan melakukan ini, Anda dapat menetapkan batas keamanan antara klien menggunakan grup atau grup replikasi Valkey atau Redis OSS yang sama dan mencegah klien mengakses data satu sama lain. Untuk informasi selengkapnya, lihat [Kontrol Akses Berbasis Peran (RBAC)](Clusters.RBAC.md).
Salin program berikut dan tempel ke file bernama *UserAndUserGroups.py.* Perbarui mekanisme untuk memberikan kredensial. Kredensial dalam contoh ini ditampilkan sebagai dapat diganti dan diberikan item yang tidak dideklarasikan. Hindari kredensial hard-coding.
Contoh ini menggunakan string akses dengan izin untuk pengguna. Untuk informasi selengkapnya tentang string akses, lihat[Menentukan Izin Menggunakan String Akses](Clusters.RBAC.md#Access-string).
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def check_user_exists(UserId):
"""Checks if UserId exists
Returns True if UserId exists, otherwise False
:param UserId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_users(
UserId=UserId,
)
if response['Users'][0]['UserId'].lower() == UserId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def check_group_exists(UserGroupId):
"""Checks if UserGroupID exists
Returns True if Group ID exists, otherwise False
:param UserGroupId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_user_groups(
UserGroupId=UserGroupId
)
if response['UserGroups'][0]['UserGroupId'].lower() == UserGroupId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserGroupNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def create_user(UserId=None,UserName=None,Password=None,AccessString=None):
"""Creates a new user
Returns the ARN for the newly created user or the error message
:param UserId: ElastiCache user ID. User IDs must be unique
:param UserName: ElastiCache user name. ElastiCache allows multiple users with the same name as long as the associated user ID is unique.
:param Password: Password for user. Must have at least 16 chars.
:param AccessString: Access string with the permissions for the user.
:return: user ARN
"""
try:
response = client.create_user(
UserId=UserId,
UserName=UserName,
Engine='Redis',
Passwords=[Password],
AccessString=AccessString,
NoPasswordRequired=False
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
return e.response['Error']
def create_group(UserGroupId=None, UserIds=None):
"""Creates a new group.
A default user is required (mandatory) and should be specified in the UserIds list
Return: Group ARN
:param UserIds: List with user IDs to be associated with the new group. A default user is required
:param UserGroupId: The ID (name) for the group
:return: Group ARN
"""
try:
response = client.create_user_group(
UserGroupId=UserGroupId,
Engine='Redis',
UserIds=UserIds
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
if __name__ == '__main__':
groupName='mygroup2'
userName = 'myuser2'
userId=groupName+'-'+userName
# Creates a new user if the user ID does not exist.
for tmpUserId,tmpUserName in [ (userId,userName), (groupName+'-default','default')]:
if not check_user_exists(tmpUserId):
response=create_user(UserId=tmpUserId, UserName=EXAMPLE,Password=EXAMPLE,AccessString='on ~* +@all')
logging.info(response)
# assigns the new user ID to the user group
if not check_group_exists(groupName):
UserIds = [ userId , groupName+'-default']
response=create_group(UserGroupId=groupName,UserIds=UserIds)
logging.info(response)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python UserAndUserGroups.py`
## Tutorial: Menghubungkan ke ElastiCache
Contoh berikut menggunakan klien Valkey atau Redis OSS untuk terhubung ke. ElastiCache
**Topics**
+ [Menghubungkan ke klaster yang menonaktifkan mode klaster](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Menghubungkan ke klaster yang mengaktifkan mode klaster](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Menghubungkan ke klaster yang menonaktifkan mode klaster
Salin program berikut dan tempel ke file bernama *ConnectClusterModeDisabled.py.* Perbarui mekanisme untuk memberikan kredensial. Kredensial dalam contoh ini ditampilkan sebagai dapat diganti dan diberikan item yang tidak dideklarasikan. Hindari kredensial hard-coding.
```
from redis import Redis
import logging
logging.basicConfig(level=logging.INFO)
redis = Redis(host='primary.xxx.yyyyyy.zzz1.cache.amazonaws.com', port=6379, decode_responses=True, ssl=True, username=example, password=EXAMPLE)
if redis.ping():
logging.info("Connected to Redis")
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ConnectClusterModeDisabled.py`
### Menghubungkan ke klaster yang mengaktifkan mode klaster
Salin program berikut dan tempel ke file bernama *ConnectClusterModeEnabled.py.*
```
from rediscluster import RedisCluster
import logging
logging.basicConfig(level=logging.INFO)
redis = RedisCluster(startup_nodes=[{"host": "xxx.yyy.clustercfg.zzz1.cache.amazonaws.com","port": "6379"}], decode_responses=True,skip_full_coverage_check=True)
if redis.ping():
logging.info("Connected to Redis")
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ConnectClusterModeEnabled.py`
## Contoh penggunaan
Contoh berikut menggunakan boto3 SDK ElastiCache untuk bekerja dengan ElastiCache Redis OSS.
**Topics**
+ [Menetapkan dan Mendapatkan string](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Tentukan dan Dapatkan hash dengan beberapa item](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Publikasikan (tulis) dan berlangganan (baca) dari Pub/Sub saluran](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Tulis dan baca dari aliran](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Menetapkan dan Mendapatkan string
Salin program berikut dan tempel ke file bernama *SetAndGetStrings.py.*
```
import time
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
currTime=time.ctime(time.time())
# Set the key 'mykey' with the current date and time as value.
# The Key will expire and removed from cache in 60 seconds.
redis.set(keyName, currTime, ex=60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieve the key value and current TTL
keyValue=redis.get(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValue, keyTTL))
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python SetAndGetStrings.py`
### Tentukan dan Dapatkan hash dengan beberapa item
Salin program berikut dan tempel ke file bernama *SetAndGetHash.py.*
```
import logging
import time
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
keyValues={'datetime': time.ctime(time.time()), 'epochtime': time.time()}
# Set the hash 'mykey' with the current date and time in human readable format (datetime field) and epoch number (epochtime field).
redis.hset(keyName, mapping=keyValues)
# Set the key to expire and removed from cache in 60 seconds.
redis.expire(keyName, 60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieves all the fields and current TTL
keyValues=redis.hgetall(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValues, keyTTL))
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python SetAndGetHash.py`
### Publikasikan (tulis) dan berlangganan (baca) dari Pub/Sub saluran
Salin program berikut dan tempel ke file bernama *PubAndSub.py.*
```
import logging
import time
def handlerFunction(message):
"""Prints message got from PubSub channel to the log output
Return None
:param message: message to log
"""
logging.info(message)
logging.basicConfig(level=logging.INFO)
redis = Redis(host="redis202104053.tihewd.ng.0001.use1.cache.amazonaws.com", port=6379, decode_responses=True)
# Creates the subscriber connection on "mychannel"
subscriber = redis.pubsub()
subscriber.subscribe(**{'mychannel': handlerFunction})
# Creates a new thread to watch for messages while the main process continues with its routines
thread = subscriber.run_in_thread(sleep_time=0.01)
# Creates publisher connection on "mychannel"
redis.publish('mychannel', 'My message')
# Publishes several messages. Subscriber thread will read and print on log.
while True:
redis.publish('mychannel',time.ctime(time.time()))
time.sleep(1)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python PubAndSub.py`
### Tulis dan baca dari aliran
Salin program berikut dan tempel ke file bernama *ReadWriteStream.py.*
```
from redis import Redis
import redis.exceptions as exceptions
import logging
import time
import threading
logging.basicConfig(level=logging.INFO)
def writeMessage(streamName):
"""Starts a loop writting the current time and thread name to 'streamName'
:param streamName: Stream (key) name to write messages.
"""
fieldsDict={'writerId':threading.currentThread().getName(),'myvalue':None}
while True:
fieldsDict['myvalue'] = time.ctime(time.time())
redis.xadd(streamName,fieldsDict)
time.sleep(1)
def readMessage(groupName=None,streamName=None):
"""Starts a loop reading from 'streamName'
Multiple threads will read from the same stream consumer group. Consumer group is used to coordinate data distribution.
Once a thread acknowleges the message, it won't be provided again. If message wasn't acknowledged, it can be served to another thread.
:param groupName: stream group were multiple threads will read.
:param streamName: Stream (key) name where messages will be read.
"""
readerID=threading.currentThread().getName()
while True:
try:
# Check if the stream has any message
if redis.xlen(streamName)>0:
# Check if if the messages are new (not acknowledged) or not (already processed)
streamData=redis.xreadgroup(groupName,readerID,{streamName:'>'},count=1)
if len(streamData) > 0:
msgId,message = streamData[0][1][0]
logging.info("{}: Got {} from ID {}".format(readerID,message,msgId))
#Do some processing here. If the message has been processed sucessfuly, acknowledge it and (optional) delete the message.
redis.xack(streamName,groupName,msgId)
logging.info("Stream message ID {} read and processed successfuly by {}".format(msgId,readerID))
redis.xdel(streamName,msgId)
else:
pass
except:
raise
time.sleep(0.5)
# Creates the stream 'mystream' and consumer group 'myworkergroup' where multiple threads will write/read.
try:
redis.xgroup_create('mystream','myworkergroup',mkstream=True)
except exceptions.ResponseError as e:
logging.info("Consumer group already exists. Will continue despite the error: {}".format(e))
except:
raise
# Starts 5 writer threads.
for writer_no in range(5):
writerThread = threading.Thread(target=writeMessage, name='writer-'+str(writer_no), args=('mystream',),daemon=True)
writerThread.start()
# Starts 10 reader threads
for reader_no in range(10):
readerThread = threading.Thread(target=readMessage, name='reader-'+str(reader_no), args=('myworkergroup','mystream',),daemon=True)
readerThread.daemon = True
readerThread.start()
# Keep the code running for 30 seconds
time.sleep(30)
```
Untuk menjalankan program ini, masukkan perintah berikut:
`python ReadWriteStream.py`
# Tutorial: Mengkonfigurasi Lambda untuk ElastiCache mengakses di VPC
Dalam tutorial ini Anda dapat mempelajari cara membuat cache ElastiCache tanpa server, membuat fungsi Lambda, lalu menguji fungsi Lambda, dan secara opsional membersihkan setelahnya.
**Topics**
+ [Langkah 1: Membuat cache ElastiCache tanpa server.](#LambdaRedis.step1)
+ [Langkah 2: Buat fungsi Lambda untuk ElastiCache](#LambdaRedis.step2)
+ [Langkah 3: Uji fungsi Lambda dengan ElastiCache](#LambdaRedis.step3)
+ [Langkah 4: Bersihkan (Opsional)](#LambdaRedis.step4)
## Langkah 1: Membuat cache ElastiCache tanpa server.
Untuk membuat cache tanpa server, ikuti langkah-langkah ini.
### Langkah 1.1: Buat cache tanpa server
Pada langkah ini, Anda membuat cache tanpa server di VPC Amazon default di wilayah us-east-1 di akun Anda menggunakan (CLI).AWS Command Line Interface Untuk informasi tentang membuat cache tanpa server menggunakan ElastiCache konsol atau API, lihat. [Buat cache tanpa server Redis OSS](GettingStarted.serverless-redis.step1.md)
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
Perhatikan bahwa nilai bidang Status diatur ke `CREATING`. Diperlukan waktu satu menit ElastiCache untuk menyelesaikan pembuatan cache Anda.
### Langkah 1.2: Salin titik akhir cache tanpa server
Verifikasi bahwa ElastiCache untuk Redis OSS telah selesai membuat cache dengan perintah. `describe-serverless-caches`
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Salin Alamat Titik Akhir yang ditunjukkan pada output. Anda akan memerlukan alamat ini saat membuat paket deployment untuk fungsi Lambda Anda.
### Langkah 1.3: Buat Peran IAM
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",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
}]
}
```
------
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"
```
### Langkah 1.4: Buat pengguna default
1. Buat pengguna default baru.
```
aws elasticache create-user \
--user-name default \
--user-id default-user-disabled \
--engine redis \
--authentication-mode Type=no-password-required \
--access-string "off +get ~keys*"
```
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-user-disabled iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Langkah 2: Buat fungsi Lambda untuk ElastiCache
Untuk membuat fungsi Lambda untuk mengakses ElastiCache cache, lakukan langkah-langkah ini.
### Langkah 2.1: Buat fungsi Lambda
Dalam tutorial ini, kami memberikan contoh kode dalam Python untuk fungsi Lambda Anda.
**Python**
Contoh kode Python berikut membaca dan menulis item ke cache Anda ElastiCache . Salin kode tersebut dan simpan ke dalam file bernama `app.py`. Pastikan untuk mengganti `elasticache_endpoint` nilai dalam kode dengan alamat titik akhir yang Anda salin pada langkah sebelumnya.
```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse
import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid
class ElastiCacheIAMProvider(redis.CredentialProvider):
def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
self.user = user
self.cache_name = cache_name
self.is_serverless = is_serverless
self.region = region
session = botocore.session.get_session()
self.request_signer = RequestSigner(
ServiceId("elasticache"),
self.region,
"elasticache",
"v4",
session.get_credentials(),
session.get_component("event_emitter"),
)
# Generated IAM tokens are valid for 15 minutes
@cached(cache=TTLCache(maxsize=128, ttl=900))
def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
query_params = {"Action": "connect", "User": self.user}
if self.is_serverless:
query_params["ResourceType"] = "ServerlessCache"
url = urlunparse(
ParseResult(
scheme="https",
netloc=self.cache_name,
path="/",
query=urlencode(query_params),
params="",
fragment="",
)
)
signed_url = self.request_signer.generate_presigned_url(
{"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
operation_name="connect",
expires_in=900,
region_name=self.region,
)
# RequestSigner only seems to work if the URL has a protocol, but
# Elasticache only accepts the URL without a protocol
# So strip it off the signed URL before returning
return (self.user, signed_url.removeprefix("https://"))
def lambda_handler(event, context):
username = "iam-user-01" # replace with your user id
cache_name = "cache-01" # replace with your cache name
elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
key='uuid'
# create a random UUID - this will be the sample element we add to the cache
uuid_in = uuid.uuid4().hex
redis_client.set(key, uuid_in)
result = redis_client.get(key)
decoded_result = result.decode("utf-8")
# check the retrieved item matches the item added to the cache and print
# the results
if decoded_result == uuid_in:
print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
else:
raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
return "Fetched value from Valkey"
```
Kode ini menggunakan pustaka redis-py Python untuk memasukkan item ke dalam cache Anda dan mengambilnya. Kode ini menggunakan cachetools untuk menyimpan token Auth IAM yang dihasilkan selama 15 menit. Untuk membuat paket penerapan yang berisi redis-py dan cachetools, lakukan langkah-langkah berikut.
Di direktori proyek Anda yang berisi file kode sumber app.py, buat paket folder untuk menginstal pustaka redis-py dan cachetools ke dalamnya.
```
mkdir package
```
Instal redis-py, cachetools menggunakan pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Buat file.zip yang berisi pustaka redis-py dan cachetools. Di Linux atau macOS, jalankan perintah CLI berikut. Di Windows, gunakan utilitas zip pilihan Anda untuk membuat file.zip dengan pustaka redis-py dan cachetools di root.
```
cd package
zip -r ../my_deployment_package.zip .
```
Tambahkan kode fungsi Anda ke file .zip. Di Linux atau macOS, jalankan perintah CLI berikut. Di Windows, gunakan utilitas zip pilihan Anda untuk menambahkan app.py ke root file.zip Anda.
```
cd ..
zip my_deployment_package.zip app.py
```
### Langkah 2.2: Buat peran IAM (peran eksekusi)
Lampirkan kebijakan AWS terkelola yang diberi nama `AWSLambdaVPCAccessExecutionRole` ke peran.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Langkah 2.3: Unggah paket deployment (buat fungsi Lambda)
Pada langkah ini, Anda membuat fungsi Lambda (AccessValkey) menggunakan perintah AWS CLI create-function.
Dari direktori proyek yang berisi file paket deployment Anda .zip, jalankan perintah Lambda CLI berikut. `create-function`
Untuk opsi peran, gunakan ARN dari peran eksekusi yang Anda buat di langkah sebelumnya. Untuk vpc-config masukkan daftar yang dipisahkan koma dari subnet VPC default Anda dan ID grup keamanan VPC default Anda. Anda dapat menemukan nilai-nilai ini di konsol Amazon VPC. Untuk menemukan subnet VPC default Anda, pilih **Your VPCs**, lalu pilih VPC default AWS akun Anda. Untuk menemukan grup keamanan untuk VPC ini, buka **Keamanan** dan pilih Grup **keamanan**. Pastikan Anda memilih wilayah us-east-1.
```
aws lambda create-function \
--function-name AccessValkey \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12 \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```
## Langkah 3: Uji fungsi Lambda dengan ElastiCache
Pada langkah ini, Anda menjalankan fungsi Lambda secara manual menggunakan perintah pemanggilan. Ketika fungsi Lambda dijalankan, ia menghasilkan UUID dan menulisnya ke ElastiCache cache yang Anda tentukan dalam kode Lambda Anda. Fungsi Lambda kemudian mengambil item dari cache.
1. Memanggil fungsi Lambda AccessValkey () menggunakan perintah pemanggilan AWS Lambda.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Verifikasikan bahwa fungsi Lambda berhasil dijalankan sebagai berikut:
+ Tinjau file output.txt.
+ Verifikasi hasil di CloudWatch Log dengan membuka CloudWatch konsol dan memilih grup log untuk fungsi Anda (/aws/lambda/AccessValkey). Log stream akan berisi output seperti yang berikut ini:
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Tinjau hasilnya di AWS Lambda konsol.
## Langkah 4: Bersihkan (Opsional)
Untuk membersihkannya, ambil langkah-langkah ini.
### Langkah 4.1: Hapus fungsi Lambda
```
aws lambda delete-function \
--function-name AccessValkey
```
### Langkah 4.2: Hapus cache Tanpa Server
Hapus cache.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Hapus pengguna dan grup pengguna.
```
aws elasticache delete-user \
--user-id default-user-disabled
aws elasticache delete-user \
--user-id iam-user-01
aws elasticache delete-user-group \
--user-group-id iam-user-group-01
```
### Langkah 4.3: Hapus Peran dan kebijakan IAM
```
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
aws iam delete-role \
--role-name "elasticache-iam-auth-app"
aws iam delete-policy \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```