知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 可靠性与容错设计 > 导读:本文从"Agent 在本地跑得好好的,一上线就时不时任务失败;加了重试之后,任务确实更容易成功了,但数据却重复写了两遍"这个具体痛点出发,把分层重试、检查点与恢复、幂等性、多层超时、降级策略、错误传播控制这六件事讲透,最后给出工程实践与踩坑。适合正在把 Agent 接入真实业务、或需要回答"Agent 怎么保证可靠"的同学。 ## 一、先建立全局认知 ### Q:为什么 Agent 比普通程序更难保证可靠性? A:结论先行——因为 Agent 同时引入了三种不确定性:LLM 输出的随机性、外部工具调用的不稳定、以及多步骤错误的累积传播。普通程序"输入确定则输出确定",Agent 不满足这个前提。 ```text 普通程序: 输入确定 → 输出确定 错误有明确的类型和处理方式 Agent: LLM 输出有随机性(同样的输入可能有不同输出) 工具调用依赖外部服务(网络、API 都可能失败) 多步骤任务中,错误会累积和传播 很难预测 Agent 会走哪条路 ``` 关键点解读:这三条不确定性分别对应三种不同的兜底手段——**随机性靠"约束与校验"(限制路径、校验输出),外部不稳定靠"重试与超时",错误累积靠"检查点与降级"。** 把它们混在一起用一个 try/except 包起来,是可靠性设计最常见的失败模式。 ### Q:可靠性应该分成哪几层兜底? A:结论先行——五层:重试(恢复瞬时故障)、检查点(可续跑)、幂等(不重复副作用)、超时(不无限等待)、降级(总有备选)。顺序即优先级。  *图:五层兜底:重试、超时、幂等、检查点、降级* ```text 五层兜底(从局部到全局): 1. 重试 → 单次调用的瞬时故障 2. 超时 → 单次调用不能无限等待 3. 幂等 → 重试之后副作用不重复发生 4. 检查点 → 任务中断后能从断点续跑 5. 降级 → 主方案不可用时仍有次优结果 ``` 关键点解读:注意第 3 层的特殊位置——**幂等是"让重试变安全"的前提**。没有幂等就上重试,等价于给系统加了一个"重复副作用生成器"。这也解释了本文开头那个痛点:先加重试、后补幂等,顺序反了就会踩坑。 ### Q:可靠性设计的出发假设应该是什么? A:结论先行——假设"每一步都会失败"。基于这个假设,每个步骤都必须有明确的失败处理路径,而不是"正常情况下不会失败所以不用管"。 ```text 两种假设的差别: 乐观假设:"正常情况下不会失败" → 失败时只能抛异常、任务终止 悲观假设:"每一步都可能失败" → 每步都有重试/降级/跳过路径 → 失败成为"预期内的分支",而不是"意外" ``` 关键点解读:这个思维转变的工程价值在于——**失败处理从"异常路径"变成"正常路径"**,于是它会被设计、被测试、被监控。反之,只在异常里写 `print(e)` 然后继续,等于把失败静默掉了,这是最难排查的一类问题。 ### Q:可靠性要做到什么程度?有"够用"的标准吗? A:结论先行——有。可靠性应当由业务后果倒推,而不是"越高越好"。判断依据是"失败的代价"与"用户能否容忍降级",据此把任务分成三档,各配不同的兜底强度。 ```text 按后果分档决定投入: 高危(涉及资金、不可逆写操作) → 全套:幂等 + 检查点 + 人工确认 + 严格超时 中危(有副作用但可补偿) → 幂等 + 重试 + 降级,事后可修正 低危(只读、可重新生成) → 重试 + 超时即可,允许失败重跑 判断追问: 1. 失败了会产生不可逆后果吗? 2. 用户能接受"降级但可用"的结果吗? 3. 重跑的成本是否可接受? ``` 关键点解读:这组追问的意义在于避免两个极端——**一边是"所有任务都上全套冗余"(成本失控、开发迟缓),另一边是"所有任务都不做兜底"(一崩全崩)**。把可靠性当成"按后果分配的资源",才能与业务目标对齐。注意这里的档位划分是原则性的,具体阈值必须与业务方一起定义,而不是由工程方单方面拍定。 ## 二、重试策略 ### Q:指数退避重试怎么实现? A:结论先行——把重试参数(次数、初始延迟、最大延迟、退避底数、是否加抖动)收敛成配置对象,用一个通用函数执行"失败—等待—再试"的循环。 ```python import asyncio from dataclasses import dataclass @dataclass class RetryConfig: max_attempts: int = 3 base_delay: float = 1.0 # 初始等待时间(秒) max_delay: float = 60.0 # 最大等待时间 exponential_base: float = 2.0 # 指数退避的底数 jitter: bool = True # 是否加随机抖动(防止惊群效应) async def retry_with_backoff(func, config: RetryConfig, *args, **kwargs): """指数退避重试""" last_exception = None for attempt in range(config.max_attempts): try: return await func(*args, **kwargs) except Exception as e: last_exception = e if attempt == config.max_attempts - 1: break # 最后一次,不再等待 # 计算等待时间 delay = min( config.base_delay * (config.exponential_base ** attempt), config.max_delay ) if config.jitter: import random delay *= (0.5 + random.random()) # 加 ±50% 的随机抖动 print(f"第 {attempt+1} 次失败,{delay:.1f}s 后重试:{e}") await asyncio.sleep(delay) raise last_exception # 不同场景的重试配置 LLM_RETRY = RetryConfig(max_attempts=3, base_delay=2.0) TOOL_RETRY = RetryConfig(max_attempts=5, base_delay=1.0) CRITICAL_RETRY = RetryConfig(max_attempts=10, base_delay=0.5, max_delay=30) ``` 关键点解读:三个设计要点。第一,`max_delay` 是必须的——没有它,指数增长会很快把等待时间推到不可接受的量级。第二,**最后一次尝试不做等待**(`break`),避免为注定失败的调用白等一个周期。第三,抖动的实现是 `0.5 + random.random()`,即把等待时间在 50%~150% 之间随机化,这正是第 03 篇提到的"防止惊群"。注意这里的参数取值都是示意值,必须结合你的下游承载能力实测确定。 ### Q:不同场景的重试配置为什么不一样? A:结论先行——因为"失败的性质"和"重试的代价"不同:LLM 调用通常较慢且限流敏感,重试次数不宜多;工具调用便宜且多为瞬时故障,可以多试几次;关键步骤宁可多花时间也要成功。 | 场景 | 示例配置(示意) | 设计理由 | |---|---|---| | LLM 调用 | 少次数、较长初始延迟 | 失败多为限流,需要给足恢复窗口 | | 普通工具调用 | 较多次数、较短延迟 | 多为瞬时网络抖动,快速重试即可 | | 关键步骤 | 最多次数、较小上限 | 宁可多等,也不能丢结果 | 关键点解读:这张表的架构含义是——**重试策略应当是可以按调用点定制的策略,而不是一个全局常量。** 实践中常见的反模式是"全局重试 3 次",结果关键步骤不够、廉价步骤浪费。配置化之后,重试预算就成了可以按业务价值分配的稀缺资源。 ### Q:哪些错误该重试,哪些绝不该重试? A:结论先行——区分"环境性错误"与"语义性错误":前者(限流、超时、连接失败、服务暂时不可用)可重试;后者(认证失败、请求格式错误、权限不足、资源不存在)重试无效,应立即转入修复或降级。 ```python class RetryDecider: """决定是否应该重试""" # 可以重试的错误 RETRYABLE_ERRORS = { "RateLimitError", # API 限流 "TimeoutError", # 超时 "ConnectionError", # 网络连接失败 "ServiceUnavailable", # 服务暂时不可用 } # 不应该重试的错误 NON_RETRYABLE_ERRORS = { "AuthenticationError", # 认证失败(重试也没用) "InvalidRequestError", # 请求格式错误(需要修复) "PermissionDenied", # 权限不足 "NotFound", # 资源不存在 } @classmethod def should_retry(cls, error: Exception) -> bool: error_type = type(error).__name__ if error_type in cls.NON_RETRYABLE_ERRORS: return False if error_type in cls.RETRYABLE_ERRORS: return True # 默认:未知错误尝试重试 return True ``` 关键点解读:注意最后那个默认分支——**"未知错误默认重试"是一个刻意的保守选择**,但它有风险:如果未知错误其实是语义性的,重试只会浪费时间与配额。更稳的做法是给"未知错误"配一个很小的重试预算(例如只重试 1 次),既保留了容错,又限制了浪费。这段分类学与第 03 篇的工具错误三分类是同源思想,只是应用位置不同(一个在调用方,一个在工具内部)。 ### Q:重试会不会把下游打垮?怎么控制? A:结论先行——会。重试是"乘数",会把失败流量放大到下游;控制手段是全局重试预算、熔断与队列化,而不是各调用点各自为政地重试。 ```text 重试放大效应(示意): 上游 1 次请求 → 内层重试 3 次 → 外层再重试 3 次 → 最坏情况下游收到 9 次请求 若下游已经过载,这 9 次会让它更难恢复 三种控制手段: 1. 重试预算:给整个任务设"总重试次数"上限,用尽即降级 2. 熔断:连续失败达到阈值后,一段时间内不再重试(快速失败) 3. 队列化:把重试放入队列按速率消费,天然限流 ``` 关键点解读:多层重试相乘是一个极易被忽略的陷阱——**内层有重试、外层也有重试时,实际请求量是乘积关系**。设计时必须明确"重试只在哪一层做",通常建议只在最内层(单次调用)做,外层用"降级"而不是"再重试"。 ## 三、检查点与恢复 ### Q:为什么 Agent 必须有检查点? A:结论先行——因为 Agent 任务往往耗时且多步,途中任何一次失败都会让"前面的工作全部作废"。检查点(Checkpoint)把状态持久化,使任务可以从断点继续,而不是从零重跑。  *图:有无检查点对比:全部重来还是只补跑失败一步* ```text 无检查点: 跑了 18 步 → 第 19 步失败 → 全部重来 → 又跑 18 步 → 再失败 → 成本翻倍、体验极差 有检查点: 跑了 18 步 → 第 19 步失败 → 从第 19 步继续 → 只补跑失败的那一步 ``` 关键点解读:检查点的收益随步骤数增长而放大,所以它是"复杂任务专属"的投入——三五步的简单任务不值得为它搭持久化。判断是否引入检查点,看两个条件:**任务耗时是否长到重跑不可接受?步骤是否多到失败概率显著?** 两者任一成立就值得。 ### Q:用框架自带的检查点怎么做? A:结论先行——把"状态持久化"交给框架的 checkpointer,用 thread_id 标识一次任务,失败后传空输入即可从最近检查点继续。 ```python from langgraph.checkpoint.postgres import PostgresSaver # 使用 PostgreSQL 持久化检查点 checkpointer = PostgresSaver.from_conn_string(DATABASE_URL) app = graph.compile(checkpointer=checkpointer) # 每次执行都有唯一的 thread_id config = {"configurable": {"thread_id": "task_12345"}} # 第一次执行(可能中途失败) try: result = await app.ainvoke(initial_state, config) except Exception as e: print(f"执行失败:{e}") # 状态已自动保存到检查点 # 从检查点恢复(不需要重新开始) result = await app.ainvoke(None, config) # 传 None 表示从检查点继续 ``` 关键点解读:三个必须理解的点。第一,`thread_id` 是幂等恢复的关键——**同一个任务必须复用同一个 thread_id**,否则会新建一条执行线。第二,传 `None` 表示"接着上次跑",这是框架约定的语义,不是"没输入"。第三,检查点的持久化介质是有外部依赖的(这里是数据库),它的可用性直接决定恢复能力,本身也要做监控。注意不同框架的 checkpointer 实现与 API 有差异,接入前请以所选版本的官方文档为准。 ### Q:不用框架,怎么自己实现检查点? A:结论先行——把状态序列化后落盘或入库,每完成一步就保存一次,恢复时先尝试加载,完成后清理。 ```python import json import os class CheckpointManager: def __init__(self, checkpoint_dir: str): self.checkpoint_dir = checkpoint_dir os.makedirs(checkpoint_dir, exist_ok=True) def save(self, task_id: str, state: dict): """保存检查点""" path = os.path.join(self.checkpoint_dir, f"{task_id}.json") with open(path, "w") as f: json.dump(state, f, ensure_ascii=False, indent=2) def load(self, task_id: str) -> dict | None: """加载检查点""" path = os.path.join(self.checkpoint_dir, f"{task_id}.json") if os.path.exists(path): with open(path) as f: return json.load(f) return None def delete(self, task_id: str): """任务完成后删除检查点""" path = os.path.join(self.checkpoint_dir, f"{task_id}.json") if os.path.exists(path): os.remove(path) # 使用 checkpoint_mgr = CheckpointManager("./checkpoints") async def run_task_with_checkpoint(task_id: str, initial_state: dict): # 尝试从检查点恢复 state = checkpoint_mgr.load(task_id) or initial_state try: while not is_complete(state): state = await execute_step(state) checkpoint_mgr.save(task_id, state) # 每步保存 checkpoint_mgr.delete(task_id) # 完成后清理 return state except Exception as e: # 状态已保存,下次可以从这里继续 raise ``` 关键点解读:这份实现适合本地调试或轻量场景,但上生产前要正视它的三个不足:**写文件不是原子的**(崩溃时可能写出半截 JSON,应改为"写临时文件再重命名");**本地磁盘不共享**(多副本部署时无法跨实例恢复);**没有版本管理**(并发写会互相覆盖)。因此生产环境更推荐用数据库或对象存储,并配合乐观锁。另外注意"完成后删除"这个动作——如果删除失败,残留的检查点会在下次同名任务时造成"错误恢复",建议给检查点加过期时间。 ## 四、幂等性设计 ### Q:为什么 Agent 特别需要幂等? A:结论先行——因为 Agent 天然会重试、会重复规划、可能在恢复后重放某一步,而这些"重复"如果落到写操作上,就会产生重复副作用。幂等(Idempotency)保证"同样的操作执行多次,效果与执行一次相同"。 ```text Agent 中三种"重复"的来源: 1. 重试:同一次调用失败后被重发 2. 恢复:从检查点续跑时重放边界步骤 3. 规划抖动:LLM 在不同轮次给出相同的工具调用 共同结果:同一个写操作可能被执行多次 ``` 关键点解读:注意第 3 条——这不是故障,而是 Agent 的常态行为。所以幂等不是"防故障的补丁",而是"适配 Agent 工作方式的必要设计"。 ```python class IdempotentToolExecutor: """幂等工具执行器:相同的操作只执行一次""" def __init__(self, cache): self.cache = cache self.executed_operations = set() def make_operation_id(self, tool_name: str, args: dict) -> str: """生成操作的唯一 ID""" import hashlib, json content = f"{tool_name}:{json.dumps(args, sort_keys=True)}" return hashlib.sha256(content.encode()).hexdigest()[:16] async def execute(self, tool_name: str, args: dict, tool_func): op_id = self.make_operation_id(tool_name, args) # 检查是否已执行过 cached_result = await self.cache.get(op_id) if cached_result is not None: print(f"[幂等] 操作 {op_id} 已执行过,返回缓存结果") return cached_result # 执行工具 result = await tool_func(**args) # 缓存结果 await self.cache.set(op_id, result, ttl=3600) return result ``` 关键点解读:这段实现有一个必须说清的局限——**"先查后写"不是原子的**。两个并发的相同请求可能同时查到"未执行",然后各写一次。真正的强幂等要靠**唯一的业务键 + 数据库唯一约束**:让写入本身带一个 `operation_id` 唯一索引,重复写入触发唯一键冲突,此时把冲突当成"已执行"处理。上面的缓存方案适用于"并发度低、或副作用可容忍重复"的场景,属于弱幂等。这个区别在面试里经常被追问。 ### Q:幂等键应该怎么设计? A:结论先行——键要能唯一标识"同一次业务意图",与重试次数无关,且由业务字段稳定推导出来。用随机 ID 每次生成,等于没有幂等。 ```text 幂等键的设计原则: 1. 稳定:同一次业务意图,多次生成必须得到同一键 ✓ 由业务字段推导:task_id + step_id + 规范化参数 ✗ 每次调用随机生成 UUID(等于不幂等) 2. 粒度合适:太粗会误判(把两次真实操作当成一次) 太细会失效(发现不了重复) 3. 可保留:键要持久保存到"超过最大可能重试窗口" 4. 可观测:键要写进日志与追踪,便于复盘 ``` 关键点解读:第 1 条是最常被写错的。**很多人把"调用时生成的 UUID"当作幂等键传下去,结果每次重试都是新键,重复副作用照旧。** 正确做法是从业务语义中提取:例如"给订单 123 发货"就应该是 `order:123:ship`,而不是随机串。第 2 条的粒度问题则需要与业务方对齐——同一个订单"修改地址"和"取消订单"必须是两个不同的键。 ## 五、超时控制 ### Q:为什么超时要分层,只设一个总超时不够吗? A:结论先行——不够。单一的"整任务超时"只能保证不死等,无法定位"卡在哪一层",也无法给出针对性的恢复动作。分层超时能区分"是模型慢、工具慢,还是规划出了问题"。 ```python import asyncio class TimeoutController: def __init__(self): self.timeouts = { "llm_call": 30, # 单次 LLM 调用 "tool_call": 15, # 单次工具调用 "single_step": 60, # 单个步骤(LLM + 工具) "total_task": 300, # 整个任务 } async def with_timeout(self, coro, timeout_type: str): timeout = self.timeouts[timeout_type] try: return await asyncio.wait_for(coro, timeout=timeout) except asyncio.TimeoutError: raise TimeoutError( f"{timeout_type} 超时({timeout}s)," f"请考虑拆分任务或增加超时时间" ) # 使用 controller = TimeoutController() # LLM 调用超时 response = await controller.with_timeout( llm.ainvoke(messages), "llm_call" ) # 整个任务超时 result = await controller.with_timeout( run_agent(task), "total_task" ) ``` 关键点解读:这里的层级关系必须自洽——**内层超时之和应当小于外层超时**,否则外层会先触发,内层超时形同虚设。举例:单步超时 60 秒,则 LLM 调用 30 秒 + 工具调用 15 秒的组合是合理的;如果 LLM 超时设成 90 秒,那么"单步 60 秒"就永远先触发。表中的数值均为示意,必须结合你的模型响应分布与工具特性实测确定。 ### Q:超时之后应该重试还是终止? A:结论先行——取决于超时的性质:如果是"偶发慢"(如网络抖动导致的单次超时),重试通常有效;如果是"稳定慢"(任务本身超出预算),重试只会浪费更多时间,应转为降级或拆解任务。  *图:超时处理决策:偶发重试、连续降级、总任务返回部分结果* ```text 超时处理决策: 单次、偶发超时 → 重试(并确认没有产生半成品副作用) 同一调用连续超时 → 说明规模/复杂度不匹配 → 降级(换成更小的子任务 / 更简单的模型) → 或终止并提示用户拆分任务 总任务超时 → 直接返回部分结果(部分结果优于无结果) ``` 关键点解读:这里有一个隐蔽风险——**超时不代表没执行**。一个写操作可能已经在下游生效,只是响应没回来。所以"超时后重试写操作"必须先确认幂等键已带上,否则会造成重复写入。这是超时与幂等耦合的地方,也是把两者分开设计最容易出问题的点。 ## 六、降级策略与错误传播控制 ### Q:降级应该怎么设计? A:结论先行——设计一串"从好到差"的策略链,逐级尝试,任何一级成功即返回;全部失败时返回"部分结果 + 明确说明",而不是抛异常。 ```python class DegradationStrategy: """降级策略:当主方案失败时,尝试备选方案""" async def execute_with_fallback(self, task: str, state: dict) -> dict: strategies = [ self._try_full_agent, # 完整 Agent(最好) self._try_simplified_agent, # 简化 Agent(工具更少) self._try_direct_llm, # 直接 LLM(不用工具) self._return_partial_result, # 返回部分结果(最差但比没有好) ] for strategy in strategies: try: result = await strategy(task, state) if result: return result except Exception as e: print(f"策略 {strategy.__name__} 失败:{e},尝试下一个") # 所有策略都失败 return { "success": False, "message": "无法完成任务,请人工处理", "partial_results": state.get("intermediate_results", {}) } async def _try_full_agent(self, task, state): """完整 Agent,所有工具可用""" return await full_agent.ainvoke({"task": task, **state}) async def _try_simplified_agent(self, task, state): """简化 Agent,只用基础工具""" return await simple_agent.ainvoke({"task": task}) async def _try_direct_llm(self, task, state): """直接问 LLM,不调用工具""" response = await llm.ainvoke([ {"role": "user", "content": f"请尽力回答:{task}"} ]) return {"success": True, "result": response.content, "degraded": True} async def _return_partial_result(self, task, state): """返回已有的部分结果""" if state.get("intermediate_results"): return { "success": "partial", "result": state["intermediate_results"], "message": "任务未完全完成,以下是部分结果" } return None ``` 关键点解读:这份设计的精髓是**"降级也带标记"**——`degraded: True` 与 `success: "partial"` 让调用方能区分"完整成功"和"降级成功"。没有这个标记,上层就无法判断结果的可信度,降级反而成了"悄悄降质"。另外注意降级链的排序原则是**"能力递减、可信度递减"**:先试能力最强的,再试最保守的,最后兜底给部分结果——把顺序弄反,等于一有问题就退到最弱方案。 ### Q:多步骤任务里,一个步骤失败该怎么处理? A:结论先行——区分错误严重程度做"可控传播":可恢复错误记录并交给 LLM 决策,连续多次则升级为致命;致命错误直接抛出终止。关键是别让一个步骤的小错直接掀翻整个任务。 ```python class StepExecutor: """步骤执行器,控制错误传播""" def __init__(self, max_consecutive_errors=3): self.max_consecutive_errors = max_consecutive_errors self.consecutive_errors = 0 async def execute_step(self, step: dict, state: dict) -> dict: try: result = await self._do_execute(step, state) self.consecutive_errors = 0 # 成功后重置 return result except RecoverableError as e: # 可恢复的错误:记录并继续 self.consecutive_errors += 1 state["errors"].append(str(e)) if self.consecutive_errors >= self.max_consecutive_errors: raise FatalError(f"连续 {self.max_consecutive_errors} 次错误,任务终止") # 让 LLM 决定如何处理这个错误 return await self._handle_error_with_llm(e, step, state) except FatalError: raise # 致命错误直接抛出 async def _handle_error_with_llm(self, error, step, state): """让 LLM 决定如何从错误中恢复""" recovery_prompt = f""" 执行步骤时遇到错误:{error} 当前步骤:{step} 已完成的步骤:{state['completed_steps']} 请决定: 1. 跳过这个步骤继续 2. 用不同的方式重试 3. 修改后续计划 你的决定:""" response = await llm.ainvoke([{"role": "user", "content": recovery_prompt}]) return await self._execute_recovery_plan(response.content, state) ``` 关键点解读:这段代码体现了三个关键设计。第一,**`consecutive_errors` 只在成功时重置**——防的是"错一步、对一步、再错一步"的慢性劣化,连续失败才说明方向错了。第二,**错误恢复交给 LLM 是有条件的**:只在"可恢复"这一档才这么做,致命错误直接抛,避免模型"硬撑着继续"。第三,给 LLM 的三个选项是**封闭枚举**(跳过/换方式重试/改计划),而不是开放式追问,这样才能保证返回可控。 ### Q:什么时候"跳过"比"失败"更好? A:结论先行——当该步骤不是任务成功的关键路径、且缺失它不会导致错误结论时,跳过是对的;反之,如果它是关键路径,跳过只会产出一个"看起来成功、实际错误"的结果,比失败更糟。 ```text 判断"能否跳过"的两个问题: 1. 这一步的产物是否被后续步骤依赖? 依赖 → 不能盲目跳过(要么替代,要么终止) 2. 跳过之后,最终结果是否会"看起来对、实际错"? 会 → 宁可失败,也不要静默降质 更安全的做法: 跳过时在结果中显式标注 missing/failed 步骤, 让调用方与用户都看得见。 ``` 关键点解读:这里的原则可以概括为——**宁可显式失败,不可静默降质**。原因很简单:Agent 的输出常被直接消费,一个"缺少关键步骤但格式完整"的结果,危害远大于一次明确的失败。 ## 七、工程实践与踩坑 ### Q:可靠性改造中最常见的坑有哪些? A:结论先行——五类:重试早于幂等、检查点写非原子、超时层级不自洽、降级不标注、把异常静默吞掉。 ```text 坑 1:先加重试,后补幂等 后果:重试期间重复副作用 正确顺序:幂等 → 重试 坑 2:检查点非原子写入 后果:崩溃时产生半截状态,恢复即报错 修法:写临时文件再原子重命名 / 数据库事务 坑 3:超时层级不自洽 后果:内层超时永不触发,排查时误判 修法:内层之和 < 外层;上线前做一次校验 坑 4:降级不标注 后果:调用方误把降级结果当完整结果 修法:结果中带 degraded / partial 标记 坑 5:异常被吞掉 后果:日志里有错误、流程却"成功"结束 修法:区分"已处理"与"已吞掉",后者必须告警 ``` 关键点解读:坑 1 的顺序问题在本文开头就点明了,它是"改造顺序影响正确性"的典型例子。坑 5 最隐蔽——代码里一个 `except Exception: pass` 就能让整条可靠性链路失效,因为它让"失败"变成了"成功"。**在可靠性设计里,"看不见的失败"比"看得见的失败"危险得多。** ### Q:怎么验证可靠性设计真的生效? A:结论先行——用故障注入(Fault Injection)主动制造失败,验证每一层兜底是否按预期工作,而不是等线上出事。  *图:故障注入清单:五项要验证的容错能力* ```text 故障注入清单: □ 杀掉进程 → 检查点能否恢复?从哪一步恢复? □ 让工具超时 → 是否重试?重试是否带退避与抖动? □ 重复发同一次写请求 → 幂等键是否拦住? □ 让下游持续不可用 → 是否走到降级链?降级是否被标注? □ 制造连续 N 次错误 → 是否触发任务终止而不是无限重试? ``` 关键点解读:故障注入是可靠性工程里性价比最高的验证手段——它把一个"只能等线上出事才知道"的问题,变成一次可控实验。建议把它做成常规的回归测试,每次改动重试/超时/降级配置后都跑一遍。 ## 小结 - 一句话:**可靠性 = 重试(指数退避)+ 检查点(可恢复)+ 幂等(不重复执行)+ 超时(不无限等待)+ 降级(总有备选方案),每一层都要有兜底。** - 修正顺序很关键:先有幂等,再上重试;先能恢复,再谈优化。 - 重试必须配置化(次数、退避、上限、抖动),错误要区分"可重试"与"不可重试"。 - 检查点把"从零重跑"变成"从断点续跑";持久化介质本身也要监控。 - 幂等的强实现依赖唯一业务键 + 唯一约束;缓存式幂等只适用于弱一致场景。 - 多层超时要保证"内层之和小于外层",超时不等于未执行。 - 降级做成一串"能力递减"的策略链,且必须带降级标记。 - 错误传播要可控:连续失败升级为致命,可恢复错误交给 LLM 在封闭选项内决策。 - 宁可显式失败,不可静默降质。 ## 思考题 1. 重试与幂等的正确顺序是"先幂等后重试"。请举一个顺序反了会造成生产事故的具体例子,并说明如何补救。 2. 缓存式幂等(先查后写)在并发下有竞态。请描述用数据库唯一约束实现强幂等的完整流程,包括冲突时如何返回正确结果。 3. 多层超时的"内层之和小于外层"是一条硬约束。当某个工具的正常耗时波动很大时,你会如何设计超时,既不误杀又不失效? 4. 降级链里"直接问 LLM(不用工具)"这一档,在什么类型的任务上是可接受的?在什么类型上是有害的? 5. 如果任务的关键路径步骤失败了,但"跳过它"能让流程继续跑完,你会选择终止还是跳过?请给出你的判断依据与结果标注方式。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入