2024 年 11 月 16 日 · Redis 深度实践 04

客户端收到 SET 的 OK,接着主节点退出。这笔数据能不能回来?

如果回答是“有 AOF,所以能”,我还会继续问:有没有 fsync,文件在哪块盘上,故障切换会选哪个副本,备份上一次恢复是什么时候。这里的每个答案,都可能改变最后的结果。

我会把问题分成三段:本地怎么保存,副本跟到了哪里,故障后怎么找回正确的数据。 下面按 Redis 7.2.6 的实现展开,最后真的停一次进程、恢复一次快照。

先把“写成功”拆成不同的确认点

从命令执行到副本落盘的确认层次

普通 SET 返回 OK,首先说明命令已被当前服务端处理。它能否同时代表落盘,取决于持久化配置和具体确认机制。复制和持久化分别有自己的进度,不能只数“部署了几台机器”。

观察到的结果 能说明的事 还没有说明的事
SET 返回 OK 当前节点处理了写入 所有副本与磁盘都已保存
WAIT 返回 1 至少一个副本确认了本连接此前写入的复制进度 副本一定已 fsync、切换一定选它
WAITAOF 返回 [1,1] 本节点与至少一个副本确认了对应 AOF fsync 业务已经获得强一致系统
独立备份恢复成功 这份备份能恢复到验证过的状态 最后一次备份之后的写入也存在

WAIT 和 WAITAOF 都不是强一致开关,官方文档专门说明了这一点。WAIT、WAITAOF

我会先把允许的数据丢失窗口 RPO 和恢复时间 RTO 写出来。如果业务说“绝对不能丢、也不能停”,光靠几项 Redis 配置无法直接兑现,需要连同权威存储、故障模型和业务补偿一起设计。

RDB 是一个恢复点,AOF 是一条需要管理的写入历史

RDB 保存某个时间点的数据集。BGSAVE 通常由子进程生成文件,父进程继续接请求;副本和备份系统也可以利用快照。它适合形成清晰的恢复点,但快照之后的写入不会凭空出现在旧文件中。RDB 机制

AOF 则记录写入带来的变化。Redis 7.0 起采用多文件 AOF:manifest 维护 base 文件与增量文件的关系,base 文件还可能使用 RDB 格式。因此,在 7.2.6 上只寻找一个 appendonly.aof,很容易找错对象。AOF 配置与实现

常见起步配置如下,具体值需要按业务与磁盘验证:

1
2
3
4
5
6
appendonly yes
appendfsync everysec
no-appendfsync-on-rewrite no
aof-use-rdb-preamble yes
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

everysec 通常把未落盘窗口控制在约一秒的量级,但磁盘阻塞、系统调度等会让它偏离理想情况,不应写成“任何故障最多丢一秒”。always 追求更频繁的 fsync 确认,代价要测磁盘延迟;no 则把时机更多交给操作系统。

no-appendfsync-on-rewrite yes 会在重写相关阶段减少 fsync 干扰,同时放大数据风险窗口。我不会把它放进一份没有说明代价的“性能优化配置”。重写阈值也只是触发条件,不是最大 AOF 体积保证。

后台保存,仍然要给 fork 和写时复制留预算

子进程生成快照时,父子进程最初共享许多内存页;父进程继续写,修改过的页就可能产生写时复制。数据集越大、写入越活跃、后台操作越久,额外内存和延迟越值得关注。

这也是为什么“机器 16 GB,maxmemory 就设 15 GB”往往经不起一次重写。maxmemory 的淘汰统计口径和整台机器实际内存峰值并不是同一回事。Linux 上还要检查 overcommit、透明大页和换页情况,不能把 macOS 的本地结果当成 Linux 的内存行为。官方管理说明

我会在演练期间记录这些指标,而不是只看平均 CPU:

1
2
3
INFO persistence
INFO memory
INFO stats

重点对照 rdb_bgsave_in_progress、aof_rewrite_in_progress、rdb_last_bgsave_status、aof_last_bgrewrite_status、aof_last_write_status,再看 latest_fork_usec、COW 相关统计和磁盘时延。指标名称和口径可以查INFO 说明。

即便采用 AOF,也要保留独立备份。误删会被复制,也会继续进入日志;有副本不等于能回到误删之前。

复制延迟和落盘延迟,是两条进度线

Redis 主从复制默认异步。主节点处理完写入,不会因为每个副本都尚未处理完,就一律阻塞当前写请求。副本断线后,能否增量追赶,还取决于复制 ID、offset 和 backlog 是否覆盖缺口。复制说明

backlog 我会按复制流量估算:

1
backlog 预算 ≈ 峰值复制流量 × 希望覆盖的断连时间 × 余量

