故障切换 · XB 现场笔记

故障切换是一把演练过的开关

Thu, 25 Feb 2027 00:00:00 +0000

备用节点只有在提升路径可用、旧写者不能破坏新历史时才有价值。故障切换既是决策，也是流程与演练。副本看起来健康，不代表客户端能连上它，也不代表所有已确认写入都已经复制过去。先确定恢复时间目标与可接受的数据损失，再决定何时切换，而不是等报警响起才现场讨论。

提前设计好决定

确定谁有权批准提升、什么证据足以说明故障，以及由自动化还是操作员执行。心跳丢失可能是网络分区，而不是主库已经停止。故障检测本身不能授权两个独立写者。系统需要真正执行所有权边界的机制，例如经过确认的节点隔离，或存储端校验的 fencing，并使它与复制协议的保证相匹配。

单写者服务的安全目标是「最多一个被接受的写者」，并非每一瞬间都恰好有一个可用写者。隔离旧节点后、提升新节点前，暂时没有写者可能正是正确的停机选择。操作手册应写明候选节点、复制位置、可接受的丢失范围、客户端如何重连，以及前提不成立时由谁叫停。自动切换能缩短决策时间，却不能凭空补回尚未复制的数据。

演练真实经过的路径

根据风险决定演练频率，并在相关变更后重测。演练只能证明实际覆盖到的路径：绕过 DNS 的数据库提升不能验证地址缓存；测试客户端使用另一套身份，也不能证明生产权限正确。在安全前提下，加入真实的重连流程和已确认写入核对。记录范围、耗时、复制延迟、拒绝条件及恢复证据，不要把最近一次成功的日期当成完整的就绪评分。

开始前先安排安全停止点和恢复步骤。新主库一旦接受写入，切回旧节点往往就不再是撤销一项配置那么简单。旧主库可能需要对账或重建为副本，不能因为进程重新启动就恢复写权限。备份提供另一条恢复路径，但「有备份」本身也不等于已经验证能恢复。

坏掉的样子

旧主库在提升之后仍可写，就会产生脑裂。控制器里记录一句「已隔离」不够，存储或隔离机制必须真正阻止旧写入。落后的候选节点也可能在切换成功后丢失已确认写入。延迟阈值必须有明确单位，并与数据损失目标相连；允许非零延迟，不能同时宣称零数据丢失。

健康检查反复抖动会触发来回切换，应设置明确的故障判定和恢复条件，不要在重新同步之前自动切回。DNS 修改只影响后续查询：已有连接可能持续使用旧地址，按旧 TTL 缓存的回答也不会立刻消失。事故发生时调低 TTL，不能追溯缩短已经缓存的寿命。除了权威 DNS 的响应，还要验证真实客户端的重试、缓存和重连行为，否则控制台显示成功，用户路径仍可能失败。

快速验证

将下面内容保存为 failover_drill.py，在临时目录运行 python3 failover_drill.py。它只修改内存对象。健康状态和复制延迟是模拟值，fence() 只是更新集合，并不执行真实隔离。模型保留一个被指定的主节点，但隔离期间允许没有可写节点。候选节点通过检查后会被明确解除隔离，因此切回旧节点时不会出现「已经成为主库，却还留在隔离集合中」的自相矛盾状态。

"""Failover drill: single-primary switch with health and lag guards (stdlib only)."""
from dataclasses import dataclass

MAX_LAG = 128 # Synthetic units, not seconds or a zero-data-loss guarantee.

class FailoverRefused(Exception):
 pass

@dataclass
class Node:
 name: str
 healthy: bool = True
 lag: int = 0
 is_primary: bool = False

