Gestion de Cluster Redis : Initialisation, Nœuds, Santé et Resharding

Introduction

Dans ce laboratoire, vous apprendrez à gérer un cluster Redis. Le laboratoire se concentre sur les tâches essentielles de gestion de cluster, notamment l'initialisation d'un cluster, l'ajout de nœuds, la vérification de l'état du cluster et le repartitionnement (resharding) des slots.

Nous commencerons par initialiser un cluster Redis à l'aide de la commande redis-cli --cluster, qui automatise la configuration initiale. Ensuite, vous apprendrez à ajouter un nouveau nœud à l'aide de CLUSTER MEET. Puis, vous vérifierez l'état du cluster avec CLUSTER INFO. Enfin, vous repartitionnerez les slots entre les nœuds à l'aide de CLUSTER SETSLOT pour équilibrer le cluster.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL redis(("Redis")) -.-> redis/RedisGroup(["Redis"]) redis/RedisGroup -.-> redis/setup_redis("Install Redis") redis/RedisGroup -.-> redis/launch_server("Start Redis Server") redis/RedisGroup -.-> redis/access_cli("Connect Using CLI") subgraph Lab Skills redis/setup_redis -.-> lab-552095{{"Gestion de Cluster Redis"}} redis/launch_server -.-> lab-552095{{"Gestion de Cluster Redis"}} redis/access_cli -.-> lab-552095{{"Gestion de Cluster Redis"}} end

Initialiser le cluster Redis

Dans cette étape, vous allez initialiser un cluster Redis à l'aide de la commande redis-cli --cluster create. Cette commande simplifie le processus de configuration d'un cluster Redis fonctionnel.

Qu'est-ce qu'un cluster Redis ?

Un cluster Redis est une configuration distribuée qui divise automatiquement les données entre plusieurs nœuds Redis. Cela vous permet de faire évoluer votre déploiement Redis horizontalement et de gérer des ensembles de données plus volumineux qu'une seule instance Redis ne peut en traiter.

Pourquoi utiliser redis-cli --cluster create ?

La commande redis-cli --cluster create offre un moyen simple de créer, de gérer et d'interagir avec un cluster Redis. Elle automatise la configuration initiale et la découverte des nœuds, ce qui facilite la création du cluster.

Étapes :

Démarrer les instances Redis :

Tout d'abord, vous devez configurer et démarrer plusieurs instances Redis. Pour ce laboratoire, nous utiliserons six instances fonctionnant sur les ports 7000 à 7005. Chaque instance doit être configurée avec cluster-enabled yes.

Pour ce faire, vous pouvez utiliser les commandes suivantes pour créer des fichiers de configuration et démarrer les instances Redis. Notez que ces commandes sont fournies à des fins de démonstration. Le script d'installation a déjà configuré et démarré ces instances pour vous.

REDIS_CONF="/etc/redis/redis.conf"
for port in 7000 7001 7002 7003 7004 7005; do
  CONF_FILE="/etc/redis/redis-${port}.conf"
  sudo cp "$REDIS_CONF" "$CONF_FILE"
  sudo sed -i "s/^port 6379/port ${port}/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-enabled yes/cluster-enabled yes/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-config-file nodes.conf/cluster-config-file nodes-${port}.conf/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-node-timeout 15000/cluster-node-timeout 15000/g" "$CONF_FILE"
  sudo sed -i "s/^#appendonly no/appendonly yes/g" "$CONF_FILE"
  sudo redis-server "$CONF_FILE" &
done
sleep 5

Créer le cluster :

Maintenant, utilisez la commande redis-cli --cluster create pour créer le cluster. Cette commande nécessite les adresses IP et les ports des nœuds initiaux.

Ouvrez votre terminal et exécutez la commande suivante :
```
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 --cluster-replicas 1
```
- redis-cli --cluster create : Démarre le processus de création du cluster.
- 127.0.0.1:7000 127.0.0.1:7001 ... 127.0.0.1:7005 : Les adresses et les ports des instances Redis.
- --cluster-replicas 1 : Spécifie que chaque nœud maître (master node) doit avoir un réplica.

