Construction d'un environnement de cluster distribué Redis

        Les clusters distribués Redis peuvent être divisés en clusters maître- esclave , clusters sentinelles et clusters fragmentés Dans cet article, nous présenterons la construction de ces trois environnements de cluster.

        Cet environnement de génération est un système de machine virtuelle Linux.

        Avant de construire un cluster redis, vous devez installer et déployer un redis autonome dans le système linux (le répertoire d'installation est : /usr/local/src ), et les étapes détaillées peuvent être cliquées sur le lien suivant : Linux cloud server étapes détaillées d'installation et de déploiement redis

Ⅰ Construction d'un cluster maître-esclave Redis

1.1 Structure des grappes 

La structure de cluster maître-esclave que nous avons construite est illustrée dans la figure :

Il y a trois nœuds au total, un nœud maître et deux nœuds esclaves (le nœud maître est utilisé pour les opérations d'écriture et les nœuds esclaves ne peuvent effectuer que des opérations de lecture).

Ici nous allons ouvrir 3 instances redis dans la même machine virtuelle pour simuler un cluster maître-esclave, les informations sont les suivantes :

IP	PORT	Rôle
192.168.70.130	7001	maître
192.168.70.130	7002	esclave
192.168.70.130	7003	esclave

1.2 Préparer et configurer l'instance

Pour démarrer trois instances sur la même machine virtuelle, trois fichiers et répertoires de configuration différents doivent être préparés, et le répertoire où se trouvent les fichiers de configuration est également le répertoire de travail.

1) Créer un répertoire

Nous créons trois dossiers nommés 7001, 7002 et 7003 :

# 进入 /usr/local/src 目录
cd /usr/local/src
# 创建目录
mkdir 7001 7002 7003

Comme indiqué sur l'image :

2) Activez RDB et désactivez AOF (par défaut)

Modifiez le fichier redis-6.2.4/redis.conf, remplacez le mode de persistance par le mode RDB par défaut et désactivez AOF

# 开启RDB
# save ""
save 3600 1
save 300 100
save 60 10000

# 关闭AOF
appendonly no

3) Copiez le fichier de configuration dans chaque répertoire d'instance

# 方式一：逐个拷贝
cp redis-6.2.4/redis.conf 7001
cp redis-6.2.4/redis.conf 7002
cp redis-6.2.4/redis.conf 7003

# 方式二：管道组合命令，一键拷贝
echo 7001 7002 7003 | xargs -t -n 1 cp redis-6.2.4/redis.conf

4) Modifier le port et le répertoire de travail de chaque instance

Modifiez les fichiers de configuration dans chaque dossier, modifiez les ports sur 7001, 7002 et 7003 respectivement, et modifiez l'emplacement de stockage des fichiers rdb dans votre propre répertoire (exécutez les commandes suivantes dans le répertoire /usr/local/src) :

sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \/usr\/local\/src\/7001\//g' 7001/redis.conf
sed -i -e 's/6379/7002/g' -e 's/dir .\//dir \/usr\/local\/src\/7002\//g' 7002/redis.conf
sed -i -e 's/6379/7003/g' -e 's/dir .\//dir \/usr\/local\/src\/7003\//g' 7003/redis.conf

5) Modifier l'IP déclarée de chaque instance

La machine virtuelle elle-même possède plusieurs adresses IP. Afin d'éviter toute confusion à l'avenir, nous devons spécifier les informations d'adresse IP de liaison de chaque instance dans le fichier redis.conf. Le format est le suivant :

# redis实例的声明 IP
replica-announce-ip 192.168.150.101

Chaque répertoire doit être changé, et nous pouvons terminer la modification en un clic (exécutez la commande suivante dans le répertoire /usr/local/src) :

# 逐一执行
sed -i '1a replica-announce-ip 192.168.70.130' 7001/redis.conf
sed -i '1a replica-announce-ip 192.168.70.130' 7002/redis.conf
sed -i '1a replica-announce-ip 192.168.70.130' 7003/redis.conf

# 或者一键修改
printf '%s\n' 7001 7002 7003 | xargs -I{} -t sed -i '1a replica-announce-ip 192.168.70.130' {}/redis.conf

