Déploiement et Gestion d'un Cluster Redis : Guide Complet

La mise en œuvre d'un cluster Redis est une stratégie efficace pour assurer la haute disponibilité et l'évolutivité de vos données, en répartissant la charge et en garantissant la résilience face aux pannes. Ce guide détaille les étapes et les considérations clés pour déployer et administrer un tel environnement.

Architecture d'un Cluster Redis

Conception des Nœuds

Un cluster Redis est généralement composé de plusieurs nœuds maîtres et de leurs répliques (esclaves), organisés pour le partage des données et la tolérance aux pannes. L'architecture type inclut :

  • Trois nœuds maîtres : par exemple, sur les ports 7000, 7001 et 7002.
  • Trois nœuds esclaves : un esclave par maître, par exemple 7003 pour 7000, 7004 pour 7001, et 7005 pour 7002.
  • La distribution des données s'effectue sur 16384 slots de hachage, répartis équitablement entre les nœuds maîtres.

Haute Disponibilité

Chaque nœud maître est associé à une ou plusieurs répliques. En cas de défaillance d'un maître, un mécanisme de basculement automatique promeut l'un de ses esclaves au rang de nouveau maître, assurant ainsi la continuité du service sans intervention manuelle.

Optimisation des Performances

Pour des performances optimales, il est recommandé de limiter la mémoire utilisée par chaque instance Redis, idéalement à moins de 10 Go. L'activation des mécanismes de persistance (RDB et AOF) est égalemetn cruciale pour la sécurité des données, tout en trouvant un équilibre avec les exigences de performance.

Préparation et Déploiement de l'Environnement

Prérequis Système

Avant le déploiement de Redis, certains ajustements au niveau du système d'exploitation sont nécessaires :


# Désactiver le pare-feu pour simplifier la configuration réseau initiale
sudo systemctl stop firewalld
sudo systemctl disable firewalld

# Désactiver SELinux pour éviter les problèmes de permissions
# Modifier le fichier de configuration et appliquer le changement immédiatement
sudo sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
sudo setenforce 0

# Ajuster les paramètres du noyau pour Redis
# vm.overcommit_memory = 1: Permet à Redis d'allouer de la mémoire sans être tué par le système en cas d'OOM.
# net.core.somaxconn = 1024: Augmente la taille de la file d'attente des connexions TCP pour gérer plus de connexions simultanées.
echo "vm.overcommit_memory = 1" | sudo tee -a /etc/sysctl.conf
echo "net.core.somaxconn = 1024" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Procédure de Déploiement

Le déploiement implique généralement de télécharger, compiler Redis, créer les fichiers de configuration pour chaque instance (maître et esclave), puis de démarrer ces instances. Enfin, l'outil redis-cli --cluster create est utilisé pour former le cluster et attribuer les répliques.


# Après la création du cluster, vérifier son état depuis n'importe quel nœud (par exemple, le port 7000)
redis-cli -a votre_mot_de_passe_redis -c -p 7000 cluster nodes

Paramètres de Configuration Clés

Fichier redis.conf : Configurations Essentielles

Voici les directives importantes à configurer dans redis.conf pour chaque instance de votre cluster :


# SECTION : Cluster
# Active le mode cluster pour cette instance Redis
cluster-enabled yes
# Fichier utilisé par Redis pour stocker la configuration du cluster (généré automatiquement)
cluster-config-file nodes.conf
# Durée maximale (en millisecondes) pendant laquelle un nœud peut être injoignable avant d'être considéré comme défaillant
cluster-node-timeout 5000
# Définit si le cluster doit fonctionner même si tous les slots ne sont pas couverts.
# 'no' permet au cluster de continuer à servir des requêtes même avec des slots non attribués ou des nœuds manquants.
# 'yes' (par défaut) arrête le cluster si des slots sont manquants, garantissant une cohérence stricte.
cluster-require-full-coverage no

