1. 项目背景

1.1 业务场景

商品详情服务的 Redis 已经成了整个系统的命脉——商品缓存、购物车、排行榜、库存快照都在 Redis 中。读 QPS 从两个月前的 5000 涨到了现在的 40000。单机 Redis 虽然 QPS 绰绰有余,但运维开始担心两个问题:

第一,单点故障。这台 Redis 如果宕机,依赖它的 15 个服务接口全部降级——虽然部分可以从数据库回源,但回源流量会瞬间打满数据库。

第二,读扩展受限。主库既要处理写入(每秒 200 次),又要处理读取(每秒 40000 次)。虽然单机 Redis 还能扛住,但持续增长的读流量总有天花板——加 CPU 不如加从库,把读请求分散到多个副本。

主从复制是 Redis 高可用和水平扩展读能力的第一层基石。主库负责写入,从库通过复制流实时同步数据并承担读请求。它不能自动故障转移(需要 Sentinel),也不能拆分数据容量(需要 Cluster),但在当前阶段——中小规模、单分片数据量可接受——一主两从已经能大幅提升读容量和容灾能力。

1.2 本章目标

  • 搭建 Docker 一主两从环境,理解全量同步与增量同步。
  • 配置客户端读写分离,区分哪些读可以走从库。
  • 观察复制延迟和断链重连行为。
  • 使用 min-replicas-to-write 做数据安全保护。

2. 项目设计

2.1 第一幕:主从复制是抄作业,不是同时交

小胖:"主从复制不就是主库写了,从库跟着抄作业吗?读请求全丢给从库,主库专心写就行。"

小白:"但从库抄作业需要时间。如果主库刚写完 SET nickname '小胖',用户立刻刷新页面——请求到了从库,从库还没同步到这条写操作,用户看到的还是旧昵称。这不就等于是'读己之写'不一致了吗?"

大师:"这就是主从复制的第一个关键认知——它是异步复制。主库写成功不等待从库确认,从库通过复制流异步追赶。所以读写分离必须先做业务分级:"

读写分离的业务分级:

  可以读从库的:
    ✓ 商品详情(允许短暂旧数据,TTL 10分钟)
    ✓ 排行榜(允许几秒延迟)
    ✓ 店铺信息(几天才变一次)
    ✓ 推荐列表(允许延迟)

  必须读主库的:
    ✗ 刚提交订单后的查询(读己之写)
    ✗ 支付状态确认
    ✗ 库存扣减后的确认
    ✗ 用户刚修改的资料

  做法:
    普通读 → 从库(低延迟、高吞吐)
    刚写后读 → 主库(避免复制延迟)
    强一致读 → 数据库(最终事实来源)

技术映射:Redis 主从复制是异步的——master_repl_offset 和 slave_repl_offset 的差值反映复制延迟。业务需要根据这个延迟量决定读路径。

2.2 第二幕:全量同步 vs 增量同步

小胖:"从库第一次连主库,是不是要把所有数据都同步过来?如果主库有 10GB 数据,这个过程要多久?"

大师:"第一次连接触发全量同步(full resync)。流程是:"

全量同步流程:

  主库                          从库
   │                             │
   │  1. 从库发送 PSYNC ? -1     │  (请求全量同步)
   │ ◀─────────────────────────── │
   │                             │
   │  2. 主库 BGSAVE 生成 RDB     │
   │  3. 同时缓冲新写入命令       │
   │                             │
   │  4. 发送 RDB 给从库          │
   │ ──────────────────────────▶ │
   │                             │  5. 从库清除旧数据
   │                             │  6. 从库加载 RDB
   │                             │
   │  7. 发送缓冲区中的写命令      │
   │ ──────────────────────────▶ │  8. 从库回放增量命令
   │                             │
   │  复制进入稳定状态             │

