Installation Redis de la version Linux et configuration du cluster

1. Installez la version Linux de Redis

1. Installation et tests

1 : Installer l'environnement wget

yum -y install wget

2 : Téléchargez le package compressé Redis

3 : Exécutez la commande (installez l'environnement de langage C)

yum install gcc

4 : Après la décompression, entrez dans le répertoire racine Redis et exécutez make compilation

make

4 : Après une compilation réussie, entrez : make install

make install

5 : Démarrez redis (entrez src dans le répertoire redis et exécutez la commande suivante) Utilisez le fichier redis.conf pour démarrer

./redis-server ../redis.conf

2. Persistance Redis

Redis est une base de données en mémoire. Lorsque le serveur Redis est redémarré ou que l'ordinateur est redémarré, les données seront perdues. Nous pouvons conserver les données dans la mémoire Redis dans un fichier sur le disque dur.

Redis propose deux méthodes de persistance :

RDB : instantané, enregistré et conservé à partir du serveur

​ AOF : Log, l'opération génère des journaux pertinents et récupère les données via les journaux. couchDB ne modifie pas le contenu des données, mais l'ajoute uniquement, le fichier lui-même est donc un journal et aucune donnée ne sera perdue.

1. Le nom complet de RDB est la persistance du fichier de sauvegarde de la base de données Redis (fichier de sauvegarde des données Redis).

​ Écrivez l'instantané de l'ensemble de données dans la mémoire sur le disque dans l'intervalle de temps spécifié, qui est l'instantané Snapshot dans le jargon. Lorsqu'il est restauré, le fichier d'instantané est lu directement dans la mémoire. Redis créera (fork) un sous-processus séparément. Pour la persistance, les données seront d'abord écrites dans un fichier temporaire. Une fois le processus de persistance terminé, ce fichier temporaire sera utilisé pour remplacer le dernier fichier persistant. Pendant tout le processus, le processus principal n'effectue aucune opération d'E/S, ce qui garantit des performances extrêmement élevées. Si une récupération de données à grande échelle est requise et que l'intégrité de la récupération des données n'est pas très sensible, la méthode RDB est plus efficace que la méthode AOF. .de haute efficacité. L'inconvénient de RDB est que les données après la dernière persistance peuvent être perdues.

Remarque : La fonction de fork est de copier un processus identique au processus actuel. Toutes les données (variables, variables d'environnement, compteurs de programme, etc.) du nouveau processus ont les mêmes valeurs que le processus d'origine, mais il s'agit d'un processus complètement nouveau et sert de processus enfant du processus d'origine. le serveur Redis démarre, il videra automatiquement toutes les paires clé-valeur du fichier .rdb sont lues en mémoire.

Modifier le fichier de configuration redis.conf

RDB快照相关参数：
	save 900 1    #刷新快照到硬盘中，必须满足两者要求才会触发，即900秒之后至少1个关键字发生变化。
	save 300 10  #必须是300秒之后至少10个关键字发生变化。
	save 60 10000 #必须是60秒之后至少10000个关键字发生变化。
	上面三个参数屏闭后，rdb方式就关闭了
	
	stop-writes-on-bgsave-error yes    #后台存储错误停止写。
	rdbcompression yes    #使用LZF压缩rdb文件。
	rdbchecksum yes    #存储和加载rdb文件时校验。
	dbfilename dump.rdb    #设置rdb文件名。
	dir ./    #设置工作目录，rdb文件会写入该目录。

2. Persistance du journal AOF

config set appendonly yes
或者进入redis.conf 修改 appendonly = yes 默认是no

Principe du journal AOF

Idée : Chaque fois qu'un élément est écrit dans la mémoire, il est sauvegardé. L'intervalle de temps est de 1 seconde. Inconvénients : Le fichier est volumineux et les opérations d'écriture sont fréquentes.

• Enregistrez chaque opération d'écriture sous forme de journal, et enregistrez toutes les instructions d'écriture exécutées par Redis (les opérations de lecture ne sont pas enregistrées),

• Seuls les fichiers peuvent être ajoutés mais pas réécrits. Lorsque Redis démarre, il lira le fichier (fichier aof) et reconstruira les données. En d'autres termes, lorsque Redis redémarrera, il exécutera les instructions d'écriture d'avant en arrière en fonction du contenu de le fichier journal pour compléter les données. Retour au travail

• aof enregistre le fichier appendonly.aof

AOF日志相关参数:
	appendonly no # 是否打开aof日志功能  no:不开启   yes:开启日志
	appendfsync always   # 每1个命令,都立即同步到aof. 安全,速度慢
				everysec # 折衷方案,每秒写1次
				no      # 写入工作交给操作系统,由操作系统判断缓冲区大小,统一写入到aof. 同步频率低,速度快
	no-appendfsync-on-rewrite  no # 正在导出rdb快照的过程中,要不要停止同步aof

Configurer pour activer le journal AOF

Configurer le plan de stockage

3. Réécriture AOF

Réflexion : Si plusieurs opérations sont effectuées sur la même clé, comment afficher les enregistrements d'opérations dans le journal AOF, un ou n ?

​Cas : Créez un âge et modifiez la valeur cinq fois

Le journal enregistrera chaque étape de l'opération. Si une touche est actionnée plusieurs fois, il n'y aura qu'une seule performance dans les données mais n enregistrements dans le journal. Comment trouver la valeur correcte lorsque des données sont perdues et doivent être récupérées ?

Une de la réécriture consiste à inverser la clé et la valeur en mémoire en commandes redis et à les enregistrer dans le journal, qui est comme un résumé des opérations effectuées.

aof重写相关参数:
	no-appendfsync-on-rewrite  no # 正在导出rdb快照的过程中,要不要停止同步aof
	auto-aof-rewrite-percentage 100 #aof文件大小比起上次重写时的大小,增长率100%时,重写
	auto-aof-rewrite-min-size 64mb #aof文件,至少超过64M时,重写

Question : Pendant le processus de dump rdb, si l'aof arrête la synchronisation, sera-t-il perdu ?

Réponse : Non, toutes les opérations sont mises en cache dans la file d'attente mémoire. Une fois le vidage terminé, les opérations sont unifiées.

Q : Que signifie une réécriture ?

Réponse : La réécriture Aof fait référence à la conversion des données de la mémoire en commandes et à leur écriture dans le journal aof pour résoudre le problème du journal aof trop volumineux.

Question : Si le fichier rdb et le fichier aof existent, lequel doit être utilisé en premier pour récupérer les données ?

Réponse : aof

Question : Les deux types peuvent-ils être utilisés en même temps ?

Réponse : Oui, et c'est recommandé

Question : Lequel est le plus rapide à restaurer, rdb ou aof ?

Réponse : RDB est rapide car il s'agit d'un mappage mémoire de données et est chargé directement dans la mémoire, tandis qu'AOF est une commande et doit être exécutée une par une.

问题思考:在使用rdb做持久化时，我们关掉了redis服务，然后重新打开，保存的数据还在。但在做aof的时候我们将redis服务关闭后再打开数据就没有了。在上面不是配置过rdb持久化吗，为什么没起作用?
答：当rdb中有数据，并开启了AOF选项，重启redis服务后会产生一个空的aof文件，当rdb和aof文件都存在，会以aof文件来恢复数据。

3. Publication et abonnement de messages Redis

Redis publier et s'abonner (pub/sub) est un modèle de communication de messages : l'expéditeur (pub) envoie des messages et les abonnés (sub) reçoivent des messages.

Les clients Redis peuvent s'abonner à n'importe quel nombre de canaux.

Cas : Créer une borne d'abonnement aux messages

./redis-cli --raw   --打开redis客户端
SUBSCRIBE woniu     --订阅蜗牛频道信息

Cas : Créer un éditeur de messages

PUBLISH woniu '你好'  --发布 ”你好“ 信息

4. Configuration du cluster Redis

1. Redis réplication maître-esclave (Maître/Esclave)

a. Structure des clusters

Trois nœuds : un nœud maître et deux nœuds esclaves

b. Préparer les instances et les configurations

Ouvrez trois instances Redis dans la machine virtuelle pour simuler le mode cluster maître-esclave. Les informations sont les suivantes :

adresse IP	poste	Rôle
127.0.0.1	7001	maître
127.0.0.1	7002	esclave
127.0.0.1	7003	esclave

1. Créez trois dossiers dans le répertoire redis :

2. Copiez redis.conf dans trois dossiers :

 cp /redis/redis-6.0.6/redis.conf /redis/7001
 cp /redis/redis-6.0.6/redis.conf /redis/7002
 cp /redis/redis-6.0.6/redis.conf /redis/7003

3. Modifiez le port dans le fichier, l'emplacement de stockage du fichier RDB et l'adresse IP déclarée par l'instance Redis.

Par exemple instance 7001 :

dir ../../7001
port 7001

4. Démarrez trois services et entrez dans le répertoire src.

Par exemple, démarrez l'instance 7001 :

./redis-server ../../7001/redis.conf

5. Connectez-vous au client Redis

Par exemple, connectez-vous à l'instance 7001 :

./redis-cli -p 7001

C. Ouvrir la relation maître-esclave

Établissez une relation maître-esclave via des commandes :

Par exemple, connectez-vous au client 7002 et exécutez la commande. 7002 devient le nœud esclave de 7001.

redis-cli -p 7002 ouvre rapidement le client d'un certain port

SLAVEOF 127.0.0.1 7001

d. Vérifier la relation maître-esclave

Entrez le client de 7001 et entrez la commande

info replication

Principe de synchronisation maître-esclave

Principe : La première fois que le nœud esclave envoie une requête, il apporte sa propre réponse et son offset. Le nœud maître juge si elle est cohérente avec sa propre réplique et la transmet au nœud esclave. Le nœud esclave enregistre les informations de version. Le maître Le nœud exécute bgsave pour générer le fichier RDB et synchronise avec le nœud esclave, et le nœud esclave charge le fichier RDB pour réaliser la synchronisation des données. À ce moment, si une opération de modification se produit sur le nœud maître, un journal repl-baklog sera généré.

2. Mode Sentinelle (sentinelle)

Que se passe-t-il si le nœud maître tombe en panne ?

Surveillance : Sentinel vérifie en permanence si votre maître et votre esclave fonctionnent comme prévu

Récupération automatique en cas d'échec : si le maître échoue, Sentinel promouvra un esclave au rang de maître. Lorsque l'instance défaillante sera récupérée, le nouveau maître deviendra le maître.

Notification : Sentinel agit comme une source de découverte de services pour le client Redis. Lorsqu'un basculement se produit dans le cluster, les dernières informations seront transmises au client Redis.

Détection de l'état du service Sentinel, envoi d'une commande ping à chaque instance du cluster toutes les secondes

Hors ligne subjectif : si un nœud sentinelle constate qu'une instance ne répond pas dans le délai spécifié, l'instance est considérée comme étant subjectivement hors ligne.

Objectif hors ligne : Si toutes les sentinelles dépassant le nombre d'exécutions (quornum) considèrent l'instance hors ligne, l'instance sera objectivement hors ligne (le nombre de quornum est de préférence supérieur à la moitié du nombre total d'instances)

adresse IP	poste	Rôle
127.0.0.1	27001	maître
127.0.0.1	27002	esclave
127.0.0.1	27003	esclave

1. Créez trois dossiers dans le répertoire redis :

2. Créez un nouveau fichier sentinel.conf

Prenons l'exemple de 27001 :

port 27001
sentinel monitor mymaster 127.0.0.1 7001 2
sentinel down-after-milliseconds mymaster 50000
sentinel failover-timeout mymaster 180000
dir "/ding/s1"

3. Démarrez et entrez dans le répertoire src

redis-sentinel ../../s1/sentinel.conf