# SECTION : Sécurité
# Définit le mot de passe requis pour les connexions clients
requirepass votre_mot_de_passe_redis
# Mot de passe utilisé par un esclave pour s'authentifier auprès de son maître
masterauth votre_mot_de_passe_redis

# SECTION : Persistance des données
# Configuration de la persistance RDB (snapshotting)
# Sauvegarde si au moins 1 modification survient en 900 secondes (15 minutes)
save 900 1
# Active la persistance AOF (Append Only File)
appendonly yes
# Stratégie de synchronisation AOF : synchronise le fichier AOF toutes les secondes
appendfsync everysec

Paramètres d'Optimisation des Performances


# Limite maximale de mémoire que cette instance Redis est autorisée à utiliser (par exemple, 8 Go)
maxmemory 8gb
# Stratégie d'éviction des clés lorsque la limite 'maxmemory' est atteinte (Least Recently Used)
maxmemory-policy allkeys-lru
# Taille du backlog TCP pour les connexions en attente
tcp-backlog 511

Utilisation avec les Clients Java

Client Jedis

Le client Jedis permet de se connecter facilement à un cluster Redis via la classe JedisCluster. Il gère automatiquement la découverte des nœuds et les redirections pour les clés situées sur des slots différents, ainsi que la gestion des pools de connexions.


import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.util.HashSet;
import java.util.Set;

public class JedisClusterExample {

    public static void main(String[] args) {
        Set<HostAndPort> clusterNodes = new HashSet<>();
        // Ajouter les adresses de vos nœuds maîtres du cluster
        clusterNodes.add(new HostAndPort("192.168.1.10", 7000));
        clusterNodes.add(new HostAndPort("192.168.1.11", 7001));
        clusterNodes.add(new HostAndPort("192.168.1.12", 7002));

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100);    // Nombre maximal de connexions dans le pool
        poolConfig.setMaxIdle(50);     // Nombre maximal de connexions inactives
        poolConfig.setMinIdle(5);      // Nombre minimal de connexions inactives