大师:"全量同步期间,主库既要 BGSAVE(CPU/内存/磁盘),又要网络传输 RDB(带宽),还要缓冲新写入(内存)。所以不要在业务高峰期给集群加从库。"

小白追问:"如果网络闪断了几秒后又恢复,从库还需要全量同步吗?"

大师:"这取决于复制积压缓冲区(repl-backlog)。它是一个环形缓冲区,存储最近的写命令。如果断线期间的写入量没有超过 backlog 大小,从库只需要增量同步(partial resync),补齐断线期间的命令。如果 backlog 被覆盖了,就只能触发全量同步。所以 repl-backlog-size 要根据写入峰值和可接受断线时间来配置。"

backlog 大小估算:
  backlog_size ≥ 写入速率(字节/秒) × 最大可接受断线时间(秒)

  例如: 写入峰值 20MB/s, 希望 60 秒断线仍可增量同步
  → backlog_size ≥ 20MB × 60 = 1.2GB

2.3 第三幕:min-replicas-to-write——安全与可用性的权衡

小胖:"如果主库写了但所有从库都挂了——主库突然宕机又没从库可以接手——这些数据是不是就丢了?"

大师:"min-replicas-to-write 就是应对这个风险的。它要求主库在执行写入前,至少要有 N 个从库在线且延迟不超过 M 秒。如果条件不满足,主库拒绝写入。"

min-replicas-to-write 的权衡:

  配置: min-replicas-to-write 1
        min-replicas-max-lag 5

  场景 1: 正常 → 1 个从库在线,延迟 2s → 写入允许 ✓
  场景 2: 从库全部宕机 → 0 个从库在线 → 写入拒绝 ✗
  场景 3: 从库在线但延迟 6s → 延迟超限 → 写入拒绝 ✗

  优点: 降低了"主库写完后宕机、从库没来得及同步"的风险
  缺点: 牺牲了可用性——从库出问题时写入也会失败
  建议: 配合客户端的降级策略——写失败时返回友好提示而非报错

3. 项目实战

3.1 环境准备

# 创建 Docker 网络
docker network create redis-repl-net

# 启动一主两从
docker run --name redis-master --network redis-repl-net -p 6379:6379 \
  -d redis:8.6 redis-server --appendonly yes

docker run --name redis-replica1 --network redis-repl-net -p 6380:6379 \
  -d redis:8.6 redis-server --appendonly yes --replicaof redis-master 6379

docker run --name redis-replica2 --network redis-repl-net -p 6381:6379 \
  -d redis:8.6 redis-server --appendonly yes --replicaof redis-master 6379

3.2 实战一:验证复制状态

# 查看主库复制状态
docker exec -it redis-master redis-cli INFO replication
# role:master
# connected_slaves:2
# slave0:ip=...,port=6379,state=online,offset=...,lag=0
# slave1:ip=...,port=6379,state=online,offset=...,lag=0
# master_repl_offset:12345

# 查看从库状态
docker exec -it redis-replica1 redis-cli INFO replication
# role:slave
# master_host:redis-master
# master_link_status:up
# slave_repl_offset:12345

# 主库写入
docker exec -it redis-master redis-cli
127.0.0.1:6379> SET product:1001 '{"name":"机械键盘","price":299}'
OK

# 从库读取(验证同步)
docker exec -it redis-replica1 redis-cli GET product:1001
"{\"name\":\"机械键盘\",\"price\":299}"

# 从库只读验证
docker exec -it redis-replica1 redis-cli SET test:write "should-fail"
# (error) READONLY You can't write against a read only replica.

3.3 实战二:模拟复制延迟

# 观察复制偏移量
docker exec -it redis-master redis-cli INFO replication | grep master_repl_offset
docker exec -it redis-replica1 redis-cli INFO replication | grep slave_repl_offset
# 偏移量差异 = 复制延迟(字节数)

# 停止从库模拟断链
docker stop redis-replica1

