← 返回首页 📚 实战课程
📑 本篇章节导航 (共6章,点击直达)
本节目标(学完能回答的面试题)核心知识实战代码面试模拟实操练习本节小结

P2-01 - Redis集群架构实战

本节目标(学完能回答的面试题)

1. Redis主从复制、哨兵模式、Cluster模式分别解决什么问题?生产环境怎么选?

2. 哨兵模式的故障转移流程是什么?几个哨兵才能完成故障转移?

3. Cluster模式的槽位分配机制是什么?为什么是16384个槽?

4. Cluster模式下节点之间如何通信?Gossip协议的优缺点?

5. 生产环境Redis集群如何做容量规划和监控?

核心知识

一、Redis高可用架构演进路线


单机 → 主从复制 → 哨兵模式 → Cluster模式
  |        |           |           |
容量    读分离+备份   自动故障转移  水平扩展+高可用

三种架构对比表:

维度主从复制哨兵模式Cluster模式
高可用无自动故障转移自动故障转移自动故障转移
扩展性读扩展读扩展读写扩展
数据分片不支持不支持支持
运维复杂度低中高
客户端支持普通需 sentinel 地址需 Smart Client
适用场景读多写少中小规模大规模

二、主从复制深度解析

2.1 全量复制流程


Slave发起: PSYNC ? -1  (第一次复制,没有runid和offset)
Master返回: +FULLRESYNC <runid> <offset>
Master执行: BGSAVE 生成RDB
Master发送: RDB文件给Slave
Master缓冲: repl_backlog积压后续写命令
Slave执行: 清空旧数据,加载RDB
Master发送: 积压的写命令

2.2 部分复制(断线重连)


Slave发起: PSYNC <runid> <offset>
Master判断: offset在repl_backlog范围内?
  → 是: +CONTINUE,发送差异数据
  → 否: +FULLRESYNC,触发全量复制

关键参数配置:


# Master节点配置
repl-diskless-sync yes          # 无盘复制,直接通过网络发送RDB
repl-diskless-sync-delay 5      # 等待更多slave一起复制
repl-backlog-size 256mb         # 复制积压缓冲区大小
repl-timeout 60                 # 复制超时时间

# Slave节点配置
replica-serve-stale-data yes    # 主节点断开后是否继续响应请求
replica-read-only yes           # 从节点只读
masterauth <password>           # 主节点密码

2.3 主从复制延迟问题


主节点写入 → 异步复制到从节点 → 从节点有延迟

可能导致的问题:
- 主节点宕机,从节点未同步的数据丢失
- 读写分离时,从节点读到旧数据

三、哨兵模式(Sentinel)

3.1 哨兵架构


                  ┌──────────┐
                  │ Sentinel1│
                  └────┬─────┘
                       │
┌──────────┐    ┌──────┴─────┐    ┌──────────┐
│ Sentinel2│────│  Master    │────│ Sentinel3│
└──────────┘    └──────┬─────┘    └──────────┘
                   ┌───┴───┐
              ┌────┴──┐ ┌──┴────┐
              │Slave1 │ │Slave2 │
              └───────┘ └───────┘

3.2 故障检测与转移流程

步骤1:主观下线(SDOWN)


Sentinel每秒向Master发送PING
超过 is-master-down-after-milliseconds 未响应
→ Sentinel标记Master为 SDOWN(主观下线)

步骤2:客观下线(ODOWN)


Sentinel通过 SENTINEL is-master-down-by-addr 询问其他Sentinel
超过 quorum 数量的Sentinel确认
→ 标记为 ODOWN(客观下线)

步骤3:领导者选举


基于Raft算法选举领头Sentinel
每个Sentinel只有一个投票权
先到先得,多数派确认

步骤4:故障转移


1. 领头Sentinel从Slave中选出新Master
   选择条件:
   - 排除断线的Slave
   - replica-priority 最小的优先
   - 复制偏移量最大的优先(数据最新)
   - runid 最小的优先

2. 对选中的Slave执行 SLAVEOF NO ONE

3. 向其他Slave发送 SLAVEOF <new_master>

4. 更新 Sentinel 配置中的 Master 信息

5. 监控旧Master,若恢复则设为新Master的Slave

3.3 哨兵配置实战


# sentinel.conf(每个Sentinel节点一份)
port 26379
sentinel monitor mymaster 192.168.1.100 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 10000
sentinel parallel-syncs mymaster 1
sentinel auth-pass mymaster your_password

参数解释:

3.4 Spring Boot连接Sentinel


# application.yml
spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.1.100:26379
        - 192.168.1.101:26379
        - 192.168.1.102:26379
    password: your_password
    lettuce:
      pool:
        max-active: 20
        max-idle: 10
        min-idle: 5

四、Cluster模式深度实战

4.1 为什么是16384个槽?


CRC16(key) % 16384 = slot号

为什么不是65536?
1. 节点间Gossip心跳包携带的bitmap,16384个槽只需2KB
   65536个槽需要8KB,集群节点多时带宽开销大
