Clúster centinela de replicación maestro-esclavo de Redis

1. Replicación maestro-esclavo de Redis

1.1 Introducción a la replicación maestro-esclavo de Redis

• La replicación maestro-esclavo se refiere a copiar los datos de un servidor Redis a otros servidores Redis. El primero se denomina nodo maestro (Master), y el segundo se denomina nodo esclavo (Slave); la replicación de datos es unidireccional, solo del nodo maestro al nodo esclavo.
• De forma predeterminada, cada servidor de Redis es un nodo maestro y un nodo maestro puede tener varios nodos esclavos (o ningún nodo esclavo), pero un nodo esclavo solo puede tener un nodo maestro.

1. Replicación maestro-esclavo: la replicación maestro-esclavo es la base de Redis de alta disponibilidad. Los centinelas y los clústeres se basan en la replicación maestro-esclavo para lograr una alta disponibilidad. La replicación maestro-esclavo implementa principalmente copias de seguridad de datos en varias máquinas, así como equilibrio de carga para operaciones de lectura y recuperación de fallas simple. Defectos: la recuperación de fallas no se puede automatizar; las operaciones de escritura no se pueden equilibrar en la carga; la capacidad de almacenamiento está limitada por una sola máquina.
2. Sentinel: basado en la replicación maestro-esclavo, Sentinel realiza una recuperación automática de fallas. Defectos: las operaciones de escritura no se pueden equilibrar en la carga; la capacidad de almacenamiento está limitada por una sola máquina; Sentinel no puede conmutar por error automáticamente los nodos esclavos. En el escenario de separación de lectura y escritura, la falla del nodo esclavo hará que los servicios de lectura no estén disponibles y la supervisión adicional de Se requieren nodos esclavos, operación de interruptor.
3. Agrupación: a través de la agrupación, Redis resuelve el problema de que las operaciones de escritura no pueden equilibrarse con la carga, y la capacidad de almacenamiento está limitada por una sola máquina, y realiza una solución de alta disponibilidad relativamente completa.

1.2 El papel de la replicación maestro-esclavo

1. Redundancia de datos: la replicación maestro-esclavo realiza una copia de seguridad activa de los datos, que es un método de redundancia de datos distinto de la persistencia.
2. Recuperación de fallas: cuando hay un problema con el nodo maestro, el nodo esclavo puede proporcionar servicios para lograr una rápida recuperación de fallas, en realidad es un tipo de redundancia de servicio.
3. Equilibrio de carga: sobre la base de la replicación maestro-esclavo, combinada con la separación de lectura y escritura, el nodo maestro puede proporcionar servicios de escritura y los nodos esclavos pueden proporcionar servicios de lectura (es decir, la aplicación se conecta al nodo maestro al escribir). datos de Redis, y la aplicación se conecta al nodo esclavo cuando lee datos de Redis. nodo) para compartir la carga del servidor; especialmente en el escenario de escribir menos y leer más, compartir la carga de lectura a través de múltiples nodos esclavos puede aumentar considerablemente la concurrencia de los servidor Redis.
4. La piedra angular de la alta disponibilidad: además de las funciones anteriores, la replicación maestro-esclavo también es la base para la implementación de centinelas y clústeres. Por lo tanto, la replicación maestro-esclavo es la base para la alta disponibilidad de Redis.

1.3 El proceso de replicación maestro-esclavo

