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。
| 维度 | RDB |
|---|---|
| 优点 | 恢复速度极快(直接加载二进制文件) |
| 优点 | 文件紧凑,适合冷备份和容灾 |
| 优点 | 对性能影响小(fork后子进程处理) |
| 缺点 | 非实时,可能丢失两次快照间的数据 |
| 缺点 | fork大内存实例时可能卡顿 |
| 缺点 | 不同版本RDB格式可能不兼容 |
AOF(Append Only File)将每条写命令追加到日志文件。
AOF写入流程:
┌──────────┐ ┌───────────┐ ┌──────────┐ ┌──────────┐
│ Redis │ │ AOF缓冲区 │ │ OS文件 │ │ 磁盘 │
│ 写命令 │──→ │(aof_buf) │──→ │ 系统缓存 │──→ │ 持久化 │
│ │ │ │ │ (page │ │ │
│ │ │ │ │ cache) │ │ │
└──────────┘ └───────────┘ └──────────┘ └──────────┘
① append ② write ③ fsync
三种同步策略(appendfsync配置):
┌───────────────────────────────────────────────────────┐
│ always: 每条命令都fsync │
│ 最安全,性能最差(每次写都刷盘) │
│ 适用于: 数据极其重要的场景 │
│ │
│ everysec: 每秒fsync一次(推荐) │
│ 最多丢1秒数据,性能较好 │
│ 适用于: 绝大多数生产环境 │
│ │
│ no: OS决定何时fsync │
│ 性能最好,可能丢较多数据 │
│ 适用于: 纯缓存场景 │
└───────────────────────────────────────────────────────┘
为什么需要重写?
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文件
配置: aof-use-rdb-preamble yes
原理: AOF重写时,前半段用RDB格式(快),后半段用AOF格式(增量)
┌─────────────────────────────────────┐
│ AOF文件(混合模式) │
│ ┌──────────────────────────────┐ │
│ │ RDB格式部分 │ │ ← 全量基线,加载快
│ │ (当前内存快照的二进制表示) │ │
│ ├──────────────────────────────┤ │
│ │ AOF格式部分 │ │ ← 增量命令
│ │ (重写期间的写命令) │ │
│ └──────────────────────────────┘ │
└─────────────────────────────────────┘
重启恢复:
1. 加载RDB部分(快,直接读入内存)
2. 重放AOF部分(增量命令少,也快)
3. 兼顾恢复速度和数据完整性
| 维度 | RDB | AOF |
|---|---|---|
| 原理 | 定时全量快照 | 追加写命令日志 |
| 文件格式 | 二进制(紧凑) | 文本(可读) |
| 恢复速度 | 极快(直接加载) | 慢(重放命令) |
| 数据安全 | 可能丢数分钟数据 | 最多丢1秒(everysec) |
| 文件大小 | 小 | 大(重写后变小) |
| 对性能影响 | fork时可能卡顿 | 写操作多一次写文件 |
| 适用场景 | 备份/容灾/快速恢复 | 数据安全要求高 |
企业级推荐: 两者都开启。RDB做定期冷备(每天备份到OSS),AOF(everysec)保证数据安全。开启混合持久化兼顾恢复速度。
┌─────────────────┐
│ Sentinel集群 │
│ (3个或奇数个) │
│ │
│ S1 S2 S3 │ ← 互相监控
└──┬───┬───┬──────┘
│ │ │
┌─────────────┘ │ └─────────────┐
│ │ │
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Master │─────→│ Slave1 │ │ Slave2 │
│ (写+读) │ │ (只读) │ │ (只读) │
└─────────┘ └─────────┘ └─────────┘
┌─────────────────────────────────────────────────────────┐
│ 哨兵故障转移流程 │
├─────────────────────────────────────────────────────────┤
│ │
│ 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 │
└─────────────────────────────────────────────────────────┘
不是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即可
┌───────────────────────────────────────────────────────┐
│ 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 │
└───────────────────────────────────────────────────────┘
客户端请求路由:
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 │
├──────────┼─────────────────┼─────────────────┤
│ 含义 │ 槽已永久迁移 │ 槽正在迁移中 │
│ 客户端 │ 更新路由缓存 │ 不更新 │
│ 触发场景 │ 扩缩容完成后 │ 扩容迁移过程中 │
│ 后续请求 │ 直接连新节点 │ 还会先连旧节点 │
└──────────┴─────────────────┴─────────────────┘
扩容流程(新增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
┌─────────┐ ┌─────────────┐ ┌────────────┐
│ 单机 │────→│ 主从复制 │────→│ 哨兵模式 │
│ (开发) │ │ (读分离) │ │ (自动故障 │
│ │ │ 手动故障转移│ │ 转移) │
└─────────┘ └─────────────┘ └────────────┘
│
▼
┌────────────┐
│ Cluster │
│ (分布式) │
│ 16384槽 │
│ 自动分片 │
└────────────┘
选型建议:
- 开发/测试: 单机
- 中小项目(需高可用): 哨兵(1主2从+3哨兵)
- 大项目(需水平扩展): Cluster(3主3从起步)
面试话术: "Redis持久化我们用混合模式,RDB做定期冷备AOF保证最多丢1秒。集群方案看规模:中小项目用哨兵模式自动故障转移,大项目用Cluster分布式存储。Cluster用16384个哈希槽分布数据,而不是65535,因为心跳包只需2KB而不是8KB。路由用CRC16(key)%16384算槽位,MOVED是永久迁移更新缓存,ASK是临时迁移不更新。"
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怎么选",请给出一个企业级的回答,包括两者都开启的方案。