Skip to content

高可用:冗余、故障域与多活容灾 ​

本篇要点:能把“我们要四个九”翻译成每年 52.6 分钟的预算,能画出系统的故障域边界,能用切换实验测出真实的 RTO 而不是会议室里估出来的数字。前置:《数据一致性:缓存双写与最终一致》处理了副本之间“暂时不一样”,这一章处理副本所在的那台机器、那个机柜、那座机房直接没了。

一、为什么需要它 ​

2026 年 1 月,一个做 SaaS 客服系统的团队做了一次演练。他们的架构图上写着“数据库高可用:主从 + 自动切换”,用了三年没出事。

演练方式很简单:在业务低峰期直接 kill -9 主库进程,然后开秒表看用户多久能恢复。结果是这样:第 12 秒应用侧开始报错,第 40 秒切换完成,但用户到第 6 分钟还在报错。原因不在数据库——连接池里的连接全部指向旧主库的 IP,池子重连要等超时;故障转移后新主库的地址变了,而应用侧配的是域名,DNS 记录的 TTL 是 300 秒。

这个案例里有两个数字要分开看。组件层面的恢复时间是 40 秒,用户感知的恢复时间是 6 分钟。前者是 DBA 汇报的数字,后者才是可用性预算真正消耗掉的数字。做高可用最容易被跳过的一步,是把“我以为的恢复时间”和“用户实际等了多久”放在一起量。

还有一个更隐蔽的问题:他们的主库和从库在同一个机柜。那个机柜的交换机坏掉时,主从一起掉线,“自动切换”没有东西可切。冗余做在了机器层面,故障域却还是机柜。

截至 2026 年 11 月的坐标:Redis 8.2.2(8.x 最新线 8.10.3)、MySQL 8.4.6、Chaos Mesh 2.8.8(2026-11-06 发布)。下面所有秒数都是我在一台 Mac 上用本机进程测出来的,测的是机制本身的耗时结构,生产环境会加上网络与调度开销。

二、核心概念 ​

2.1 可用性等级与 RTO、RPO ​

可用性(availability)在工程上通常写成“几个九”,它是可测量的:统计周期内可用时间除以总时间。四个九不是形容词,是每年 52.6 分钟。

两个常与它一起出现的词决定了故障时的行为:

  • RTO(recovery time objective,恢复时间目标):从故障发生到服务恢复,最多允许多久。
  • RPO(recovery point objective,恢复点目标):最多允许多少数据丢掉,通常换算成“时间点”——RPO = 0 意味着任何已确认的写入都不能丢,RPO = 5 分钟意味着可以退回到 5 分钟前的状态。
可用性每年不可用每月不可用这个档位通常靠什么达到
99%87.60 小时438.0 分钟单机 + 人工重启
99.9%8.76 小时43.8 分钟主从 + 自动切换
99.95%4.38 小时21.9 分钟多可用区(AWS RDS Multi-AZ 的 SLA 承诺线)
99.99%52.6 分钟4.4 分钟同城双活 + 秒级切流
99.999%5.3 分钟0.4 分钟异地多活 + 常态化演练

表 6-1 五档可用性对应的停机预算与常见达成手段

表里 99.95% 那一行不是随口写的:截至 2026 年 11 月,AWS 的 RDS SLA 对 Multi-AZ 实例承诺 99.95% 月度可用性,对单实例承诺 99.5%,低于承诺按比例给服务积分。各家条款会改,签字前以官网原文为准。这张表可以直接反过来用——承诺四个九,就得有支撑 4.4 分钟/月的能力,靠人工介入的流程不可能做到。

2.2 冗余的组合方式:串联拉低、并联拉高 ​

冗余(redundancy)的效果不能拍脑袋估,要按组合方式算。系统由多个组件串联而成,总可用性是各段相乘;同一层部署两份、任意一份可用即可,是并联。