1. Si se inicia un proceso de máquina esclava, enviará un comando de "comando de sincronización" a la máquina maestra para solicitar una conexión síncrona.
2. Ya sea la primera conexión o la reconexión, la máquina Maestra iniciará un proceso en segundo plano para guardar la instantánea de datos en el archivo de datos (ejecutar la operación rdb), y la Maestra también registrará todos los comandos para modificar los datos y los almacenará en caché. el archivo de datos
3. Después de que el proceso en segundo plano complete la operación de caché, la máquina maestra enviará el archivo de datos a la máquina esclava, y la máquina esclava guardará el archivo de datos en el disco duro y luego lo cargará en la memoria, y luego la máquina maestra La máquina modificará todas las operaciones de los datos. Envíelos juntos a la máquina final Esclava. Si el Esclavo falla y provoca un tiempo de inactividad, se volverá a conectar automáticamente después de volver a la normalidad.
4. Después de que la máquina maestra recibe la conexión de la máquina esclava, envía su archivo de datos completo a la máquina esclava.Si la máquina maestra recibe solicitudes de sincronización de varios esclavos al mismo tiempo, la maestra iniciará un proceso en segundo plano para guardar el archivo de datos y luego envíelo a todas las máquinas del lado esclavo para asegurarse de que todas las máquinas del lado esclavo sean normales.

2. Cree la replicación maestro-esclavo de Redis

Master节点：192.168.80.10
Slave1节点：192.168.80.11
Slave2节点：192.168.80.12

2.1 Instalar Redis

//环境准备
systemctl stop firewalld
systemctl disable firewalld
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

#修改内核参数
vim /etc/sysctl.conf
vm.overcommit_memory = 1
net.core.somaxconn = 2048

sysctl -p


//安装redis
yum install -y gcc gcc-c++ make

tar zxvf /opt/redis-7.0.9.tar.gz -C /opt/
cd /opt/redis-7.0.9
make
make PREFIX=/usr/local/redis install
#由于Redis源码包中直接提供了 Makefile 文件，所以在解压完软件包后，不用先执行 ./configure 进行配置，可直接执行 make 与 make install 命令进行安装。

2.2 Crear directorio de trabajo redis

mkdir /usr/local/redis/{conf,log,data}

cp /opt/redis-7.0.9/redis.conf /usr/local/redis/conf/

useradd -M -s /sbin/nologin redis
chown -R redis.redis /usr/local/redis/

2.3 Variables de entorno

vim /etc/profile 
PATH=$PATH:/usr/local/redis/bin		#增加一行

source /etc/profile

2.4 Definir el script de gestión de servicios systemd

vim /usr/lib/systemd/system/redis-server.service
[Unit]
Description=Redis Server
After=network.target

[Service]
User=redis
Group=redis
Type=forking
TimeoutSec=0
PIDFile=/usr/local/redis/log/redis_6379.pid
ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

2.5 Modificar el archivo de configuración de Redis (Operación del nodo maestro)

vim /usr/local/redis/conf/redis.conf
bind 0.0.0.0									#87行，修改监听地址为0.0.0.0
protected-mode no								#111行，将本机访问保护模式设置no
port 6379										#138行，Redis默认的监听6379端口
daemonize yes									#309行，设置为守护进程，后台启动
pidfile /usr/local/redis/log/redis_6379.pid		#341行，指定 PID 文件
logfile "/usr/local/redis/log/redis_6379.log"	#354行，指定日志文件
dir /usr/local/redis/data						#504行，指定持久化文件所在目录
#requirepass abc123								#1037行，可选，设置redis密码
appendonly yes									#1380行，开启AOF


systemctl restart redis-server.service

2.6 Modificar el archivo de configuración de Redis (Operación de nodo esclavo)

vim /usr/local/redis/conf/redis.conf
bind 0.0.0.0									#87行，修改监听地址为0.0.0.0
protected-mode no								#111行，将本机访问保护模式设置no
port 6379										#138行，Redis默认的监听6379端口
daemonize yes									#309行，设置为守护进程，后台启动
pidfile /usr/local/redis/log/redis_6379.pid		#341行，指定 PID 文件
logfile "/usr/local/redis/log/redis_6379.log"	#354行，指定日志文件
dir /usr/local/redis/data						#504行，指定持久化文件所在目录
#requirepass abc123								#1037行，可选，设置redis密码
appendonly yes									#1380行，开启AOF
replicaof 192.168.80.10 6379					#528行，指定要同步的Master节点IP和端口
#masterauth abc123								#535行，可选，指定Master节点的密码，仅在Master节点设置了requirepass


