Redis prend non seulement en charge le mode cluster décentralisé, mais peut également implémenter des clusters de réplication maître-esclave. Ci-dessous, je vais créer étape par étape un cluster de réplication maître-esclave simple pour aider tout le monde à comprendre la réplication maître-esclave et le mode sentinelle.
Avant de commencer le texte, permettez-moi d'abord de vous expliquer les différents concepts impliqués pour vous faire gagner du temps dans Baidu.
Un cluster fait référence à plusieurs instances du même composant formant un tout logique.
La réplication maître-esclave est une solution de sauvegarde des données. Pour faire simple, deux bases de données identiques ou plus sont utilisées, une base de données est utilisée comme base de données maître et l'autre base de données est utilisée comme base de données esclave. Lors de l'exécution des opérations correspondantes dans la base de données maître, la base de données esclave enregistre toutes les opérations de la base de données maître afin qu'elles soient exactement les mêmes.
La séparation de la lecture et de l'écriture est un moyen d'utiliser la base de données pour la rendre plus stable.
Il est utilisé lorsqu'il existe une base de données esclave. Lorsque la base de données maître ajoute, supprime ou modifie des données, c'est-à-dire écrit, la tâche de requête est transférée à la base de données esclave. La séparation des opérations de lecture et des opérations d'écriture peut augmenter considérablement la capacité de chargement simultané de la base de données.
1. Téléchargez et installez Redis
Veuillez vous référer à : L'ensemble du processus d'installation, de configuration et de démarrage de Redis sous Linux (centos7) et la résolution du problème d'erreur de création
2. Modèle de réplication maître-esclave
J'ai dessiné un croquis. Il s'agit d'un modèle de cluster simple avec un maître et deux esclaves. Le maître est utilisé pour l'écriture et l'esclave est utilisé pour lire les données afin d'obtenir une séparation de la lecture et de l'écriture. Notre prochaine étape consiste à mettre en œuvre un tel système de cluster.
3. Configurer l'environnement de cluster
J'ai utilisé une machine virtuelle centos7 pour créer cette démo. L'environnement requis est :
JDK, Linux et Redis.
Copiez plusieurs fichiers redis.conf et démarrez le serveur Redis en utilisant différents fichiers de configuration pour simuler plusieurs services.
1. Démarrez votre service Redis et entrezréplication des informationsCommande pour afficher des informations sur la bibliothèque actuelle
127.0.0.1:6379> info replication
# Replication
role:master //当前库为master
connected_slaves:0 //连接当前master的从机数目为0
master_replid:7b7cb8aa6a54e4fb2b717e59d6d626578c7b7f3f
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
Une fois le cluster déployé, vous pouvez utiliser cette commande pour afficher les informations.
2. Créez un nouveau répertoire conf et copiez le fichier de configuration redis trois fois dans le répertoire conf.
[root@localhost bin]# mkdir conf
[root@localhost bin]# cp redis.conf conf/redis6380.conf
[root@localhost bin]# cp redis.conf conf/redis6381.conf
[root@localhost bin]# cp redis.conf conf/redis6382.conf
De cette façon, nous obtenons trois fichiers de configuration. Apportons-y quelques modifications.
3. Modifiez le fichier de configuration de l'hôte
Nous configurons redis6380.conf comme hôte (maître)
et entrons dans le répertoire conf.vim redis6380.confModifier le fichier de configuration
- Nous devons d'abord changer le numéro de port pour qu'il corresponde au nom du fichier de configuration
- N'oubliez pas de le remplacer par oui lors de l'exécution en arrière-plan
- Changez le nom du fichier pid pour éviter la duplication
- Modifiez le nom du fichier journal pour éviter la duplication
- Changer le nom du fichier rdb pour éviter la duplication
4. Pour modifier le fichier de configuration de l'esclave, reportez-vous à la méthode de modification de l'hôte.
Les modifications apportées à l'hôte sont toutes les mêmes. Nous pouvons définir les ports respectivement sur 6381 et 6382. Modifiez le fichier journal et le fichier rdb de la même manière pour éviter la duplication des noms.
Si vous souhaitez configurer la réplication maître-esclave directement via le fichier de configuration, vous devez alors ajouter une configuration lors de la modification du fichier de configuration esclave :esclave de 127.0.0.1 6380, en spécifiant l'adresse de leur serveur hôte.
De cette façon, ils démarreront directement en tant qu'esclaves. Pour le moment, veuillez ignorer l'étape d'entrée esclave de l'étape ci-dessous.
5. Commencez séparément
Nous pouvons démarrer plusieurs terminaux de commande pour les ouvrir séparément, ou utiliser Xshell sur plusieurs pages à onglets.
Exécutez les commandes suivantes pour chacune d'elles (notez la modification du numéro de port) :
Une fois que toutes sont démarrées, vérifiez les informations du processus et confirmez à nouveaups -ef|grep redis:
L'image ci-dessus montre que tous les services ont été démarrés avec succès et que l'environnement de cluster a été configuré.
4. Configurer la réplication maître-esclave (slaveof)
Maintenant, nous pouvons entrer dans chaque serviceréplication des informations, vous constaterez que les trois redis sont désormais des hôtes et qu'il n'y a aucune connexion entre eux. Nous devons le configurer manuellement.
- Ouvrez le client 6381 et utilisezesclave de 127.0.0.1 6380commande, en spécifiant son adresse hôte. Alorsréplication des informationsVous constaterez que son identité devient une machine esclave.
De même, spécifiez 6380 comme hôte pour 6382, ce qui forme essentiellement une situation de maître et deux esclaves, dans laquelle 6380 est l'hôte commun et 6381/6382 sont des esclaves.
Vous pouvez lire et écrire certaines données sur des clients séparés. Vous constaterez que l'hôte peut lire et écrire, l'esclave ne peut que lire et les données sont partagées entre eux. Par exemple, vous pouvez définir plusieurs variables sur le maître, puis utiliser le client esclave pour accéder à ces variables.
Remplir
réplication maître-esclave en cascade Redis
Redis ne peut s'empêcher de prendre en charge la réplication maître-esclave d'un maître et de plusieurs esclaves, et prend également en charge le mode cascade illustré dans la figure ci-dessous : Le mode
de mise en œuvre est similaire à celui d'un maître et de plusieurs esclaves mentionné ci-dessus, c'est-à-dire le service esclave. peut également être utilisé comme maître des autres, en utilisant la commande slaveof Just baby.
Configurer la réplication maître-esclave via les fichiers de configuration
Pour utiliser le fichier de configuration pour configurer le service de réplication maître-esclave, il vous suffit d'ajouter une configuration au fichier de configuration du serveur esclave. Le service maître n'a pas besoin d'apporter de modifications. La configuration est la suivante :
slaveof [host] [ port]
où host dans la formule ci-dessus est l'adresse du serveur maître. port est le port du serveur principal, exemple :
slaveof 127.0.0.1 6379
Principe de réplication maître-esclave Redis
Le processus de synchronisation de réplication maître-esclave Redis est divisé en deux types : synchronisation complète et synchronisation incrémentielle. Lorsque le maître-esclave vient d'être connecté, une synchronisation complète est effectuée ; une fois la synchronisation complète terminée, une synchronisation incrémentielle est effectuée. Bien entendu, si nécessaire, l'esclave peut à tout moment lancer une synchronisation complète.
Alors, que sont la synchronisation complète et la synchronisation incrémentielle ? En fait, en termes simples, le processus de synchronisation de toutes les données du serveur maître vers le serveur esclave est une synchronisation complète. Comme vous pouvez l'imaginer, ce processus devrait prendre beaucoup de temps et de main d'œuvre ; tandis que la synchronisation incrémentielle signifie que le serveur esclave synchronise uniquement les dernières données écrites et modifiées. Les données sont envoyées à chaque extension chaque fois que le serveur principal exécute une commande d'écriture pour obtenir une réplication incrémentielle, ce qui est très rapide.
La stratégie Redis est que, quoi qu'il arrive, une synchronisation incrémentielle sera tentée en premier, et en cas d'échec, la machine esclave devra effectuer une synchronisation complète.
Voici les concepts détaillés de la synchronisation complète et de la synchronisation incrémentielle :
Synchronisation complète
La copie complète de Redis se produit généralement lors de la phase d'initialisation de l'esclave. À ce moment-là, l'esclave doit copier toutes les données sur le maître. Les étapes spécifiques sont les suivantes :
- Le serveur esclave se connecte au serveur maître et envoie la commande SYNC ;
- Après avoir reçu le nom SYNC, le serveur principal commence à exécuter la commande BGSAVE pour générer un fichier RDB et utilise le tampon pour enregistrer toutes les commandes d'écriture exécutées par la suite ;
- Une fois que le serveur maître BGSAVE est exécuté, il envoie des fichiers d'instantanés à tous les serveurs esclaves et continue d'enregistrer les commandes d'écriture exécutées pendant la période d'envoi ;
- Après avoir reçu le fichier d'instantané du serveur, supprimez toutes les anciennes données et chargez l'instantané reçu ;
- Une fois l'instantané du serveur maître envoyé, il commence à envoyer la commande d'écriture dans le tampon au serveur esclave ;
- Le serveur esclave termine le chargement de l'instantané, commence à recevoir des demandes de commandes et exécute des commandes d'écriture à partir du tampon du serveur maître ;
Après avoir terminé les étapes ci-dessus, toutes les opérations d'initialisation des données du serveur esclave sont terminées. Le serveur esclave peut désormais recevoir les demandes de lecture des utilisateurs.
Synchronisation incrémentielle
La réplication incrémentielle Redis fait référence au processus dans lequel les opérations d'écriture qui se produisent sur le serveur maître sont synchronisées avec le serveur esclave lorsque l'esclave est initialisé et commence à fonctionner normalement.
Le processus de réplication incrémentielle consiste principalement à ce que chaque fois que le serveur maître exécute une commande d'écriture, il envoie la même commande d'écriture au serveur esclave, et le serveur esclave reçoit et exécute la commande d'écriture reçue.
Remarque :
Si plusieurs esclaves sont déconnectés et doivent être redémarrés, tant que l'esclave démarre, il enverra une demande de synchronisation et se synchronisera entièrement avec l'hôte. Lorsque plusieurs esclaves apparaissent en même temps, cela peut entraîner une forte augmentation du nombre de maîtres. Temps d'arrêt des E/S.
Développer les connaissances
La configuration de la réplication maître-esclave Redis est très simple, elle peut faire du serveur esclave une copie complète du serveur maître. Il y a plusieurs points importants à comprendre concernant la réplication maître-esclave Redis :
1) Redis utilise la réplication asynchrone. Mais à partir de Redis 2.8, le serveur esclave répondra périodiquement à la quantité de données traitées à partir du flux de réplication.
2) Un serveur maître peut avoir plusieurs serveurs esclaves.
3) Le serveur esclave peut également accepter les connexions d'autres serveurs esclaves. En plus de plusieurs serveurs esclaves connectés à un serveur maître, plusieurs serveurs esclaves peuvent également être connectés à un serveur esclave pour former une
structure de type graphique.
4) La réplication maître-esclave Redis ne bloque pas le serveur maître. C'est-à-dire que lorsque plusieurs serveurs esclaves effectuent une synchronisation initiale, le serveur maître peut toujours traiter les requêtes.
5) La réplication maître-esclave ne bloque pas le côté serveur esclave. Lorsque le serveur esclave effectue la synchronisation initiale, il utilise l'ancienne version des données pour répondre aux requêtes, en supposant que vous l'ayez configuré dans le fichier de configuration redis.conf. Sinon, vous pouvez configurer l'esclave pour qu'il renvoie une erreur au client lorsque le flux de réplication est fermé. Cependant, lorsque la synchronisation initiale est terminée, l'ancien ensemble de données doit être supprimé et le nouvel ensemble de données doit être chargé. Pendant cette courte période, le serveur esclave bloquera les requêtes entrantes.
6) La réplication maître-esclave peut être utilisée pour améliorer l'évolutivité, en utilisant plusieurs serveurs esclaves pour gérer les requêtes en lecture seule (par exemple, des opérations de tri lourdes peuvent être effectuées sur les serveurs esclaves), ou elle peut être simplement utilisée pour la redondance des données.
7) L'utilisation de la réplication maître-esclave peut éviter au serveur maître la consommation d'écriture de données sur le disque : configurez "Éviter l'enregistrement" dans le fichier redis.conf du serveur maître (commentez toutes les commandes "enregistrer"), puis connectez un serveur configuré comme "Proceed". Cliquez simplement sur "Save" sur le serveur esclave. Mais cette configuration doit garantir que le serveur principal ne redémarrera pas automatiquement
Dans le prochain article, nous configurerons le mécanisme sentinelle pour qu'ils se préparent à la situation particulière de panne de l'hôte.