class Cluster:
 def __init__(self):
 self.nodes = {"a": Node("a", is_primary=True), "b": Node("b")}
 self.fenced: set[str] = set()

 @property
 def primary(self) -> str:
 primaries = [n for n in self.nodes.values() if n.is_primary]
 assert len(primaries) == 1, f"must keep exactly one primary, saw {[p.name for p in primaries]}"
 return primaries[0].name

 def can_write(self, name: str) -> bool:
 node = self.nodes[name]
 return node.is_primary and node.healthy and name not in self.fenced

 def health_check(self, name: str) -> bool:
 node = self.nodes[name]
 return node.healthy and node.lag <= MAX_LAG

 def fence(self, name: str) -> None:
 self.fenced.add(name)
 assert not self.can_write(name)

 def failover(self, target: str, *, fence_old: bool) -> str:
 old = self.primary
 if target == old:
 raise FailoverRefused("target is already primary")
 if target not in self.nodes:
 raise FailoverRefused(f"unknown target {target}")
 candidate = self.nodes[target]
 if not fence_old or old not in self.fenced:
 raise FailoverRefused(f"refuse: old primary {old} is not fenced; fence first to avoid split brain")
 if not candidate.healthy:
 raise FailoverRefused(f"refuse: standby {target} is unhealthy")
 if candidate.lag > MAX_LAG:
 raise FailoverRefused(f"refuse: standby {target} lags by {candidate.lag} (> {MAX_LAG})")
 self.nodes[old].is_primary = False
 # Model explicit reactivation after the old writer is fenced.
 self.fenced.discard(target)
 candidate.is_primary = True
 assert self.primary == target and self.can_write(target)
 assert sum(self.can_write(name) for name in self.nodes) <= 1
 return target

def expect_refused(fn, label: str) -> None:
 try:
 fn()
 except FailoverRefused as exc:
 print(f"refused as expected ({label}): {exc}")
 return
 raise AssertionError(f"should have refused: {label}")

def main() -> None:
 # 1. Clean drill: healthy standby, caught-up replica, old primary fenced.
 cluster = Cluster()
 assert cluster.primary == "a"
 assert cluster.health_check("b")
 cluster.fence("a")
 assert cluster.failover("b", fence_old=True) == "b"
 print("clean switch: a -> b")

 # 2. Refuse lag beyond this policy; even accepted positive lag may lose writes.
 cluster = Cluster()
 cluster.nodes["b"].lag = 900
 assert not cluster.health_check("b")
 cluster.fence("a")
 expect_refused(lambda: cluster.failover("b", fence_old=True), "stale replica")
 assert cluster.primary == "a"

 # 3. Unhealthy standby must not promote.
 cluster.nodes["b"].lag = 0
 cluster.nodes["b"].healthy = False
 expect_refused(lambda: cluster.failover("b", fence_old=True), "unhealthy standby")
 assert cluster.primary == "a"

 # 4. Unfenced old primary must block promotion (split-brain guard).
 cluster.nodes["b"].healthy = True
 unfenced = Cluster() # nobody fenced yet
 expect_refused(lambda: unfenced.failover("b", fence_old=False), "split brain")
 expect_refused(lambda: unfenced.failover("b", fence_old=True), "split brain without fence record")
 assert unfenced.primary == "a"

 # 5. Failback: resynchronize the candidate, then fence the CURRENT writer.
 cluster = Cluster()
 cluster.fence("a")
 cluster.failover("b", fence_old=True)
 cluster.nodes["a"].healthy = True
 cluster.nodes["a"].lag = 0
 cluster.fence("b")
 assert cluster.failover("a", fence_old=True) == "a"
 print("failback: b -> a")

 print("PASS: at most one writable node; 4 refusals + clean switch + failback passed")

if __name__ == "__main__":
 main()

输出包括一次正常切换、分属三类的四次拒绝，以及一次切回，最后为 PASS: at most one writable node; 4 refusals + clean switch + failback passed。拒绝提升会保留原有的主节点标记，但已经被隔离的旧主库仍不可写，并不代表服务自动恢复可用。正常切换与切回场景的延迟都是零；策略另外允许最多 128 个模拟单位的正延迟，这包含可能丢失数据的取舍，不应误读为真实数据库的推荐阈值。

旧版练习记录的环境是 macOS、Python 3.14.4；修订版在 Linux、Python 3.12.14 下通过断言。当前测试验证顺序执行的决策逻辑，也检查曾被隔离的目标节点是否真正恢复为可写。它不验证并发提升、真实复制、权限、DNS 传播、存储隔离或生产恢复。那些结论需要另外获准的预发布演练，使用实际机制和具有代表性的客户端；这个小模型不能替代它们。

来源

