1. Redis主从复制、哨兵模式、Cluster模式分别解决什么问题?生产环境怎么选?
2. 哨兵模式的故障转移流程是什么?几个哨兵才能完成故障转移?
3. Cluster模式的槽位分配机制是什么?为什么是16384个槽?
4. Cluster模式下节点之间如何通信?Gossip协议的优缺点?
5. 生产环境Redis集群如何做容量规划和监控?
单机 → 主从复制 → 哨兵模式 → Cluster模式
| | | |
容量 读分离+备份 自动故障转移 水平扩展+高可用
三种架构对比表:
| 维度 | 主从复制 | 哨兵模式 | Cluster模式 |
|---|---|---|---|
| 高可用 | 无自动故障转移 | 自动故障转移 | 自动故障转移 |
| 扩展性 | 读扩展 | 读扩展 | 读写扩展 |
| 数据分片 | 不支持 | 不支持 | 支持 |
| 运维复杂度 | 低 | 中 | 高 |
| 客户端支持 | 普通 | 需 sentinel 地址 | 需 Smart Client |
| 适用场景 | 读多写少 | 中小规模 | 大规模 |
Slave发起: PSYNC ? -1 (第一次复制,没有runid和offset)
Master返回: +FULLRESYNC <runid> <offset>
Master执行: BGSAVE 生成RDB
Master发送: RDB文件给Slave
Master缓冲: repl_backlog积压后续写命令
Slave执行: 清空旧数据,加载RDB
Master发送: 积压的写命令
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> # 主节点密码
主节点写入 → 异步复制到从节点 → 从节点有延迟
可能导致的问题:
- 主节点宕机,从节点未同步的数据丢失
- 读写分离时,从节点读到旧数据
┌──────────┐
│ Sentinel1│
└────┬─────┘
│
┌──────────┐ ┌──────┴─────┐ ┌──────────┐
│ Sentinel2│────│ Master │────│ Sentinel3│
└──────────┘ └──────┬─────┘ └──────────┘
┌───┴───┐
┌────┴──┐ ┌──┴────┐
│Slave1 │ │Slave2 │
└───────┘ └───────┘
步骤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
# 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
参数解释:
quorum=2:至少2个Sentinel同意才判定客观下线parallel-syncs=1:故障转移时同时向新Master发起复制的Slave数量
# 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
CRC16(key) % 16384 = slot号
为什么不是65536?
1. 节点间Gossip心跳包携带的bitmap,16384个槽只需2KB
65536个槽需要8KB,集群节点多时带宽开销大
2. 16384个槽对于1000个节点的集群已足够
每个节点平均管理16个槽,分布均匀
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
# 查看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>
节点间每秒随机选择一个节点发送PING
携带自己的信息和部分其他节点的状态
消息类型:
- PING:心跳检测
- PONG:响应PING
- MEET:加入集群
- FAIL:标记节点下线
优点:去中心化,无需全部通信
缺点:状态传播有延迟,可能短暂不一致
客户端发送命令 → 计算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
# 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 ""
@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;
}
}
答:
Sentinel适合数据量不大(单机内存能承载)、主要需求是高可用的场景。Cluster适合数据量大、需要水平扩展的场景。Cluster本身就包含了故障转移能力,不需要额外部署Sentinel。但Cluster不支持多key操作(mget、mset等跨槽操作需要hash tag),如果业务强依赖多key操作,Sentinel可能更合适。
答:
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
答:
Redis集群采用异步复制,不保证强一致性:
wait 命令等待N个Slave确认,但会降低性能答:
1. 启动新节点并加入集群(MEET)
2. 使用 --cluster reshard 迁移指定数量的槽位
3. 迁移过程中,源节点逐个迁移key,同时用 ASK 重定向客户端
4. 迁移完成后更新集群的槽位映射表
5. 生产环境建议在低峰期操作,每次迁移少量槽位,观察集群负载
答:
因为不同的key可能分布在不同节点上,分布式事务需要两阶段提交,Redis没有实现这个机制。解决方案是使用hash tag:用 {} 包裹key中相同的部分,如 user:{1001}:name 和 user:{1001}:age,这样同一用户的属性会落在同一个槽。但hash tag可能导致数据倾斜,需要权衡使用。
# 1. 创建6个配置文件(端口7000-7005)
# 2. 启动6个Redis实例
# 3. 使用redis-cli创建集群
# 4. 验证:写入数据,杀掉一个Master,观察故障转移
# 5. 恢复被杀的节点,观察它变成Slave
# 1. 配置spring.redis.cluster.nodes
# 2. 编写一个Controller,实现 get/set/delete 接口
# 3. 使用 JMeter 压测,同时杀掉一个节点,验证服务不中断
# 4. 观察日志中的 MOVED/ASK 重定向
# 场景:电商系统,日活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、慢查询 |