Redis Cluster 集群详解:分片算法、搭建、故障处理与扩容实战

✅️ 集群(Cluster)

目录

  • [1. 基本概念](#1. 基本概念)
  • [2. 数据分片算法](#2. 数据分片算法)
    • [2.1 哈希求余](#2.1 哈希求余)
    • [2.2 一致性哈希算法](#2.2 一致性哈希算法)
    • [2.3 哈希槽分区算法(Redis使用)](#2.3 哈希槽分区算法(Redis使用))
  • [3. 集群搭建(基于docker)](#3. 集群搭建(基于docker))
  • [4. 主节点宕机](#4. 主节点宕机)
  • [5. 故障处理流程](#5. 故障处理流程)
  • [6. 集群扩容](#6. 集群扩容)
  • [7. 总结](#7. 总结)
  • [8. 经典面试题](#8. 经典面试题)
1. 基本概念
2. 数据分片算法

Redis cluster 的核⼼思路是⽤多组机器来存数据的每个部分. 那么接下来的核⼼问题就是, 给定⼀个数据 (⼀个具体的 key), 那么这个数据应该存储在哪个分⽚上? 读取的时候⼜应该去哪个分⽚读取?

围绕这个问题, 业界有三种⽐较主流的实现⽅式.

2.1 哈希求余

📌 拓展

md5:本身就是一个计算hash值的算法,针对一个字符串,里面的内容进行一系列的数学变换- 整数。MD5是一个广泛使用的hash算法,特点:

1.md5的计算结果是定长的,无论输入的字符串多长,最终算出的结果都是固定长度

2.md5计算结果都是分散的(哈希函数)两个原字符串,哪怕大部分相同,只有一个小地方不同,计算结果也会差别很大。

3.md5计算结果是不可逆的,给你一个原字符串,可以很容易算出md5的值,给你md5值,很难还原出原始的字符串(理论上上是不可行的)。但是

网上的一些md5破解,其实就是把一些常见的字符串的md5值提前算好,保存下来,就按照打表的方式,根据md5值映射到原字符串,能不能查到就随缘了。

2.2 一致性哈希算法

🧱 为了降低上述的搬运开销,能够高效的扩容,此时就需要引入"一致性哈希算法"。

key映射到分片序号的过程不在是简单求余了,而是改为如下的过程:

在这个情况下, 如果扩容⼀个分⽚, 如何处理呢?
原有分⽚在环上的位置不动, 只要在环上新安排⼀个分⽚位置即可.


🐯优点: ⼤大降低了扩容时数据搬运的规模, 提⾼了扩容操作的效率.

缺点: 数据分配不均匀 (有的多有的少, 数据倾斜).

2.3 哈希槽分区算法(Redis使用)

🐻 算法本质:哈希槽分区算法本质就是把一致性哈希算法和哈希求余这两种方式结合起来。

为了解决上述问题(搬运成本高和数据分配不均匀),Redis Cluster引入了哈希槽(hash slots)算法。

🐼 拓展问题

问题⼀: Redis 集群是最多有 16384 个分⽚吗?

并⾮如此. 如果⼀个分⽚只有⼀个槽位, 这对于集群的数据均匀其实是难以保证的.实际上 Redis 的作者建议集群分⽚数不应该超过 1000.⽽且, 16000 这么⼤规模的集群, 本⾝的可⽤性也是⼀个⼤问题. ⼀个系统越复杂, 出现故障的概率是越⾼的.

问题⼆: 为什么是 16384 个槽位?

① 节点之间通过⼼跳包通信. ⼼跳包中包含了该节点持有哪些 slots. 这个是使⽤位图这样的数据结构表⽰的. 表⽰ 16384 (16k) 个 slots, 需要的位图⼤⼩是 2KB. 如果给定的 slots 数更多了, ⽐如 65536个了, 此时就需要消耗更多的空间, 8 KB 位图表⽰了. 8 KB, 对于内存来说不算什么, 但是在频繁的⽹络⼼跳包中, 还是⼀个不⼩的开销的.

② 另⼀⽅⾯, Redis 集群⼀般不建议超过 1000 个分⽚. 所以 16k 对于最⼤1000个分⽚来说是⾜够⽤的, 同时也会使对应的槽位配置位图体积不⾄于很⼤.

3. 集群搭建(基于docker)

接下来基于 docker, 搭建⼀个集群. 每个节点都是⼀个容器.

拓扑结构如下:

💡 提示:此处创建11个redis节点,其中前9个用来演示集群搭建,后两个用来演示集群扩容。

第一步:创建目录和配置

  1. 创建redis-cluster 目录,内部创建两个文件。
bash 复制代码
[lijing@localhost redis-cluster]$ tree ../redis-cluster/
../redis-cluster/
├── docker-compose.yml
└── generate.sh

0 directories, 2 files
  1. generate.sh文件如下:
bash 复制代码
#!/bin/bash
set -euo pipefail

# 生成 11 个 Redis 集群节点的配置目录与 redis.conf
# 节点 IP 规划:172.30.0.101 ~ 172.30.0.111(需在 docker-compose 中为容器指定静态 IP)
# 说明:redis.conf 不支持行尾注释,注释只能写在本脚本中,不能出现在 heredoc 内容里

NODES=11
BASE_IP="172.30.0"
BASE_HOST=100

# 清理旧目录:nodes.conf 由 Redis 自动生成,残留会导致集群信息与新的 announce-ip 冲突
rm -rf redis{1..11}

for i in $(seq 1 "${NODES}"); do
    dir="redis${i}"
    mkdir -p "${dir}"

    cat > "${dir}/redis.conf" <<EOF
port 6379
bind 0.0.0.0
protected-mode no
appendonly yes
cluster-enabled yes
cluster-config-file nodes.conf # 不需要手动配置,后续redis会自动生成(后续启动后会有一些集群信息放到这)
cluster-node-timeout 5000
cluster-announce-ip ${BASE_IP}.$((BASE_HOST + i))
cluster-announce-port 6379
cluster-announce-bus-port 16379
EOF

    echo "已生成 ${dir}/redis.conf  cluster-announce-ip ${BASE_IP}.$((BASE_HOST + i))"
done

📚 说明:

  1. cluster-announce-ip ${BASE_IP}.$((BASE_HOST + i)):该redis(自己)所在自己的IP地址(当前是使用docker容器模拟的主机,此处写的应该是docker容器的ip)
  2. cluster-announce-port 6379 : 业务端口:用来进行业务数据通信的,即响应客户端的请求的端口。
  3. cluster-announce-bus-port 16379 : 管理端口:为了完成一些管理上的任务来进行通信的端口。比如如果某个分片中的redis主节点挂了,就需要让从节点变成主节点,就需要通过刚才的管理端口来完成对应的操作。(sentinel管理)
  4. cluster-enabled yes 开启集群.
  5. cluster-config-file nodes.conf 集群节点⽣成的配置.
  6. cluster-node-timeout 5000 节点失联的超时时间.
  1. 执行命令:
bash 复制代码
[root@localhost redis-cluster]# ll
总用量 4
-rw-rw-r--. 1 lijing lijing   0 11月 15 21:17 docker-compose.yml
-rwxrwxr-x. 1 lijing lijing 943 11月 15 21:38 generate.sh
[root@localhost redis-cluster]# ./generate.sh 
已生成 redis1/redis.conf  cluster-announce-ip 172.30.0.101
已生成 redis2/redis.conf  cluster-announce-ip 172.30.0.102
已生成 redis3/redis.conf  cluster-announce-ip 172.30.0.103
已生成 redis4/redis.conf  cluster-announce-ip 172.30.0.104
已生成 redis5/redis.conf  cluster-announce-ip 172.30.0.105
已生成 redis6/redis.conf  cluster-announce-ip 172.30.0.106
已生成 redis7/redis.conf  cluster-announce-ip 172.30.0.107
已生成 redis8/redis.conf  cluster-announce-ip 172.30.0.108
已生成 redis9/redis.conf  cluster-announce-ip 172.30.0.109
已生成 redis10/redis.conf  cluster-announce-ip 172.30.0.110
已生成 redis11/redis.conf  cluster-announce-ip 172.30.0.111
  1. 结果目录如下:
bash 复制代码
[root@localhost redis-cluster]# tree ../redis-cluster/
../redis-cluster/
├── docker-compose.yml
├── generate.sh
├── redis1
│   └── redis.conf
├── redis10
│   └── redis.conf
├── redis11
│   └── redis.conf
├── redis2
│   └── redis.conf
├── redis3
│   └── redis.conf
├── redis4
│   └── redis.conf
├── redis5
│   └── redis.conf
├── redis6
│   └── redis.conf
├── redis7
│   └── redis.conf
├── redis8
│   └── redis.conf
└── redis9
    └── redis.conf

🐳 注意:上面的每一个redis.conf都是不同的,区别在于每个配置中的cluster-announce-ip是不同的,其他部分都相同。后续会给每个节点分配不同的 ip 地址.

第一步:: 编写 docker-compose.yml

  • 先创建 networks, 并分配⽹段为 172.30.0.0/24
  • 配置每个节点. 注意配置⽂件映射, 端⼝映射, 以及容器的 ip 地址. 设定成固定ip⽅便后续的观察和操作.

此处的端⼝映射不配置也可以, 配置的⽬的是为了可以通过宿主机 ip + 映射的端⼝进⾏访问. 通过 容器⾃⾝ ip:6379 的⽅式也可以访问.

bash 复制代码
version: '3.7'

networks:
  mynet:
    ipam:
      config:
        - subnet: 172.30.0.0/24

services:
  redis1:
    image: 'redis:5.0.9'
    container_name: redis1
    restart: always
    volumes:
      - ./redis1/:/etc/redis/
    ports:
      - 6371:6379
      - 16371:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.101

  redis2:
    image: 'redis:5.0.9'
    container_name: redis2
    restart: always
    volumes:
      - ./redis2/:/etc/redis/
    ports:
      - 6372:6379   # 此处不进行端口映射,也是可以的,映射一下的目的是为了在容器外面通过客户端直接访问
      - 16372:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.102

  redis3:
    image: 'redis:5.0.9'
    container_name: redis3
    restart: always
    volumes:
      - ./redis3/:/etc/redis/
    ports:
      - 6373:6379
      - 16373:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.103

  redis4:
    image: 'redis:5.0.9'
    container_name: redis4
    restart: always
    volumes:
      - ./redis4/:/etc/redis/
    ports:
      - 6374:6379
      - 16374:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.104

  redis5:
    image: 'redis:5.0.9'
    container_name: redis5
    restart: always
    volumes:
      - ./redis5/:/etc/redis/
    ports:
      - 6375:6379
      - 16375:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.105

  redis6:
    image: 'redis:5.0.9'
    container_name: redis6
    restart: always
    volumes:
      - ./redis6/:/etc/redis/
    ports:
      - 6376:6379
      - 16376:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.106

  redis7:
    image: 'redis:5.0.9'
    container_name: redis7
    restart: always
    volumes:
      - ./redis7/:/etc/redis/
    ports:
      - 6377:6379
      - 16377:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.107

  redis8:
    image: 'redis:5.0.9'
    container_name: redis8
    restart: always
    volumes:
      - ./redis8/:/etc/redis/
    ports:
      - 6378:6379
      - 16378:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.108

  redis9:
    image: 'redis:5.0.9'
    container_name: redis9
    restart: always
    volumes:
      - ./redis9/:/etc/redis/
    ports:
      - 6379:6379
      - 16379:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.109

  redis10:
    image: 'redis:5.0.9'
    container_name: redis10
    restart: always
    volumes:
      - ./redis10/:/etc/redis/
    ports:
      - 6380:6379
      - 16380:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.110

  redis11:
    image: 'redis:5.0.9'
    container_name: redis11
    restart: always
    volumes:
      - ./redis11/:/etc/redis/
    ports:
      - 6381:6379
      - 16381:16379
    command: redis-server /etc/redis/redis.conf
    networks:
      mynet:
        ipv4_address: 172.30.0.111

第三步 启动容器

bash 复制代码
docker compose up -d

第四部 :构建集群

启动一个docker 客户端

bash 复制代码
redis-cli --cluster create 172.30.0.101:6379 172.30.0.102:6379 
172.30.0.103:6379 172.30.0.104:6379 172.30.0.105:6379 172.30.0.106:6379 
172.30.0.107:6379 172.30.0.108:6379 172.30.0.109:6379 --cluster-replicas 2
  • --cluster create 表⽰建⽴集群. 后⾯填写每个节点的 ip 和地址.
  • --cluster-replicas 2 表⽰每个主节点需要两个从节点备份

执行之后,容器之间会加入集群操作,日志中会描述哪些节点是主节点,哪些从节点跟随于哪个主节点。

bash 复制代码
>>> Performing hash slots allocation on 9 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.30.0.105:6379 to 172.30.0.101:6379
Adding replica 172.30.0.106:6379 to 172.30.0.101:6379
Adding replica 172.30.0.107:6379 to 172.30.0.102:6379
Adding replica 172.30.0.108:6379 to 172.30.0.102:6379
Adding replica 172.30.0.109:6379 to 172.30.0.103:6379
Adding replica 172.30.0.104:6379 to 172.30.0.103:6379
M: e4f37f8f0ea0dafc584349999795716613910e51 172.30.0.101:6379
slots:[0-5460] (5461 slots) master
M: 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 172.30.0.102:6379
slots:[5461-10922] (5462 slots) master
M: b3c0a96f6a206088ecea639147b6fcf903afe872 172.30.0.103:6379
slots:[10923-16383] (5461 slots) master
S: 85025819223f12615046c54d89f510e9cd0444a1 172.30.0.104:6379
replicates b3c0a96f6a206088ecea639147b6fcf903afe872
S: 2e5dc211288784ba55d554a377b87bfe2b5398db 172.30.0.105:6379
replicates e4f37f8f0ea0dafc584349999795716613910e51
S: 29f05d98982bd3df05d0222091e4b8ef9569f424 172.30.0.106:6379
replicates e4f37f8f0ea0dafc584349999795716613910e51
S: 3584840ac704c3ee016f3bdcca3f7ebe6f6e8e80 172.30.0.107:6379
replicates 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c
S: 0a889103b35db2a6e82e8c09904bbef310cff3b1 172.30.0.108:6379
replicates 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c
S: 00ba82bed6abeb015116d51d1af7fcb1609d03ad 172.30.0.109:6379
replicates b3c0a96f6a206088ecea639147b6fcf903afe872
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
 ...
 >>> Performing Cluster Check (using node 172.30.0.101:6379)
 M: e4f37f8f0ea0dafc584349999795716613910e51 172.30.0.101:6379
slots:[0-5460] (5461 slots) master
2 additional replica(s)
M: 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 172.30.0.102:6379
slots:[5461-10922] (5462 slots) master
additional replica(s)
S: 2e5dc211288784ba55d554a377b87bfe2b5398db 172.30.0.105:6379
slots: (0 slots) slave
replicates e4f37f8f0ea0dafc584349999795716613910e51
S: 0a889103b35db2a6e82e8c09904bbef310cff3b1 172.30.0.108:6379
slots: (0 slots) slave
replicates 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c
S: 3584840ac704c3ee016f3bdcca3f7ebe6f6e8e80 172.30.0.107:6379
slots: (0 slots) slave
replicates 5f71983ad52cc7077ce8874ae1c4f9c23d9f502c
S: 85025819223f12615046c54d89f510e9cd0444a1 172.30.0.104:6379
slots: (0 slots) slave
replicates b3c0a96f6a206088ecea639147b6fcf903afe872
S: 00ba82bed6abeb015116d51d1af7fcb1609d03ad 172.30.0.109:6379
slots: (0 slots) slave
replicates b3c0a96f6a206088ecea639147b6fcf903afe872
S: 29f05d98982bd3df05d0222091e4b8ef9569f424 172.30.0.106:6379
 slots: (0 slots) slave
 replicates e4f37f8f0ea0dafc584349999795716613910e51
M: b3c0a96f6a206088ecea639147b6fcf903afe872 172.30.0.103:6379
 slots:[10923-16383] (5461 slots) master
 2 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

显示ok即表示创建集群成功!

此时, 使⽤客⼾端连上集群中的任何⼀个节点, 都相当于连上了整个集群.

  • 客⼾端后⾯要加上-c选项, 否则如果key没有落到当前节点上, 是不能操作的. -c 会⾃动把请求重定向到对应节点.
  • 使⽤ cluster nodes 可以查看到整个集群的情况.

✏️ 笔记 :-c选型加上后,redis客户端就会通过当前的key实际计算出的槽位号,自动找到匹配的分区主机,进一步就可以完成操作。

具体构建集群的步骤如下:

  1. 生成每个redis节点的配置文件
  2. 使用docker创建出11个redis节点,并且启动容器
  3. 使用redis-cli执行构建集群命令
4. 主节点宕机

此处手动模拟一个主节点宕机,即使用命令docker stop redis1 即可将redis1主节点宕机

bash 复制代码
172.30.0.102:6379> CLUSTER NODES
e4f37f8f0ea0dafc584349999795716613910e51 172.30.0.101:6379@16379 master,fail - 
1682599172083 1682599170000 1 connected  # 此处可以看到101 fail了 原来slave的105成了新master
0a889103b35db2a6e82e8c09904bbef310cff3b1 172.30.0.108:6379@16379 slave 
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 0 1682603536508 8 connected
29f05d98982bd3df05d0222091e4b8ef9569f424 172.30.0.106:6379@16379 slave 
2e5dc211288784ba55d554a377b87bfe2b5398db 0 1682603537512 10 connected
00ba82bed6abeb015116d51d1af7fcb1609d03ad 172.30.0.109:6379@16379 slave 
b3c0a96f6a206088ecea639147b6fcf903afe872 0 1682603536000 9 connected
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 172.30.0.102:6379@16379 myself,master 
- 0 1682603535000 2 connected 5461-10922
b3c0a96f6a206088ecea639147b6fcf903afe872 172.30.0.103:6379@16379 master - 0 
1682603537009 3 connected 10923-16383
2e5dc211288784ba55d554a377b87bfe2b5398db 172.30.0.105:6379@16379 master - 0 
1682603537000 10 connected 0-5460
3584840ac704c3ee016f3bdcca3f7ebe6f6e8e80 172.30.0.107:6379@16379 slave 
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 0 1682603537512 7 connected
85025819223f12615046c54d89f510e9cd0444a1 172.30.0.104:6379@16379 slave 
b3c0a96f6a206088ecea639147b6fcf903afe872 0 1682603536708 4 connected

使用命令docker start redis1 可以看到:redis1仍然是slave

bash 复制代码
172.30.0.102:6379> CLUSTER NODES
e4f37f8f0ea0dafc584349999795716613910e51 172.30.0.101:6379@16379 slave 
2e5dc211288784ba55d554a377b87bfe2b5398db 0 1682603944000 10 connected
0a889103b35db2a6e82e8c09904bbef310cff3b1 172.30.0.108:6379@16379 slave 
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 0 1682603944628 8 connected
29f05d98982bd3df05d0222091e4b8ef9569f424 172.30.0.106:6379@16379 slave 
2e5dc211288784ba55d554a377b87bfe2b5398db 0 1682603943625 10 connected
00ba82bed6abeb015116d51d1af7fcb1609d03ad 172.30.0.109:6379@16379 slave 
b3c0a96f6a206088ecea639147b6fcf903afe872 0 1682603944126 9 connected
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 172.30.0.102:6379@16379 myself,master 
- 0 1682603944000 2 connected 5461-10922
b3c0a96f6a206088ecea639147b6fcf903afe872 172.30.0.103:6379@16379 master - 0 
1682603945030 3 connected 10923-16383
2e5dc211288784ba55d554a377b87bfe2b5398db 172.30.0.105:6379@16379 master - 0 
1682603944025 10 connected 0-5460
3584840ac704c3ee016f3bdcca3f7ebe6f6e8e80 172.30.0.107:6379@16379 slave 
5f71983ad52cc7077ce8874ae1c4f9c23d9f502c 0 1682603945131 7 connected
85025819223f12615046c54d89f510e9cd0444a1 172.30.0.104:6379@16379 slave 
b3c0a96f6a206088ecea639147b6fcf903afe872 0 1682603944628 4 connected

可以使⽤ cluster failover 进⾏集群恢复. 也就是把 101 重新设定成 master. (登录到101上执⾏)

5. 故障处理流程

故障判定

集群中的所有节点, 都会周期性的使⽤⼼跳包进⾏通信.

  1. 节点 A 给 节点 B 发送 ping 包, B 就会给A返回⼀个 pong 包. ping 和 pong 除了 message type属性之外, 其他部分都是⼀样的. 这⾥包含了集群的配置信息(该节点的id, 该节点从属于哪个分⽚,是主节点还是从节点, 从属于谁, 持有哪些 slots 的位图...).
  2. 每个节点, 每秒钟, 都会给⼀些随机的节点发起 ping 包 , ⽽不是全发⼀遍. 这样设定是为了避免在节点很多的时候, ⼼跳包也⾮常多(⽐如有 9 个节点, 如果全发, 就是 9 * 8 有72组⼼跳了, ⽽且这是按照 N^2 这样的级别增⻓的).
  3. 当节点 A 给节点 B 发起 ping 包, B 不能如期回应的时候, 此时A就会尝试重置和 B 的 tcp 连接, 看能否连接成功. 如果仍然连接失败, A 就会把B设为 PFAIL 状态(相当于主观下线).
  4. A 判定 B 为 PFAIL 之后, 会通过redis内置的 Gossip 协议, 和其他节点进⾏沟通, 向其他节点确认 B的状态. (每个节点都会维护⼀个⾃⼰的 "下线列表", 由于视⻆不同, 每个节点的下线列表也不⼀定相同).
  5. 此时 A 发现其他很多节点, 也认为 B 为 PFAIL, 并且数⽬超过总集群个数的⼀半, 那么 A 就会把 B 标记成 FAIL (相当于客观下线), 并且把这个消息同步给其他节点(其他节点收到之后, 也会把 B 标记成FAIL).

⾄此, B 就彻底被判定为故障节点了.某个或者某些节点宕机, 有的时候会引起整个集群都宕机 (称为 fail 状态)

以下三种情况会出现集群宕机:

某个分⽚, 所有的主节点和从节点都挂了.

某个分⽚, 主节点挂了, 但是没有从节点.

超过半数的 master 节点都挂了.
🐳 说明:

如果master宕机了,但是后面还有slave来作为补充的话一般不会出现什么问题,但是如果突然一系列的master都宕机了,此时说明集群遇到了非常严重的问题,此时需要赶紧停下来,检查是什么问题。其恢复的核心原则就是保证每个slots都能正常工作(存取数据).

故障迁移

上述例⼦中, B 故障, 并且 A 把 B FAIL 的消息告知集群中的其他节点.

  • 如果 B 是从节点, 那么不需要进⾏故障迁移.
  • 如果 B 是主节点, 那么就会由 B 的从节点 (⽐如 C 和 D) 触发故障迁移了

所谓故障迁移, 就是指把从节点提拔成主节点, 继续给整个 redis 集群提供⽀持.

具体流程如下:

  1. 从节点判定⾃⼰是否具有参选资格. 如果从节点和主节点已经太久没通信(此时认为从节点的数据和主节点差异太⼤了), 时间超过阈值, 就失去竞选资格.
  2. 具有资格的节点, ⽐如 C 和 D, 就会先休眠⼀定时间. 休眠时间 = 500ms 基础时间 + [0, 500ms] 随机时间 + 排名 * 1000ms. offset 的值越⼤, 则排名越靠前(越⼩).
  3. ⽐如 C 的休眠时间到了, C 就会给其他所有集群中的节点, 进⾏拉票操作. 但是只有主节点才有投票资格.
  4. 主节点就会把⾃⼰的票投给C(每个主节点只有1票). 当 C 收到的票数超过主节点数⽬的⼀半, C 就会晋升成主节点. (C ⾃⼰负责执⾏ slaveof no one, 并且让D执⾏ slaveof C).
  5. 同时, C 还会把⾃⼰成为主节点的消息, 同步给其他集群的节点. ⼤家也都会更新⾃⼰保存的集群结构信息.

🏅 上述选举的过程, 称为 Raft 算法, 是⼀种在分布式系统中⼴泛使⽤的算法.在随机休眠时间的加持下, 基本上就是谁先唤醒, 谁就能竞选成功.

6. 集群扩容

扩容是⼀个在开发中⽐较常遇到的场景.

随着业务的发展, 现有集群很可能⽆法容纳⽇益增⻓的数据. 此时给集群中加⼊更多新的机器, 就可以使存储的空间更⼤了.

🐦 所谓分布式的本质, 就是使⽤更多的机器, 引⼊更多的硬件资源.

① 往集群中加入新的主节点

前面我们创建了两个额外的redis10和redis11,将两者加入集群中,此处将redis10作为master,redis11作为slave.

bash 复制代码
redis-cli --cluster add-node 172.30.0.110:6379 172.30.0.101:6379

⭐add-node后的第⼀组地址是新节点的地址. 第⼆组地址是集群中的任意节点地址

添加新节点结果如下:

bash 复制代码
>>> Adding node 172.30.0.110:6379 to cluster 172.30.0.101:6379
>>> Performing Cluster Check (using node 172.30.0.101:6379)
M: 00d319e23ef76a4d51e74600c42ee2a371ae81f6 172.30.0.101:6379
slots:[0-5460] (5461 slots) master
2 additional replica(s)
S: e34911c57d7605903de84ec05b3deac611aaef7e 172.30.0.105:6379
slots: (0 slots) slave
...

此时的集群状态如下, 可以看到 172.30.0.110 这个节点已经成为了集群中的主节点.

bash 复制代码
127.0.0.1:6379> CLUSTER NODES
b3f2ba758318f4bd54031c98c01d7a6155ff43d3 172.30.0.102:6379@16379 master - 0 
1683183720184 2 connected 5461-10922
e34911c57d7605903de84ec05b3deac611aaef7e 172.30.0.105:6379@16379 slave 
00d319e23ef76a4d51e74600c42ee2a371ae81f6 0 1683183722189 5 connected
522a1bd88a1a9084e6919fa88f4bf1c3655ad837 172.30.0.110:6379@16379 master - 0 
1683183720000 10 connected
...

② 重新分配slots

bash 复制代码
redis-cli --cluster reshard 172.30.0.101:6379

☀️ reshard 后的地址是集群中的任意节点地址.另外, 注意单词拼写, 是 reshard (重新切分), 不是reshared(重新分享) , 不要多写个 e.

执⾏之后, 会进⼊交互式操作, redis 会提⽰⽤⼾输⼊以下内容:

• 多少个 slots 要进⾏reshard? (此处我们填写 4096) - 搬多少槽位

• 哪个节点来接收这些 slots ? (此处我们填写 172.30.0.110 这个节点的集群节点 id) - 搬运到哪里

• 这些 slots 从哪些节点搬运过来? (此处我们填写 all, 表⽰从其他所有的节点都进⾏搬运) - 从哪里搬运

结果如下:

bash 复制代码
How many slots do you want to move (from 1 to 16384)? 4096
What is the receiving node ID? 522a1bd88a1a9084e6919fa88f4bf1c3655ad837
Please enter all the source node IDs.
Type 'all' to use all the nodes as source nodes for the hash slots.
Type 'done' once you entered all the source nodes IDs.
Source node #1: all

此处的all可以替换成为手动指定,从某一个或者某几个节点来移动slots(以done为结尾)

确定之后,会初步打印出搬运⽅案, 让⽤⼾确认.

之后就会进⾏集群的 key 搬运⼯作. 这个过程涉及到数据搬运. 可能需要消耗⼀定的时间.

❗️ 提醒

在搬运key的过程中, 对于那些不需要搬运的 key, 访问的时候是没有任何问题的. 但是对于需要搬运的key, 进⾏访问可能会出现短暂的访问错误 (key 的位置出现了变化).随着搬运完成, 这样的错误⾃然就恢复了.

因此,想要追求更高的可用性,让扩容对于用户影响更小,就需要高一组新机器,重新搭建集群,并且把数据导入进来,使用新集群替代旧集群(成本是最高的)。

③ 给新master添加slave节点

为了保证主节点宕机了,有从节点能够顶上去,此时就需要给主节点配从节点。

bash 复制代码
#  172.30.0.111:6379 172.30.0.101:6379 表示集群
# [172.30.1.110 节点的 nodeId] 表示成为哪个主节点的从节点
redis-cli --cluster add-node 172.30.0.111:6379 172.30.0.101:6379 --cluster-slave --cluster-master-id [172.30.1.110 节点的 nodeId]
7. 总结

到这里,Redis Cluster 的核心内容就梳理完了。回顾一下整条主线:

  • 为什么需要集群 :单机 Redis 受限于内存、CPU 和网络带宽,数据量一大就撑不住,集群通过多组机器分片存储来解决容量与性能瓶颈。
  • 数据怎么分片 :业界主流有三种思路------哈希求余(简单但扩容搬运成本高)、一致性哈希(降低搬运量但存在数据倾斜)、哈希槽分区(Redis 采用,把前两者结合,兼顾均匀与扩容效率)。
  • 集群怎么搭 :基于 docker 为每个节点准备独立配置(关键是 cluster-announce-ip),用 docker compose 拉起容器,再用 redis-cli --cluster create 一次性构建集群,--cluster-replicas 指定每个主节点的从节点数量。
  • 故障怎么处理 :节点间通过心跳包通信,先由单个节点判定 PFAIL(主观下线),再经 Gossip 协议汇总超过半数节点意见后标记 FAIL(客观下线);主节点故障时由从节点基于 Raft 算法选举晋升,完成故障迁移。
  • 容量怎么扩 :add-node 加入新节点 → reshard 重新分配槽位 → 给新主节点挂从节点,三步完成扩容。

一句话概括:Redis Cluster 用 16384 个哈希槽把数据均匀打散到多个主节点上,用主从复制保证高可用,用 Gossip + Raft 实现自动故障发现与迁移。

8. 经典面试题

以下问题覆盖了集群分片、搭建、故障处理、扩容等高频考点,建议结合前面的实验过程理解记忆。

Q1:Redis Cluster 是如何实现数据分片的?为什么是 16384 个槽?

Redis Cluster 采用哈希槽(hash slots)分区算法,把整个键空间划分为 16384 个槽,每个主节点负责其中一部分槽位。写入时先对 key 做 CRC16 校验再对 16384 取模,得到槽位号,从而定位到对应节点。

之所以是 16384(16k)而不是更多,主要有两点考虑:

  1. 节点间心跳包需要携带自己持有的槽位信息,用位图表示,16384 个槽只需 2KB;若用 65536 个槽则需要 8KB,在频繁的网络心跳中是不小的开销。
  2. Redis 作者建议集群分片数不超过 1000,16k 个槽对最大 1000 个分片来说完全够用,同时位图体积也不至于过大。

Q2:一致性哈希和哈希槽分区有什么区别?

  • 一致性哈希:把节点和数据都映射到一个哈希环上,数据顺时针找到第一个节点。扩容时只需在环上新增节点,只影响相邻区间的数据,大幅降低搬运量;但节点少时容易出现数据倾斜。
  • 哈希槽分区:本质是一致性哈希与哈希求余的结合。槽位与节点解耦,槽可以灵活迁移,既保证了扩容时只搬运部分槽(而非全量重算),又通过槽的均匀分配缓解了数据倾斜问题。

Q3:集群搭建时 cluster-announce-ip 为什么必须配置?

在 docker 等容器环境下,Redis 默认会用容器内部 IP 向集群其他节点宣告自己,但容器 IP 对外部或其他容器可能不可达,导致节点互相找不到。cluster-announce-ip 显式指定该节点对外宣告的 IP,保证集群内各节点能正确通信。同理还有 cluster-announce-port(业务端口)和 cluster-announce-bus-port(集群总线端口,默认 16379)。

Q4:PFAIL 和 FAIL 有什么区别?

  • PFAIL(主观下线) :单个节点 A 给 B 发 ping 无响应,重连 tcp 仍失败后,A 单方面认为 B 下线,这是局部视角的判断。
  • FAIL(客观下线) :A 通过 Gossip 协议与其他节点沟通,当超过半数节点都认为 B 为 PFAIL 时,A 才把 B 标记为 FAIL 并同步给全集群。这是集群层面的共识判定,避免因网络抖动误判。

Q5:什么情况下整个集群会进入 fail 状态(不可用)?

以下三种情况会导致集群宕机:

  1. 某个分片的所有主节点和从节点全部挂掉;
  2. 某个分片的主节点挂了,且该分片没有从节点;
  3. 超过半数的 master 节点都挂了。

核心原则是:必须保证每个槽位都能正常工作,一旦有槽位无人负责,集群就无法对外提供服务。

Q6:主节点宕机后,从节点是如何晋升为主节点的?

这个过程基于 Raft 选举算法:

  1. 从节点先判断自己是否有参选资格------若与主节点失联时间超过阈值,认为数据差异过大,则失去资格;
  2. 有资格的从节点进入休眠,休眠时间 = 500ms 基础时间 + [0, 500ms] 随机时间 + 排名 × 1000ms,offset 越大排名越靠前、休眠越短;
  3. 先醒来的节点向所有主节点拉票,只有主节点有投票权,每个主节点一票;
  4. 得票超过主节点总数一半即晋升为主节点,执行 slaveof no one,并让其他从节点 slaveof 自己;
  5. 新主节点把结果同步给全集群,各节点更新集群结构信息。

随机休眠时间的设计,使得正常情况下基本是数据最新的节点先唤醒、先当选,避免选票分散。

Q7:集群扩容的完整步骤是什么?扩容过程中会有什么影响?

扩容分三步:

  1. 加入新节点 :redis-cli --cluster add-node 新节点IP:端口 集群任意节点IP:端口,新节点以主节点身份加入,但此时不持有任何槽位;
  2. 重新分配槽位 :redis-cli --cluster reshard 集群任意节点IP:端口,交互式输入要迁移的槽数量、接收节点 ID、来源节点(可填 all),Redis 会打印迁移方案并执行 key 搬运;
  3. 给新主节点挂从节点 :redis-cli --cluster add-node 从节点IP:端口 集群任意节点IP:端口 --cluster-slave --cluster-master-id 主节点ID,保证新主节点也有备份。

扩容过程中,不需要搬运的 key 访问不受影响;正在搬运的 key 可能出现短暂的访问错误(key 位置发生变化),搬运完成后自动恢复。若想进一步降低对用户的影响,可以采用「新搭一套集群 + 数据导入 + 切换」的方式,但成本最高。

Q8:客户端连接集群时为什么要加 -c 参数?

不加 -c 时,客户端连上某个节点后,如果操作的 key 不属于该节点负责的槽位,会直接报 MOVED 重定向错误。加上 -c 后,客户端会根据 key 计算出的槽位号自动重定向到正确的节点,对使用者透明。生产环境的集群客户端(如 Jedis、Lettuce)内部都实现了槽位缓存与重定向逻辑,原理与此一致。

相关推荐
老师我太想进步了20262 小时前
【数据结构-8】栈的实现
c语言·数据结构·算法
纆兰3 小时前
MySQL的多表查询
数据库·mysql
七夜zippoe3 小时前
Nexent 模型配置:4 字段与 9 个槽位
数据库·人工智能·模型·nexent
kyle~3 小时前
因子图优化(Factor Graph Optimization)
c++·算法·机器人·传感器
进击的荆棘3 小时前
MySQL——表的操作
数据库·mysql
Pniubi4 小时前
贪心算法入门
算法·贪心算法
MobotStone5 小时前
AI 能不能越用越会用?从“改答案”到“改进自己”,读懂 RSI
人工智能·算法
复杂网络与机器学习5 小时前
Meta 重写 K-Means:25 轮压成 2 轮,GPU 快 45 倍
人工智能·算法·数据挖掘
nice_lcj5205 小时前
MySQL 慢查询与 EXPLAIN:怎么定位、怎么优化
java·数据库·后端·mysql