# 主库继续大量写入
docker exec -it redis-master redis-cli
for i in $(seq 1 100); do
  SET "test:key:$i" "value-$i"
done

# 重启从库观察恢复
docker start redis-replica1
sleep 3
docker exec -it redis-replica1 redis-cli GET test:key:100
"value-100"    # 增量同步成功

3.4 实战三:客户端读写分离

@Configuration
public class ReadWriteSplitConfig {

    @Bean("redisWriteTemplate")
    public StringRedisTemplate writeTemplate() {
        // 连接主库: redis-master:6379
        return createTemplate("redis-master", 6379);
    }

    @Bean("redisReadTemplate")
    public StringRedisTemplate readTemplate() {
        // 连接从库: redis-replica1:6380, redis-replica2:6381
        // 使用轮询/随机负载均衡
        LettuceClientConfiguration config = LettuceClientConfiguration.builder()
            .readFrom(ReadFrom.REPLICA_PREFERRED)  // 优先读从库
            .build();
        return createTemplateWithConfig(config, "redis-master", 6379);
    }
}

@Service
public class ProductReadService {
    @Resource(name = "redisReadTemplate")
    private StringRedisTemplate readRedis;   // 普通读走从库

    @Resource(name = "redisWriteTemplate")
    private StringRedisTemplate writeRedis;  // 写后读走主库

    // 刚更新后短时间内的读取走主库
    public Product getProductAfterUpdate(String productId) {
        // 写入走主库
        writeRedis.opsForValue().set("product:" + productId, json);

        // 写后读也走主库(避免复制延迟)
        String json = writeRedis.opsForValue().get("product:" + productId);
        return deserialize(json);
    }

    // 普通读取走从库
    public Product getProduct(String productId) {
        String json = readRedis.opsForValue().get("product:" + productId);
        if (json == null) {
            // 从库未命中 → 回源数据库(不是回源主库!)
            return loadFromDatabase(productId);
        }
        return deserialize(json);
    }
}

3.5 实战四:min-replicas-to-write 配置

# 主库配置数据安全保护
127.0.0.1:6379> CONFIG SET min-replicas-to-write 1
OK
127.0.0.1:6379> CONFIG SET min-replicas-max-lag 5
OK

# 验证: 从库正常时写入成功
127.0.0.1:6379> SET safe:test "ok"
OK

# 停止所有从库后测试
# docker stop redis-replica1 redis-replica2
127.0.0.1:6379> SET safe:test "should-fail"
(error) NOREPLICAS Not enough good replicas to write.

3.6 实战五:复制监控指标

# 关键监控指标
127.0.0.1:6379> INFO replication
# 主库关注:
#   connected_slaves: 从库数量(应该等于期望值)
#   master_repl_offset: 主库复制偏移
# 从库关注:
#   master_link_status: up/down
#   slave_repl_offset: 从库复制偏移
#   master_last_io_seconds_ago: 最后一次主从通信距今秒数
#   master_sync_in_progress: 是否正在进行全量同步

# 计算复制延迟
# 在主库: INFO replication → master_repl_offset
# 在从库: INFO replication → slave_repl_offset
# 延迟 = master_repl_offset - slave_repl_offset (字节)

3.7 实战六:全量同步的风险与规避

全量同步(full resync)对主库的影响:

# 风险1: 主库内存开销
# BGSAVE 期间 fork 子进程 → Copy-on-Write 内存增长
# 如果主库写入量大,COW 可导致内存翻倍

# 风险2: 磁盘 IO
# RDB 写入磁盘 + 网络传输 RDB 文件

# 风险3: 网络带宽
# 从库数量 × RDB 大小 = 网络总流量

# 规避措施:
# 1. 不要在业务高峰期加从库
# 2. 设置 repl-diskless-sync yes (无盘复制, Redis 2.8.18+)
#    主库不写磁盘,直接通过网络发送 RDB
#    CONFIG SET repl-diskless-sync yes

