Mettre à l'échelle Redis : Guide de configuration d'un cluster Redis

Redis, un puissant magasin de structures de données en mémoire, est largement utilisé comme base de données, cache et courtier de messages. Bien qu'une seule instance Redis puisse gérer une charge significative, de nombreuses applications finissent par nécessiter une disponibilité plus élevée et la capacité de s'adapter horizontalement pour s'adapter à des volumes de données et un trafic croissants. Redis Cluster offre une solution native pour atteindre ces deux objectifs.

Ce guide vous accompagnera tout au long du processus de configuration, de paramétrage et de gestion d'un cluster Redis. Nous aborderons les concepts fondamentaux, fournirons des instructions étape par étape pour l'installation et la configuration, et discuterons des tâches de gestion essentielles pour garantir que votre cluster reste robuste et performant.

Comprendre les concepts du cluster Redis

Avant de plonger dans la configuration, il est crucial de comprendre les concepts fondamentaux qui sous-tendent le cluster Redis :

Partage (Sharding) : Redis Cluster partitionne votre ensemble de données sur plusieurs nœuds Redis. Chaque nœud est responsable d'un sous-ensemble des slots de hachage (16384 au total). Lorsqu'un client doit accéder à une clé, la bibliothèque cliente calcule à quel slot de hachage la clé appartient et dirige la requête vers le nœud approprié.
Réplication : Pour une haute disponibilité, chaque nœud primaire du cluster peut avoir un ou plusieurs nœuds réplicas. Si un nœud primaire tombe en panne, l'un de ses réplicas peut être promu pour prendre sa place, minimisant ainsi les temps d'arrêt.
Protocole Gossip : Les nœuds du cluster Redis communiquent entre eux en utilisant un protocole gossip. Cela permet aux nœuds de se découvrir mutuellement, d'échanger des informations sur leur état et de détecter les pannes.
Consensus : Lorsqu'un nœud primaire tombe en panne, le cluster doit parvenir à un consensus entre les nœuds primaires restants pour élire un nouveau primaire parmi ses réplicas. Ce processus garantit que le cluster reste opérationnel.

Prérequis

Pour configurer un cluster Redis, vous aurez besoin de :

Plusieurs serveurs ou machines virtuelles (au moins 6 nœuds sont recommandés pour une configuration prête pour la production : 3 primaires et 3 réplicas).
Redis installé sur chaque serveur. Assurez-vous d'utiliser Redis version 3.0 ou ultérieure.
Connectivité réseau entre tous les nœuds. Les nœuds doivent pouvoir communiquer entre eux sur leur port client et leur port de bus de cluster (port client + 10000).
redis-cli, l'interface de ligne de commande Redis, qui inclut le script redis-trib.rb pour la création de clusters.

Configuration d'un cluster Redis : Étape par étape

Cette section fournit un guide pratique, étape par étape, pour créer un cluster Redis de base. Par souci de simplicité, nous supposerons que vous configurez un cluster sur une seule machine en utilisant différents ports pour chaque nœud. Dans un environnement de production, vous distribueriez généralement ces nœuds sur différentes machines physiques ou virtuelles.

1. Installer Redis

Si Redis n'est pas déjà installé, suivez le guide d'installation officiel de Redis pour votre système d'exploitation. Par exemple, sur Debian/Ubuntu :

sudo apt update
sudo apt install redis-server

2. Configurer les instances Redis pour le mode Cluster

Pour chaque nœud de votre cluster, vous avez besoin d'un fichier de configuration Redis distinct. Créez des répertoires pour chaque nœud et copiez le fichier redis.conf par défaut.

Supposons que nous configurions un cluster primaire de 3 nœuds sans réplicas pour cette configuration initiale. Nous utiliserons les ports 7000, 7001 et 7002.

# Créer des répertoires pour chaque nœud
mkdir cluster
cd cluster
mkdir 7000 7001 7002

# Copier redis.conf dans chaque répertoire
cp /etc/redis/redis.conf ./7000/
cp /etc/redis/redis.conf ./7001/
cp /etc/redis/redis.conf ./7002/

