[TOC]

13：redis集群高可用#

今日工作任务路线图

一、工作场景#

为确保 Redis 服务的高可用和数据持久化，运维团队开始一系列操作。首先，团队搭建了一主一从的 Redis 结构，将 redis67 配置为主服务器，redis68 作为从服务器，实现数据的实时同步和备份。接着，为进一步提高服务的可靠性，在 redis69 上配置了哨兵服务。在一次突发状况中，主服务器 redis67 出现故障，哨兵服务迅速响应，自动将从服务器 redis68 升级为主服务器，保障业务不受影响。当 redis67 恢复后，又自动成为新主服务器的从服务器，确保整个 Redis 服务的稳定运行。

二、为什么学#

在当今数据量激增的时代，企业对数据存储和访问的效率与稳定性要求极高。从文档可知，Redis 若没有高可用机制，一旦主节点故障，业务会中断，数据也可能丢失。而 Redis 高可用方案，如主从复制、哨兵服务、集群部署等，能保障数据的自动备份与实时同步。像哨兵服务可自动监控节点状态，在主节点故障时快速实现故障转移，将从节点提升为主节点。集群部署则能实现数据的分布式存储，避免单点性能瓶颈，让 Redis 服务在各种复杂环境下稳定运行，确保业务的连续性。

三、Redis持久化#

当前任务环节

3.1 使用RDB文件恢复数据#

创建1台虚拟机

主机名	IP地址	说明
redis50	192.168.90.50	redis服务器

配置服务器192.168.90.50

1
[root@redis50 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis50
2
[root@redis50 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.50/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis50~]# nmcli connection【肯耐申】 up ens160
4

5
#配置DNS
6
[root@redis50 ~]# vim /etc/resolv.conf
7
nameserver 192.168.90.2

步骤一：设置存盘间隔为120秒且10个key改变数据自动存盘

查看 redis服务存储数据到硬盘的存盘频率

配置行	含义	作用
`save 3600 1`	如果 3600 秒（1 小时）内，至少有 1 个 key 被修改，则保存快照。	最宽松的持久化，防止长时间无备份
`save 300 100`	如果 300 秒（5 分钟）内，至少有 100 个 key 被修改，则保存快照。	中等频率，平衡性能与安全性
`save 60 10000`	如果 60 秒（1 分钟）内，至少有 10,000 个 key 被修改，则保存快照。	高频写入场景下的快速保护

1
[root@redis50 ~]# yum -y install【因-斯多】 redis
2

3
#修改之前
4
[root@redis50 ~]# vim /etc/redis/redis.conf
5
 383 # save 3600 1
6
 384 # save 300 100
7
 385 # save 60 10000
8

9
#修改之后
10
[root@redis50 ~]# vim /etc/redis/redis.conf
11
 383 # save 3600 1
12
 384 save 120 10
13
 385 # save 60 10000
14

15
#启动redis
16
[root@redis50 ~]# systemctl【西斯屯-ctl】 start【s 达儿】 redis
17

18
#目前还没有rdb文件
19
[root@redis50 ~]# ls /var/lib/redis/

在服务启动后，要在2分钟内存储大于等10个变量

1
#存上4个变量
2
[root@redis50 ~]# redis-cli
3
127.0.0.1:6379> mset a 1 b 2 c 3 d 4
4
OK
5
127.0.0.1:6379> exit
6

7
#还没有达到存储的条件，还没有rdb文件
8
[root@redis50 ~]# ls /var/lib/redis/
9

10
#继续存上6个变量
11
[root@redis50 ~]# redis-cli
12
127.0.0.1:6379> mset   x 1 y 2  z 3 k 6  i 7  z 9   f 22  zz 99  cc  66
13
OK
14
127.0.0.1:6379> exit
15

16
#达到条件，数据已经持久化到rdb文件中了
17
[root@redis50 ~]# ls /var/lib/redis/
18
dump.rdb

步骤二：使用RDB文件恢复数据

1
#第1步：拷贝 dump.rdb 文件就是对数据的备份
2
[root@redis50 ~]# cp /var/lib/redis/dump.rdb /opt/
3
[root@redis50 ~]# ls /opt/
4
dump.rdb
5

6
#第2步：清空数据
7
[root@redis50 ~]# redis-cli
8
127.0.0.1:6379> flushall
9
OK
10
127.0.0.1:6379> keys *
11
(empty array)

使用备份的dump.rdb文件恢复

1
#第1步 停止内存没有数据的redis服务
2
[root@redis50 ~]# systemctl【西斯屯-ctl】 stop【 s 多】 redis
3

4
#第2步 把没有数据的dump.rdb文件删除
5
[root@redis50 ~]# rm -rf /var/lib/redis/dump.rdb
6

7
#第3步 把备份dump.rdb文件拷贝到数据库目录下
8
[root@redis50 ~]# cp /opt/dump.rdb /var/lib/redis/
9

10
#第4步 启动redis服务 并连接服务查看数据
11
[root@redis50 ~]# systemctl【西斯屯-ctl】 start【s 达儿】 redis
12
[root@redis50 ~]# redis-cli
13
127.0.0.1:6379> keys *
14
 1) "x"
15
 2) "a"
16
 3) "y"
17
 4) "cc"
18
 5) "f"
19
 6) "c"
20
 7) "zz"
21
 8) "z"
22
 9) "d"
23
10) "i"
24
11) "k"
25
12) "b"

3.2 使用AOF文件恢复数据#

1
操作步骤
2
# 1. 在 A 节点（源）安全关闭 Redis（确保 AOF 完整）
3
redis-cli -h A_host shutdown
4

5
# 2. 拷贝 AOF 文件到 B 节点
6
scp /path/to/appendonly.aof user@B_host:/redis/data/
7

8
# 3. 在 B 节点（目标）：
9
#    - 停止 Redis
10
#    - 备份/删除原有 AOF 和 RDB
11
#    - 放入新 AOF 文件
12
#    - 确保 redis.conf 中 appendonly yes
13
#    - 启动 Redis
14

15
redis-server /etc/redis.conf

步骤一：启用AOF

命令操作如下所示：

1
[root@redis50 ~]# redis-cli
2

3
#启用aof文件
4
127.0.0.1:6379> config set appendonly yes
5
OK
6

7
#查看是否启用
8
192.168.88.50:6379> config get  appendonly
9
1) "appendonly"
10
2) "yes"
11

12
#保存配置
13
127.0.0.1:6379> config rewrite
14
OK
15
127.0.0.1:6379> exit
16

17
#数据库目录多了.aof文件
18
[root@redis50 ~]# ls /var/lib/redis/
19
appendonly.aof  dump.rdb
20

21
#查看文件行数
22
[root@redis50 ~]# wc -l /var/lib/redis/appendonly.aof
23
2 /var/lib/redis/appendonly.aof
24

25
#存放数据
26
[root@redis50 ~]# redis-cli
27
127.0.0.1:6379> mset x 1 y 2 z 3
28
OK
29
127.0.0.1:6379> keys *
30
 1) "x"
31
 2) "a"
32
 3) "y"
33
 4) "cc"
34
 5) "f"
35
 6) "c"
36
 7) "zz"
37
 8) "z"
38
 9) "d"
39
10) "i"
40
11) "k"
41
12) "b"
42
127.0.0.1:6379> exit
43

44
#查看文件行数
45
[root@redis50 ~]# wc -l /var/lib/redis/appendonly.aof
46
22 /var/lib/redis/appendonly.aof

步骤二：使用AOF文件恢复数据

1）备份aof文件

1
[root@redis50 ~]# cp /var/lib/redis/appendonly.aof /opt/
2
[root@redis50 ~]# ls /opt/
3
appendonly.aof  dump.rdb

2）清空数据

1
[root@redis50 ~]# redis-cli
2
127.0.0.1:6379> flushall
3
OK
4
127.0.0.1:6379> exit

3）恢复数据

1
 [root@redis50 ~]# rm -rf  /var/lib/redis/*
2
 [root@redis70 ~]# cp /opt/appendonly.aof  /var/lib/redis/
3
 [root@redis70 ~]# chown -R redis:redis /var/lib/redis
4
 [root@redis50 ~]# systemctl【西斯屯-ctl】 restart redis
