← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L14 - Redis持久化与集群架构

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、RDB持久化

1.1 RDB原理

RDB(Redis Database)是将内存数据以二进制快照形式保存到磁盘。


触发方式:
┌──────────────────────────────────────────────────┐
│ save命令(生产禁用!)                                │
│   → 阻塞主进程 → 所有客户端请求阻塞 → 线上禁用     │
│                                                   │
│ bgsave命令(推荐)                                  │
│   → fork()子进程 → 利用OS的COW(写时复制)           │
│   → 子进程写RDB文件 → 主进程继续服务               │
│                                                   │
│ 自动触发(配置)                                     │
│   save 900 1      # 900秒内至少1个key变化          │
│   save 300 10     # 300秒内至少10个key变化         │
│   save 60 10000   # 60秒内至少10000个key变化       │
└──────────────────────────────────────────────────┘

bgsave fork + COW过程:
┌─────────┐    fork()    ┌─────────┐
│ 主进程   │ ──────────→ │ 子进程   │
│ (继续处理│              │ 生成RDB  │
│  请求)   │              │ 文件     │
│         │              │         │
│ 写操作→ │ COW:         │         │
│ 复制被修│ 被修改的页    │ 读原始页 │
│ 改的内存│ 复制一份     │ 生成快照  │
│ 页      │ 主进程用副本  │         │
└─────────┘              └─────────┘
注意: fork大内存实例时(如30GB),复制页表本身需要时间,
     可能造成毫秒~秒级停顿。建议单实例不超过10GB。

1.2 RDB优缺点

维度RDB
优点恢复速度极快(直接加载二进制文件)
优点文件紧凑,适合冷备份和容灾
优点对性能影响小(fork后子进程处理)
缺点非实时,可能丢失两次快照间的数据
缺点fork大内存实例时可能卡顿
缺点不同版本RDB格式可能不兼容

二、AOF持久化

2.1 AOF原理

AOF(Append Only File)将每条写命令追加到日志文件。


AOF写入流程:
┌──────────┐    ┌───────────┐    ┌──────────┐    ┌──────────┐
│ Redis    │    │ AOF缓冲区  │    │ OS文件   │    │ 磁盘     │
│ 写命令   │──→ │(aof_buf)  │──→ │ 系统缓存  │──→ │ 持久化   │
│          │    │           │    │ (page    │    │          │
│          │    │           │    │  cache)  │    │          │
└──────────┘    └───────────┘    └──────────┘    └──────────┘
    ① append        ② write         ③ fsync

三种同步策略(appendfsync配置):
┌───────────────────────────────────────────────────────┐
│ always:    每条命令都fsync                             │
│            最安全,性能最差(每次写都刷盘)                 │
│            适用于: 数据极其重要的场景                     │
│                                                       │
│ everysec:  每秒fsync一次(推荐)                         │
│            最多丢1秒数据,性能较好                      │
│            适用于: 绝大多数生产环境                      │
│                                                       │
│ no:        OS决定何时fsync                             │
│            性能最好,可能丢较多数据                      │
│            适用于: 纯缓存场景                           │
└───────────────────────────────────────────────────────┘

2.2 AOF重写(BGREWRITEAOF)


为什么需要重写?
AOF是追加写命令,文件越来越大:
  SET counter 1
  INCR counter    → counter=2
  INCR counter    → counter=3
  ... 执行1000次 ...
  INCR counter    → counter=1001

重写后只需要一条:
  SET counter 1001

重写流程:
1. fork()子进程
2. 子进程根据当前内存状态生成新AOF(只保留最终状态的命令)
3. 主进程继续处理请求,同时将新写命令写入旧AOF和重写缓冲区
4. 子进程完成后,主进程将重写缓冲区的增量追加到新AOF
5. 原子替换旧AOF文件

三、混合持久化(Redis 4.0+)


配置: aof-use-rdb-preamble yes

原理: AOF重写时,前半段用RDB格式(快),后半段用AOF格式(增量)