Si le mot de passe requirepass est activé à la fois sur le maître et l'esclave, ce qui entraîne un échec de la vérification, ajoutez simplement masterauth 123321 dans le fichier de configuration (redis.conf) du serveur esclave redis (exécutez la commande suivante dans /usr/local/src annuaire):

# 逐一执行
sed -i 'masterauth 123321' 7002/redis.conf
sed -i 'masterauth 123321' 7003/redis.conf

# 或者意见修改
printf '%s\n' 7002 7003 | xargs -I{} -t sed -i 'masterauth 123321' {}/redis.conf

(123321 est le mot de passe de mon redis principal, ce paramètre est la vérification du mot de passe lors de la connexion avec le principal)

1.3 commencer

Afin de visualiser les journaux de manière pratique, nous pouvons ouvrir 3 fenêtres ssh, démarrer 3 instances redis respectivement et lancer la commande (exécutez la commande suivante dans le répertoire /usr/local/src) :  

# 第1个
redis-server 7001/redis.conf
# 第2个
redis-server 7002/redis.conf
# 第3个
redis-server 7003/redis.conf

Si vous souhaitez arrêter avec une touche, vous pouvez exécuter la commande suivante :

printf '%s\n' 7001 7002 7003 | xargs -I{} -t redis-cli -p {} shutdown

1.4 Ouvrir la relation maître-esclave

Maintenant, les trois instances n'ont plus rien à voir, pour configurer le maître-esclave, vous pouvez utiliser la commande replicaof ou slaveof (avant 5.0).

Il existe deux modes, temporaire et permanent :

• Modifier le fichier de configuration (permanent)

  • Ajoutez une ligne de configuration à redis.conf :slaveof <masterip> <masterport>

• Utilisez le client redis-cli pour vous connecter au service redis et exécutez la commande slaveof (elle échouera après le redémarrage) :slaveof <masterip> <masterport>

Note : La commande replicaof est ajoutée après 5.0, qui a le même effet que salveof.

Ici, nous utilisons la deuxième méthode pour la démonstration :

1) Connectez-vous au 7002 via la commande redis-cli et exécutez la commande suivante :

# 连接 7002
redis-cli -p 7002
# 执行slaveof
slaveof 192.168.150.101 7001

2) Connectez-vous au 7003 via la commande redis-cli et exécutez la commande suivante :  

# 连接 7003
redis-cli -p 7003
# 执行slaveof
slaveof 192.168.150.101 7001

3) Connectez-vous ensuite au nœud 7001 pour vérifier l'état du cluster :

# 连接 7001
redis-cli -p 7001
# 查看状态
info replication

résultat:

1.5 Essai

Procédez comme suit pour tester :

• Utilisez redis-cli pour vous connecter à 7001, exécutezset num 123

• Utilisez redis-cli pour vous connecter à 7002, exécutez get num, puis exécutezset num 666

• Utilisez redis-cli pour vous connecter à 7003, exécutez get num, puis exécutezset num 888

On constate que seul le nœud maître 7001 peut effectuer des opérations d'écriture, et les deux nœuds esclaves 7002 et 7003 ne peuvent effectuer que des opérations de lecture.

Ⅱ. Construction d'un cluster sentinelle Redis

2.1 Structure des grappes

Ici, nous construisons un cluster Sentinel formé de trois nœuds pour superviser le cluster maître-esclave Redis précédent. Comme indiqué sur l'image :  

 

Les informations des trois instances sentinelles sont les suivantes :

nœud	IP	PORT
s1	192.168.70.130	27001
s2	192.168.70.130	27002
s3	192.168.70.130	27003

2.2 Préparer et configurer l'instance

Pour démarrer trois instances sur la même machine virtuelle, trois fichiers et répertoires de configuration différents doivent être préparés, et le répertoire où se trouvent les fichiers de configuration est également le répertoire de travail.

Nous créons trois dossiers nommés s1, s2, s3 :

# 进入/usr/local/src目录
cd /usr/local/src
# 创建目录
mkdir s1 s2 s3

Comme indiqué sur l'image :

Ensuite, nous créons un fichier sentinel.conf dans le répertoire s1 et ajoutons le contenu suivant :

port 27001
sentinel announce-ip 192.168.70.130
sentinel monitor mymaster 192.168.70.130 7001 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
dir "/usr/local/src/s1"

expliquer:

• port 27001: est le port de l'instance sentinelle actuelle