例如测得峰值复制流量约 5 MiB/s,希望覆盖 60 秒,基础就是 300 MiB,再考虑突发和测量误差。这里要用复制流量,而不是简单拿业务请求体大小相乘;副本追赶能力也要大于新增流量,否则保留再长仍追不上。

下面两项可以在健康副本不足时限制主节点继续接收写入:

1
2
min-replicas-to-write 1
min-replicas-max-lag 5

它检查满足条件的副本数量和延迟,能减少某些孤立主节点继续写入的窗口,但没有让每条写都同步落在一个副本上。副本或网络故障时拒绝写入,是它主动换来的可用性代价。配置解释

WAIT 和 WAITAOF,要跟写命令用同一条连接

这两个命令针对的是当前客户端连接之前的写入。连接池借出连接 A 完成 SET,再借连接 B 去 WAIT,不能假设检查的就是 A 的那笔写入。

在同一个交互式 redis-cli 会话中,可以这样观察:

1
2
3
SET invoice:42 paid
WAIT 1 3000
WAITAOF 1 1 5000

WAIT 返回达到复制进度的副本数量;WAITAOF 的两个数字分别对应本地和副本 AOF 的确认数量。超时后也会返回实际达到的数值,要检查是否满足自己的要求。0 超时表示无限等待,不适合随手放到有响应预算的接口里。

要等待副本 AOF,副本也必须启用 AOF,并正常跟进。把 WAITAOF 放进不能阻塞的事务或脚本上下文,它不会按普通阻塞方式等待。具体限制和行为以7.2 时期的命令文档为准。

如果要求没有达到,这笔写入也不因此撤销。应用拿到“确认不足”后,需要保留状态、查询或补偿;重试一笔非幂等操作,可能把结果执行两遍。

我真的停了进程,再分别从 AOF 和 RDB 恢复

实验启动一主一从,都开启 AOF、appendfsync everysec,随后按以下顺序执行:

  1. 写入 lab:invoice:42=paid,在同一连接执行 WAIT 和 WAITAOF。
  2. 完成 BGSAVE,把生成的 RDB 复制到独立恢复目录。
  3. 再写入 lab:after-snapshot=tail-write,等待本地 AOF fsync。
  4. 用 SIGKILL 停止主进程,再从原目录重新启动,检查 AOF 恢复。
  5. 在另一个目录、另一个端口,只加载那份 RDB,检查恢复点。

AOF 恢复与旧快照恢复的实验顺序

结果很直观:

检查项 本次结果
WAIT 1 3000 1
WAITAOF 1 1 5000 [1,1]
AOF 重启后 invoice paid
AOF 重启后快照之后的 Key tail-write
仅用 RDB 恢复 invoice paid
仅用 RDB 恢复快照之后的 Key 不存在

这个实验验证了进程崩溃后的恢复路径和快照边界。SIGKILL 没有关闭操作系统,更没有模拟断电、损坏磁盘或存储设备谎报写入完成,不能拿它证明所有故障下的数据保证。

WAIT、WAITAOF 与两种恢复路径的真实输出

运行方式与原始结果(见文末实验记录)如下,实验脚本还会检查 manifest 是否存在,并断言恢复值正确:

1
python3 lab/redis_lab.py durability --redis-server "$REDIS_LAB_SERVER"

真正能交接的,是一套验证过的恢复顺序

我会给恢复手册写明数据目录、配置、版本和依赖,保留最后一次验证的结果。只写“从备份恢复”五个字,值班同事仍然需要临场做太多决定。

备份、恢复、核验和业务放量的演练安排

恢复时,我会先隔离故障节点和写入流量,保护原始文件副本,再选择恢复点。在干净实例上加载备份,核对日志和数据,然后让应用用实际查询抽样验证。Key 数量相同,并不能证明值相同;还要检查关键值、TTL、业务序号和预期时间窗口。过期中的 Key 会变化,校验口径需要约定。

RDB 备份应在保存完成后复制,并保留校验和、生成时间与版本。多文件 AOF 要按同一时点的 manifest 和它引用的文件形成一致集合,不能趁正在重写时随意拷几个文件。备份还应离开实例所在的故障域,并定期在独立环境恢复。

遇到截断或损坏,先复制保留原件,再用对应版本的 redis-check-rdb、redis-check-aof 检查。带 --fix 的修复会改变文件,修复可能意味着丢弃尾部内容;不能直接对唯一一份原始数据下手。RDB 与 AOF 同时启用时,启动加载还要遵循对应配置和 AOF 的恢复路径。官方恢复说明

数据能否找回来,最后要由恢复结果回答。文件存在、复制在线、监控绿色,都是有用的信号;真正值得保留的是一次完整恢复的耗时、校验记录,以及业务确认过的缺失窗口。