# 3. 限制同时同步的从库数量
#    CONFIG SET repl-diskless-sync-max-replicas 3

3.8 实战七:复制状态巡检脚本

#!/bin/bash
# replication_check.sh

echo "=== 主库状态 ==="
redis-cli -h redis-master INFO replication | grep -E "role|connected_slaves|master_repl_offset"

echo ""
echo "=== 从库状态 ==="
for host in redis-replica1 redis-replica2; do
  echo "--- $host ---"
  redis-cli -h $host INFO replication | grep -E "role|master_link_status|slave_repl_offset|master_last_io_seconds_ago|master_sync_in_progress"
done

echo ""
echo "=== 复制延迟估算 ==="
MASTER_OFFSET=$(redis-cli -h redis-master INFO replication | grep master_repl_offset | cut -d: -f2 | tr -d '\r')
REPLICA_OFFSET=$(redis-cli -h redis-replica1 INFO replication | grep slave_repl_offset | cut -d: -f2 | tr -d '\r')
echo "复制延迟: $((MASTER_OFFSET - REPLICA_OFFSET)) 字节"

3.9 实战八:读写分离的灰度方案

不推荐一次性把所有读切换从库——风险太大。建议分阶段灰度:

阶段 1: 低风险读(商品详情、店铺信息)
  → 配置从库只读连接池
  → 1% 流量切到从库,观察延迟和命中率
  → 逐步放大到 50% → 100%

阶段 2: 中风险读(排行榜、推荐列表)
  → 允许延迟 3-5 秒
  → 同上灰度

阶段 3: 写后读方案
  → 刚写入的 key 在主库读(避免复制延迟)
  → 其他 key 在从库读
  → 实现: 写入时记录 key + timestamp 到 ThreadLocal
    读取时检查是否在"近期写入集合"中
    - 在 → 读主库
    - 不在 + 超时 → 读从库

阶段 4: 全量监控对比
  → 对比主从库数据一致性(抽样)
  → 监控从库延迟 P99

3.10 实战九:主从切换后的脏数据清理

# 场景: 旧主宕机恢复后变成从库
# 旧主在隔离期间可能接受了部分写入(如果客户端还连着它)
# 这些写入在新主上不存在

# 恢复后旧主成为从库 → 会执行全量同步
# → 隔离期间的写入被清空 ✓

# 但是如果旧主上的某些 key 被设置了 TTL...
# 隔离期间这些 key 可能过期了但没人通知
# → TTL 依赖新主的过期删除策略

4.4 生产事故:主从断链导致全量同步风暴

某电商系统一主两从,repl-backlog-size 配置为默认的 1MB。某次网络抖动导致两个从库同时断连 30 秒。这 30 秒内主库写入量约 600MB——远超 backlog 大小。两个从库重连时都触发全量同步。主库同时为两个从库生成 RDB、传输——导致主库 CPU 100%、网络打满、正常业务请求延迟暴涨。教训:repl-backlog-size 必须按"写入峰值 × 最大容忍断线时间"来配置,不能用默认值。

4.5 主从复制配置速查卡

配置 生产建议值 说明
repl-backlog-size 256mb-1gb 按写入量估算
repl-backlog-ttl 3600 秒数
replica-read-only yes 从库只读
replica-serve-stale-data yes 断链时从库仍可读旧数据
repl-diskless-sync yes 无盘复制
min-replicas-to-write 1 数据安全
min-replicas-max-lag 5-10 最大延迟

4.6 主从复制深度对话

小胖:"我部署了一主两从,为什么从库的 used_memory 和主库几乎一样大?我以为从库只是'转发'读请求,不占内存。"

大师:"从库要存完整的数据副本——因为 Redis 的访问是 O(1) 内存查找,不是 SQL 的查询转发。从这个角度,主从复制不是'免费'的——每加一个从库,总内存成本翻倍。这是 Redis 和 MySQL 读写分离的本质区别——MySQL 从库也是完整数据副本,但磁盘便宜;Redis 从库用的也是内存,贵得多。"