5
 [root@redis50 ~]# redis-cli
6
 127.0.0.1:6379> keys *
7
 1) "x"
8
 2) "a"
9
 3) "y"
10
 4) "cc"
11
 5) "f"
12
 6) "c"
13
 7) "zz"
14
 8) "z"
15
 9) "d"
16
10) "i"
17
11) "k"
18
12) "b"

四、redis高可用集群#

当前任务环节

4.1 准备环境#

创建6台新虚拟机

主机名	IP地址	说明
redis51	192.168.90.51	redis服务器
redis52	192.168.90.52	redis服务器
redis53	192.168.90.53	redis服务器
redis54	192.168.90.54	redis服务器
redis55	192.168.90.55	redis服务器
redis56	192.168.90.56	redis服务器

4.1.1 配置redis51#

配置服务器192.168.90.51

1
[root@redis51 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis51
2
[root@redis51 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.51/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis51~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis51 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis51 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis51 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis51 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1793/redis-server 0
12
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1793/redis-server 0

4.1.1 配置redis52#

配置服务器192.168.90.52

1
[root@redis52 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis52
2
[root@redis52 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.52/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis52~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis52 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis52 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis52 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis52 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1758/redis-server 0
12
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1758/redis-server 0

4.1.1 配置redis53#

配置服务器192.168.90.53

1
[root@redis53 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis53
2
[root@redis53 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.53/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis53~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis53 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis53 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis53 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis53 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1785/redis-server 0
12
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1785/redis-server 0

4.1.1 配置redis54#

配置服务器192.168.90.54

1
[root@redis54 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis54
2
[root@redis54 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.54/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis54~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis54 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis54 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis54 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis54 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1745/redis-server 0
12
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1745/redis-server 0

4.1.1 配置redis55#

配置服务器192.168.90.55

1
[root@redis55 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis55
2
[root@redis55 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.55/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis55~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis55 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis55 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis55 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis55 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1778/redis-server 0
12
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1778/redis-server 0

4.1.1 配置redis56#

配置服务器192.168.90.56

1
[root@redis56 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis56
2
[root@redis56 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.56/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis56~]# nmcli connection【肯耐申】 up ens160

安装redis和配置

1
[root@redis56 ~]# yum -y install【因-斯多】 redis
2
#修改4行配置
3
[root@redis56 ~]# vim /etc/redis/redis.conf
4
75 bind 0.0.0.0
5
1387 cluster-enabled yes   #启用集群功能
6
1395 cluster-config-file nodes-6379.conf  #存储集群信息文件
7
1401 cluster-node-timeout 5000  #集群中主机通信超时时间
8

9
[root@redis56 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
10
[root@redis56 ~]# netstat -utnlp  | grep redis-serve
11
tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      1793/redis-server 0
12
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      1793/redis-server 0

4.2 高可用集群原理#

4.2.1 架构与节点连接#

Redis Cluster 采用无中心结构，每个节点保存数据和整个集群状态，且每个节点都和其他所有节点连接。一组三主三从集群由 6 个 Redis 实例组成，其中 3 个为主节点，3 个为从节点，每个主节点至少对应一个从节点。

4.2.2 分布式数据分片#

哈希槽机制：Redis Cluster 将数据划分为 16384 个槽位，每个主节点负责部分槽位。例如，主节点 1 管理槽 0 - 5460，主节点 2 管理 5461 - 10922，主节点 3 管理 10923 - 16383 。当存储一个 key 时，会使用 CRC16 算法计算该 key 的哈希值，然后对 16384 取模，得到所属的槽位，进而将这个 key 分到对应槽位区间的节点上。
自动负载均衡：数据按哈希值分配到不同节点，避免单点性能瓶颈。当新增节点时，还可以进行动态地、无中断地数据重新分片。

分布式数据分片核心好处#

水平扩展（Scalability）

突破单机性能瓶颈：数据和请求负载分散到多个节点，可线性提升吞吐量（QPS）和存储容量。
动态扩容/缩容：通过迁移槽位（如 redis-cli --cluster reshard），可在不停服的情况下增减节点。
1. 高可用性（High Availability）
自动故障转移：每个主节点可配置从节点（replica），主节点宕机时，从节点自动升主（由集群内部 Gossip 协议协调）。
无单点故障：即使部分节点失效，其余节点仍可提供服务（只要大多数主节点存活）。

数据分布均衡

确定性分片：slot = CRC16(key) % 16384 确保相同 key 总路由到同一节点，避免数据重复。
均匀分布：哈希算法使 key 在槽位间近似均匀分布，结合槽位均分到节点，实现负载均衡。

客户端智能路由

MOVED 重定向：客户端首次访问错误节点时，返回正确节点地址，后续直接连接目标节点。
本地缓存槽位映射：客户端（如 redis-py-cluster）缓存 slot → node 映射，减少重定向开销。

简化运维

去中心化架构：无中心调度节点，所有节点对等通信（Gossip 协议），避免单点瓶颈。
自动发现与状态同步：节点通过 PING/PONG 消息交换拓扑、故障信息，无需人工干预。

总结

Redis 集群的分片机制在 性能、容量、可用性 三者间取得平衡：
通过哈希槽实现数据分布式存储，既支持弹性扩展，又保障高可用，同时保持协议简洁高效，是 Redis 大规模部署的核心方案。

4.2.3 主从复制#

主从节点的数据准实时一致，通过异步的主备复制保证。从节点启动时会连接主节点，发送 SYNC 命令。主节点接收到后，开始执行 BGSAVE 命令生成 RDB 文件，并使用缓冲区记录此后执行的所有写命令。主节点 BGSAVE 执行完后，向从节点发送快照文件，发送期间继续记录写命令。从节点收到快照文件后丢弃旧数据，载入快照。主节点快照发送完毕后，向从节点发送缓冲区中的写命令。之后主节点每执行一个写命令，都会向从节点发送相同的写命令。

Redis 主从复制通过异步方式实现数据准实时同步，过程如下：

建立连接：从节点启动后，向主节点发起连接，并发送 PSYNC 命令（首次为 PSYNC ? -1）。
全量同步（必要时）：主节点收到首次 PSYNC 后，执行 BGSAVE 生成 RDB 快照；同时将新写命令缓存在复制积压缓冲区（repl_backlog）； RDB 生成后，主节点将其发送给从节点；从节点清空本地数据，加载 RDB。
增量同步：主节点将 RDB 生成期间及之后的写命令持续发送给从节点；从节点执行这些命令，保持与主节点一致。
断线重连优化：若网络闪断，从节点通过 PSYNC 请求部分重同步；主节点若在 repl_backlog 中找到对应偏移量，则仅发送缺失命令，避免全量同步。

4.2.4读写分离#

在 Redis 集群中，写操作只能由主节点处理；读操作既可以在主节点上进行，也可以在从节点上进行，以此分载主节点的读操作压力。

4.3 创建集群#

启用集群配置#

1
# 1. 绑定所有接口（允许外部连接）
2
bind 0.0.0.0
3

4
# 2. 禁用保护模式（因未设密码，有密码情况下可以设置为yes）
5
protected-mode no
6

7
# 3. 监听端口
8
port 6379
9

10
# 4. 不以守护进程方式运行（由 systemd 管理）
11
daemonize no
12

13
# 5. 启用集群模式（核心！）
14
cluster-enabled yes
15

16
# 6. 集群节点超时（毫秒），默认 15000，可调小测试用
17
cluster-node-timeout 5000
18

19
# 7. 集群配置文件（自动生成，不要手动创建）
20
cluster-config-file nodes-6379.conf

说明：

1、在任意一台redis服务器上都可以执行创建集群的命令。

2、—cluster-replicas 1 给每个master服务器分配一台slave服务器，每个主至少要分配1台slave服务器，不然无法实现redis服务的高可用。

3、创建集群时，会自动创建主从角色，默认把主机列表中的前3台服务器创建为 Master角色的redis服务器，剩下的均配置为slave角色服务器。

4、创建集群时，会自动给master角色的主机分配hash槽，通过hash槽实现数据的分布式存储。

1
[root@redis51 ~]# redis-cli --cluster【克拉斯特】 create 192.168.90.51:6379 192.168.90.52:6379 192.168.90.53:6379 192.168.90.54:6379 192.168.90.55:6379 192.168.90.56:6379 --cluster-replicas 1
2
>>> Creating cluster
3
>>> Performing hash slots allocation on 6 nodes...
4
Using 3 masters:
5
192.168.90.51:6379
6
192.168.90.52:6379
7
192.168.90.53:6379
8
Adding replica 192.168.90.55:6379 to 192.168.90.51:6379
9
Adding replica 192.168.90.56:6379 to 192.168.90.52:6379
10
Adding replica 192.168.90.54:6379 to 192.168.90.53:6379
11
M: 0eb3b7aa0493a19189cba35b0c658202cc20884b 192.168.90.51:6379
12
   slots:0-5460 (5461 slots) master
13
M: a9cb8ccd31bf3eb70433c00906c9f1a99b5e8441 192.168.90.52:6379
14
   slots:5461-10922 (5462 slots) master
15
M: f2c1bdb78d8d224c3666fa6440bdf80ba563c581 192.168.90.53:6379
16
   slots:10923-16383 (5461 slots) master
17
S: bdba77868965371680fa825badff59bf8ef95a81 192.168.90.54:6379
18
   replicates f2c1bdb78d8d224c3666fa6440bdf80ba563c581
19
S: 11510f42bfd9cf667bab5f31c01476d94984200a 192.168.90.55:6379
20
   replicates 0eb3b7aa0493a19189cba35b0c658202cc20884b
21
S: fe572ce003ee634c52adc4b42d92d15f847937d7 192.168.90.56:6379
22
   replicates a9cb8ccd31bf3eb70433c00906c9f1a99b5e8441
23
Can I set the above configuration? (type 'yes' to accept): yes #同意
24
....
25
....
26
[OK] All nodes agree about slots configuration.
27
>>> Check for open slots...
28
>>> Check slots coverage...
29
[OK] All 16384 slots covered.  //创建成功的提示

4.4 查看集群信息#

第一列：主服务器ip地址

第二列：主服务器ID

第三列：存储变量个数

第四列：hash槽个数（hash槽的作用在集群存储工程过程里讲）

第五列：从服务器数量

1
[root@redis51 ~]# redis-cli --cluster【克拉斯特】  info【因否】  192.168.90.51:6379
2
192.168.90.53:6379 (f2c1bdb7...) -> 0 keys | 5461 slots | 1 slaves.
3
192.168.90.51:6379 (0eb3b7aa...) -> 0 keys | 5461 slots | 1 slaves.
4
192.168.90.52:6379 (a9cb8ccd...) -> 0 keys | 5462 slots | 1 slaves.
5
[OK] 0 keys in 3 masters.
6
0.00 keys per slot on average.

4.5 访问集群#

1
[root@redis51 ~]# redis-cli  -c -h 192.168.90.51 -p 6379
2
192.168.90.51:6379> set school  moershi
3
-> Redirected to slot [8455] located at 192.168.90.52:6379
4
OK
5
192.168.90.52:6379> set teacher jam
6
-> Redirected to slot [12541] located at 192.168.90.53:6379
7
OK
8
192.168.90.53:6379> set class NSD
9
-> Redirected to slot [741] located at 192.168.90.51:6379
10
OK
11
192.168.90.51:6379>

会发现3个变量被分别存储到集群中的3台master服务器上，实现了数据的分布式存储。当连接集群中的任意一台redis服务器存储数据时，会调用集群CRC16算法得出此次存储变量使用的hash 槽，然后连接hash 槽所在的master服务器存储变量。在创建集群时会把默认的16384个槽平均的分配给集群中的3个master服务器。可以通过查看集群信息查看每个master服务器占用hash槽的个数。

1
[root@redis51 ~]# redis-cli  --cluster【克拉斯特】  info【因否】  192.168.90.51:6379
2
192.168.90.53:6379 (f2c1bdb7...) -> 0 keys | 5461 slots | 1 slaves.
3
192.168.90.51:6379 (0eb3b7aa...) -> 0 keys | 5461 slots | 1 slaves.
4
192.168.90.52:6379 (a9cb8ccd...) -> 0 keys | 5462 slots | 1 slaves.
5
[OK] 0 keys in 3 masters.
6
0.00 keys per slot on average.

集群中slave角色的主机会自动同步master角色主机的数据，实现数据的自动备份，

分别连接集群中的3台slave服务器查看变量

1
[root@redis54 ~]# redis-cli -c -h 192.168.90.54 -p 6379
2
192.168.90.54:6379> keys *
3
1) "class"
4
[root@redis55 ~]# redis-cli -c -h 192.168.90.55 -p 6379
5
192.168.90.55:6379> keys *
6
1) "school"
7
[root@redis56 ~]# redis-cli -c -h 192.168.90.56 -p 6379
8
192.168.90.56:6379> keys *
9
1) "teacher"

当master角色的服务器宕机时，对应的slave服务器会升级为master 并接手对应的hash槽，实现redis服务的高可用，例如停止host53主机的redis服务，对应的从会升级为master 。(当宕机的master恢复后自动做当前主的从服务器)

1
#停止redis服务
2
[root@redis53 ~]# systemctl【西斯屯-ctl】  stop【 s 多】  redis
3
#查看集群信息
4
[root@redis51 ~]#]# redis-cli --cluster【克拉斯特】  info【因否】  192.168.90.51:6379
5
192.168.90.54:6379 (f2c1bdb7...) -> 1 keys | 5461 slots | 0 slaves.
6
192.168.90.51:6379 (0eb3b7aa...) -> 1 keys | 5461 slots | 1 slaves.
7
192.168.90.52:6379 (a9cb8ccd...) -> 1 keys | 5462 slots | 1 slaves.
8
[OK] 0 keys in 3 masters.
9
keys per slot on average.
10
#启动redis服务
11
[root@redis53 ~]# systemctl【西斯屯-ctl】  start【s 达儿】  redis
12
#查看集群信息
13
[root@redis51 ~]#]# redis-cli --cluster【克拉斯特】  info【因否】  192.168.90.51:6379
14
192.168.90.54:6379 (f2c1bdb7...) -> 1 keys | 5461 slots | 1 slaves.
15
192.168.90.51:6379 (0eb3b7aa...) -> 1 keys | 5461 slots | 1 slaves.
16
192.168.90.52:6379 (a9cb8ccd...) -> 1 keys | 5462 slots | 1 slaves.
17
[OK] 0 keys in 3 masters.
18
keys per slot on average.

五、配置主从复制#

当前任务环节

5.1 环境准备#

准备3台新虚拟机

主机名	主机名	说明
redis61	192.168.90.61	redis服务器
redis62	192.168.90.62	redis服务器
redis63	192.168.90.63	redis服务器

配置服务器192.168.90.61

1
[root@redis61 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis61
2
[root@redis61 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.61/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis61~]# nmcli connection【肯耐申】 up ens160

配置服务器192.168.90.62

1
[root@redis62 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis62
2
[root@redis62 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.62/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis62~]# nmcli connection【肯耐申】 up ens160

配置服务器192.168.90.63

1
[root@redis63 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis63
2
[root@redis63 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.63/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis63~]# nmcli connection【肯耐申】 up ens160

5.2 配置一主一从结构#

1）配置redis61为主服务器

1
[root@redis61 ~]# yum -y install【因-斯多】 redis
2
[root@redis61 ~]# vim /etc/redis/redis.conf
3
75 bind 0.0.0.0
4
[root@redis61 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
5
[root@redis61 ~]# redis-cli
6
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
7
# Replication
8
role:master   # 默认就是主服务器
9
connected_slaves:0  #没有从服务器
10
master_failover_state:no-failover
11
master_replid:bd86b885e9e6b21e452696d472e2b2852c7fea72
12
master_replid2:0000000000000000000000000000000000000000
13
master_repl_offset:0
14
second_repl_offset:-1
15
repl_backlog_active:0
16
repl_backlog_size:1048576
17
repl_backlog_first_byte_offset:0
18
repl_backlog_histlen:

2）配置redids62为redis61的从服务器

1
[root@redis62 ~]# yum -y install【因-斯多】 redis
2
[root@redis62 ~]# vim /etc/redis/redis.conf
3
75 bind 0.0.0.0
4
[root@redis62 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
5
[root@redis62 ~]# redis-cli
6
127.0.0.1:6379> replicaof 192.168.90.61 6379  #指定主服务器ip和端口
7
OK
8
127.0.0.1:6379> config rewrite  #永久保存配置
9
OK
10
127.0.0.1:6379> exit
11
#查看文件末尾
12
[root@redis62 ~]# tail -1 /etc/redis/redis.conf
13
replicaof 192.168.90.61 6379
14
[root@redis62 ~]# redis-cli
15
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
16
# Replication
17
role:slave   #从角色
18
master_host:192.168.90.61  #主服务器ip地址
19
master_port:6379  #主服务器端口号
20
master_link_status:up  #与主服务器连接状态 （up 正常  down 连接失败）
21
master_last_io_seconds_ago:0
22
master_sync_in_progress:0
23
slave_read_repl_offset:84
24
slave_repl_offset:84
25
slave_priority:100
26
slave_read_only:1
27
replica_announced:1
28
connected_slaves:0
29
master_failover_state:no-failover
30
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
31
master_replid2:0000000000000000000000000000000000000000
32
master_repl_offset:84
33
second_repl_offset:-1
34
repl_backlog_active:1
35
repl_backlog_size:1048576
36
repl_backlog_first_byte_offset:1
37
repl_backlog_histlen:84

3）在主服务器redis61查看复制信息

1
127.0.0.1:6379> info【因否】 replication
2
# Replication
3
role:master  #主角色
4
connected_slaves:1  #一个从
5
slave0:ip=192.168.90.62,port=6379,state=online,offset=98,lag=0 #从服务器信息
6
master_failover_state:no-failover
7
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
8
master_replid2:0000000000000000000000000000000000000000
9
master_repl_offset:98
10
second_repl_offset:-1
11
repl_backlog_active:1
12
repl_backlog_size:1048576
13
repl_backlog_first_byte_offset:1
14
repl_backlog_histlen:98
15
127.0.0.1:6379> mset x 1 y 2 z 3  #存储数据
16
OK
17
127.0.0.1:6379> keys *
18
1) "x"
19
2) "z"
20
3) "y"

4）在从服务器查看是否同步数据

1
127.0.0.1:6379> keys *
2
1) "x"
3
2) "z"
4
3) "y"

5.3 配置一主多从结构#

把redis63也配置为redis61的从服务器

1）配置redis63为redis61的从服务器

1
[root@redis63 ~]# yum -y install【因-斯多】 redis
2
[root@redis63 ~]# vim /etc/redis/redis.conf
3
75 bind 0.0.0.0
4
[root@redis63 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
5
[root@redis63 ~]# redis-cli
6
127.0.0.1:6379> replicaof 192.168.90.61 6379  #指定主服务器ip和端口
7
OK
8
127.0.0.1:6379> config rewrite  #永久保存配置
9
OK
10
127.0.0.1:6379> exit
11
#查看文件末尾
12
[root@redis62 ~]# tail -1 /etc/redis/redis.conf
13
replicaof 192.168.90.61 6379
14
[root@redis63 ~]# redis-cli
15
127.0.0.1:6379> info【因否】 replication
16
# Replication
17
role:slave
18
master_host:192.168.90.61
19
master_port:6379
20
master_link_status:up
21
master_last_io_seconds_ago:10
22
master_sync_in_progress:0
23
slave_read_repl_offset:1507
24
slave_repl_offset:1507
25
slave_priority:100
26
slave_read_only:1
27
replica_announced:1
28
connected_slaves:0
29
master_failover_state:no-failover
30
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
31
master_replid2:0000000000000000000000000000000000000000
32
master_repl_offset:1507
33
second_repl_offset:-1
34
repl_backlog_active:1
35
repl_backlog_size:1048576
36
repl_backlog_first_byte_offset:1466
37
127.0.0.1:6379> keys *
38
1) "y"
39
2) "z"
40
3) "x"

在redis61 查看到有2台从服务器

1
127.0.0.1:6379> info【因否】 replication
2
# Replication
3
role:master
4
connected_slaves:2  #2个从服务器
5
slave0:ip=192.168.90.62,port=6379,state=online,offset=1591,lag=0  #从1
6
slave1:ip=192.168.90.63,port=6379,state=online,offset=1591,lag=1  #从2
7
master_failover_state:no-failover
8
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
9
master_replid2:0000000000000000000000000000000000000000
10
master_repl_offset:1591
11
second_repl_offset:-1
12
repl_backlog_active:1
13
repl_backlog_size:1048576
14
repl_backlog_first_byte_offset:1
15
repl_backlog_histlen:1591

5.4 配置主从从结构#

把redis63恢复为独立的redis服务器，然后配置为redis62的从服务器

1）配置redis63

1
127.0.0.1:6379> replicaof no one #恢复为独立的数据库服务器
2
OK
3
127.0.0.1:6379> replicaof 192.168.90.62 6379  #指定主服务器为62
4
OK
5
127.0.0.1:6379> config rewrite #保存配置
6
OK
7
127.0.0.1:6379> exit
8
@查看是否保存
9
[root@redis63 ~]# tail -1 /etc/redis/redis.conf
10
replicaof 192.168.90.62 6379
11
[root@redis63 ~]# redis-cli
12
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
13
# Replication
14
role:slave #从角色
15
master_host:192.168.90.62 #主服务器IP
16
master_port:6379  #主服务端口
17
master_link_status:up #与主服务器连接状态
18
master_last_io_seconds_ago:3
19
master_sync_in_progress:0
20
slave_read_repl_offset:2025
21
slave_repl_offset:2025
22
slave_priority:100
23
slave_read_only:1
24
replica_announced:1
25
connected_slaves:0
26
master_failover_state:no-failover
27
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
28
master_replid2:0000000000000000000000000000000000000000
29
master_repl_offset:2025
30
second_repl_offset:-1
31
repl_backlog_active:1
32
repl_backlog_size:1048576
33
repl_backlog_first_byte_offset:1956
34
repl_backlog_histlen:70

2）在redis62查看复制信息

1
127.0.0.1:6379> info【因否】 replication
2
# Replication
3
role:slave  #本身是从服务器
4
master_host:192.168.90.61  #主服务器ip
5
master_port:6379  #主服务器redis服务端口
6
master_link_status:up   #与主服务器连接状态
7
master_last_io_seconds_ago:6
8
master_sync_in_progress:0
9
slave_read_repl_offset:2291
10
slave_repl_offset:2291
11
slave_priority:100
12
slave_read_only:1
13
replica_announced:1
14
connected_slaves:1  #本身有一个从服务器
15
slave0:ip=192.168.90.63,port=6379,state=online,offset=2291,lag=0 #从服务器信息
16
master_failover_state:no-failover
17
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
18
master_replid2:0000000000000000000000000000000000000000
19
master_repl_offset:2291
20
second_repl_offset:-1
21
repl_backlog_active:1
22
repl_backlog_size:1048576
23
repl_backlog_first_byte_offset:1
24
repl_backlog_histlen:2291

3)在redis61上查看信息

1
127.0.0.1:6379> info【因否】 replication
2
# Replication
3
role:master
4
connected_slaves:1 #只有一个从了
5
slave0:ip=192.168.90.62,port=6379,state=online,offset=2403,lag=0
6
master_failover_state:no-failover
7
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
8
master_replid2:0000000000000000000000000000000000000000
9
master_repl_offset:2403
10
second_repl_offset:-1
11
repl_backlog_active:1
12
repl_backlog_size:1048576
13
repl_backlog_first_byte_offset:1
14
repl_backlog_histlen:2403

六、置带验证的主从复制#

当前任务环节

基于案例1做如下配置：

配置主机redis61，redis服务连接密码为123456
主机redis62设置连接redis61的redis服务密码

给redis61主机的Redis服务设置连接密码，如果从服务器不指定连接密码无法同步数据。

6.1 配置主机redis61#

redis服务连接密码为123456

命令操作如下所示：

1
[root@redis61 ~]# redis-cli
2
127.0.0.1:6379> config get requirepass  #查看密码，默认服务没有密码
3
1) "requirepass"
4
2) ""
5
127.0.0.1:6379> config set requirepass 123456  #设置密码
6
OK
7
127.0.0.1:6379> auth 123456  #密码登录
8
OK
9
127.0.0.1:6379> config rewrite #保存配置
10
OK
11
127.0.0.1:6379> exit
12
#保存到文件的的密码
13
[root@redis61 ~]# grep "123456" /etc/redis/redis.conf
14
requirepass "123456"
15
#重启redis服务
16
[root@redis61 ~]# systemctl【西斯屯-ctl】 restart redis
17
[root@redis61 ~]# redis-cli
18
127.0.0.1:6379> auth 123456
19
OK
20
127.0.0.1:6379> info【因否】 replication
21
# Replication
22
role:master
23
connected_slaves:0 # 没有从服务器了 因为从没有输入连接密码连接不上主服务器
24
master_failover_state:no-failover
25
master_replid:7f7c394d93a5df791bbdfb207cdeaf1eb506358f
26
master_replid2:0000000000000000000000000000000000000000
27
master_repl_offset:0
28
second_repl_offset:-1
29
repl_backlog_active:0
30
repl_backlog_size:1048576
31
repl_backlog_first_byte_offset:0
32
repl_backlog_histlen:0

6.2 主机redis62设置连接redis61的redis服务密码#

命令操作如下所示：

1
#重启redis服务
2
[root@redis62 ~]# systemctl【西斯屯-ctl】 restart redis
3
[root@redis62 ~]# redis-cli
4
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
5
# Replication
6
role:slave
7
master_host:192.168.90.61
8
master_port:6379
9
master_link_status:down  #没设置密码 与master主机是断开状态
10
master_last_io_seconds_ago:-1
11
master_sync_in_progress:1
12
slave_read_repl_offset:1
13
slave_repl_offset:1
14
master_sync_total_bytes:-1
15
master_sync_read_bytes:0
16
master_sync_left_bytes:-1
17
master_sync_perc:-0.00
18
master_sync_last_io_seconds_ago:0
19
master_link_down_since_seconds:-1
20
slave_priority:100
21
slave_read_only:1
22
replica_announced:1
23
connected_slaves:0
24
master_failover_state:no-failover
25
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
26
master_replid2:0000000000000000000000000000000000000000
27
master_repl_offset:3383
28
second_repl_offset:-1
29
repl_backlog_active:0
30
repl_backlog_size:1048576
31
repl_backlog_first_byte_offset:0
32
repl_backlog_histlen:0

指定主服务器的密码

1
127.0.0.1:6379> config set masterauth 123456  #指定主服务器密码
2
OK
3
127.0.0.1:6379> config rewrite  #保存配置
4
OK
5
127.0.0.1:6379> info【因否】 replication  #查看主从信息
6
# Replication
7
role:slave
8
master_host:192.168.90.61
9
master_port:6379
10
master_link_status:up  #现在是启动状态
11
master_last_io_seconds_ago:2
12
master_sync_in_progress:0
13
slave_read_repl_offset:28
14
slave_repl_offset:28
15
slave_priority:100
16
slave_read_only:1
17
replica_announced:1
18
connected_slaves:1
19
slave0:ip=192.168.90.63,port=6379,state=online,offset=28,lag=1
20
master_failover_state:no-failover
21
master_replid:a288cad0a8747569f147c06bb63237b2751a9fb4
22
master_replid2:0000000000000000000000000000000000000000
23
master_repl_offset:28
24
second_repl_offset:-1
25
repl_backlog_active:1
26
repl_backlog_size:1048576
27
repl_backlog_first_byte_offset:1
28
repl_backlog_histlen:28

3)在redis61上查看信息

1
[root@redis61 ~]# redis-cli
2
127.0.0.1:6379> auth 123456
3
OK
4
127.0.0.1:6379> info【因否】 replication
5
# Replication
6
role:master
7
connected_slaves:1
8
slave0:ip=192.168.90.62,port=6379,state=online,offset=70,lag=1
9
master_failover_state:no-failover
10
master_replid:a288cad0a8747569f147c06bb63237b2751a9fb4
11
master_replid2:0000000000000000000000000000000000000000
12
master_repl_offset:70
13
second_repl_offset:-1
14
repl_backlog_active:1
15
repl_backlog_size:1048576
16
repl_backlog_first_byte_offset:1
17
repl_backlog_histlen:70

七、哨兵服务#

当前任务环节

7.1环境准备#

准备3台新的虚拟机

主机名	IP地址	说明
redis67	192.168.90.67	Master服务器
redis68	192.168.90.68	Slave服务器
redis69	192.168.90.69	哨兵服务

说明：

1）可以使用一主一从或一主多从或主从从 + 哨兵服务做服务的高可用和数据自动备份

2）如果主从结构中的redis服务设置连接密码的话必须全每台数据库都要设置密码且密码要一样，要么全都不设置密码。

3）如果Redis服务有密码宕机的服务器启动服务后，要人为指定主服务器的连接密码。

配置服务器192.168.90.67

1
[root@redis67 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis67
2
[root@redis67 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.67/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis67~]# nmcli connection【肯耐申】 up ens160

配置服务器192.168.90.68

1
[root@redis68 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis68
2
[root@redis68 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.68/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis68~]# nmcli connection【肯耐申】 up ens160

配置服务器192.168.90.69

1
[root@redis69 ~]# hostnamectl【厚斯内姆 ctl】 set-hostname【赛特-厚斯内姆】 redis69
2
[root@redis69 ~]# nmcli connection【肯耐申】 modify【莫迪fái】 ens160 ipv4.addresses【额拽西斯】 192.168.90.69/24 autoconnect【奥特欧 坑聂特】 yes
3
[root@redis69~]# nmcli connection【肯耐申】 up ens160

7.2 哨兵服务的原理#

Redis哨兵是一种分布式高可用解决方案，用于实现主从自动故障转移、集群监控以及充当配置中心自动更新客户端连接信息。其工作原理主要分为三个阶段：监控、共识和故障转移。

监控（Monitoring）：哨兵每秒向主/从节点发送PING命令，若节点超时（down-after-milliseconds，默认30s）无响应，该哨兵会将其标记为主观下线（SDOWN）。即单个哨兵认为实例不可用（PING无响应超过 down-after-milliseconds 配置）。
共识（Agreement）：哨兵集群通过Gossip协议交换节点状态。当多数哨兵（≥ quorum）都认为主节点下线时，会将其标记为客观下线（ODOWN）。也就是当足够数量（quorum配置）的哨兵都认为主节点不可用时，才判定主节点真正不可用。
故障转移（Failover）
- 选举领导者哨兵：基于Raft协议进行选举。发现主节点ODOWN的哨兵发起选举，每个哨兵在每个配置纪元（epoch）仅投一票，最先获得多数票（≥ N/2 + 1）的哨兵当选为领导者哨兵来执行故障转移；若选举超时（默认100ms），则会重新发起选举。
- 选择新主节点：从从节点中选出新主节点，选择规则依次基于优先级（slave-priority配置）、复制偏移量（选择数据最新的）、运行ID（选择较小的）。先排除已下线节点和replica-priority = 0的节点，然后选择优先级最高、复制偏移量最大、Run ID最小的节点。
- 重新配置：领导者哨兵将选中的从节点提升为主节点（执行SLAVEOF NO ONE命令）；通知其他从节点复制新的主节点（执行SLAVEOF new_master_ip port命令）；当旧主节点恢复时，将其配置为新主节点的从节点。
- 通知客户端：通过Redis的发布/订阅机制，将新主节点的IP和端口信息推送给客户端，让客户端更新配置，连接到新的主节点。

7.3 配置主机redis67为master服务器#

命令操作如下所示：

1
[root@redis67 ~]# yum -y install【因-斯多】 redis
2
#替换掉75行
3
[root@redis67 ~]# sed -i "75c bind 0.0.0.0" /etc/redis/redis.conf
4
[root@redis67 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
5
[root@redis67 ~]# redis-cli
6
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
7
# Replication
8
role:master   # 默认就是主服务器
9
connected_slaves:0  #没有从服务器
10
master_failover_state:no-failover
11
master_replid:bd86b885e9e6b21e452696d472e2b2852c7fea72
12
master_replid2:0000000000000000000000000000000000000000
13
master_repl_offset:0
14
second_repl_offset:-1
15
repl_backlog_active:0
16
repl_backlog_size:1048576
17
repl_backlog_first_byte_offset:0
18
repl_backlog_histlen:

7.4 配置主机redis68为redis67的slave服务器#

命令操作如下所示：

1
[root@redis68 ~]# yum -y install【因-斯多】 redis
2
[root@redis68 ~]# sed -i "75c bind 0.0.0.0" /etc/redis/redis.conf
3
[root@redis68 ~]# systemctl【西斯屯-ctl】   start【s 达儿】  redis
4
[root@redis68 ~]# redis-cli
5
127.0.0.1:6379> replicaof 192.168.90.67 6379  #指定主服务器ip和端口
6
OK
7
127.0.0.1:6379> config rewrite  #永久保存配置
8
OK
9
127.0.0.1:6379> exit
10
#查看文件末尾
11
[root@redis68 ~]# tail -1 /etc/redis/redis.conf
12
replicaof 192.168.90.67 6379
13
[root@redis62 ~]# redis-cli
14
127.0.0.1:6379> info【因否】 replication  #查看主从关系信息
15
# Replication
16
role:slave   #从角色
17
master_host:192.168.90.67  #主服务器ip地址
18
master_port:6379  #主服务器端口号
19
master_link_status:up  #与主服务器连接状态 （up 正常  down 连接失败）
20
master_last_io_seconds_ago:0
21
master_sync_in_progress:0
22
slave_read_repl_offset:84
23
slave_repl_offset:84
24
slave_priority:100
25
slave_read_only:1
26
replica_announced:1
27
connected_slaves:0
28
master_failover_state:no-failover
29
master_replid:f2fde7a2f3f7c6b3a20b1223b0c35ba55b245d0c
30
master_replid2:0000000000000000000000000000000000000000
31
master_repl_offset:84
32
second_repl_offset:-1
33
repl_backlog_active:1
34
repl_backlog_size:1048576
35
repl_backlog_first_byte_offset:1
36
repl_backlog_histlen:84

7.5 配置主机redis69运行哨兵服务#

安装redis软件，启动哨兵服务

1
[root@redis68 ~]# yum -y install【因-斯多】 redis
2
#哨兵配置文件
3
[root@redis69 ~]# vim /etc/redis/sentinel.conf
4
15 bind 0.0.0.0
5
26 daemonize yes
6
84 sentinel monitor mymaster 192.168.90.67 6379 1
7

8
#启动哨兵服务
9
[root@redis69 ~]# systemctl【西斯屯-ctl】  start【s 达儿】 redis-sentinel
10
#查看端口号
11
[root@redis69 ~]#  netstat  -utnlp  | grep 26379
12
tcp        0      0 0.0.0.0:26379           0.0.0.0:*               LISTEN      2179/redis-sentinel
13
[root@redis69 ~]#

2）查看日志获取监视信息

复制一个终端会话

1
[root@redis69 ~]# tail -f /var/log/redis/sentinel.log
2
2179:X 23 Jun 2025 15:47:44.301 * Supervised by systemd. Please make sure you set appropriate values for TimeoutStartSec and TimeoutStopSec in your service unit.
3
2179:X 23 Jun 2025 15:47:44.301 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
4
2179:X 23 Jun 2025 15:47:44.301 # Redis version=6.2.18, bits=64, commit=00000000, modified=0, pid=2179, just started
5
2179:X 23 Jun 2025 15:47:44.301 # Configuration loaded
6
2179:X 23 Jun 2025 15:47:44.302 * monotonic clock: POSIX clock_gettime
7
2179:X 23 Jun 2025 15:47:44.302 * Running mode=sentinel, port=26379.
8
2179:X 23 Jun 2025 15:47:44.304 # Sentinel ID is 5ab8d490e1e7b600170a2a725b4679d25186b4d1
9
2179:X 23 Jun 2025 15:47:44.304 # +monitor master mymaster 192.168.90.67 6379 quorum 1
10
2179:X 23 Jun 2025 15:47:44.306 * +slave slave 192.168.90.68:6379 192.168.90.68 6379 @ mymaster 192.168.90.67 6379

7.6 测试配置#

思路：停止master主机的redis 服务，原slave角色会升级为主，哨兵服务会自动监视新的master服务，宕机的master 主机恢复后自动配置为当前主的从服务器。

停止master主机的redis 服务

1
[root@redis67 ~]# systemctl【西斯屯-ctl】 stop【 s 多】 redis

查看slave

原slave角色会升级为主

1
127.0.0.1:6379> info【因否】 replication
2
# Replication
3
role:slave
4
master_host:192.168.90.67
5
master_port:6379
6
master_link_status:down  #master宕机了
7
master_last_io_seconds_ago:-1
8
master_sync_in_progress:0
9
slave_read_repl_offset:22602
10
slave_repl_offset:22602
11
master_link_down_since_seconds:27
12
slave_priority:100
13
slave_read_only:1
14
replica_announced:1
15
connected_slaves:0
16
master_failover_state:no-failover
17
master_replid:0f9c32408bfd386ab9c9ef00617298a969e89c73
18
master_replid2:0000000000000000000000000000000000000000
19
master_repl_offset:22602
20
second_repl_offset:-1
21
repl_backlog_active:1
22
repl_backlog_size:1048576
23
repl_backlog_first_byte_offset:1
24

25
#重新登录
26
[root@redis68 ~]#  redis-cli
27
127.0.0.1:6379> info【因否】 replication
28
# Replication
29
role:master #升级为master
30
connected_slaves:0
31
master_failover_state:no-failover
32
master_replid:8289cfb1acb8573be217df886ac24732f2bdb6a9
33
master_replid2:0f9c32408bfd386ab9c9ef00617298a969e89c73
34
master_repl_offset:25586
35
second_repl_offset:22603
36
repl_backlog_active:1
37
repl_backlog_size:1048576
38
repl_backlog_first_byte_offset:1

哨兵服务会自动监视新的master服务

宕机的master 主机恢复后自动配置为当前主的从服务器。

1
[root@redis67 ~]# redis-cli
2
127.0.0.1:6379> info【因否】 replication
3
Error: Server closed the connection【肯耐申】
4
127.0.0.1:6379> info【因否】 replication
5
# Replication
6
role:slave  #变成从服务器
7
master_host:192.168.90.68  #现在主服务器是192.168.90.68
8
master_port:6379
9
master_link_status:up
10
master_last_io_seconds_ago:2
11
master_sync_in_progress:0
12
slave_read_repl_offset:41965
13
slave_repl_offset:41965
14
slave_priority:100
15
slave_read_only:1
16
replica_announced:1
17
connected_slaves:0
18
master_failover_state:no-failover
19
master_replid:8289cfb1acb8573be217df886ac24732f2bdb6a9
20
master_replid2:0000000000000000000000000000000000000000
21
master_repl_offset:41965
22
second_repl_offset:-1
23
repl_backlog_active:1
24
repl_backlog_size:1048576
25
repl_backlog_first_byte_offset:41520
26
repl_backlog_histlen:446

八、作业#

1 选择题#

Redis 哨兵将主节点标记为客观下线（ODOWN）的条件是？ B A. 单个哨兵认为主节点不可用 B. 多数哨兵（≥ quorum）都认为主节点下线 C. 主节点主动发出下线通知 D. 主节点超过 1 分钟无响应
Redis Cluster 采用的分布式数据分片机制是？ A A. 哈希槽机制 B. 随机分配机制 C. 轮询机制 D. 顺序分配机制
在 Redis 主从复制中，从节点启动时会向主节点发送什么命令？ A A. SYNC 命令 B. SAVE 命令 C. FLUSHALL 命令 D. info 命令

2 简答题#

简述 Redis 哨兵服务的工作原理。答：
1. 监控（Monitoring）：哨兵每秒向主/从节点发送PING命令，若节点超时（down-after-milliseconds，默认30s）无响应，该哨兵会将其标记为主观下线（SDOWN）。即单个哨兵认为实例不可用（PING无响应超过 down-after-milliseconds 配置）。
2. 共识（Agreement）：哨兵集群通过Gossip协议交换节点状态。当多数哨兵（≥ quorum）都认为主节点下线时，会将其标记为客观下线（ODOWN）。也就是当足够数量（quorum配置）的哨兵都认为主节点不可用时，才判定主节点真正不可用。
3. 故障转移（Failover）
  - 选举领导者哨兵：基于Raft协议进行选举。发现主节点ODOWN的哨兵发起选举，每个哨兵在每个配置纪元（epoch）仅投一票，最先获得多数票（≥ N/2 + 1）的哨兵当选为领导者哨兵来执行故障转移；若选举超时（默认100ms），则会重新发起选举。
  - 选择新主节点：从从节点中选出新主节点，选择规则依次基于优先级（slave-priority配置）、复制偏移量（选择数据最新的）、运行ID（选择较小的）。先排除已下线节点和replica-priority = 0的节点，然后选择优先级最高、复制偏移量最大、Run ID最小的节点。
  - 重新配置：领导者哨兵将选中的从节点提升为主节点（执行SLAVEOF NO ONE命令）；通知其他从节点复制新的主节点（执行SLAVEOF new_master_ip port命令）；当旧主节点恢复时，将其配置为新主节点的从节点。
4. 通知客户端：通过Redis的发布/订阅机制，将新主节点的IP和端口信息推送给客户端，让客户端更新配置，连接到新的主节点。
说明 Redis 集群中分布式数据分片的好处。答：
1. 水平扩展：突破单机性能瓶颈，将数据和请求负载分散到多个节点，可线性提升吞吐量（QPS）和存储容量。动态扩容在通过迁移槽位（如 redis-cli —cluster reshard），可在不停服的情况下增减节点。
2. 高可用性：自动故障转移，每个主节点可配置从节点（replica），主节点宕机时，从节点自动升主，主节点恢复自从加入新主节点的从节点。无单点故障，即使部分节点失效，其余节点仍可提供服务（只要大多数主节点存活）。
3. 数据分布均衡：确定性分片，如slot = CRC16(key) % 16384 确保相同 key 总路由到同一节点，避免数据重复。均匀分布，哈希算法使 key 在槽位间近似均匀分布，结合槽位均分到节点，实现负载均衡。
请阐述 Redis 主从复制的过程。答：
1. 建立连接：从节点启动后，向主节点发起连接，并发送 PSYNC 命令（首次为 PSYNC ? -1）。
2. 主节点收到首次 PSYNC 后，执行 BGSAVE 生成 RDB 快照，同时将新写命令缓存在复制积压缓冲区（repl_backlog），DB 生成后，主节点将其发送给从节点，从节点清空本地数据，加载 RDB。

3 操作题#

请写出配置 Redis 一主一从结构的详细步骤。

1
[root@redis60 ~]#     主配置
2
[root@redis60 ~]# systemctl start redis.service
3
[root@redis60 ~]# redis-cli
4
127.0.0.1:6379> config set protected-mode no
5
OK
6
127.0.0.1:6379> config rewrite
7
OK
8
127.0.0.1:6379> info replication
9
# Replication
10
role:master
11
connected_slaves:0
12
master_failover_state:no-failover
13
master_replid:2aae21339753d355129c78fab17bd7a1c547aedf
14
master_replid2:0000000000000000000000000000000000000000
15
master_repl_offset:0
16
second_repl_offset:-1
17
repl_backlog_active:0
18
repl_backlog_size:1048576
19
repl_backlog_first_byte_offset:0
20
repl_backlog_histlen:0
21

22

23

24
[root@redis61 ~]#     从配置
25
[root@redis61 ~]# systemctl start redis.service
26
[root@redis61 ~]# redis-cli
27
127.0.0.1:6379> config set protected-mode no
28
OK
29
127.0.0.1:6379> config rewrite
30
OK
31
127.0.0.1:6379> replicaof 192.168.88.60 6379
32
OK
33
127.0.0.1:6379> config rewrite
34
OK
35
127.0.0.1:6379> info replication
36
# Replication
37
role:slave
38
master_host:192.168.88.60
39
master_port:6379
40
master_link_status:up
41
master_last_io_seconds_ago:9
42
master_sync_in_progress:0
43
slave_read_repl_offset:224
44
slave_repl_offset:224
45
replica_full_sync_buffer_size:0
46
replica_full_sync_buffer_peak:0
47
master_current_sync_attempts:160
48
master_total_sync_attempts:160
49
master_link_up_since_seconds:154
50
total_disconnect_time_sec:0
51
slave_priority:100
52
slave_read_only:1
53
replica_announced:1
54
connected_slaves:0
55
master_failover_state:no-failover
56
master_replid:a321b83129695ff3cea398fd398097e9b99f63f5
57
master_replid2:0000000000000000000000000000000000000000
58
master_repl_offset:224
59
second_repl_offset:-1
60
repl_backlog_active:1
61
repl_backlog_size:1048576
62
repl_backlog_first_byte_offset:15
63
repl_backlog_histlen:210
64
127.0.0.1:6379>
65

66

67
127.0.0.1:6379>    主redis状态检查
68
127.0.0.1:6379> info replication
69
# Replication
70
role:master
71
connected_slaves:1
72
slave0:ip=192.168.88.61,port=6379,state=online,offset=266,lag=1
73
master_failover_state:no-failover
74
master_replid:a321b83129695ff3cea398fd398097e9b99f63f5
75
master_replid2:0000000000000000000000000000000000000000
76
master_repl_offset:266
77
second_repl_offset:-1
78
repl_backlog_active:1
79
repl_backlog_size:1048576
80
repl_backlog_first_byte_offset:1
81
repl_backlog_histlen:266
82
127.0.0.1:6379>
83

84

85

86
127.0.0.1:6379>     验证：主写入数据
87
127.0.0.1:6379> mset a 1 b 2 c 3 d 4 e 5 f 6
88
OK
89
127.0.0.1:6379>
90

91
127.0.0.1:6379>     验证：从数据读取
92
127.0.0.1:6379> keys *
93
1) "a"
94
2) "d"
95
3) "f"
96
4) "b"
97
5) "c"
98
6) "e"
99
127.0.0.1:6379> mget a b c d e f
100
1) "1"
101
2) "2"
102
3) "3"
103
4) "4"
104
5) "5"
105
6) "6"
106
127.0.0.1:6379>