反例:一个“高可用”链路上有网关、应用、数据库三段,每段都是 99.9%。串联之后总可用性 99.70030%,折算下来每年 26.25 小时——比任何单个组件都差。加机器不会让串联链路变好,只会让并联段变好。

2.3 故障域 ​

故障域(failure domain)是“一次故障能同时打掉的范围”。机柜、可用区、region、同一个网络分区、同一个 Kubernetes 节点、同一个上游依赖,都是故障域。

划故障域的方法是问一句:“这个故障发生时,哪些东西会一起没?”主从同机柜,故障域是机柜,冗余形同虚设;主从跨可用区,故障域才是机器。同一个团队经常在“跨可用区”上做对,却在“同一个配置中心”“同一个 DNS”“同一条专线”上做错——故障域不只看机器。

2.4 同城双活与异地多活 ​

同城双活(active-active in one city)指两个可用区同时承接流量,通常共享一份数据的主副本,故障时靠切流。它的 RPO 接近 0,RTO 在秒到分钟级,代价是两个机房的网络延迟进了关键路径。

异地多活(multi-region active-active)指两个地理上分开的 region 都承接写流量。它解决的是 region 级故障,代价立刻变复杂:跨 region 延迟变成几十毫秒,写冲突需要业务层面解决,数据同步不再是“主从”,而是双向且要处理幂等与顺回。

判断顺序应该是:先确认 RTO 和 RPO 的要求,再看故障域够不够隔离,最后才决定要不要付异地多活的代价。

图 6-1 从可用性目标推到部署形态的判断链,每一步都可能得出“当前方案不成立”

如图 6-1 所示,两个分支最后都会绕回“故障域”这一步。跳过它直接上异地多活,是把最贵的手段用在了最不该省的地方。图上每个判断点都可能得出“当前方案不成立”,这正是这条决策链的用处:在花钱之前先发现漏了一层。

2.5 演练与混沌工程 ​

演练(failover drill)是按剧本执行一次切换,验证“步骤对不对、时间够不够”。混沌工程(chaos engineering)是在受控条件下注入故障,观察系统在不完整信息下的真实反应。两者都做同一件事:把“我以为”换成“我测过”。

三、动手实践 ​

三个实验分别对应预算、组件级 RTO 和数据安全边界。环境:本机 Redis 8.2.2(主 6389、从 6390、Sentinel 26389)、MySQL 8.4.6(端口 3406,从库 3407),客户端 Python 3.14 + redis 8.1.0。

3.1 把“几个九”算成分钟 ​

python
YEAR_MIN = 365 * 24 * 60
def human(m):
    return f"{m/60:.2f} 小时/年" if m >= 60 else f"{m:.1f} 分钟/年"

for k, v in [("99%",0.99),("99.9%",0.999),("99.95%",0.9995),
             ("99.99%",0.9999),("99.999%",0.99999)]:
    m = YEAR_MIN * (1 - v)
    print(f"{k:>9}  {human(m):>13}   每月 {m/12:6.1f} 分钟")

for label, p in [("串联 3 个 99.9%", 0.999**3), ("串联 5 个 99.9%", 0.999**5),
                 ("并联 2 个 99.9%", 1-(1-0.999)**2), ("并联 2 个 99%", 1-(1-0.99)**2)]:
    print(f"{label:16s} 可用性 {p*100:9.5f}%  ->  不可用 {human(YEAR_MIN*(1-p))}")

运行结果:

text
      99%    87.60 小时/年   每月  438.0 分钟
    99.9%     8.76 小时/年   每月   43.8 分钟
   99.95%     4.38 小时/年   每月   21.9 分钟
  99.99%    52.6 分钟/年   每月    4.4 分钟
 99.999%     5.3 分钟/年   每月    0.4 分钟
串联 3 个 99.9%     可用性  99.70030%  ->  不可用 26.25 小时/年
串联 5 个 99.9%     可用性  99.50100%  ->  不可用 43.71 小时/年
并联 2 个 99.9%     可用性  99.99990%  ->  不可用 0.5 分钟/年
并联 2 个 99%       可用性  99.99000%  ->  不可用 52.6 分钟/年