小白追问:"那什么情况下读从库反而会变慢?"

大师:"① 从库正在加载 RDB 或回放大量积压命令时——CPU 和内存 IO 被占用;② 从库所在的机器有其他重负载;③ 网络延迟导致从库落后主库太多,读到的数据太旧导致业务请求反复重试。所以从库的延迟和主从偏移量是必须监控的核心指标。"


4. 项目总结

4.1 主从复制关键配置

配置 建议值 说明
repl-backlog-size 256mb-1gb 按写入峰值 × 断线时间估算
repl-backlog-ttl 3600 backlog 保留秒数
replica-read-only yes 从库默认只读
min-replicas-to-write 1 至少 1 个从库在线才写入
min-replicas-max-lag 5-10 从库最大延迟秒数
client-output-buffer-limit replica 256mb 64mb 60 从库输出缓冲区限制

4.2 思考题

  1. 设计题:如果从库延迟达到 3 秒,你会让哪些业务接口自动切回主库读取?如何实现这个自动切换?

  2. 容量题:主库写入峰值 20MB/s,希望网络断开 30 秒仍可增量同步。repl-backlog-size 至少需要多大?如果从库重启后仍需全量同步,请分析可能的原因。

(答案提示将在下一章末尾给出。)

4.3 读写分离实现模式——从简单到健壮

读写分离听起来简单——"写走主,读走从",但实现起来有四个逐渐成熟的阶段。

阶段一:朴素路由(写主读从,不管一致性)

// 最简单的实现——仅按操作类型路由
// 问题:完全没有考虑复制延迟,"读己之写"必出问题

@Component
public class NaiveReadWriteRouter {
    private final RedisTemplate<String, Object> master;
    private final List<RedisTemplate<String, Object>> slaves;

    public void set(String key, Object value) {
        master.opsForValue().set(key, value);
    }

    public Object get(String key) {
        // 随机选从库,完全不考虑用户刚写过的情况
        int idx = ThreadLocalRandom.current().nextInt(slaves.size());
        return slaves.get(idx).opsForValue().get(key);
    }
}

阶段二:带写入标记的路由(解决"读己之写")

// 核心思路:写入后记录 key + 时间戳,
// 短期内读到这些 key 时强制走主库

@Component
public class WriteAwareRouter {
    private final RedisTemplate<String, Object> master;
    private final List<RedisTemplate<String, Object>> slaves;
    // ThreadLocal 存储本线程最近写入的 key
    private final ThreadLocal<Map<String, Long>> recentWrites =
        ThreadLocal.withInitial(HashMap::new);
    private static final long STICKY_MS = 3000; // 3 秒内走主库

    public void set(String key, Object value) {
        master.opsForValue().set(key, value);
        // 记录写入时间
        recentWrites.get().put(key, System.currentTimeMillis());

        // 定期清理过期记录(避免内存泄漏)
        if (recentWrites.get().size() > 1000) {
            AutoRemover.cleanExpired(recentWrites.get(), STICKY_MS);
        }
    }

    public Object get(String key) {
        // 检查是否是"近期写入"的 key
        Long writeTime = recentWrites.get().get(key);
        if (writeTime != null &&
            System.currentTimeMillis() - writeTime < STICKY_MS) {
            return master.opsForValue().get(key); // 强制读主库
        }

        // 读从库(带轮询负载均衡)
        int idx = ThreadLocalRandom.current().nextInt(slaves.size());
        return slaves.get(idx).opsForValue().get(key);
    }

    // 重要:请求结束时清理 ThreadLocal
    @Scheduled(fixedRate = 60000)
    public void cleanThreadLocals() {
        // 实际应在 Filter/Interceptor 中清理
    }
}