┌─────────────────────────────────────┐
│            AOF文件(混合模式)         │
│  ┌──────────────────────────────┐  │
│  │ RDB格式部分                   │  │ ← 全量基线,加载快
│  │ (当前内存快照的二进制表示)      │  │
│  ├──────────────────────────────┤  │
│  │ AOF格式部分                   │  │ ← 增量命令
│  │ (重写期间的写命令)             │  │
│  └──────────────────────────────┘  │
└─────────────────────────────────────┘

重启恢复:
1. 加载RDB部分(快,直接读入内存)
2. 重放AOF部分(增量命令少,也快)
3. 兼顾恢复速度和数据完整性

四、RDB vs AOF全面对比

维度RDBAOF
原理定时全量快照追加写命令日志
文件格式二进制(紧凑)文本(可读)
恢复速度极快(直接加载)慢(重放命令)
数据安全可能丢数分钟数据最多丢1秒(everysec)
文件大小小大(重写后变小)
对性能影响fork时可能卡顿写操作多一次写文件
适用场景备份/容灾/快速恢复数据安全要求高

企业级推荐: 两者都开启。RDB做定期冷备(每天备份到OSS),AOF(everysec)保证数据安全。开启混合持久化兼顾恢复速度。

五、哨兵模式(Sentinel)

5.1 架构图


                    ┌─────────────────┐
                    │   Sentinel集群   │
                    │  (3个或奇数个)   │
                    │                 │
                    │  S1   S2   S3   │ ← 互相监控
                    └──┬───┬───┬──────┘
                       │   │   │
         ┌─────────────┘   │   └─────────────┐
         │                 │                  │
         ▼                 ▼                  ▼
    ┌─────────┐      ┌─────────┐       ┌─────────┐
    │ Master  │─────→│ Slave1  │       │ Slave2  │
    │ (写+读)  │      │ (只读)   │       │ (只读)   │
    └─────────┘      └─────────┘       └─────────┘

5.2 故障转移流程


┌─────────────────────────────────────────────────────────┐
│                  哨兵故障转移流程                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 主观下线(SDOWN)                                      │
│     Sentinel-1 ping Master → 超时无响应                  │
│     → Sentinel-1标记Master为SDOWN                        │
│     (可能是网络抖动,不一定真挂了)                         │
│                                                         │
│  2. 客观下线(ODOWN)                                      │
│     Sentinel-1问其他Sentinel: "你也认为Master下线了吗?"  │
│     → 超过quorum个(通常>半数)Sentinel同意                 │
│     → 确认Master真的下线,标记ODOWN                       │
│                                                         │
│  3. 选举Leader Sentinel(Raft协议)                        │
│     多个Sentinel中选出一个负责执行故障转移                  │
│                                                         │
│  4. 选出新Master                                         │
│     规则(按优先级):                                       │
│     a. slave-priority值最小的(配置优先级)                  │
│     b. 复制偏移量最大的(数据最完整)                        │
│     c. run_id最小的(兜底)                                 │
│                                                         │
│  5. 执行转移                                             │
│     a. 对新Master执行 SLAVEOF NO ONE                     │
│     b. 其他Slave改为复制新Master                          │
│     c. 通知客户端新Master地址                             │
│     d. 旧Master恢复后变为新Master的Slave                  │
└─────────────────────────────────────────────────────────┘

六、Redis Cluster

6.1 为什么是16384个槽?


不是65535的原因:
1. 心跳包大小:
   16384个槽 → 16384/8 = 2048字节 ≈ 2KB
   65535个槽 → 65535/8 = 8192字节 ≈ 8KB
   节点间频繁发心跳,8KB太大浪费带宽

2. 集群规模:
   Redis Cluster建议不超过1000个节点
   16384 / 1000 ≈ 每节点16个槽,足够均匀

3. CRC16(key) % 16384 计算槽位
   CRC16产生16bit值(0~65535),取模16384即可

6.2 Cluster架构