Confirmer la création du cluster :

L'outil redis-cli vous demandera de confirmer la création du cluster. Tapez yes et appuyez sur Entrée.

>>> Creating cluster
>>> Performing hash slots allocation on 6 nodes...
>>> Master[0] -> Slots 0 - 5460
>>> Master[1] -> Slots 5461 - 10922
>>> Master[2] -> Slots 10923 - 16383
>>> Adding replica node to Master[0]
>>> Adding replica node to Master[1]
>>> Adding replica node to Master[2]
>>> M: 49a4928719291928192819281928192819281928 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
>>> M: 9281928192819281928192819281928192819281 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
>>> M: 19281928192819281928192819281928192819281 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
>>> S: 81928192819281928192819281928192819281928 127.0.0.1:7003
   replicates 49a4928719291928192819281928192819281928
>>> S: 28192819281928192819281928192819281928192 127.0.0.1:7004
   replicates 9281928192819281928192819281928192819281
>>> S: 928192819281928192819281928192819281928192 127.0.0.1:7005
   replicates 19281928192819281928192819281928192819281
>>> Can I set the above configuration? (type 'yes' to accept): yes
>>> Slots 0-5460 assigned to node 49a4928719291928192819281928192819281928
>>> Slots 5461-10922 assigned to node 9281928192819281928192819281928192819281
>>> Slots 10923-16383 assigned to node 19281928192819281928192819281928192819281
>>> Adding replica 81928192819281928192819281928192819281928 to 49a4928719291928192819281928192819281928
>>> Adding replica 28192819281928192819281928192819281928192 to 9281928192819281928192819281928192819281
>>> Adding replica 928192819281928192819281928192819281928192 to 19281928192819281928192819281928192819281
>>> [OK] All nodes agree about the cluster configuration.
>>> >>> Check cluster info
>>> >>> Nodes
>>> M: 49a4928719291928192819281928192819281928 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
>>> M: 9281928192819281928192819281928192819281 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
>>> M: 19281928192819281928192819281928192819281 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
>>> S: 81928192819281928192819281928192819281928 127.0.0.1:7003
   replicates 49a4928719291928192819281928192819281928
>>> S: 28192819281928192819281928192819281928192 127.0.0.1:7004
   replicates 9281928192819281928192819281928192819281
>>> S: 928192819281928192819281928192819281928192 127.0.0.1:7005
   replicates 19281928192819281928192819281928192819281
>>> [OK] All nodes agree about the cluster configuration.
>>> All 16384 slots covered.

Cette sortie montre l'allocation des slots à chaque nœud maître et l'affectation des réplicas.

Se connecter au cluster :

Connectez-vous au cluster Redis à l'aide de redis-cli. Cela vous permet d'exécuter des commandes sur le cluster.
```
redis-cli -h 127.0.0.1 -p 7000
```
Quitter redis-cli :

Quittez la session redis-cli pour vous assurer que la commande est enregistrée.
```
exit
```

Vous avez maintenant initialisé avec succès un cluster Redis. Dans les prochaines étapes, nous explorerons comment ajouter des nœuds, vérifier l'état du cluster et repartitionner les slots.

Ajouter un nouveau nœud au cluster

Dans cette étape, vous apprendrez à ajouter un nouveau nœud à un cluster Redis existant à l'aide de la commande CLUSTER MEET. Cette commande est essentielle pour étendre la capacité de votre cluster et garantir une haute disponibilité.

Comprendre CLUSTER MEET

La commande CLUSTER MEET introduit un nouveau nœud Redis dans le cluster. Lorsqu'un nœud reçoit cette commande, il tente de se connecter au nœud spécifié et de démarrer le processus de "handshake" (poignée de main) pour faire partie du cluster.