描述创建 Redis 高可用集群的具体操作过程。

1
# 集群配置
2

3
[root@redis59 ~]#
4
[root@redis59 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
5
1:bind 0.0.0.0
6
2:protected-mode no
7
3:port 6379
8
7:daemonize no
9
51:cluster-enabled yes
10
52:cluster-config-file nodes-6379.conf
11
53:cluster-node-timeout 5000
12
[root@redis59 ~]# systemctl start redis.service
13

14
[root@redis60 ~]#
15
[root@redis60 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
16
1:bind 0.0.0.0
17
2:protected-mode no
18
3:port 6379
19
7:daemonize no
20
51:cluster-enabled yes
21
52:cluster-config-file nodes-6379.conf
22
53:cluster-node-timeout 5000
23
[root@redis60 ~]# systemctl start redis.service
24

25
[root@redis61 ~]#
26
[root@redis61 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
27
1:bind 0.0.0.0
28
2:protected-mode no
29
3:port 6379
30
7:daemonize no
31
51:cluster-enabled yes
32
52:cluster-config-file nodes-6379.conf
33
53:cluster-node-timeout 5000
34
[root@redis61 ~]# systemctl start redis.service
35

36
[root@redis62 ~]#
37
[root@redis62 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
38
1:bind 0.0.0.0
39
2:protected-mode no
40
3:port 6379
41
7:daemonize no
42
51:cluster-enabled yes
43
52:cluster-config-file nodes-6379.conf
44
53:cluster-node-timeout 5000
45
[root@redis62 ~]# systemctl start redis.service
46

47
[root@redis63 ~]#
48
[root@redis63 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
49
1:bind 0.0.0.0
50
2:protected-mode no
51
3:port 6379
52
7:daemonize no
53
51:cluster-enabled yes
54
52:cluster-config-file nodes-6379.conf
55
53:cluster-node-timeout 5000
56
[root@redis63 ~]# systemctl start redis.service
57

58
[root@redis64 ~]#
59
[root@redis64 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep -nE "bind|protected-mode|port|daemonize|cluster"
60
1:bind 0.0.0.0
61
2:protected-mode no
62
3:port 6379
63
7:daemonize no
64
51:cluster-enabled yes
65
52:cluster-config-file nodes-6379.conf
66
53:cluster-node-timeout 5000
67
[root@redis64 ~]# systemctl start redis.service
68

69

70
[root@redis59 ~]#     搭建集群
71
[root@redis59 ~]# redis-cli --cluster create 192.168.88.59:6379 192.168.88.60:6379 192.168.88.61:6379 192.168.88.62:6379 192.168.88.63:6379 192.168.88.64:6379 --cluster-replicas 1
72
>>> Performing hash slots allocation on 6 nodes...
73
Master[0] -> Slots 0 - 5460
74
Master[1] -> Slots 5461 - 10922
75
Master[2] -> Slots 10923 - 16383
76
Adding replica 192.168.88.63:6379 to 192.168.88.59:6379
77
Adding replica 192.168.88.64:6379 to 192.168.88.60:6379
78
Adding replica 192.168.88.62:6379 to 192.168.88.61:6379
79
M: 4f75181056b5aefd90f2b1cc242e105f929ec5b4 192.168.88.59:6379
80
   slots:[0-5460] (5461 slots) master
81
M: e92ce91b5b3b4587c5520482e7a825b050d02dee 192.168.88.60:6379
82
   slots:[5461-10922] (5462 slots) master
83
M: 8f23c1c05cda60f570d70543c5ea3e5bf643c89c 192.168.88.61:6379
84
   slots:[10923-16383] (5461 slots) master
85
S: fa61df96aea2f9a53427eae75fd0c82e4b916ffb 192.168.88.62:6379
86
   replicates 8f23c1c05cda60f570d70543c5ea3e5bf643c89c
87
S: 1ca6b10204e7df92340b5c8318416340d4c5ec6b 192.168.88.63:6379
88
   replicates 4f75181056b5aefd90f2b1cc242e105f929ec5b4
89
S: 0d342ee7810cadea394eb62a7da4e3a1f320f680 192.168.88.64:6379
90
   replicates e92ce91b5b3b4587c5520482e7a825b050d02dee
91
Can I set the above configuration? (type 'yes' to accept): yes
92
>>> Nodes configuration updated
93
>>> Assign a different config epoch to each node
94
>>> Sending CLUSTER MEET messages to join the cluster
95
Waiting for the cluster to join
96

97
>>> Performing Cluster Check (using node 192.168.88.59:6379)
98
M: 4f75181056b5aefd90f2b1cc242e105f929ec5b4 192.168.88.59:6379
99
   slots:[0-5460] (5461 slots) master
100
   1 additional replica(s)
101
M: e92ce91b5b3b4587c5520482e7a825b050d02dee 192.168.88.60:6379
102
   slots:[5461-10922] (5462 slots) master
103
   1 additional replica(s)
104
M: 8f23c1c05cda60f570d70543c5ea3e5bf643c89c 192.168.88.61:6379
105
   slots:[10923-16383] (5461 slots) master
106
   1 additional replica(s)
107
S: 0d342ee7810cadea394eb62a7da4e3a1f320f680 192.168.88.64:6379
108
   slots: (0 slots) slave
109
   replicates e92ce91b5b3b4587c5520482e7a825b050d02dee
110
S: fa61df96aea2f9a53427eae75fd0c82e4b916ffb 192.168.88.62:6379
111
   slots: (0 slots) slave
112
   replicates 8f23c1c05cda60f570d70543c5ea3e5bf643c89c
113
S: 1ca6b10204e7df92340b5c8318416340d4c5ec6b 192.168.88.63:6379
114
   slots: (0 slots) slave
115
   replicates 4f75181056b5aefd90f2b1cc242e105f929ec5b4
116
[OK] All nodes agree about slots configuration.
117
>>> Check for open slots...
118
>>> Check slots coverage...
119
[OK] All 16384 slots covered.
120
[root@redis59 ~]#
121

122

123
[root@redis59 ~]#      查看集群信息
124
[root@redis59 ~]# redis-cli --cluster info 192.168.88.59:6379
125
192.168.88.59:6379 (4f751810...) -> 0 keys | 5461 slots | 1 slaves.
126
192.168.88.60:6379 (e92ce91b...) -> 0 keys | 5462 slots | 1 slaves.
127
192.168.88.61:6379 (8f23c1c0...) -> 0 keys | 5461 slots | 1 slaves.
128
[OK] 0 keys in 3 masters.
129
0.00 keys per slot on average.
130
[root@redis59 ~]#
131

132

133
[root@redis59 ~]#  访问集群验证数据
134
[root@redis59 ~]# redis-cli -c -h 192.168.88.59 -p 6379
135
192.168.88.59:6379> set a 1
136
-> Redirected to slot [15495] located at 192.168.88.61:6379
137
OK
138
192.168.88.61:6379> set b 2
139
-> Redirected to slot [3300] located at 192.168.88.59:6379
140
OK
141
192.168.88.59:6379> set c 3
142
-> Redirected to slot [7365] located at 192.168.88.60:6379
143
OK
144
192.168.88.60:6379> get a
145
-> Redirected to slot [15495] located at 192.168.88.61:6379
146
"1"
147
192.168.88.61:6379> get a
148
"1"
149
192.168.88.61:6379> get b
150
-> Redirected to slot [3300] located at 192.168.88.59:6379
151
"2"
152
192.168.88.59:6379> get c
153
-> Redirected to slot [7365] located at 192.168.88.60:6379
154
"3"
155
192.168.88.60:6379>

说明如何使用 RDB 文件恢复 Redis 数据。

1
[root@redis59 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep save
2
save 3600 1 120 10 60 10000
3
stop-writes-on-bgsave-error yes
4
rdb-save-incremental-fsync yes
5
[root@redis59 ~]# systemctl start redis.service
6
[root@redis59 ~]# ls /opt/redis/data/
7
[root@redis59 ~]# redis-cli
8
127.0.0.1:6379> keys *
9
(empty array)
10
127.0.0.1:6379> mset a 1 b 2 c 3 d 4 x 1 y 2  z 3 k 6  i 7  z 9   f 22  zz 99  cc  66
11
OK
12
127.0.0.1:6379> keys *
13
 1) "c"
14
 2) "d"
15
 3) "k"
16
 4) "a"
17
 5) "cc"
18
 6) "x"
19
 7) "zz"
