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 dans ElastiCache
Un *cluster* est un ensemble d'un ou de plusieurs nœuds de cache, qui exécutent tous une instance du logiciel de moteur Valkey, Memcached et Redis OSS. Lorsque vous créez un cluster, vous spécifiez le moteur et la version que tous les nœuds utiliseront.
**Clusters Valkey et Redis OSS**
Le schéma suivant illustre un cluster Valkey ou Redis OSS typique. Ces clusters peuvent contenir un seul nœud ou jusqu'à six nœuds au sein d'une partition (API/CLI : groupe de nœuds), un cluster Valkey ou Redis OSS à nœud unique (mode cluster désactivé) ne possède aucune partition, et un cluster Valkey ou Redis OSS (mode cluster désactivé) à plusieurs nœuds ne possède qu'une seule partition. Les clusters Valkey ou Redis OSS (mode cluster activé) peuvent contenir jusqu'à 500 partitions, vos données étant partitionnées entre les partitions. La limite de nœuds ou de partitions peut être augmentée jusqu'à un maximum de 500 par cluster si la version du moteur est Valkey 7.2 ou version ultérieure ou Redis OSS 5.0.6 ou version ultérieure. Par exemple, vous pouvez choisir de configurer un cluster de 500 nœuds compris entre 83 (un principal et 5 réplicas par partition) et 500 partitions (un principal et aucun réplicas). Assurez-vous qu’il y ait suffisamment d’adresses IP disponibles pour faire face à l’augmentation. Les pièges courants incluent les sous-réseaux du groupe de sous-réseaux avec une plage CIDR trop petite ou les sous-réseaux partagés et fortement utilisés par d’autres clusters. Pour de plus amples informations, veuillez consulter [Création d'un groupe de sous-réseaux](SubnetGroups.Creating.md). Pour les versions antérieures à 5.0.6, la limite est de 250 par cluster.
Pour demander une augmentation de cette limite, veuillez consulter [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) et sélectionnez le type de limite **Nœuds par cluster par type d'instance**.
Lorsque vous avez plusieurs nœuds dans une partition Valkey ou Redis OSS, l'un des nœuds est un read/write nœud principal. Tous les autres nœuds de la partition sont des réplicas en lecture seule.
Les clusters Valkey ou Redis OSS typiques se présentent comme suit.
![\[Image : Clusters Valkey et Redis OSS typiques\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Clusters Memcached**
Les clusters Memcached classiques se présentent comme suit. Les clusters Memcached contiennent de 1 à 60 nœuds, sur lesquels vous partitionnez vos données horizontalement.
![\[Image : Cluster Memcached standard\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Opérations Elasticache pour Valkey, Memcached et Redis OSS**
La plupart ElastiCache des opérations 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' ElastiCache API et AWS CLI les commandes. L'identifiant du cluster doit être unique pour ce client dans une AWS région.
ElastiCache prend en charge plusieurs versions de moteur. Sauf si vous avez des raisons spécifiques, nous vous recommandons d'utiliser la dernière version.
ElastiCache les clusters sont conçus pour être accessibles via une EC2 instance Amazon. Si vous lancez votre cluster dans un cloud privé virtuel (VPC) basé sur le service Amazon VPC, vous pouvez y accéder depuis l'extérieur d' AWS. Pour de plus amples informations, veuillez consulter [Accès aux ElastiCache ressources depuis l'extérieur AWS](accessing-elasticache.md#access-from-outside-aws).
Pour obtenir la liste des versions prises en charge[Moteurs et versions pris en charge](VersionManagement.md#supported-engine-versions), reportez-vous aux [Versions du moteur Redis OSS prises en charge](engine-versions.md#supported-engine-versions.redis) sections, et[Pris en charge ElastiCache pour les versions de Memcached](engine-versions.md#supported-engine-versions-mc).
# Choix d'un type de réseau dans ElastiCache
ElastiCache prend en charge les versions 4 et 6 du protocole Internet (IPv4 et IPv6), ce qui vous permet de configurer votre cluster pour qu'il accepte :
+ uniquement IPv4 des connexions,
+ uniquement IPv6 des connexions,
+ à la fois IPv4 et IPv6 connexions (double pile)
IPv6 [est pris en charge pour les charges de travail utilisant Valkey 7.2 et versions ultérieures, ou Redis OSS 6.2 et versions ultérieures, sur toutes les instances créées sur le système Nitro.](https://aws.amazon.com/ec2/nitro/) Il n'y a pas de frais supplémentaires pour y ElastiCache accéder IPv6.
**Note**
La migration des clusters créés avant la disponibilité de IPV6 /dual-stack n'est pas prise en charge. La commutation entre les types de réseaux sur les clusters nouvellement créés n'est pas non plus prise en charge.
IPv6 [est pris en charge pour les charges de travail utilisant Memcached 1.6.6 et versions ultérieures sur toutes les instances basées sur le système Nitro.](https://aws.amazon.com/ec2/nitro/) Il n'y a pas de frais supplémentaires pour y ElastiCache accéder IPv6.
## Configuration de sous-réseaux pour le type de réseau
Si vous créez un cluster dans un Amazon VPC, vous devez spécifier un groupe de sous-réseaux. ElastiCache utilise ce groupe de sous-réseaux pour choisir un sous-réseau et les adresses IP de ce sous-réseau à associer à vos nœuds. ElastiCache les clusters nécessitent un sous-réseau à double pile auquel les deux IPv6 adresses sont attribuées pour fonctionner en mode double pile IPv4 et un sous-réseau « uniquement » pour fonctionner en tant que « IPv6 -only ». IPv6
## Utilisation de la double pile
Lors de l'utilisation ElastiCache de Redis OSS en mode cluster activé, du point de vue de l'application, la connexion à tous les nœuds du cluster via le point de terminaison de configuration n'est pas différente de la connexion directe à un nœud de cache individuel. Pour ce faire, un client sensible aux clusters doit s'engager dans un processus de découverte des clusters et demander les informations de configuration pour tous les nœuds. Le protocole de découverte de Redis ne prend en charge qu'une seule adresse IP par nœud.
Lorsque vous créez un cluster avec ElastiCache for Memcached et que vous choisissez Dual-Stack comme type de réseau, vous devez ensuite désigner un type de découverte IP, soit. IPv4 IPv6 ElastiCache définira par défaut le type de réseau et la découverte IP IPv6, mais cela peut être modifié. Si vous utilisez la découverte automatique, seules les adresses IP du type d'IP que vous avez choisi sont renvoyées au client Memcached. Pour de plus amples informations, veuillez consulter [Identifiez automatiquement les nœuds de votre cluster (Memcached)](AutoDiscovery.md).
Pour maintenir la rétrocompatibilité avec tous les clients existants, la découverte d'adresses IP est introduite, qui vous permet de sélectionner le type d'adresse IP (c'est-à-dire IPv4 ou IPv6) à annoncer dans le protocole de découverte. Bien que cela limite la découverte automatique à un seul type d'adresse IP, la double pile reste avantageuse pour les charges de travail activées en mode cluster, car elle permet des migrations (ou des annulations) d'un type d'adresse IP de découverte IPv4 vers un type d'adresse IP de IPv6 découverte sans interruption de service.
## Clusters à double pile ElastiCache compatibles TLS
Lorsque TLS est activé pour les ElastiCache clusters, les fonctions de découverte de clusters telles que `cluster slots``cluster shards`, et `cluster nodes` avec Valkey ou Redis OSS et `config get cluster` avec Memcached renvoient des noms d'hôte au lieu de. IPs Les noms d'hôtes sont ensuite utilisés au lieu de se IPs connecter au ElastiCache cluster et d'effectuer une poignée de main TLS. Cela signifie que les clients ne seront pas affectés par le paramètre de découverte d'adresses IP. *Pour les clusters prenant en charge TLS, le paramètre de découverte d'adresses IP n'a aucun effet sur le protocole IP préféré.* Au lieu de cela, le protocole IP utilisé sera déterminé par le protocole IP que le client préfère lors de la résolution des noms d'hôtes DNS.
Pour obtenir des exemples de configuration d'une préférence de protocole IP lors de la résolution de noms d'hôtes DNS, consultez [Clusters à double pile ElastiCache compatibles TLS](BestPractices.md#network-type-configuring-tls-enabled-dual-stack).
## Utilisation du AWS Management Console(Valkey et Redis OSS)
Lorsque vous créez un cluster à l'aide de AWS Management Console, sous **Connectivité**, choisissez un type de réseau, soit un type de réseau **IPv4**, **IPv6**soit une **double pile**. Si vous créez un cluster Valkey ou Redis OSS (mode cluster activé) et que vous choisissez la double pile, vous devez sélectionner un **type d'IP de découverte**, soit IPv6 . IPv4
Pour plus d’informations, consultez [Création d'un cluster Valkey ou Redis OSS (mode cluster activé) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ou [Création d'un système d'exploitation Valkey ou Redis (mode cluster désactivé) (console)](Clusters.Create.md#Clusters.Create.CON.Redis).
Lorsque vous créez un groupe de réplication à l'aide du AWS Management Console, choisissez un type de réseau, soit un type de réseau **IPv4**, **IPv6**soit une **double pile**. Si vous choisissez la double pile, vous devez sélectionner un **type d'IP de découverte**, IPv6 soit IPv4.
Pour plus d’informations, consultez [Création d'un groupe de réplication Valkey ou Redis OSS (mode cluster désactivé) à partir de zéro](Replication.CreatingReplGroup.NoExistingCluster.Classic.md) ou [Création d'un groupe de réplication dans Valkey ou Redis OSS (mode cluster activé) à partir de zéro](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md).
## Utilisation du AWS Management Console(Memcached)
Lorsque vous créez un cluster à l'aide de AWS Management Console, sous **Connectivité**, choisissez un type de réseau, soit un type de réseau **IPv4**, **IPv6**soit une **double pile**. Si vous choisissez la double pile, vous devez sélectionner un **type d'IP de découverte**, IPv6 soit IPv4.
Pour de plus amples informations, veuillez consulter [Création d'un cluster Memcached (console)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
## Utilisation de la CLI avec Valkey, Memcached ou Redis OSS.
**Système d'exploitation Redis**
Lorsque vous créez un cluster avec Valkey ou Redis OSS à l'aide de la CLI, vous utilisez la [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)commande et spécifiez les paramètres `NetworkType` et `IPDiscovery` :
Pour Linux, macOS ou Unix :
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Pour Windows :
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Lorsque vous créez un groupe de réplication avec le mode cluster désactivé à l'aide de la CLI, vous utilisez la [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)commande et spécifiez les `IPDiscovery` paramètres `NetworkType` et :
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
Pour Windows :
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Lorsque vous créez un groupe de réplication avec le mode cluster activé et que vous l'utilisez IPv4 pour la découverte d'adresses IP à l'aide de la CLI, vous utilisez la [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)commande et spécifiez les `IPDiscovery` paramètres `NetworkType` et :
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
Pour Windows :
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
Lorsque vous créez un groupe de réplication avec le mode cluster activé et que vous l'utilisez IPv6 pour la découverte d'adresses IP à l'aide de la CLI, vous utilisez la [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)commande et spécifiez les `IPDiscovery` paramètres `NetworkType` et :
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
Pour Windows :
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
Lorsque vous créez un cluster avec Memcached à l'aide de la CLI, vous utilisez la [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)commande et spécifiez les paramètres `NetworkType` et `IPDiscovery` :
Pour Linux, macOS ou Unix :
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Pour Windows :
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# Identifiez automatiquement les nœuds de votre cluster (Memcached)
Pour les clusters exécutant le moteur Memcached, ElastiCache prend en charge la *détection automatique*, c'est-à-dire la capacité des programmes clients à identifier automatiquement tous les nœuds d'un cluster, ainsi qu'à établir et maintenir des connexions avec tous ces nœuds.
**Note**
La détection automatique est ajoutée pour les clusters exécutés sur Amazon ElastiCache Memcached. Auto Discovery n'est pas disponible pour les moteurs Valkey ou Redis OSS.
Avec la découverte automatique, votre application n'a pas besoin d'être manuellement connectée à chaque nœud de cache. Votre application se connecte plutôt à un nœud Memcached et accède à la liste de tous les nœuds. Grâce à cette liste, votre application connaît l'ensemble des nœuds du cluster et peut se connecter à chacun d'entre eux. Vous n'avez pas besoin de définir de façon spécifique chaque point de terminaison d'un nœud de cache dans votre application.
Si vous utilisez un type de réseau à double pile sur votre cluster, Auto Discovery renverra uniquement IPv6 les adresses IPv4 ou, selon le type que vous sélectionnez. Pour plus d’informations, consultez [Choix d'un type de réseau dans ElastiCache](network-type.md).
Tous les nœuds de cache dans le cluster conservent une liste de métadonnées sur tous les autres nœuds. Ces métadonnées sont mises à jour chaque fois que des nœuds sont ajoutés ou supprimés du cluster.
**Topics**
+ [Avantages de la découverte automatique avec Memcached](AutoDiscovery.Benefits.md)
+ [Comment fonctionne la découverte automatique](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Utilisation de la découverte automatique](AutoDiscovery.Using.md)
+ [Connexion manuelle aux nœuds de cache Memcached](AutoDiscovery.Manual.md)
+ [Ajouter Auto Discovery à votre bibliothèque cliente Memcached](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache clients dotés d'une fonction de détection automatique](Clients.md)
# Avantages de la découverte automatique avec Memcached
Lorsque vous utilisez Memcached, Auto Discovery offre les avantages suivants :
+ Lorsque vous augmentez le nombre de nœuds dans un cluster, les nouveaux nœuds s'enregistrent auprès du point de terminaison de configuration et auprès de tous les autres nœuds. Quand vous supprimez des nœuds dans un cluster de cache, les nœuds supprimés se désenregistrent automatiquement. Dans les deux cas, tous les autres nœuds du cluster sont mis à jour avec les métadonnées les plus récentes du nœud de cache.
+ Les défaillances de nœuds de cache sont détectées automatiquement ; les nœuds défaillants sont automatiquement remplacés.
**Note**
Jusqu'à ce que le nœud soit complètement remplacé, celui-ci continuera à être défaillant.
+ Un programme client doit uniquement se connecter au point de terminaison de configuration. Passé ce délai, la bibliothèque de découverte automatique se connecte à tous les autres nœuds du cluster.
+ Les programmes clients interrogent le cluster une fois par minute (si nécessaire, cet intervalle peut être ajusté). En cas de modifications de la configuration du cluster, telles que des nœuds ajoutés ou supprimés, le client reçoit une liste mise à jour des métadonnées. Puis le client se connecte à ces nœuds ou s'en déconnecte, selon le cas.
La découverte automatique est activée sur tous les clusters ElastiCache Memcached. Vous n'avez pas besoin de redémarrer un de vos nœuds de cache pour utiliser cette fonctionnalité.
# Comment fonctionne la découverte automatique
**Topics**
+ [Connexion aux nœuds de cache](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Opérations de routine sur un cluster](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Autres opérations](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
Cette section décrit comment les applications clientes utilisent le client de ElastiCache cluster pour gérer les connexions aux nœuds de cache et interagir avec les éléments de données du cache.
## Connexion aux nœuds de cache
Pour une application, il n'y a pas de différence entre se connecter au point de terminaison de la configuration du cluster et se connecter directement à chaque nœud de cache. Le graphique ci-dessous illustre le processus de connexion aux nœuds de cache.
![\[Connexion aux nœuds de cache\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Processus de connexion aux nœuds de cache**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/1.png) | Cette application résout le nom DNS du point de terminaison de la configuration. Etant donné que le point de terminaison de la configuration conserve les entrées CNAME pour tous les nœuds de cache, le nom DNS est converti en l'un de ces nœuds ; le client peut alors se connecter à ce nœud. |
| ![\[2\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/2.png) | Le client requiert les informations de configuration pour tous les autres nœuds. Du fait que chaque nœud conserve les informations de configuration de tous les nœuds du cluster, chaque nœud peut transmettre les informations de configuration au client à la demande. |
| ![\[3\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/3.png) | Le client reçoit la liste actuelle des adresses IP et des noms d'hôtes des nœuds de cache. Il peut alors se connecter à tous les autres nœuds du cluster. |
**Note**
Le programme client actualise sa liste des adresses IP et de noms d'hôtes des nœuds de cache chaque minute. Cet intervalle peut être modifié si nécessaire.
## Opérations de routine sur un cluster
Lorsque l'application est connectée à tous les nœuds de cache, le client de ElastiCache cluster détermine quels nœuds doivent stocker des éléments de données individuels et quels nœuds doivent être interrogés ultérieurement pour ces éléments de données. Le diagramme, ci-dessous, illustre le déroulement normal des opérations sur un cluster.
![\[Opérations de routine sur un cluster\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Déroulement des opérations de routine sur un cluster**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/1.png) | L'application émet une requête get pour une donnée particulière, identifiée par sa clé. |
| ![\[2\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/2.png) | Le client utilise un algorithme de hachage sur la clé pour déterminer quel nœud de cache contient l'élément de donnée. |
| ![\[3\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/3.png) | L'élément de données est demandé au nœud approprié. |
| ![\[4\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/callouts/4.png) | L'élément de données est transmis à l'application. |
## Autres opérations
Dans certains cas, vous pouvez modifier les nœuds d'un cluster. Par exemple, vous pouvez ajouter un nœud supplémentaire pour répondre à une demande supplémentaire ou supprimer un nœud pour économiser de l'argent pendant les périodes de demande réduite. Ou vous pouvez remplacer un nœud en raison d'une défaillance d'une sorte ou d'une autre.
Lorsque survient une modification dans un cluster qui requiert une mise à jour des métadonnées aux points de terminaison du cluster, cette modification affecte tous les nœuds en même temps. Ainsi, les métadonnées dans un nœud quelconque sont identiques à toutes les métadonnées de tous les autres nœuds du cluster.
Dans tous les cas, les métadonnées sont identiques dans tous les nœuds à chaque instant, puisque celles-ci sont mises à jour au même moment pour tous les nœuds dans le cluster. Vous devez toujours utiliser le point de terminaison de configuration pour obtenir les points de terminaison de chacun des nœuds du cluster. L'utilisation du point de terminaison de configuration vous évite d'obtenir des données de point de terminaison d'un nœud qui « disparaîtra » au moment où vous voulez y accéder.
### Ajout d'un nœud
Pendant la phase d'activation d'un nœud, son point de terminaison n'est pas inclus dans les métadonnées. Dès que le nœud devient disponible, il est ajouté aux métadonnées de chacun des nœuds du cluster. Dans ce scénario, les métadonnées sont identiques dans tous les nœuds et vous pourrez interagir avec le nouveau nœud uniquement une fois qu'il est disponible. Avant que le nœud ne soit disponible, il ne vous apparaîtra pas et vous utiliserez les nœuds de votre cluster comme si ce nouveau nœud n'existait pas.
### Suppression d'un nœud
Lorsqu'un nœud est supprimé, son point de terminaison est d'abord supprimé des métadonnées, puis le nœud est supprimé du cluster. Dans ce scénario, les métadonnées sont identiques dans tous les nœuds et à aucun moment elles ne contiendront le point de terminaison du nœud à supprimer alors que celui-ci est indisponible. Pendant la suppression du nœud, il n'est pas inclus dans les métadonnées et votre application interagira donc uniquement avec les n-1 nœuds restants, comme si ce nœud n'existait pas.
### Remplacement d'un nœud
Si un nœud tombe en panne, ElastiCache démonte ce nœud et lance un nœud de remplacement. Le processus de remplacement prend quelques minutes. Pendant ce temps, les métadonnées dans tous les nœuds contiennent encore le point de terminaison du nœud défaillant, mais toute tentative d'interaction avec celui-ci échouera. Par conséquent, vous devez toujours penser à réessayer.
# Utilisation de la découverte automatique
Pour commencer à utiliser Auto Discovery avec ElastiCache for Memcached, procédez comme suit :
+ [Obtenir le point de terminaison de configuration](#AutoDiscovery.Using.ConfigEndpoint)
+ [Téléchargez le client ElastiCache de cluster](#AutoDiscovery.Using.ClusterClient)
+ [Modifiez votre programme de candidature](#AutoDiscovery.Using.ModifyApp)
## Obtenir le point de terminaison de configuration
Pour se connecter à un cluster, les programmes clients doivent connaître le point de terminaison de configuration du cluster. Consultez la rubrique [Trouver les points de terminaison d'un cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)
Vous pouvez également utiliser la commande `aws elasticache describe-cache-clusters` avec le paramètre `--show-cache-node-info` :
Quelle que soit la méthode que vous utilisez pour trouver les points de terminaison du cluster, le point de terminaison de configuration aura toujours **.cfg** dans son adresse.
**Example Recherche de points de terminaison à l'aide du for AWS CLI ElastiCache**
Pour Linux, macOS ou Unix :
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Pour Windows :
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Cette opération produit une sortie similaire à la sortie suivante (format JSON) :
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1e"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1a"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "Multiple",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-10-12T21:39:28.001Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "sat:06:00-sat:07:00",
"CacheNodeType": "cache.r3.large"
}
]
}
```
## Téléchargez le client ElastiCache de cluster
Pour pouvoir bénéficier de la découverte automatique, les programmes clients doivent utiliser le *client de cluster ElastiCache*. Le client de ElastiCache cluster est disponible pour Java, PHP et .NET et contient toute la logique nécessaire pour découvrir et se connecter à tous vos nœuds de cache.
**Pour télécharger le client ElastiCache de cluster**
1. Connectez-vous à la console AWS de gestion et ouvrez-la à l' ElastiCache adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la ElastiCache console, choisissez **ElastiCache Cluster Client**, puis **Download**.
Le code source du client ElastiCache Cluster pour Java est disponible à l'adresse [https://github.com/amazonwebservices/aws-elasticache-cluster-client- memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Cette bibliothèque est basée sur le client Spymemcached populaire. Le client de ElastiCache cluster est publié sous la licence logicielle Amazon [https://aws.amazon.com/asl.](https://aws.amazon.com/asl) Vous êtes libre de modifier le code source selon vos besoins. Vous pouvez même incorporer le code dans d'autres bibliothèques Memcached open source, ou dans votre propre code client.
**Note**
Pour utiliser le client de ElastiCache cluster pour PHP, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, veuillez consulter [Installation du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoverySetup.md).
Pour un client qui prend en charge TLS, téléchargez le binaire avec PHP version 7.4 ou supérieure.
Pour utiliser le client de ElastiCache cluster pour .NET, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, veuillez consulter [Installation du client de ElastiCache cluster pour .NET](Appendix.DotNETAutoDiscoverySetup.md).
## Modifiez votre programme de candidature
Modifiez votre programme d'application afin qu'il utilise la découverte automatique. Les sections suivantes montrent comment utiliser le client de ElastiCache cluster pour Java, PHP et .NET.
**Important**
Lorsque vous spécifiez le point de terminaison de configuration du cluster, assurez-vous que le point de terminaison a « .cfg » dans son adresse comme illustré ici. N'utilisez pas un CNAME ou un point de terminaison sans « .cfg ».
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
Si vous ne spécifiez pas explicitement le point de terminaison de configuration du cluster, la configuration se fait sur un nœud spécifique.
# Utilisation du client de ElastiCache cluster pour Java
Le programme ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permet au programme de connecter tous les nœuds du cluster sans aucune autre intervention.
```
package com.amazon.elasticache;
import java.io.IOException;
import java.net.InetSocketAddress;
// Import the &AWS;-provided library with Auto Discovery support
import net.spy.memcached.MemcachedClient;
public class AutoDiscoveryDemo {
public static void main(String[] args) throws IOException {
String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
Integer clusterPort = 11211;
MemcachedClient client = new MemcachedClient(
new InetSocketAddress(configEndpoint,
clusterPort));
// The client will connect to the other cache nodes automatically.
// Store a data item for an hour.
// The client will decide which cache host will store this item.
client.set("theKey", 3600, "This is the data value");
}
}
```
# Utilisation du client de ElastiCache cluster pour PHP
Le programme ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permettra au programme de se connecter à tous les nœuds du cluster sans aucune autre intervention.
Pour utiliser le client de ElastiCache cluster pour PHP, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, consultez [Installation du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoverySetup.md).
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$dynamic_client->addServer($server_endpoint, $server_port);
/**
* Store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
$dynamic_client->set('key', 'value', 60);
/**
* Configuring the client with Static client mode disables the usage of Auto Discovery
* and the client operates as it did before the introduction of Auto Discovery.
* The user can then add a list of server endpoints.
*/
$static_client = new Memcached('persistent-id');
$static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE);
$static_client->addServer($server_endpoint, $server_port);
/**
* Store the data without expiration.
* The client will decide which cache host will store this item.
*/
$static_client->set('key', 'value');
?>
```
Pour un exemple d'utilisation du client de ElastiCache cluster avec TLS activé, voir [Utilisation du chiffrement en transit avec PHP et Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).
# Utilisation du client de ElastiCache cluster pour .NET
**Note**
Le client de cluster ElastiCache .NET est devenu obsolète en mai 2022.
Le client .NET pour ElastiCache est open source à l'adresse [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Les applications .NET obtiennent généralement leur configuration à partir de leur fichier de configuration. Le fichier ci-dessous est un exemple de fichier de configuration.
```
```
Le programme C\$1 ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permettra au programme de se connecter à tous les nœuds du cluster sans aucune autre intervention.
```
// *****************
// Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature.
using System;
using Amazon.ElastiCacheCluster;
using Enyim.Caching;
using Enyim.Caching.Memcached;
public class DotNetAutoDiscoveryDemo {
public static void Main(String[] args) {
// instantiate a new client.
ElastiCacheClusterConfig config = new ElastiCacheClusterConfig();
MemcachedClient memClient = new MemcachedClient(config);
// Store the data for 3600 seconds (1hour) in the cluster.
// The client will decide which cache host will store this item.
memClient.Store(StoreMode.Set, 3600, "This is the data value.");
} // end Main
} // end class DotNetAutoDiscoverDemo
```
# Connexion manuelle aux nœuds de cache Memcached
Si votre programme client n'utilise pas Auto Discovery, il peut se connecter manuellement à chacun des nœuds de cache Memcached. C'est le comportement par défaut des clients Memcached.
Vous pouvez obtenir une liste des noms d'hôte des numéros de port des nœuds de cache à partir de [la console de gestion AWS](https://aws.amazon.com/console/). Vous pouvez également utiliser la AWS CLI`aws elasticache describe-cache-clusters` commande avec le `--show-cache-node-info` paramètre.
**Example**
L'extrait de code Java suivant montre comment se connecter à tous les nœuds d'un cluster à quatre nœuds :
```
...
ArrayList cacheNodes = new ArrayList(
Arrays.asList(
"mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211"));
MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes));
...
```
**Important**
Si vous augmentez ou réduisez votre cluster en ajoutant ou en supprimant des nœuds, vous devez mettre à jour la liste des nœuds dans le code client.
# Ajouter Auto Discovery à votre bibliothèque cliente Memcached
Les informations de configuration pour Auto Discovery sont stockées de manière redondante dans chaque nœud de cluster Memcached. Les applications client peuvent interroger chaque nœud de cache pour obtenir les informations de configuration de tous les nœuds du cluster.
La façon de laquelle une application effectue cette tâche dépend de la version du moteur de cache :
+ Si la version du moteur de cache est **1.4.14 ou supérieure**, utilisez la commande `config`.
+ Si la version du moteur de cache est **inférieure à 1.4.14**, utilisez la commande `get AmazonElastiCache:cluster`.
Les résultats de ces deux commandes sont identiques et sont décrits dans la section [Format de sortie](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) ci-dessous.
## Moteur de cache version 1.4.14 ou supérieure
Dans le cas d'une version 1.4.14 ou supérieure du moteur de cache, utilisez la commande `config`. Cette commande a été ajoutée aux protocoles ASCII et binaires Memcached par ElastiCache et est implémentée dans le client de cluster. ElastiCache Si vous souhaitez utiliser la découverte automatique avec une autre bibliothèque client, alors cette bibliothèque devra être étendue pour prendre en charge la commande `config`.
**Note**
La documentation suivante concerne le protocole ASCII ; toutefois, la commande `config` prend en charge le protocole ASCII aussi bien que le protocole binaire. Si vous souhaitez ajouter la prise en charge de la découverte automatique à l'aide du protocole binaire, reportez-vous au [code source du client de ElastiCache cluster](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary).
**Syntaxe**
`config [sub-command] [key]`
### Options
| Nom | Description | Obligatoire |
| --- | --- | --- |
| sub-command | La sous-commande utilisée pour interagir avec un nœud de cache. Pour la découverte automatique, cette sous-commande est `get`. | Oui |
| key | La clé sous laquelle la configuration du cluster est sauvegardée. Pour la découverte automatique, cette clé est appelée `cluster`. | Oui |
Pour obtenir les informations de configuration du cluster, utilisez la commande suivante :
```
config get cluster
```
## Moteur de cache version 1.4.14 ou inférieure
Pour obtenir les informations de configuration du cluster, utilisez la commande suivante :
```
get AmazonElastiCache:cluster
```
**Note**
Ne modifiez pas la clé « :cluster AmazonElastiCache », car c'est là que se trouvent les informations de configuration du cluster. Si vous remplacez cette clé, il se peut que le client soit mal configuré pendant une courte période (pas plus de 15 secondes) avant de mettre à jour ElastiCache automatiquement et correctement les informations de configuration.
## Format de sortie
Que vous utilisiez `config get cluster` ou `get AmazonElastiCache:cluster`, la réponse tient deux lignes :
+ Le numéro de version des informations de configuration. Chaque fois qu'un nœud est ajouté ou supprimé du cluster, le numéro de version augmente d'une unité.
+ Une liste des nœuds de cache. Chaque nœud dans la liste est représenté par un groupe *hostname\$1ip-address\$1port* et chaque nœud est séparé par un espace.
Un retour à la ligne et un saut de ligne (CR \$1 LF) figurent à la fin de chaque ligne. La ligne de données se termine par un retour à la ligne, puis un retour à la ligne et un saut de ligne (CR \$1 LF) sont ajoutés. La ligne où figure la version de configuration se termine par saut de ligne (LF) sans retour à la ligne (CR).
Un cluster contenant trois nœuds serait représenté comme suit :
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Pour chaque nœud, sont affichés le CNAME et l'adresse IP privée. Le CNAME est toujours affiché ; l'adresse IP n'est affichée que si elle existe. Cependant, les barres verticales « `|` »seront tout de même affichées.
**Example**
Voici un exemple de la charge utile transmise lorsque vous interrogez les informations de configuration :
```
CONFIG cluster 0 136\r\n
12\n
myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n
END\r\n
```
**Note**
La deuxième ligne indique que les informations de configuration a été modifiées douze fois jusqu'à présent.
Sur la troisième ligne, la liste de nœuds est triée alphabétiquement par nom d'hôte. Cet ordre peut être différent de celui que vous utilisez habituellement dans votre application client.
# ElastiCache clients dotés d'une fonction de détection automatique
Les programmes clients du cluster peuvent automatiquement identifier et se connecter à tous les nœuds du cluster qui exécutent le moteur Memcached.
Cette section décrit l'installation et la configuration des clients ElastiCache PHP et .NET pour une utilisation avec la découverte automatique.
**Topics**
+ [Installation et compilation des clients de cluster](Appendix.InstallingClients.md)
+ [Configuration des ElastiCache clients](ClientConfig.md)
# Installation et compilation des clients de cluster
Cette section traite de l'installation, de la configuration et de la compilation des clients du cluster de découverte ElastiCache automatique Amazon PHP et .NET.
**Topics**
+ [Installation du client de ElastiCache cluster pour .NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Installation du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Compiler le code source du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoveryCompile.md)
# Installation du client de ElastiCache cluster pour .NET
Vous pouvez trouver le code du client ElastiCache .NET Cluster en open source à l'adresse [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Cette section décrit comment installer, mettre à jour et supprimer les composants .NET pour le client de ElastiCache cluster sur les EC2 instances Amazon. Pour plus d'informations sur la découverte automatique, consultez [Identifiez automatiquement les nœuds de votre cluster (Memcached)](AutoDiscovery.md). Pour un exemple de code .NET pour utiliser le client, consultez [Utilisation du client de ElastiCache cluster pour .NET](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Installation de .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Téléchargez le client de cluster ElastiCache .NET pour ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Installez les AWS assemblages avec NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Installation de .NET
.NET 3.5 ou version ultérieure doit être installé pour utiliser le SDK AWS .NET pour ElastiCache. Si vous ne disposez pas .NET 3.5 ou version ultérieure, vous pouvez télécharger et installer la dernière version de [http://www.microsoft.com/net](http://www.microsoft.com/net).
## Téléchargez le client de cluster ElastiCache .NET pour ElastiCache
**Pour télécharger le client de cluster ElastiCache .NET**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, cliquez sur **ElastiCache Cluster Client**.
1. **Dans la liste **Télécharger le client de cluster ElastiCache Memcached**, sélectionnez **.NET**, puis cliquez sur Télécharger.**
## Installez les AWS assemblages avec NuGet
NuGet est un système de gestion de paquets pour la plate-forme .NET. NuGet connaît les dépendances de l'assemblage et installe automatiquement tous les fichiers requis. NuGet les assemblages installés sont stockés avec votre solution, plutôt que dans un emplacement central, par exemple`Program Files`, afin que vous puissiez installer des versions spécifiques à une application sans créer de problèmes de compatibilité.
### Installation NuGet
NuGet peut être installé à partir de la galerie d'installation sur MSDN ; voir [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c.](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c) Si vous utilisez Visual Studio 2010 ou version ultérieure, NuGet il est automatiquement installé.
Vous pouvez l'utiliser NuGet à partir de l'**Explorateur de solutions** ou de **la console Package Manager**.
### Utilisation NuGet depuis l'Explorateur de solutions
**À utiliser NuGet depuis l'Explorateur de solutions dans Visual Studio 2010**
1. Dans le menu **Tools**, sélectionnez **Library Package Manager**.
1. Cliquez sur **Console du Gestionnaire de package**.
**À utiliser NuGet depuis l'Explorateur de solutions dans Visual Studio 2012 ou Visual Studio 2013**
1. Dans le menu **Outils**, sélectionnez **NuGet Package Manager**.
1. Cliquez sur **Console du Gestionnaire de package**.
A partir de la ligne de commande, vous pouvez installer les assemblages à l'aide de `Install-Package`, comme indiqué ci-après.
```
Install-Package Amazon.ElastiCacheCluster
```
[Pour voir une page pour chaque package disponible NuGet, tel que les assemblages AWS SDK et AWS.Extensions, consultez le NuGet site Web à l'adresse http://www.nuget.org.](http://www.nuget.org) La page de chaque package inclut un exemple de ligne de commande pour installer le package à l'aide de la console et une liste des versions précédentes du package disponibles viaNuGet.
Pour plus d'informations sur les commandes de **Console du Gestionnaire de package**, accédez à [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29).
# Installation du client de ElastiCache cluster pour PHP
Cette section décrit comment installer, mettre à jour et supprimer les composants PHP pour le client de ElastiCache cluster sur les EC2 instances Amazon. Pour plus d'informations sur la découverte automatique, consultez [Identifiez automatiquement les nœuds de votre cluster (Memcached)](AutoDiscovery.md). Pour un exemple de code PHP pour utiliser le client, consultez [Utilisation du client de ElastiCache cluster pour PHP](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Téléchargement du package d'installation](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Pour les utilisateurs qui ont déjà l'extension *php-memcached* installée](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Étapes d'installation pour les nouveaux utilisateurs](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Suppression du client de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Téléchargement du package d'installation
Pour vous assurer que vous utilisez la bonne version du client de ElastiCache cluster pour PHP, vous devez savoir quelle version de PHP est installée sur votre EC2 instance Amazon. Vous devez également savoir si votre EC2 instance Amazon exécute une version 64 bits ou 32 bits de Linux.
**Pour déterminer la version de PHP installée sur votre EC2 instance Amazon**
+ A l'invite de commande, exécutez la commande suivante :
```
php -v
```
La version PHP s'affiche dans le résultat, comme dans cet exemple :
```
PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies
```
**Note**
Si vos versions PHP et Memcached sont incompatibles, vous verrez un message d'erreur s'afficher, similaire à ce qui suit :
```
PHP Warning: PHP Startup: memcached: Unable to initialize module
Module compiled with module API=20100525
PHP compiled with module API=20131226
These options need to match
in Unknown on line 0
```
Si cela se produit, vous devrez compiler le module du code source. Pour de plus amples informations, veuillez consulter [Compiler le code source du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoveryCompile.md).
**Pour déterminer votre architecture Amazon EC2 AMI (64 bits ou 32 bits)**
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 la liste des **instances**, cliquez sur votre EC2 instance Amazon.
1. Dans l'onglet **Description**, recherchez le champ **AMI**. Une instance 64 bits doit disposer `x86_64` dans la description ; pour une instance 32 bits, recherchez `i386` ou `i686` dans ce champ.
Vous êtes maintenant prêt à télécharger le client de ElastiCache cluster.
**Pour télécharger le client de ElastiCache cluster pour PHP**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la ElastiCache console, choisissez **ElastiCache Cluster Client**.
1. Dans la liste **Télécharger le client de cluster ElastiCache Memcached, choisissez le client** de ElastiCache cluster qui correspond à votre version de PHP et à votre architecture AMI, puis cliquez sur le bouton **Télécharger**.
## Pour les utilisateurs qui ont déjà l'extension *php-memcached* installée
**Pour mettre à jour l'installation `php-memcached`**
1. Supprimez l'installation précédente de l'extension de Memcached pour PHP, tel que décrit par la rubrique [Suppression du client de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md).
1. Installez la nouvelle ElastiCache `php-memcached` extension comme décrit précédemment dans[Étapes d'installation pour les nouveaux utilisateurs](Appendix.PHPAutoDiscoverySetup.Installing.md).
# Étapes d'installation pour les nouveaux utilisateurs
**Topics**
+ [Installation de PHP 7.x pour les nouveaux utilisateurs](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Installation de PHP 5.x pour les nouveaux utilisateurs](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Installation de PHP 7.x pour les nouveaux utilisateurs
**Topics**
+ [Pour installer PHP 7 sur un serveur Ubuntu 14.04 LTS AMI (64 bits et 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [Pour installer PHP 7 sur une AMI Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [Pour installer PHP 7 sur une AMI de SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Pour installer PHP 7 sur un serveur Ubuntu 14.04 LTS AMI (64 bits et 32 bits)
1. Lancez une nouvelle instance depuis l’AMI.
1. Exécutez les commandes suivantes :
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Installez PHP 7.
```
sudo yum install php70
```
1. Téléchargez le client Amazon ElastiCache Cluster.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrayez `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Avec les autorisations racine, copiez le fichier artefact extrait `amazon-elasticache-cluster-client.so` dans `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Insérez la ligne `extension=amazon-elasticache-cluster-client.so` dans le fichier `/etc/php/7.0/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
### Pour installer PHP 7 sur une AMI Amazon Linux 201609
1. Lancez une nouvelle instance depuis l’AMI.
1. Exécutez la commande suivante :
```
sudo yum install gcc-c++
```
1. Installez PHP 7.
```
sudo yum install php70
```
1. Téléchargez le client Amazon ElastiCache Cluster.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrayez `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Avec l'autorisation racine, copiez le fichier artefact extrait `amazon-elasticache-cluster-client.so` dans `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Créez le fichier `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
### Pour installer PHP 7 sur une AMI de SUSE Linux
1. Lancez une nouvelle instance depuis l’AMI.
1. Exécutez la commande suivante :
```
sudo zypper install gcc
```
1. Installez PHP 7.
```
sudo yum install php70
```
1. Téléchargez le client Amazon ElastiCache Cluster.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrayez `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Avec l'autorisation racine, copiez le fichier artefact extrait `amazon-elasticache-cluster-client.so` dans `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Insérez la ligne `extension=amazon-elasticache-cluster-client.so` dans le fichier `/etc/php7/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
## Installation de PHP 5.x pour les nouveaux utilisateurs
**Topics**
+ [Pour installer PHP 5 sur une AMI d'Amazon Linux 2014.03 (64 bits et 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [Pour installer PHP 5 sur une AMI de Red Hat Enterprise Linux 7,0 (64 bits et 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [Pour installer PHP 5 sur une AMI de serveur Ubuntu 14.04 LTS (64 bits et 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [Pour installer PHP 5 pour AMI de SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Autres distributions Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### Pour installer PHP 5 sur une AMI d'Amazon Linux 2014.03 (64 bits et 32 bits)
1. Lancez une instance Amazon Linux (32 bits ou 64 bits) et connectez-vous.
1. Installez les dépendances PHP :
```
sudo yum install gcc-c++ php php-pear
```
1. Téléchargez le `php-memcached` package correspondant à votre EC2 instance Amazon et à votre version de PHP. Pour de plus amples informations, veuillez consulter [Téléchargement du package d'installation](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installer `php-memcached`. L'URI doit être le chemin de téléchargement du package d'installation :
```
sudo pecl install
```
Voici un exemple de commande installation pour PHP 5.4, Linux 64 bits. Dans cet exemple, remplacez *X.Y.Z* par le numéro de version réel :
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**Note**
Veuillez à utiliser la dernière version de l'artefact d'installation.
1. Avec root/sudo autorisation, ajoutez un nouveau fichier nommé `memcached.ini` dans le `/etc/php.d` répertoire et insérez « extension= amazon-elasticache-cluster-client .so » dans le fichier :
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
### Pour installer PHP 5 sur une AMI de Red Hat Enterprise Linux 7,0 (64 bits et 32 bits)
1. Lancez une instance Red Hat Enterprise Linux (32 bits ou 64 bits) et connectez-vous.
1. Installez les dépendances PHP :
```
sudo yum install gcc-c++ php php-pear
```
1. Téléchargez le `php-memcached` package correspondant à votre EC2 instance Amazon et à votre version de PHP. Pour de plus amples informations, veuillez consulter [Téléchargement du package d'installation](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installer `php-memcached`. L'URI doit être le chemin de téléchargement du package d'installation :
```
sudo pecl install
```
1. Avec root/sudo autorisation, ajoutez un nouveau fichier nommé `memcached.ini` dans le `/etc/php.d` répertoire et insérez-le `extension=amazon-elasticache-cluster-client.so` dans le fichier.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
### Pour installer PHP 5 sur une AMI de serveur Ubuntu 14.04 LTS (64 bits et 32 bits)
1. Lancez une instance Ubuntu Linux (32 bits ou 64 bits) et connectez-vous.
1. Installez les dépendances PHP :
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Téléchargez le `php-memcached` package correspondant à votre EC2 instance Amazon et à votre version de PHP. Pour de plus amples informations, veuillez consulter [Téléchargement du package d'installation](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installer `php-memcached`. L'URI doit être le chemin de téléchargement du package d'installation.
```
sudo pecl install
```
**Note**
Cette étape permet d'installer l'artefact de build `amazon-elasticache-cluster-client.so` dans le répertoire `/usr/lib/php5/20121212*`. Vérifiez le chemin d'accès absolu de l'artefact de génération, car vous en avez besoin pour l'étape suivante.
Si la commande précédente ne fonctionne pas, vous devez extraire manuellement l'artefact de client PHP `amazon-elasticache-cluster-client.so` du fichier `*.tgz` téléchargé, et le copier dans l'annuaire `/usr/lib/php5/20121212*`.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Avec root/sudo autorisation, ajoutez un nouveau fichier nommé `memcached.ini` dans le `/etc/php5/cli/conf.d` répertoire et insérez « extension= » dans le fichier.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
### Pour installer PHP 5 pour AMI de SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)
1. Lancez une instance SUSE Linux (32 bits ou 64 bits) et connectez-vous.
1. Installez les dépendances PHP :
```
sudo zypper install gcc php53-devel
```
1. Téléchargez le `php-memcached` package correspondant à votre EC2 instance Amazon et à votre version de PHP. Pour de plus amples informations, veuillez consulter [Téléchargement du package d'installation](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installer `php-memcached`. L'URI doit être le chemin de téléchargement du package d'installation.
```
sudo pecl install
```
1. Avec root/sudo autorisation, ajoutez un nouveau fichier nommé `memcached.ini` dans le `/etc/php5/conf.d` répertoire et insérez-le **extension=`amazon-elasticache-cluster-client.so`** dans le fichier.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
**Note**
Si l'étape 5 ne fonctionne pas pour une des plateformes précédentes, vérifiez le chemin d'installation de `amazon-elasticache-cluster-client.so`. Spécifiez également le chemin d'accès complet du fichier binaire dans l'extension. En outre, vérifiez que la version du PHP en cours d'utilisation est prise en charge. Nous prenons en charge les versions 5.3 via 5.5.
### Autres distributions Linux
Sur certains systèmes, notamment Cent OS7 et Red Hat Enterprise Linux (RHEL), la version 7.1 `libsasl2.so.3` a été remplacée`libsasl2.so.2`. Sur ces systèmes, lorsque vous chargez le client du ElastiCache cluster, celui-ci tente de le trouver et de le charger, mais il échoue`libsasl2.so.2`. Pour résoudre ce problème, créez un lien symbolique vers `libsasl2.so.3` afin que lorsque le client tente de charger libsasl2.so.2, il est redirigé vers `libsasl2.so.3`. Le code suivant crée ce lien symbolique.
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Suppression du client de cluster PHP
**Topics**
+ [Suppression d'une version antérieure de PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Suppression d'une version antérieure de PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Suppression d'une version antérieure de PHP 7
**Pour supprimer une version antérieure de PHP 7**
1. Supprimez le fichier `amazon-elasticache-cluster-client.so` dans le répertoire de lib PHP approprié comme indiqué précédemment dans les instructions d'installation. Consultez la section pour votre installation dans [Pour les utilisateurs qui ont déjà l'extension *php-memcached* installée](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Supprimez la ligne `extension=amazon-elasticache-cluster-client.so` du fichier `php.ini`.
1. Démarrez ou redémarrez votre serveur Apache.
```
sudo /etc/init.d/httpd start
```
## Suppression d'une version antérieure de PHP 5
**Pour supprimer une version antérieure de PHP 5**
1. Supprimez l'extension `php-memcached` :
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Supprimez le fichier `memcached.ini` ajouté dans le répertoire approprié comme indiqué dans les étapes d'installation précédentes.
# Compiler le code source du client de ElastiCache cluster pour PHP
Cette section explique comment obtenir et compiler le code source du client de ElastiCache cluster pour PHP.
[Il existe deux paquets que vous devez extraire GitHub et compiler : [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) et -. aws-elasticache-cluster-client memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php)
**Topics**
+ [Compilation de la bibliothèque libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Compilation du client de découverte automatique ElastiCache Memcached pour PHP](#Appendix.PHPAutoDiscoveryCompile.Client)
## Compilation de la bibliothèque libmemcached
**Pour compiler la aws-elasticache-cluster-client bibliothèque -libmemcached**
1. Lancez une EC2 instance Amazon.
1. Installez les dépendances de bibliothèque.
+ Sur AMI d'Amazon Linux 201509
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ Sur AMI d'Ubuntu 14.04
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Extrayez le référentiel et compilez le code.
```
Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz)
```
## Compilation du client de découverte automatique ElastiCache Memcached pour PHP
Les sections suivantes décrivent comment compiler le client ElastiCache Memcached Auto Discovery
**Topics**
+ [Compiler le client ElastiCache Memcached pour PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Compiler le client ElastiCache Memcached pour PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Compiler le client ElastiCache Memcached pour PHP 7
Exécutez l'ensemble de commandes dans le répertoire du code.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
git checkout php7
sudo yum install php70-devel
phpize
./configure --with-libmemcached-dir= --disable-memcached-sasl
make
make install
```
**Note**
Vous pouvez lier statiquement la bibliothèque libmemcached dans le binaire PHP afin qu'il soit porté sur différentes plateformes Linux. Pour cela, exécutez la commande suivante avant `make` :
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Compiler le client ElastiCache Memcached pour PHP 5
Compilez le `aws-elasticache-cluster-client-memcached-for-php` en exécutant les commandes suivantes dans le dossier `aws-elasticache-cluster-client-memcached-for-php/`.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
sudo yum install zlib-devel
phpize
./configure --with-libmemcached-dir=
make
make install
```
# Configuration des ElastiCache clients
Un ElastiCache cluster est conforme au protocole avec Valkey, Memcached et Redis OSS. Le code, les applications et les outils les plus courants que vous utilisez aujourd'hui dans votre environnement existant fonctionneront parfaitement avec le service.
Cette section contient des considérations spécifiques pour la connexion aux nœuds de cache dans ElastiCache.
**Topics**
+ [Commandes limitées](ClientConfig.RestrictedCommands.md)
+ [Recherche des points de terminaison et des numéros de port des nœuds](ClientConfig.FindingEndpointsAndPorts.md)
+ [Connexion pour l'utilisation de la découverte automatique](ClientConfig.AutoDiscovery.md)
+ [Connexion aux nœuds d'un cluster Valkey ou Redis OSS](ClientConfig.ReplicationGroup.md)
+ [Noms DNS et réseau IP sous-jacent](ClientConfig.DNS.md)
# Commandes limitées
Pour offrir une expérience de service géré, ElastiCache restreint l'accès à certaines commandes spécifiques au moteur de cache qui nécessitent des privilèges avancés. Pour les clusters exécutant Redis OSS, les commandes suivantes ne sont pas disponibles :
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Recherche des points de terminaison et des numéros de port des nœuds
Pour se connecter à un nœud de cache, votre application a besoin de connaître le point de terminaison et le numéro de port de ce nœud.
## Recherche des points de terminaison et des numéros de port des nœuds (console)
**Pour déterminer les points de terminaison et les numéros de port des nœuds de **
1. Connectez-vous à la [console ElastiCache de gestion Amazon](https://aws.amazon.com/elasticache) et choisissez le moteur exécuté sur votre cluster.
La liste de tous les clusters exécutant le moteur choisi s'affiche.
1. Poursuivez ci-dessous pour le moteur et la configuration que vous exécutez.
1. Choisissez le nom du cluster qui vous intéresse.
1. Recherchez les colonnes **Port** et **Endpoint** pour le nœud qui vous intéresse.
## Recherche des points de terminaison et des numéros de port des nœuds de cache (AWS CLI)
Pour déterminer les points de terminaison et les numéros de port des nœuds de cache, utilisez la commande `describe-cache-clusters` avec le paramètre `--show-cache-node-info`.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
Les noms DNS complets et les numéros de port sont dans la section Endpoint du résultat.
## Recherche des points de terminaison et des numéros de port des nœuds de cache (ElastiCache API)
Pour déterminer les points de terminaison et les numéros de port des nœuds de cache, utilisez l'action `DescribeCacheClusters` avec le paramètre `ShowCacheNodeInfo=true`.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ShowCacheNodeInfo=true
4. &SignatureVersion=4
5. &SignatureMethod=HmacSHA256
6. &Timestamp=20140421T220302Z
7. &Version=2014-09-30
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Credential=
10. &X-Amz-Date=20140421T220302Z
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Signature=
13. &X-Amz-SignedHeaders=Host
```
# Connexion pour l'utilisation de la découverte automatique
Si vos applications utilisent la découverte automatique, il vous suffit de connaître le point de terminaison de configuration du cluster, plutôt que les points de terminaison individuels de chaque nœud de cache. Pour de plus amples informations, veuillez consulter [Identifiez automatiquement les nœuds de votre cluster (Memcached)](AutoDiscovery.md).
**Note**
À l'heure actuelle, Auto Discovery n'est disponible que pour les clusters exécutant Memcached.
# Connexion aux nœuds d'un cluster Valkey ou Redis OSS
**Note**
À l'heure actuelle, les clusters (API/CLI : groupes de réplication) qui prennent en charge la réplication et la lecture des répliques ne sont pris en charge que pour les clusters exécutant Valkey ou Redis OSS.
Pour les clusters, ElastiCache fournit des interfaces de console, de CLI et d'API pour obtenir des informations de connexion pour les nœuds individuels.
Pour l'activité de lecture seule, les applications peuvent se connecter à n'importe quel nœud du cluster. Toutefois, pour les activités d'écriture, nous recommandons que vos applications se connectent au point de terminaison principal (Valkey ou Redis OSS (mode cluster désactivé)) ou au point de configuration (Valkey ou Redis OSS (mode cluster activé)) du cluster au lieu de se connecter directement à un nœud. Cela permet de s'assurer que vos applications trouveront toujours le nœud correct, même si vous décidez de reconfigurer votre cluster en faisant la promotion d'un réplica en lecture en réplica principal.
## Connexion aux clusters dans un groupe de réplication (console)
**Pour déterminer les points de terminaison et les numéros de port**
+ Consultez la rubrique, [Trouver les points de terminaison d'un cluster Valkey ou Redis OSS (mode cluster désactivé) (console)](Endpoints.md#Endpoints.Find.Redis).
## Connexion aux clusters dans un groupe de réplication (AWS CLI)
**Pour déterminer les points de terminaison et les numéros de port des nœuds de cache**
Utilisez la commande `describe-replication-groups` avec le nom de votre groupe de réplication :
```
aws elasticache describe-replication-groups redis2x2
```
Cette commande doit produire une sortie similaire à ce qui suit :
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "redis2x2",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"redis2x2-0001-001",
"redis2x2-0001-002",
"redis2x2-0002-001",
"redis2x2-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"PendingModifiedValues": {}
}
]
}
```
## Connexion aux clusters d'un groupe de réplication (ElastiCache API)
**Pour déterminer les points de terminaison et les numéros de port des nœuds de cache**
Appelez `DescribeReplicationGroups` avec le paramètre suivant :
`ReplicationGroupId` = le nom de votre groupe de réplication.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ReplicationGroupId=repgroup01
4. &Version=2014-09-30
5. &SignatureVersion=4
6. &SignatureMethod=HmacSHA256
7. &Timestamp=20140421T220302Z
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Date=20140421T220302Z
10. &X-Amz-SignedHeaders=Host
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Credential=
13. &X-Amz-Signature=
```
# Noms DNS et réseau IP sous-jacent
Les clients gèrent une liste de serveurs contenant les adresses et les ports des serveurs contenant les données de cache. Lors de l'utilisation ElastiCache, l' DescribeCacheClusters API (ou l'utilitaire de ligne de describe-cache-clusters commande) renvoie une entrée DNS complète et un numéro de port qui peuvent être utilisés pour la liste des serveurs.
**Important**
Il est important que les applications clientes soient configurées pour résoudre fréquemment les noms DNS des nœuds de cache lorsqu'elles tentent de se connecter au point de terminaison d'un nœud de cache.
ElastiCache garantit que le nom DNS des nœuds de cache reste le même lorsque les nœuds de cache sont restaurés en cas de défaillance.
La plupart des bibliothèques clientes prennent en charge les connexions persistantes au nœud de cache, par défaut. Nous recommandons d'utiliser des connexions persistantes aux nœuds de cache lors de l'utilisation d' ElastiCache. La mise en cache de DNS côté client peut se produire à plusieurs endroits, notamment dans les bibliothèques clientes, dans l'environnement Common Language Runtime ou le système d'exploitation client. Vous devez passer en revue la configuration de votre application à chaque couche pour vous assurer de résoudre fréquemment les adresses IP pour vos nœuds de cache.
# Hiérarchisation des données ElastiCache
ElastiCache pour les clusters Valkey ou Redis OSS qui comprennent un groupe de réplication et utilisent un type de nœud de la famille r6gd, leurs données sont hiérarchisées entre la mémoire et le stockage SSD (SSD) local. La hiérarchisation des données offre une nouvelle option de rapport prix/performances pour les charges de travail Valkey ou 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. Elle 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 ElastiCache clusters dotés de la hiérarchisation des données, ElastiCache surveille l'heure du dernier accès à chaque élément stocké. Lorsque la mémoire disponible (DRAM) est entièrement consommée, ElastiCache utilise l'algorithme le moins récemment utilisé (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, elles sont ElastiCache automatiquement et asynchrones remises 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 vous attendre à 300 microsecondes de latence supplémentaires en moyenne pour les demandes de données stockées sur le SSD par rapport aux demandes de données en mémoire.
Grâce à la plus grande taille de nœud de hiérarchisation des données (cache.r6gd.16xlarge), vous pouvez stocker jusqu’à 1 pétaoctet dans un seul cluster de 500 nœuds (500 To en utilisant 1 réplica en lecture). La hiérarchisation des données est compatible avec toutes les commandes et structures de données Valkey ou Redis OSS prises en charge dans. ElastiCache Vous n’avez besoin d’aucune modification côté client pour utiliser cette fonction.
**Topics**
+ [Bonnes pratiques](#data-tiering-best-practices)
+ [Limites](#data-tiering-prerequisites)
+ [Tarification](#data-tiering-pricing)
+ [Surveillance](#data-tiering-monitoring)
+ [Utilisation de la hiérarchisation des données](#data-tiering-enabling)
+ [Restauration des données de la sauvegarde dans des clusters avec la hiérarchisation des données activée](#data-tiering-enabling-snapshots)
## 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é. 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
La hiérarchisation des données présente les limitations suivantes :
+ Vous ne pouvez utiliser la hiérarchisation des données que sur des clusters faisant partie d’un groupe de réplication.
+ 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-central-1`, `eu-north-1`, `eu-west-3`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` et `sa-east-1`.
+ Vous devez utiliser un moteur Valkey 7.2 ou version ultérieure, ou un moteur Redis OSS 6.2 ou version ultérieure.
+ Vous ne pouvez pas restaurer une sauvegarde d’un cluster r6gd dans un autre cluster sauf s’il utilise également r6gd.
+ Vous ne pouvez pas exporter une sauvegarde vers Amazon S3 pour les clusters de hiérarchisation des données.
+ La migration en ligne n'est pas prise en charge pour les clusters exécutés sur le type de nœud r6gd.
+ 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). Pour de plus amples informations, veuillez consulter [Dimensionnement ElastiCache](Scaling.md).
+ Le dimensionnement automatique est pris en charge sur les clusters à l'aide de la hiérarchisation des données pour Valkey version 7.2 et versions ultérieures, et Redis OSS version 7.0.7 et versions ultérieures. Pour de plus amples informations, consultez [Clusters Auto Scaling Valkey et Redis OSS](AutoScaling.md).
+ La hiérarchisation des données prend uniquement en charge les politiques maxmemory `volatile-lru`, `allkeys-lru`, `volatile-lfu`, `allkeys-lfu` et `noeviction`.
+ La sauvegarde sans formulaire est prise en charge pour Valkey version 7.2 et versions ultérieures, et pour Redis OSS version 7.0.7 et versions ultérieures. Pour de plus amples informations, veuillez consulter [Implémentation de la sauvegarde et de la synchronisation](Replication.Redis.Versions.md).
+ Les éléments de plus de 128 MiB ne sont pas déplacés vers le SSD.
+ À partir de Valley 8.1 et versions ultérieures, un élément dont la taille clé\$1valeur est inférieure à 40 octets ne sera pas déplacé vers le SSD.
## Tarification
Les nœuds R6gd ont une capacité totale 4,8 fois plus élevée (mémoire \$1 SSD) et peuvent vous aider à réaliser des économies de plus de 60 % quand ils s’exécutent au maximum de leur capacité par rapport aux nœuds R6g (mémoire uniquement). Pour en savoir plus, consultez [PricingElastiCache ](https://aws.amazon.com/elasticache/pricing/) (Tarification).
## Surveillance
ElastiCache propose des métriques conçues spécifiquement pour surveiller les clusters de performances 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 de [Metrics for Valkey et Redis](CacheMetrics.Redis.md) OSS. Vous pouvez calculer le pourcentage comme suit : *(CurrItems avec Dimension : Tier = Memory \$1 100)/(CurrItems sans filtre de dimension)*.
Si la politique d'expulsion configurée le permet, elle ElastiCache 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é d'envisager une mise à l'échelle horizontale pour les clusters activés en mode cluster ou une mise à l'échelle supérieure pour les clusters désactivés en mode cluster lorsque le pourcentage d'éléments en mémoire tombe en dessous de 5 %. Pour plus d'informations sur la mise à l'échelle, voir[Mise à l'échelle des clusters Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md). Pour plus d'informations sur les métriques pour les clusters Valkey ou Redis OSS qui utilisent la hiérarchisation des données, consultez. [Métriques pour Valkey et Redis OSS](CacheMetrics.Redis.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 dans le cadre d’un groupe de réplication, vous utilisez la hiérarchisation des données en sélectionnant un type de nœud dans la famille r6gd, tel que *cache.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 [Création d'un cluster pour Valkey ou Redis OSS](Clusters.Create.md).
### Activation de la hiérarchisation des données à l'aide du AWS CLI
Lorsque vous créez un groupe de réplication à 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 *cache.r6gd.xlarge, et en définissant le paramètre.* `--data-tiering-enabled`
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-enabled`, l’opération échouera.
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
Pour Windows :
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
Après avoir exécuté cette opération, une réponse similaire à ceci s’affiche :
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## Restauration des données de la sauvegarde dans des clusters avec la hiérarchisation des données activée
Vous pouvez restaurer une sauvegarde sur un nouveau cluster avec la hiérarchisation des données activée à l'aide de la (console), (AWS CLI) ou (ElastiCache API). 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 à partir de la sauvegarde dans des clusters avec la hiérarchisation des données activée (console)
**Pour restaurer une sauvegarde dans un nouveau cluster avec la hiérarchisation des données activée (console)**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation de gauche, choisissez **Sauvegardes**.
1. Dans la liste des sauvegardes, cochez la case située à gauche du nom de la sauvegarde à restaurer.
1. Choisissez **Restore** (Restaurer).
1. Renseignez la boîte de dialogue **Restore Cluster. ** Veillez à remplir tous les champs **obligatoires**, ainsi que ceux dont vous ne souhaitez pas conserver la valeur par défaut.
1. **ID du cluster** : obligatoire. Nom du nouveau cluster.
1. **Mode cluster activé (mise à l'échelle externe)** — Choisissez cette option pour un cluster Valkey ou Redis OSS (mode cluster activé).
1. **Type de nœud** : préciser **cache.r6gd.xlarge** ou tout autre type de nœud de la famille r6gd.
1. **Nombre de partitions** : choisissez le nombre de partitions dont vous avez besoin dans le nouveau cluster (API/CLI : groupes de nœuds).
1. **Replicas per Shard (Réplicas par partition)** : choisissez le nombre de nœuds de réplica en lecture souhaité dans chaque partition.
1. **Slots and keyspaces (Emplacements et espaces de clés)** : choisissez la répartition des clés entre les partitions. Si vous choisissez de spécifier les répartitions de clés, remplissez le tableau en spécifiant les plages de clés de chaque partition.
1. **Zone(s) de disponibilité** : spécifiez la façon dont les zones de disponibilité du cluster doivent être sélectionnées.
1. **Port** : modifiez cette valeur uniquement si vous souhaitez que le nouveau cluster utilise un port différent.
1. **Choisir un VPC** : choisissez le VPC dans lequel vous souhaitez créer ce cluster.
1. **Groupe de paramètres** : choisissez un groupe de paramètres qui réserve suffisamment de mémoire pour la surcharge de Valkey ou Redis OSS pour le type de nœud que vous avez sélectionné.
1. Lorsque les paramètres vous conviennent, choisissez **Create**.
Pour plus d'informations sur la création des clusters , consultez [Création d'un cluster pour Valkey ou Redis OSS](Clusters.Create.md).
### Restauration des données de la sauvegarde dans des clusters avec la hiérarchisation des données activée AWS CLI
Lors de la création d'un groupe de réplication à 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 *cache.r6gd.xlarge*, et en définissant le paramètre. `--data-tiering-enabled`
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-enabled`, l’opération échouera.
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
Pour Linux, macOS ou Unix :
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
Après avoir exécuté cette opération, une réponse similaire à ceci s’affiche :
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# Préparation d'un cluster dans ElastiCache
Vous trouverez ci-dessous des instructions sur la création d'un cluster à l'aide de la ElastiCache console AWS CLI, de l'API ou de l' ElastiCache API.
Vous pouvez également créer un ElastiCache cluster à l'aide de [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). Pour plus d'informations, consultez [AWS: : : ElastiCache : CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html) dans le *guide de l'utilisateur de AWS Cloud Formation*, qui contient des conseils sur la manière de mettre en œuvre cette approche.
Chaque fois que vous créez un cluster ou un groupe de réplication , il est utile de réaliser un travail préparatoire de sorte à ne pas avoir besoin d'effectuer une mise à niveau ou d'apporter des changements immédiatement.
**Topics**
+ [Déterminer les exigences ElastiCache de votre cluster](cluster-create-determine-requirements.md)
+ [Choix de la taille de votre nœud](CacheNodes.SelectSize.md)
# Déterminer les exigences ElastiCache de votre cluster
**Préparation**
Connaître les réponses aux questions suivantes facilite la création de votre ElastiCache cluster :
+ De quel type d'instance de nœud avez-vous besoin ?
Pour vous guider dans la sélection du type de nœud d'instance, consultez [Choix de la taille de votre nœud](CacheNodes.SelectSize.md).
+ Lancez-vous votre cluster dans un cloud privé virtuel (VPC) basé sur Amazon VPC ?
**Important**
Si vous envisagez de lancer votre cluster dans un VPC, vous devez créer un groupe de sous-réseaux dans le même VPC avant de commencer à créer un cluster. Pour de plus amples informations, veuillez consulter [Sous-réseaux et groupes de sous-réseaux](SubnetGroups.md).
ElastiCache est conçu pour être accessible depuis AWS l'intérieur via Amazon EC2. Cependant, si vous lancez votre cluster dans un VPC basé sur Amazon VPC et qu'il se trouve dans un VPC, vous pouvez y accéder depuis l'extérieur d' AWS. Pour de plus amples informations, veuillez consulter [Accès aux ElastiCache ressources depuis l'extérieur AWS](accessing-elasticache.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 ElastiCache de paramètres](ParameterGroups.Creating.md).
Si vous utilisez Valkey ou Redis OSS, pensez à définir `reserved-memory` ou. `reserved-memory-percent` Pour de plus amples informations, veuillez consulter [Gestion de la mémoire réservée pour Valkey et Redis OSS](redis-memory-management.md).
+ Devez-vous créer votre propre *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](disaster-recovery-resiliency.md#FaultTolerance).
**Topics**
+ [ElastiCache exigences en matière de mémoire et de processeur](#cluster-create-determine-requirements-memory)
+ [Configuration du cluster Memcached](#memcached-cluster-configuration)
+ [Configuration des clusters Valkey et Redis OSS](#redis-cluster-configuration)
+ [ElastiCache exigences de dimensionnement](#cluster-create-determine-requirements-scaling)
+ [ElastiCache exigences en matière d'accès](#cluster-create-determine-requirements-access)
+ [Exigences relatives à la région, à la zone de disponibilité et à la zone locale pour ElastiCache](#cluster-create-determine-requirements-region)
## ElastiCache exigences en matière de mémoire et de processeur
L'élément de base d'Amazon ElastiCache est le nœud. Les nœuds sont configurés de manière individuelle ou en groupe 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.
Le moteur Memcached est en multi-thread. Le nombre de cœurs du nœud a donc un impact sur la puissance de calcul à disposition du cluster.
## Configuration du cluster Memcached
ElastiCache pour les clusters Memcached sont composés de 1 à 60 nœuds. Les données contenues dans un cluster Memcached sont partitionnées parmi les nœuds du cluster. Votre application se connecte à un cluster Memcached par le biais d'une adresse de réseau appelée point de terminaison. Chaque nœud d'un cluster Memcached dispose de son propre point de terminaison que votre application utilise afin de lire ou d'écrire sur le nœud spécifique. En plus des points de terminaison de nœud, le cluster Memcached lui-même possède un point de terminaison appelé *configuration endpoint* (point de terminaison de configuration). Votre application peut utiliser ce point de terminaison pour lire ou écrire sur le cluster, laissant la détermination du nœud à lire ou à écrire à la découverte automatique.
![\[Image montrant comment un cluster Memcached est partitionné entre les nœuds du cluster.\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
## Configuration des clusters Valkey et Redis OSS
ElastiCache pour Valkey et Redis OSS, les clusters sont composés de 0 à 500 partitions (également appelés groupes de nœuds). Les données d'un cluster Valkey ou Redis OSS sont partitionnées entre les partitions du cluster. Votre application se connecte à un cluster Valkey ou Redis OSS à l'aide d'une adresse réseau appelée Endpoint. Les nœuds d'une partition Valkey ou Redis OSS remplissent l'un des deux rôles suivants : un nœud read/write principal et tous les autres nœuds secondaires en lecture seule (également appelés répliques en lecture). *Outre les points de terminaison du nœud, le cluster Valkey ou Redis OSS lui-même possède un point de terminaison appelé point de terminaison de configuration.* Votre application peut utiliser ce point de terminaison pour lire ou écrire dans le cluster, ce qui laisse à Redis OSS le soin de déterminer le nœud à ElastiCache partir duquel lire ou écrire.
![\[Image comparant un cluster Valkey ou Redis OSS en mode désactivé et en mode activé.\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
## ElastiCache exigences de dimensionnement
Tous les clusters peuvent augmentés par la création d'un nouveau cluster doté d'un nouveau type de nœud plus grand. Lorsque vous augmentez la taille d'un cluster Memcached, le nouveau cluster est vide au départ. Lorsque vous augmentez la taille d'un cluster Valkey ou Redis OSS, vous pouvez l'amorcer à partir d'une sauvegarde et éviter que le nouveau cluster ne démarre à vide.
Les clusters Amazon ElastiCache for Memcached peuvent être étendus ou intégrés. Pour augmenter ou diminuer un cluster Memcached, il suffit d'ajouter ou de supprimer des nœuds du cluster. Si vous avez activé la Découverte automatique et que votre application se connecte au point de terminaison de la configuration du cluster, votre application ne nécessite aucune modification lors de l'ajout ou de la suppression de nœuds.
Pour plus d’informations, consultez [Dimensionnement ElastiCache](Scaling.md) dans ce guide.
## ElastiCache exigences en matière d'accès
De par leur conception, les ElastiCache clusters Amazon sont accessibles à partir d' EC2 instances Amazon. L'accès réseau à un ElastiCache cluster est limité au compte qui a créé le cluster. Par conséquent, avant de pouvoir accéder à un cluster depuis une EC2 instance Amazon, vous devez autoriser l' EC2 instance Amazon à accéder au cluster. Les étapes pour ce faire varient selon que vous avez lancé EC2 -VPC ou EC2 -Classic.
Si vous avez lancé votre cluster dans EC2 -VPC, vous devez autoriser l'accès réseau au cluster. Si vous avez lancé votre cluster dans EC2 -Classic, vous devez accorder au groupe de sécurité Amazon Elastic Compute Cloud associé à l'instance l'accès à votre groupe ElastiCache de sécurité. Pour plus d'informations, consultez [Étape 3. Autoriser l'accès au cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) dans ce manuel.
## Exigences relatives à la région, à la zone de disponibilité et à la zone locale pour ElastiCache
Amazon ElastiCache prend en charge toutes les AWS régions. En localisant vos ElastiCache clusters dans une AWS région proche de votre application, vous pouvez réduire la latence. Si votre cluster comporte plusieurs nœuds, la localisation de vos nœuds dans différentes zones de disponibilité ou dans des zones locales peut réduire l'impact des défaillances sur votre cluster.
Pour plus d’informations, consultez les ressources suivantes :
+ [Choix des régions et des zones de disponibilité pour ElastiCache](RegionsAndAZs.md)
+ [Utilisation de zones locales avec ElastiCache](Local_zones.md)
+ [Atténuation des défaillances](disaster-recovery-resiliency.md#FaultTolerance)
# Choix de la taille de votre nœud
La taille du nœud que vous sélectionnez pour votre ElastiCache cluster a un impact sur les coûts, les performances et la tolérance aux pannes.
## Taille du nœud (Valkey et Redis OSS)
Pour découvrir les avantages des processeurs Graviton, consultez [Processeur AWS Graviton](https://aws.amazon.com/pm/ec2-graviton/).
Répondre aux questions suivantes peut vous aider à déterminer le type de nœud minimal dont vous avez besoin pour votre implémentation de Valkey ou Redis OSS :
+ Vous attendez-vous à des charges de travail limitées en termes de débit avec plusieurs connexions client ?
Si tel est le cas et que vous utilisez Redis OSS version 5.0.6 ou supérieure, vous pouvez obtenir un meilleur débit et une meilleure latence grâce à notre I/O fonctionnalité améliorée, qui, le cas échéantCPUs , est utilisée pour décharger les connexions client, au nom du moteur Redis OSS. Si vous utilisez Redis OSS version 7.0.4 ou supérieure, les I/O, you will get additional acceleration with enhanced I/O multiplexing, where each dedicated network IO thread pipelines commands from multiple clients into the Redis OSS engine, taking advantage of Redis OSS' ability to efficiently process commands in batches. In ElastiCache for Redis OSS v7.1 and above, we extended the enhanced I/O threads functionality to also handle the presentation layer logic. By presentation layer, what we mean is that Enhanced I/O threads améliorés ne se contentent plus de lire les entrées du client, mais aussi de les analyser au format de commande binaire Redis OSS, qui sont ensuite transmises au thread principal pour exécution, ce qui améliore les performances. Pour plus de détails, reportez-vous au [billet de blog](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/) et à la page des [versions prises en charge](VersionManagement.md#supported-engine-versions).
+ Avez-vous des charges de travail qui accèdent régulièrement à un faible pourcentage de leurs données ?
Si tel est le cas et que vous utilisez le moteur Redis OSS version 6.2 ou ultérieure, vous pouvez tirer parti de la hiérarchisation des données en choisissant le type de nœud r6gd. Avec la hiérarchisation des données, les données les moins récemment utilisées sont stockées sur le SSD. Lorsqu’il est récupéré, il y a un faible coût de latence, qui est équilibré par des économies de coûts. Pour de plus amples informations, veuillez consulter [Hiérarchisation des données ElastiCache](data-tiering.md).
Pour de plus amples informations, veuillez consulter [Types de nœuds pris en charge](CacheNodes.SupportedTypes.md).
+ Quelle est la quantité totale de mémoire dont vous avez besoin pour vos données ?
Pour obtenir une estimation générale, prenez la taille des éléments que vous souhaitez mettre en cache. Multipliez cette taille par le nombre d'éléments que vous voulez conserver dans le cache en même temps. Pour obtenir une estimation raisonnable de la taille des éléments, commencez par sérialiser vos éléments de cache, puis comptez les caractères. Divisez ensuite ce nombre sur le nombre de partitions dans votre cluster.
Pour de plus amples informations, veuillez consulter [Types de nœuds pris en charge](CacheNodes.SupportedTypes.md).
+ Quelle version de Redis OSS utilisez-vous ?
Les versions de Redis OSS antérieures à la version 2.8.22 vous obligent à réserver davantage de mémoire pour le basculement, le snapshot, la synchronisation et la promotion d'une réplique vers les opérations principales. En effet, vous devez disposer d'une mémoire suffisante pour toutes les écritures qui se produisent au cours du processus.
Les versions 2.8.22 et ultérieures de Redis OSS utilisent un processus de sauvegarde sans fourche qui nécessite moins de mémoire disponible que le processus précédent.
Pour plus d’informations, consultez les ressources suivantes :
+ [Implémentation de la sauvegarde et de la synchronisation](Replication.Redis.Versions.md)
+ [S'assurer que vous disposez de suffisamment de mémoire pour créer un instantané Valkey ou Redis OSS](BestPractices.BGSAVE.md)
+ S'agit-il d'une application d'écriture intensive ?
Les applications d'écriture intensive nécessitent une plus grande capacité de mémoire disponible, la mémoire non utilisée par les données , lors de la création des instantanés ou d'un basculement. Chaque fois que le processus `BGSAVE` est exécuté, vous devez disposer d'une mémoire suffisante qui n'est pas utilisée par les données pour accueillir toutes les écritures qui se produisent au cours du processus `BGSAVE`. Par exemple, lors de la prise d'un instantané, lors de la synchronisation d'un cluster principal avec un réplica dans un cluster et lors de l'activation de la fonctionnalité de fichier annexe uniquement (AOF). Autre exemple : lors de la promotion d'un réplica en instance principale (si le mode Multi-AZ est activé). Le pire des cas est lorsque toutes vos données sont réécrites pendant le processus. Dans ce cas, vous devez disposer d'une taille d'instance de nœud avec deux fois plus de mémoire que pour les données uniquement.
Pour en savoir plus, consultez [S'assurer que vous disposez de suffisamment de mémoire pour créer un instantané Valkey ou Redis OSS](BestPractices.BGSAVE.md).
+ Votre implémentation sera-t-elle un cluster Valkey ou Redis OSS autonome (mode cluster désactivé), ou un cluster Valkey ou Redis OSS (mode cluster activé) avec plusieurs partitions ?
**Cluster Valkey ou Redis OSS (mode cluster désactivé)**
Si vous implémentez un cluster Valkey ou Redis OSS (mode cluster désactivé), votre type de nœud doit être capable d'accueillir toutes vos données ainsi que la surcharge nécessaire, comme décrit dans le bullet précédent.
Par exemple, supposons que vous estimez que la taille totale de tous vos articles est de 12 Go. Dans ce cas, vous pouvez utiliser un nœud `cache.m3.xlarge` avec 13,3 Go de mémoire ou un nœud `cache.r3.large` avec 13,5 Go de mémoire. Toutefois, vous aurez sans doute besoin de davantage de mémoire pour les opérations `BGSAVE`. Si votre application est très exigeante en matière d'écriture, doublez les besoins en mémoire pour atteindre au moins 24 Go. Utilisez ainsi un `cache.m3.2xlarge` disposant de 27,9 Go de mémoire ou un `cache.r3.xlarge` disposant de 30,5 Go de mémoire.
**Valkey ou Redis OSS (mode cluster activé) avec plusieurs partitions**
Si vous implémentez un cluster Valkey ou Redis OSS (mode cluster activé) avec plusieurs partitions, le type de nœud doit être capable d'accueillir des `bytes-for-data-and-overhead / number-of-shards` octets de données.
Par exemple, supposons que vous estimez la taille totale de tous les éléments à 12 Go et que vous ayez deux partitions. Dans ce cas, vous pouvez utiliser un nœud `cache.m3.large` disposant de 6,05 Go de mémoire (12 Go/2). Toutefois, vous aurez sans doute besoin de davantage de mémoire pour les opérations `BGSAVE`. Si votre application est très exigeante en matière d'écriture, doublez les besoins en mémoire pour atteindre au moins 12 Go par partition. Utilisez ainsi un `cache.m3.xlarge` disposant de 13,3 Go de mémoire ou un `cache.r3.large` disposant de 13,5 Go de mémoire.
+ Utilisez-vous des Local Zones ?
[Les Zones Locales](Local_zones.md) vous permettent de placer des ressources telles qu'un ElastiCache cluster dans plusieurs emplacements proches de vos utilisateurs. Toutefois, lorsque vous choisissez la taille de votre nœud, sachez que les tailles de nœud disponibles sont limitées aux suivantes pour le moment, quelles que soient les exigences de capacité :
+ Génération actuelle :
**Types de nœuds M5 :** `cache.m5.large`, `cache.m5.xlarge`, `cache.m5.2xlarge`, `cache.m5.4xlarge`, `cache.m5.12xlarge`, `cache.m5.24xlarge`
**Types de nœuds R5:** `cache.r5.large`, `cache.r5.xlarge`, `cache.r5.2xlarge`, `cache.r5.4xlarge`, `cache.r5.12xlarge`, `cache.r5.24xlarge`
**Types de nœuds T3 :** `cache.t3.micro`, `cache.t3.small`, `cache.t3.medium`
Pendant que votre cluster est en cours d'exécution, vous pouvez surveiller l'utilisation de la mémoire, l'utilisation du processeur, les accès au cache et les mesures relatives aux erreurs de cache publiées sur CloudWatch. Vous remarquerez peut-être que votre cluster n'a pas le taux de succès souhaité ou que les clés sont expulsées trop souvent. Dans ces cas, vous pouvez choisir une taille de nœud différente avec des spécifications de mémoire et un CPU plus grands.
Lorsque vous surveillez l'utilisation du processeur, n'oubliez pas que Valkey et Redis OSS sont à thread unique. Ainsi, multipliez l'utilisation du CPU signalée par le nombre de cœurs du processeur pour obtenir que l'utilisation réelle. Par exemple, un processeur à quatre cœurs affichant un taux d'utilisation de 20 % est en fait le processeur Redis OSS à un cœur qui fonctionne à 80 % d'utilisation.
## Taille du nœud (Memcached)
Les clusters Memcached contiennent un ou plusieurs nœuds avec les données du cluster partitionnées sur les nœuds. Pour cette raison, les besoins en mémoire du cluster et la mémoire d'un nœud sont liés, mais pas identiques. Vous pouvez atteindre la capacité de mémoire de cluster souhaitée, soit en utilisant un petit nombre de nœuds de grande taille ou plusieurs nœuds de petite taille. En outre, à mesure que vos besoins changent, vous pouvez ajouter des nœuds ou en supprimer du cluster, et donc ne payer que pour ce dont vous avez besoin.
La capacité de mémoire totale de votre cluster est calculée en multipliant le nombre de nœuds du cluster par la capacité de RAM de chaque nœud après déduction de la surcharge du système. La capacité de chaque nœud est basée sur le type de nœud.
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
Le nombre de nœuds de dans le cluster est un facteur clé dans la disponibilité de votre cluster Memcached. La défaillance d'un nœud simple peut avoir un impact sur la disponibilité de votre application et sur la charge de votre base de données backend. Dans ce cas, fournit un ElastiCache remplacement pour un nœud défaillant et celui-ci est repeuplé. Pour réduire cet impact sur la disponibilité, répartissez votre mémoire et votre capacité de calcul sur un plus grand nombre de nœuds de plus petite capacité, plutôt que d'utiliser un plus petit nombre de nœuds de grande capacité.
Dans un scénario où vous avez besoin de 35 Go de mémoire cache, vous pouvez utiliser l'une des configurations suivantes :
+ 11 nœuds `cache.t2.medium` avec 3,22 Go de mémoire et 2 threads chacun = 35,42 Go et 22 threads.
+ 6 nœuds `cache.m4.large` avec 6,42 Go de mémoire et 2 threads chacun = 38,52 Go et 12 threads.
+ 3 nœuds `cache.r4.large` avec 12,3 Go de mémoire et 2 threads chacun = 36,90 Go et 6 threads.
+ 3 nœuds `cache.m4.xlarge` avec 14,28 Go de mémoire et 4 threads chacun = 42,84 Go et 12 threads.
**Comparaison des options de nœuds**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
Ces options permettent d'avoir la même capacité de mémoire, mais une capacité de calcul et un coût différents. Pour comparer les coûts de vos options spécifiques, consultez [Amazon ElastiCache Pricing](https://aws.amazon.com/elasticache/pricing/).
Pour les clusters Memcached, une partie de la mémoire disponible sur chaque nœud de est utilisée pour la surcharge de connexion. Pour plus d'informations, consultez [Surcharge de la connexion Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead)
L'utilisation de plusieurs nœuds nécessitera la répartition des clés sur tous ces nœuds. Chaque nœud a son propre point de terminaison. Pour faciliter la gestion des terminaux, vous pouvez utiliser ElastiCache la fonction Auto Discovery, qui permet aux programmes clients d'identifier automatiquement tous les nœuds d'un cluster. Pour de plus amples informations, veuillez consulter [Identifiez automatiquement les nœuds de votre cluster (Memcached)](AutoDiscovery.md).
Dans certains cas, vous n'êtes peut-être pas certain de la capacité dont vous avez besoin. Si c'est le cas, pour les tests, nous vous recommandons de commencer par un nœud `cache.m5.large`. Surveillez ensuite l'utilisation de la mémoire, l'utilisation du processeur et le taux de réussite du cache à l'aide des ElastiCache métriques publiées sur Amazon CloudWatch. Pour plus d'informations sur CloudWatch les mesures relatives à ElastiCache, voir[Surveillance de l'utilisation à l'aide de CloudWatch métriques](CacheMetrics.md). Pour la production et des charges de travail plus grandes, les nœuds R5 offrent les meilleures performances et valeur de coût de la RAM.
Si votre cluster n'a pas le taux de réussite souhaité, vous pouvez facilement ajouter d'autres nœuds, ce qui accroît la mémoire disponible totale de votre cluster.
Si votre cluster est limité par le CPU mais s'il bénéficie d'un taux de réussite suffisant, essayez de configurer un nouveau cluster avec un type de nœud de qui fournit une plus grande puissance de calcul.
# Création d'un cluster pour Valkey ou Redis OSS
Les exemples suivants montrent comment créer un cluster Valkey ou Redis OSS à l'aide de l'API AWS Management ConsoleAWS CLI et ElastiCache .
## Création d'un système d'exploitation Valkey ou Redis (mode cluster désactivé) (console)
ElastiCache prend en charge la réplication lorsque vous utilisez le moteur Valkey ou Redis OSS. Pour surveiller la latence entre le moment où les données sont écrites dans un cluster read/write principal Valkey ou Redis OSS et le moment où elles sont propagées vers un cluster secondaire en lecture seule, ElastiCache ajoute au cluster une clé spéciale,. `ElastiCacheMasterReplicationTimestamp` Cette clé est le fuseau UTC (temps universel coordonné) actuel. Étant donné qu'un cluster Valkey ou Redis OSS peut être ajouté ultérieurement à un groupe de réplication, cette clé est incluse dans tous les clusters Valkey ou Redis OSS, même s'ils ne sont initialement pas membres d'un groupe de réplication. Pour plus d'informations sur les groupes de réplication, consultez [Haute disponibilité avec les groupes de réplication](Replication.md).
Pour créer un cluster Valkey ou Redis OSS (mode cluster désactivé), suivez les étapes décrites dans. [Création d'un cluster Valkey (mode cluster désactivé) (console)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
Dès que le statut de votre cluster est *disponible*, vous pouvez autoriser Amazon à y EC2 accéder, vous y connecter et commencer à l'utiliser. Pour plus d’informations, consultez [Étape 3. Autoriser l'accès au cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) et [Étape 4 : Connectez-vous au nœud du cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Important**
Dès que votre cluster est disponible, vous êtes facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous ne l'utilisez pas activement. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
## Création d'un cluster Valkey ou Redis OSS (mode cluster activé) (console)
Si vous utilisez Redis OSS 3.2.4 ou version ultérieure, vous pouvez créer un cluster Valkey ou Redis OSS (mode cluster activé). Les clusters Valkey ou Redis OSS (mode cluster activé) prennent en charge le partitionnement de vos données sur 1 à 500 partitions (API/CLI : groupes de nœuds), mais avec certaines limites. Pour une comparaison entre Valkey ou Redis OSS (mode cluster désactivé) et Valkey ou Redis OSS (mode cluster activé), voir. [Moteurs et versions pris en charge](VersionManagement.md#supported-engine-versions)
**Pour créer un cluster Valkey ou Redis OSS (mode cluster activé) à l'aide de la console ElastiCache**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la liste située dans le coin supérieur droit, choisissez la AWS région dans laquelle vous souhaitez lancer ce cluster.
1. Choisissez **Get started** (Mise en route) dans le panneau de navigation.
1. Choisissez **Create VPC** (Créer un VPC) et suivez les étapes décrites à la page [Création d'un cloud privé virtuel (VPC)](VPCs.CreatingVPC.md).
1. Sur la page du tableau de ElastiCache bord, choisissez **Create cluster**, puis **Create Valkey cluster** ou **Create Redis OSS** cluster.
1. Sous **Cluster settings** (Paramètres du cluster), procédez comme suit :
1. Choisissez **Configure and create a new cluster** (Configurer et créer un cluster).
1. Pour **Cluster mode** (Mode cluster), choisissez **Enabled** (Activé).
1. Pour **Cluster info** (Informations sur le cluster), saisissez une valeur pour **Name** (Nom).
1. (Facultatif) Saisissez une valeur pour **Description**.
1. Sous **Location** (Emplacement) :
------
#### [ AWS Cloud ]
1. Pour **AWS Cloud**, nous vous recommandons d'accepter les paramètres par défaut pour **Multi-AZ** et **Auto-failover** (Basculement automatique). Pour plus d'informations, consultez [Minimiser les temps d'arrêt ElastiCache pour Redis OSS avec Multi-AZ](AutoFailover.md).
1. Sous **Cluster settings** (Paramètres de cluster)
1. Pour **Engine version** (Version du moteur), choisissez une version disponible.
1. Pour **Port**, utilisez le port par défaut, 6379. Si vous avez une raison d'utiliser un autre port, saisissez le numéro de port.
1. Pour **Groupe de paramètres**, choisissez un groupe de paramètres ou créez-en un nouveau. Les groupes de paramètres contrôlent les paramètres d'exécution de votre cluster. Pour plus d'informations sur les groupes de paramètres, consultez [Paramètres OSS Valkey et Redis](ParameterGroups.Engine.md#ParameterGroups.Redis) et [Création d'un groupe ElastiCache de paramètres](ParameterGroups.Creating.md).
**Note**
Lorsque vous sélectionnez un groupe de paramètres pour définir les valeurs de configuration du moteur, ce groupe de paramètres est appliqué à tous les clusters du magasin de données global. Dans la page **Parameter Groups (Groupes de paramètres)** l'attribut **Global** yes/no (oui/non) indique si un groupe de paramètres fait partie d'un magasin de données global.
1. Pour **Type de nœud**, choisissez la flèche vers le bas (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). Dans la boîte de dialogue **Modifier le type de nœud** choisissez une valeur pour la **famille d'instances** pour le type de nœud souhaité. Choisissez ensuite le type de nœud que vous souhaitez utiliser pour ce cluster, puis choisissez **Enregistrer**.
Pour de plus amples informations, veuillez consulter [Choix de la taille de votre nœud](CacheNodes.SelectSize.md).
Si vous choisissez un type de nœud r6gd, la hiérarchisation des données est automatiquement activée. Pour de plus amples informations, veuillez consulter [Hiérarchisation des données ElastiCache](data-tiering.md).
1. Pour **Nombre de partitions**, choisissez le nombre de partitions (partitions/groupes de nœuds) que vous souhaitez pour ce cluster Valkey ou Redis OSS (mode cluster activé).
Pour certaines versions de Valkey ou Redis OSS (mode cluster activé), vous pouvez modifier dynamiquement le nombre de partitions de votre cluster :
+ **Redis OSS 3.2.10 et versions ultérieures** : si votre cluster exécute Redis OSS 3.2.10 ou versions ultérieures, vous pouvez modifier le nombre de partitions de votre cluster de manière dynamique. Pour de plus amples informations, veuillez consulter [Mise à l'échelle des clusters Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md).
+ **Autres versions de Redis OSS** — Si votre cluster exécute une version de Redis OSS antérieure à la version 3.2.10, il existe une autre approche. Pour modifier le nombre de fragments dans votre cluster dans ce cas, créez un nouveau cluster avec le nouveau nombre de fragments. Pour de plus amples informations, veuillez consulter [Restauration à partir d’une sauvegarde dans un nouveau cache](backups-restoring.md).
1. Pour **Réplicas par partition**, choisissez le nombre de nœuds de réplica en lecture souhaité dans chaque partition.
Les restrictions suivantes existent pour Valkey ou Redis OSS (mode cluster activé).
+ Si Multi-AZ est activé, assurez-vous d'avoir au moins un réplica par partition.
+ Le nombre de réplicas est le même pour chaque partition lors de la création du cluster à l'aide de la console.
+ Le nombre de réplicas de lecture par partition est fixe et ne peut pas être modifié. Si vous avez besoin de davantage ou de moins de réplicas par partition (API/CLI : groupe de nœuds), vous devez créer un cluster avec le nouveau nombre de réplicas. Pour de plus amples informations, veuillez consulter [Tutoriel : Création d'un nouveau cluster basé sur des nœuds avec une sauvegarde créée en externe](backups-seeding-redis.md).
1. Sous **Connectivity** (Connectivité)
1. Dans **Network type** (Type de réseau), choisissez la ou les versions d'adresses IP que ce cluster prendra en charge.
1. Pour les **groupes de sous-réseaux**, choisissez le sous-réseau que vous souhaitez appliquer à ce cluster. ElastiCache utilise ce groupe de sous-réseaux pour choisir un sous-réseau et les adresses IP de ce sous-réseau à associer à vos nœuds. ElastiCache les clusters nécessitent un sous-réseau à double pile auquel les deux IPv6 adresses sont attribuées pour fonctionner en mode double pile IPv4 et un sous-réseau « uniquement » pour fonctionner en tant que « IPv6 -only ». IPv6
Lorsque vous créez un nouveau groupe de sous-réseaux, entrez le **VPC ID** (ID du VPC) auquel il appartient.
Sélectionnez un **Discovery IP type** (Type d'adresse IP de découverte). Seules les adresses IP du protocole que vous avez choisi sont renvoyées.
Pour en savoir plus, consultez :
+ [Choix d'un type de réseau dans ElastiCache](network-type.md).
+ [Créer un sous-réseau dans votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)
Si vous utilisez [Utilisation de zones locales avec ElastiCache](Local_zones.md), vous devez créer ou choisir un sous-réseau qui se trouve dans la zone locale.
Pour de plus amples informations, veuillez consulter [Sous-réseaux et groupes de sous-réseaux](SubnetGroups.md).
1. Pour **Availability zone placements** (Placement de zones de disponibilité), vous avez deux options :
+ **Aucune préférence** : ElastiCache choisit la zone de disponibilité.
+ **Specify availability zones (Spécifier les zones de disponibilité)** : vous spécifiez la zone de disponibilité pour chaque cluster.
Si vous avez choisi de spécifier les Zones de disponibilité, pour chaque cluster de chaque partition, choisissez la Zone de disponibilité depuis la liste.
Pour de plus amples informations, veuillez consulter [Choix des régions et des zones de disponibilité pour ElastiCache](RegionsAndAZs.md).
1. Choisissez **Next** (Suivant)
1. Sous Paramètres **avancés de Valkey ou Paramètres** **avancés de Redis OSS** ou
1. Pour **Security** (Sécurité) :
1. Pour le chiffrement de vos données, vous avez les options suivantes :
+ **Encryption at rest (Chiffrement au repos)** : active le chiffrement des données stockées sur le disque. Pour de plus amples informations, veuillez consulter [Chiffrement au repos](at-rest-encryption.md).
**Note**
Vous avez la possibilité de fournir une autre clé de chiffrement en choisissant la clé **AWS KMS gérée par le client** et en choisissant la clé. Pour de plus amples informations, veuillez consulter [Utilisation clés AWS KMS gérées par le client](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Encryption in-transit (Chiffrement en transit)** : permet le chiffrement des données sur le câble. Pour de plus amples informations, veuillez consulter [Chiffrement en transit](in-transit-encryption.md). Pour Valkey 7.2 et versions ultérieures ou Redis OSS 6.0 et versions ultérieures, si vous activez le chiffrement en transit, vous serez invité à spécifier l'une des options de contrôle d'**accès** suivantes :
+ **No Access Control (Aucun contrôle d'accès)** – il s'agit du paramètre par défaut. Cela indique qu'aucune restriction n'est imposée à l'accès des utilisateurs au cluster.
+ **User Group Access Control List (Liste de contrôle d'accès au groupe d'utilisateurs)** : choisissez un groupe d'utilisateurs avec un ensemble défini d'utilisateurs pouvant accéder au cluster. Pour de plus amples informations, veuillez consulter [Gestion des groupes d'utilisateurs avec la console et la CLI](Clusters.RBAC.md#User-Groups).
+ **Utilisateur par défaut AUTH** : mécanisme d'authentification pour un serveur Valkey ou Redis OSS. Pour plus d'informations, consultez [AUTH.](auth.md)
+ **AUTH** — Un mécanisme d'authentification pour le serveur Valkey ou Redis OSS. Pour plus d'informations, consultez [AUTH.](auth.md)
**Note**
Pour les versions de Redis OSS supérieures à 3.2.6, à l'exception de la version 3.2.10, AUTH est la seule option.
1. Pour **Groupes de sécurité**, choisissez les groupes de sécurité que vous souhaitez utiliser pour ce cluster. Un *groupe de sécurité* agit comme un pare-feu pour contrôler l'accès réseau à votre cluster. Vous pouvez utiliser le groupe de sécurité par défaut pour votre VPC ou en créer un nouveau.
Pour plus d'informations sur les groupes de sécurité, consultez [Groupes de sécurité pour votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) dans le *Guide de l'utilisateur Amazon VPC*.
1. Pour des sauvegardes automatiques régulières, choisissez **Activer les sauvegardes automatiques**, puis entrez le nombre de jours pendant lesquels vous souhaitez conserver une sauvegarde automatique avant sa suppression automatique. Si vous ne souhaitez pas de sauvegardes automatiques régulières, désactivez la case à cocher **Enable automatic backups**. Dans les deux cas, vous avez toujours la possibilité de créer des sauvegardes manuelles.
Pour plus d'informations sur la sauvegarde et la restauration, consultez[Instantané et restauration](backups.md).
1. (Facultatif) Spécifiez une fenêtre de maintenance. La *fenêtre de maintenance* indique le moment, généralement d'une durée d'une heure, chaque semaine, où ElastiCache planifie la maintenance du système pour votre cluster. Vous pouvez autoriser ElastiCache à choisir le jour et l'heure de la fenêtre de maintenance (*Aucune préférence*) ou vous pouvez choisir vous-même le jour, l'heure et la durée (*Specify maintenance window (Spécifier la fenêtre de maintenance)*). Si vous choisissez *Specify maintenance window*, choisissez dans les listes les valeurs de *Start day*, *Start time* et *Duration* (en heures) pour le créneau de maintenance. Toutes les heures sont exprimées en heures UCT.
Pour de plus amples informations, veuillez consulter [Gestion de la maintenance des ElastiCache clusters](maintenance-window.md).
1. (Facultatif) Pour **Logs (Journaux)** :
+ Sous **Log format (Format de journal)**, sélectionnez **Text (Texte)** ou **JSON**.
+ Sous **Type de destination**, sélectionnez **CloudWatch Logs** ou **Kinesis Firehose**.
+ Sous **Destination du journal**, choisissez **Create new** et entrez le nom de votre groupe de CloudWatch journaux ou le nom de votre stream Firehose, ou choisissez **Select existing**, puis choisissez le nom de votre groupe de journaux de CloudWatch logs ou le nom de votre stream Firehose,
1. Pour les **balises**, pour vous aider à gérer vos clusters et autres ElastiCache ressources, vous pouvez attribuer vos propres métadonnées à chaque ressource sous forme de balises. Pour plus d'informations, consultez [Marquer vos ressources ElastiCache](Tagging-Resources.md).
1. Choisissez **Suivant**.
1. Passez en revue toutes vos entrées et sélections, puis effectuez les corrections nécessaires. Lorsque vous êtes prêt, choisissez **Create** (Créer).
------
#### [ On premises ]
1. Pour **On premises** (Sur site), nous vous recommandons de laisser **Auto-failover** (Basculement automatique) activé. Pour plus d'informations, voir [Minimiser les temps d'arrêt ElastiCache pour Redis OSS avec Multi-AZ](AutoFailover.md)
1. Suivez les étapes décrites dans [Utilisation d'Outposts](ElastiCache-Outposts.md).
------
Pour créer l'équivalent à l'aide de l' ElastiCache API ou à la AWS CLI place de la ElastiCache console, consultez ce qui suit :
+ API : [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI : [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Dès que l'état de votre cluster est *disponible*, vous pouvez autoriser EC2 l'accès à celui-ci, vous y connecter et commencer à l'utiliser. Pour plus d’informations, consultez [Étape 3. Autoriser l'accès au cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) et [Étape 4 : Connectez-vous au nœud du cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Important**
Dès que votre cluster est disponible, vous êtes facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous ne l'utilisez pas activement. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
## Création d'un cluster (AWS CLI)
Pour créer un cluster à l'aide de AWS CLI, utilisez la `create-cache-cluster` commande.
**Important**
Dès que votre cluster est disponible, vous êtes facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous ne l'utilisez pas activement. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
### Création d'un cluster (CLI) Valkey ou Redis OSS (mode cluster désactivé)
**Example — Un cluster Valkey ou Redis OSS (mode cluster désactivé) sans répliques en lecture**
Le code CLI suivant crée un cluster Valkey ou Redis OSS (mode cluster désactivé) sans répliques.
Lors de la création d’un cluster à l’aide d’un type de nœud de la famille r6gd, vous devez passer le paramètre `data-tiering-enabled`.
Pour Linux, macOS ou Unix :
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
Pour Windows :
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### Création d'un cluster Valkey ou Redis OSS (mode cluster activé) ()AWS CLI
Les clusters Valkey ou Redis OSS (mode cluster activé) (API/CLI : groupes de réplication) ne peuvent pas être créés à l'aide de cette opération. `create-cache-cluster` Pour créer un cluster Valkey ou Redis OSS (mode cluster activé) (API/CLI : groupe de réplication), consultez. [Création d'un groupe de réplication Valkey ou Redis OSS (mode cluster activé) à partir de zéro ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
Pour plus d'informations, consultez AWS CLI la rubrique ElastiCache de référence [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
## Création d'un cluster pour Valkey ou Redis OSS (API) ElastiCache
Pour créer un cluster à l'aide de l' ElastiCache API, utilisez l'`CreateCacheCluster`action.
**Important**
Dès que votre cluster est disponible, vous serez facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous l'utilisez pas. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
**Topics**
+ [Création d'un cluster (API) Valkey ou Redis OSS (mode cluster désactivé) ElastiCache](#Clusters.Create.API.Redis)
+ [Création d'un cluster dans Valkey ou Redis OSS (mode cluster activé) (ElastiCache API)](#Clusters.Create.API.RedisCluster)
### Création d'un cluster (API) Valkey ou Redis OSS (mode cluster désactivé) ElastiCache
Le code suivant crée un cluster (ElastiCache API) Valkey ou Redis OSS (mode cluster désactivé).
Des sauts de ligne sont ajoutés pour faciliter la lecture.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### Création d'un cluster dans Valkey ou Redis OSS (mode cluster activé) (ElastiCache API)
Les clusters Valkey ou Redis OSS (mode cluster activé) (API/CLI : groupes de réplication) ne peuvent pas être créés à l'aide de cette opération. `CreateCacheCluster` Pour créer un cluster Valkey ou Redis OSS (mode cluster activé) (API/CLI : groupe de réplication), consultez. [Création d'un groupe de réplication dans Valkey ou Redis OSS (mode cluster activé) à partir de zéro (ElastiCache API)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API)
Pour plus d'informations, consultez la rubrique de référence sur les ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html).
# Création d'un cluster pour Memcached
Les exemples suivants montrent comment créer un cluster à l'aide de AWS Management Console l' ElastiCache API AWS CLI et.
## Création d'un cluster Memcached (console)
Lorsque vous utilisez le moteur Memcached, Amazon ElastiCache prend en charge le partitionnement horizontal de vos données sur plusieurs nœuds. Memcached permet la découverte automatique afin que vous n'avez pas besoin de suivre les points de terminaison de chaque nœud. Memcached suit le point de terminaison de chaque nœud, en mettant à jour la liste des points de terminaison au fur et à mesure que des nœuds sont ajoutés et supprimés. Tout ce dont votre application a besoin pour interagir avec le cluster est le point de terminaison de configuration.
Pour créer un cluster Memcached via la console, suivez les étapes décrites dans [Création d'un cluster Valkey (mode cluster désactivé) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Lorsque vous atteignez l'étape 5, sélectionnez **Créer un cache Memcached**.
Dès que le statut de votre cluster est *disponible*, vous pouvez autoriser Amazon à y EC2 accéder, vous y connecter et commencer à l'utiliser. Pour plus d'informations, consultez les étapes similaires [Étape 3. Autoriser l'accès au cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) et[Étape 4 : Connectez-vous au nœud du cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Important**
Dès que votre cluster est disponible, vous êtes facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous ne l'utilisez pas activement. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
## Création d'un cluster (AWS CLI)
Pour créer un cluster à l'aide de AWS CLI, utilisez la `create-cache-cluster` commande.
**Important**
Dès que votre cluster est disponible, vous êtes facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous ne l'utilisez pas activement. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
### Création d'un cluster de cache Memcached (AWS CLI)
Le code CLI suivant crée un cluster Memcached avec 3 nœuds.
Pour Linux, macOS ou Unix :
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
Pour Windows :
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## Création d'un cluster pour Memcached (API) ElastiCache
Pour créer un cluster à l'aide de l' ElastiCache API, utilisez l'`CreateCacheCluster`action.
**Important**
Dès que votre cluster est disponible, vous serez facturé pour chaque heure ou heure partielle où le cluster est actif, même si vous l'utilisez pas. Pour ne plus être facturé pour ce cluster, vous devez le supprimer. Consultez [Supprimer un cluster dans ElastiCache](Clusters.Delete.md).
**Topics**
+ [Création d'un cluster Memcached (API) ElastiCache](#Clusters.Create.API.Memcached)
### Création d'un cluster Memcached (API) ElastiCache
Le code suivant crée un cluster Memcached avec 3 nœuds (ElastiCache API).
Des sauts de ligne sont ajoutés pour faciliter la lecture.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# Afficher les détails d'un ElastiCache cluster
Vous pouvez afficher des informations détaillées sur un ou plusieurs clusters à l'aide de la ElastiCache console ou de ElastiCache l'API. AWS CLI
## Afficher les détails d'un cluster Memcached (console)
Vous pouvez consulter les détails d'un cluster Memcached à l'aide de la ElastiCache console, du AWS CLI for ElastiCache ou de l' ElastiCache API.
La procédure suivante explique comment afficher les détails d'un cluster Memcached à l'aide de la ElastiCache console.
**Pour afficher les détails d'un cluster Memcached**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la liste en haut à droite, choisissez la AWS région qui vous intéresse.
1. Dans le tableau de bord ElastiCache du moteur, choisissez **Memcached**. Cela affiche une liste de tous vos clusters qui s'exécutent sur le moteur Memcached.
1. Pour voir les détails d'un cluster, choisissez la zone à gauche du nom du cluster.
1. Pour afficher les informations sur les nœuds, choisissez l'onglet **Nodes** (Nœuds) qui affiche des informations sur le statut et le point de terminaison du ou des nœuds.
1. Choisissez l'onglet **Metrics** (Métriques) qui affiche les métriques pertinentes pour tous les nœuds du cluster. Pour de plus amples informations, consultez [Surveillance de l'utilisation à l'aide de CloudWatch métriques](CacheMetrics.md).
1. Choisissez l'onglet **Network and security** (Réseau et sécurité) pour afficher des détails sur la connectivité réseau et la configuration du groupe de sous-réseaux du cluster, ainsi que sur le groupe de sécurité VPC. Pour de plus amples informations, veuillez consulter [Sous-réseaux et groupes de sous-réseaux](SubnetGroups.md).
1. Choisissez l'onglet **Maintenance** pour afficher des détails sur les paramètres de maintenance du cluster. Pour de plus amples informations, veuillez consulter [Gestion de la maintenance des ElastiCache clusters](maintenance-window.md).
1. Choisissez l'onglet **Tags** (Balises) pour afficher des détails sur les balises appliquées aux ressources du cluster. Pour de plus amples informations, veuillez consulter [Marquer vos ressources ElastiCache](Tagging-Resources.md).
## Affichage des détails de Valkey ou Redis OSS (mode cluster désactivé) (console)
Vous pouvez afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster désactivé) à l'aide de la ElastiCache console, du AWS CLI for ElastiCache ou de l' ElastiCache API.
La procédure suivante explique comment afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster désactivé) à l'aide de la ElastiCache console.
**Pour afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster désactivé)**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le tableau de bord ElastiCache du moteur, choisissez **Valkey** ou **Redis OSS** pour afficher la liste de tous vos clusters exécutés sur ce moteur.
1. Pour voir les détails d'un cluster, cochez la case à gauche du nom du cluster. Assurez-vous de sélectionner un cluster exécutant le moteur Valkey ou Redis OSS, et non Clustered Valkey ou Clustered Redis OSS. Cette opération permet d'afficher des détails sur le cluster, y compris son point de terminaison principal.
1. Pour afficher les informations de nœud :
1. Choisissez le nom du cluster.
1. Choisissez l'onglet **Shards and nodes** (Partitions et nœuds). Cette opération permet d'afficher des détails sur chaque nœud, y compris son point de terminaison que vous devez utiliser pour lire le cluster.
1. Choisissez l'onglet **Metrics** (Métriques) qui affiche les métriques pertinentes pour tous les nœuds du cluster. Pour de plus amples informations, consultez [Surveillance de l'utilisation à l'aide de CloudWatch métriques](CacheMetrics.md).
1. Pour afficher les journaux, choisissez l'onglet **Logs** (Journaux) qui indique si le cluster utilise des journaux lents ou des journaux de moteur et fournit des informations pertinentes. Pour de plus amples informations, veuillez consulter [Livraison de journaux](Log_Delivery.md).
1. Choisissez l'onglet **Network and security** (Réseau et sécurité) pour afficher des détails sur la connectivité réseau et la configuration du groupe de sous-réseaux du cluster. Pour de plus amples informations, veuillez consulter [Sous-réseaux et groupes de sous-réseaux](SubnetGroups.md).
1. Choisissez l'onglet **Maintenance** pour afficher des détails sur les paramètres de maintenance du cluster. Pour de plus amples informations, veuillez consulter [Gestion de la maintenance des ElastiCache clusters](maintenance-window.md).
1. Choisissez l'onglet **Service updates** (Mises à jour du service) pour afficher des détails sur les mises à jour de service disponibles, ainsi que leur date limite d'application recommandée. Pour de plus amples informations, veuillez consulter [Mises à jour du service dans ElastiCache](Self-Service-Updates.md).
1. Choisissez l'onglet **Tags** (Balises) pour afficher des détails sur les balises appliquées aux ressources du cluster. Pour de plus amples informations, veuillez consulter [Marquer vos ressources ElastiCache](Tagging-Resources.md).
## Affichage des détails d'un cluster Valkey ou Redis OSS (mode cluster activé) (console)
Vous pouvez afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster activé) à l'aide de la ElastiCache console, du AWS CLI for ElastiCache ou de l' ElastiCache API.
La procédure suivante explique comment afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster activé) à l'aide de la ElastiCache console.
**Pour afficher les détails d'un cluster Valkey ou Redis OSS (mode cluster activé)**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la liste en haut à droite, choisissez la AWS région qui vous intéresse.
1. Dans le tableau de bord ElastiCache du moteur, choisissez **Valkey** ou **Redis OSS** pour afficher la liste de tous vos clusters exécutés sur ce moteur.
1. Pour voir les détails d'un cluster Valkey ou Redis OSS (mode cluster activé), cochez la case à gauche du nom du cluster. Assurez-vous de choisir un cluster exécutant le moteur Valkey ou le moteur Redis OSS en cluster.
L'écran se développe sous le cluster et affiche des détails sur le cluster, y compris le point de terminaison de configuration du cluster.
1. Pour afficher une liste des partitions du cluster et le nombre de nœuds dans chaque partition, choisissez l'onglet **Shards and nodes** (Partitions et nœuds).
1. Pour afficher des informations spécifiques sur un nœud :
1. Choisissez l'ID de partition.
Cela vous permet d'afficher les informations sur chaque nœud, y compris le point de terminaison de chaque nœud que vous devez utiliser pour lire les données du cluster.
1. Choisissez l'onglet **Metrics** (Métriques) qui affiche les métriques pertinentes pour tous les nœuds du cluster. Pour de plus amples informations, consultez [Surveillance de l'utilisation à l'aide de CloudWatch métriques](CacheMetrics.md).
1. Pour afficher les journaux, choisissez l'onglet **Logs** (Journaux) qui indique si le cluster utilise des journaux lents ou des journaux de moteur et fournit des informations pertinentes. Pour de plus amples informations, veuillez consulter [Livraison de journaux](Log_Delivery.md).
1. Choisissez l'onglet **Network and security** (Réseau et sécurité) pour afficher des détails sur la connectivité réseau et la configuration du groupe de sous-réseaux du cluster, le groupe de sécurité VPC et la méthode de chiffrement activée sur le cluster, le cas échéant. Pour plus d’informations, consultez [Sous-réseaux et groupes de sous-réseaux](SubnetGroups.md) et [Sécurité des données sur Amazon ElastiCache](encryption.md).
1. Choisissez l'onglet **Maintenance** pour afficher des détails sur les paramètres de maintenance du cluster. Pour de plus amples informations, veuillez consulter [Gestion de la maintenance des ElastiCache clusters](maintenance-window.md).
1. Choisissez l'onglet **Service updates** (Mises à jour du service) pour afficher des détails sur les mises à jour de service disponibles, ainsi que leur date limite d'application recommandée. Pour de plus amples informations, veuillez consulter [Mises à jour du service dans ElastiCache](Self-Service-Updates.md).
1. Choisissez l'onglet **Tags** (Balises) pour afficher des détails sur les balises appliquées aux ressources du cluster. Pour de plus amples informations, veuillez consulter [Marquer vos ressources ElastiCache](Tagging-Resources.md).
## Afficher les détails d'un ElastiCache cluster (AWS CLI)
Le code suivant répertorie les informations relatives à *my-cluster* :
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
*my-cluster*Remplacez-le par le nom de votre cluster dans le cas où le cluster est créé avec 1 nœud de cache et 0 partition à l'aide de la `create-cache-cluster` commande.
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
Si le cluster est créé à l'aide du AWS Management Console (nœud de cluster activé ou désactivé avec une ou plusieurs partitions), utilisez la commande suivante pour décrire les détails du cluster (remplacez *my-cluster* par le nom du groupe de réplication (nom de votre cluster) :
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
Pour plus d'informations, consultez AWS CLI la ElastiCache rubrique dédiée [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
## Afficher les détails d'un ElastiCache cluster (ElastiCache API)
Vous pouvez consulter les détails d'un cluster à l'aide de l'`DescribeCacheClusters`action ElastiCache API. Si le paramètre `CacheClusterId` est inclus, les détails du cluster spécifié sont retournés. Si le paramètre `CacheClusterId` n'est pas spécifié, les détails de `MaxRecords` clusters maximum (100 par défaut) sont retournés. La valeur de `MaxRecords` ne peut pas être inférieure à 20 ou supérieure à 100.
Le code suivant répertorie les détails de `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Le code suivant affiche les détails de 25 clusters maximum.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Pour plus d'informations, consultez la rubrique de référence sur les ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html).
# Modification d'un ElastiCache cluster
Outre l'ajout ou la suppression de nœuds dans un ElastiCache cluster, il peut arriver que vous deviez apporter d'autres modifications, telles que l'ajout d'un groupe de sécurité, la modification de la fenêtre de maintenance ou d'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 changez les paramètres d'un cluster, le changement est appliqué au cluster immédiatement ou après le redémarrage du cluster. C'est vrai si vous changez le groupe de paramètres même du cluster ou une valeur de paramètre dans le groupe de paramètres du cluster. Pour déterminer à quel moment une modification de paramètre particulière est appliquée, consultez la section **Prise d'effet des modifications** de la colonne **Détails** des tableaux pour [Paramètres spécifiques Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached)et [Paramètres OSS Valkey et Redis](ParameterGroups.Engine.md#ParameterGroups.Redis). Pour plus d'informations sur le redémarrage des nœuds d'un cluster, consultez [Redémarrage des nœuds](nodes.rebooting.md).
## À l'aide du ElastiCache AWS Management Console
**Pour modifier un cluster**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
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 volet de navigation, choisissez le moteur s'exécutant sur le cluster que vous voulez modifier.
Une liste de clusters du moteur choisi s'affiche.
1. Dans la liste des clusters, choisissez le nom du cluster que vous souhaitez modifier.
1. Choisissez **Actions**, puis **Modifier**.
La fenêtre **Modify Cluster** s'affiche.
1. Dans la fenêtre **Modifier un cluster**, effectuez les modifications nécessaires. Les options incluent :
+ Description
+ Mode cluster : pour modifier le mode cluster de **Désactivé** à **Activé**, vous devez d'abord définir le mode cluster sur **Compatible**.
Le mode compatible permet à vos clients Valkey ou Redis OSS de se connecter en utilisant à la fois le mode cluster activé et le mode cluster désactivé. **Après avoir migré tous les clients Valkey ou Redis OSS pour utiliser le mode cluster activé, vous pouvez terminer la configuration du mode cluster et définir le mode cluster sur Activé.**
+ Compatibilité de version de moteur
**Important**
Vous pouvez mettre à niveau vers des versions de moteur plus récentes. Si vous mettez à niveau les versions majeures du moteur, par exemple, de 5.0.6 à 6.0, vous devez sélectionner une famille de groupe de paramètres compatible avec la nouvelle version du moteur. Pour plus d’informations sur la procédure à utiliser, consultez [Gestion des versions pour ElastiCache](VersionManagement.md). Cependant, vous ne pouvez pas mettre à niveau vers des versions antérieures du moteur, sauf en supprimant le cluster existant et en le recréant.
+ Groupes de sécurité VPC
+ Parameter Group
+ 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 plus d’informations, consultez la rubrique [Hiérarchisation des données](data-tiering.md).
+ Multi-AZ
+ Basculement automatique (mode cluster désactivé uniquement)
+ Activer les sauvegardes automatiques
+ ID du nœud de Backup
+ Période de conservation de la sauvegarde
+ Fenêtre de sauvegarde
+ Rubrique pour la notification SNS
+ Compatibilité des versions du moteur Memcached
+ Network type (Type de réseau)
**Note**
Si vous passez de IPv4 à IPv6, vous devez sélectionner ou créer des groupes de sous-réseaux compatibles avec IPv6. Pour de plus amples informations, veuillez consulter [Choix d'un type de réseau dans ElastiCache](network-type.md).
+ Groupes de sécurité VPC
+ Parameter Group
+ Fenêtre de maintenance
+ Rubrique pour la notification SNS
La case **Appliquer immédiatement** s'applique uniquement aux modifications de version du moteur et de type de nœud. Pour appliquer les modifications immédiatement, cochez la case **Apply Immediately (Appliquer immédiatement)**. Si elle n'est pas cochée, les modifications apportées à la version du moteur sont appliquées lors du prochain créneau de maintenance. D'autres modifications, telles que la modification du créneau de maintenance, sont appliquées immédiatement.
**Pour enable/disable enregistrer la livraison pour Redis**
1. Dans la liste des clusters, choisissez le cluster que vous souhaitez augmenter. Cliquez sur l'onglet **Cluster name (Nom du cluster)** et pas la case à cocher à côté.
1. Sur la page des **détails du cluster**, choisissez l'onglet **Logs**.
1. Pour activer ou désactiver les journaux lents, choisissez **Activer** ou **Désactiver**.
Si vous choisissez Enable (Activer) :
1. Sous **Log format** (Format de journal), choisissez **JSON** ou **Text** (Texte).
1. Sous **Type de destination du journal**, sélectionnez **CloudWatch Logs** ou **Kinesis Firehose**.
1. Sous **Destination du journal**, vous pouvez choisir **Create new** et saisir le nom de votre groupe de CloudWatchLogs journaux ou le nom de votre flux Kinesis Data Firehose. Vous pouvez également **sélectionner Select existing**, puis choisir le nom de votre groupe de CloudWatchLogs logs ou le nom de votre flux Kinesis Data Firehose.
1. Sélectionnez **Activer**.
**Pour modifier votre configuration pour Redis, procédez comme suit :**
1. Sélectionnez **Modifier**.
1. Sous **Log format** (Format de journal), choisissez **JSON** ou **Text** (Texte).
1. Sous **Type de destination**, sélectionnez **CloudWatch Logs** ou **Kinesis Firehose**.
1. Sous **Destination du journal**, choisissez **Create new** et entrez le nom de votre groupe de CloudWatchLogs journaux ou le nom de votre flux Kinesis Data Firehose. Vous pouvez également choisir **Select existing**, puis le nom de votre groupe de CloudWatchLogs logs ou le nom de votre flux Kinesis Data Firehose.
## En utilisant le AWS CLI avec ElastiCache
Vous pouvez modifier un cluster existant à l'aide de cette AWS CLI `modify-cache-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.
**Important**
Vous pouvez effectuer une mise à niveau vers de nouvelles versions du moteur Memcached. Pour plus d’informations sur la procédure à utiliser, consultez [Gestion des versions pour ElastiCache](VersionManagement.md). Cependant, vous ne pouvez pas mettre à niveau vers des versions antérieures du moteur, sauf en supprimant le cluster existant et en le recréant.
**Important**
Vous pouvez effectuer une mise à niveau vers les nouvelles versions du moteur Valkey ou Redis OSS. Si vous mettez à niveau les principales versions du moteur, par exemple de Redis OSS 5.0.6 vers Redis OSS 6.0, vous devez sélectionner une famille de groupes de paramètres compatible avec la nouvelle version du moteur. Pour plus d’informations sur la procédure à utiliser, consultez [Gestion des versions pour ElastiCache](VersionManagement.md). Cependant, vous ne pouvez pas mettre à niveau vers des versions antérieures du moteur, sauf en supprimant le cluster existant et en le recréant.
Pour Linux, macOS ou Unix :
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Pour Windows :
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Le paramètre `--apply-immediately` s'applique uniquement à des modifications dans le type de nœud, la version du moteur et aux modifications du nombre de nœuds dans un cluster Si vous souhaitez appliquer une de ces modifications immédiatement, utilisez le paramètre `--apply-immediately`. Si vous préférez l'application de ces modifications au prochain créneau de maintenance, utilisez le paramètre `--no-apply-immediately`. D'autres modifications, telles que la modification du créneau de maintenance, sont appliquées immédiatement.
Pour plus d'informations, consultez AWS CLI la ElastiCache rubrique dédiée [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Utilisation de l' ElastiCache API
Vous pouvez modifier un cluster existant à l'aide de l'`ModifyCacheCluster`opération ElastiCache API. 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.
**Important**
Vous pouvez effectuer une mise à niveau vers de nouvelles versions du moteur Memcached. Pour plus d’informations sur la procédure à utiliser, consultez [Gestion des versions pour ElastiCache](VersionManagement.md). Cependant, vous ne pouvez pas mettre à niveau vers des versions antérieures du moteur, sauf en supprimant le cluster existant et en le recréant.
**Important**
Vous pouvez effectuer une mise à niveau vers les nouvelles versions du moteur Valkey ou Redis OSS. Si vous mettez à niveau les principales versions du moteur, par exemple de Redis OSS 5.0.6 vers Redis OSS 6.0, vous devez sélectionner une famille de groupes de paramètres compatible avec la nouvelle version du moteur. Pour plus d’informations sur la procédure à utiliser, consultez [Gestion des versions pour ElastiCache](VersionManagement.md). Cependant, vous ne pouvez pas mettre à niveau vers des versions antérieures du moteur, sauf en supprimant le cluster existant et en le recréant.
Des sauts de ligne sont ajoutés pour faciliter la lecture.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Le paramètre `ApplyImmediately` s'applique uniquement à des modifications dans le type de nœud, la version du moteur et aux modifications du nombre de nœuds dans un cluster Si vous souhaitez appliquer une de ces modifications immédiatement, définissez le paramètre `ApplyImmediately` sur `true`. Si vous préférez reporter l'application de ces modifications au prochain créneau de maintenance, définissez le paramètre `ApplyImmediately` sur `false`. D'autres modifications, telles que la modification du créneau de maintenance, sont appliquées immédiatement.
Pour plus d'informations, consultez la rubrique de référence sur les ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Ajouter des nœuds à un ElastiCache cluster
L'ajout de nœuds à un cluster Memcached augmente le nombre de partitions de votre cluster. Lorsque vous modifiez le nombre de partitions dans un cluster, vous devez redéfinir le mappage de certains de vos espace de clé afin qu'ils soient mappés avec le nœud adéquat. Le remappage des espaces de clé augmente temporairement le nombre d'échecs d'accès au cache sur le cluster. Pour de plus amples informations, veuillez consulter [Configuration de votre ElastiCache client pour un équilibrage de charge efficace (Memcached)](BestPractices.LoadBalancing.md).
Pour reconfigurer votre cluster Valkey ou Redis OSS (mode cluster activé), voir [Mise à l'échelle des clusters Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md)
Vous pouvez utiliser la console ElastiCache de gestion AWS CLI ou l' ElastiCache API pour ajouter des nœuds à votre cluster.
## À l'aide du ElastiCache AWS Management Console
Si vous souhaitez ajouter un nœud à un cluster Valkey ou Redis OSS (mode cluster désactivé) à nœud unique (un cluster sans réplication activée), il s'agit d'un processus en deux étapes : ajoutez d'abord la réplication, puis ajoutez un nœud de réplique.
**Rubriques**
+ [Pour ajouter une réplication à un cluster Valkey ou Redis OSS sans partitions](#AddReplication.CON)
+ [Pour ajouter des nœuds à un ElastiCache cluster (console)](#AddNode.CON)
La procédure suivante ajoute la réplication à un Valkey ou Redis OSS à nœud unique pour lequel la réplication n'est pas activée. Lorsque vous ajoutez la réplication, le nœud existant devient le nœud principal dans le cluster avec réplication activée. Une fois la réplication ajoutée, vous pouvez ajouter jusqu'à 5 nœuds de réplica au cluster.
**Pour ajouter une réplication à un cluster Valkey ou Redis OSS sans partitions**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, choisissez **Valkey clusters** ou **Redis OSS** clusters.
La liste des clusters exécutant ce moteur s'affiche.
1. Choisissez le nom d'un cluster, pas la case à gauche du nom du cluster, auquel vous souhaitez ajouter des nœuds.
Ce qui suit est vrai pour un cluster Redis OSS dont la réplication n'est pas activée :
+ Il exécute Redis OSS, et non Redis OSS en cluster.
+ Il n'a pas de partitions.
Si le cluster a des partitions, la réplication est déjà activée dessus et vous pouvez continuer sur [Pour ajouter des nœuds à un ElastiCache cluster (console)](#AddNode.CON).
1. Choisissez **Add replication**.
1. Dans **Ajouter une réplication**, entrez une description pour ce cluster avec réplication activée.
1. Choisissez **Ajouter**.
Dès que l'état du cluster retourne à *disponible*, vous pouvez passer à la prochaine procédure et ajouter des réplicas au cluster.
**Pour ajouter des nœuds à un ElastiCache cluster (console)**
La procédure suivante peut être utilisée pour ajouter des nœuds à un cluster.
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, choisissez le moteur s'exécutant sur le cluster auquel vous voulez ajouter des nœuds.
La liste des clusters exécutant le moteur choisi s'affiche.
1. Dans la liste des clusters, choisissez le nom du cluster auquel vous souhaitez ajouter un nœud.
Si votre cluster est un cluster Valkey ou Redis OSS (mode cluster activé), consultez. [Mise à l'échelle des clusters Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md)
Si votre cluster est un cluster Valkey ou Redis OSS (mode cluster désactivé) ne contenant aucune partition, effectuez d'abord les étapes décrites à. [Pour ajouter une réplication à un cluster Valkey ou Redis OSS sans partitions](#AddReplication.CON)
1. Choisissez **Add node** (Ajouter un nœud).
1. Saisissez les informations demandées dans la boîte de dialogue **Add Node (Ajouter un nœud)**.
1. Choisissez le bouton **Apply Immediately - Yes (Appliquer immédiatement - Oui)** pour ajouter ce nœud immédiatement, ou choisissez **No (Non)** pour ajouter ce nœud lors du prochain créneau de maintenance du cluster.
**Impact des nouvelles demandes d'ajout et de suppression sur les demandes en attente**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
Pour déterminer les opérations en attente, choisissez l'onglet **Description** et vérifiez combien de créations ou de suppressions en attente sont affichées. Vous ne pouvez pas avoir à la fois des créations et des suppressions en attente.
1. Choisissez le bouton **Add**.
Au bout de quelques instants, les nouveaux nœuds apparaissent dans la liste des nœuds avec le statut **creating**. S'ils n'apparaissent pas, actualisez la page de votre navigateur. Lorsque l'état du nœud passe à *available* (disponible), le nouveau nœud peut être utilisé.
## En utilisant le AWS CLI avec ElastiCache
Pour ajouter des nœuds à un cluster à l'aide de AWS CLI, utilisez l'AWS CLI opération `modify-cache-cluster` avec les paramètres suivants :
+ `--cache-cluster-id` ID du cluster auquel vous souhaitez ajouter des nœuds.
+ `--num-cache-nodes` Le paramètre `--num-cache-nodes` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification. Pour ajouter des nœuds à ce cluster, `--num-cache-nodes` doit être supérieur au nombre actuel de nœuds dans ce cluster. Si cette valeur est inférieure au nombre actuel de nœuds, ElastiCache attendez-vous à ce que le paramètre `cache-node-ids-to-remove` et une liste de nœuds soient supprimés du cluster. Pour de plus amples informations, veuillez consulter [En utilisant le AWS CLI avec ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI).
+ `--apply-immediately` ou `--no-apply-immediately` qui spécifie s'il convient d'ajouter ces nœuds immédiatement ou lors du prochain créneau de maintenance.
Pour Linux, macOS ou Unix :
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
Pour Windows :
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
Cette opération produit une sortie similaire à la sortie suivante (format JSON) :
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
Pour plus d'informations, consultez la AWS CLI rubrique [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## En utilisant le AWS CLI avec ElastiCache
Si vous souhaitez ajouter des nœuds à un cluster Valkey ou Redis OSS existant (mode cluster désactivé) dont la réplication n'est pas activée, vous devez d'abord créer le groupe de réplication en spécifiant le cluster existant comme principal. Pour de plus amples informations, veuillez consulter [Création d'un groupe de réplication à l'aide d'un cluster Valkey ou Redis OSS disponible ()AWS CLI](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI). Une fois que le groupe de réplication est *disponible*, vous pouvez passer au processus suivant.
Pour ajouter des nœuds à un cluster à l'aide de AWS CLI, utilisez l'AWS CLI opération `increase-replica-count` avec les paramètres suivants :
+ `--replication-group-id` ID du groupe de réplication auquel vous souhaitez ajouter des nœuds.
+ `--new-replica-count` indique le nombre de nœuds que vous souhaitez avoir dans ce groupe de réplication après l'application de la modification. Pour ajouter des nœuds à ce cluster, `--new-replica-count` doit être supérieur au nombre actuel de nœuds dans ce cluster.
+ `--apply-immediately` ou `--no-apply-immediately` qui spécifie s'il convient d'ajouter ces nœuds immédiatement ou lors du prochain créneau de maintenance.
Pour Linux, macOS ou Unix :
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
Pour Windows :
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
Cette opération produit une sortie similaire à la sortie suivante (format JSON) :
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Pour plus d'informations, consultez la AWS CLI rubrique [https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html).
## Utilisation de l' ElastiCache API
Si vous souhaitez ajouter des nœuds à un cluster Valkey ou Redis OSS existant (mode cluster désactivé) dont la réplication n'est pas activée, vous devez d'abord créer le groupe de réplication en spécifiant le cluster existant comme principal. Pour de plus amples informations, veuillez consulter [Ajouter des répliques à un cluster (API) autonome Valkey ou Redis OSS (mode cluster désactivé) ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API). Une fois que le groupe de réplication est *disponible*, vous pouvez passer au processus suivant.
**Pour ajouter des nœuds à un cluster (ElastiCache API)**
+ Appelez l'opération d'API `IncreaseReplicaCount` avec les paramètres suivants :
+ `ReplicationGroupId` ID du cluster auquel vous souhaitez ajouter des nœuds.
+ `NewReplicaCount` Le paramètre `NewReplicaCount` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification. Pour ajouter des nœuds à ce cluster, `NewReplicaCount` doit être supérieur au nombre actuel de nœuds dans ce cluster. Si cette valeur est inférieure au nombre actuel de nœuds, utilisez l'API `DecreaseReplicaCount` avec le nombre de nœuds à retirer du cluster.
+ `ApplyImmediately` spécifie s'il convient d'ajouter ces nœuds immédiatement ou lors du prochain créneau de maintenance.
+ `Region`Spécifie la AWS région du cluster à laquelle vous souhaitez ajouter des nœuds.
L'exemple suivant montre un appel à ajouter des nœuds à un cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Pour plus d'informations, consultez la rubrique ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html).
## Utilisation de l' ElastiCache API
**Pour ajouter des nœuds à un cluster (ElastiCache API)**
+ Appelez l'opération d'API `ModifyCacheCluster` avec les paramètres suivants :
+ `CacheClusterId` ID du cluster auquel vous souhaitez ajouter des nœuds.
+ `NumCacheNodes` Le paramètre `NumCachNodes` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification. Pour ajouter des nœuds à ce cluster, `NumCacheNodes` doit être supérieur au nombre actuel de nœuds dans ce cluster. Si cette valeur est inférieure au nombre actuel de nœuds, ElastiCache attendez-vous à ce que le paramètre `CacheNodeIdsToRemove` contenant une liste de nœuds soit supprimé du cluster (voir[Utilisation de l' ElastiCache API avec Memcached](Clusters.DeleteNode.md#Clusters.DeleteNode.API)).
+ `ApplyImmediately` spécifie s'il convient d'ajouter ces nœuds immédiatement ou lors du prochain créneau de maintenance.
+ `Region`Spécifie la AWS région du cluster à laquelle vous souhaitez ajouter des nœuds.
L'exemple suivant montre un appel à ajouter des nœuds à un cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Pour plus d'informations, consultez la rubrique ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Supprimer des nœuds d'un ElastiCache cluster
Vous pouvez supprimer un nœud d'un cluster Valkey, Memcached ou Redis OSS à l'aide de l'API AWS Management Console, de ou de l'API AWS CLI. ElastiCache
**Note**
Chaque fois que vous modifiez le nombre de nœuds dans un cluster Memcached, vous devez redéfinir le mappage, au minimum, d'une partie de votre espace de clé vers le nœud adéquat. Pour en savoir plus sur l'équilibrage de charge d'un cluster Memcached, consultez [Configuration de votre ElastiCache client pour un équilibrage de charge efficace (Memcached)](BestPractices.LoadBalancing.md).
## En utilisant le ElastiCache AWS Management Console
**Pour supprimer des nœuds d'un cluster (console)**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans la liste située dans le coin supérieur droit, choisissez la AWS région du cluster dont vous souhaitez supprimer des nœuds.
1. Dans le volet de navigation, choisissez le moteur s'exécutant sur le cluster duquel vous voulez supprimer un nœud.
La liste des clusters exécutant le moteur choisi s'affiche.
1. Dans la liste de clusters, choisissez le nom du cluster dans lequel vous souhaitez supprimer un nœud.
Une liste des nœuds du cluster s'affiche.
1. Choisissez la zone de gauche de l'ID de nœud pour le nœud que vous souhaitez supprimer. À l'aide de la console ElastiCache , vous pouvez supprimer un seul nœud à la fois. Par conséquent, la sélection de plusieurs nœuds vous empêche d'utiliser le bouton **Supprimer un nœud**.
La page *Supprimer le nœud* s'affiche.
1. Pour supprimer le nœud, remplissez la page **Supprimer un nœud**, puis choisissez **Supprimer un nœud**. Pour conserver le nœud, choisissez **Annuler**.
**Important**
Avec Valkey ou Redis OSS, si vous supprimez le nœud, le cluster n'est plus compatible avec Multi-AZ, assurez-vous d'abord de décocher la case **Multi-AZ**, puis de supprimer le nœud. Si vous désactivez la case à cocher **Multi-AZ** vous pouvez choisir d'activer le **basculement automatique**.
**Impact des nouvelles demandes d'ajout et de suppression sur les demandes en attente**
| Scénarios | Opérations en suspens | Nouvelle demande | Résultats |
| --- | --- | --- | --- |
| Scénario 1 | Suppression | Suppression | La nouvelle demande de suppression, en attente ou immédiate, remplace la demande de suppression en attente. Par exemple, si les nœuds 0001, 0003 et 0007 sont en attente de suppression et qu'une nouvelle demande de suppression des nœuds 0002 et 0004 est émise, seuls les nœuds 0002 et 0004 seront supprimés. Les nœuds 0001, 0003 et 0007 ne seront pas supprimés. |
| Scénario 2 | Suppression | Créer | La nouvelle demande de création, en attente ou immédiate, remplace la demande de suppression en attente. Par exemple, si les nœuds 0001, 0003 et 0007 sont en attente de suppression et qu'une nouvelle demande de création d'un nœud est émise, un nouveau nœud sera créé et les nœuds 0001, 0003 et 0007 ne seront pas supprimés. |
| Scénario 3 | Créer | Suppression | La nouvelle demande de suppression, en attente ou immédiate, remplace la demande de création en attente. Par exemple, s'il y a une demande en attente de création de deux nœuds et qu'une nouvelle demande est émise pour supprimer le nœud 0003, aucun nouveau nœud ne sera créé et le nœud 0003 sera supprimé. |
| Scénario 4 | Créer | Créer | La nouvelle demande de création est ajoutée à la demande de création en attente. Par exemple, s'il y a une demande en attente pour créer deux nœuds et qu'une nouvelle demande est émise pour créer trois nœuds, les nouvelles demandes sont ajoutées à la demande en attente et cinq nœuds seront créés. Si la nouvelle demande de création est définie sur **Apply Immediately - Yes (Appliquer immédiatement. Oui)**, toutes les demandes de création sont exécutées immédiatement. Si la nouvelle demande de création est définie sur **Apply Immediately - No (Appliquer immédiatement. Non)**, toutes les demandes de création sont en attente. |
Pour déterminer les opérations en attente, choisissez l'onglet **Description** et vérifiez combien de créations ou de suppressions en attente sont affichées. Vous ne pouvez pas avoir à la fois des créations et des suppressions en attente.
## En utilisant le AWS CLI avec ElastiCache
1. Identifiez IDs les nœuds que vous souhaitez supprimer. Pour de plus amples informations, veuillez consulter [Afficher les détails d'un ElastiCache cluster](Clusters.ViewDetails.md).
1. Utilisez l'opération `decrease-replica-count` 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 `decrease-replica-count` avec les paramètres suivants :
+ `--replication-group-id` ID du groupe de réplication auquel vous souhaitez ajouter des nœuds.
+ `--new-replica-count` Le paramètre `--new-replica-count` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification.
+ `--replicas-to-remove`Liste des nœuds IDs que vous souhaitez supprimer de ce cluster.
+ `--apply-immediately` ou `--no-apply-immediately` qui spécifie s'il convient de supprimer ces nœuds immédiatement ou lors du prochain créneau de maintenance.
+ `--region`Spécifie la AWS région du cluster dont vous souhaitez supprimer des nœuds.
**Note**
Vous ne pouvez passer qu'un seul des paramètres `--replicas-to-remove` ou `--new-replica-count` lors de l'appel de cette opération.
Pour Linux, macOS ou Unix :
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
Pour Windows :
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
Cette opération produit une sortie similaire à la sortie suivante (format JSON) :
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Vous pouvez également appeler `decrease-replica-count` et au lieu de passer au paramètre `--new-replica-count`, vous pouvez passer le paramètre `--replicas-to-remove`, comme illustré ci-après :
Pour Linux, macOS ou Unix :
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
Pour Windows :
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
Pour plus d'informations, consultez les AWS CLI rubriques [https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html).
## Utilisation de l' ElastiCache API avec Valkey ou Redis OSS
Pour supprimer des nœuds à l'aide de l' ElastiCache API, appelez l'opération d'`DecreaseReplicaCount`API avec l'ID du groupe de réplication et une liste des nœuds à supprimer, comme indiqué :
+ `ReplicationGroupId` ID du groupe de réplication auquel vous souhaitez ajouter des nœuds.
+ `ReplicasToRemove` Le paramètre `ReplicasToRemove` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification.
+ `ApplyImmediately` spécifie s'il convient de supprimer ces nœuds immédiatement ou lors du prochain créneau de maintenance.
+ `Region`Spécifie la AWS région du cluster dont vous souhaitez supprimer un nœud.
L'exemple suivant supprime immédiatement les nœuds 0004 et 0005 du cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Pour plus d'informations, consultez la rubrique ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html).
## Utilisation de l' ElastiCache API avec Memcached
Pour supprimer des nœuds à l'aide de l' ElastiCache API, appelez l'opération d'`ModifyCacheCluster`API avec l'ID du cluster de cache et une liste des nœuds à supprimer, comme indiqué :
+ `CacheClusterId`ID du cluster dont vous souhaitez supprimer des nœuds.
+ `NumCacheNodes` Le paramètre `NumCacheNodes` spécifie le nombre de nœuds que vous voulez ajouter à ce cluster après application de la modification.
+ `CacheNodeIdsToRemove.member.n`Liste des nœuds IDs à supprimer du cluster.
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` spécifie s'il convient de supprimer ces nœuds immédiatement ou lors du prochain créneau de maintenance.
+ `Region`Spécifie la AWS région du cluster dont vous souhaitez supprimer un nœud.
L'exemple suivant supprime immédiatement les nœuds 0004 et 0005 du cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Pour plus d'informations, consultez la rubrique ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Annulation des opérations d'ajout ou de suppression de nœuds en attente dans ElastiCache
Si vous avez choisi de ne pas appliquer immédiatement une modification au ElastiCache cluster, l'opération est **en attente** jusqu'à ce qu'elle soit effectuée lors de votre prochaine fenêtre de maintenance. Vous pouvez annuler toute opération d'ajout ou de suppression en attente.
Pour annuler une opération d'ajout ou de suppression de nœud en attente avec le AWS CLI, utilisez la `modify-cache-cluster` commande. Définissez un paramètre `num-cache-nodes` égal au nombre actuel de nœuds de cache dans le cluster, puis ajoutez l'`--apply-immediately`indicateur. Cela annulera la modification en attente.
Pour annuler l'ajout ou la suppression d'un nœud en attente :
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
S'il n'est pas clair si des ajouts ou des suppressions de nœuds sont en attente, vous pouvez confirmer leur statut à l'aide de la `describe-cache-clusters` commande suivante :
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
Tous les nœuds en attente doivent apparaître dans la `PendingModifiedValues` sortie. Par exemple :
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# Supprimer un cluster dans ElastiCache
Tant qu'un ElastiCache cluster est *disponible*, il vous est facturé, que vous l'utilisiez activement ou non. Pour ne plus être facturé, supprimez le cluster.
**Avertissement**
Lorsque vous supprimez un ElastiCache cluster, vos instantanés manuels sont conservés. Vous pouvez également créer un instantané final avant la suppression du cluster. Les instantanés mis en cache automatiquement ne sont pas conservés.
## En utilisant le AWS Management Console
La procédure suivante supprime un cluster unique de votre déploiement. Pour supprimer plusieurs clusters, répétez la procédure pour chaque cluster à supprimer. Vous n'avez pas besoin d'attendre la fin de la suppression d'un cluster avant de démarrer la procédure pour en supprimer un autre.
**Pour supprimer un cluster**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le ElastiCache tableau de bord du moteur, choisissez le moteur qui s'exécute dans le cluster que vous souhaitez supprimer.
La liste de tous les clusters exécutant le moteur choisi s'affiche.
1. Pour choisir le cluster à supprimer, choisissez le nom du cluster dans la liste des clusters.
**Important**
Vous ne pouvez supprimer qu'un seul cluster à la fois depuis la ElastiCache console. Le choix de plusieurs clusters désactive l'opération de suppression.
1. Pour **Actions**, choisissez **Supprimer**.
1. Dans l'écran de confirmation **Supprimer le cluster**, choisissez **Supprimer** pour supprimer le cluster ou **Annuler** pour le conserver.
Si vous choisissez **Delete**, le cluster passe à l'état *Suppression en cours*.
Dès que votre cluster n'est plus répertorié dans la liste des clusters, il n'est plus facturé.
## Utilisation du AWS CLI pour supprimer un ElastiCache cluster
Le code suivant supprime le ElastiCache cluster`my-cluster`.
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
L'action `delete-cache-cluster` CLI ne supprime qu'un seul cluster. Pour supprimer plusieurs clusters, appelez `delete-cache-cluster` chaque cluster de cache que vous souhaitez supprimer. Il n'est pas nécessaire d'attendre la fin de la suppression d'un cluster pour en supprimer un autre.
Pour Linux, macOS ou Unix :
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
Pour Windows :
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
Pour plus d'informations, consultez AWS CLI la ElastiCache rubrique dédiée [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html).
## Utilisation de l' ElastiCache API
Le code suivant supprime le cluster `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
L'opération `DeleteCacheCluster` d'API ne supprime qu'un seul cluster. Pour supprimer plusieurs clusters, appelez `DeleteCacheCluster` chaque cluster que vous souhaitez supprimer. Il n'est pas nécessaire d'attendre la fin de la suppression d'un cluster pour en supprimer un autre.
Pour plus d'informations, consultez la rubrique de référence sur les ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html).
# Accès à votre ElastiCache cluster ou à votre groupe de réplication
Vos ElastiCache instances Amazon sont conçues pour être accessibles via une EC2 instance Amazon.
Si vous avez lancé votre ElastiCache instance dans un Amazon Virtual Private Cloud (Amazon VPC), vous pouvez accéder à votre ElastiCache instance depuis une EC2 instance Amazon située dans le même Amazon VPC. Ou bien, en utilisant le peering VPC, vous pouvez accéder à votre ElastiCache instance depuis un Amazon EC2 dans un autre Amazon VPC.
Si vous avez lancé votre ElastiCache instance dans EC2 Classic, vous autorisez l' EC2 instance à accéder à votre cluster en accordant au groupe de EC2 sécurité Amazon associé à l'instance l'accès à votre groupe de sécurité du cache. Par défaut, l'accès au cluster est limité au compte qui a lancé le cluster.
**Topics**
+ [Octroi de l'accès à votre clusterou groupe de réplication](#grant-access)
## Octroi de l'accès à votre clusterou groupe de réplication
### Vous avez lancé votre cluster dans EC2 -VPC
Si vous avez lancé votre cluster dans un Amazon Virtual Private Cloud (Amazon VPC), vous ne pouvez vous ElastiCache y connecter 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.
**Note**
Si vous utilisez les *zones locales (Local Zones)*, assurez-vous que vous les avez activées. Pour de plus amples informations, veuillez consulter [Activation des zones locales](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone). Ce faisant, votre VPC est étendu à cette zone locale et votre VPC traitera le sous-réseau comme n'importe quel sous-réseau dans toute autre zone de disponibilité et les passerelles, tables de routage et autres considérations de groupe de sécurité. sera automatiquement ajusté.
**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, sous **Réseau et sécurité**, choisissez **Groupes de sécurité**.
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é à ElastiCache utiliser, 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 Memcached est **11211** Le port par défaut pour Valkey et Redis OSS est. **6379**
1. Dans le champ **Source**, choisissez **Anywhere** doté d'une plage de ports (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. ElastiCache
**Important**
L'ouverture du ElastiCache cluster à 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. Nous vous recommandons donc de créer un groupe de sécurité VPC qui sera utilisé exclusivement par ElastiCache. 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 ElastiCache cluster.
### Accès aux ElastiCache ressources depuis l'extérieur AWS
Amazon ElastiCache est un AWS service qui fournit un stockage de valeurs clés en mémoire basé sur le cloud. Le service est conçu pour être accessible exclusivement de l'intérieur AWS. Toutefois, si le ElastiCache cluster est hébergé dans un VPC, vous pouvez utiliser une instance de traduction d'adresses réseau (NAT) pour fournir un accès extérieur.
#### Exigences
Les conditions suivantes doivent être remplies pour que vous puissiez accéder à vos ElastiCache ressources depuis l'extérieur AWS :
+ Le cluster doit se trouver dans un VPC et être accessible via une instance de traduction d'adresses réseau (NAT). Cette exigence ne souffre aucune exception.
+ L'instance NAT doit être lancée dans le même VPC que le cluster.
+ L'instance NAT doit être lancée dans un sous-réseau public distinct du cluster.
+ Une adresse IP Elastic (EIP) doit être associée à l'instance NAT. La fonction de réacheminement d'iptables permet de rediriger un port de l'instance NAT vers le port du nœud de cache dans le cadre du VPC.
#### Considérations
N'oubliez pas de prendre en compte les éléments suivants lorsque vous accédez à vos ressources ElastiCache en dehors d' ElastiCache.
+ Les clients se connectent au port EIP et au port cache de l'instance NAT. Le transfert de port sur l'instance NAT transfère le trafic vers le nœud de cluster approprié.
+ Si un nœud de cluster est ajouté ou remplacé, les règles iptables doivent être mises à jour pour prendre en compte ce changement.
#### Limitations
Cette approche doit être utilisée à des fins de test et de développement uniquement. Elle est déconseillée dans le cadre d'une utilisation en production en raison des limitations suivantes :
+ L'instance NAT agit comme un proxy entre les clients et plusieurs clusters. L'ajout d'un proxy a un impact sur les performances du cluster. L'impact augmente avec le nombre de clusters auxquels vous accédez via l'instance NAT.
+ Le trafic depuis les clients vers l'instance NAT n'est pas chiffré. Par conséquent, vous devez éviter d'envoyer des données sensibles via l'instance NAT.
+ L'instance NAT ajoute la surcharge de traitement liée à la maintenance d'une autre instance.
+ L'instance NAT constitue un point de défaillance unique. Pour plus d'informations sur la façon de configurer une solution haute disponibilité des instances NAT sur VPC, veuillez consulter [Solution haute disponibilité des instances NAT sur Amazon VPC : un exemple](https://aws.amazon.com/articles/2781451301784570).
#### Comment accéder aux ElastiCache ressources depuis l'extérieur AWS
La procédure suivante explique comment vous connecter à vos ElastiCache ressources à l'aide d'une instance NAT.
Ces étapes supposent les faits suivants :
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
Vous avez ensuite besoin de l’instance NAT dans le sens opposé :
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
Vous devez également activer le transfert IP, qui est désactivé par défaut :
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ Vous accédez à un cluster Memcached avec les éléments suivants :
+ Adresse IP : *10.0.1.230*
+ Port Memcached par défaut : *11211*
+ Groupe de sécurité : *\$110\$1.0\$1.0\$1.55\$1*
+ Vous accédez à un cluster Valkey ou Redis OSS avec :
+ Adresse IP : *10.0.1.230*
+ Port par défaut : *6379*
+ Groupe de sécurité : *sg-bd56b7da*
+ AWS adresse IP de l'instance — *198.99.100.27*
+ Votre client de confiance a l'adresse IP *198.51.100.27*.
+ Votre instance NAT a l'adresse IP Elastic *203.0.113.73*.
+ Votre instance NAT a le groupe de sécurité *sg-ce56b7a9*.
**Pour vous connecter à vos ElastiCache ressources à l'aide d'une instance NAT**
1. Créez une instance NAT dans le même VPC que votre cluster mais dans un sous-réseau public.
Par défaut, l'assistant VPC lancera un type de nœud *cache.m1.small*. Vous devez sélectionner une taille de nœud selon vos besoins. Vous devez utiliser l'AMI EC2 NAT pour pouvoir y accéder ElastiCache depuis l'extérieur AWS.
Pour plus d'informations sur la création d'une instance NAT, consultez la section [Instances NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html) dans le guide de l'utilisateur AWS VPC.
1. Créez des règles de groupe de sécurité pour le cluster et l'instance NAT.
Le groupe de sécurité de l’instance NAT et l’instance de cluster doivent avoir les règles suivantes :
+ Deux règles de trafic entrant
+ Avec Memcached, la première règle est d'autoriser les connexions TCP des clients de confiance à chaque port de cache transféré depuis l'instance NAT (11211 - 11213).
+ Avec Valkey et Redis OSS, la première règle est d'autoriser les connexions TCP des clients de confiance à chaque port de cache transféré depuis l'instance NAT (6379 - 6381).
+ Une deuxième règle pour autoriser l'accès SSH aux clients de confiance.
**Groupe de sécurité d'instances NAT - règles entrantes avec Memcached**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**Groupe de sécurité d'instances NAT : règles entrantes avec Valkey ou Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Avec Memcached, une règle sortante autorisant les connexions TCP au port de cache (11211).
**Groupe de sécurité de l’instance NAT - Règle de trafic sortant**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Avec Valkey ou Redis OSS, une règle sortante permettant aux connexions TCP d'accéder au port de cache (6379).
**Groupe de sécurité de l’instance NAT - Règle de trafic sortant**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Avec Memcached, règle entrante pour le groupe de sécurité du cluster qui autorise les connexions TCP entre l'instance NAT et le port de cache (11211).
**Groupe de sécurité de l’instance de cluster - Règle de trafic entrant**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Avec Valkey ou Redis OSS, règle entrante pour le groupe de sécurité du cluster qui autorise les connexions TCP entre l'instance NAT et le port de cache (6379).
**Groupe de sécurité de l’instance de cluster - Règle de trafic entrant**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. Validez les règles.
+ Vérifiez que le client de confiance peut accéder à l'instance NAT via SSH.
+ Vérifiez que le client de confiance peut se connecter au cluster à partir de l'instance NAT.
1. **Memcached**
Ajoutez une règle iptables à l'instance NAT.
Une règle iptables doit être ajoutée à la table NAT pour chaque nœud dans le cluster pour rediriger le port de cache depuis l'instance NAT vers le nœud de cluster. Voici un exemple possible :
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
Le numéro de port doit être unique pour chaque nœud du cluster. Par exemple, si vous utilisez un cluster de Memcached de trois nœuds avec les ports 11211 – 11213, les règles devraient se présenter comme suit :
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
Vérifiez que le client de confiance peut se connecter au cluster.
Le client de confiance doit se connecter à l'EIP associée à l'instance NAT et au port de cluster correspondant au nœud de cluster approprié. Par exemple, la chaîne de connexion pour PHP pourrait ressembler à ce qui suit :
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
Un client Telnet peut également être utilisé pour vérifier la connexion. Par exemple :
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Valkey ou Redis OSS**
Ajoutez une règle iptables à l'instance NAT.
Une règle iptables doit être ajoutée à la table NAT pour chaque nœud dans le cluster pour rediriger le port de cache depuis l'instance NAT vers le nœud de cluster. Voici un exemple possible :
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
Le numéro de port doit être unique pour chaque nœud du cluster. Par exemple, si vous travaillez avec un cluster Redis OSS à trois nœuds utilisant les ports 6379 à 6381, les règles seront les suivantes :
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
Vérifiez que le client de confiance peut se connecter au cluster.
Le client de confiance doit se connecter à l'EIP associée à l'instance NAT et au port de cluster correspondant au nœud de cluster approprié. Par exemple, la chaîne de connexion pour PHP pourrait ressembler à ce qui suit :
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
Un client Telnet peut également être utilisé pour vérifier la connexion. Par exemple :
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. Enregistrez la configuration iptables.
Enregistrez les règles après les avoir testées et vérifiées. Si vous utilisez une distribution Linux basée sur Redhat (comme Amazon Linux), exécutez la commande suivante :
```
service iptables save
```
#### Rubriques en relation
Les rubriques suivantes sont susceptibles de vous intéresser.
+ [Modèles d'accès pour accéder à un ElastiCache cache dans un Amazon VPC](elasticache-vpc-accessing.md)
+ [Accès à un ElastiCache cache depuis une application exécutée dans le centre de données d'un client](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [Instances NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [Configuration des ElastiCache clients](ClientConfig.md)
+ [Solution haute disponibilité des instances NAT sur Amazon VPC : un exemple](https://aws.amazon.com/articles/2781451301784570)
# Recherche de points de terminaison de connexion dans ElastiCache
Votre application se connecte à votre ElastiCache cluster à l'aide de points de terminaison. Un point de terminaison est l'adresse unique d'un nœud ou d'un cluster.
Vous pouvez également établir une connexion privée entre votre VPC et les points de terminaison d' ElastiCache API en créant un point de terminaison VPC d'interface via. AWS PrivateLink Pour de plus amples informations, veuillez consulter [ElastiCache Points de terminaison VPC de l'API et de l'interface ()AWS PrivateLink](elasticache-privatelink.md).
**Quels points de terminaison utiliser avec Valkey ou Redis OSS.**
+ Pour un **nœud autonome**, utilisez le point de terminaison du nœud pour les opérations de lecture et d'écriture.
+ Pour les **clusters Valkey, Valkey ou Redis OSS (mode cluster désactivé)**, utilisez le point de *terminaison principal* pour toutes les opérations d'écriture. Utilisez le *Point de terminaison du lecteur* pour répartir également les connexions entrantes vers le point de terminaison entre toutes les réplicas lues. Utilisez les *points de terminaison de nœud* individuels pour les opérations d'écriture (dans l'API/la CLI, ils sont appelés points de terminaison de lecture).
+ Pour les **clusters Valkey ou Redis OSS (mode cluster activé)**, utilisez le point de *terminaison de configuration* du cluster pour toutes les opérations prenant en charge les commandes activées en mode cluster. Vous devez utiliser un client qui prend en charge Valkey Cluster ou Redis OSS Cluster sur Redis OSS 3.2 et versions ultérieures. Vous pouvez toujours lire à partir des points de terminaison de nœuds individuels (ils API/CLI sont appelés points de terminaison de lecture).
Les sections suivantes vous guident à travers la découverte de points de terminaison dont vous aurez besoin pour le moteur utilisé.
**Quels points de terminaison utiliser avec Memcached.**
Pour le **cache ElastiCache sans serveur pour Memcached**, il suffit d'acquérir le DNS et le port du point de terminaison du cluster depuis la console.
À partir du AWS CLI, utilisez la `describe-serverless-caches` commande pour obtenir les informations du point de terminaison.
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Le résultat de l’opération ci-dessus doit ressembler à cet exemple (format JSON) :
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
Pour un **cluster Memcached basé sur une instance**, si vous utilisez Automatic Discovery, vous pouvez utiliser le point de *terminaison de configuration* du cluster pour configurer votre client Memcached. Cela signifie que vous devez utiliser un client qui prend en charge la découverte automatique.
Si vous n'utilisez pas la découverte automatique, vous devez configurer votre client pour utiliser les points de terminaison des nœuds individuels pour les lectures et écritures. Vous devez également garder des traces de ces dernières lorsque vous ajoutez ou supprimez des nœuds.
## Trouver les points de terminaison d'un cluster Valkey ou Redis OSS (mode cluster désactivé) (console)
Si un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé) ne possède qu'un seul nœud, le point de terminaison du nœud est utilisé à la fois pour les lectures et les écritures. *Si un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé) possède plusieurs nœuds, il existe trois types de points de terminaison : le point de *terminaison principal, le point de terminaison* du *lecteur et les points de terminaison* du nœud.*
Le point de terminaison principal est un nom DNS qui est toujours résolu dans le nœud principal du cluster. Le point de terminaison principal n'est pas affecté par les changements apportés à votre cluster, tels que la promotion d'un réplica en lecture au rang de réplica principal. Pour l'activité d'écriture, il est préférable que vos applications se connectent au point de terminaison principal.
Un point de terminaison de lecteur répartira de manière égale les connexions entrantes vers le point de terminaison entre toutes les répliques de lecture ElastiCache d'un cluster Redis OSS. Des facteurs supplémentaires, comme le moment où l'application crée les connexions ou la façon dont l'application utilise ou réutilise les connexions, détermineront la distribution du trafic. Les points de terminaison du lecteur suivent les changements de cluster en temps réel au fur et à mesure que des réplicas sont ajoutés ou supprimés. Vous pouvez placer ElastiCache les multiples répliques de lecture de votre cluster Redis OSS dans différentes zones de AWS disponibilité (AZ) afin de garantir la haute disponibilité des points de terminaison des lecteurs.
**Note**
Un point de terminaison du lecteur n'est pas un équilibreur de charge. Il s'agit d'un enregistrement DNS qui se résoudra à une adresse IP de l'un des nœuds de réplica en mode round robin.
Pour l'activité de lecture, les applications peuvent également se connecter à n'importe quel nœud du cluster. Contrairement au point de terminaison principal, les points de terminaison des nœuds sont résolus dans des points de terminaison spécifiques. En cas de modification dans votre cluster, comme l'ajout ou la suppression d'un réplica, vous devez mettre à jour les points de terminaison des nœuds de votre application.
**Pour rechercher les points de terminaison d'un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé)**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, choisissez **Valkey clusters** ou **Redis OSS** clusters.
L'écran des clusters apparaîtra avec une liste de clusters Valkey, Valkey ou Redis OSS (mode cluster désactivé) et Valkey ou Redis OSS (mode cluster activé).
1. Pour trouver les points de terminaison du and/or lecteur principal du cluster, choisissez le nom du cluster (et non le bouton à gauche).
![\[Image : point de terminaison principal pour un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé)\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Points de terminaison principaux et lecteurs pour un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé)*
S'il y a un seul nœud dans le cluster, il n'y a aucun point de terminaison principal et vous pouvez passer à l'étape suivante.
1. **Si le cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé) possède des nœuds de réplication, vous pouvez trouver les points de terminaison des nœuds de réplication du cluster en choisissant le nom du cluster, puis en choisissant l'onglet Nœuds.**
L'écran des nœuds s'affiche avec chaque nœud du cluster, principal et de réplica, répertorié avec son point de terminaison.
![\[Image : points de terminaison de nœuds pour un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé)\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Points de terminaison de nœuds pour un cluster Valkey, Valkey ou Redis OSS (mode cluster désactivé)*
1. Pour copier un point de terminaison dans le presse-papiers :
1. Un point de terminaison à la fois, recherchez le point de terminaison que vous souhaitez copier.
1. Cliquez sur l'icône de copie située juste devant le point de terminaison.
Le point de terminaison est maintenant copié dans votre presse-papiers. Pour en savoir plus sur l’utilisation du point de terminaison pour se connecter à un nœud, consultez [Connexion aux nœuds Memcached](nodes-connecting.md#nodes-connecting.mem).
Un point de terminaison principal Valkey, Valkey ou Redis OSS (mode cluster désactivé) ressemble à ce qui suit. Il existe une différence selon que le chiffrement en transit est activé ou pas.
**Chiffrement en transit non activé**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**Chiffrement en transit activé**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## Recherche de points de terminaison pour un cluster Valkey ou Redis OSS (mode cluster activé) (console)
Un cluster Valkey ou Redis OSS (mode cluster activé) possède un point de terminaison de configuration unique. En se connectant au point de terminaison de configuration, votre application est en mesure de découvrir les points de terminaison principal et de lecture pour chaque partition du cluster.
**Pour trouver le point de terminaison d'un cluster Valkey ou Redis OSS (mode cluster activé)**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, choisissez **Valkey clusters** ou **Redis OSS** clusters.
L'écran des clusters apparaîtra avec une liste de clusters. Choisissez le cluster auquel vous souhaitez vous connecter.
1. Pour rechercher le point de terminaison de la configuration du cluster, choisissez le nom du cluster (et non le bouton radio).
1. Le **Configuration endpoint** (point de terminaison de la configuration) est affiché sous **Cluster details** (Détails du cluster). Pour le copier, choisissez l'icône de *copie* à gauche du point de terminaison.
## Trouver les points de terminaison d'un cluster (console) (Memcached)
Tous les points de terminaison Memcached sont des points de terminaison. read/write Pour vous connecter aux nœuds dans un cluster Memcached, votre application peut utiliser les points de terminaison de chaque nœud ou le point de terminaison de configuration du cluster avec la découverte automatique. Pour utiliser la découverte automatique, vous devez avoir recours à un client qui prend en charge la découverte automatique.
Lorsque vous utilisez la découverte automatique, votre application client se connecte à votre cluster Memcached en utilisant le point de terminaison de configuration. Lorsque vous redimensionnez votre cluster en ajoutant ou supprimant des nœuds, votre application « connaîtra » automatiquement tous les nœuds du cluster et sera en mesure de se connecter à l'un d'eux. Sans la fonction de découverte automatique, votre application devra faire cela ou vous devrez mettre à jour manuellement les points de terminaison de votre application après chaque ajout ou suppression d'un nœud.
Pour copier un point de terminaison, cliquez sur l'icône de copie située juste devant l'adresse du point de terminaison. Pour en savoir plus sur l’utilisation du point de terminaison pour se connecter à un nœud, consultez [Connexion aux nœuds Memcached](nodes-connecting.md#nodes-connecting.mem).
La configuration et les points de terminaison des nœuds sont très similaires. Les différences sont mises en évidence en **gras** comme suit.
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**Important**
Si vous choisissez de créer un enregistrement CNAME pour votre point de terminaison de configuration Memcached, afin que votre client de découverte automatique reconnaisse l'enregistrement CNAME comme point de terminaison de configuration, vous devez inclure `.cfg.` dans le CNAME.
## Recherche des points de terminaison (AWS CLI)
Pour Memcached, vous pouvez utiliser le for AWS CLI Amazon ElastiCache pour découvrir les points de terminaison des nœuds et des clusters.
Pour Redis OSS, vous pouvez utiliser le AWS CLI for Amazon ElastiCache pour découvrir les points de terminaison des nœuds, des clusters et également des groupes de réplication.
**Topics**
+ [Recherche des points de terminaison des nœuds et des clusters (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Recherche des points de terminaison pour les groupes de réplication Valkey ou Redis OSS ()AWS CLI](#Endpoints.Find.CLI.ReplGroups)
### Recherche des points de terminaison des nœuds et des clusters (AWS CLI)
Vous pouvez utiliser le AWS CLI pour découvrir les points de terminaison d'un cluster et de ses nœuds à l'aide de la `describe-cache-clusters` commande. Pour les clusters Valkey ou Redis OSS, la commande renvoie le point de terminaison du cluster. Pour les clusters Memcached, la commande renvoie le point de terminaison de configuration. Si vous ajoutez le paramètre facultatif `--show-cache-node-info`, la commande renvoie également les points de terminaison de chaque nœud figurant dans le cluster.
**Example**
La commande suivante extrait le point de terminaison de configuration (`ConfigurationEndpoint`) et les points de terminaison des nœuds individuels (`Endpoint`) pour le cluster Memcached *mycluster*.
Pour Linux, macOS ou Unix :
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Pour Windows :
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Le résultat de l'opération ci-dessus doit ressembler à cet exemple (format JSON).
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
Si vous choisissez de créer un enregistrement CNAME pour votre point de terminaison de configuration Memcached, afin que votre client de découverte automatique reconnaisse l'enregistrement CNAME comme point de terminaison de configuration, vous devez inclure `.cfg.` dans le CNAME. Par exemple, `mycluster.cfg.local` dans votre fichier php.ini pour le paramètre `session.save_path`.
**Example**
*Pour Valkey et Redis OSS, la commande suivante récupère les informations de cluster pour le cluster à nœud unique mycluster.*
Le paramètre `--cache-cluster-id` peut être utilisé avec un identifiant de cluster Valkey ou Redis OSS (mode cluster désactivé) à nœud unique ou des identifiants de nœud spécifiques dans les groupes de réplication. Le `--cache-cluster-id` d'un groupe de réplication est une valeur à 4 chiffres telle que`0001`. S'il s'`--cache-cluster-id`agit de l'identifiant d'un cluster (nœud) dans un groupe de réplication, `replication-group-id` il est inclus dans la sortie.
Pour Linux, macOS ou Unix :
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
Pour Windows :
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
Le résultat de l'opération ci-dessus doit ressembler à cet exemple (format JSON).
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
Pour de plus amples informations, consultez la rubrique [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
### Recherche des points de terminaison pour les groupes de réplication Valkey ou Redis OSS ()AWS CLI
Vous pouvez utiliser le AWS CLI pour découvrir les points de terminaison d'un groupe de réplication et de ses clusters à l'aide de la `describe-replication-groups` commande. La commande renvoie le point de terminaison principal du groupe de réplication et une liste de tous les clusters (nœuds) figurant dans le groupe de réplication avec leurs points de terminaison et avec le point de terminaison du lecteur.
L'opération suivante extrait le point de terminaison principal et les points de terminaison du lecteur pour le groupe de réplication `myreplgroup`. Utilisez le point de terminaison principal pour toutes les opérations d'écriture.
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
Pour Windows :
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
Le résultat de cette opération doit ressembler à cet exemple (format JSON).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
Pour plus d’informations, consultez [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) dans la *Référence des commandes de l’AWS CLI *.
## Recherche de points de terminaison (ElastiCache API)
Pour Memcached, vous pouvez utiliser l' ElastiCache API Amazon pour découvrir les points de terminaison des nœuds et des clusters.
Pour Redis OSS, vous pouvez utiliser l' ElastiCache API Amazon pour découvrir les points de terminaison des nœuds, des clusters et des groupes de réplication.
**Topics**
+ [Recherche de points de terminaison pour les nœuds et les clusters (ElastiCache API)](#Endpoints.Find.API.Nodes)
+ [Recherche de points de terminaison pour les groupes de réplication (API) Valkey ou Redis OSS ElastiCache](#Endpoints.Find.API.ReplGroups)
### Recherche de points de terminaison pour les nœuds et les clusters (ElastiCache API)
Vous pouvez utiliser l' ElastiCache API pour découvrir les points de terminaison d'un cluster et de ses nœuds grâce à l'`DescribeCacheClusters`action. Pour les clusters Valkey ou Redis OSS, la commande renvoie le point de terminaison du cluster. Pour les clusters Memcached, la commande renvoie le point de terminaison de configuration. Si vous ajoutez le paramètre facultatif `ShowCacheNodeInfo`, l'action renvoie également les points de terminaison de chaque nœud figurant dans le cluster.
**Example**
*Pour Memcached, la commande suivante récupère le point de terminaison de configuration (`ConfigurationEndpoint`) et les points de terminaison des nœuds individuels (`Endpoint`) pour le cluster Memcached mycluster.*
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Si vous choisissez de créer un enregistrement CNAME pour votre point de terminaison de configuration Memcached, afin que votre client de découverte automatique reconnaisse l'enregistrement CNAME comme point de terminaison de configuration, vous devez inclure `.cfg.` dans le CNAME. Par exemple, `mycluster.cfg.local` dans votre fichier php.ini pour le paramètre `session.save_path`.
### Recherche de points de terminaison pour les groupes de réplication (API) Valkey ou Redis OSS ElastiCache
Vous pouvez utiliser l' ElastiCache API pour découvrir les points de terminaison d'un groupe de réplication et de ses clusters grâce à l'`DescribeReplicationGroups`action. L'action renvoie le point de terminaison principal du groupe de réplication et une liste de tous les clusters figurant dans le groupe de réplication avec le point de terminaison du lecteur.
L'opération suivante permet de récupérer le point de terminaison principal (PrimaryEndpoint), le point de terminaison du lecteur (ReaderEndpoint) et les points de terminaison des nœuds individuels (ReadEndpoint) pour le groupe de réplication. `myreplgroup` Utilisez le point de terminaison principal pour toutes les opérations d'écriture.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Pour de plus amples informations, veuillez consulter [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Utilisation de fragments dans ElastiCache
Un shard (API/CLI : groupe de nœuds) est une collection de un à six nœuds Valkey ou ElastiCache Redis OSS. Un cluster Valkey ou Redis OSS (mode cluster désactivé) ne comportera jamais plus d'une partition. Avec les partitions, vous pouvez séparer les grandes bases de données en parties plus petites, plus rapides et plus faciles à gérer, appelées fragments de données. Cela peut améliorer l'efficacité de la base de données en répartissant les opérations entre plusieurs sections distinctes. L'utilisation de partitions peut offrir de nombreux avantages, notamment une amélioration des performances, de l'évolutivité et de la rentabilité.
Vous pouvez créer un cluster contenant un nombre de partitions supérieur et un nombre de réplicas inférieur, qui conduisent à un nombre total de 90 nœuds par cluster. Cette configuration de cluster peut contenir de 90 partitions avec 0 réplica à 15 partitions avec 5 réplicas, ce qui correspond au nombre maximal de réplicas autorisé. 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.
La limite de nœuds ou de partitions peut être augmentée jusqu'à un maximum de 500 par cluster si la version du moteur est Valkey 7.2 ou supérieure, ou Redis OSS 5.0.6 à 7.1. Par exemple, vous pouvez choisir de configurer un cluster de 500 nœuds compris entre 83 (un principal et 5 réplicas par partition) et 500 partitions (un principal et aucun réplicas). Assurez-vous qu’il y ait suffisamment d’adresses IP disponibles pour faire face à l’augmentation. Les pièges courants incluent les sous-réseaux du groupe de sous-réseaux avec une plage CIDR trop petite ou les sous-réseaux partagés et fortement utilisés par d’autres clusters. Pour de plus amples informations, veuillez consulter [Création d'un groupe de sous-réseaux](SubnetGroups.Creating.md).
Pour les versions antérieures à 5.0.6, la limite est de 250 par cluster.
Pour demander une augmentation de cette limite, veuillez consulter [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) et sélectionnez le type de limite **Nœuds par cluster par type d'instance**.
Lorsque vous créez un cluster Valkey ou Redis OSS (mode cluster activé) à l'aide de la ElastiCache 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 Valkey ou Redis OSS (mode cluster activé) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Si vous utilisez l' ElastiCache API ou AWS CLI pour créer un cluster (appelé groupe de *réplication dans le groupe* de nœuds API/CLI), you can configure the number of nodes in a shard (API/CLI :) de manière indépendante. Pour plus d’informations, consultez les ressources suivantes :
+ API : [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI : [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Chaque nœud de partition possède les mêmes spécifications de calcul, de stockage et de mémoire. L' ElastiCache API vous permet de contrôler les attributs à l'échelle de la partition, tels que le nombre de nœuds, les paramètres de sécurité et les fenêtres de maintenance du système.
![\[Image : configurations de partition Valkey ou Redis OSS.\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Configurations de partage Valkey ou Redis OSS*
Pour plus d’informations, consultez [Repartage hors ligne pour Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline) et [Repartage en ligne pour Valkey ou Redis OSS (mode cluster activé)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online).
## Recherche de l'ID d'une partition
Vous pouvez trouver l'ID d'une partition à l'aide de l'API AWS Management Console, de AWS CLI ou de l' ElastiCache API.
### À l'aide du AWS Management Console
**Topics**
+ [Pour Valkey ou Redis OSS (mode cluster désactivé)](#shard-find-id-con-classic)
+ [Pour Valkey ou Redis OSS (mode cluster activé)](#shard-find-id-con-cluster)
#### Pour Valkey ou Redis OSS (mode cluster désactivé)
Les partitions du groupe de réplication Valkey ou Redis OSS (mode cluster désactivé) le sont toujours IDs . `0001`
#### Pour Valkey ou Redis OSS (mode cluster activé)
La procédure suivante utilise le AWS Management Console pour rechercher l'ID de partition d'un groupe de réplication Valkey ou Redis OSS (mode cluster activé).
**Pour trouver l'ID de partition dans un groupe de réplication Valkey ou Redis OSS (mode cluster activé)**
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation, choisissez **Valkey** ou **Redis OSS**, puis le nom du groupe de réplication Valkey ou Redis OSS (mode cluster activé) pour lequel vous souhaitez rechercher le shard. IDs
1. Dans la colonne **Shard Name (Nom de la partition)**, l'ID de la partition correspond aux quatre derniers chiffres du nom de la partition.
### À l'aide du AWS CLI
Pour trouver les identifiants de partition (groupe de nœuds) pour les groupes de réplication Valkey ou Redis OSS (mode cluster désactivé) ou Valkey ou Redis OSS (mode cluster activé), utilisez l' AWS CLI opération `describe-replication-groups` avec le paramètre facultatif suivant.
+ **`--replication-group-id`** – paramètre facultatif qui, lorsqu'il est utilisé, limite la sortie aux informations correspondant au groupe de réplication spécifié. Si ce paramètre n'est pas utilisé, vous obtenez les informations relatives à 100 groupes de réplication maximum.
**Example**
Cette commande renvoie les informations relatives à `sample-repl-group`.
Pour Linux, macOS ou Unix :
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
Pour Windows :
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
Le résultat de cette commande ressemble à ceci. Les identifiants de shard (groupe de nœuds) sont *highlighted* là pour faciliter leur recherche.
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### Utilisation de l' ElastiCache API
Pour trouver les identifiants de partition (groupe de nœuds) pour les groupes de réplication Valkey ou Redis OSS (mode cluster désactivé) ou Valkey ou Redis OSS (mode cluster activé), utilisez l' AWS CLI opération `describe-replication-groups` avec le paramètre facultatif suivant.
+ **`ReplicationGroupId`** : paramètre facultatif qui, lorsqu'il est utilisé, limite la sortie aux informations correspondant au groupe de réplication spécifié. Si ce paramètre est omis, les détails d'un maximum de groupes de *xxx* réplication sont renvoyés.
**Example**
Cette commande renvoie les informations relatives à `sample-repl-group`.
Pour Linux, macOS ou Unix :
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```