实验环境与完整代码

先准备 Redis 7.2.6。以下操作只创建本机实验目录,需要 C 编译器、make 和 Python 3;Redis 实例仅监听回环地址。

1
2
3
4
5
6
7
8
9
10
11
mkdir -p /tmp/redis-deep-lab-build
cd /tmp/redis-deep-lab-build
curl -fLO https://download.redis.io/releases/redis-7.2.6.tar.gz
shasum -a 256 redis-7.2.6.tar.gz
# 应为 fb10d67a2fe2b4556f6cb840064dd6e6e3175ce8ca035f0726990ec2da9f3d0e
# 校验一致后再继续。
tar -xzf redis-7.2.6.tar.gz
cd redis-7.2.6
make -j4
export REDIS_LAB_SERVER="$PWD/src/redis-server"
export REDIS_LAB_CLI="$PWD/src/redis-cli"

在自己的实验项目中创建 lab/ 目录,把下面的 Python 代码保存为 lab/redis_lab.py,然后回到该项目根目录运行文中的命令。默认从 18379 端口开始;检测到已有服务会停止。脚本只关闭自己启动的进程,原始输出保存在项目的 assets/ 目录中。

展开本篇完整实验代码(Python 3,无第三方包)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
from pathlib import Path
import argparse, concurrent.futures, datetime, hashlib, json, os, platform
import random, shutil, signal, socket, statistics, subprocess, tempfile, threading, time

ROOT=Path(__file__).resolve().parents[1]

class RedisError(Exception): pass

class Client:
def __init__(self,port):
self.sock=socket.create_connection(('127.0.0.1',port),timeout=8)
self.file=self.sock.makefile('rb')
@staticmethod
def encode(args):
parts=[a if isinstance(a,bytes) else str(a).encode() for a in args]
return b'*'+str(len(parts)).encode()+b'\r\n'+b''.join(b'$'+str(len(x)).encode()+b'\r\n'+x+b'\r\n' for x in parts)
def read(self):
line=self.file.readline()
if not line: raise ConnectionError('Redis 连接已关闭')
kind=line[:1];data=line[1:-2]
if kind==b'+':return data.decode()
if kind==b'-':return RedisError(data.decode())
if kind==b':':return int(data)
n=int(data)
if n==-1:return None
if kind==b'$':
value=self.file.read(n);assert self.file.read(2)==b'\r\n';return value.decode()
if kind==b'*':return [self.read() for _ in range(n)]
raise ValueError(line)
def cmd(self,*args):
self.sock.sendall(self.encode(args));value=self.read()
if isinstance(value,RedisError):raise value
return value
def pipeline(self,commands):
self.sock.sendall(b''.join(self.encode(args) for args in commands))
return [self.read() for _ in commands]
def close(self):self.file.close();self.sock.close()
def __enter__(self):return self
def __exit__(self,*_):self.close()

def fields(raw):return dict(line.split(':',1) for line in raw.splitlines() if ':' in line and not line.startswith('#'))

def until(predicate,seconds=12):
start=time.monotonic()
while time.monotonic()-start<seconds:
try:
result=predicate()
if result:return result
except (OSError,RedisError,ConnectionError):pass
time.sleep(.05)
raise TimeoutError('实验等待条件未满足')

