Parlons de l'architecture de réplication maître-esclave dans Redis6 et voyons quelles sont ses caractéristiques !

Cet article vous présentera l'architecture de réplication maître-esclave dans Redis6 et présentera les caractéristiques de la réplication maître-esclave dans Redis6. J'espère qu'il sera utile à tout le monde !

Introduction à la réplication maître-esclave

La réplication maître-esclave fait référence à la copie de données d'un serveur Redis vers d'autres serveurs Redis. Le premier est le nœud maître (maître) et le second devient le nœud esclave (esclave) ; la réplication des données est unidirectionnelle et ne peut s'effectuer que du nœud maître vers le nœud esclave. Par défaut, chaque serveur Redis est un nœud maître, et un nœud maître peut avoir plusieurs nœuds esclaves (ou aucun nœud esclave), mais un nœud esclave ne peut avoir qu'un seul nœud maître. [Recommandations associées : Tutoriel vidéo Redis]

Les avantages de l'utilisation de la réplication maître-esclave : séparation de la lecture et de l'écriture, qui peut augmenter la capacité de lecture du nœud maître et partager la pression sur le nœud maître. Pour la reprise après sinistre, une fois le nœud maître en panne, le nœud esclave peut être utilisé comme sauvegarde du nœud maître et peut être installé à tout moment.

Introduction à l'architecture

Le nœud esclave copie les données du nœud maître Après la copie, nous pouvons effectuer une séparation en lecture-écriture. S'il s'agit d'un nœud unique, les requêtes applicatives sont concentrées sur le nœud maître, mais avec le nœud esclave, il peut supporter une partie de la pression de lecture. Le nœud maître peut effectuer des opérations de lecture et d'écriture, tandis que le nœud esclave ne peut effectuer que des opérations de lecture. Cela partagera la pression sur le nœud maître.

Réplication maître-esclave Redis, préparation de l'environnement d'architecture un maître et deux esclaves

Après avoir parlé de tant de concepts, commençons à déployer l'architecture de réplication maître-esclave de Redis. Cette fois, nous déployons un maître-esclave. et une architecture à deux esclaves.

#创建文件
mkdir -p /data/redis/master/data
mkdir -p /data/redis/slave1/data
mkdir -p /data/redis/slave2/data

#从节点开启只读模式(默认)
replica-read-only yes

#从节点访问主节点的密码，和requirepass⼀样
masterauth 123456
    
#哪个主节点进⾏复制
replicaof 8.129.113.233 6379

Créez d'abord un nœud maître, touchez un fichier redis.conf dans le répertoire data/redis/master/data, éditez le fichier redis.conf

bind 0.0.0.0
port 6379
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis1.log"
dbfilename "xdclass1.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly1.aof"
masterauth "123456"

Créez ensuite le nœud esclave 1, dans le répertoire data/redis/slave1/data répertoire Construisez redis.conf

bind 0.0.0.0
port 6380
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis2.log"
dbfilename "xdclass2.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly2.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

Créez le nœud esclave 2 et construisez redis.conf

bind 0.0.0.0
port 6381
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis3.log"
dbfilename "xdclass3.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly3.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

dans le répertoire data/redis/slave2/data Remarque : N'oubliez pas de désactiver le pare-feu et d'ouvrir le groupe de sécurité réseau. le serveur Alibaba Cloud.

Démarrez le nœud configuré après la création

Méthode de démarrage :

#启动主
./redis-server/data/redis/master/data/redis.conf
#启动从1
./redis-server/data/redis/slave1/data/redis.conf
#启动从2
./redis-server/data/redis/slave2/data/redis.conf

Utilisez la réplication des informations pour afficher l'état du nœud actuel

Réplication maître-esclave et vérification en lecture-écriture

1.在主节点创建一个key
set name jack
2.在两个从节点测试是否能拿到主节点的数据
get name
3.在从节点set key是失败的，因为从节点只支持读操作

Architecture maître-esclave Redis6 - réplication Analyse du principe de séparation lecture-écriture

La réplication maître-esclave est divisée en deux types : l'un est une synchronisation complète lorsque le maître-esclave se connecte pour la première fois ; l'autre est une synchronisation incrémentielle une fois la synchronisation complète terminée.

Copie complète : le serveur maître démarrera un processus en arrière-plan pour générer un fichier rdb à partir des données Redis. Le serveur maître mettra en cache toutes les commandes d'écriture reçues du client. Lorsque le processus est enregistré en arrière-plan, le fichier rdb sera transmis. vers le serveur esclave A ce moment, le serveur esclave dispose des données du serveur maître. Après cela, le serveur maître enverra les commandes mises en cache pendant cette période au serveur esclave via le protocole de transmission Redis, puis le serveur esclave utilisera à son tour ces commandes localement, obtenant finalement la cohérence des données

Réplication incrémentielle : Le Le nœud maître continuera à écrire des commandes. Lorsque l'esclave termine son initialisation et commence à fonctionner, le processus par lequel le serveur maître envoie des opérations d'écriture pour les synchroniser avec le serveur est appelé réplication incrémentielle. La réplication incrémentielle signifie que chaque fois que le serveur exécute une commande d'écriture, il envoie la même commande d'écriture au serveur esclave, et le serveur esclave accepte et exécute la commande d'écriture reçue.

Quelles sont les caractéristiques de la réplication maître-esclave :

La réplication maître-esclave est non bloquante pour le serveur maître/esclave Toutes les requêtes externes peuvent être traitées normalement lors de la synchronisation des données. nœuds esclaves, chaque nœud esclave peut accepter des connexions provenant d’autres nœuds esclaves. Le nœud esclave ne laissera pas la clé expirer. Au lieu de cela, une fois la clé du nœud maître expirée et supprimée, il enverra une commande de suppression au nœud esclave pour la supprimer.

Réplication accélérée : lorsque le nœud termine la resynchronisation, vous devez créer un fichier RDB sur le disque, puis charger ce fichier pour envoyer des données depuis le serveur, mais que se passe-t-il si le débit du disque est relativement faible ? Cela entraînera une incohérence des données entre le nœud maître et le nœud esclave. Dans la nouvelle version de Redis, la réplication sans disque est prise en charge et les fichiers RBD sont directement envoyés au serveur esclave via le réseau, sans utiliser de disques comme middleware.

Si la connexion maître-esclave est déconnectée, la réplication peut être poursuivie là où elle a été interrompue après la reconnexion sans resynchronisation. Après la version 2.8, cette nouvelle fonctionnalité de resynchronisation utilise la commande PSYNC, tandis que l'ancienne utilise la commande SYNC

Pour plus de connaissances liées à la programmation, veuillez visiter : Vidéo de programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!