PostgreSQL 18：故障切换，旧主库隔离、重建冗余与书面切换流程，已核验 2026-10-15。
AWS：配置 DNS 故障切换，健康检查及路由配置，已核验 2026-10-15。
Google SRE：可靠性测试，生产测试范围、自动化防护与灾难恢复测试，已核验 2026-10-15。
AWS：记录 TTL，解析器缓存以及切换前的 TTL 调整，已核验 2026-10-15。

Redis Sentinel 协调主节点故障转移

Sat, 09 Jan 2027 00:00:00 +0000

Redis Sentinel 监督非 Cluster 的主从部署，并提供当前主节点地址。它不存储应用数据集，也不代理应用命令。主节点失败后自动提升副本，可以帮助恢复写入可用性，但服务发现、副本数据新鲜度、客户端重连以及阻止旧写者继续写入，仍然是不同的问题，不能由“有哨兵”三个字一并保证。

故障认定与选举授权是两道门

一个 Sentinel 在足够长时间收不到可接受回复后，会把实例标记为主观下线；达到配置的 quorum 都认为主节点不可达，才形成客观下线判断。这个故障判定阈值不等于故障转移领导者获得授权所需的多数。选举还必须达到配置的 quorum，因此将 quorum 设置得更高，也可能进一步提高授权门槛。

例如五个已知 Sentinel 配置 quorum 为二，两个观察者可以同意主节点发生故障，但授权提升仍需要三个构成多数。反过来，quorum 为一也不意味着三个已知观察者只剩一个时，它能独自授权。SENTINEL CKQUORUM 会检查这两项可达性条件；某个 Redis 进程看上去健康，并不能证明观察者满足条件。

稳健部署至少需要三个处在独立故障范围内的 Sentinel。同一台笔记本上的三个进程能测试协议行为，却会随整台机器一起失效。每个 Sentinel 还需要可写的配置文件，持久保存发现的拓扑与纪元状态；这些不是随时可以丢弃的普通静态配置，也应保护其中可能存放的认证材料。

提升副本不会阻止所有旧连接写入

Redis 使用异步复制，被选中的副本可能没有收到旧主已经确认的一条写入。网络分区时，留在旧主一侧的客户端甚至可能继续向它写入，而另一侧已经提升替代节点。Sentinel 协调选举，并不等于撤销所有旧连接的写权限，更不会把 Redis 自动变成强一致存储。

min-replicas-to-write、min-replicas-max-lag 等设置可以在复制健康度下降时限制写入，同时牺牲部分可用性；它们不是通用的隔离旧写者协议。仍需独立备份和明确的应用恢复规则。网络分区、复制落后和单纯杀死一个进程应分别验证，不能用其中一个结果替代其他情形。

客户端需要重新发现并建立连接

支持 Sentinel 的客户端先查询观察者拿到主节点地址，再直接连接 Redis。因此，它要处理暂时发现不到主节点、连接断开和角色改变。只认旧地址的客户端，不会因为某个哨兵已经更新答案就自动恢复；同样，写请求超时也不能证明操作从未执行。

下面的代码在发现新的主节点后，明确断开应用的旧连接池，再检查新连接。这样能够单独验证重连环节，而不是承诺故障转移对调用方完全不可见。切换窗口内不能盲目重复非幂等写操作，节点提升并没有替业务提供去重机制。

坏掉的样子

可达观察者不足、没有合格副本、Sentinel 状态文件不可写，或者通告的地址从客户端不可达，都可能阻止恢复。认证与网络规则需要分别允许观察者之间、观察者与 Redis、复制链路以及应用连接等必要路径。仅看到某个端口能回复 PING，并不说明这些链路都已配置正确。

应结合 CKQUORUM、副本健康、故障转移事件、发现结果和真实客户端操作监控。检测与选举都需要时间，过于激进的超时还可能把短暂停顿当成故障。应使用实际部署的客户端、拓扑和安全配置演练后，再对外承诺可接受的中断窗口。

快速验证

原有实验记录使用 macOS、Python 3.14.4、Redis 8.10.1 和 redis-py 8.1.0；本轮审阅没有重新执行服务实验，下面的结果说明保留原有观察范围。准备 POSIX 环境、C 编译器、make、curl、tar 与 Python 3.10 或更新版本。安装步骤仅用 libc 构建 Redis 核心，并把客户端装入临时虚拟环境。

