Redis Sentinel est un processus dédié pour automatiser et simplifier le basculement et la bascule de la réplication Redis. Sans Sentinel, vous pourriez également gérer votre réplication Redis manuellement, en utilisant la commande SLAVEOF ou REPLICAOF. Sentinel nécessite un certain nombre d'instances, et fonctionne comme un groupe de décideurs, avant de décider quel nœud est actif ou inactif et quand le basculement doit être déclenché. En d'autres termes, Sentinel est le gestionnaire de basculement de réplication pour Redis.

Dans cet exemple, nous allons déployer une architecture simple de Redis hautement disponible avec Sentinel, comme illustré dans le diagramme suivant :

Nous aurons deux instances Redis sur deux nœuds différents - 1 maître et 1 réplique (ou esclave). Sentinel sera co-localisé sur ces 2 nœuds, plus un nœud supplémentaire sur un de nos serveurs web.

En général, on installe une instance de Redis sur le serveur web/application et on y accède via localhost ou via un fichier socket UNIX. Cela peut être considéré comme la manière la plus simple d'incorporer Redis dans l'application.

Pour une application évolutive et hautement disponible, Redis doit être déployé selon une approche centralisée, ou dans un niveau différent appelé niveau de cache. Cela permet aux instances Redis de travailler ensemble comme un fournisseur de cache dédié aux applications, en découplant les applications des dépendances locales de Redis.

Avant de déployer Redis Sentinel, nous devons déployer une réplication Redis composée de deux ou plusieurs instances Redis.

Commençons par installer Redis sur les deux serveurs, redis1 et redis2 :

$ sudo add-apt-repository ppa:redislabs/redis
$ sudo apt-get -y update
$ sudo apt-get -y install redis redis-sentinel net-tools

Ensuite, nous devons nous assurer que les lignes de configuration suivantes existent dans /etc/redis/redis.conf :

Pour Redis1 (master):

bind 127.0.0.1 192.168.44.71
protected-mode no
supervised systemd
masterauth SuperS3cr3tP455
masteruser masteruser
user masteruser +@all on >SuperS3cr3tP455

Pour Redis2 (replica):

bind 127.0.0.1 192.168.44.72
protected-mode no
supervised systemd
replicaof 192.168.44.71 6379
masterauth SuperS3cr3tP455
masteruser masteruser
user masteruser +@all on >SuperS3cr3tP455

Quelques explications :

• bind : Listez toutes les adresses IP que vous voulez que Redis écoute. Pour que Sentinel fonctionne correctement, Redis doit être joignable à distance. Nous devons donc lister l'interface avec laquelle Sentinel communiquera.
• protected-mode : Ce paramètre doit être défini sur “no” pour permettre à Redis de servir les connexions à distance. Ceci est également requis pour Sentinel.
• supervised : Nous utilisons les fichiers unitaires systemd par défaut fournis par le paquet d'installation. Pour Ubuntu 20.04, il utilise systemd comme gestionnaire de services, donc nous spécifions systemd ici.
• replicaof : Ceci est uniquement pour le nœud esclave. Pour la topologie originale, nous ferons de redis2 la réplique et de redis1 le maître.
• masterauth : Le mot de passe pour l'utilisateur masteruser.
• masteruser : Le nom d'utilisateur de l'utilisateur maître.
• user : Nous créons l'utilisateur maître ici. L'utilisateur ne doit avoir aucune limite (+@all) et un mot de passe. Cet utilisateur sera utilisé pour Redis pour gérer la réplication et le basculement par Sentinel.

Redémarrez Redis pour appliquer les changements et l'activer au démarrage :

$ sudo systemctl restart redis-server
$ sudo systemctl enable redis-server

Vérifiez que Redis fonctionne sur le port 6379 sur les deux interfaces.

Redis 1

$ sudo netstat -tulpn | grep -i redis
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      2266/redis-server 1
tcp        0      0 0.0.0.0:26379           0.0.0.0:*               LISTEN      2124/redis-sentinel
tcp        0      0 10.75.168.69:6379       0.0.0.0:*               LISTEN      2266/redis-server 1
tcp6       0      0 :::26379                :::*                    LISTEN      2124/redis-sentinel

Redis 2

$ sudo netstat -tulpn | grep -i redis
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      2266/redis-server 1
tcp        0      0 0.0.0.0:26379           0.0.0.0:*               LISTEN      2124/redis-sentinel
tcp        0      0 10.75.168.70:6379       0.0.0.0:*               LISTEN      2266/redis-server 1
tcp6       0      0 :::26379                :::*                    LISTEN      2124/redis-sentinel

Vérifiez que la réplication fonctionne.

Sur Redis1 :

$ redis-cli info replication
# Replication
role:master
connected_slaves:1
slave0:ip=10.75.168.70,port=6379,state=online,offset=56,lag=0
master_failover_state:no-failover
master_replid:da3d3f01cd00abbad99f6d7904e1a6be7d85fdf7
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:56
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:56

Faites attention aux clés role, connected_slaves et slave{i}. Cela indique que redis1 est le maître. Notez également qu'une réplique peut être le maître d'une autre réplique - c'est ce qu'on appelle la réplication en chaîne.

Sur Redis 2 :

$ redis-cli info replication
# Replication
role:slave
master_host:10.75.168.69
master_port:6379
master_link_status:up
master_last_io_seconds_ago:9
master_sync_in_progress:0
slave_read_repl_offset:56
slave_repl_offset:56
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:da3d3f01cd00abbad99f6d7904e1a6be7d85fdf7
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:56
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:15
repl_backlog_histlen:42

Faites attention au role, master_host, master_link_status et master_repl_offset. Le délai de réplication entre ces deux nœuds peut être déterminé par la valeur master_repl_offset sur les deux serveurs.

Redis Sentinel est essentiellement le même processus “redis-server” exécuté avec le paramètre “-sentinel” et des fichiers de configuration et des ports différents.

Pour une utilisation en production, il est fortement recommandé d'avoir au moins 3 instances de Sentinel pour une observation précise lors de l'exécution du basculement automatique.

Nous allons donc installer Sentinel sur les 2 nœuds Redis dont nous disposons, plus un de nos serveurs web, 192.168.44.70 (comme indiqué dans le schéma d'architecture).

Installez le paquet redis-sentinel sur le serveur web sélectionné (Sentinel est déjà installé sur nos hôtes Redis) :

$ sudo add-apt-repository ppa:redislabs/redis
$ sudo apt-get -y update
$ sudo apt-get -y install redis-sentinel net-tools

https://redis.io/