didacticiel graphique du cluster Redis Sentinel

Sentinel est une solution haute disponibilité pour Redis : un système Sentinel composé d'une ou plusieurs instances Sentinel peut surveiller n'importe quel nombre de serveurs maîtres et les serveurs sous ces serveurs maîtres. , et lorsque le serveur maître surveillé se déconnecte, met automatiquement à niveau un serveur esclave sous le serveur maître hors ligne vers le nouveau serveur maître. Recommandé : Tutoriel vidéo Redis

Par exemple :

Après la mise hors ligne du serveur 1 :

Mettez à niveau le serveur2 vers le nouveau serveur maître :

2. Séparation maître-esclave Redis

.

Avant d'expliquer le cluster Sentinel, construisons d'abord une simple séparation maître-esclave (séparation lecture-écriture).

Tout d'abord, par défaut tout le monde a installé redis, puis nous allons copier redis.conf en plusieurs copies et créer plusieurs répertoires pour distinguer plusieurs services redis :

Ici, chaque répertoire a son propre fichier de configuration redis.conf. Ensuite, nous définissons d'abord le fichier de configuration du serveur principal.

1. Configurer le maître

1. Modifier le port

# Accept connections on the specified port, default is 6379 (IANA #815344).
# If port 0 is specified Redis will not listen on a TCP socket.
port 6380

Le port par défaut de redis est 6379. Ici, nous définissons le port du serveur principal sur 6380

2. Modifier le fichier pid

# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
# Creating a pid file is best effort: if Redis is not able to create it
# nothing bad happens, the server will start and run normally.
pidfile /var/run/redis_6380.pid

pidfile est un numéro de processus pid qui nous est attribué par Linux lorsque nous démarrons Redis. S'il n'est pas modifié ici, il affectera le démarrage ultérieur du service Redis

3. Démarrez redis

Démarrez redis, on voit que redis a occupé le port 6380

Entrez le client

redis-cli -p 6380
127.0.0.1:6380> info
...
# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
...

us Comme vous pouvez le voir, le rôle actuel de redis est un service démarré par le maître.

2. Configurer l'esclave

Identique à la configuration du maître ci-dessus, nous devons modifier le numéro de port et le fichier pid. Après modification, nous avons deux méthodes pour configurer le service esclave

1. Configurez le service esclave dans le fichier de configuration

################################# REPLICATION #################################

# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of slaves.
# 2) Redis slaves are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition slaves automatically try to reconnect to masters
#    and resynchronize with them.
#
# slaveof <masterip> <masterport>
slaveof 127.0.0.1 6380

On peut modifier directement l'attribut slaveof dans le fichier de configuration On configure directement l'adresse IP et le numéro de port du serveur principal ici. un mot de passe de configuration

Vous pouvez définir le mot de passe du lien en configurant masterauth

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#
# masterauth <master-password>

Démarrez le service redis :

On peut voir ça là il y en a deux en cours d'exécution maintenant, nous entrons dans le client de 6381 et regardons son statut

# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:71
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

Nous pouvons voir que le redis actuel est un service esclave, connecté au service de 6380.

2. Configurer après le démarrage du service

Après avoir modifié le fichier de configuration du serveur du port 6382, démarrez le service

Entrée le client, Vérifiez l'état du serveur actuel :

# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

Nous pouvons voir que l'état du serveur actuel est exécuté en tant que service principal Modifions ensuite son état :

127.0.0.1:6382> slaveof 127.0.0.1 6380

//修改后状态
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:617
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

3. Résumé

Regardons d'abord l'état actuel du maître :

# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=785,lag=0
slave1:ip=127.0.0.1,port=6382,state=online,offset=785,lag=0
master_repl_offset:785
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:784

Nous pouvons voir que les deux services esclaves sont déjà connectés au serveur maître. La différence entre les deux configurations ci-dessus. c'est que lorsque le salve est déconnecté Après la reconnexion de la ligne,

Si on modifie le fichier de configuration de la classe, on se connectera au maître après reconnexion et synchronisera les données sur le maître

