Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengelola klaster
Sebagian besar operasi MemoryDB dilakukan di tingkat cluster. Anda dapat menyiapkan klaster dengan jumlah simpul tertentu dan grup parameter yang mengontrol properti untuk setiap simpul. Semua simpul dalam klaster dirancang agar berupa jenis simpul yang sama serta memiliki parameter dan pengaturan grup keamanan yang sama.
Setiap klaster harus memiliki pengidentifikasi klaster. Pengidentifikasi klaster adalah nama yang diberikan pelanggan untuk klaster. Identifier ini menentukan cluster tertentu ketika berinteraksi dengan MemoryDB API dan perintah. AWS CLI Pengidentifikasi klaster harus unik untuk pelanggan tersebut di suatu AWS Wilayah.
Cluster MemoryDB dirancang untuk diakses menggunakan instans Amazon EC2. Anda hanya dapat meluncurkan cluster MemoryDB Anda di cloud pribadi virtual (VPC) berdasarkan layanan Amazon VPC, tetapi Anda dapat mengaksesnya dari luar. AWS Untuk informasi selengkapnya, lihat [Mengakses sumber daya MemoryDB dari luar AWS](accessing-memorydb.md#access-from-outside-aws).
# Tingkatan data
Cluster yang menggunakan tipe node dari keluarga r6gd memiliki data berjenjang antara memori dan penyimpanan SSD lokal (solid state drive). Tiering data menyediakan opsi harga-kinerja baru untuk beban kerja Valkey dan Redis OSS dengan memanfaatkan solid state drive (SSDs) berbiaya lebih rendah di setiap node cluster selain menyimpan data dalam memori. Mirip dengan tipe node lainnya, data yang ditulis ke node r6gd disimpan dengan tahan lama dalam log transaksi multi-AZ. Tingkatan data sangat ideal untuk beban kerja yang mengakses hingga 20 persen dari keseluruhan set datanya secara rutin, dan untuk aplikasi yang dapat menoleransi latensi tambahan saat mengakses data di SSD.
Pada cluster dengan tiering data, MemoryDB memantau waktu akses terakhir dari setiap item yang disimpannya. Ketika memori yang tersedia (DRAM) sepenuhnya dikonsumsi, MemoryDB menggunakan algoritma yang paling tidak baru digunakan (LRU) untuk secara otomatis memindahkan item yang jarang diakses dari memori ke SSD. Ketika data pada SSD kemudian diakses, MemoryDB secara otomatis dan asinkron memindahkannya kembali ke memori sebelum memproses permintaan. Jika Anda memiliki beban kerja yang mengakses hanya subset dari datanya secara teratur, tingkatan data adalah cara optimal untuk menskalakan kapasitas Anda dengan hemat biaya.
Perhatikan bahwa saat menggunakan tingkatan data, kunci itu sendiri selalu tetap dalam memori, sedangkan LRU mengatur penempatan nilai pada memori vs disk. Secara umum, sebaiknya buat kunci Anda lebih kecil dari ukuran nilai Anda saat menggunakan tingkatan data.
Tingkatan data dirancang untuk memiliki dampak performa minimal pada beban kerja aplikasi. Misalnya, dengan asumsi nilai String 500 byte, Anda biasanya dapat mengharapkan latensi 450 mikrodetik tambahan untuk permintaan baca ke data yang disimpan di SSD dibandingkan dengan permintaan baca ke data dalam memori.
Dengan ukuran node tiering data terbesar (db.r6gd.8xlarge), Anda dapat menyimpan hingga \$1500 TBs dalam satu cluster 500 node (250 TB saat menggunakan 1 replika baca). Untuk tiering Data, MemoryDB menyimpan 19% memori (DRAM) per node untuk penggunaan non-data. Tiering data kompatibel dengan semua perintah Valkey dan Redis OSS dan struktur data yang didukung di MemoryDB. Anda tidak memerlukan perubahan sisi klien untuk menggunakan fitur ini.
**Topics**
+ [Praktik terbaik](data-tiering-best-practices.md)
+ [Keterbatasan tingkatan data](data-tiering-prerequisites.md)
+ [Harga tingkatan data](data-tiering-pricing.md)
+ [Pemantauan tingkat data](data-tiering-monitoring.md)
+ [Menggunakan tingkatan data](data-tiering-enabling.md)
+ [Memulihkan data dari snapshot ke dalam cluster](data-tiering-enabling-snapshots.md)
# Praktik terbaik
Kami merekomendasikan praktik terbaik berikut:
+ Tingkatan data sangat ideal untuk beban kerja yang mengakses hingga 20 persen dari keseluruhan set datanya secara rutin, dan untuk aplikasi yang dapat menoleransi latensi tambahan saat mengakses data di SSD.
+ Saat menggunakan kapasitas SSD yang tersedia pada simpul bertingkatan data, kami menyarankan agar ukuran nilai lebih besar dari ukuran kunci. Ukuran nilai tidak boleh lebih besar dari 128MB; jika tidak, itu tidak akan dipindahkan ke disk. Ketika item dipindahkan antara DRAM dan SSD, kunci akan selalu tetap dalam memori dan hanya nilai yang dipindahkan ke tingkat SSD.
# Keterbatasan tingkatan data
Tingkatan data memiliki batasan berikut:
+ Jenis node yang Anda gunakan harus berasal dari keluarga r6gd, yang tersedia di wilayah berikut:`us-east-2`,,,,`us-east-1`,`us-west-2`,`us-west-1`,`eu-west-1`,`eu-west-3`,`eu-central-1`, `ap-northeast-1` `ap-southeast-1``ap-southeast-2`, `ap-south-1` dan. `ca-central-1` `sa-east-1`
+ Anda tidak dapat memulihkan snapshot cluster r6gd ke cluster lain kecuali jika ia juga menggunakan r6gd.
+ Anda tidak dapat mengekspor snapshot ke Amazon S3 untuk kluster tingkat data.
+ Penyimpanan forkless tidak didukung.
+ Penskalaan tidak didukung dari klaster tingkatan data (misalnya, sebuah klaster yang menggunakan jenis simpul r6gd) ke klaster yang tidak menggunakan tingkatan data (misalnya, klaster yang menggunakan jenis simpul r6g).
+ Tingkatan data hanya mendukung kebijakan maxmemory `volatile-lru`, `allkeys-lru`, dan `noeviction`.
+ Item yang lebih besar dari 128 MiB tidak dipindahkan ke SSD.
# Harga tingkatan data
Node R6gd memiliki kapasitas total 5x lebih besar (memori\$1SSD) dan dapat membantu Anda mencapai penghematan biaya penyimpanan lebih dari 60 persen saat berjalan pada pemanfaatan maksimum dibandingkan dengan node R6g (hanya memori). Untuk informasi lebih lanjut, lihat harga [MemoryDB](https://aws.amazon.com/memorydb/pricing/).
# Pemantauan tingkat data
MemoryDB menawarkan metrik yang dirancang khusus untuk memantau cluster kinerja yang menggunakan tingkatan data. Untuk memantau rasio item dalam DRAM dibandingkan dengan SSD, Anda dapat menggunakan `CurrItems` metrik di[Metrik untuk MemoryDB](metrics.memorydb.md). Anda dapat menghitung persentase sebagai:`(CurrItems with Dimension: Tier = Memory * 100) / (CurrItems with no dimension filter)`.
Jika kebijakan penggusuran yang dikonfigurasi memungkinkan, maka MemoryDB akan mulai mengusir item ketika persentase item dalam memori berkurang di bawah 5 persen. Pada node yang dikonfigurasi dengan kebijakan noeviction, operasi tulis akan menerima kesalahan kehabisan memori.
Masih disarankan agar Anda mempertimbangkan [Penskalaan cluster MemoryDB](scaling-cluster.md) kapan persentase item dalam memori menurun di bawah 5 persen. Untuk informasi selengkapnya, lihat *Metrik untuk klaster MemoryDB yang menggunakan* tingkat data di. [Metrik untuk MemoryDB](metrics.memorydb.md)
# Menggunakan tingkatan data
## Menggunakan data tiering menggunakan Konsol Manajemen AWS
*Saat membuat cluster, Anda menggunakan tiering data dengan memilih tipe node dari keluarga r6gd, seperti db.r6gd.xlarge.* Memilih jenis simpul tersebut secara otomatis mengaktifkan tingkatan data.
Untuk informasi tentang cara membuat klaster, lihat [Langkah 2: Buat klaster](getting-started.md#getting-started.createcluster).
## Mengaktifkan tiering data menggunakan AWS CLI
Saat membuat cluster menggunakan AWS CLI, Anda menggunakan tiering data dengan memilih tipe node dari keluarga r6gd, seperti *db.r6gd.xlarge* dan mengatur parameter. `--data-tiering`
Anda tidak dapat membatalkan penggunaan tingkatan data ketika memilih jenis simpul dari keluarga r6gd. Jika Anda mengatur parameter `--no-data-tiering`, operasi akan gagal.
Untuk Linux, macOS, atau Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey \
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering
```
Untuk Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg
--data-tiering
```
Setelah menjalankan operasi ini, Anda akan melihat respons seperti yang berikut ini:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering":"true",
"AutoMinorVersionUpgrade": true
}
}
```
# Memulihkan data dari snapshot ke dalam cluster
Anda dapat memulihkan snapshot ke cluster baru dengan tiering data yang diaktifkan menggunakan (Console), (AWS CLI) atau (MemoryDB API). Ketika Anda membuat sebuah klaster menggunakan jenis simpul dalam keluarga r6gd, tingkatan data diaktifkan.
## Memulihkan data dari snapshot ke cluster dengan tiering data diaktifkan (konsol)
Untuk memulihkan snapshot ke cluster baru dengan tiering data diaktifkan (konsol), ikuti langkah-langkah di [Memulihkan dari snapshot (Konsol)](snapshots-restoring.md#snapshots-restoring-CON)
Perhatikan bahwa untuk mengaktifkan data-tiering, Anda perlu memilih jenis node dari keluarga r6gd.
## Memulihkan data dari snapshot ke cluster dengan tiering data diaktifkan (CLI)AWS
Saat membuat cluster menggunakan AWS CLI, tiering data secara default digunakan dengan memilih tipe node dari keluarga r6gd, seperti *db.r6gd.xlarge* dan mengatur parameter. `--data-tiering`
Anda tidak dapat membatalkan penggunaan tingkatan data ketika memilih jenis simpul dari keluarga r6gd. Jika Anda mengatur parameter `--no-data-tiering`, operasi akan gagal.
Untuk Linux, macOS, atau Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering \
--snapshot-name my-snapshot
```
Untuk Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg ^
--data-tiering ^
--snapshot-name my-snapshot
```
Setelah menjalankan operasi ini, Anda akan melihat respons seperti yang berikut ini:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "true"
}
```
# Menyiapkan klaster
Berikut ini, Anda dapat menemukan petunjuk tentang membuat cluster menggunakan konsol MemoryDB, AWS CLI, atau MemoryDB API.
Setiap kali Anda membuat cluster, itu adalah ide yang baik untuk melakukan beberapa pekerjaan persiapan sehingga Anda tidak perlu meng-upgrade atau membuat perubahan segera.
**Topics**
+ [Menentukan kebutuhan Anda](cluster-create-determine-requirements.md)
# Menentukan kebutuhan Anda
**Persiapan**
Mengetahui jawaban atas pertanyaan berikut akan membantu memudahkan proses pembuatan klaster Anda:
+ Pastikan untuk membuat grup subnet di VPC yang sama sebelum Anda mulai membuat cluster. Atau, Anda dapat menggunakan grup subnet default yang disediakan. Untuk informasi selengkapnya, lihat [Subnet dan grup subnet](subnetgroups.md).
MemoryDB dirancang untuk diakses dari dalam AWS menggunakan Amazon EC2. Namun, jika Anda meluncurkan dalam VPC berbasis Amazon VPC, Anda dapat memberikan akses dari luar. AWS Untuk informasi selengkapnya, lihat [Mengakses sumber daya MemoryDB dari luar AWS](accessing-memorydb.md#access-from-outside-aws).
+ Apakah Anda perlu menyesuaikan nilai parameter tertentu?
Jika ya, buat grup parameter kustom. Untuk informasi selengkapnya, lihat [Membuat grup parameter](parametergroups.creating.md).
+ Apakah Anda perlu membuat grup keamanan VPC?
Untuk informasi selengkapnya, lihat [Keamanan di VPC Anda](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Bagaimana Anda akan menerapkan toleransi kesalahan?
Untuk informasi selengkapnya, lihat [Mitigasi Kegagalan](faulttolerance.md).
**Topics**
+ [Persyaratan memori dan prosesor](#cluster-create-determine-requirements-memory)
+ [Konfigurasi cluster MemoryDB](#cluster-configuration)
+ [I/O Multiplexing yang disempurnakan](#cluster-create-determine-requirements-multiplexing)
+ [Persyaratan penskalaan](#cluster-create-determine-requirements-scaling)
+ [Persyaratan akses](#cluster-create-determine-requirements-access)
+ [Wilayah dan Zona Ketersediaan](#cluster-create-determine-requirements-region)
## Persyaratan memori dan prosesor
Blok bangunan dasar MemoryDB adalah node. Node dikonfigurasi dalam pecahan untuk membentuk cluster. Saat menentukan jenis simpul yang akan digunakan untuk klaster Anda, pertimbangkan konfigurasi simpul klaster dan jumlah data yang harus disimpan.
## Konfigurasi cluster MemoryDB
Cluster MemoryDB terdiri dari 1 hingga 500 pecahan. Data dalam cluster MemoryDB dipartisi di seluruh pecahan di cluster. Aplikasi Anda terhubung dengan cluster MemoryDB menggunakan alamat jaringan yang disebut Endpoint. *Selain titik akhir node, cluster MemoryDB sendiri memiliki titik akhir yang disebut titik akhir cluster.* Aplikasi Anda dapat menggunakan endpoint ini untuk membaca dari atau menulis ke cluster, meninggalkan penentuan node mana yang akan dibaca atau ditulis hingga MemoryDB.
## I/O Multiplexing yang disempurnakan
Jika Anda menjalankan Valkey atau Redis OSS versi 7.0 atau lebih tinggi, Anda akan mendapatkan akselerasi tambahan dengan I/O multiplexing yang disempurnakan, di mana setiap jaringan pipa thread IO khusus memerintahkan dari beberapa klien ke mesin, memanfaatkan kemampuan untuk memproses perintah secara efisien dalam batch. Untuk informasi selengkapnya, lihat [Performa ultra-cepat](https://aws.amazon.com/memorydb/features/#Ultra-fast_performance) dan[Jenis simpul yang didukung](nodes.supportedtypes.md).
## Persyaratan penskalaan
Semua cluster dapat ditingkatkan tipe node yang lebih besar. Saat Anda meningkatkan kluster MemoryDB, Anda dapat melakukannya secara online sehingga cluster tetap tersedia atau Anda dapat menyemai cluster baru dari snapshot dan menghindari cluster baru mulai kosong.
Untuk informasi selengkapnya, lihat [Penskalaan](scaling.md) dalam panduan ini.
## Persyaratan akses
Secara desain, cluster MemoryDB diakses dari instans Amazon EC2. Akses jaringan ke cluster MemoryDB terbatas pada akun yang membuat cluster. Oleh karena itu, sebelum Anda dapat mengakses cluster dari instans Amazon EC2, Anda harus mengotorisasi ingress ke cluster. Untuk petunjuk yang lebih mendetail, lihat [Langkah 3: Mengizinkan akses ke klaster](getting-started.md#getting-started.authorizeaccess) dalam panduan ini.
## Wilayah dan Zona Ketersediaan
Dengan menemukan kluster MemoryDB Anda di AWS Wilayah yang dekat dengan aplikasi Anda, Anda dapat mengurangi latensi. Jika klaster Anda memiliki beberapa node, menempatkan node Anda di Availability Zone yang berbeda dapat mengurangi dampak kegagalan pada klaster Anda.
Untuk informasi selengkapnya, lihat berikut ini:
+ [Memilih Wilayah dan Availability Zone](regionsandazs.md)
+ [Mitigasi Kegagalan](faulttolerance.md)
# Membuat kluster
MemoryDB menawarkan tiga cara untuk membuat cluster. Untuk informasi selengkapnya, lihat [Langkah 2: Buat klaster](getting-started.md#getting-started.createcluster).
# Melihat detail klaster
Anda dapat melihat informasi detail tentang satu atau beberapa cluster menggunakan konsol MemoryDB, AWS CLI, atau MemoryDB API.
## Melihat detail untuk cluster MemoryDB (Konsol)
Prosedur berikut merinci cara melihat detail cluster MemoryDB menggunakan konsol MemoryDB.
****
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Untuk melihat detail cluster, pilih tombol radio di sebelah kiri nama cluster dan kemudian pilih **Lihat detail**. Anda juga dapat mengklik langsung pada cluster untuk melihat halaman detail cluster.
Halaman **detail Cluster** menampilkan detail tentang cluster, termasuk titik akhir cluster. Anda dapat melihat detail lebih lanjut menggunakan beberapa tab yang tersedia di halaman **detail Cluster**.
1. Pilih tab **Pecahan dan node** untuk melihat daftar pecahan cluster dan jumlah node di setiap pecahan.
1. Untuk melihat informasi spesifik pada sebuah node, perluas pecahan pada tabel di bawah ini. Atau Anda juga dapat mencari pecahan menggunakan kotak pencarian.
Melakukan hal ini akan menampilkan informasi tentang setiap node, termasuk Availability Zone, slots/keyspaces dan statusnya.
1. Pilih tab **Metrik** untuk memantau prosesnya masing-masing, seperti **Pemanfaatan CPU dan Pemanfaatan** **CPU Mesin**. Untuk informasi selengkapnya, lihat [Metrik untuk MemoryDB](metrics.memorydb.md).
1. Pilih tab **Jaringan dan keamanan** untuk melihat detail grup subnet dan grup keamanan.
1. Di **grup Subnet**, Anda dapat melihat nama grup subnet, tautan ke VPC yang dimiliki subnet dan Nama Sumber Daya Amazon (ARN) grup subnet.
1. Di **Grup keamanan**, Anda dapat melihat ID grup keamanan, nama, dan deskripsi.
1. Pilih tab **Maintenace dan snapshot** untuk melihat detail pengaturan snapshot.
1. Di **Snapshot**, Anda dapat melihat apakah Snapshot Otomatis diaktifkan, periode retensi snapshot, dan jendela snapshot.
1. Di **Snapshots**, Anda akan melihat daftar snapshot apa pun ke cluster ini, termasuk nama snapshot, ukuran, jumlah pecahan, dan status.
Untuk informasi selengkapnya, lihat [Melakukan snapshot dan pemulihan](snapshots.md).
1. Pilih tab **Maintenace dan snapshot** untuk melihat detail Jendela Pemeliharaan, bersama dengan pembaruan ACL, Resharding, atau Layanan yang tertunda. Untuk informasi selengkapnya, lihat [Mengelola pemeliharaan](maintenance-window.md).
1. Pilih tab **Pembaruan Layanan** untuk melihat detail pembaruan layanan apa pun yang berlaku untuk klaster ini. Untuk informasi selengkapnya, lihat [Pembaruan layanan di MemoryDB](service-updates.md).
1. Pilih tab **Tag** untuk melihat detail tag sumber daya atau alokasi biaya apa pun yang terkait dengan klaster ini. Untuk informasi selengkapnya, lihat [Menandai snapshot](snapshots-tagging.md).
## Melihat detail cluster (AWS CLI)
Anda dapat melihat detail untuk cluster menggunakan AWS CLI `describe-clusters` perintah. Jika parameter `--cluster-name` dihilangkan, detail untuk maksimal `--max-results` klaster akan ditampilkan. Jika parameter `--cluster-name` disertakan, detail untuk klaster yang ditentukan akan ditampilkan. Anda dapat membatasi jumlah catatan yang ditampilkan dengan parameter `--max-results`.
Kode berikut menampilkan daftar detail untuk `my-cluster`.
```
aws memorydb describe-clusters --cluster-name my-cluster
```
Kode berikut menampilkan daftar detail untuk maksimal 25 klaster.
```
aws memorydb describe-clusters --max-results 25
```
**Example**
Untuk Linux, macOS, atau Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster \
--show-shard-details
```
Untuk Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster ^
--show-shard-details
```
Output JSON berikut menunjukkan respons:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Description": "my cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": 1629230643.961,
"Endpoint": {
"Address": "my-cluster-0001-001.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"CreateTime": 1629230644.025,
"Endpoint": {
"Address": "my-cluster-0001-002.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "default",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:000000000:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "sat:06:30-sat:07:30",
"SnapshotWindow": "04:00-05:00",
"ACLName": "open-access",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true,
}
```
Untuk informasi lebih lanjut, lihat topik AWS CLI untuk MemoryDB. [https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html)
## Melihat detail cluster (MemoryDB API)
Anda dapat melihat detail untuk cluster menggunakan aksi API `DescribeClusters` MemoryDB. Jika parameter `ClusterName` disertakan, detail untuk klaster yang ditentukan akan ditampilkan. Jika parameter `ClusterName` dihilangkan, detail untuk maksimal `MaxResults` klaster (default-nya 100) akan ditampilkan. Nilai untuk `MaxResults` tidak boleh kurang dari 20 atau lebih dari 100.
Kode berikut menampilkan daftar detail untuk `my-cluster`.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=my-cluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Kode berikut menampilkan daftar detail untuk maksimal 25 klaster.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&MaxResults=25
&Version=2021-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Untuk informasi selengkapnya, lihat topik referensi API MemoryDB. [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html)
# Memodifikasi cluster MemoryDB
Selain menambahkan atau menghapus node dari cluster, mungkin ada saat-saat di mana Anda perlu membuat perubahan lain ke cluster yang ada, seperti menambahkan grup keamanan, mengubah jendela pemeliharaan atau grup parameter.
Sebaiknya atur periode pemeliharaan Anda pada waktu penggunaan terendah. Jadi, Anda mungkin perlu mengubahnya dari waktu ke waktu.
Saat Anda mengubah parameter klaster, perubahan tersebut akan segera diterapkan pada klaster tersebut. Hal ini berlaku terlepas dari apakah Anda mengubah grup parameter klaster itu sendiri atau nilai parameter dalam grup parameter klaster.
Anda juga dapat memperbarui versi mesin cluster Anda. Misalnya, Anda dapat memilih versi minor engine baru dan MemoryDB akan segera memperbarui cluster Anda.
## Menggunakan Konsol Manajemen AWS
**Untuk mengubah klaster**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dari daftar di sudut kanan atas, pilih AWS Wilayah tempat cluster yang ingin Anda modifikasi berada.
1. Dari navigasi kiri, pergi ke **Clusters**. Dari **detail Clusters**, pilih cluster menggunakan tombol radio dan pergi ke **Actions** dan kemudian **Modify**.
1. Halaman **Modify** muncul.
1. Di jendela **Modify**, buat modifikasi yang Anda inginkan. Opsinya meliputi:
+ Deskripsi
+ Grup Subnet
+ Grup Keamanan VPC
+ Tipe simpul
**catatan**
Jika klaster menggunakan jenis simpul dari keluarga r6gd, Anda hanya dapat memilih ukuran simpul yang berbeda dari dalam keluarga tersebut. Jika Anda memilih jenis simpul dari keluarga r6gd, tingkatan data akan diaktifkan secara otomatis. Untuk informasi selengkapnya, lihat [Tingkatan data](data-tiering.md).
+ Kompatibilitas versi Valkey atau Redis OSS
+ Aktifkan snapshot otomatis
+ Periode Retensi Snapshot
+ Jendela Snapshot
+ Periode pemeliharaan
+ Topik untuk Pemberitahuan SNS
1. Pilih **Simpan perubahan**.
Anda juga dapat pergi ke halaman **detail Cluster** dan klik **modifikasi** untuk membuat modifikasi pada cluster. Jika Anda ingin memodifikasi bagian tertentu dari cluster, Anda dapat pergi ke tab masing-masing di halaman **detail Cluster** dan klik **Ubah**.
## Menggunakan AWS CLI
Anda dapat memodifikasi cluster yang ada menggunakan AWS CLI `update-cluster` operasi. Untuk mengubah nilai konfigurasi klaster, tentukan ID klaster, parameter yang akan diubah, dan nilai baru parameter. Contoh berikut mengubah periode pemeliharaan untuk klaster bernama `my-cluster` dan menerapkan perubahan tersebut secara langsung.
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Untuk Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Untuk informasi selengkapnya, lihat [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) di Command Reference. AWS CLI
## Menggunakan MemoryDB API
Anda dapat memodifikasi cluster yang ada menggunakan operasi API [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)MemoryDB. Untuk mengubah nilai konfigurasi klaster, tentukan ID klaster, parameter yang akan diubah, dan nilai baru parameter. Contoh berikut mengubah periode pemeliharaan untuk klaster bernama `my-cluster` dan menerapkan perubahan tersebut secara langsung.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&ClusterName=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210802T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
## Cara memicu peningkatan lintas mesin dari Redis OSS ke Valkey
Anda dapat memutakhirkan cluster Redis OSS yang ada ke mesin Valkey menggunakan Konsol, API, atau CLI.
Jika Anda memiliki kluster Redis OSS yang menggunakan grup parameter default, Anda dapat meningkatkan ke Valkey dengan menentukan versi engine dan engine baru dengan API update-cluster.
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2
```
Untuk Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2
```
Jika Anda memiliki grup parameter khusus yang diterapkan ke cluster Redis OSS yang ada yang ingin Anda tingkatkan, Anda harus melewati grup parameter Valkey kustom dalam permintaan juga. Grup parameter kustom Valkey input harus memiliki nilai parameter statis Redis OSS yang sama dengan grup parameter kustom Redis OSS yang ada.
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2 \
--parameter-group-name myParamGroup
```
Untuk Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2 ^
--parameter-group-name myParamGroup
```
# Menambahkan/Menghapus node dari cluster
Anda dapat menambahkan atau menghapus node dari cluster menggunakan API Konsol Manajemen AWS, the AWS CLI, atau MemoryDB.
## Menggunakan Konsol Manajemen AWS
****
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dari daftar cluster, pilih nama cluster dari mana Anda ingin menambahkan atau menghapus node.
1. Di bawah tab **Pecahan dan node**, pilih **Tambah/Hapus** node
1. Di **Jumlah node baru**, masukkan jumlah node yang Anda inginkan.
1. Pilih **Konfirmasi**.
**penting**
Jika Anda mengatur jumlah node ke 1, Anda tidak akan lagi diaktifkan Multi-AZ. Anda juga dapat memilih untuk mengaktifkan **Auto failover**.
## Menggunakan AWS CLI
1. Identifikasi nama-nama node yang ingin Anda hapus. Untuk informasi selengkapnya, lihat [Melihat detail klaster](clusters.viewdetails.md).
1. Gunakan operasi CLI `update-cluster` dengan daftar simpul yang akan dihapus, seperti dalam contoh berikut.
Untuk menghapus simpul dari klaster menggunakan antarmuka baris perintah, gunakan perintah `update-cluster` dengan parameter berikut:
+ `--cluster-name`ID dari cluster yang ingin Anda hapus node dari.
+ `--replica-configuration`— Memungkinkan Anda untuk mengatur jumlah replika:
+ `ReplicaCount`— Tetapkan properti ini untuk menentukan jumlah node replika yang Anda inginkan.
+ `--region`Menentukan AWS Wilayah cluster yang ingin Anda hapus node dari.
Untuk Linux, macOS, atau Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--replica-configuration \
ReplicaCount=1 \
--region us-east-1
```
Untuk Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--replica-configuration ^
ReplicaCount=1 ^
--region us-east-1
```
Untuk informasi lebih lanjut, lihat AWS CLI topiknya [https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Menggunakan MemoryDB API
Untuk menghapus node menggunakan API MemoryDB, panggil operasi `UpdateCluster` API dengan nama cluster dan daftar node yang akan dihapus, seperti yang ditunjukkan:
+ `ClusterName`ID dari cluster yang ingin Anda hapus node dari.
+ `ReplicaConfiguration`— Memungkinkan Anda untuk mengatur jumlah replika:
+ `ReplicaCount`— Tetapkan properti ini untuk menentukan jumlah node replika yang Anda inginkan.
+ `Region`Menentukan AWS Wilayah cluster yang Anda ingin menghapus node dari.
Lihat informasi yang lebih lengkap di [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Mengakses klaster Anda
Instans MemoryDB Anda dirancang untuk diakses melalui instans Amazon. EC2
Anda dapat mengakses node MemoryDB Anda dari EC2 instans Amazon di VPC Amazon yang sama. Atau, dengan menggunakan VPC peering, Anda dapat mengakses node MemoryDB Anda dari Amazon di VPC Amazon yang EC2 berbeda.
**Topics**
+ [Berikan akses ke klaster Anda](#grant-access)
+ [Mengakses sumber daya MemoryDB dari luar AWS](#access-from-outside-aws)
## Berikan akses ke klaster Anda
Anda dapat terhubung ke cluster MemoryDB Anda hanya dari EC2 instans Amazon yang berjalan di VPC Amazon yang sama. Dalam hal ini, Anda akan perlu memberikan izin masuk jaringan ke klaster.
**Untuk memberikan izin masuk jaringan dari grup keamanan Amazon VPC ke klaster**
1. Masuk ke Konsol Manajemen AWS dan buka EC2 konsol Amazon di [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Di panel navigasi kiri, di bawah **Jaringan & Keamanan**, pilih **Grup Keamanan**.
1. Dari daftar grup keamanan, pilih grup keamanan untuk Amazon VPC Anda. *Kecuali Anda membuat grup keamanan untuk penggunaan MemoryDB, grup keamanan ini akan diberi nama default.*
1. Pilih tab **Masuk**, lalu lakukan hal berikut:
1. Pilih **Edit**.
1. Pilih **Tambahkan aturan**.
1. Di kolom **Jenis**, pilih **Aturan TCP kustom**.
1. Di kotak **Rentang port**, ketik nomor port untuk simpul klaster Anda. Nomor ini harus sama dengan yang Anda tentukan saat meluncurkan klaster. Port default untuk Valkey dan Redis OSS adalah. **6379**
1. Di kotak **Sumber**, pilih **Anywhere** 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 node MemoryDB Anda.
**penting**
Membuka cluster MemoryDB ke 0.0.0.0/0 tidak mengekspos cluster ke Internet karena tidak memiliki alamat IP publik dan oleh karena itu tidak dapat diakses dari luar VPC. Namun, grup keamanan default dapat diterapkan ke EC2 instans Amazon lainnya di akun pelanggan, dan instans tersebut mungkin memiliki alamat IP publik. Jika instans tersebut menjalankan sesuatu di port default, layanan tersebut dapat terekspos secara tak disengaja. Oleh karena itu, kami sarankan untuk membuat Grup Keamanan VPC yang akan digunakan secara eksklusif oleh MemoryDB. Untuk informasi selengkapnya, lihat [Grup Keamanan Kustom](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Pilih **Simpan**.
Saat Anda meluncurkan EC2 instans Amazon ke VPC Amazon Anda, instance itu akan dapat terhubung ke cluster MemoryDB Anda.
## Mengakses sumber daya MemoryDB dari luar AWS
MemoryDB adalah layanan yang dirancang untuk digunakan secara internal ke VPC Anda. Akses eksternal tidak disarankan karena latensi lalu lintas Internet dan masalah keamanan. Namun, jika akses eksternal ke MemoryDB diperlukan untuk tujuan pengujian atau pengembangan, itu dapat dilakukan melalui VPN.
Menggunakan AWS Client VPN, Anda mengizinkan akses eksternal ke node MemoryDB Anda dengan manfaat berikut:
+ Akses terbatas hanya untuk pengguna atau kunci autentikasi yang disetujui;
+ Lalu lintas terenkripsi antara Klien VPN dan titik akhir AWS VPN;
+ Akses yang terbatas ke subnet atau simpul tertentu;
+ Pencabutan akses dengan mudah dari pengguna atau kunci autentikasi;
+ Mengaudit koneksi;
Prosedur berikut menunjukkan cara untuk:
**Topics**
+ [Membuat otoritas sertifikat](#create-cert)
+ [Mengkonfigurasi komponen VPN AWS klien](#configure-vpn-components)
+ [Konfigurasi klien VPN](#configure-vpn-client)
### Membuat otoritas sertifikat
Dimungkinkan untuk membuat Otoritas Sertifikat (CA) menggunakan teknik atau alat yang berbeda. Dianjurkan menggunakan utilitas easy-rsa, yang disediakan oleh proyek [OpenVPN](https://openvpn.net/community-resources/openvpn-project/). Terlepas opsi pilihan Anda, pastikan untuk menjaga kunci tetap aman. Prosedur berikut mengunduh skrip easy-RSA, membuat Otoritas Sertifikat dan kunci untuk autentikasi klien VPN pertama:
+ Untuk membuat sertifikat awal, buka terminal dan lakukan hal berikut:
+ `git clone`[https://github.com/OpenVPN/mudah-rsa](https://github.com/OpenVPN/easy-rsa)
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa init-pki`
+ `./easyrsa3/easyrsa build-ca nopass`
+ `./easyrsa3/easyrsa build-server-full server nopass`
+ `./easyrsa3/easyrsa build-client-full client1.domain.tld nopass`
Subdirektori **pki** yang berisi sertifikat akan dibuat di bawah **easy-rsa**.
+ Kirim sertifikat server ke manajer AWS Sertifikat (ACM):
+ Pada konsol ACM, pilih **Certificate Manager**.
+ Pilih **Impor Sertifikat**.
+ Masukkan sertifikat kunci publik yang tersedia di dalam file `easy-rsa/pki/issued/server.crt` pada bidang **Tubuh sertifikat**.
+ Tempelkan kunci privat yang tersedia di dalam `easy-rsa/pki/private/server.key` pada bidang **Kunci privat sertifikat**. Pastikan untuk mengeblok semua baris di antara `BEGIN AND END PRIVATE KEY` (termasuk baris `BEGIN` dan `END`).
+ Tempelkan kunci publik CA yang tersedia pada file `easy-rsa/pki/ca.crt` pada bidang **Rantai sertifikat**.
+ Pilih **Tinjau dan impor**.
+ Pilih **Impor**.
Untuk mengirimkan sertifikat server ke ACM menggunakan AWS CLI, jalankan perintah berikut: `aws acm import-certificate --certificate fileb://easy-rsa/pki/issued/server.crt --private-key file://easy-rsa/pki/private/server.key --certificate-chain file://easy-rsa/pki/ca.crt --region region`
Perhatikan ARN sertifikat untuk penggunaan di masa mendatang.
### Mengkonfigurasi komponen VPN AWS klien
**Menggunakan AWS Konsol**
Di AWS konsol, pilih **Layanan** dan kemudian **VPC**.
Di bawah **Virtual Private Network**, pilih **Titik akhir Client VPN** dan lakukan hal berikut:
**Mengkonfigurasi komponen AWS Client VPN**
+ Pilih **Buat Titik Akhir Client VPN**.
+ Tentukan opsi berikut:
+ ** IPv4 Client CIDR**: gunakan jaringan pribadi dengan netmask minimal /22 range. Pastikan bahwa subnet yang dipilih tidak bertentangan dengan alamat dari jaringan VPC. Contoh: 10.0.0.0/22.
+ Pada **ARN sertifikat server**, pilih ARN dari sertifikat yang sebelumnya diimpor.
+ Pilih **Gunakan autentikasi bersama**.
+ Pada **ARN sertifikat klien**, pilih ARN dari sertifikat yang sebelumnya diimpor.
+ Pilih **Buat Titik Akhir Client VPN**.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 create-client-vpn-endpoint --client-cidr-block "10.0.0.0/22" --server-certificate-arn arn:aws:acm:us-east-1:012345678912:certificate/0123abcd-ab12-01a0-123a-123456abcdef --authentication-options Type=certificate-authentication,,MutualAuthentication={ClientRootCertificateChainArn=arn:aws:acm:us-east-1:012345678912:certificate/123abcd-ab12-01a0-123a-123456abcdef} --connection-log-options Enabled=false `
Contoh keluaran:
`"ClientVpnEndpointId": "cvpn-endpoint-0123456789abcdefg", "Status": { "Code": "pending-associate" }, "DnsName": "cvpn-endpoint-0123456789abcdefg.prod.clientvpn.us-east-1.amazonaws.com" } `
**Kaitkan jaringan target ke titik akhir VPN**
+ Pilih titik akhir baru VPN, dan kemudian pilih tab **Asosiasi**.
+ Pilih **Associate** dan tentukan opsi berikut.
+ **VPC: Pilih VPC** MemoryDB Cluster.
+ Pilih salah satu jaringan cluster MemoryDB. Jika ragu, tinjau jaringan di **Grup Subnet** di dasbor MemoryDB.
+ Pilih **Associate**. Jika perlu, ulangi langkah tersebut untuk jaringan yang tersisa.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 associate-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --subnet-id subnet-0123456789abdcdef`
Contoh keluaran:
`"Status": { "Code": "associating" }, "AssociationId": "cvpn-assoc-0123456789abdcdef" } `
**Tinjau grup keamanan VPN**
Titik akhir VPN akan secara otomatis mengadopsi grup keamanan default dari VPC. Periksa aturan masuk dan keluar dan konfirmasikan apakah grup keamanan mengizinkan lalu lintas dari jaringan VPN (ditentukan pada pengaturan Titik Akhir VPN) ke jaringan MemoryDB pada port layanan (secara default, 6379 untuk Redis).
Jika Anda perlu mengubah grup keamanan yang ditetapkan untuk titik akhir VPN, lanjutkan sebagai berikut:
+ Pilih grup keamanan saat ini.
+ Pilih **Terapkan Grup Keamanan**.
+ Pilih Grup Keamanan baru.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 apply-security-groups-to-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefga --vpc-id vpc-0123456789abdcdef --security-group-ids sg-0123456789abdcdef`
Contoh keluaran:
`"SecurityGroupIds": [ "sg-0123456789abdcdef" ] } `
**catatan**
Grup keamanan MemoryDB juga perlu mengizinkan lalu lintas yang datang dari klien VPN. Alamat klien akan ditutupi dengan alamat titik akhir VPN, sesuai Jaringan VPC. Oleh karena itu, pertimbangkan jaringan VPC (bukan jaringan Klien VPN) saat membuat aturan masuk pada grup keamanan MemoryDB.
**Otorisasi akses VPN ke jaringan tujuan**
Pada tab **Otorisasi**, pilih **Izinkan Masuk** dan tentukan hal berikut:
+ Jaringan tujuan untuk mengaktifkan akses: Gunakan 0.0.0.0/0 untuk memungkinkan akses ke jaringan apa pun (termasuk Internet) atau membatasi jaringan/host MemoryDB.
+ Di bawah **Berikan akses ke:**, pilih **Izinkan akses ke semua pengguna**.
+ Pilih **Tambahkan Aturan Otorisasi**.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 authorize-client-vpn-ingress --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --target-network-cidr 0.0.0.0/0 --authorize-all-groups`
Contoh keluaran:
`{ "Status": { "Code": "authorizing" } }`
**Mengizinkan akses ke Internet dari klien VPN**
Jika Anda perlu menelusuri Internet melalui VPN, Anda perlu membuat rute tambahan. Pilih tab **Tabel Rute** dan kemudian pilih **Buat Rute**:
+ Tujuan rute: 0.0.0.0/0
+ **ID Subnet VPC Target**: Pilih salah satu subnet yang terkait dengan akses ke Internet.
+ Pilih **Buat Rute**.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 create-client-vpn-route --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --destination-cidr-block 0.0.0.0/0 --target-vpc-subnet-id subnet-0123456789abdcdef`
Contoh keluaran:
`{ "Status": { "Code": "creating" } } `
### Konfigurasi klien VPN
Di Dasbor AWS Client VPN, pilih titik akhir VPN yang baru saja dibuat dan pilih **Unduh Konfigurasi Klien**. Salin file konfigurasi, serta file `easy-rsa/pki/issued/client1.domain.tld.crt` dan `easy-rsa/pki/private/client1.domain.tld.key`. Edit file konfigurasi dan ubah atau tambahkan parameter berikut:
+ cert: tambahkan baris baru dengan parameter cert menunjuk ke file `client1.domain.tld.crt`. Gunakan jalur lengkap ke file. Contoh: `cert /home/user/.cert/client1.domain.tld.crt`
+ cert: key: tambahkan baris baru dengan kunci parameter menunjuk ke file `client1.domain.tld.key`. Gunakan jalur lengkap ke file. Contoh: `key /home/user/.cert/client1.domain.tld.key`
Tetapkan koneksi VPN dengan perintah: `sudo openvpn --config downloaded-client-config.ovpn`
**Mencabut akses**
Jika Anda perlu untuk membatalkan akses dari kunci klien tertentu, kunci tersebut perlu dicabut di CA. Kemudian kirimkan daftar pencabutan ke AWS Client VPN.
Mencabut kunci dengan easy-rsa:
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa revoke client1.domain.tld`
+ Masukkan “ya” untuk melanjutkan, atau masukkan input lain apa pun untuk membatalkan.
`Continue with revocation: `yes` ... * `./easyrsa3/easyrsa gen-crl`
+ CRL yang diperbarui telah dibuat. File CRL: `/home/user/easy-rsa/pki/crl.pem`
Mengimpor daftar pencabutan ke Client VPN AWS :
+ Pada Konsol Manajemen AWS, pilih **Layanan** dan kemudian **VPC**.
+ Pilih **Titik Akhir Client VPN**.
+ Pilih Titik Akhir Client VPN dan kemudian pilih **Tindakan** -> **Impor CRL Sertifikat Klien**.
+ Tempelkan isi dari file `crl.pem`.
**Menggunakan AWS CLI**
Jalankan perintah berikut:
`aws ec2 import-client-vpn-client-certificate-revocation-list --certificate-revocation-list file://./easy-rsa/pki/crl.pem --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg `
Contoh keluaran:
`Example output: { "Return": true } `
# Menemukan titik akhir koneksi
Aplikasi Anda terhubung ke cluster Anda menggunakan endpoint. Endpoint adalah alamat unik cluster. Gunakan Cluster *Endpoint cluster* untuk semua operasi.
Bagian berikut memandu Anda untuk menemukan titik akhir yang Anda perlukan.
## Menemukan Endpoint untuk Cluster MemoryDB ()Konsol Manajemen AWS
**Untuk menemukan titik akhir cluster MemoryDB**
1. Masuk ke Konsol Manajemen AWS dan buka konsol MemoryDB di. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dari panel navigasi, pilih **Clusters**.
Layar cluster akan muncul dengan daftar cluster. Pilih cluster yang ingin Anda sambungkan.
1. Untuk menemukan titik akhir cluster, pilih nama cluster (bukan tombol radio).
1. **Titik akhir Cluster** ditampilkan di bawah **detail Cluster**. Untuk menyalinnya, pilih ikon *salin* di sebelah kiri titik akhir.
## Menemukan Titik Akhir untuk Cluster MemoryDB (CLI)AWS
Anda dapat menggunakan `describe-clusters` perintah untuk menemukan titik akhir untuk sebuah cluster. Perintah mengembalikan titik akhir cluster.
Operasi berikut mengambil endpoint, yang dalam contoh ini direpresentasikan sebagai*sample*, untuk cluster. `mycluster`
Ia mengembalikan respon JSON berikut:
```
aws memorydb describe-clusters \
--cluster-name mycluster
```
Untuk Windows:
```
aws memorydb describe-clusters ^
--cluster-name mycluster
```
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.4",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:zzzexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"AutoMinorVersionUpgrade": true
}
]
}
```
Untuk informasi selengkapnya, lihat [menjelaskan klaster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html).
## Menemukan Endpoint untuk Cluster MemoryDB (MemoryDB API)
Anda dapat menggunakan API MemoryDB untuk menemukan titik akhir cluster.
### Menemukan Endpoint untuk Cluster MemoryDB (MemoryDB API)
Anda dapat menggunakan API MemoryDB untuk menemukan titik akhir klaster dengan tindakan tersebut. `DescribeClusters` Tindakan mengembalikan titik akhir cluster.
Operasi berikut mengambil endpoint cluster untuk cluster. `mycluster`
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=mycluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Lihat informasi yang lebih lengkap di [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html).
# Menggunakan serpihan
Shard adalah kumpulan dari satu hingga 6 node. Anda dapat membuat cluster dengan jumlah pecahan yang lebih tinggi dan jumlah replika yang lebih rendah dengan total hingga 500 node per cluster. Konfigurasi cluster ini dapat berkisar dari 500 pecahan dan 0 replika hingga 100 pecahan dan 4 replika, yang merupakan jumlah maksimum replika yang diizinkan. Data klaster dipartisi di seluruh serpihan klaster. Jika ada lebih dari satu node dalam pecahan, shard mengimplementasikan replikasi dengan satu node menjadi node read/write utama dan node lainnya read-only replika node.
Saat Anda membuat cluster MemoryDB menggunakan Konsol Manajemen AWS, Anda menentukan jumlah pecahan di cluster dan jumlah node dalam pecahan. Untuk informasi selengkapnya, lihat [Membuat cluster MemoryDB](getting-started.md#clusters.create).
Setiap simpul dalam serpihan memiliki spesifikasi komputasi, penyimpanan, dan memori yang sama. MemoryDB API memungkinkan Anda mengontrol atribut seluruh cluster, seperti jumlah node, pengaturan keamanan, dan jendela pemeliharaan sistem.
Untuk informasi selengkapnya, lihat [Resharding offline untuk MemoryDB](cluster-resharding-offline.md) dan [Resharding online untuk MemoryDB](cluster-resharding-online.md).
## Menemukan nama pecahan
Anda dapat menemukan nama pecahan menggunakan API Konsol Manajemen AWS, AWS CLI atau MemoryDB.
### Menggunakan Konsol Manajemen AWS
Prosedur berikut menggunakan Konsol Manajemen AWS untuk menemukan nama pecahan cluster MemoryDB ini.
****
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 **Clusters**.
1. Pilih cluster di bawah **Nama yang nama** pecahan yang ingin Anda temukan.
1. **Di bawah tab **Pecahan dan node**, lihat daftar pecahan di bawah Nama.** Anda juga dapat memperluas masing-masing untuk melihat detail node mereka.
### Menggunakan AWS CLI
Untuk menemukan nama shard (shard) untuk cluster MemoryDB gunakan AWS CLI operasi `describe-clusters` dengan parameter opsional berikut.
+ **`--cluster-name`**—Parameter opsional yang bila digunakan membatasi output ke rincian cluster yang ditentukan. Jika parameter ini dihilangkan, detail hingga 100 cluster dikembalikan.
+ **`--show-shard-details`**—Mengembalikan detail pecahan, termasuk namanya.
Perintah ini akan menampilkan detail untuk `my-cluster`.
Untuk Linux, macOS, atau Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Untuk Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Ia mengembalikan respon JSON berikut:
Jeda baris ditambahkan agar dapat lebih mudah dibaca.
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
### Menggunakan MemoryDB API
Untuk menemukan id pecahan untuk cluster MemoryDB gunakan operasi API `DescribeClusters` dengan parameter opsional berikut.
+ **`ClusterName`**—Parameter opsional yang bila digunakan membatasi output ke rincian cluster yang ditentukan. Jika parameter ini dihilangkan, detail hingga 100 cluster dikembalikan.
+ **`ShowShardDetails`**—Mengembalikan detail pecahan, termasuk namanya.
**Example**
Perintah ini akan menampilkan detail untuk `my-cluster`.
Untuk Linux, macOS, atau Unix:
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=sample-cluster
&ShowShardDetails=true
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```