2. 16384个槽对于1000个节点的集群已足够
   每个节点平均管理16个槽,分布均匀

4.2 手动搭建3主3从Cluster

Step 1:准备6个节点配置


# 创建目录
mkdir -p /opt/redis-cluster/{7000,7001,7002,7003,7004,7005}

节点7000配置(redis-7000.conf):


port 7000
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 5000
appendonly yes
daemonize yes
dir /opt/redis-cluster/7000
logfile /opt/redis-cluster/7000/redis.log
requirepass your_password
masterauth your_password

其余节点7001-7005同理,只改port和目录。

Step 2:启动所有节点


for port in 7000 7001 7002 7003 7004 7005; do
  redis-server /opt/redis-cluster/${port}/redis-${port}.conf
done

Step 3:创建集群


redis-cli --cluster create \
  192.168.1.100:7000 192.168.1.100:7001 \
  192.168.1.101:7002 192.168.1.101:7003 \
  192.168.1.102:7004 192.168.1.102:7005 \
  --cluster-replicas 1 \
  -a your_password

输出示例:


>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.1.101:7003 to 192.168.1.100:7000
Adding replica 192.168.1.102:7005 to 192.168.1.101:7002
Adding replica 192.168.1.100:7001 to 192.168.1.102:7004

Step 4:验证集群状态


# 查看集群信息
redis-cli -p 7000 -a your_password cluster info

# 查看节点信息
redis-cli -p 7000 -a your_password cluster nodes

# 检查槽位分配
redis-cli -p 7000 -a your_password --cluster check 192.168.1.100:7000

4.3 槽位操作


# 查看key属于哪个槽
redis-cli -p 7000 -a your_password cluster keyslot "user:1001"
# 输出:12539

# 手动迁移槽位(从7000迁移到7002)
redis-cli -p 7000 -a your_password \
  --cluster reshard 192.168.1.100:7000 \
  --cluster-from <node-id-7000> \
  --cluster-to <node-id-7002> \
  --cluster-slots 1000 \
  --cluster-yes

# 添加新节点
redis-cli -p 7000 -a your_password \
  --cluster add-node 192.168.1.103:7006 192.168.1.100:7000

# 添加新从节点
redis-cli -p 7000 -a your_password \
  --cluster add-node 192.168.1.103:7007 192.168.1.100:7000 \
  --cluster-slave --cluster-master-id <master-node-id>

4.4 Gossip协议通信


节点间每秒随机选择一个节点发送PING
携带自己的信息和部分其他节点的状态

消息类型:
- PING:心跳检测
- PONG:响应PING
- MEET:加入集群
- FAIL:标记节点下线

优点:去中心化,无需全部通信
缺点:状态传播有延迟,可能短暂不一致

4.5 客户端路由


客户端发送命令 → 计算slot → 找到目标节点
  → 目标节点处理 → 返回结果

如果key不在当前节点:
  → 返回 MOVED <slot> <ip:port>
  → Smart Client自动重定向

如果正在迁移槽位:
  → 返回 ASK <slot> <ip:port>
  → 客户端只对本次请求重定向

Spring Boot连接Cluster:


spring:
  redis:
    cluster:
      nodes:
        - 192.168.1.100:7000
        - 192.168.1.100:7001
        - 192.168.1.101:7002
        - 192.168.1.101:7003
        - 192.168.1.102:7004
        - 192.168.1.102:7005
      max-redirects: 3
    password: your_password
    lettuce:
      pool:
        max-active: 20
        max-idle: 10

4.6 生产环境配置清单


# redis.conf 生产配置要点
bind 0.0.0.0
protected-mode yes
port 6379
tcp-backlog 511
timeout 300
tcp-keepalive 60
daemonize yes
supervised no

# 持久化
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 内存管理
maxmemory 4gb
maxmemory-policy allkeys-lru

# 慢查询
slowlog-log-slower-than 10000
slowlog-max-len 128

# 集群
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-require-full-coverage no    # 部分槽不可用时仍可服务

# 安全
requirepass <strong-password>
masterauth <strong-password>
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG ""

实战代码

Spring Boot + Redis Cluster 配置类


@Configuration
public class RedisClusterConfig {

    @Value("${spring.redis.cluster.nodes}")
    private String clusterNodes;

    @Value("${spring.redis.password}")
    private String password;

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        // 解析集群节点
        String[] nodes = clusterNodes.split(",");
        List<RedisNode> redisNodes = new ArrayList<>();
        for (String node : nodes) {
            String[] parts = node.trim().split(":");
            redisNodes.add(new RedisNode(parts[0], Integer.parseInt(parts[1])));
        }

        // 集群拓扑刷新配置
        ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
            .enablePeriodicRefresh(Duration.ofSeconds(30))   // 定期刷新
            .enableAllAdaptiveRefreshTriggers()               // 自适应刷新
            .adaptiveRefreshTriggersTimeout(Duration.ofSeconds(30))
            .build();