systemctl restart redis-server.service

2.7 Verificar el efecto maestro-esclavo

在Master节点上看日志：
tail -f /usr/local/redis/log/redis_6379.log 
Replica 192.168.80.11:6379 asks for synchronization
Replica 192.168.80.12:6379 asks for synchronization
Synchronization with replica 192.168.80.11:6379 succeeded
Synchronization with replica 192.168.80.12:6379 succeeded

在Master节点上验证从节点：
redis-cli info replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.80.11,port=6379,state=online,offset=1246,lag=0
slave1:ip=192.168.80.12,port=6379,state=online,offset=1246,lag=1

3. Modo centinela Redis

3.1 ¿Qué es el modo centinela?

• El método de la tecnología de conmutación maestro-esclavo es: cuando el servidor está inactivo, es necesario cambiar manualmente una máquina esclava a la máquina maestra, lo que requiere una intervención manual, que no solo requiere mucho tiempo y es laboriosa, sino que también hace que el servicio no estar disponible por un período de tiempo. Para resolver las deficiencias de la replicación maestro-esclavo, existe un mecanismo centinela.

• Función principal de Sentinel: basado en la replicación maestro-esclavo, Sentinel introduce la conmutación por error automática del nodo maestro.

3.2 El papel del modo centinela

1. Monitoreo: Sentinel verificará constantemente si el nodo maestro y los nodos esclavos funcionan normalmente.

2. Conmutación por error automática: cuando el nodo maestro no funciona normalmente, Sentinel iniciará una operación de conmutación por error automática. Actualizará uno de los nodos esclavos del nodo maestro fallido a un nuevo nodo maestro y permitirá que otros nodos esclavos copien el nuevo maestro. nodo nodo

3. Notificación (recordatorio): Sentinel puede enviar el resultado de la conmutación por error al cliente.

3.3 La estructura centinela consta de dos partes, el nodo centinela y el nodo de datos

1. Nodo centinela: el sistema centinela consta de uno o más nodos centinela, que son nodos redis especiales que no almacenan datos.
2. Nodo de datos: tanto el nodo maestro como el nodo esclavo son nodos de datos.

3.4 Mecanismo de conmutación por error

1. Cada nodo centinela enviará un comando ping al nodo maestro, al nodo esclavo y a otros nodos centinela cada segundo para una detección de latidos. Si el nodo maestro no responde dentro de un cierto período de tiempo o responde con un mensaje de error, el centinela considerará que el nodo maestro está fuera de línea subjetivamente (unilateralmente). Cuando más de la mitad de los nodos centinela piensan que el nodo maestro está desconectado subjetivamente, objetivamente está desconectado.

2. Cuando el nodo maestro falle, el nodo centinela implementará el mecanismo de elección a través del algoritmo Raft (algoritmo de elección) para elegir conjuntamente un nodo centinela como líder que se encargará de manejar la conmutación por error y la notificación del nodo maestro. Por lo tanto, la cantidad de clústeres que ejecutan Sentinels no debe ser inferior a 3 nodos.

3. La conmutación por error la realiza el nodo centinela líder, el proceso es el siguiente:
(1) Actualizar un cierto nodo esclavo a un nuevo nodo maestro y dejar que otros nodos esclavos apunten al nuevo nodo maestro;
(2) Si el original el nodo maestro se recupera, también se convierte en un nodo esclavo y apunta al nuevo nodo principal;
(3) notifica al cliente que el nodo principal ha sido reemplazado.

需要特别注意的是，客观下线是主节点才有的概念；如果从节点和哨兵节点发生故障，被哨兵主观下线后，不会再有后续的客观下线和故障转移操作。

3.5 Elección del nodo maestro