// 使用 Spring Interceptor 自动清理
@Component
public class ThreadLocalCleanInterceptor implements HandlerInterceptor {
    @Override
    public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler, Exception ex) {
        WriteAwareRouter.clearCurrentThread();
    }
}

阶段三:延迟感知的动态路由(核心实现)

// 实时监控从库延迟,延迟过高时自动摘除故障从库

@Component
public class ReplicationAwareReadRouter {
    private final RedisTemplate<String, Object> master;
    private final List<SlaveNode> slaves = new CopyOnWriteArrayList<>();
    private final ScheduledExecutorService scheduler =
        Executors.newSingleThreadScheduledExecutor();

    @Data
    @AllArgsConstructor
    public static class SlaveNode {
        private final String name;
        private final RedisTemplate<String, Object> template;
        private final String host;
        private final int port;
        private volatile long lagBytes = 0;       // 复制延迟(字节)
        private volatile long lagSeconds = 0;     // 复制延迟(秒数)
        private volatile boolean healthy = true;
        private volatile long lastCheckTime = 0;
    }

    @PostConstruct
    public void startHealthCheck() {
        // 每秒检查一次从库状态
        scheduler.scheduleAtFixedRate(() -> {
            for (SlaveNode slave : slaves) {
                try {
                    checkSlaveHealth(slave);
                } catch (Exception e) {
                    log.warn("从库 {} 健康检查失败", slave.getName(), e);
                    slave.setHealthy(false);
                }
            }
        }, 0, 1, TimeUnit.SECONDS);
    }

    private void checkSlaveHealth(SlaveNode slave) {
        Properties info = (Properties) slave.getTemplate()
            .execute((RedisCallback<Object>) conn -> {
                return conn.serverCommands().info("replication");
            });

        String role = info.getProperty("role");
        if (!"slave".equals(role)) {
            slave.setHealthy(false);
            return;
        }

        // 计算复制延迟
        long masterReplOffset = Long.parseLong(
            info.getProperty("master_repl_offset"));
        long slaveReplOffset = Long.parseLong(
            info.getProperty("slave_repl_offset"));
        long lag = masterReplOffset - slaveReplOffset;
        slave.setLagBytes(lag);

        // 估算秒级延迟(写入速度约 10MB/s)
        slave.setLagSeconds(lag / (10 * 1024 * 1024));

        // 健康判定:延迟 < 3 秒 且 连接正常
        boolean wasHealthy = slave.isHealthy();
        slave.setHealthy(
            "connected".equals(info.getProperty("master_link_status"))
            && slave.getLagSeconds() < 3
        );

        if (wasHealthy && !slave.isHealthy()) {
            log.warn("从库 {} 被标记为不健康!延迟={}秒",
                slave.getName(), slave.getLagSeconds());
        } else if (!wasHealthy && slave.isHealthy()) {
            log.info("从库 {} 已恢复健康,延迟={}秒",
                slave.getName(), slave.getLagSeconds());
        }
    }

    // 获取当前可用的从库列表
    public List<SlaveNode> getHealthySlaves() {
        return slaves.stream()
            .filter(SlaveNode::isHealthy)
            .collect(Collectors.toList());
    }

    @PreDestroy
    public void shutdown() {
        scheduler.shutdown();
    }
}

阶段四:Spring AOP 注解式路由(生产级封装)

// 通过注解声明每个方法走主库还是从库

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadFrom {
    Source value() default Source.SLAVE;
    boolean allowStale() default true; // 是否容忍旧数据

    enum Source { MASTER, SLAVE }
}

@Aspect
@Component
@Order(1)
public class ReadWriteRoutingAspect {
    private final ReplicationAwareReadRouter router;

    @Around("@annotation(readFrom)")
    public Object route(ProceedingJoinPoint pjp, ReadFrom readFrom) throws Throwable {
        if (readFrom.value() == ReadFrom.Source.MASTER) {
            // 强制走主库 → 切换 ThreadLocal 标记
            RoutingContext.forceMaster();
        } else if (!readFrom.allowStale()) {
            // 不允许脏读 → 走主库
            RoutingContext.forceMaster();
        }
        // else: 默认走从库

        try {
            return pjp.proceed();
        } finally {
            RoutingContext.clear();
        }
    }
}