        // 客户端配置
        ClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(3))
            .shutdownTimeout(Duration.ofMillis(200))
            .clientOptions(ClusterClientOptions.builder()
                .topologyRefreshOptions(topologyRefreshOptions)
                .maxRedirects(3)
                .build())
            .build();

        // 集群配置
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration();
        clusterConfig.setPassword(password);
        for (RedisNode node : redisNodes) {
            clusterConfig.addClusterNode(node);
        }

        return new LettuceConnectionFactory(clusterConfig, clientConfig);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}

集群健康检查工具类


@Component
@Slf4j
public class RedisClusterHealthChecker {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 检查集群状态
     */
    public ClusterHealthReport checkClusterHealth() {
        ClusterHealthReport report = new ClusterHealthReport();
        report.setCheckTime(LocalDateTime.now());

        try {
            Properties info = redisTemplate.execute((RedisCallback<Properties>) conn -> {
                return conn.info("cluster");
            });

            String clusterState = info.getProperty("cluster_state");
            String clusterSlotsOk = info.getProperty("cluster_slots_ok");
            String clusterSlotsAssigned = info.getProperty("cluster_slots_assigned");
            String clusterKnownNodes = info.getProperty("cluster_known_nodes");

            report.setClusterState(clusterState);
            report.setSlotsOk(Integer.parseInt(clusterSlotsOk));
            report.setSlotsAssigned(Integer.parseInt(clusterSlotsAssigned));
            report.setKnownNodes(Integer.parseInt(clusterKnownNodes));

            if (!"ok".equals(clusterState)) {
                log.error("Redis集群状态异常: {}", clusterState);
                // 发送告警...
            }

        } catch (Exception e) {
            log.error("Redis集群健康检查失败", e);
            report.setError(e.getMessage());
        }

        return report;
    }

    @Data
    public static class ClusterHealthReport {
        private LocalDateTime checkTime;
        private String clusterState;
        private int slotsOk;
        private int slotsAssigned;
        private int knownNodes;
        private String error;
    }
}

面试模拟

Q1:Sentinel和Cluster怎么选?

答:

Sentinel适合数据量不大(单机内存能承载)、主要需求是高可用的场景。Cluster适合数据量大、需要水平扩展的场景。Cluster本身就包含了故障转移能力,不需要额外部署Sentinel。但Cluster不支持多key操作(mget、mset等跨槽操作需要hash tag),如果业务强依赖多key操作,Sentinel可能更合适。

Q2:Cluster的故障转移流程?

答:

1. 集群内节点通过Gossip协议互相检测,发现某Master不可达

2. 超过cluster-node-timeout后,将该Master标记为PFAIL(疑似下线)

3. 超过半数Master确认后,标记为FAIL

4. 该Master的Slave发起选举,基于Raft协议

5. 选举成功后,新Master执行 SLAVEOF NO ONE

6. 通知其他节点更新路由信息

7. 如果旧Master恢复,变为新Master的Slave

Q3:Redis集群数据一致性如何保证?

答:

Redis集群采用异步复制,不保证强一致性:

Q4:集群扩容时数据如何迁移?

答:

1. 启动新节点并加入集群(MEET)

2. 使用 --cluster reshard 迁移指定数量的槽位

3. 迁移过程中,源节点逐个迁移key,同时用 ASK 重定向客户端

4. 迁移完成后更新集群的槽位映射表

5. 生产环境建议在低峰期操作,每次迁移少量槽位,观察集群负载

Q5:为什么Cluster不支持多key事务?

答:

因为不同的key可能分布在不同节点上,分布式事务需要两阶段提交,Redis没有实现这个机制。解决方案是使用hash tag:用 {} 包裹key中相同的部分,如 user:{1001}:name 和 user:{1001}:age,这样同一用户的属性会落在同一个槽。但hash tag可能导致数据倾斜,需要权衡使用。

实操练习

练习1:搭建本地3主3从集群


# 1. 创建6个配置文件(端口7000-7005)
# 2. 启动6个Redis实例
# 3. 使用redis-cli创建集群
# 4. 验证:写入数据,杀掉一个Master,观察故障转移
# 5. 恢复被杀的节点,观察它变成Slave

练习2:Spring Boot接入集群


# 1. 配置spring.redis.cluster.nodes
# 2. 编写一个Controller,实现 get/set/delete 接口
# 3. 使用 JMeter 压测,同时杀掉一个节点,验证服务不中断
# 4. 观察日志中的 MOVED/ASK 重定向

练习3:容量规划


# 场景:电商系统,日活100万用户
# - 用户Session:key=user:session:{uid},value约500B,TTL 30min
# - 商品缓存:key=product:{pid},value约2KB,TTL 1h
# - 热点排行榜:key=rank:daily,ZSet约1万member
#
# 问题:
# 1. 计算总内存需求
# 2. 设计集群节点数量
# 3. 预估QPS,验证网络带宽是否够用

本节小结

知识点关键词
主从复制PSYNC、repl_backlog、全量/部分复制
哨兵模式SDOWN/ODOWN、Raft选举、故障转移
Cluster模式16384槽、Gossip、MOVED/ASK、hash tag
生产配置maxmemory、cluster-require-full-coverage、慢查询