        // Instanciation de JedisCluster
        // Paramètres : nœuds du cluster, timeout de connexion, timeout de socket, nombre de redirections, mot de passe, configuration du pool
        try (JedisCluster clusterClient = new JedisCluster(clusterNodes, 5000, 5000, 5, "votre_mot_de_passe_redis", poolConfig)) {
            // Opérations sur le cluster
            clusterClient.set("utilisateur:1:nom", "Alice");
            String username = clusterClient.get("utilisateur:1:nom");
            System.out.println("Nom de l'utilisateur 1 : " + username);

            clusterClient.hset("produit:101", "nom", "Laptop");
            clusterClient.hset("produit:101", "prix", "1200");
            System.out.println("Nom du produit 101 : " + clusterClient.hget("produit:101", "nom"));

        } catch (Exception e) {
            System.err.println("Erreur lors de l'interaction avec le cluster Redis : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Spring Data Redis

Spring Data Redis, souvent utilisé avec Lettuce (ou Jedis), offre une intégration transparente avec les clusters Redis. Il suffit de configurer RedisClusterConfiguration avec les adresses des nœuds et d'utiliser LettuceConnectionFactory pour le gestionnaire de connexion, puis RedisTemplate pour les opérations de données.


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Arrays;

@Configuration
public class RedisClusterConfig {

    /**
     * Configure la fabrique de connexions Lettuce pour un cluster Redis.
     * @return Une instance de LettuceConnectionFactory.
     */
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration(
                Arrays.asList("192.168.1.10:7000", "192.168.1.11:7001", "192.168.1.12:7002"));
        // Définir le mot de passe si le cluster est sécurisé
        clusterConfig.setPassword("votre_mot_de_passe_redis");

        return new LettuceConnectionFactory(clusterConfig);
    }

    /**
     * Configure le RedisTemplate pour interagir avec le cluster.
     * Utilise des StringRedisSerializer pour les clés et les valeurs par défaut.
     * @return Une instance de RedisTemplate.
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());

        // Configure les serializers pour les clés et les valeurs
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());

        template.afterPropertiesSet(); // Initialise le template après la configuration
        return template;
    }
}

Gestion et Opérations

Surveillance du Cluster

Une surveillance régulière est indispensable pour garantir la stabilité et les performances du cluster.


# Afficher des informations générales sur l'état du cluster (ex: état, nombre de maîtres/esclaves, slots)
redis-cli -a votre_mot_de_passe -c -p 7000 cluster info

# Lister tous les nœuds du cluster, leurs IDs, rôles, état, et slots attribués
redis-cli -a votre_mot_de_passe -c -p 7000 cluster nodes

# Obtenir des statistiques de performance détaillées pour une instance spécifique (par exemple, utilisation CPU, mémoire, connexions, QPS)
redis-cli -a votre_mot_de_passe -p 7000 info stats

Gestion des Incidents

  • En cas de défaillance d'un nœud maître, un de ses esclaves sera automatiquement promu, assurant la résilience.
  • Utilisez redis-cli --cluster fix pour corriger les problèmes de configuration ou les slots non attribués.
  • Pour ajouter de nouveaux nœuds (maîtres ou esclaves) :

# Ajouter un nouveau nœud (maître par défaut)
redis-cli --cluster add-node nouveau_hote:nouveau_port hote_existant:port_existant

# Ajouter un nouveau nœud en tant qu'esclave d'un maître existant
# Remplacez <ID_DU_MAITRE> par l'ID du nœud maître cible
redis-cli --cluster add-node nouveau_hote:nouveau_port hote_existant:port_existant --cluster-slave --cluster-master-id <ID_DU_MAITRE>

# Après l'ajout de nœuds maîtres, il est nécessaire de redistribuer les slots (reshard)
# Cela peut être une opération interactive ou scriptée
redis-cli --cluster reshard un_hote:un_port --cluster-from <ID_NODE_SOURCE1>,<ID_NODE_SOURCE2> --cluster-to <ID_NODE_DESTINATION> --cluster-slots 1000 --cluster-yes

Sauvegarde des Données

Des stratégies de sauvegarde robustes sont essentielles pour la récupération après sinistre.


# Déclencher manuellement une sauvegarde RDB (snapshot) sur une instance Redis
redis-cli -a votre_mot_de_passe -p 7000 bgsave

# Exécuter une copie périodique du fichier AOF
# Assurez-vous d'adapter le chemin du fichier AOF à votre configuration
cp /var/lib/redis/7000/appendonly.aof /mnt/backup/redis_aof_$(date +%Y%m%d_%H%M%S).aof

Considérations pour la Production

Planification Réseau

Une latence réseau faible (inférieure à 1 ms) est cruciale entre les nœuds du cluster. L'utilisation d'un réseau dédié ou d'un réseau privé virtuel (VPC) est fortement recommandée.

Renforcement de la Sécurité

  • Ne jamais exposer directement les ports Redis sur l'internet.
  • Mettre en place des pare-feu pour restreindre l'accès aux adresses IP autorisées.
  • Maintenir Redis à jour pour bénéficier des dernières corrections de sécurité.

Surveillance des Performances

Surveiller continuellement les métriques clés telles que l'utilisation CPU et mémoire, le nombre de requêtes par seconde (QPS), la latence des opérations, et les journaux de requêtes lentes. Ajustez les seuils de surveillance et les alertes en conséquence.

Stratégie d'Évolution (Scaling)

Anticipez la croissance future de votre charge de travail. Planiifez l'ajout de nouveaux nœuds maîtres et esclaves pour étendre la capacité du cluster et redistribuez les slots de hachage de manière appropriée pour maintenir un équilibre de charge optimal.

Étiquettes: Redis Cluster HauteDisponibilité persistance Jedis

Publié le 1 juin à 15h11

Étiquettes Populaires

©2026 L'Atelier Monstre