• sentinel monitor mymaster 192.168.70.130 7001 2: Spécifiez les informations du nœud maître

  • mymaster: nom du nœud maître, défini par l'utilisateur, écriture arbitraire

  • 192.168.70.130 7001: l'ip et le port du nœud maître

  • 2: La valeur du quorum lorsque le maître est élu (c'est-à-dire que si plus de 2 sentinelles pensent que le nœud est subjectivement déconnecté, on considère que le nœud est objectivement déconnecté)

Copiez ensuite le fichier s1/sentinel.conf dans les répertoires s2 et s3 (exécutez la commande suivante dans le répertoire /usr/local/src) :

# 方式一：逐个拷贝
cp s1/sentinel.conf s2
cp s1/sentinel.conf s3
# 方式二：管道组合命令，一键拷贝
echo s2 s3 | xargs -t -n 1 cp s1/sentinel.conf

Modifiez les fichiers de configuration dans les dossiers s2 et s3, et changez les ports en 27002 et 27003 respectivement (exécutez les commandes suivantes dans le répertoire /usr/local/src) :

sed -i -e 's/27001/27002/g' -e 's/s1/s2/g' s2/sentinel.conf
sed -i -e 's/27001/27003/g' -e 's/s1/s3/g' s3/sentinel.conf

2.3 commencer

Afin de visualiser les journaux de manière pratique, nous pouvons ouvrir 3 fenêtres ssh, démarrer 3 instances redis respectivement et lancer la commande (exécutez la commande suivante dans le répertoire /usr/local/src) :  

# 第1个
redis-sentinel s1/sentinel.conf
# 第2个
redis-sentinel s2/sentinel.conf
# 第3个
redis-sentinel s3/sentinel.conf

2.4 Tests

Essayez d'arrêter le nœud maître 7001, vérifiez le journal sentinelle :  

Vérifiez le journal de 7003 :

Vérifiez le journal de 7002 :

2.5 redisTemplate (optionnel)

Dans le cluster maître-esclave Redis supervisé par le cluster Sentinel, ses nœuds changeront en raison du basculement automatique, et le client Redis doit détecter ce changement et mettre à jour les informations de connexion à temps. La couche inférieure de RedisTemplate de Spring utilise de la laitue pour réaliser la perception des nœuds et la commutation automatique.

Ensuite, nous implémentons le mécanisme sentinelle d'intégration RedisTemplate via un test.

1) Introduisez les dépendances dans le fichier pom du projet :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2) Spécifiez ensuite les informations relatives à la sentinelle de redis dans le fichier de configuration application.yml :

spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.70.130:27001
        - 192.168.70.130:27002
        - 192.168.70.130:27003

3) Dans la classe de démarrage du projet, ajoutez un nouveau bean et configurez la séparation lecture-écriture :

@Bean
public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer(){
    return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
}

Ce bean est configuré avec des stratégies de lecture et d'écriture, dont quatre types :

• MASTER : lire depuis le nœud maître

• MASTER_PREFERRED : lire d'abord depuis le nœud maître, lire la réplique lorsque le maître n'est pas disponible

• REPLICA : lecture à partir du nœud esclave (réplique)

• REPLICA _PREFERRED : lecture à partir du nœud esclave (réplique) en premier, tous les esclaves sont indisponibles pour lire le maître

Ⅲ. Construction d'un cluster de partitionnement Redis 

3.1 Structure des grappes

Ici nous allons ouvrir 6 instances redis dans la même machine virtuelle pour simuler un cluster fragmenté, les informations sont les suivantes :

IP	PORT	Rôle
192.168.70.130	7001	maître
192.168.70.130	7002	maître
192.168.70.130	7003	maître
192.168.70.130	8001	esclave
192.168.70.130	8002	esclave
192.168.70.130	8003	esclave

3.2 Préparer et configurer l'instance

Créez les répertoires 7001, 7002, 7003, 8001, 8002, 8003 (si le même nœud existe déjà, pensez à supprimer les répertoires 7001, 7002, 7003 précédents) :

# 进入/usr/local/src目录
cd /usr/local/src
# 删除旧的，避免配置干扰
rm -rf 7001 7002 7003
# 创建目录
mkdir 7001 7002 7003 8001 8002 8003