redis_lab=$(mktemp -d)
curl --fail --location --output "$redis_lab/redis.tar.gz" https://download.redis.io/releases/redis-8.10.1.tar.gz
tar -xzf "$redis_lab/redis.tar.gz" -C "$redis_lab"
make -C "$redis_lab/redis-8.10.1" build redis -j2 MALLOC=libc
export REDIS_SERVER="$redis_lab/redis-8.10.1/src/redis-server"
python3 -m venv "$redis_lab/venv"
"$redis_lab/venv/bin/python" -m pip install redis==8.1.0

在同一个 shell 中，用 "$redis_lab/venv/bin/python" 运行代码。它在预先占位分配的回环端口上创建一个主节点、一个副本和三个 Sentinel，以私有 Unix socket 控制，并生成临时可写配置。数据库持久化关闭；只杀死自己创建的子进程，结束时关闭客户端、停止其余进程并清理测试目录。很短的检测参数仅用于实验，不是生产建议。

from contextlib import contextmanager, ExitStack
import os
from pathlib import Path
import signal
import socket
import subprocess
from tempfile import TemporaryDirectory
import time

import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
from redis.sentinel import MasterNotFoundError, Sentinel


def until(check):
 deadline = time.monotonic() + 20
 while not check():
 assert time.monotonic() < deadline, "Sentinel state did not converge"
 time.sleep(0.05)


@contextmanager
def instance(directory, port, monitor=None):
 directory.mkdir()
 endpoint = str(directory / "redis.sock")
 config = directory / "redis.conf"
 lines = ["bind 127.0.0.1", f"port {port}", "protected-mode yes",
 f"unixsocket {endpoint}", "unixsocketperm 700", f"dir {directory}"]
 if monitor is None:
 lines += ['save ""', "appendonly no"]
 else:
 lines += [f"sentinel monitor lab 127.0.0.1 {monitor} 2",
 "sentinel down-after-milliseconds lab 500",
 "sentinel failover-timeout lab 5000",
 "sentinel parallel-syncs lab 1",
 "sentinel announce-ip 127.0.0.1"]
 config.write_text("\n".join(lines) + "\n")
 command = [os.environ["REDIS_SERVER"], str(config)]
 if monitor is not None:
 command.append("--sentinel")
 client = redis.Redis(unix_socket_path=endpoint, decode_responses=False,
 socket_timeout=2, retry=Retry(NoBackoff(), 0))
 process = subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
 try:
 deadline = time.monotonic() + 5
 while True:
 assert process.poll() is None, "Redis exited during startup"
 try:
 if client.ping():
 break
 except redis.ConnectionError:
 assert time.monotonic() < deadline, "Redis did not start"
 time.sleep(0.02)
 assert client.info("server")["process_id"] == process.pid
 yield client, process
 finally:
 client.close()
 if process.poll() is None:
 process.terminate()
 try:
 _, errors = process.communicate(timeout=5)
 except subprocess.TimeoutExpired:
 process.kill()
 process.communicate()
 raise
 assert process.returncode in (0, -signal.SIGKILL), errors.decode()


def crash(process):
 assert process.poll() is None
 process.kill()
 assert process.wait(timeout=5) == -signal.SIGKILL