Maintenant, modifiez le fichier de configuration de chaque nœud. Pour 7000/redis.conf, 7001/redis.conf et 7002/redis.conf, apportez les modifications suivantes :

port 700X (où X est 0, 1 ou 2)
cluster-enabled yes
cluster-config-file nodes-700X.conf (Ce fichier est géré par Redis lui-même et ne doit pas être édité manuellement. Il stocke l'état du cluster.)
cluster-node-timeout 5000 (Délai d'expiration recommandé en millisecondes pour qu'un nœud soit considéré comme défaillant.)
appendonly yes (Recommandé pour la durabilité des données, surtout en production)

Exemple pour 7000/redis.conf :

port 7000
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 5000
appendonly yes
# Assurez-vous que bind est défini sur 0.0.0.0 ou l'IP correcte si vous exécutez sur une machine distante
bind 0.0.0.0

Répétez ces modifications pour 7001/redis.conf (port 7001) et 7002/redis.conf (port 7002).

3. Démarrer les instances Redis

Démarrez chaque instance Redis en utilisant son fichier de configuration spécifique :

redis-server ./7000/redis.conf
redis-server ./7001/redis.conf
redis-server ./7002/redis.conf

Si Redis est exécuté en tant que service, vous devrez peut-être arrêter l'instance par défaut (sudo systemctl stop redis-server) et les démarrer manuellement comme indiqué ci-dessus, ou configurer plusieurs fichiers de service.

4. Créer le cluster à l'aide de `redis-trib.rb`

Le script redis-trib.rb est une gemme Ruby qui aide à automatiser la création d'un cluster Redis. Il est inclus avec les distributions Redis.

Naviguez vers le répertoire où se trouve redis-trib.rb (souvent dans /usr/share/redis/ ou vous devrez peut-être le trouver dans votre installation Redis). Vous devrez peut-être installer Ruby s'il n'est pas présent (sudo apt install ruby-full).

Exécutez le script pour créer un cluster avec 3 nœuds maîtres :

# Assurez-vous d'être dans le répertoire du cluster ou fournissez les chemins complets
# ruby /path/to/redis/src/redis-trib.rb create --replicas 0 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002

# Ou si redis-trib.rb est dans votre PATH
redis-trib.rb create --replicas 0 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002

Cette commande :
* create : Indique à redis-trib.rb de créer un nouveau cluster.
* --replicas 0 : Spécifie que nous voulons 0 réplica par maître. Pour une configuration de production, vous utiliseriez --replicas 1 (ou plus).
* 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 : Liste les nœuds qui participeront au cluster.

Le script demandera une confirmation. Tapez yes pour continuer. Il attribuera ensuite les slots de hachage à chaque nœud maître et configurera le cluster.

5. Vérifier le cluster

Une fois que redis-trib.rb a terminé, vous pouvez vous connecter à n'importe quel nœud et vérifier l'état du cluster :

redis-cli -c -p 7000

CLUSTER INFO
CLUSTER NODES

La commande CLUSTER INFO devrait afficher cluster_state:ok. La commande CLUSTER NODES listera tous les nœuds du cluster, leurs rôles et leurs slots attribués.

Astuce : Utilisez le drapeau -c avec redis-cli (redis-cli -c) pour activer le mode cluster. Cela permet à redis-cli de rediriger automatiquement les commandes vers le bon nœud lorsqu'une migration ou une redirection de slot de hachage est nécessaire.

Ajout de réplicas à un cluster existant

Pour une haute disponibilité, vous devez ajouter des réplicas. Ajoutons un réplica pour le nœud sur le port 7000 (maître) sur le port 7003.

Configurer le nouveau nœud : Créez un nouveau répertoire (par exemple, cluster/7003), copiez redis.conf et mettez-le à jour pour le port 7003, en activant le mode cluster et en définissant le cluster-config-file.
ini port 7003 cluster-enabled yes cluster-config-file nodes-7003.conf cluster-node-timeout 5000 appendonly yes bind 0.0.0.0
Démarrer le nouveau nœud : redis-server ./7003/redis.conf
Ajouter le réplica à l'aide de redis-trib.rb : Connectez-vous à votre cluster existant à l'aide de redis-cli -c -p 7000 et utilisez la commande CLUSTER REPLICATE ou utilisez à nouveau redis-trib.rb. L'utilisation de redis-trib.rb est généralement plus simple pour la configuration initiale.

```bash

Exemple d'utilisation de redis-trib.rb pour ajouter un réplica pour le nœud 7000

Vous avez besoin de l'ID de nœud du maître que vous souhaitez répliquer.

D'abord, obtenez l'ID de nœud : redis-cli -p 7000 CLUSTER NODES

Supposons que l'ID du nœud maître est 'your_master_node_id'

redis-trib.rb --cluster-add-node 127.0.0.1:7003 --cluster-slave --cluster-master-id 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002
`` *Note* : La commanderedis-trib.rbpour ajouter des nœuds peut être un peu complexe. Une approche plus simple pour ajouter des réplicas consiste à d'abord démarrer la nouvelle instance de réplica, puis à se connecter au nœud maître viaredis-cliet à émettre la commandeCLUSTER REPLICATE `.

Alternativement, vous pouvez utiliser redis-trib.rb pour reconfigurer un cluster existant avec des réplicas :

```bash

Exemple pour ajouter des réplicas à un cluster existant à 3 maîtres

redis-trib.rb replace-node-master --replicas 1 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
```
Cette commande est plus complexe et suppose que vous avez configuré des nœuds supplémentaires (7003, 7004, 7005) en tant que réplicas.

6. Gestion du cluster

Ajout/Suppression de nœuds : Vous pouvez ajouter de nouveaux nœuds maîtres et des réplicas pour faire évoluer le cluster. redis-trib.rb ou des commandes manuelles peuvent être utilisés. La suppression de nœuds implique d'abord la migration des slots hors du nœud.
Failover : Redis Cluster gère automatiquement le failover. Si un nœud maître devient inaccessible, ses réplicas tenteront d'être promus. Vous pouvez simuler des pannes en utilisant CLUSTER FAILOVER (sur un réplica) ou en arrêtant un nœud.
Déplacement de slots : Vous pouvez déplacer manuellement des slots de hachage entre les nœuds maîtres à l'aide des commandes CLUSTER SETSLOT <slot> IMPORTING/NODE et MIGRATE. Cela est utile pour rééquilibrer le cluster ou se préparer à supprimer un nœud.

Meilleures pratiques pour Redis Cluster

Utilisez au moins 6 nœuds : Un cluster prêt pour la production doit avoir au moins 3 maîtres et 3 réplicas (un réplica par maître) pour la tolérance aux pannes.
Distribuez les nœuds sur différentes zones de disponibilité : Pour les déploiements cloud, placez les nœuds dans différentes zones de disponibilité pour se protéger contre les pannes au niveau de la zone.
Surveillez votre cluster : Utilisez les outils de surveillance de Redis et les systèmes de surveillance externes pour suivre les performances, l'utilisation de la mémoire et la santé des nœuds.
Configurez protected-mode no : Si vous exécutez Redis Cluster sur un réseau, assurez-vous que protected-mode no est défini dans votre redis.conf et utilisez un pare-feu pour restreindre l'accès.
Utilisez appendonly yes : Pour la durabilité des données, assurez-vous que la persistance du fichier append-only est activée.
Support de la bibliothèque client : Assurez-vous que votre bibliothèque client Redis prend en charge Redis Cluster et gère correctement la redirection.

Conclusion

La configuration d'un cluster Redis est une étape critique pour les applications nécessitant une haute disponibilité et une évolutivité horizontale. En comprenant les concepts fondamentaux du sharding, de la réplication et de la communication de cluster, vous pouvez déployer et gérer avec succès un cluster Redis robuste. N'oubliez pas de planifier la topologie de votre cluster, de surveiller sa santé et de suivre les meilleures pratiques pour garantir des performances et une fiabilité optimales.