Préparez un nouveau fichier redis.conf sous /usr/local/src avec le contenu suivant :

port 6379
# 开启集群功能
cluster-enabled yes
# 集群的配置文件名称，不需要我们创建，由redis自己维护
cluster-config-file /usr/local/src/6379/nodes.conf
# 节点心跳失败的超时时间
cluster-node-timeout 5000
# 持久化文件存放目录
dir /usr/local/src/6379
# 绑定地址
bind 0.0.0.0
# 让redis后台运行
daemonize yes
# 注册的实例ip
replica-announce-ip 192.168.70.130
# 保护模式
protected-mode no
# 数据库数量
databases 1
# 日志
logfile /usr/local/src/6379/run.log

Copiez ce fichier dans les répertoires 7001, 7002, 7003, 8001, 8002, 8003 (exécutez les commandes suivantes dans le répertoire /usr/local/src) :

# 执行拷贝
echo 7001 7002 7003 8001 8002 8003 | xargs -t -n 1 cp redis.conf

Modifiez redis.conf dans chaque répertoire et modifiez 6379 pour être cohérent avec le répertoire (exécutez la commande suivante dans le répertoire /usr/local/src) :

# 修改配置文件
printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t sed -i 's/6379/{}/g' {}/redis.conf

3.3 commencer

 Comme le mode de démarrage en arrière-plan a été configuré, le service peut être démarré directement (exécutez la commande suivante dans le répertoire /usr/local/src) :

# 一键启动所有服务
printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t redis-server {}/redis.conf

Afficher l'état via ps :

ps -ef | grep redis

Les services de découverte ont démarré normalement :

Si vous souhaitez fermer tous les processus, vous pouvez exécuter la commande :

ps -ef | grep redis | awk '{print $2}' | xargs kill
# 或者
printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t redis-cli -p {} shutdown # 推荐

3.4 Créer un cluster

Bien que le service soit démarré, chaque service est actuellement indépendant sans aucune association.

Nous devons exécuter des commandes pour créer un cluster. Il était difficile de créer un cluster avant Redis 5.0. Après la version 5.0, les commandes de gestion de cluster sont intégrées dans redis-cli.

1) Avant Redis5.0

Avant Redis5.0, les commandes de cluster étaient toutes implémentées avec src/redis-trib.rb sous le package d'installation redis. Étant donné que redis-trib.rb est écrit en langage ruby, il doit installer l'environnement ruby.  

 # 安装依赖
 yum -y install zlib ruby rubygems
 gem install redis

Utilisez ensuite la commande pour gérer le cluster :

# 进入redis的src目录
cd /usr/local/src/redis-6.2.4/src
# 创建集群
./redis-trib.rb create --replicas 1 192.168.70.130:7001 192.168.70.130:7002 192.168.70.130:7003 192.168.70.130:8001 192.168.70.130:8002 192.168.70.130:8003

2) Après Redis5.0

Nous utilisons la version Redis6.2.4, la gestion des clusters et intégrée à redis-cli, le format est le suivant :

redis-cli --cluster create --cluster-replicas 1 192.168.70.130:7001 192.168.70.130:7002 192.168.70.130:7003 192.168.70.130:8001 192.168.70.130:8002 192.168.70.130:8003

Description de la commande :

• redis-cli --cluster Ou ./redis-trib.rb : représente une commande d'opération de cluster

• create: représente la création d'un cluster

• --replicas 1 Ou  --cluster-replicas 1: spécifiez que le nombre de copies de chaque master dans le cluster est 1, et 节点总数 ÷ (replicas + 1)  le nombre obtenu à ce moment est le nombre de masters. Par conséquent, les n premiers nœuds de la liste de nœuds sont des maîtres et les autres nœuds sont des nœuds esclaves, qui sont attribués de manière aléatoire à différents maîtres.

À quoi ça ressemble après avoir couru :

Entrez yes ici, et le cluster commencera à être créé :

Vous pouvez afficher l'état du cluster avec la commande :

redis-cli -p 7001 cluster nodes

3.5 Essais

Essayez de vous connecter au nœud 7001 et stockez une donnée :

# 连接
redis-cli -c -p 7001
# 存储数据
set num 123
# 读取数据
get num
# 再次存储
set a 1

Remarque : Le paramètre -c doit être ajouté lors de la connexion, sinon l'opération échouera