Prérequis :

Un cluster Redis initialisé comme décrit dans l'étape précédente.
Une nouvelle instance Redis en cours d'exécution et configurée pour faire partie du cluster, mais pas encore connectée. Pour ce laboratoire, nous supposerons que vous avez une nouvelle instance en cours d'exécution sur le port 7006. Cette instance doit être démarrée avec l'option de configuration cluster-enabled yes. Le script d'installation a déjà configuré et démarré cette instance pour vous.

Étapes :

Se connecter à un nœud existant :

Connectez-vous à l'un des nœuds existants du cluster à l'aide de redis-cli. Peu importe le nœud auquel vous vous connectez, car la commande CLUSTER MEET propagera les informations dans tout le cluster.
```
redis-cli -h 127.0.0.1 -p 7000
```
Utiliser la commande CLUSTER MEET :

Maintenant que vous êtes connecté à un nœud du cluster, utilisez la commande CLUSTER MEET pour introduire le nouveau nœud (port 7006).
```
CLUSTER MEET 127.0.0.1 7006
```
- CLUSTER MEET : La commande pour ajouter un nouveau nœud.
- 127.0.0.1 : L'adresse IP du nouveau nœud.
- 7006 : Le numéro de port du nouveau nœud.
Vous devriez voir la sortie suivante :
```
OK
```
Cela indique que la commande a été envoyée avec succès.
Quitter redis-cli :

Quittez la session redis-cli pour vous assurer que la commande est enregistrée.
```
exit
```

Vous avez ajouté avec succès un nouveau nœud au cluster Redis. Dans l'étape suivante, nous vérifierons l'état du cluster.

Vérifier l'état du cluster

Dans cette étape, vous apprendrez à vérifier l'état et le statut de votre cluster Redis à l'aide de la commande CLUSTER INFO. Cette commande fournit des informations précieuses sur l'état général du cluster.

Comprendre CLUSTER INFO

La commande CLUSTER INFO renvoie des informations sur le cluster Redis, qui peuvent être utilisées pour surveiller son état et diagnostiquer les problèmes.

Prérequis :

Un cluster Redis initialisé et avec un nouveau nœud ajouté comme décrit dans les étapes précédentes.

Étapes :

Se connecter à un nœud du cluster :

Connectez-vous à l'un des nœuds du cluster à l'aide de redis-cli.
```
redis-cli -h 127.0.0.1 -p 7000
```

Exécuter la commande CLUSTER INFO :

Utilisez la commande CLUSTER INFO pour récupérer les informations du cluster.

CLUSTER INFO

Vous devriez voir une sortie similaire à ce qui suit :

cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:7
cluster_size:3
cluster_current_epoch:7
cluster_my_epoch:7
...

Interpréter la sortie :

Voici une ventilation de certaines métriques clés :
- cluster_state:ok : Le cluster est dans un état sain.
- cluster_slots_assigned:16384 : Le nombre de slots attribués aux nœuds.
- cluster_slots_ok:16384 : Le nombre de slots fonctionnant correctement.
- cluster_slots_pfail:0 : Le nombre de slots dans un état "potentiellement défaillant" (potentially failing).
- cluster_slots_fail:0 : Le nombre de slots dans un état "défaillant" (failing).
- cluster_known_nodes:7 : Le nombre total de nœuds que le nœud actuel connaît.
- cluster_size:3 : Le nombre de nœuds maîtres (master nodes) dans le cluster.
Quitter redis-cli :

Quittez la session redis-cli pour vous assurer que la commande est enregistrée.
```
exit
```

Vous avez vérifié avec succès l'état de votre cluster Redis à l'aide de la commande CLUSTER INFO.

Réaffecter (Reshard) des Slots au nouveau nœud

Dans cette étape, vous apprendrez à réaffecter (reshard) des slots dans un cluster Redis à l'aide de la commande redis-cli --cluster reshard. Ceci est important pour distribuer les données de manière uniforme, en particulier après l'ajout de nouveaux nœuds.