这两组数字的对比是整个文章的重心:串联三个 99.9% 的组件,你得到一个 99.70030% 的系统;并联两个 99.9% 的实例,你得到 99.99990%。目标定错位置,加多少机器都补不回来。

3.2 实测一次自动切换要多久 ​

搭好一主一从和 Sentinel,配置 sentinel down-after-milliseconds mymaster 3000,然后直接杀掉主库进程,用客户端视角记录“从杀进程到新主库可写”的时间:

python
def sentinel_master_port():
    s = redis.Redis(port=26389, socket_timeout=0.5)
    addr = s.execute_command("SENTINEL", "get-master-addr-by-name", "mymaster")
    return int(addr[1])

def writable(port):
    try:
        c = redis.Redis(port=port, socket_connect_timeout=0.3, socket_timeout=0.3)
        c.set("probe", "1")
        return c.get("probe") == b"1"
    except Exception:
        return False

pid = subprocess.run(["pgrep", "-f", "redis-server \\*:6389"],
                     capture_output=True, text=True).stdout.split()
t0 = time.time()
subprocess.run(["kill", "-9", pid[0]])          # 模拟进程崩溃

ok_at = None
while time.time() - t0 < 25:
    try:
        p = sentinel_master_port()
    except Exception:
        p = None
    if p == 6390 and writable(p):
        ok_at = time.time() - t0
        break
    time.sleep(0.05)
print(f"新主库 6390 在 t={ok_at:.2f}s 起可写")

运行结果:

text
切换前 Sentinel 报告的 master 端口: 6389
t=0 杀掉 6389(pid 53161),sentinel down-after-milliseconds=3000
新主库 6390 在 t=4.20s 起可写
客户端不可用时长 ≈ 4.20s,其中 3.00s 是 down-after 判定,其余是选举与提升

4.20 秒里,3.00 秒纯粹是在等判定——Sentinel 必须确认主库真的死了,才敢提升从库,否则会出现两个主库。这个参数是可以调的,往小调换更快的切换,代价是网络抖动时更容易误判。剩下的 1.20 秒是 Sentinel 之间的投票和从库提升。

这不只是 Redis 的特性,是所有自动切换的共同结构:判定时间 + 执行时间。你能压缩的往往只有执行时间。

3.3 没有从库时,切换根本不会发生 ​

把从库关掉,同样的杀主库动作(sentinel_master_port() 沿用 3.2 节的定义):

python
pid = subprocess.run(["pgrep", "-f", "redis-server \\*:6389"],
                     capture_output=True, text=True).stdout.split()
t0 = time.time()
subprocess.run(["kill", "-9", pid[0]])
last = None
while time.time() - t0 < 30:
    p = sentinel_master_port()
    if p != last:
        print(f"  t={time.time()-t0:5.2f}s  Sentinel 报告的 master 端口 = {p}")
        last = p
    time.sleep(0.2)

运行结果:

text
t=0 杀掉唯一实例(无从库)
  t= 0.02s  Sentinel 报告的 master 端口 = 6389
30 秒内没有可提升的从库,服务一直不可用

Sentinel 一直指向那个已经死掉的端口,不报新地址,也不放弃。这个实验说明一件容易被架构图掩盖的事:自动切换的前提是有一个可以切过去的副本,而且它不在同一个故障域里。主从同机柜的团队,故障时面对的和这个实验一模一样。

顺带把数据安全也测了。MySQL 8.4 装好 semisync_source.so、从库装好 semisync_replica.so 并打开 rpl_semi_sync_replica_enabled,主库设 rpl_semi_sync_source_timeout=2000。先测正常情况,三次提交各 real 0.01,状态位是 ON,yes_tx 累计到 4。

然后用 kill -STOP 冻结从库进程——TCP 连接还在,但它不再回确认,这是最接近“从库卡死”的故障形态。下面是三次提交的计时与状态位:

