Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Gestion des clusters
La plupart des opérations MemoryDB sont effectuées au niveau du cluster. Vous pouvez définir un cluster de avec un nombre spécifique de nœuds de et un groupe de paramètres du qui contrôle les propriétés de chaque nœud de Tous les nœuds de au sein d'un cluster sont conçus pour avoir le même type de nœud et les mêmes paramètres et les mêmes configurations du groupe de sécurité.
Chaque cluster doit avoir un identifiant de cluster. L'identifiant de cluster est un nom fourni par le client pour le cluster. Cet identifiant spécifie un cluster particulier lors de l'interaction avec l'API et AWS CLI les commandes MemoryDB. L'identifiant du cluster doit être unique pour ce client dans une AWS région.
Les clusters MemoryDB sont conçus pour être accessibles via une instance Amazon EC2. Vous ne pouvez lancer votre cluster MemoryDB que dans un cloud privé virtuel (VPC) basé sur le service Amazon VPC, mais vous pouvez y accéder depuis l'extérieur. AWS Pour de plus amples informations, veuillez consulter [Accès aux ressources de MemoryDB depuis l'extérieur AWS](accessing-memorydb.md#access-from-outside-aws).
# Mise à niveau des données
Les clusters qui utilisent un type de nœud de la famille r6gd voient leurs données hiérarchisées entre la mémoire et le stockage SSD (Solid State Drive) local. La hiérarchisation des données offre une nouvelle option de rapport prix/performances pour les charges de travail Valkey et Redis OSS en utilisant des disques SSD (SSDs) à moindre coût dans chaque nœud du cluster, en plus du stockage des données en mémoire. Comme pour les autres types de nœuds, les données écrites sur les nœuds r6gd sont stockées de manière durable dans un journal des transactions multi-AZ. La hiérarchisation des données est parfaitement adaptée aux charges de travail qui accèdent régulièrement jusqu'à 20 % de leur jeu de données, et pour les applications qui peuvent tolérer une latence supplémentaire lors de l'accès aux données sur SSD.
Sur les clusters avec hiérarchisation des données, MemoryDB surveille l'heure du dernier accès de chaque élément stocké. Lorsque la mémoire disponible (DRAM) est entièrement consommée, MemoryDB utilise un algorithme utilisé le moins récemment (LRU) pour déplacer automatiquement les éléments rarement consultés de la mémoire vers le SSD. Lorsque les données du SSD sont ultérieurement consultées, MemoryDB les replace automatiquement et de manière asynchrone en mémoire avant de traiter la demande. Si votre charge de travail n’accède régulièrement qu’à un sous-ensemble de ses données, la hiérarchisation des données est un moyen optimal de mettre à l’échelle votre capacité de manière rentable.
Notez que lors de l'utilisation de la hiérarchisation des données, les clés elles-mêmes restent toujours en mémoire, tandis que le principe du moins récemment utilisé (LRU, Least Recently Used) régit le placement des valeurs en mémoire plutôt que sur le disque. En général, nous recommandons que la taille de vos clés soit inférieure à celle de vos valeurs lorsque vous utilisez la hiérarchisation des données.
La hiérarchisation des données est conçue pour avoir un impact minimal sur les performances des charges de travail des applications. Par exemple, en supposant des valeurs de chaîne de 500 octets, vous pouvez généralement vous attendre à 450 microsecondes de latence supplémentaires pour les demandes de lecture de données stockées sur un SSD par rapport aux demandes de lecture de données en mémoire.
Avec la plus grande taille de nœud de hiérarchisation des données (db.r6gd.8xlarge), vous pouvez en stocker jusqu'à 500 TBs dans un seul cluster de 500 nœuds (250 To avec une réplique en lecture). Pour la hiérarchisation des données, MemoryDB réserve 19 % de la mémoire (DRAM) par nœud à des fins autres que les données. La hiérarchisation des données est compatible avec toutes les commandes et structures de données Valkey et Redis OSS prises en charge dans MemoryDB. Vous n’avez besoin d’aucune modification côté client pour utiliser cette fonction.
**Topics**
+ [Bonnes pratiques](data-tiering-best-practices.md)
+ [Limites de hiérarchisation des données](data-tiering-prerequisites.md)
+ [Mise à niveau de tarification des données](data-tiering-pricing.md)
+ [Surveillance de la hiérarchisation des données](data-tiering-monitoring.md)
+ [Utilisation de la hiérarchisation des données](data-tiering-enabling.md)
+ [Restauration des données d'un instantané vers des clusters](data-tiering-enabling-snapshots.md)
# Bonnes pratiques
Nous recommandons les bonnes pratiques suivantes :
+ La hiérarchisation des données est parfaitement adaptée aux charges de travail qui accèdent régulièrement jusqu'à 20 % de leur jeu de données, et pour les applications qui peuvent tolérer une latence supplémentaire lors de l'accès aux données sur SSD.
+ Lors de l'utilisation de la capacité SSD disponible sur les nœuds hiérarchisés en fonction des données, nous recommandons que la taille de la valeur soit supérieure à celle de la clé. La taille de la valeur ne peut pas être supérieure à 128 Mo ; sinon, elle ne sera pas déplacée sur le disque. Lorsque des éléments sont déplacés entre DRAM et SSD, les clés restent toujours en mémoire et seules les valeurs sont déplacées vers le niveau SSD.
# Limites de hiérarchisation des données
La hiérarchisation des données présente les limitations suivantes :
+ Le type de nœud que vous utilisez doit appartenir à la famille r6gd, disponible dans les régions suivantes : `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`, `ca-central-1` et `sa-east-1`.
+ Vous ne pouvez pas restaurer un instantané d'un cluster r6gd dans un autre cluster à moins que celui-ci n'utilise également r6gd.
+ Vous ne pouvez pas exporter un instantané vers Amazon S3 pour les clusters de hiérarchisation des données.
+ L’enregistrement sans fonction fork n’est pas prise en charge.
+ La mise à l’échelle n’est pas prise en charge depuis un cluster de hiérarchisation de données (par exemple, un cluster utilisant un type de nœud r6gd) vers un cluster qui n’utilise pas la hiérarchisation des données (par exemple, un cluster utilisant un type de nœud r6g).
+ La hiérarchisation des données prend uniquement en charge les politiques de mémoire maximale `volatile-lru`, `allkeys-lru` et `noeviction`.
+ Les éléments de plus de 128 MiB ne sont pas déplacés vers le SSD.
# Mise à niveau de tarification des données
Les nœuds R6gd ont une capacité totale (mémoire\$1SSD) 5 fois supérieure et peuvent vous aider à réaliser des économies de stockage de plus de 60 % lorsqu'ils fonctionnent à une utilisation maximale par rapport aux nœuds R6g (mémoire uniquement). Pour plus d'informations, consultez la section Tarification de [MemoryDB.](https://aws.amazon.com/memorydb/pricing/)
# Surveillance de la hiérarchisation des données
MemoryDB propose des métriques conçues spécifiquement pour surveiller les clusters de performance qui utilisent la hiérarchisation des données. Pour surveiller le ratio entre les éléments en DRAM et en SSD, vous pouvez utiliser la `CurrItems` métrique à[Métriques pour MemoryDB](metrics.memorydb.md). Vous pouvez calculer le pourcentage comme suit :`(CurrItems with Dimension: Tier = Memory * 100) / (CurrItems with no dimension filter)`.
Si la politique d'expulsion configurée le permet, MemoryDB commencera à expulser des éléments lorsque le pourcentage d'éléments en mémoire sera inférieur à 5 %. Sur les nœuds configurés avec une politique de non-éviction, les opérations d'écriture recevront une erreur de mémoire insuffisante.
Il est tout de même recommandé de prendre en compte les [Dimensionnement des clusters MemoryDB](scaling-cluster.md) cas où le pourcentage d'éléments en mémoire tombe en dessous de 5 %. Pour plus d'informations, voir *Métriques pour les clusters MemoryDB qui utilisent la hiérarchisation des données* à. [Métriques pour MemoryDB](metrics.memorydb.md)
# Utilisation de la hiérarchisation des données
## Utilisation de la hiérarchisation des données à l'aide du AWS Management Console
*Lorsque vous créez un cluster, vous utilisez la hiérarchisation des données en sélectionnant un type de nœud de la famille r6gd, tel que db.r6gd.xlarge.* La sélection de ce type de nœud active automatiquement la hiérarchisation des données.
Pour plus d'informations sur la création des clusters , consultez [Étape 2 : Créer un cluster](getting-started.md#getting-started.createcluster).
## Activation de la hiérarchisation des données à l'aide du AWS CLI
Lorsque vous créez un cluster à l'aide de AWS CLI, vous utilisez la hiérarchisation des données en sélectionnant un type de nœud de la famille r6gd, tel que *db.r6gd.xlarge, et en définissant le paramètre*. `--data-tiering`
Vous ne pouvez pas désactiver la hiérarchisation des données lorsque vous sélectionnez un type de nœud dans la famille r6gd. Si vous définissez le paramètre `--no-data-tiering`, l’opération échouera.
Pour Linux, macOS ou 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
```
Pour 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
```
Après avoir exécuté cette opération, une réponse similaire à ceci s’affiche :
```
{
"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
}
}
```
# Restauration des données d'un instantané vers des clusters
Vous pouvez restaurer un instantané sur un nouveau cluster avec la hiérarchisation des données activée à l'aide de la (console), (AWS CLI) ou (API MemoryDB). Lorsque vous créez un cluster à l’aide de types de nœuds de la famille r6gd, la hiérarchisation des données est activée.
## Restauration des données d'un instantané vers des clusters avec la hiérarchisation des données activée (console)
Pour restaurer un instantané sur un nouveau cluster avec la hiérarchisation des données activée (console), suivez les étapes décrites dans [Restauration à partir d'un instantané (console)](snapshots-restoring.md#snapshots-restoring-CON)
Notez que pour activer la hiérarchisation des données, vous devez sélectionner un type de nœud de la famille r6gd.
## Restauration des données d'un instantané dans des clusters avec la hiérarchisation des données activée (AWS CLI)
Lors de la création d'un cluster à l'aide de AWS CLI, la hiérarchisation des données est utilisée par défaut en sélectionnant un type de nœud de la famille r6gd, tel que *db.r6gd.xlarge, et en définissant le paramètre*. `--data-tiering`
Vous ne pouvez pas désactiver la hiérarchisation des données lorsque vous sélectionnez un type de nœud dans la famille r6gd. Si vous définissez le paramètre `--no-data-tiering`, l’opération échouera.
Pour Linux, macOS ou 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
```
Pour 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
```
Après avoir exécuté cette opération, une réponse similaire à ceci s’affiche :
```
{
"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"
}
```
# Préparation d'un cluster
Vous trouverez ci-dessous des instructions sur la création d'un cluster à l'aide de la console MemoryDB, de l'API MemoryDB ou de l' AWS CLI API MemoryDB.
Chaque fois que vous créez un cluster, il est conseillé d'effectuer des travaux préparatoires afin de ne pas avoir à le mettre à niveau ou à apporter des modifications immédiatement.
**Topics**
+ [Déterminer les exigences](cluster-create-determine-requirements.md)
# Déterminer les exigences
**Préparation**
Connaître les réponses aux questions suivantes permet d'accélérer la création de votre cluster :
+ Assurez-vous de créer un groupe de sous-réseaux dans le même VPC avant de commencer à créer un cluster. Vous pouvez également utiliser le groupe de sous-réseaux par défaut fourni. Pour de plus amples informations, veuillez consulter [Sous-réseaux et groupes de sous-réseaux](subnetgroups.md).
MemoryDB est conçu pour être accessible de l'intérieur à AWS l'aide d'Amazon EC2. Toutefois, si vous lancez un VPC basé sur Amazon VPC, vous pouvez fournir un accès depuis l'extérieur. AWS Pour de plus amples informations, veuillez consulter [Accès aux ressources de MemoryDB depuis l'extérieur AWS](accessing-memorydb.md#access-from-outside-aws).
+ Avez-vous besoin de personnaliser les valeurs des paramètres ?
Si vous le faites, créez un groupe de paramètres personnalisé. Pour de plus amples informations, veuillez consulter [Création d'un groupe de paramètres](parametergroups.creating.md).
+ Devez-vous créer un groupe de sécurité VPC ?
Pour plus d’informations, consultez [Sécurité au sein de votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Comment avez-vous l'intention de mettre en œuvre la tolérance aux pannes ?
Pour de plus amples informations, veuillez consulter [Atténuation des défaillances](faulttolerance.md).
**Topics**
+ [Exigences relatives à la mémoire et au processeur](#cluster-create-determine-requirements-memory)
+ [Configuration du cluster MemoryDB](#cluster-configuration)
+ [I/O Multiplexage amélioré](#cluster-create-determine-requirements-multiplexing)
+ [Exigences relatives au dimensionnement](#cluster-create-determine-requirements-scaling)
+ [Exigences relatives à l'accès](#cluster-create-determine-requirements-access)
+ [Région et zones de disponibilité](#cluster-create-determine-requirements-region)
## Exigences relatives à la mémoire et au processeur
L'élément de base de MemoryDB est le nœud. Les nœuds sont configurés en fragments pour former des clusters. En déterminant le type de nœud à utiliser pour votre cluster, tenez compte de la configuration de nœud du cluster et de la quantité de données à stocker.
## Configuration du cluster MemoryDB
Les clusters MemoryDB sont composés de 1 à 500 partitions. Les données d'un cluster MemoryDB sont partitionnées entre les partitions du cluster. Votre application se connecte à un cluster MemoryDB à l'aide d'une adresse réseau appelée Endpoint. *Outre les points de terminaison du nœud, le cluster MemoryDB lui-même possède un point de terminaison appelé point de terminaison du cluster.* Votre application peut utiliser ce point de terminaison pour lire ou écrire dans le cluster, laissant à MemoryDB le soin de déterminer le nœud à partir duquel lire ou écrire.
## I/O Multiplexage amélioré
Si vous utilisez Valkey ou Redis OSS version 7.0 ou ultérieure, vous bénéficierez d'une accélération supplémentaire grâce au I/O multiplexage amélioré, dans le cadre duquel chaque thread d'E/S réseau dédié achemine les commandes de plusieurs clients vers le moteur, en tirant parti de la capacité à traiter efficacement les commandes par lots. Pour plus d'informations, voir [Performances ultrarapides](https://aws.amazon.com/memorydb/features/#Ultra-fast_performance) et[Types de nœuds pris en charge](nodes.supportedtypes.md).
## Exigences relatives au dimensionnement
Tous les clusters peuvent être étendus à un type de nœud plus grand. Lorsque vous augmentez la taille d'un cluster MemoryDB, vous pouvez le faire en ligne pour qu'il reste disponible ou vous pouvez créer un nouveau cluster à partir d'un instantané et éviter que le nouveau cluster ne démarre à vide.
Pour plus d’informations, consultez [Mise à l’échelle](scaling.md) dans ce guide.
## Exigences relatives à l'accès
De par leur conception, les clusters MemoryDB sont accessibles à partir d'instances Amazon EC2. L'accès réseau à un cluster MemoryDB est limité au compte qui a créé le cluster. Par conséquent, avant de pouvoir accéder à un cluster depuis une instance Amazon EC2, vous devez autoriser l'accès au cluster. Pour plus d'informations, consultez [Étape 4 : Autoriser l'accès au cluster](getting-started.md#getting-started.authorizeaccess) dans ce manuel.
## Région et zones de disponibilité
En localisant vos clusters MemoryDB dans une AWS région proche de votre application, vous pouvez réduire la latence. Si votre cluster dispose de plusieurs nœuds, la localisation de vos nœuds dans différentes zones de disponibilité peut réduire l'impact des échecs sur votre cluster.
Pour plus d’informations, consultez les ressources suivantes :
+ [Choix des régions et zones de disponibilité](regionsandazs.md)
+ [Atténuation des défaillances](faulttolerance.md)
# Création d’un cluster
MemoryDB propose trois méthodes pour créer un cluster. Pour de plus amples informations, veuillez consulter [Étape 2 : Créer un cluster](getting-started.md#getting-started.createcluster).
# Affichage des détails d'un cluster
Vous pouvez afficher des informations détaillées sur un ou plusieurs clusters à l'aide de la console MemoryDB ou de l'API AWS CLI MemoryDB.
## Affichage des détails d'un cluster MemoryDB (console)
La procédure suivante explique comment afficher les détails d'un cluster MemoryDB à l'aide de la console MemoryDB.
****
1. Connectez-vous à la console MemoryDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Pour voir les détails d'un cluster, cliquez sur le bouton radio situé à gauche du nom du cluster, puis choisissez **Afficher les détails**. Vous pouvez également cliquer directement sur le cluster pour afficher la page de détails du cluster.
La page des **détails du cluster** affiche des informations sur le cluster, y compris le point de terminaison du cluster. Vous pouvez afficher plus de détails à l'aide des multiples onglets disponibles sur la page des **détails du cluster**.
1. Cliquez sur l'onglet **Shards and nodes** pour voir la liste des partitions du cluster et le nombre de nœuds dans chaque partition.
1. Pour afficher des informations spécifiques sur un nœud, développez le fragment dans le tableau ci-dessous. Vous pouvez également rechercher le fragment à l'aide du champ de recherche.
Cela permet d'afficher des informations sur chaque nœud, y compris sa zone de disponibilité slots/keyspaces et son statut.
1. Choisissez l'onglet **Metrics** pour surveiller leurs processus respectifs, tels que **l'utilisation du processeur et l'utilisation** **du processeur du moteur**. Pour de plus amples informations, veuillez consulter [Métriques pour MemoryDB](metrics.memorydb.md).
1. Choisissez l'onglet **Réseau et sécurité** pour voir les détails du groupe de sous-réseaux et des groupes de sécurité.
1. Dans le **groupe de sous-réseaux**, vous pouvez voir le nom du groupe de sous-réseaux, un lien vers le VPC auquel appartient le sous-réseau et le nom de ressource Amazon (ARN) du groupe de sous-réseaux.
1. Dans **Groupes de sécurité**, vous pouvez voir l'ID, le nom et la description du groupe de sécurité.
1. Choisissez l'onglet **Maintenance et capture** d'écran pour voir les détails des paramètres de capture d'écran.
1. Dans **Snapshot**, vous pouvez voir si les instantanés automatisés sont activés, quelle est la période de conservation des instantanés et quelle est la fenêtre des instantanés.
1. Dans **Snapshots**, vous verrez une liste de tous les instantanés de ce cluster, y compris le nom, la taille, le nombre de partitions et le statut de l'instantané.
Pour de plus amples informations, veuillez consulter [Instantané et restauration](snapshots.md).
1. Choisissez l'onglet **Maintenance et capture instantanée** pour voir les détails de la fenêtre de maintenance, ainsi que les mises à jour de l'ACL, du repartage ou du service en attente. Pour de plus amples informations, veuillez consulter [Gestion de la maintenance](maintenance-window.md).
1. Choisissez l'onglet **Mises à jour de service** pour voir les détails des mises à jour de service applicables à ce cluster. Pour de plus amples informations, veuillez consulter [Mises à jour du service dans MemoryDB](service-updates.md).
1. Cliquez sur l'onglet **Balises** pour voir les détails des balises de ressources ou de répartition des coûts associées à ce cluster. Pour de plus amples informations, veuillez consulter [Marquage des instantanés](snapshots-tagging.md).
## Afficher les détails d'un cluster (AWS CLI)
Vous pouvez afficher les détails d'un cluster à l'aide de la AWS CLI `describe-clusters` commande. Si le paramètre `--cluster-name` n'est pas spécifié, les détails de plusieurs clusters jusqu'à `--max-results`, sont retournés. Si le paramètre `--cluster-name` est inclus, les détails du cluster spécifié sont retournés. Vous pouvez limiter le nombre d'enregistrements renvoyés avec le paramètre `--max-results`.
Le code suivant répertorie les détails de `my-cluster`.
```
aws memorydb describe-clusters --cluster-name my-cluster
```
Le code suivant affiche les détails de 25 clusters maximum.
```
aws memorydb describe-clusters --max-results 25
```
**Example**
Pour Linux, macOS ou Unix :
```
aws memorydb describe-clusters \
--cluster-name my-cluster \
--show-shard-details
```
Pour Windows :
```
aws memorydb describe-clusters ^
--cluster-name my-cluster ^
--show-shard-details
```
La sortie JSON suivante montre la réponse :
```
{
"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,
}
```
Pour plus d'informations, consultez la rubrique dédiée AWS CLI à 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)
## Afficher les détails d'un cluster (API MemoryDB)
Vous pouvez afficher les détails d'un cluster à l'aide de l'action d'API `DescribeClusters` MemoryDB. Si le paramètre `ClusterName` est inclus, les détails du cluster spécifié sont retournés. Si le paramètre `ClusterName` n'est pas spécifié, les détails de `MaxResults` clusters maximum (100 par défaut) sont retournés. La valeur de `MaxResults` ne peut pas être inférieure à 20 ou supérieure à 100.
Le code suivant répertorie les détails de `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=
```
Le code suivant affiche les détails de 25 clusters maximum.
```
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=
```
Pour plus d'informations, consultez la rubrique de référence de l'API MemoryDB. [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html)
# Modification d'un cluster MemoryDB
Outre l'ajout ou la suppression de nœuds dans un cluster, il peut arriver que vous deviez apporter d'autres modifications à un cluster existant, par exemple en ajoutant un groupe de sécurité, en modifiant la fenêtre de maintenance ou un groupe de paramètres.
Nous vous conseillons que votre créneau de maintenance soit défini au moment où l'utilisation est la plus faible. Donc une modification peut s'avérer nécessaire de temps en temps.
Lorsque vous modifiez les paramètres d'un cluster, les modifications sont immédiatement appliquées au cluster. Cela est vrai que vous modifiiez le groupe de paramètres du cluster lui-même ou une valeur de paramètre au sein du groupe de paramètres du cluster.
Vous pouvez également mettre à jour la version du moteur de vos clusters. Par exemple, vous pouvez sélectionner une nouvelle version mineure du moteur et MemoryDB commencera immédiatement à mettre à jour votre cluster.
## En utilisant le AWS Management Console
**Pour modifier un cluster**
1. Connectez-vous à la console MemoryDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dans la liste située dans le coin supérieur droit, choisissez la AWS région dans laquelle se trouve le cluster que vous souhaitez modifier.
1. Dans le menu de navigation de gauche, accédez à **Clusters**. Dans **Détails des clusters**, sélectionnez le cluster à l'aide du bouton radio et accédez à **Actions** puis à **Modifier**.
1. La page **Modifier** apparaît.
1. Dans la fenêtre **Modifier**, apportez les modifications souhaitées. Voici les options :
+ Description
+ Groupes de sous-réseaux
+ Groupes de sécurité VPC
+ Type de nœud
**Note**
Si le cluster utilise un type de nœud de la famille r6gd, vous ne pouvez choisir qu’une taille de nœud différente de celle de cette famille. Si vous choisissez un type de nœud de la famille r6gd, la hiérarchisation des données sera automatiquement activée. Pour de plus amples informations, veuillez consulter [Mise à niveau des données](data-tiering.md).
+ Compatibilité des versions Valkey ou Redis OSS
+ Activer les instantanés automatiques
+ Période de conservation des instantanés
+ Fenêtre de capture instantanée
+ Fenêtre de maintenance
+ Rubrique relative aux notifications SNS
1. Sélectionnez **Enregistrer les modifications**.
Vous pouvez également accéder à la page des **détails du cluster** et cliquer sur **Modifier** pour apporter des modifications au cluster. Si vous souhaitez modifier des sections spécifiques du cluster, vous pouvez accéder à l'onglet correspondant de la page des **détails du cluster** et cliquer sur **Modifier**.
## En utilisant le AWS CLI
Vous pouvez modifier un cluster existant à l'aide de cette AWS CLI `update-cluster` opération. Pour modifier la valeur de configuration d'un cluster, spécifiez l'ID du cluster, le paramètre à modifier et la nouvelle valeur du paramètre. L'exemple suivant change le créneau de maintenance pour un cluster nommé `my-cluster` et applique la modification immédiatement.
Pour Linux, macOS ou Unix :
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Pour Windows :
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Pour plus d'informations, consultez [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) dans la référence des AWS CLI commandes.
## Utilisation de l'API MemoryDB
Vous pouvez modifier un cluster existant à l'aide de l'opération d'API [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)MemoryDB. Pour modifier la valeur de configuration d'un cluster, spécifiez l'ID du cluster, le paramètre à modifier et la nouvelle valeur du paramètre. L'exemple suivant change le créneau de maintenance pour un cluster nommé `my-cluster` et applique la modification immédiatement.
```
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=
```
## Comment déclencher une mise à niveau entre moteurs de Redis OSS vers Valkey
Vous pouvez mettre à niveau un cluster Redis OSS existant vers le moteur Valkey à l'aide de la console, de l'API ou de la CLI.
Si vous avez un cluster Redis OSS existant qui utilise le groupe de paramètres par défaut, vous pouvez passer à Valkey en spécifiant le nouveau moteur et la nouvelle version du moteur avec l'API update-cluster.
Pour Linux, macOS ou Unix :
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2
```
Pour Windows :
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2
```
Si un groupe de paramètres personnalisé est appliqué au cluster Redis OSS existant que vous souhaitez mettre à niveau, vous devrez également transmettre un groupe de paramètres Valkey personnalisé dans la demande. Le groupe de paramètres personnalisés Valkey en entrée doit avoir les mêmes valeurs de paramètres statiques Redis OSS que le groupe de paramètres personnalisés Redis OSS existant.
Pour Linux, macOS ou Unix :
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2 \
--parameter-group-name myParamGroup
```
Pour Windows :
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2 ^
--parameter-group-name myParamGroup
```
# Ajouter/supprimer des nœuds d'un cluster
Vous pouvez ajouter ou supprimer des nœuds d'un cluster à l'aide de l'API AWS Management Console, de AWS CLI, ou de l'API MemoryDB.
## En utilisant le AWS Management Console
****
1. Connectez-vous à la console MemoryDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dans la liste des clusters, choisissez le nom du cluster auquel vous souhaitez ajouter ou supprimer un nœud.
1. Dans l'onglet **Shards and nodes**, sélectionnez **Add/Delete** nodes
1. Dans **Nouveau nombre de nœuds**, entrez le nombre de nœuds souhaité.
1. Choisissez **Confirmer**.
**Important**
Si vous définissez le nombre de nœuds sur 1, le mode multi-AZ ne sera plus activé. Vous pouvez également choisir d'activer le **basculement automatique**.
## En utilisant le AWS CLI
1. Identifiez les noms des nœuds que vous souhaitez supprimer. Pour de plus amples informations, veuillez consulter [Affichage des détails d'un cluster](clusters.viewdetails.md).
1. Utilisez l'opération `update-cluster` de la CLI avec une liste des nœuds à supprimer, comme dans l'exemple suivant.
Pour supprimer des nœuds d'un cluster à l'aide de l'interface de ligne de commande, utilisez la commande `update-cluster` avec les paramètres suivants :
+ `--cluster-name`ID du cluster dont vous souhaitez supprimer des nœuds.
+ `--replica-configuration`— Permet de définir le nombre de répliques :
+ `ReplicaCount`— Définissez cette propriété pour spécifier le nombre de nœuds de réplication souhaités.
+ `--region`Spécifie la AWS région du cluster dont vous souhaitez supprimer des nœuds.
Pour Linux, macOS ou Unix :
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--replica-configuration \
ReplicaCount=1 \
--region us-east-1
```
Pour Windows :
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--replica-configuration ^
ReplicaCount=1 ^
--region us-east-1
```
Pour plus d'informations, consultez les AWS CLI rubriques [https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Utilisation de l'API MemoryDB
Pour supprimer des nœuds à l'aide de l'API MemoryDB, appelez l'opération d'`UpdateCluster`API avec le nom du cluster et une liste des nœuds à supprimer, comme indiqué :
+ `ClusterName`ID du cluster dont vous souhaitez supprimer des nœuds.
+ `ReplicaConfiguration`— Permet de définir le nombre de répliques :
+ `ReplicaCount`— Définissez cette propriété pour spécifier le nombre de nœuds de réplication souhaités.
+ `Region`Spécifie la AWS région du cluster dont vous souhaitez supprimer un nœud.
Pour de plus amples informations, veuillez consulter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Accès à votre cluster
Vos instances MemoryDB sont conçues pour être accessibles via une instance Amazon EC2 .
Vous pouvez accéder à votre nœud MemoryDB depuis une EC2 instance Amazon dans le même Amazon VPC. Ou, en utilisant le peering VPC, vous pouvez accéder à votre nœud MemoryDB depuis un Amazon dans un EC2 autre Amazon VPC.
**Topics**
+ [Accordez l'accès à votre cluster](#grant-access)
+ [Accès aux ressources de MemoryDB depuis l'extérieur AWS](#access-from-outside-aws)
## Accordez l'accès à votre cluster
Vous ne pouvez vous connecter à votre cluster MemoryDB qu'à partir d'une EC2 instance Amazon exécutée dans le même Amazon VPC. Dans ce cas, vous devez accorder l'accès au réseau au cluster.
**Pour accorder l'accès réseau à un cluster, à partir d'un groupe de sécurité Amazon VPC**
1. Connectez-vous à la EC2 console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le volet de navigation de gauche, sous **Réseau et sécurité**, choisissez **Security Groups**.
1. Dans la liste des groupes de sécurité, choisissez le groupe de sécurité de votre Amazon VPC. *À moins que vous n'ayez créé un groupe de sécurité pour l'utilisation de MemoryDB, ce groupe de sécurité sera nommé par défaut.*
1. Choisissez l'onglet **Entrant** et effectuez les opérations suivantes :
1. Choisissez **Edit** (Modifier).
1. Choisissez **Ajouter une règle**.
1. Dans la colonne **Type**, choisissez **Règle TCP personnalisée**.
1. Dans la zone **Port range**, tapez le numéro de port de votre nœud de cluster de Ce numéro doit être le même que celui que vous avez spécifié lorsque vous avez lancé le cluster. Le port par défaut pour Valkey et Redis OSS est. **6379**
1. Dans le champ **Source**, choisissez **Anywhere** dont la plage de ports est comprise (0.0.0.0/0) afin que toute EC2 instance Amazon que vous lancez au sein de votre Amazon VPC puisse se connecter à vos nœuds MemoryDB.
**Important**
L'ouverture du cluster MemoryDB à 0.0.0.0/0 n'expose pas le cluster à Internet car il ne possède aucune adresse IP publique et n'est donc pas accessible depuis l'extérieur du VPC. Cependant, le groupe de sécurité par défaut peut être appliqué à d'autres EC2 instances Amazon du compte du client, et ces instances peuvent avoir une adresse IP publique. Si ces instances exécutent un service sur le port par défaut, ce service peut être exposé accidentellement. Par conséquent, nous vous recommandons de créer un groupe de sécurité VPC qui sera utilisé exclusivement par MemoryDB. Pour plus d'informations, consultez [Groupes de sécurité personnalisés](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Choisissez **Enregistrer**.
Lorsque vous lancez une EC2 instance Amazon dans votre Amazon VPC, cette instance pourra se connecter à votre cluster MemoryDB.
## Accès aux ressources de MemoryDB depuis l'extérieur AWS
MemoryDB est un service conçu pour être utilisé en interne dans votre VPC. L'accès externe est déconseillé en raison de la latence du trafic Internet et des problèmes de sécurité. Toutefois, si un accès externe à MemoryDB est requis à des fins de test ou de développement, il peut être effectué via un VPN.
À l'aide du AWS Client VPN, vous autorisez l'accès externe à vos nœuds MemoryDB avec les avantages suivants :
+ Accès restreint aux utilisateurs approuvés ou aux clés d'authentification
+ Trafic crypté entre le client VPN et le point de terminaison AWS VPN ;
+ Accès limité à certains sous-réseaux ou nœuds
+ Révocation facile de l'accès d'utilisateurs ou de clés d'authentification
+ Audit des connexions
Les procédures suivantes montrent comment :
**Topics**
+ [Création d'une autorité de certification](#create-cert)
+ [Configuration des composants VPN du AWS client](#configure-vpn-components)
+ [Configuration du client VPN](#configure-vpn-client)
### Création d'une autorité de certification
Il est possible de créer une autorité de certification (CA) en utilisant différents outils ou techniques. Nous suggérons d'utiliser l'utilitaire easy-rsa, fourni par le projet [OpenVPN](https://openvpn.net/community-resources/openvpn-project/). Quelle que soit l'option que vous choisissez, assurez-vous de garder les clés en sécurité. La procédure suivante télécharge les scripts easy-rsa, puis crée l'autorité de certification et les clés pour authentifier le premier client VPN :
+ Pour créer les certificats initiaux, ouvrez un terminal et procédez comme suit :
+ `git clone`[https://github.com/OpenVPN/easy-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`
Un sous-répertoire **pki** contenant les certificats sera créé sous **easy-rsa**.
+ Soumettez le certificat du serveur au gestionnaire de AWS certificats (ACM) :
+ Dans la console ACM, sélectionnez **Certificate Manager**.
+ Sélectionnez **Import Certificate (Importer un certificat)**.
+ Entrez le certificat de clé publique disponible dans le fichier `easy-rsa/pki/issued/server.crt` dans le champ **Corps du certificat**.
+ Collez la clé privée disponible dans `easy-rsa/pki/private/server.key` dans le champ **Clé privée du certificat**. Assurez-vous de sélectionner toutes les lignes entre `BEGIN AND END PRIVATE KEY` (y compris les lignes `BEGIN` et `END`).
+ Collez la clé publique de l'autorité de certification disponible dans le fichier `easy-rsa/pki/ca.crt` dans le champ **Chaîne de certificats**.
+ Sélectionnez **Vérifier et importer**.
+ Sélectionnez **Importer**.
Pour envoyer les certificats du serveur à ACM à l'aide de la AWS CLI, exécutez la commande suivante : `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`
Notez l'ARN du certificat pour un usage futur.
### Configuration des composants VPN du AWS client
**Utilisation de la AWS console**
Sur la AWS console, sélectionnez **Services**, puis **VPC**.
Sous **Virtual Private Network (Réseau privé virtuel)**, sélectionnez **Client VPN Endpoints (Points de terminaison VPN client)** et procédez comme suit :
**Configuration des composants VPN du AWS Client**
+ Sélectionnez **Create Client VPN Endpoint (Créer un point de terminaison VPN client)**.
+ Spécifiez les options suivantes :
+ ** IPv4 CIDR client** : utilisez un réseau privé avec un masque de réseau d'au moins la plage /22. Assurez-vous que le sous-réseau sélectionné n'est pas en conflit avec les adresses des réseaux VPC. Exemple : 10.0.0.0/22.
+ Dans **Server certificate ARN (ARN du certificat de serveur)**, sélectionnez l'ARN du certificat que vous venez d'importer.
+ Sélectionnez **Use mutual authentication (Utiliser l'authentification mutuelle)**.
+ Dans **Client certificate ARN (ARN du certificat de client)**, sélectionnez l'ARN du certificat que vous venez d'importer.
+ Sélectionnez **Create Client VPN Endpoint (Créer un point de terminaison VPN client)**.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`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 `
Exemple de sortie :
`"ClientVpnEndpointId": "cvpn-endpoint-0123456789abcdefg", "Status": { "Code": "pending-associate" }, "DnsName": "cvpn-endpoint-0123456789abcdefg.prod.clientvpn.us-east-1.amazonaws.com" } `
**Association des réseaux cibles au point de terminaison VPN**
+ Sélectionnez le nouveau point de terminaison VPN, puis sélectionnez l'onglet **Associations**.
+ Sélectionnez **Associate (Associer)**, puis spécifiez les options suivantes.
+ **VPC** : sélectionnez le VPC du cluster MemoryDB.
+ Sélectionnez l'un des réseaux du cluster MemoryDB. En cas de doute, passez en revue les réseaux dans les **groupes de sous-réseaux** du tableau de bord MemoryDB.
+ Sélectionnez **Associate (Associer)**. Si nécessaire, répétez les étapes pour les réseaux restants.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`aws ec2 associate-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --subnet-id subnet-0123456789abdcdef`
Exemple de sortie :
`"Status": { "Code": "associating" }, "AssociationId": "cvpn-assoc-0123456789abdcdef" } `
**Examen du groupe de sécurité VPN**
Le point de terminaison VPN adopte automatiquement le groupe de sécurité par défaut du VPC. Vérifiez les règles entrantes et sortantes et confirmez si le groupe de sécurité autorise le trafic du réseau VPN (défini dans les paramètres du point de terminaison VPN) vers les réseaux MemoryDB sur les ports de service (par défaut, 6379 pour Redis).
Si vous devez modifier le groupe de sécurité affecté au point de terminaison VPN, procédez comme suit :
+ Sélectionnez le groupe de sécurité en cours.
+ Sélectionnez **Apply Security Group (Appliquer le groupe de sécurité)**.
+ Sélectionnez le nouveau groupe de sécurité.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`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`
Exemple de sortie :
`"SecurityGroupIds": [ "sg-0123456789abdcdef" ] } `
**Note**
Le groupe de sécurité MemoryDB doit également autoriser le trafic provenant des clients VPN. Les adresses des clients sont masquées avec l'adresse du point de terminaison VPN, selon le réseau VPC. Par conséquent, considérez le réseau VPC (et non le réseau des clients VPN) lors de la création de la règle entrante sur le groupe de sécurité MemoryDB.
**Autorisation de l'accès VPN aux réseaux de destination**
Dans l'onglet **Authorization (Autorisation)**, sélectionnez **Authorize Ingress (Autoriser l'entrée)** et spécifiez les éléments suivants :
+ Réseau de destination pour activer l'accès : utilisez 0.0.0.0/0 pour autoriser l'accès à n'importe quel réseau (y compris Internet) ou limitez les réseaux/hôtes MemoryDB.
+ Sous **Grant access to: (Accorder l'accès à :)**, sélectionnez **Allow access to all users (Autoriser l'accès à tous les utilisateurs)**.
+ Sélectionnez **Add Authorization Rules (Ajouter des règles d'autorisation)**.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`aws ec2 authorize-client-vpn-ingress --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --target-network-cidr 0.0.0.0/0 --authorize-all-groups`
Exemple de sortie :
`{ "Status": { "Code": "authorizing" } }`
**Autorisation de l'accès à Internet à partir des clients VPN**
Si vous avez besoin de naviguer sur Internet via le VPN, vous devez créer un routage supplémentaire. Sélectionnez l'onglet **Route Table (Table de routage)**, puis sélectionnez **Create Route (Créer un routage)** :
+ Destination du routage : 0.0.0.0/0
+ **Target VPC Subnet ID (ID de sous-réseau du VPC cible)** : sélectionnez l'un des sous-réseaux associés ayant accès à Internet.
+ Sélectionnez **Create Route (Créer un routage)**.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`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`
Exemple de sortie :
`{ "Status": { "Code": "creating" } } `
### Configuration du client VPN
Sur le tableau de bord du AWS client VPN, sélectionnez le point de terminaison VPN récemment créé et sélectionnez **Télécharger la configuration du client**. Copiez le fichier de configuration, puis les fichiers `easy-rsa/pki/issued/client1.domain.tld.crt` et `easy-rsa/pki/private/client1.domain.tld.key`. Modifiez le fichier de configuration et modifiez ou ajoutez les paramètres suivants :
+ cert : ajoutez une nouvelle ligne avec le paramètre cert pointant vers le fichier `client1.domain.tld.crt`. Utilisez le chemin complet du fichier. Exemple : `cert /home/user/.cert/client1.domain.tld.crt`
+ key : ajoutez une nouvelle ligne avec le paramètre key pointant vers le fichier `client1.domain.tld.key`. Utilisez le chemin complet du fichier. Exemple : `key /home/user/.cert/client1.domain.tld.key`
Établissez la connexion VPN à l'aide de la commande : `sudo openvpn --config downloaded-client-config.ovpn`
**Révocation de l'accès**
Si vous devez invalider l'accès à partir d'une clé client particulière, la clé doit être révoquée dans l'autorité de certification. Soumettez ensuite la liste de révocation au AWS Client VPN.
Révocation de la clé avec easy-rsa :
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa revoke client1.domain.tld`
+ Entrez « yes » pour continuer, ou toute autre entrée pour abandonner.
`Continue with revocation: `yes` ... * `./easyrsa3/easyrsa gen-crl`
+ Une liste de révocation de certificats (CRL) à jour a été créée. Fichier CRL : `/home/user/easy-rsa/pki/crl.pem`
Importation de la liste de révocation dans le VPN du AWS Client :
+ Sur le AWS Management Console, sélectionnez **Services**, puis **VPC**.
+ Sélectionnez **Client VPN Endpoints (Points de terminaison VPN client)**.
+ Sélectionnez le point de terminaison VPN client, puis sélectionnez **Actions** -> **Import Client Certificate CRL (Importer une liste de révocation des certificats de client)**.
+ Collez le contenu du fichier `crl.pem`.
**En utilisant le AWS CLI**
Exécutez la commande suivante :
`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 `
Exemple de sortie :
`Example output: { "Return": true } `
# Recherche de points de terminaison de connexion
Votre application se connecte à votre cluster à l'aide du point de terminaison. Un point de terminaison est l'adresse unique d'un cluster. Utilisez le point de *terminaison du cluster* pour toutes les opérations.
Les sections suivantes vous aideront à découvrir le point de terminaison dont vous aurez besoin.
## Trouver le point de terminaison d'un cluster MemoryDB ()AWS Management Console
**Pour trouver le point de terminaison d'un cluster MemoryDB**
1. Connectez-vous à la console MemoryDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dans le panneau de navigation, choisissez **Clusters**.
L'écran des clusters apparaîtra avec une liste de clusters. Choisissez le cluster auquel vous souhaitez vous connecter.
1. Pour trouver le point de terminaison du cluster, choisissez le nom du cluster (et non le bouton radio).
1. Le point de **terminaison du cluster** s'affiche sous **Détails du cluster**. Pour le copier, choisissez l'icône de *copie* à gauche du point de terminaison.
## Trouver le point de terminaison d'un cluster MemoryDB (CLI)AWS
Vous pouvez utiliser la `describe-clusters` commande pour découvrir le point de terminaison d'un cluster. La commande renvoie le point de terminaison du cluster.
L'opération suivante récupère le point de terminaison, représenté dans cet exemple par un*sample*, pour le cluster`mycluster`.
Elle renvoie la réponse JSON suivante :
```
aws memorydb describe-clusters \
--cluster-name mycluster
```
Pour 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
}
]
}
```
Pour plus d'informations, consultez [describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html).
## Trouver le point de terminaison d'un cluster MemoryDB (API MemoryDB)
Vous pouvez utiliser l'API MemoryDB pour découvrir le point de terminaison d'un cluster.
### Trouver le point de terminaison d'un cluster MemoryDB (API MemoryDB)
Vous pouvez utiliser l'API MemoryDB pour découvrir le point de terminaison d'un cluster avec l'`DescribeClusters`action. L'action renvoie le point de terminaison du cluster.
L'opération suivante permet de récupérer le point de terminaison du 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=
```
Pour de plus amples informations, veuillez consulter [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html).
# Utilisation de partitions
Un shard est un ensemble de 1 à 6 nœuds. Vous pouvez créer un cluster avec un plus grand nombre de partitions et un nombre inférieur de répliques, pour un total de 500 nœuds par cluster. Cette configuration de cluster peut aller de 500 partitions et 0 répliques à 100 partitions et 4 répliques, soit le nombre maximum de répliques autorisées. Les données du cluster sont partitionnées entre les partitions du cluster. S'il existe plusieurs nœuds dans une partition, la partition implémente la réplication, l'un des nœuds étant le nœud read/write principal et les autres nœuds étant des nœuds de réplication en lecture seule.
Lorsque vous créez un cluster MemoryDB à l'aide de AWS Management Console, vous spécifiez le nombre de partitions dans le cluster et le nombre de nœuds dans les partitions. Pour de plus amples informations, veuillez consulter [Création d'un cluster MemoryDB](getting-started.md#clusters.create).
Chaque nœud de partition possède les mêmes spécifications de calcul, de stockage et de mémoire. L'API MemoryDB vous permet de contrôler les attributs à l'échelle du cluster, tels que le nombre de nœuds, les paramètres de sécurité et les fenêtres de maintenance du système.
Pour plus d’informations, consultez [Repartage hors ligne pour MemoryDB](cluster-resharding-offline.md) et [Repartage en ligne pour MemoryDB](cluster-resharding-online.md).
## Trouver le nom d'un fragment
Vous pouvez trouver le nom d'une partition à l'aide de l'API AWS Management Console, de AWS CLI ou de MemoryDB.
### En utilisant le AWS Management Console
La procédure suivante utilise le AWS Management Console pour rechercher les noms de partition d'un cluster MemoryDB.
****
1. Connectez-vous à la console MemoryDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dans le volet de navigation de gauche, choisissez **Clusters**.
1. Sous **Nom**, choisissez le cluster dont vous souhaitez rechercher les noms de partition.
1. **Sous l'onglet **Partitions et nœuds**, consultez la liste des partitions sous Nom.** Vous pouvez également développer chacun d'eux pour afficher les détails de leurs nœuds.
### En utilisant le AWS CLI
Pour trouver les noms de partitions (partitions) pour les clusters MemoryDB, utilisez l' AWS CLI opération `describe-clusters` avec le paramètre facultatif suivant.
+ **`--cluster-name`**—Paramètre facultatif qui, lorsqu'il est utilisé, limite la sortie aux détails du cluster spécifié. Si ce paramètre est omis, les détails d'un maximum de 100 clusters sont renvoyés.
+ **`--show-shard-details`**: renvoie les détails des fragments, y compris leurs noms.
Cette commande renvoie les informations relatives à `my-cluster`.
Pour Linux, macOS ou Unix :
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Pour Windows :
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Elle renvoie la réponse JSON suivante :
Des sauts de ligne sont ajoutés pour faciliter la lecture.
```
{
"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
}
]
}
```
### Utilisation de l'API MemoryDB
Pour trouver les identifiants de partition pour les clusters MemoryDB, utilisez l'opération API `DescribeClusters` avec le paramètre facultatif suivant.
+ **`ClusterName`**—Paramètre facultatif qui, lorsqu'il est utilisé, limite la sortie aux détails du cluster spécifié. Si ce paramètre est omis, les détails d'un maximum de 100 clusters sont renvoyés.
+ **`ShowShardDetails`**: renvoie les détails des fragments, y compris leurs noms.
**Example**
Cette commande renvoie les informations relatives à `my-cluster`.
Pour Linux, macOS ou 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=
```