class Sandbox:
def __init__(self,binary,port):
self.binary=Path(binary).resolve();self.cli=self.binary.with_name('redis-cli');self.port=port
self.work=Path(tempfile.mkdtemp(prefix='redis-editorial-'));self.processes={}
version=subprocess.check_output([str(self.binary),'--version'],text=True)
assert 'v=7.2.6 ' in version, '必须指定 Redis 7.2.6'
self.version=version.strip()
def start(self,port,extra='',directory=None):
directory=directory or self.work/str(port);directory.mkdir(parents=True,exist_ok=True)
# 拒绝占用已有 Redis;不向其他进程发送任何写入或关闭命令。
with socket.socket() as check:
check.settimeout(.2)
if check.connect_ex(('127.0.0.1',port))==0:
raise RuntimeError(f'端口 {port} 已有监听进程')
with socket.socket() as probe:
probe.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
probe.bind(('127.0.0.1',port))
config=directory/'redis.conf'
config.write_text(f'bind 127.0.0.1\nprotected-mode yes\nport {port}\ndaemonize no\ndir "{directory}"\nsave ""\nappendonly no\nlogfile "{directory}/redis.log"\n'+extra+'\n')
process=subprocess.Popen([str(self.binary),str(config)],stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
self.processes[port]=process
def ready():
if process.poll() is not None:raise RuntimeError((directory/'redis.log').read_text())
with Client(port) as c:return c.cmd('PING')=='PONG'
until(ready)
return directory
def stop(self,port,kill=False):
process=self.processes.pop(port)
process.kill() if kill else process.terminate()
process.wait(timeout=8)
def close(self):
for port in list(self.processes):self.stop(port)
def __enter__(self):return self
def __exit__(self,*_):self.close()

def durability(s):
primary=s.port;replica=primary+1;restore=primary+2
pdir=s.start(primary,'appendonly yes\nappendfsync everysec')
s.start(replica,f'appendonly yes\nappendfsync everysec\nreplicaof 127.0.0.1 {primary}')
def ready():
with Client(replica) as c:return fields(c.cmd('INFO','replication')).get('master_link_status')=='up'
until(ready,20)
with Client(primary) as c:
c.cmd('SET','lab:invoice:42','paid')
wait=c.cmd('WAIT',1,3000)
fsync=c.cmd('WAITAOF',1,1,5000)
assert wait>=1 and fsync[0]>=1 and fsync[1]>=1
c.cmd('BGSAVE')
until(lambda: (pdir/'dump.rdb').exists() and fields(c.cmd('INFO','persistence')).get('rdb_bgsave_in_progress')=='0')
snap=s.work/'rdb-copy';snap.mkdir();shutil.copy2(pdir/'dump.rdb',snap/'dump.rdb')
c.cmd('SET','lab:after-snapshot','tail-write')
assert c.cmd('WAITAOF',1,0,5000)[0]==1
s.stop(primary,kill=True)
s.start(primary,'appendonly yes\nappendfsync everysec',pdir)
with Client(primary) as c:
aof_restored=c.cmd('GET','lab:invoice:42');aof_tail=c.cmd('GET','lab:after-snapshot')
info=fields(c.cmd('INFO','persistence'))
s.start(restore,directory=snap)
with Client(restore) as c:
rdb_restored=c.cmd('GET','lab:invoice:42');rdb_tail=c.cmd('GET','lab:after-snapshot')
result={'WAIT':wait,'WAITAOF':fsync,'primary_crash':'SIGKILL 后同目录重启','aof_restored_invoice':aof_restored,'aof_restored_tail':aof_tail,'rdb_restored_invoice':rdb_restored,'rdb_tail_absent':rdb_tail is None,'aof_manifest_exists':(pdir/'appendonlydir/appendonly.aof.manifest').exists(),'aof_last_write_status':info['aof_last_write_status'],'scope':'单机进程崩溃;没有模拟断电、磁盘故障或跨机房切换'}
assert aof_restored=='paid' and aof_tail=='tail-write' and rdb_restored=='paid' and rdb_tail is None
return result

def main():
parser=argparse.ArgumentParser();parser.add_argument('experiment',choices=['durability','all']);parser.add_argument('--redis-server',default='/private/tmp/redis-editorial-7.2.6/redis-7.2.6/src/redis-server');parser.add_argument('--base-port',type=int,default=18379);args=parser.parse_args()
experiments=[('durability', '04-durability')]
for name,slug in experiments:
if args.experiment not in ('all',name):continue
dest=ROOT/'assets'/slug;dest.mkdir(parents=True,exist_ok=True)
with Sandbox(args.redis_server,args.base_port) as sandbox:
result=globals()[name](sandbox)
record={'experiment':name,'executed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'runtime':sandbox.version,'os':platform.platform(),'architecture':platform.machine(),'work_directory':str(sandbox.work),'command':f'python3 lab/redis_lab.py {name} --redis-server /path/to/redis-7.2.6/src/redis-server','result':result}
(dest/'result.json').write_text(json.dumps(record,ensure_ascii=False,indent=2))
transcript=sandbox.version+'\n$ '+record['command']+'\n\n'+json.dumps(result,ensure_ascii=False,indent=2)+'\n'
(dest/'execution.txt').write_text(transcript)
print(json.dumps({'experiment':name,'result':result},ensure_ascii=False),flush=True)
# Redis 日志和实际配置留档;不包含凭据。
logs=ROOT/'lab/logs'/slug;logs.mkdir(parents=True,exist_ok=True)
for file in sandbox.work.glob('*/redis.*'):
if file.suffix in ('.log','.conf'):shutil.copy2(file,logs/(file.parent.name+'-'+file.name))

if __name__=='__main__':main()
展开本篇实验记录
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
"WAIT": 1,
"WAITAOF": [
1,
1
],
"primary_crash": "SIGKILL 后同目录重启",
"aof_restored_invoice": "paid",
"aof_restored_tail": "tail-write",
"rdb_restored_invoice": "paid",
"rdb_tail_absent": true,
"aof_manifest_exists": true,
"aof_last_write_status": "ok",
"scope": "单机进程崩溃;没有模拟断电、磁盘故障或跨机房切换"
}

资料与阅读顺序