// 业务代码使用示例
@Service
public class ProductService {
    @ReadFrom(ReadFrom.Source.SLAVE)
    public Product getProduct(Long id) {
        // 普通商品详情 → 走从库
    }

    @ReadFrom(value = ReadFrom.Source.SLAVE, allowStale = false)
    public Product getProductFresh(Long id) {
        // 需要最新数据 → 实际上会走主库
    }

    @ReadFrom(ReadFrom.Source.MASTER)
    public OrderStatus getOrderStatus(String orderId) {
        // 刚提交的订单 → 走主库
    }
}

4.4 复制延迟的精细化监控

仅仅看 INFO replication 是不够的。推荐三个维度的延迟监控。

维度一:Redis 内建指标

#!/bin/bash
# repl_monitor.sh —— 主从复制监控脚本

MASTER_HOST="redis-master"
MASTER_PORT=6379

echo "--- 主库复制状态 ---"
redis-cli -h $MASTER_HOST -p $MASTER_PORT INFO replication | \
    grep -E "connected_slaves|min_slaves_good_slaves"

echo ""
echo "--- 各从库延迟详情 ---"
redis-cli -h $MASTER_HOST -p $MASTER_PORT INFO replication | \
    grep -A 10 "slave0\|slave1\|slave2" | \
    grep -E "ip|port|state|lag|offset"

# 从库视角
for SLAVE_HOST in redis-slave1 redis-slave2; do
    echo ""
    echo "--- ${SLAVE_HOST} 从库状态 ---"
    redis-cli -h $SLAVE_HOST INFO replication | \
        grep -E "master_link_status|master_last_io_seconds_ago|master_repl_offset|slave_repl_offset|role"

    # 计算延迟字节
    MASTER_OFFSET=$(redis-cli -h $SLAVE_HOST INFO replication | \
        grep master_repl_offset | cut -d: -f2 | tr -d '\r')
    SLAVE_OFFSET=$(redis-cli -h $SLAVE_HOST INFO replication | \
        grep slave_repl_offset | cut -d: -f2 | tr -d '\r')

    LAG=$((MASTER_OFFSET - SLAVE_OFFSET))
    if [ "$LAG" -gt 10485760 ]; then  # >10MB
        echo "  [告警] 复制延迟过大: ${LAG} bytes (约 $((LAG/1024/1024)) MB)"
    else
        echo "  复制延迟: ${LAG} bytes (正常)"
    fi
done

维度二:业务层主动探测

// 定期往 Redis 写入探测 key,再从从库读取对比时间戳
// 这是最准确的"端到端"延迟指标

@Component
public class ReplicationLagProbe {
    private final RedisTemplate<String, String> master;
    private final List<RedisTemplate<String, String>> slaves;
    private static final String PROBE_KEY = "probe:replication:lag";

    @Scheduled(fixedRate = 2000) // 每 2 秒探测一次
    public void probe() {
        // 1. 主库写入当前时间戳
        long now = System.currentTimeMillis();
        master.opsForValue().set(PROBE_KEY, String.valueOf(now));

        // 2. 从库读取,计算延迟
        for (int i = 0; i < slaves.size(); i++) {
            try {
                String value = slaves.get(i).opsForValue().get(PROBE_KEY);
                if (value != null) {
                    long slaveTime = Long.parseLong(value);
                    long lagMs = now - slaveTime;

                    // 暴露给 Prometheus
                    Metrics.gauge("redis.replication.lag.ms",
                        Map.of("slave", "slave-" + i), lagMs);

                    if (lagMs > 3000) {
                        log.warn("从库 slave-{} 复制延迟过高: {}ms", i, lagMs);
                    }
                }
            } catch (Exception e) {
                log.error("从库 slave-{} 探测失败", i, e);
            }
        }
    }
}