1. Filtre los nodos esclavos en mal estado (fuera de línea) que no responden a las respuestas de ping centinela.
2. Seleccione el nodo esclavo con la configuración de mayor prioridad en el archivo de configuración. (prioridad de réplica, el valor predeterminado es 100)
3. Seleccione el nodo esclavo con el mayor desplazamiento de replicación, es decir, la replicación más completa.

哨兵的启动依赖于主从模式，所以须把主从模式安装好的情况下再去做哨兵模式

4. Cree el modo centinela de Redis

Master节点：192.168.80.10
Slave1节点：192.168.80.11
Slave2节点：192.168.80.12

systemctl stop firewalld
setenforce 0

4.1 Modificar el archivo de configuración del modo centinela de Redis (todas las operaciones de los nodos)

cp /opt/redis-7.0.9/sentinel.conf /usr/local/redis/conf/
chown redis.redis /usr/local/redis/conf/sentinel.conf

vim /usr/local/redis/conf/sentinel.conf
protected-mode no									#6行，关闭保护模式
port 26379											#10行，Redis哨兵默认的监听端口
daemonize yes										#15行，指定sentinel为后台启动
pidfile /usr/local/redis/log/redis-sentinel.pid		#20行，指定 PID 文件
logfile "/usr/local/redis/log/sentinel.log"			#25行，指定日志存放路径
dir /usr/local/redis/data							#54行，指定数据库存放路径
sentinel monitor mymaster 192.168.80.10 6379 2		#73行，修改 指定该哨兵节点监控192.168.80.10:6379这个主节点，该主节点的名称是mymaster，最后的2的含义与主节点的故障判定有关：至少需要2个哨兵节点同意，才能判定主节点故障并进行故障转移
#sentinel auth-pass mymaster abc123					#76行，可选，指定Master节点的密码，仅在Master节点设置了requirepass
sentinel down-after-milliseconds mymaster 3000		#114行，判定服务器down掉的时间周期，默认30000毫秒（30秒）
sentinel failover-timeout mymaster 180000			#214行，同一个sentinel对同一个master两次failover之间的间隔时间（180秒）

4.2 Iniciar modo centinela

先启master，再启slave
cd /usr/local/redis/conf/
redis-sentinel sentinel.conf &

4.3 Ver información centinela

redis-cli -p 26379 info Sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.80.10:6379,slaves=2,sentinels=3

4.4 Simulación de fallas

#查看redis-server进程号：
ps -ef | grep redis
root      57031      1  0 15:20 ?        00:00:07 /usr/local/bin/redis-server 0.0.0.0:6379
root      57742      1  1 16:05 ?        00:00:07 redis-sentinel *:26379 [sentinel]
root      57883  57462  0 16:17 pts/1    00:00:00 grep --color=auto redis

#杀死 Master 节点上redis-server的进程号
kill -9 57031			#Master节点上redis-server的进程号

4.5 Resultados de la verificación

tail -f /usr/local/redis/log/sentinel.log
6709:X 13 Mar 2023 12:27:29.517 # +sdown master mymaster 192.168.80.10 6379
6709:X 13 Mar 2023 12:27:29.594 * Sentinel new configuration saved on disk
6709:X 13 Mar 2023 12:27:29.594 # +new-epoch 1
6709:X 13 Mar 2023 12:27:29.595 * Sentinel new configuration saved on disk
6709:X 13 Mar 2023 12:27:29.595 # +vote-for-leader c64fac46fcd98350006900c330998364d6af635d 1
6709:X 13 Mar 2023 12:27:29.620 # +odown master mymaster 192.168.80.10 6379 #quorum 2/2
6709:X 13 Mar 2023 12:27:29.621 # Next failover delay: I will not start a failover before Mon Mar 13 12:33:30 2023
6709:X 13 Mar 2023 12:27:30.378 # +config-update-from sentinel c64fac46fcd98350006900c330998364d6af635d 192.168.80.11 26379 @ mymaster 192.168.80.10 6379
6709:X 13 Mar 2023 12:27:30.378 # +switch-master mymaster 192.168.80.10 6379 192.168.80.11 6379
6709:X 13 Mar 2023 12:27:30.378 * +slave slave 192.168.80.13:6379 192.168.80.13 6379 @ mymaster 192.168.80.11 6379
6709:X 13 Mar 2023 12:27:30.378 * +slave slave 192.168.80.10:6379 192.168.80.10 6379 @ mymaster 192.168.80.11 6379
6709:X 13 Mar 2023 12:27:30.381 * Sentinel new configuration saved on disk
6709:X 13 Mar 2023 12:27:33.379 # +sdown slave 192.168.80.10:6379 192.168.80.10 6379 @ mymaster 192.168.80.11 6379