运行结果:

text
real 2.03     # 第一次提交:卡满 2 秒超时
real 0.02     # 第二次:立刻返回
real 0.01     # 第三次:立刻返回

Rpl_semi_sync_source_status = OFF
Rpl_semi_sync_source_no_tx  = 3
Rpl_semi_sync_source_yes_tx = 4

只有第一次付出了 2 秒的代价,之后全部走异步。这就是半同步的退化路径:慢一次,然后快,但不再同步。 no_tx 从 0 涨到 3、status 变 OFF,是这件事留下的全部痕迹。

kill -CONT 恢复从库后等 5 秒再提交,status 自己回到了 ON,yes_tx 涨到 5。也就是说这套状态会自愈,但自愈需要一个前提:主库得重新检测到有从库在响应。默认超时是 10000 毫秒,用默认值时那一下卡顿是 10 秒,而 DOWN 状态持续多久完全取决于从库什么时候回来。

四、常见误解 ​

误解一:部署了主从就是高可用。 主从解决的是“数据有第二份”,不解决“故障时自动切过去”。要同时具备三件事:副本在不同的故障域、有自动判定与提升机制、客户端能找到新地址。上面第 3 个实验里,Sentinel 配置齐全,只因为没有一个可提升的副本,30 秒过去服务仍然不可用。

误解二:RTO 是可以直接承诺的数字。 组件级切换 4.20 秒,用户级恢复可能要 6 分钟。中间的距离是连接池重连、DNS TTL、负载均衡健康检查周期、客户端的重试退避。承诺 RTO 前必须端到端测一次,测量起点是用户第一次看到错误,终点是用户第一次成功。只测数据库,测出来的那个数字只能用于内部汇报。

误解三:多活就是两地各部署一套、前面挂个 DNS 轮询。 那叫双机房部署,不叫多活。真多活要回答三个问题:写请求落在哪个 region、两个 region 同时修改同一条记录时以谁为准、某个 region 断网后如何避免两个主库同时接受写入(脑裂)。第三个问题最致命——网络分区时,两边都认为对方挂了,都继续写,恢复后数据无法合并。解决它要么引入仲裁(多数派决定谁能写),要么把写按用户或租户分片,让同一条数据永远只有一个可写 region。

五、小结 ​

《数据一致性:缓存双写与最终一致》我们把副本之间的一致性收进了可测量的范围,这一章把故障范围放大到了机房级别。

  1. 四个九是每年 52.6 分钟,三个九是 8.76 小时。可用性目标先换算成停机预算,再决定投入。
  2. 串联拉低、并联拉高:三个 99.9% 串联得到 99.70030%(每年 26.25 小时),两个 99.9% 并联得到 99.99990%(每年 0.5 分钟)。优化要打在并联段上。
  3. 实测 Redis Sentinel 切换 4.20 秒,其中 3.00 秒是 down-after-milliseconds 的故障判定。判定时间不能压到 0,否则换来误判。
  4. 没有可提升的副本就没有自动切换,哪怕 Sentinel 配置齐全。故障域要按“会一起没”来划,主从同机柜等于没冗余。
  5. MySQL 半同步在超时后退回异步:实测第一次提交卡 2.03 秒,之后 0.01 秒返回,状态位变 OFF、no_tx 涨到 3。退化只留下这两个状态位做证据,从库恢复后状态会自己回到 ON。
  6. 组件级 RTO 不等于用户级 RTO。连接池、DNS TTL、健康检查周期都会加在用户等待时间里。

六、相关文章 ​

相关文章处理流量的入口:接口契约怎么定、网关承担哪些职责、鉴权限流放在哪一层、版本怎么演进而不把老客户端打死。切流这件事最终也落在入口上,前面讨论的 RTO 能不能兑现,取决于入口有没有能力把流量干净地切走。

继续阅读:[《接口与流量入口设计》 接口与流量入口设计](/guide/architecture/api-design-and-gateway.html)