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 思考题

  1. 设计题:故障转移导致旧主上 100 条写入丢失(未复制到从库)。这些写入中有订单创建、积分增加和缓存更新。请为每种类型设计补偿策略。

  2. 架构题:你的系统有 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的网络实战圣经

posted on 2026-11-20 21:50  一天不进步,就是退步  阅读(5)  评论(0)    收藏  举报