with TemporaryDirectory(prefix="redis-sentinel-", dir="/tmp") as directory, ExitStack() as stack:
 leases = [stack.enter_context(socket.socket()) for _ in range(5)]
 for lease in leases:
 lease.bind(("127.0.0.1", 0))
 ports = [lease.getsockname()[1] for lease in leases]
 nodes = []
 for index in range(5):
 leases[index].close()
 nodes.append(stack.enter_context(instance(
 Path(directory) / str(index), ports[index], ports[0] if index >= 2 else None,
 )))
 primary, replica = nodes[0][0], nodes[1][0]
 observers = [item[0] for item in nodes[2:]]
 assert replica.replicaof("127.0.0.1", ports[0])
 until(lambda: replica.info("replication")["master_link_status"] == "up")
 until(lambda: all(observer.sentinel_master("lab")["num-other-sentinels"] == 2
 and len(observer.execute_command("SENTINEL", "REPLICAS", "lab")) == 1
 for observer in observers))
 for observer in observers:
 assert observer.execute_command("SENTINEL", "CKQUORUM", "lab").startswith(b"OK 3 usable")
 with primary.client() as writer:
 assert writer.set("marker", "replicated-before-failure")
 assert writer.wait(1, 5000) == 1
 assert replica.get("marker") == b"replicated-before-failure"
 print("three Sentinels discover each other and a replica; WAIT confirms the fixture write")

 manager = Sentinel([("127.0.0.1", port) for port in ports[2:]],
 socket_timeout=1, retry=Retry(NoBackoff(), 0),
 sentinel_kwargs={"socket_timeout": 1, "retry": Retry(NoBackoff(), 0)})
 application = manager.master_for("lab")
 try:
 assert manager.discover_master("lab") == ("127.0.0.1", ports[0])
 assert application.get("marker") == b"replicated-before-failure"
 crash(nodes[0][1])
 try:
 primary.get("marker")
 except redis.ConnectionError:
 pass
 else:
 raise AssertionError("the original primary connection must fail")

 def switched():
 try:
 return (manager.discover_master("lab") == ("127.0.0.1", ports[1])
 and replica.info("replication")["role"] == "master")
 except MasterNotFoundError:
 return False

 until(switched)
 application.connection_pool.disconnect()
 assert application.get("marker") == b"replicated-before-failure"
 assert application.set("after-failover", "new-primary")
 assert replica.get("after-failover") == b"new-primary"
 print("automatic failover changes discovery; a reconnected client uses the promoted replica")
 finally:
 application.close()
 for sentinel_client in manager.sentinels:
 sentinel_client.close()

 for item in nodes[3:]:
 crash(item[1])
 until(lambda: len(observers[0].sentinel_sentinels("lab")) == 2
 and all(peer["is_sdown"] for peer in observers[0].sentinel_sentinels("lab")))
 assert observers[0].execute_command("SENTINEL", "SET", "lab", "quorum", 1) == b"OK"
 assert observers[0].sentinel_master("lab")["quorum"] == 1
 try:
 observers[0].execute_command("SENTINEL", "CKQUORUM", "lab")
 except redis.ResponseError as error:
 assert "majority" in str(error) and "specified quorum" not in str(error)
 print("one of three known Sentinels meets quorum=1 but cannot authorize failover")
 else:
 raise AssertionError("one surviving observer is not a majority of three")

实验先等待观察者互相发现且看见副本，再写入标记，并在同一条连接上检查 WAIT。主节点被杀后，原连接失败；查询发现结果能找到被提升的副本，重新连接的应用可以读取原标记，也能写入新数据。

最后再停止两个观察者，并故意把幸存者的 quorum 降为一。CKQUORUM 仍拒绝授权，因为三个已知观察者中只有一个可用，不构成多数。这检查的是诊断门槛，而不是再次尝试提升节点。WAIT 只确认本实验标记已获得复制应答，不证明磁盘持久性或强一致性。网络分区、副本阻塞、独立主机故障和生产恢复延迟仍未执行验证。

来源

Redis Sentinel，故障检测、授权、服务发现与分区风险，已核验 2026-09-08。
Redis 复制，异步复制与写入限制，已核验 2026-09-08。
Redis WAIT，连接范围内的复制应答与一致性边界，已核验 2026-09-08。
Redis 8.10.1 Sentinel 源码，独立的 quorum 与多数检查，已核验 2026-09-08。
redis-py 8.1.0 Sentinel 客户端，服务发现和主节点连接池，已核验 2026-09-08。
Redis 8.10.1 构建说明，仅构建核心与选择分配器，已核验 2026-09-08。

故障切换 · XB 现场笔记

故障切换是一把演练过的开关

提前设计好决定

演练真实经过的路径

坏掉的样子

快速验证

延伸阅读

来源

Redis Sentinel 协调主节点故障转移

故障认定与选举授权是两道门

提升副本不会阻止所有旧连接写入

客户端需要重新发现并建立连接

坏掉的样子

快速验证

来源