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 思考题
-
设计题:如果从库延迟达到 3 秒,你会让哪些业务接口自动切回主库读取?如何实现这个自动切换?
-
容量题:主库写入峰值 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的网络实战圣经

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