Cluster sentinela de replicação mestre-escravo Redis

1. Replicação mestre-escravo do Redis

1.1 Introdução à replicação mestre-escravo do Redis

• A replicação mestre-escravo refere-se à cópia dos dados de um servidor Redis para outros servidores Redis. O primeiro é chamado de nó mestre (Master) e o último é chamado de nó escravo (Slave); a replicação de dados é unidirecional, apenas do nó mestre para o nó escravo.
• Por padrão, cada servidor Redis é um nó mestre; e um nó mestre pode ter vários nós escravos (ou nenhum nó escravo), mas um nó escravo pode ter apenas um nó mestre.

1. Replicação mestre-escravo: a replicação mestre-escravo é a base do Redis altamente disponível. Sentinels e clusters são baseados na replicação mestre-escravo para obter alta disponibilidade. A replicação mestre-escravo implementa principalmente backup de dados em várias máquinas, bem como balanceamento de carga para operações de leitura e recuperação de falhas simples. Defeitos: A recuperação de falhas não pode ser automatizada; as operações de gravação não podem ter balanceamento de carga; a capacidade de armazenamento é limitada por uma única máquina.
2. Sentinel: Com base na replicação mestre-escravo, o Sentinel realiza a recuperação automática de falhas. Defeitos: As operações de gravação não podem ter balanceamento de carga; a capacidade de armazenamento é limitada por uma única máquina; o Sentinel não pode fazer failover automático de nós escravos. No cenário de separação leitura-gravação, a falha do nó escravo fará com que os serviços de leitura fiquem indisponíveis e o monitoramento adicional nós escravos são necessários, operação de comutação.
3. Clustering: Por meio do clustering, o Redis resolve o problema de que as operações de gravação não podem ter balanceamento de carga e a capacidade de armazenamento é limitada por uma única máquina e realiza uma solução de alta disponibilidade relativamente completa.

1.2 O papel da replicação mestre-escravo

1. Redundância de dados: a replicação mestre-escravo realiza backup dinâmico de dados, que é um método de redundância de dados diferente da persistência.
2. Recuperação de falhas: Quando há um problema com o nó mestre, o nó escravo pode fornecer serviços para obter uma rápida recuperação de falhas, na verdade é um tipo de redundância de serviço.
3. Balanceamento de carga: com base na replicação mestre-escravo, combinada com a separação leitura-gravação, o nó mestre pode fornecer serviços de gravação e os nós escravos podem fornecer serviços de leitura (ou seja, o aplicativo se conecta ao nó mestre ao gravar Dados Redis, e o aplicativo se conecta ao nó escravo ao ler dados Redis. nó) para compartilhar a carga do servidor; especialmente no cenário de escrever menos e ler mais, compartilhar a carga de leitura por meio de vários nós escravos pode aumentar muito a simultaneidade do Servidor Redis.
4. A pedra angular da alta disponibilidade: Além das funções acima, a replicação mestre-escravo também é a base para a implementação de sentinelas e clusters. Portanto, a replicação mestre-escravo é a base para a alta disponibilidade do Redis.

1.3 O processo de replicação mestre-escravo

1. Se um processo de máquina Escrava for iniciado, ele enviará um comando "comando de sincronização" para a máquina Mestre para solicitar uma conexão síncrona.
2. Quer seja a primeira conexão ou reconexão, a máquina mestre iniciará um processo em segundo plano para salvar o instantâneo de dados no arquivo de dados (executar operação rdb) e o mestre também registrará todos os comandos para modificar os dados e os armazenará em cache o arquivo de dados.
3. Depois que o processo em segundo plano concluir a operação de cache, a máquina mestre enviará o arquivo de dados para a máquina escrava, e a máquina escrava salvará o arquivo de dados no disco rígido e, em seguida, carregará na memória e, em seguida, o mestre máquina modificará todas as operações dos dados Envie-os para a máquina final Escrava juntos. Se o Escravo falhar e causar um tempo de inatividade, ele se reconectará automaticamente após retornar ao normal.
4. Após a máquina mestre receber a conexão da máquina escrava, ela envia seu arquivo de dados completo para a máquina escrava. Se o mestre receber solicitações de sincronização de vários escravos ao mesmo tempo, o mestre iniciará um processo em segundo plano para salvar o arquivo de dados e, em seguida, envie-o para todas as máquinas do lado escravo para garantir que todas as máquinas do lado escravo estejam normais.

2. Crie a replicação mestre-escravo do 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 Criar diretório de trabalho 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 Variáveis ​​de ambiente

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

source /etc/profile

2.4 Definir script de gerenciamento de serviço 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 Modifique o arquivo de configuração do Redis (operação do nó mestre)

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 Modifique o arquivo de configuração do Redis (operação do nó escravo)

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 Verifique o efeito mestre-escravo

在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. Redis modo sentinela

3.1 O que é o Modo Sentinela

• O método da tecnologia de comutação mestre-escravo é: quando o servidor está inativo, é necessário alternar manualmente uma máquina escrava para a máquina mestre, o que requer intervenção manual, que não só é demorada e trabalhosa, mas também causa o serviço ficar indisponível por um período de tempo. Para resolver as deficiências da replicação mestre-escravo, existe um mecanismo sentinela.

• Função principal do Sentinel: Com base na replicação mestre-escravo, o Sentinel apresenta failover automático do nó mestre.

3.2 O papel do modo sentinela