维度三:应用层读后校验

// 关键业务的读操作,读完之后可选地校验版本号
// 这不是常规操作,但在金融/支付场景会用到

@Service
public class VerifiedReadService {
    private final RedisTemplate<String, Object> master;
    private final RedisTemplate<String, Object> slave;

    public UserBalance getBalanceWithVerify(Long userId) {
        String key = "balance:" + userId;

        // 先从库读(低延迟)
        UserBalance balance = (UserBalance) slave.opsForValue().get(key);

        // 关键业务:抽样读主库校验(1% 概率)
        if (ThreadLocalRandom.current().nextInt(100) == 0) {
            UserBalance masterBalance =
                (UserBalance) master.opsForValue().get(key);

            // 版本号不一致 → 从库数据过期
            if (balance != null && masterBalance != null &&
                balance.getVersion() < masterBalance.getVersion()) {
                log.warn("从库数据过期: key={}, slave_v={}, master_v={}",
                    key, balance.getVersion(), masterBalance.getVersion());
                balance = masterBalance; // 用最新数据纠正

                // 记录不一致次数(告警用)
                Metrics.counter("redis.stale.read").increment();
            }
        }

        return balance;
    }
}

4.5 主从复制延迟告警矩阵

延迟级别 阈值 含义 自动动作
正常 < 100ms 从库几乎实时同步 无
轻微延迟 100ms - 1s 网络波动/写入突增 记录日志
中等延迟 1s - 5s 可能影响用户体验 告警 P3 + 摘除该从库
严重延迟 5s - 30s 基本无法用于读 告警 P2 + 全量读切主库
断连 > 30s 或 link_status=down 从库不可用 告警 P1 + 触发全量同步

4.6 min-replicas-to-write 深入实践

# 配置:至少 1 个从库在 10 秒内完成同步,才接受写入
CONFIG SET min-replicas-to-write 1
CONFIG SET min-replicas-max-lag 10

# 验证:模拟从库断连
# 1. 停止所有从库
docker stop redis-slave1 redis-slave2

# 2. 主库写入
redis-cli -h redis-master SET test:minreplicas "hello"
# (error) NOREPLICAS Not enough good replicas to write

# 3. 恢复从库
docker start redis-slave1
# 等待 10 秒(小于 min-replicas-max-lag)
redis-cli -h redis-master SET test:minreplicas "hello"
# OK → 写入恢复

# 这个配置配合 Sentinel 使用是最佳组合:
# - Sentinel 保证故障转移
# - min-replicas-to-write 保证不丢数据

上一章思考题答案提示(第22章):

第1题(1 秒丢失):配置 AOF everysec。但机房断电时——磁盘缓存中的数据可能未真正写入物理磁盘,fsync 每秒一次意味着最后 1 秒可能丢失。要兑现"真的只丢 1 秒",需要:① UPS 不间断电源在断电时给服务器时间刷盘;② AOF 文件写入支持 fsync 的磁盘(而非网络存储)。

第2题(恢复演练):流程——① 运维发现故障/收到告警 → ② 评估影响范围(哪些业务依赖此 Redis)→ ③ 停止写入入口(或切换到降级模式)→ ④ 备份损坏的数据目录 → ⑤ 选择最近可用的 RDB/AOF 备份 → ⑥ 在隔离环境启动 Redis 验证数据完整性(DBSIZE、抽样 GET)→ ⑦ 将验证通过的备份替换生产数据目录 → ⑧ 启动 Redis 并观察监控指标恢复 → ⑨ 通知业务验证。

延伸阅读与资源

Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
MySQL Server 9从入门到进阶的实战之旅
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
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 09:39  一天不进步,就是退步  阅读(9)  评论(0)    收藏  举报