2.redis-cli -p 26379 INFO Sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_tilt_since_seconds:-1
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.80.11:6379,slaves=2,sentinels=3

Cinco, modo de clúster de Redis

5.1 Clúster de Redis

• Cluster, a saber, Redis Cluster, es una solución de almacenamiento distribuido introducida por Redis 3.0.

• El clúster consta de varios grupos de nodos (nodos) y los datos de Redis se distribuyen entre estos nodos. Los nodos del clúster se dividen en nodos maestros y nodos esclavos: solo el nodo maestro es responsable del mantenimiento de las solicitudes de lectura y escritura y de la información del clúster; los nodos esclavos solo replican los datos y la información de estado del nodo maestro.

5.2 El papel del clúster

1. Particionamiento de datos: el particionamiento de datos (o fragmentación de datos) es la función central del clúster.
El clúster distribuye datos a múltiples nodos. Por un lado, supera el límite del tamaño de la memoria de una sola máquina de Redis y la capacidad de almacenamiento aumenta considerablemente; por otro lado, cada nodo maestro puede proporcionar servicios externos de lectura y escritura, lo que mejora en gran medida la capacidad de respuesta del clúster.
El tamaño de la memoria independiente de Redis es limitado, lo cual se mencionó en la introducción de la persistencia y la replicación maestro-esclavo; como resultado, el nodo esclavo no puede proporcionar servicios durante mucho tiempo y el búfer de replicación del nodo maestro puede desbordarse durante el fase de replicación completa.
2. Alta disponibilidad: el clúster admite la replicación maestro-esclavo y la conmutación por error automática del nodo principal (similar a Sentinel); cuando falla algún nodo, el clúster aún puede proporcionar servicios externos.

5.3 Fragmentación de datos de Redis Cluster

1. El clúster de Redis introduce el concepto de ranuras hash 2. la
El clúster de Redis tiene 16384 ranuras hash (número 0-16383)

• Tome un clúster compuesto por 3 nodos como ejemplo:
  El nodo A contiene ranuras hash 0 a 5460
  El nodo B contiene ranuras hash 5461 a 10922 El nodo
  C contiene ranuras hash 10923 a 16383
  redis-cluster集群会用crc16算法对键进行换算，之后会得到一个数字，在用这个数字除以16384取余数，余数对应的Hash槽数值在哪个节点范围内，那么客户端输入的命令就会在哪个节点进行处理

5.4 Modelo de replicación maestro-esclavo del clúster de Redis

• Hay tres nodos en el clúster A, B y C. Si el nodo B falla, todo el clúster no estará disponible debido a la falta de ranuras en el rango de 5461-10922.
• Agregue un nodo esclavo A1, B1 y C1 a cada nodo, y el clúster completo consta de tres nodos maestros y tres nodos esclavos. Después de que falla el nodo B, el clúster elige el nodo maestro con B1 para continuar sirviendo. Cuando fallan tanto B como B1, el clúster no estará disponible.

6. Cree el modo de clúster de Redis

redis的集群一般需要6个节点，3主3从。方便起见，这里所有节点在同一台服务器上模拟：
以端口号进行区分：3个主节点端口号：6001/6002/6003，对应的从节点端口号：6004/6005/6006。