┌───────────────────────────────────────────────────────┐
│               Redis Cluster (16384 slots)              │
│                                                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐           │
│  │ Master-1 │  │ Master-2 │  │ Master-3 │  3 Master │
│  │  0-5460  │  │5461-10922│  │10923-16383│           │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘           │
│       │              │              │                  │
│  ┌────▼─────┐  ┌────▼─────┐  ┌────▼─────┐           │
│  │ Slave-1  │  │ Slave-2  │  │ Slave-3  │  3 Slave  │
│  └──────────┘  └──────────┘  └──────────┘           │
│                                                        │
│  Gossip协议: 节点间定期交换信息                         │
│  故障检测: 类似哨兵的ping/pong机制                      │
│  故障转移: Master宕机 → Slave自动提升为Master           │
└───────────────────────────────────────────────────────┘

6.3 MOVED vs ASK重定向


客户端请求路由:
Client请求 GET user:123
→ CRC16("user:123") = 13294
→ 13294 % 16384 = 13294
→ 查路由表: 13294号槽在Master-3

情况1: 请求发到Master-1 → 槽不在我这里
→ 返回 MOVED 13294 10.0.0.3:6379
→ 客户端更新本地路由缓存
→ 后续请求直接发到Master-3(永久迁移)

情况2: 扩容时槽位正在迁移中
→ 返回 ASK 13294 10.0.0.3:6379
→ 客户端仅本次请求发到新节点
→ 不更新本地路由缓存(临时迁移)

对比:
┌──────────┬─────────────────┬─────────────────┐
│          │ MOVED           │ ASK             │
├──────────┼─────────────────┼─────────────────┤
│ 含义     │ 槽已永久迁移     │ 槽正在迁移中     │
│ 客户端   │ 更新路由缓存     │ 不更新           │
│ 触发场景 │ 扩缩容完成后     │ 扩容迁移过程中   │
│ 后续请求 │ 直接连新节点     │ 还会先连旧节点   │
└──────────┴─────────────────┴─────────────────┘

6.4 集群扩缩容


扩容流程(新增Master-4):
1. 启动新Redis节点
2. cluster meet 加入集群
3. reshard 迁移槽位
   例: 从Master-1迁移1000个槽到Master-4
   → Master-1中0-999的key逐个迁移
   → 迁移过程中用ASK重定向
   → 迁移完成后客户端收到MOVED更新路由

缩容流程:
1. 先将目标节点的槽迁移到其他节点
2. 忘记节点 cluster forget

七、Redis高可用架构演进


┌─────────┐     ┌─────────────┐     ┌────────────┐
│  单机    │────→│  主从复制    │────→│  哨兵模式   │
│  (开发)  │     │  (读分离)    │     │  (自动故障  │
│         │     │  手动故障转移│     │   转移)    │
└─────────┘     └─────────────┘     └────────────┘
                                          │
                                          ▼
                                   ┌────────────┐
                                   │  Cluster   │
                                   │  (分布式)   │
                                   │  16384槽    │
                                   │  自动分片   │
                                   └────────────┘

选型建议:
- 开发/测试: 单机
- 中小项目(需高可用): 哨兵(1主2从+3哨兵)
- 大项目(需水平扩展): Cluster(3主3从起步)

面试话术: "Redis持久化我们用混合模式,RDB做定期冷备AOF保证最多丢1秒。集群方案看规模:中小项目用哨兵模式自动故障转移,大项目用Cluster分布式存储。Cluster用16384个哈希槽分布数据,而不是65535,因为心跳包只需2KB而不是8KB。路由用CRC16(key)%16384算槽位,MOVED是永久迁移更新缓存,ASK是临时迁移不更新。"

面试速记卡(考前30秒速看)

练习题(自测)

1. RDB的bgsave如何利用OS的COW机制实现不影响主进程?fork大内存实例时有什么风险?

2. AOF的always/everysec/no三种策略各自的性能和数据安全权衡是什么?生产环境推荐哪个?

3. 哨兵模式下quorum设为2,有3个Sentinel,如果Sentinel-1和Sentinel-2网络分区但都能看到Master,会发生什么?

4. Redis Cluster中,客户端请求一个正在迁移的槽位的key,完整的请求重定向流程是什么?

5. 如果面试官问"RDB和AOF怎么选",请给出一个企业级的回答,包括两者都开启的方案。

学习资料