1. Monitoramento: O Sentinel verificará constantemente se o nó mestre e os nós escravos estão operando normalmente.

2. Failover automático: Quando o nó mestre falha ao funcionar normalmente, o Sentinel iniciará uma operação de failover automático. Ele atualizará um dos nós escravos do nó mestre com falha para um novo nó mestre e permitirá que outros nós escravos copiem o novo mestre nó.

3. Notificação (lembrete): O Sentinel pode enviar o resultado do failover para o cliente.

3.3 A estrutura sentinela consiste em duas partes, o nó sentinela e o nó de dados

1. Nó sentinela: o sistema sentinela consiste em um ou mais nós sentinela, que são nós redis especiais que não armazenam dados.
2. Nó de dados: Tanto o nó mestre quanto o nó escravo são nós de dados.

3.4 Mecanismo de failover

1. Cada nó sentinela enviará um comando ping para o nó mestre, nó escravo e outros nós sentinela a cada 1 segundo para detecção de pulsação. Se o nó mestre não responder dentro de um determinado período de tempo ou responder com uma mensagem de erro, a sentinela considerará o nó mestre offline subjetivamente (unilateralmente). Quando mais da metade dos nós sentinelas pensam que o nó mestre está offline subjetivamente, ele está offline objetivamente.

2. Quando o nodo mestre falhar, o nodo sentinela implementará o mecanismo de eleição através do algoritmo Raft (algoritmo de eleição) para eleger em conjunto um nodo sentinela como o líder responsável pelo tratamento do failover e notificação do nodo mestre. Portanto, o número de clusters executando Sentinels não deve ser inferior a 3 nós.

3. O failover é executado pelo nó sentinela líder, o processo é o seguinte:
(1) Atualize um certo nó escravo para um novo nó mestre e deixe outros nós escravos apontarem para o novo nó mestre;
(2) Se o nó original o nó mestre se recupera, ele também se torna um nó escravo e aponta para o novo nó primário;
(3) notifica o cliente de que o nó primário foi substituído.

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

3.5 Eleição do nó mestre

1. Filtre os nós escravos não saudáveis ​​(off-line) que não respondem às respostas de ping do sentinela.
2. Selecione o nó escravo com a configuração de prioridade mais alta no arquivo de configuração. (prioridade de réplica, o valor padrão é 100)
3. Selecione o nó escravo com o maior deslocamento de replicação, ou seja, a replicação mais completa.

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

4. Crie o modo sentinela do Redis

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

systemctl stop firewalld
setenforce 0

4.1 Modifique o arquivo de configuração do modo sentinela do Redis (todas as operações do nó)

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 o modo sentinela

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

4.3 Exibir informações do sentinela

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 Simulação de falha

#查看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 da Verificação

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 cluster Redis

5.1 Cluster Redis

• Cluster, ou seja, Redis Cluster, é uma solução de armazenamento distribuído introduzida pelo Redis 3.0.

• O cluster consiste em vários grupos de nós (Nodes) e os dados do Redis são distribuídos entre esses nós. Os nós do cluster são divididos em nós mestres e nós escravos: apenas o nó mestre é responsável pela manutenção das solicitações de leitura e gravação e informações do cluster; os nós escravos apenas replicam os dados e informações de status do nó mestre.

5.2 O papel do cluster

1. Particionamento de dados: O particionamento de dados (ou fragmentação de dados) é a função principal do cluster.
O cluster distribui dados para vários nós. Por um lado, ele ultrapassa o limite do tamanho da memória de máquina única do Redis e a capacidade de armazenamento é bastante aumentada; por outro lado, cada nó mestre pode fornecer serviços externos de leitura e gravação, o que melhora muito a capacidade de resposta do cluster.
O tamanho da memória autônoma do Redis é limitado, o que foi mencionado na introdução de persistência e replicação mestre-escravo; Como resultado, o nó escravo não pode fornecer serviços por muito tempo e o buffer de replicação do nó mestre pode estourar durante o fase de replicação completa.
2. Alta disponibilidade: O cluster oferece suporte à replicação mestre-escravo e failover automático do nó mestre (semelhante ao Sentinel), quando qualquer nó falha, o cluster ainda pode fornecer serviços externos.

5.3 Fragmentação de Dados do Cluster Redis

1. O cluster Redis introduz o conceito de slots de hash. 2. .
O cluster Redis tem 16384 slots de hash (número 0-16383)

• Tome um cluster composto por 3 nós como exemplo:
  O nó A contém hash slots 0 a 5460
  O nó B contém hash slots 5461 a 10922 O nó
  C contém hash slots 10923 a 16383
  redis-cluster集群会用crc16算法对键进行换算，之后会得到一个数字，在用这个数字除以16384取余数，余数对应的Hash槽数值在哪个节点范围内，那么客户端输入的命令就会在哪个节点进行处理

5.4 Modelo de replicação mestre-escravo do cluster Redis

• Há três nós A, B e C no cluster. Se o nó B falhar, todo o cluster ficará indisponível devido à falta de slots no intervalo de 5461-10922.
• Adicione um nó escravo A1, B1 e C1 a cada nó e todo o cluster consistirá em três nós mestres e três nós escravos. Após a falha do nó B, o cluster elege o nó mestre com B1 para continuar atendendo. Quando B e B1 falharem, o cluster ficará indisponível.

6. Crie o modo de cluster 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 Ligue a função de cluster

#其他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 o nó 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 o cluster

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 Cluster de teste

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