cd /usr/local/redis/
mkdir -p redis-cluster/redis600{1..6}

for i in {1..6}
do
cp /opt/redis-7.0.9/redis.conf /usr/local/redis/redis-cluster/redis600$i
cp /opt/redis-7.0.9/src/redis-cli /opt/redis-7.0.9/src/redis-server /usr/local/redis/redis-cluster/redis600$i
done

6.1 Activar la función de clúster

#其他5个文件夹的配置文件以此类推修改，注意6个端口都要不一样。
cd /usr/local/redis/redis-cluster/redis6001
vim redis.conf
#bind 127.0.0.1									#87行，注释掉bind项，默认监听所有网卡
protected-mode no								#111行，关闭保护模式
port 6001										#138行，修改redis监听端口
daemonize yes									#309行，设置为守护进程，后台启动
pidfile /usr/local/redis/log/redis_6001.pid		#341行，指定 PID 文件
logfile "/usr/local/redis/log/redis_6001.log"	#354行，指定日志文件
dir ./											#504行，指定持久化文件所在目录
appendonly yes									#1379行，开启AOF
cluster-enabled yes								#1576行，取消注释，开启群集功能
cluster-config-file nodes-6001.conf				#1584行，取消注释，群集名称文件设置
cluster-node-timeout 15000						#1590行，取消注释群集超时时间设置

6.2 Inicie el nodo redis

分别进入那六个文件夹，执行命令：redis-server redis.conf ，来启动redis节点
cd /usr/local/redis/redis-cluster/redis6001
redis-server redis.conf

for d in {1..6}
do
cd /usr/local/redis/redis-cluster/redis600$d
./redis-server redis.conf
done

ps -ef | grep redis

6.3 Iniciar el clúster

redis-cli --cluster create 127.0.0.1:6001 127.0.0.1:6002 127.0.0.1:6003 127.0.0.1:6004 127.0.0.1:6005 127.0.0.1:6006 --cluster-replicas 1
#六个实例分为三组，每组一主一从，前面的做主节点，后面的做从节点。下面交互的时候 需要输入 yes 才可以创建。
--replicas 1 表示每个主节点有1个从节点。

6.4 Grupo de prueba

redis-cli -p 6001 -c					#加-c参数，节点之间就可以互相跳转
127.0.0.1:6001> cluster slots			#查看节点的哈希槽编号范围
1) 1) (integer) 5461
   2) (integer) 10922									#哈希槽编号范围
   3) 1) "127.0.0.1"
      2) (integer) 6003									#主节点IP和端口号
      3) "fdca661922216dd69a63a7c9d3c4540cd6baef44"
   4) 1) "127.0.0.1"
      2) (integer) 6004									#从节点IP和端口号
      3) "a2c0c32aff0f38980accd2b63d6d952812e44740"
2) 1) (integer) 0
   2) (integer) 5460
   3) 1) "127.0.0.1"
      2) (integer) 6001
      3) "0e5873747a2e26bdc935bc76c2bafb19d0a54b11"
   4) 1) "127.0.0.1"
      2) (integer) 6006
      3) "8842ef5584a85005e135fd0ee59e5a0d67b0cf8e"
3) 1) (integer) 10923
   2) (integer) 16383
   3) 1) "127.0.0.1"
      2) (integer) 6002
      3) "816ddaa3d1469540b2ffbcaaf9aa867646846b30"
   4) 1) "127.0.0.1"
      2) (integer) 6005
      3) "f847077bfe6722466e96178ae8cbb09dc8b4d5eb"

127.0.0.1:6001> set name zhangsan
-> Redirected to slot [5798] located at 127.0.0.1:6003
OK

127.0.0.1:6001> cluster keyslot name					#查看name键的槽编号

redis-cli -p 6004 -c
127.0.0.1:6004> keys *							#对应的slave节点也有这条数据，但是别的节点没有
1) "name"


redis-cli -p 6001 -c cluster nodes