20
 8) "f"
21
 9) "y"
22
10) "b"
23
11) "i"
24
12) "z"
25
127.0.0.1:6379> exit
26
[root@redis59 ~]# ls /opt/redis/data/
27
dump.rdb
28
[root@redis59 ~]#
29

30

31
#  在60服务器上恢复数据
32
[root@redis60 ~]#
33
[root@redis60 ~]# grep -vE "^\s*($|#)" /opt/redis/conf/redis.conf | grep save
34
save 3600 1 120 10 60 10000
35
stop-writes-on-bgsave-error yes
36
rdb-save-incremental-fsync yes
37
[root@redis60 ~]# systemctl start redis.service
38
[root@redis60 ~]# redis-cli
39
127.0.0.1:6379> keys *
40
(empty array)
41
127.0.0.1:6379> exit
42
[root@redis60 ~]# systemctl stop redis.service
43
[root@redis60 ~]# ls /opt/redis/data/
44
dump.rdb
45
[root@redis60 ~]# rm -rf /opt/redis/data/dump.rdb
46
[root@redis60 ~]# scp root@192.168.88.59:/opt/redis/data/dump.rdb /opt/redis/data/
47
root@192.168.88.59's password:
48
dump.rdb                                                           100%  157    84.3KB/s   00:00
49
[root@redis60 ~]# ll /opt/redis/data/
50
总用量 4
51
-rw-r--r-- 1 root root 157 1月  22 10:15 dump.rdb
52
[root@redis60 ~]# systemctl start redis.service
53
[root@redis60 ~]# redis-cli
54
127.0.0.1:6379> keys *
55
 1) "y"
56
 2) "f"
57
 3) "c"
58
 4) "a"
59
 5) "b"
60
 6) "zz"
61
 7) "z"
62
 8) "i"
63
 9) "cc"
64
10) "x"
65
11) "k"
66
12) "d"
67
127.0.0.1:6379>