Comprendre les Slots Redis et le Resharding

Un cluster Redis divise l'espace de clés (keyspace) en 16384 slots. Chaque nœud maître (master node) est responsable d'un sous-ensemble de ces slots. Lorsque vous ajoutez un nouveau nœud, il ne possède initialement aucun slot. Le resharding déplace les slots des nœuds existants vers le nouveau nœud, équilibrant ainsi les données et la charge de travail.

Étapes :

Se connecter au cluster en utilisant redis-cli --cluster :

Pour effectuer l'opération de resharding, vous utiliserez la commande redis-cli --cluster reshard. Cette commande fournit un moyen interactif de redistribuer les slots dans le cluster.

Ouvrez votre terminal et exécutez la commande suivante :
```
redis-cli --cluster reshard 127.0.0.1:7000
```
Cette commande se connecte au cluster Redis via le nœud à 127.0.0.1:7000 et démarre le processus de resharding.
Spécifier le nombre de slots à déplacer :

L'outil redis-cli vous demandera de saisir le nombre de slots que vous souhaitez déplacer. Pour cet exemple, déplaçons 101 slots vers le nouveau nœud.
```
How many slots do you want to move? (default: all)
```
Entrez 101 et appuyez sur Entrée.
Entrer l'ID du nœud cible :

Ensuite, l'outil vous demandera d'entrer l'ID du nœud cible, qui est le nouveau nœud que vous avez ajouté à l'étape précédente (port 7006). Pour trouver l'ID du nœud, vous pouvez utiliser la commande CLUSTER NODES comme indiqué dans les étapes précédentes, ou vous pouvez utiliser la commande suivante pour obtenir l'ID du nœud directement :
```
redis-cli -h 127.0.0.1 -p 7006 cluster nodes | grep myself | awk '{print $1}'
```
Copiez l'ID du nœud à partir de la sortie. L'outil redis-cli vous demandera :
```
What is the receiving node ID?
```
Collez l'ID du nœud et appuyez sur Entrée.
Spécifier les nœuds sources :

L'outil vous demandera de spécifier les nœuds sources à partir desquels prendre les slots. Vous pouvez entrer all pour redistribuer les slots de tous les nœuds maîtres existants.
```
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' to stop entering IDs.
```
Entrez all et appuyez sur Entrée.
Confirmer le plan de resharding :

L'outil redis-cli affichera le plan de resharding et vous demandera de confirmer.
```
Do you want to proceed with the reshard plan? (type 'yes' to accept):
```
Tapez yes et appuyez sur Entrée pour démarrer le processus de resharding.
Attendre la fin du resharding :

L'outil redis-cli va maintenant déplacer les slots des nœuds sources vers le nœud cible. Ce processus peut prendre un certain temps, en fonction de la quantité de données dans le cluster. Vous verrez des messages de progression au fur et à mesure que les slots sont déplacés.
Quitter redis-cli :

Une fois le resharding terminé, quittez la session redis-cli.

```redis
exit
```

Vous avez maintenant réaffecté avec succès les slots dans votre cluster Redis à l'aide de la commande redis-cli --cluster reshard. Cela garantit que les données sont plus uniformément réparties dans le cluster, y compris le nouveau nœud.

Résumé

Dans ce labo, vous avez appris à gérer un cluster Redis. Vous avez commencé par initialiser un cluster à l'aide de redis-cli --cluster create, puis vous avez ajouté un nouveau nœud avec CLUSTER MEET. Vous avez vérifié l'état du cluster à l'aide de CLUSTER INFO et enfin, vous avez réaffecté (reshard) des slots avec redis-cli --cluster reshard pour équilibrer le cluster. Ce sont des tâches essentielles pour gérer un cluster Redis et assurer son évolutivité (scalability) et sa haute disponibilité (high availability).