1. 项目背景
1.1 事故回放
凌晨两点十七分,运维老李被急促的告警电话吵醒。商品详情、购物车、排行榜三个核心接口大面积超时,线上订单量骤降。排查后发现——Redis 主库因为宿主机的内存故障宕机了。上一章搭建的一主两从虽然有两个从库在,但没有任何自动机制把它们中的一个提升为新主库。
老李赶紧手动操作:登录从库执行 REPLICAOF NO ONE 将其提升为主库、修改另一个从库的复制目标、通知 15 个依赖服务的负责人修改 Redis 连接地址。整个过程花了 12 分钟——这 12 分钟内,所有依赖 Redis 的服务都在降级运行,部分用户购物车为空、商品价格显示异常、排行榜不更新。
这就是没有 Sentinel 的主从架构的致命缺陷——故障转移靠人手。Sentinel 就是让这个过程自动化的"哨兵系统"。
1.2 Sentinel 能做什么、不能做什么
| 能力 | 说明 |
|---|---|
| 监控 | 持续检查主从节点是否存活 |
| 通知 | 节点故障时通过 Pub/Sub 通知 |
| 自动故障转移 | 主库客观下线 → 选新主 → 让其他从库复制新主 |
| 配置提供者 | 客户端通过 Sentinel 查询当前主库地址 |
| 不能做的 | 不做数据分片、不消除异步复制的数据丢失 |
1.3 本章目标
- 搭建三节点 Sentinel + 一主两从的完整高可用架构。
- 理解主观下线(SDOWN) → 客观下线(ODOWN) → Leader 选举 → 故障转移的完整流程。
- 模拟主库宕机,观察自动切主和客户端重连。
- 分析脑裂风险和数据丢失窗口。
2. 项目设计
2.1 第一幕:判断"店长真死了"需要几个人同意?
小胖:"有了 Sentinel,是不是主库挂了就像外卖店自动换店长,不用人工管了?"
小白:"谁来判定'店长真的死了'?如果一个 Sentinel 和主库之间网络断了(但主库没死),这个 Sentinel 就自己决定切主吗?万一两个 Sentinel 各自认为自己是 Leader,都切了一个新主——两个主库同时存在怎么办?"
大师:"这就是 Sentinel 为什么要区分主观下线和客观下线。单个 Sentinel 自己判断主库不可达叫 SDOWN(Subjective Down)。多个 Sentinel 达成共识后才叫 ODOWN(Objective Down)。只有 ODOWN 后才出发故障转移。而且 Sentinel 之间会选举出一个 Leader 负责执行故障转移——谁都来切就乱套了。"
Sentinel 故障转移全流程:
Step 1: 单个 Sentinel 发现主库不可达
→ PING 超时 > down-after-milliseconds
→ 标记主库为 SDOWN (主观下线)
Step 2: 询问其他 Sentinel
→ SENTINEL is-master-down-by-addr
→ 收集其他 Sentinel 的判断
Step 3: 达成共识
→ 同意主库下线的 Sentinel 数量 >= quorum
→ 标记主库为 ODOWN (客观下线)
Step 4: Leader 选举
→ Sentinel 之间投票选出 Leader
→ Leader 负责执行故障转移
Step 5: 选新主
→ Leader 从健康的从库中选择优先级最高的
→ SLAVEOF NO ONE 提升为新主
Step 6: 重新配置
→ 其他从库 SLAVEOF 新主
→ 旧主恢复后自动成为新主的从库
→ 通知订阅者新主地址
技术映射:quorum 决定客观下线需要的 Sentinel 同意数,down-after-milliseconds 决定超时判定时间。这两个参数直接影响故障检测的灵敏度和准确度。
2.2 第二幕:为什么 Sentinel 要奇数个?
小胖:"为什么 Sentinel 要 3 个?2 个不也能互相商量吗?"
大师:"分布式系统最怕脑裂(Split-Brain)——网络分区导致两个子集群各自认为自己是合法的。奇数个节点更容易形成多数派。3 个 Sentinel 可以容忍 1 个故障(还有 2 个能形成多数);2 个 Sentinel 如果 1 个故障,只剩 1 个无法形成多数派——哨兵系统就瘫痪了。"
Sentinel 数量与容错能力:
1 个 Sentinel: 0 容错 (自己挂了就没了)
3 个 Sentinel: 容忍 1 个 Sentinel 故障 (2 个可形成多数)
5 个 Sentinel: 容忍 2 个 Sentinel 故障 (3 个可形成多数)
2 个 Sentinel: 0 容错 (1 个挂了另一个无法单独决策)
小白追问:"如果旧主其实没死,只是和 Sentinel 网络隔离了——它还在接受客户端的写入。新主也被提升了——两个主库同时存在,数据怎么办?"
大师:"这就是脑裂中最棘手的场景。Sentinel 不能消除这种风险,但可以降低:① 配置 min-replicas-to-write——旧主发现从库都不在了,拒绝写入;② 客户端在旧主上写入超时后查询 Sentinel 获取新主地址;③ 旧主恢复后被 Sentinel 强制降级为从库,它在隔离期间接受的写入可能丢失——这是异步复制的固有限制。关键数据的最终一致性仍要靠数据库。"
2.3 第三幕:客户端如何知道新主?
小胖:"故障转移后,新主地址变了——客户端怎么知道去连新主?"
大师:"客户端不应该写死 Redis 地址,而是向 Sentinel 查询。有两种模式:"
模式 A: 主动查询
客户端 → SENTINEL get-master-addr-by-name mymaster
Sentinel → 返回当前主库 IP:Port
缺点: 故障转移期间有时间窗口
模式 B: 订阅通知
客户端 → SUBSCRIBE +switch-master
故障转移完成后 Sentinel 发布: +switch-master mymaster old-ip old-port new-ip new-port
优点: 实时感知
缺点: 订阅连接也可能断
生产做法: 主动查询 + 订阅通知 + 写失败时重新查询 (三重保障)
技术映射:成熟的 Redis 客户端(Lettuce/Jedis)通常内置了 Sentinel 模式,自动处理主库发现、故障转移通知和拓扑刷新。但要确保配置了所有 Sentinel 地址,不能只配一个。
3. 项目实战
3.1 环境准备
# 创建网络
docker network create redis-ha-net
# 启动一主两从
docker run --name redis-master --network redis-ha-net -p 6379:6379 \
-d redis:8.6 redis-server --appendonly yes
docker run --name redis-replica1 --network redis-ha-net -p 6380:6379 \
-d redis:8.6 redis-server --appendonly yes --replicaof redis-master 6379
docker run --name redis-replica2 --network redis-ha-net -p 6381:6379 \
-d redis:8.6 redis-server --appendonly yes --replicaof redis-master 6379
3.2 实战一:配置三节点 Sentinel
创建 Sentinel 配置文件 sentinel1.conf:
port 26379
dir /data
sentinel monitor mymaster redis-master 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
sentinel resolve-hostnames no
参数说明:
sentinel monitor mymaster redis-master 6379 2→ 监控名为 mymaster 的主库,quorum=2(需 2 个 Sentinel 同意才客观下线)。down-after-milliseconds 5000→ 5 秒无响应判定主观下线。failover-timeout 60000→ 故障转移总超时 60 秒。parallel-syncs 1→ 故障转移后,同时只让 1 个从库同步新主(避免网络压力)。
# 复制并修改端口创建另外两个 Sentinel 配置
cp sentinel1.conf sentinel2.conf
cp sentinel1.conf sentinel3.conf
sed -i 's/26379/26380/' sentinel2.conf
sed -i 's/26379/26381/' sentinel3.conf
# 启动三个 Sentinel
docker run --name sentinel1 --network redis-ha-net -p 26379:26379 \
-v "$PWD/sentinel1.conf:/etc/redis/sentinel.conf" \
-d redis:8.6 redis-sentinel /etc/redis/sentinel.conf
docker run --name sentinel2 --network redis-ha-net -p 26380:26379 \
-v "$PWD/sentinel2.conf:/etc/redis/sentinel.conf" \
-d redis:8.6 redis-sentinel /etc/redis/sentinel.conf
docker run --name sentinel3 --network redis-ha-net -p 26381:26379 \
-v "$PWD/sentinel3.conf:/etc/redis/sentinel.conf" \
-d redis:8.6 redis-sentinel /etc/redis/sentinel.conf
3.3 实战二:查询 Sentinel 状态
# 查询当前主库
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
1) "redis-master"
2) "6379"
# 查询所有从库
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL replicas mymaster
# 查询所有 Sentinel
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL sentinels mymaster
# 查看主库详细信息
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL master mymaster
# 手动触发故障转移(测试用)
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL FAILOVER mymaster
3.4 实战三:模拟主库宕机
# 1. 写入测试数据
docker exec -it redis-master redis-cli SET failover:test "before-failover"
OK
# 2. 停止主库
docker stop redis-master
# 3. 等待约 10-20 秒(毫秒检测 + 故障转移时间)
sleep 15
# 4. 查询新主
docker exec -it sentinel1 redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
1) "redis-replica1" # 或 replica2,Sentinel 选了一个新主
2) "6379"
# 5. 在新主上验证数据和写入能力
docker exec -it redis-replica1 redis-cli
127.0.0.1:6379> GET failover:test
"before-failover"
127.0.0.1:6379> SET after:failover "success"
OK
127.0.0.1:6379> INFO replication | grep role
role:master
# 6. 旧主恢复——自动变为从库
docker start redis-master
sleep 5
docker exec -it redis-master redis-cli INFO replication | grep role
role:slave
3.5 实战四:Java 客户端 Sentinel 模式
@Configuration
public class SentinelRedisConfig {
@Bean
public RedisConnectionFactory redisConnectionFactory() {
// 配置 Sentinel 模式
RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
.master("mymaster")
.sentinel("sentinel1", 26379)
.sentinel("sentinel2", 26379) // 配多个!不能只配一个
.sentinel("sentinel3", 26379);
// 连接密码(如果设置了)
sentinelConfig.setPassword(RedisPassword.of("redis123"));
LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
.clientOptions(ClientOptions.builder()
.autoReconnect(true)
.disconnectedBehavior(DisconnectedBehavior.REJECT_COMMANDS)
.build())
.commandTimeout(Duration.ofSeconds(2))
.build();
return new LettuceConnectionFactory(sentinelConfig, clientConfig);
}
}
3.6 实战五:监控 Sentinel 健康
# Sentinel 状态监控命令
docker exec -it sentinel1 redis-cli -p 26379
# 查看 Sentinel 自己的信息
SENTINEL MASTER mymaster | grep -E "num-other-sentinels|num-slaves|flags"
# 手动检测主库
SENTINEL PING
PONG
# 测试主库故障判断
SENTINEL RESET mymaster # 重置 Sentinel 状态(慎用!)
# 查看 ckquorum
SENTINEL CKQUORUM mymaster
# OK 3 usable Sentinels. Quorum and failover authorization can be reached
3.7 实战六:Sentinel 配置优化与生产部署
完整的生产级 Sentinel 配置:
# sentinel.conf - 生产推荐配置
port 26379
dir /tmp
# 监控主库
sentinel monitor mymaster 10.0.1.10 6379 2
sentinel auth-pass mymaster redis123
# 故障检测
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
# 网络配置
sentinel resolve-hostnames no
# 日志
logfile /var/log/redis/sentinel.log
# 安全
requirepass sentinel123
生产部署要求:
| 要求 | 说明 |
|---|---|
| 至少 3 个 Sentinel | 奇数部署,多数派决策 |
| 不同物理机/机架 | 避免单点故障域 |
| 独立于 Redis 节点 | Sentinel 不和应用/Redis 共用机器 |
| 持久化开启 | Sentinel 自身状态也需持久化 |
3.8 实战七:客户端重连的完整流程
// 带 Sentinel 的健壮客户端配置
@Bean
public LettuceConnectionFactory lettuceConnectionFactory() {
RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
.master("mymaster")
.sentinel("sentinel1.internal", 26379)
.sentinel("sentinel2.internal", 26379)
.sentinel("sentinel3.internal", 26379);
sentinelConfig.setPassword("redis123");
// 哨兵认证密码(如果 Sentinel 设置了密码)
sentinelConfig.setSentinelPassword("sentinel123");
LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
.clientOptions(ClientOptions.builder()
.autoReconnect(true) // 关键!自动重连
.disconnectedBehavior(DisconnectedBehavior.REJECT_COMMANDS)
.socketOptions(SocketOptions.builder()
.connectTimeout(Duration.ofSeconds(2))
.keepAlive(true)
.build())
.build())
.commandTimeout(Duration.ofSeconds(2))
// 拓扑刷新:定期从 Sentinel 拉取最新拓扑
.useSsl()
.build();
LettuceConnectionFactory factory = new LettuceConnectionFactory(sentinelConfig, clientConfig);
// 关键!开启拓扑刷新
factory.setValidateConnection(true);
return factory;
}
3.9 实战八:故障转移全流程演练脚本
#!/bin/bash
# sentinel_failover_drill.sh
echo "=== 故障转移演练 ==="
echo "1. 记录当前主库"
OLD_MASTER=$(redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster)
echo "当前主库: $OLD_MASTER"
echo "2. 写入测试数据"
redis-cli -h $(echo $OLD_MASTER | cut -d' ' -f1) SET drill:test "$(date)"
echo "3. 停止主库"
docker stop redis-master
echo "主库已停止"
echo "4. 等待故障转移 (预计 10-20s)..."
sleep 20
echo "5. 查询新主库"
NEW_MASTER=$(redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster)
echo "新主库: $NEW_MASTER"
echo "6. 验证数据"
redis-cli -h $(echo $NEW_MASTER | cut -d' ' -f1) GET drill:test
redis-cli -h $(echo $NEW_MASTER | cut -d' ' -f1) SET drill:recovery "ok" && echo "写入测试: 通过"
echo "7. 恢复旧主"
docker start redis-master
sleep 5
OLD_ROLE=$(docker exec redis-master redis-cli INFO replication | grep role)
echo "旧主角色: $OLD_ROLE (预期: slave)"
echo "=== 演练完成 ==="
4.4 生产事故:网络抖动引发的频繁切换
某电商平台配置down-after-milliseconds 3000(3 秒超时),因网络偶发抖动,主库在 24 小时内被 Sentinel 判定"下线"了 5 次,触发了 3 次不必要的故障转移。每次切换都导致短暂不可写入和数据丢失窗口。教训:down-after-milliseconds 不能设太短——3000ms 对瞬时网络抖动太敏感,生产通常设为 5000-10000ms。
4.5 Sentinel 配置速查卡
| 配置 | 建议值 | 说明 |
|---|---|---|
down-after-milliseconds |
5000-10000 | 太短误判,太长响应慢 |
failover-timeout |
60000-180000 | 故障转移总超时 |
parallel-syncs |
1 | 控制同步并发 |
| Sentinel 数量 | ≥ 3 且奇数 | 分布在多物理机 |
sentinel auth-pass |
设置 | 如果主库有密码 |
4.6 Sentinel 和 Cluster 的协作与区别
| 维度 | Sentinel | Cluster |
|---|---|---|
| 目标 | 单分片高可用 | 多分片扩展+高可用 |
| 数据分布 | 所有节点存全量 | 按槽位分片 |
| 主节点数 | 1 个 | N 个(每个负责部分槽位) |
| 故障转移 | Sentinel 选举 Leader 执行 | 主节点间 Gossip 协议投票 |
| 客户端 | 查 Sentinel 获取主库地址 | 查槽位表路由 |
| 多 key 限制 | 无 | 同槽位限制 |
| 适用 | 数据量 < 单机内存 | 需要横向扩容 |
关键:Sentinel 和 Cluster 不是二选一——如果数据量适合单机但需要高可用,用 Sentinel;需要同时扩展容量和吞吐,用 Cluster(Cluster 内置了分片级故障转移)。
4. 项目总结
4.1 Sentinel 配置速查
| 配置 | 建议值 | 说明 |
|---|---|---|
sentinel monitor |
mymaster ip port quorum | quorum ≥ N/2+1 |
down-after-milliseconds |
3000-10000 | 太短误判,太长响应慢 |
failover-timeout |
60000-180000 | 故障转移总超时 |
parallel-syncs |
1 | 控制同时同步的从库数 |
| Sentinel 数量 | 3 或 5(奇数) | 多机器/多机架部署 |
4.2 脑裂风险总结
| 风险 | 降低措施 |
|---|---|
| 旧主网络隔离仍接受写入 | min-replicas-to-write 拒绝无从库写入 |
| 两个主库同时存在 | 旧主恢复后 Sentinel 强制降级为从库 |
| 故障转移期间数据丢失 | 异步复制固有风险,关键数据须数据库兜底 |
| Sentinel 自身故障 | 奇数部署,至少 3 个,分布在多机器 |
4.3 思考题
-
设计题:故障转移导致旧主上 100 条写入丢失(未复制到从库)。这些写入中有订单创建、积分增加和缓存更新。请为每种类型设计补偿策略。
-
架构题:你的系统有 3 个 Sentinel 部署在同一台物理机上。为什么即使 quorum=2,这仍然是一个危险配置?
(答案提示将在下一章末尾给出。)
4.4 完整 Sentinel 部署检查清单
下面是一份经过多次生产验证的 Sentinel 部署清单,遗漏任何一项都可能埋下"伪高可用"的隐患。
部署前检查:物理环境
部署时检查:配置一致性
部署后验证:功能测试
部署后验证:故障转移演练
4.5 网络分区场景深度分析
网络分区(Split-Brain)是 Sentinel 最难处理的故障场景,需要对各种情况都有预案。
场景一:主库和 Sentinel 失联(但主库与客户端通信正常)
初始拓扑: 网络分区后:
S1 --- M --- S2 [S1, S2, R1] --- 网络隔离 --- [M, 客户端]
| | |
R1 R2 客户端 Sentinel 集群判定主库下线
选举新主 (R1)
M = 主库
S1/S2 = Sentinel 结果:
R1 = 从库 两个主库同时存在!
- 旧主 M 仍在接受客户端写入
- 新主 R1 也被客户端写入
这是最危险的脑裂状态
防护措施组合拳:
# 方案一:min-replicas-to-write(主库侧防护)
# 旧主 M 与所有从库失联 → 写操作被拒绝
CONFIG SET min-replicas-to-write 1
CONFIG SET min-replicas-max-lag 5
# 结果:旧主 M 的写入被拒绝 → 客户端拿到错误 → 触发重连 → 通过 Sentinel 找到新主
# 方案二:client-output-buffer-limit(从库保护)
# 防止从库被主库的输出缓冲区撑爆
CONFIG SET client-output-buffer-limit "replica 256mb 64mb 60"
# replica: 256MB 硬限制, 64MB 软限制, 持续超过软限制 60 秒则断开
# 方案三:Sentinel 侧配置
# 旧主恢复后 -> Sentinel 强制将其降级为从库
# 这是 Sentinel 的默认行为,但确保没有被 CONFIG REWRITE 覆盖
场景二:Sentinel 集群内部分区
[S1, S2] --- 网络隔离 --- [S3, M]
配置:3 个 Sentinel, quorum=2
问题:S1+S2 判定主库下线(2/3 满足 quorum),但 S3 能看到主库
→ 如果 S1+S2 中的 Leader 发起故障转移
→ 同时存在: 旧主 M (S3 认为正常) + 新主 R1 (S1+S2 选举)
→ 脑裂!
解决:
- quorum 必须 > N/2 (本例中应为 2,已满足)
- S1+S2 虽然满足 quorum,但只有 2/3 Sentinel,没有收到 S3 的响应
- 实际上 S1+S2 会尝试故障转移,但新主 R1 必须获得过半 Sentinel 确认
- 如果 S3 一直隔离,S1+S2 的故障转移会执行
- 关键:故障转移完成后,旧主 M 恢复时会被降级 ✓
- 隐患:隔离期间的写入丢失(min-replicas-to-write 可以缓解)
场景三:客户端和 Sentinel 的网络问题
// 客户端侧处理 Sentinel 不可达的情况
// 使用 Spring Data Redis Sentinel 模式,内置重连逻辑
@Configuration
public class SentinelClientConfig {
@Bean
public RedisConnectionFactory redisConnectionFactory() {
RedisSentinelConfiguration sentinelConfig =
new RedisSentinelConfiguration()
.master("mymaster")
.sentinel("sentinel1.example.com", 26379)
.sentinel("sentinel2.example.com", 26379)
.sentinel("sentinel3.example.com", 26379);
sentinelConfig.setPassword(RedisPassword.of("your-password"));
LettuceClientConfiguration clientConfig =
LettuceClientConfiguration.builder()
// 关键配置:拓扑刷新
.useSsl()
.clientOptions(ClusterClientOptions.builder()
.topologyRefreshOptions(TopologyRefreshOptions.builder()
.enablePeriodicRefresh(Duration.ofSeconds(10)) // 每 10 秒刷新拓扑
.enableAllAdaptiveRefreshTriggers() // 故障转移后立即刷新
.build())
.build())
// 命令超时
.commandTimeout(Duration.ofSeconds(3))
// 连接超时
.clientResources(ClientResources.builder()
.reconnectDelay(Delay.exponential(
Duration.ofMillis(100), // 初始 100ms
Duration.ofSeconds(30), // 最大 30s
Duration.ofSeconds(3))) // 倍增因子
.build())
.build();
return new LettuceConnectionFactory(sentinelConfig, clientConfig);
}
}
4.6 客户端故障转移完整测试
测试脚本:模拟主库宕机 → 观察客户端行为 → 验证数据完整性
#!/bin/bash
# failover_chaos_test.sh —— Sentinel 故障转移混沌测试
MASTER_NAME="mymaster"
SENTINEL="127.0.0.1:26379"
echo "=== 故障转移混沌测试 ==="
echo "初始状态:"
redis-cli -p 26379 SENTINEL get-master-addr-by-name $MASTER_NAME
# 1. 写入基线数据
echo ""
echo "[1/6] 写入基线数据..."
for i in $(seq 1 100); do
redis-cli -p 6379 SET test:key:$i "value_$(date +%s%3N)" > /dev/null
done
echo " 100 条数据已写入"
# 2. 启动 Java 客户端持续读写
echo ""
echo "[2/6] 启动客户端持续读写..."
java -jar sentinel-client-test.jar --duration 120 &
CLIENT_PID=$!
sleep 3
# 3. 记录故障前状态
BEFORE_MASTER=$(redis-cli -p 26379 SENTINEL get-master-addr-by-name $MASTER_NAME)
BEFORE_SLAVES=$(redis-cli -p 26379 SENTINEL slaves $MASTER_NAME | grep -c "name")
echo " 故障前: 主库=${BEFORE_MASTER}, 从库数=${BEFORE_SLAVES}"
# 4. 杀死主库
echo ""
OLD_MASTER_PORT=$(echo $BEFORE_MASTER | cut -d' ' -f2)
echo "[3/6] 杀死主库 (端口 ${OLD_MASTER_PORT})..."
redis-cli -p ${OLD_MASTER_PORT} DEBUG sleep 9999 &
sleep 2
redis-cli -p ${OLD_MASTER_PORT} SHUTDOWN NOSAVE 2>/dev/null || true
echo " 主库已停止"
# 5. 等待故障转移
echo ""
echo "[4/6] 等待 Sentinel 故障转移..."
FAILOVER_START=$(date +%s)
for i in $(seq 1 60); do
CURRENT_MASTER=$(redis-cli -p 26379 SENTINEL get-master-addr-by-name $MASTER_NAME 2>/dev/null)
CURRENT_PORT=$(echo $CURRENT_MASTER | cut -d' ' -f2)
if [ "$CURRENT_PORT" != "${OLD_MASTER_PORT}" ] && [ -n "$CURRENT_PORT" ]; then
FAILOVER_END=$(date +%s)
FAILOVER_TIME=$((FAILOVER_END - FAILOVER_START))
echo " 故障转移完成!耗时: ${FAILOVER_TIME}s"
echo " 新主库: ${CURRENT_MASTER}"
break
fi
if [ $i -eq 60 ]; then
echo " [失败] 故障转移超时 (60秒未完成)"
kill $CLIENT_PID 2>/dev/null
exit 1
fi
sleep 1
done
# 5.1 验证新旧主不同
NEW_MASTER=$(redis-cli -p 26379 SENTINEL get-master-addr-by-name $MASTER_NAME)
NEW_MASTER_PORT=$(echo $NEW_MASTER | cut -d' ' -f2)
echo " 新主端口: ${NEW_MASTER_PORT} (旧主端口: ${OLD_MASTER_PORT})"
if [ "$NEW_MASTER_PORT" = "${OLD_MASTER_PORT}" ]; then
echo " [失败] 主库未切换!"
fi
# 6. 验证新主可写入
echo ""
echo "[5/6] 验证新主可写入..."
WRITE_OK=$(redis-cli -p ${NEW_MASTER_PORT} SET failover:test "recovery_success" 2>/dev/null)
if echo "$WRITE_OK" | grep -q "OK"; then
echo " 新主写入: 成功"
else
echo " [失败] 新主写入失败: ${WRITE_OK}"
fi
# 7. 验证从库已切换复制目标
echo ""
echo "[6/6] 验证从库拓扑..."
NEW_SLAVES=$(redis-cli -p 26379 SENTINEL slaves $MASTER_NAME)
echo "$NEW_SLAVES" | grep -E "name|master-host|master-port" | paste - - -
SLAVE_COUNT=$(echo "$NEW_SLAVES" | grep -c "name")
echo " 从库数: ${SLAVE_COUNT} (预期: ${BEFORE_SLAVES})"
# 8. 等待客户端结束
wait $CLIENT_PID 2>/dev/null
CLIENT_EXIT=$?
echo ""
echo "=== 测试结果 ==="
echo "故障转移耗时: ${FAILOVER_TIME}秒"
echo "新主可写入: OK"
echo "从库拓扑: ${SLAVE_COUNT}/${BEFORE_SLAVES}"
echo "客户端退出码: ${CLIENT_EXIT} (0=正常)"
echo ""
if [ "$NEW_MASTER_PORT" != "${OLD_MASTER_PORT}" ] && \
echo "$WRITE_OK" | grep -q "OK" && \
[ "$SLAVE_COUNT" -eq "$BEFORE_SLAVES" ]; then
echo "✓ 故障转移测试通过"
else
echo "✗ 故障转移测试存在异常"
fi
4.7 Sentinel 监控与告警体系
# Sentinel 暴露的 INFO 指标(Prometheus 采集用)
redis-cli -p 26379 INFO sentinel
# 关键指标解释:
# sentinel_masters: 当前监控多少个 master(应等于配置数)
# sentinel_tilt: 是否进入 TILT 模式(时钟异常时为 1)
# sentinel_running_scripts: 当前执行的脚本数
# sentinel_scripts_queue_length: 等待执行的脚本数
# sentinel_simulate_failure_flags: 是否处于故障转移模拟模式
Sentinel TILT 模式详解:
TILT 模式是 Sentinel 的自保护机制:
- 当 Sentinel 检测到系统时钟跳变(比如 NTP 大幅调整)
- 或系统调用(PING)长时间阻塞
→ Sentinel 进入 TILT 模式
TILT 模式下:
- 停止所有定时任务(包括故障检测)
- 只处理必要的 INFO 命令
- 30 秒后如果时钟恢复 → 自动退出 TILT
排查:
# 检查是否进入 TILT
redis-cli -p 26379 SENTINEL MASTERS | grep tilt
# TILT 模式会暂停故障转移
# 必须确保 NTP 服务正常工作
chronyc tracking # 检查 NTP 同步状态
systemctl status ntpd
告警规则设计:
| 告警项 | 阈值/条件 | 级别 | 含义 |
|---|---|---|---|
sentinel_tilt = 1 |
任一节点 | P1 | 时钟异常,故障转移可能失效 |
sentinel_masters 减少 |
较上周期减少 | P1 | 有 Sentinel 失联或配置丢失 |
connected_slaves 减少 |
低于配置数 | P2 | 从库离线 |
sdown 超过 30 秒 |
持续存在 | P2 | 疑似故障但未触发 ODOWN |
odown 出现 |
任一次 | P1 | 主库客观下线,故障转移启动中 |
failover 频率 |
1 小时内 > 2 次 | P1 | 频繁切换,可能有网络问题 |
known-sentinel 减少 |
低于配置数 | P2 | 有 Sentinel 节点离线 |
4.8 故障转移期间的数据补偿方案
故障转移不可避免会造成少量数据丢失(异步复制的窗口期数据)。必须有补偿预案:
数据丢失分层补偿策略:
丢失类型 补偿方式 时效性
─────────────────────────────────────────────────────
缓存数据 (TTL key) 不需补偿——自然过期回源 分钟级
幂等数据 (计数器) 业务日志重放增量 小时级
非幂等数据 (订单) 核对数据库 vs Redis 差异 实时(T+1)
会话数据 用户重新登录 即时
排行榜 定时任务从数据库重算 分钟级
订单类数据补偿示例:
// 故障转移后,核对 Redis 和数据库的订单状态差异
@Service
public class OrderReconciliationService {
@Scheduled(fixedDelay = 60000) // 每分钟核对一次
public void reconcile() {
// 查询最近 5 分钟内创建的订单(防止 TTL 内数据丢失)
List<Order> recentOrders = orderRepository.findByCreatedAfter(
Instant.now().minus(5, ChronoUnit.MINUTES));
for (Order order : recentOrders) {
String redisKey = "order:status:" + order.getId();
String redisStatus = redisTemplate.opsForValue().get(redisKey);
if (redisStatus == null && order.isPending()) {
// Redis 中订单状态丢失,从数据库恢复
log.warn("订单 {} 在 Redis 中丢失,从数据库恢复", order.getId());
redisTemplate.opsForValue().set(redisKey,
order.getStatus().name(),
Duration.ofHours(2)); // 设置合理的 TTL
Metrics.counter("redis.order.recovered").increment();
}
if (redisStatus != null &&
!redisStatus.equals(order.getStatus().name())) {
// 状态不一致,以数据库为准纠正
log.warn("订单 {} 状态不一致: Redis={}, DB={}",
order.getId(), redisStatus, order.getStatus());
redisTemplate.opsForValue().set(redisKey,
order.getStatus().name(),
Duration.ofHours(2));
Metrics.counter("redis.order.corrected").increment();
}
}
}
}
上一章思考题答案提示(第23章):
第1题(延迟 3 秒切换):需要强一致的接口(支付确认、余额查询)自动回主库——在 Redis 客户端侧监控从库延迟(定期对比 master_repl_offset 和 slave_repl_offset),延迟超过阈值时将该从库从读池中暂时移除,该从库的读流量自动切到主库或其他延迟低的从库。
第2题(backlog 大小):20MB/s × 30s = 600MB。从库重启后仍全量同步的原因:① 重启后从库没有保存 run_id,无法确认之前和主库的连接关系;② backlog 中没有覆盖从库断开期间的写入量;③ 人为执行了
REPLICAOF NO ONE清空了复制状态。
延伸阅读与资源
Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
MySQL Server 9从入门到进阶的实战之旅
RabbitMQ从入门到进阶的实战之旅:从单机到大促高可用架构
Celery 入门到进阶之路:从异步任务到自研调度平台
LangGraph 生产级实战进阶:从零到生产级Agent工作流开发
Dify 从入门到源码:LLM 应用平台实战修炼
从零到生产级:FastAPI 异步高并发、源码与 SRE 实战
实战SQLAlchemy 2.0: 从 CRUD 到生产级架构
从零打造企业级 AI 助手:LangChain RAG、Agent 与生产实战
后端工程师 AI 转型课:Ollama 私有化大模型从入门到生产
MongoDB 实战进阶与内核修炼
NumPy 从入门到生产落地:全链路实战指南(科学计算/向量化/性能调优)
Milvus向量数据库实战修炼:从 0 到 1 精通向量检索与生产落地
Python 3实战精进:从脚本到高并发订单引擎
python入门:Rquests从菜鸟脚本到企业级SDK的网络实战圣经

微信公众号: 架构师日常笔记 欢迎关注!
浙公网安备 33010602011771号