Si. nous nous connectons manuellement au serveur principal, après la reconnexion, le serveur esclave lira ses propres données de réponse rdb locales et ne se connectera pas automatiquement au service principal

Si nous devons configurer une séparation lecture-écriture, nous seulement besoin de le définir sur le serveur principal :

# Note: read only slaves are not designed to be exposed to untrusted clients
# on the internet. It's just a protection layer against misuse of the instance.
# Still a read only slave exports by default all the administrative commands
# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
# security of read only slaves using 'rename-command' to shadow all the
# administrative / dangerous commands.
slave-read-only yes

3. Sentinel 1. Dans le fichier de configuration sentinel.conf, nous pouvons trouver l'attribut de port, utilisé ici pour définir le port de sentinel. Dans des circonstances normales, au moins trois sentinelles sont nécessaires pour surveiller Redis. Nous pouvons démarrer plusieurs services sentinelles en modifiant le port.

# port <sentinel-port># The port that this sentinel instance will run on
port 26379

2. Configurez l'IP et le port du serveur principal

Nous changeons le port d'écoute en 6380, et ajoutons un poids de 2. Le poids ici est utilisé pour calculer ce dont nous avons besoin. Le serveur doit être mis à niveau vers le serveur principal

# sentinel monitor <master-name> <ip> <redis-port> <quorum>
#
# Tells Sentinel to monitor this master, and to consider it in O_DOWN
# (Objectively Down) state only if at least <quorum> sentinels agree.
#
# Note that whatever is the ODOWN quorum, a Sentinel will require to
# be elected by the majority of the known Sentinels in order to
# start a failover, so no failover can be performed in minority.
#
# Slaves are auto-discovered, so you don&#39;t need to specify slaves in
# any way. Sentinel itself will rewrite this configuration file adding
# the slaves using additional configuration options.
# Also note that the configuration file is rewritten when a
# slave is promoted to master.
#
# Note: master name should not include special characters or spaces.
# The valid charset is A-z 0-9 and the three characters ".-_".
sentinel monitor mymaster 127.0.0.1 6380 2

3. Démarrez Sentinel

/sentinel$ redis-sentinel sentinel.conf

Après le démarrage de Sentinel, il surveillera qu'il existe désormais un serveur principal. Deux serveurs esclaves

当我们把其中一个从服务器器关闭之后，我们可以看到日志：

10894:X 30 Dec 16:27:03.670 # +sdown slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 6380

日志表示，6381这个从服务器已经从主服务器中脱离了出来，我们重新把6381 接回去。

10894:X 30 Dec 16:28:43.288 * +reboot slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 638010894:X 30 Dec
16:28:43.365 # -sdown slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 6380

4、关闭Master 

我们手动关闭Master 之后，sentinel 在监听master 确实是断线了之后，将会开始计算权值，然后重新分配主服务器

我们可以看到，6380主服务器断了之后，sentinel 帮我们选了6382作为新的主服务器

我们进到6382的客户端，查看他的状态：

# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=13751,lag=0
master_repl_offset:13751
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:13750

我们可以看到 6382，重slave 荣升为master 

127.0.0.1:6382> set name jaycekon
OK

原本的没有权限写，也得到了相应的权限

5、重连Master

大家可能会好奇，如果master 重连之后，会不会抢回属于他的位置，答案是否定的，就比如你被一个小弟抢了你老大的位置，他肯给回你这个位置吗。因此当master 回来之后，他也只能当个小弟　　

4、Sentinel 总结

一、Sentinel的作用：

A、Master 状态监测

B、如果Master 异常，则会进行Master-slave 转换，将其中一个Slave作为Master，将之前的Master作为Slave 

C、Master-Slave切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换 

二、Sentinel的工作方式:

1)：每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令 

2)：如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。 

3)：如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。 

4)：当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线 

5)：在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令 

6)：当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次 

7)：若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。 

若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

更多redis相关文章请关注redis数据库教程栏目。

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!