摘要 :告警体系最常见的失败不是"没配告警",而是配了 47 条规则、每次故障推 1800 条消息,最后值班同学把群静音,真故障在静音期间被彻底漏掉 。本文围绕一次真实的告警风暴事故,讲清四件事:告警分级的判据 (用户可感知 / 可自愈 / 需人工,三个问题定级);降噪的四个手段 (去重、抑制、聚合、依赖抑制,以及为什么"只做聚合"必然不够);Agent 特有的四类告警 (成本、质量漂移、循环、降级生效,以及它们各自的特殊之处------尤其是为什么质量告警不能用绝对阈值);值班排班与 runbook 的关系 。核心判断只有一句:没有 runbook 的告警等于噪音。 一条告警如果不能回答"收到后第一步做什么",它就不该存在------无论它背后的指标多有道理。
📌 版本声明 :本文基于 Python 3.11+、Prometheus + Alertmanager 告警模型 编写,撰写时间 2026 年 10 月。告警规则用 PromQL 表达,降噪机制按 Alertmanager 的 dedup / group / inhibit / silence 四类能力设计,换用其他告警平台时概念可平移。指标定义依赖第 49 篇的埋点体系,成本与质量指标分别衔接第 45 篇与第 36 篇,循环与降级告警对应第 46 篇与第 38 篇。各平台的告警语法与能力边界请以官方文档为准。
适用边界 :适用于已有第 49 篇所述监控埋点、且开始有真实值班压力 的 Agent 服务。如果你还在"只有一两个人开发、出问题自己看日志"的阶段,本文的超前部分(排班、升级策略)可以跳过,但第二、四章的分级与降噪应该在第一次告警风暴之前就做 。另外,本文不讨论告警通道本身的可用性(电话、短信、IM 的冗余设计),那属于基础设施范畴。
文章目录
-
- 一、为什么告警会变成噪音
-
- [1.1 一次事故:1847 条告警与一个被静音的群](#1.1 一次事故:1847 条告警与一个被静音的群)
- [1.2 改造后的效果](#1.2 改造后的效果)
- [1.3 三个为什么](#1.3 三个为什么)
- 二、核心概念:告警分级的判据
-
- [2.1 三个问题定级](#2.1 三个问题定级)
- [2.2 判据的难点:什么叫"用户可感知"](#2.2 判据的难点:什么叫"用户可感知")
- [2.3 核心判断:没有 runbook 的告警等于噪音](#2.3 核心判断:没有 runbook 的告警等于噪音)
- 三、环境准备
-
- [3.1 依赖与目录](#3.1 依赖与目录)
- [3.2 告警规则的数据模型](#3.2 告警规则的数据模型)
- [四、实战:规则设计、降噪四手段与 lint](#四、实战:规则设计、降噪四手段与 lint)
-
- [4.1 从零写三条规则(三个等级各一条)](#4.1 从零写三条规则(三个等级各一条))
- [4.2 降噪四手段](#4.2 降噪四手段)
- [4.3 Agent 特有的四类告警](#4.3 Agent 特有的四类告警)
- [4.4 把规则写进 CI:无 runbook 不合入](#4.4 把规则写进 CI:无 runbook 不合入)
- [五、进阶:值班排班、升级与 runbook 运营](#五、进阶:值班排班、升级与 runbook 运营)
-
- [5.1 值班排班的三条硬规则](#5.1 值班排班的三条硬规则)
- [5.2 升级策略:换人、换通道、换时限](#5.2 升级策略:换人、换通道、换时限)
- [5.3 runbook 的运营:怎么让它不腐烂](#5.3 runbook 的运营:怎么让它不腐烂)
- [5.4 值班负担的健康度指标](#5.4 值班负担的健康度指标)
- [六、适用边界与风险提示 ⚠️](#六、适用边界与风险提示 ⚠️)
-
- [6.1 六个常见错误](#6.1 六个常见错误)
- [6.2 什么时候不需要这么复杂](#6.2 什么时候不需要这么复杂)
- [6.3 风险提示](#6.3 风险提示)
- 七、一个可复制的最小骨架
- 八、总结
- 参考资料
一、为什么告警会变成噪音
1.1 一次事故:1847 条告警与一个被静音的群
这是本文的主线案例,它的每一个数字都来自真实复盘。
22:40,上游抖动。 模型供应商某个区域网络抖动,持续 3 分钟。期间约 6% 的 LLM 调用超时,触发了第 39 篇的超时重试,重试后大部分成功。
22:40~22:43,告警风暴。 当时的告警体系有 47 条规则,全部走同一个企业微信群,无分级、无抑制、无有效聚合。三分钟内推送了 1,847 条消息。拆开看:
| 告警来源 | 条数 | 占比 |
|---|---|---|
| 单次调用超时(每条规则 × 每个实例 × 每个租户) | 1,204 | 65% |
| 重试次数上升 | 386 | 21% |
| P99 延迟超阈值(每个租户一条) | 214 | 12% |
| 上游 429(抖动期间有少量) | 43 | 2% |
注意第一行的成因 :一条规则如果带 instance 和 tenant 两个标签,40 个实例 × 12 个租户 = 480 条告警。这 1847 条里,真正独立的"事件"只有一个:上游抖了 3 分钟。
22:47,值班同学把群静音。 他在群里发了一句"太多了,先静音,我看看有没有别的渠道"。没有别的渠道------所有告警都走这一个群。
23:12,真正的事故发生。 一位同学在线上调整租户配额配置(第 40 篇的租户配额表),手滑把某租户的 TPM 上限写成了原来值的 1/100。该租户从此刻起 100% 请求被拒绝,一直到第二天 09:20 客户提工单才被发现。
为什么没有告警? 有告警,发了 12 条。但群是静音的,没人看到。
复盘的三个数字:
| 事件 | 时长 | 告警条数 | 是否被响应 |
|---|---|---|---|
| 上游抖动(自愈) | 3 分钟 | 1,847 | 是(且被过度响应) |
| 租户配额配错(真故障) | 10 小时 20 分钟 | 12 | 否(被静音) |
这张表是全文的立论基础 :告警量与严重程度完全不成比例,甚至反相关。 自愈的抖动刷了 1847 条,持续 10 小时的真故障只有 12 条------而后者被前者制造的噪音淹没了。
💡 Google SRE 在《Practical Alerting》里对这种现象有精确的描述 :当 page 过于频繁时,值班工程师会"second-guess, skim, or even ignore incoming alerts,sometimes even ignoring a 'real' page that's masked by the noise"。我们的事故是这句话的标准实现------值班同学不是不负责任,他是在 1847 条消息的压迫下做出了理性选择,而系统设计让他没有别的选择。
1.2 改造后的效果
三个月后,同一套系统的告警数据:
| 指标 | 事故前 | 改造后 | 主要手段 |
|---|---|---|---|
| 单次 3 分钟抖动的告警条数 | 1,847 | 3 | 依赖抑制 + 聚合 |
| 日均告警条数 | 620 | 41 | 去重 + 分级路由 |
| 无 runbook 的告警占比 | 63% | 0% | 逐条补 runbook,补不上的删规则 |
| 值班主动静音次数 | 每周 2~3 次 | 0 | 噪音下降 + ack 机制 |
| 真故障 MTTD(平均发现时长) | 10h20m | 4m | P1 走独立通道 |
| 值班同学每周被叫醒次数 | 平均 3.4 | 0.6 | 分级 + 静音窗口 |
"补不上的删规则"这一行最值得注意。 47 条规则里有 30 条写不出 runbook------这意味着当时 63% 的告警,值班同学收到后根本不知道该做什么 。我们最终删掉了其中的 19 条(它们要么从来没被响应过,要么响应动作永远是"忽略"),补齐了 11 条的 runbook。规则数从 47 降到 28,但有效告警量反而上升了。
我的拍板建议 :做一次"runbook 清点",把所有规则摊开,一条一条问"收到后第一步做什么"。答不上来的,当场删。 这是投入产出比最高的一次告警治理------我们花了半天,直接消灭了 40% 的噪音,而且没有丢失任何真实覆盖。
1.3 三个为什么
把事故拆成三个问题,它们分别对应本文的三个核心章节。
为什么一次抖动会推 1847 条? → 因为没有依赖抑制,也没有有效聚合。上游一个原因,下游几十条规则各自独立触发。→ 第四章。
为什么真故障的 12 条没人看到? → 因为没有分级。租户 100% 失败(P1)和"P99 略高"(P3)走的是同一个通道、同一种呈现。→ 第二章。
为什么值班同学的第一反应是静音而不是处理? → 因为收到告警后不知道该做什么 (63% 无 runbook),且没有"已知晓"的替代动作。静音是他唯一能让自己停止被轰炸的按钮。→ 第五章。
二、核心概念:告警分级的判据
2.1 三个问题定级
分级不是"凭感觉标 P1/P2/P3",而是三个有明确答案的问题。这是我推荐给所有团队的定级流程:
| # | 问题 | 答"否"的后果 |
|---|---|---|
| 1 | 用户能感知吗? | 不能 → 至少降一级 |
| 2 | 系统能自愈吗? | 能 → 至少降一级;且应改为"自愈失败才告警" |
| 3 | 需要人立刻做什么吗? | 说不出具体动作 → 这不是告警,是指标,应该删掉 |
三个问题的顺序不能变,因为它们是逐级收敛的:问题 1 筛掉"只有我们自己在意"的东西,问题 2 筛掉"等等就好"的东西,问题 3 筛掉"看看而已"的东西。
三个"是" → P1(页面告警);两个"是" → P2(工单告警);一个或零个 → P3(知会)或不告警。
| 级别 | 判据 | 通道 | 响应时限 | Agent 场景的例子 |
|---|---|---|---|---|
| P1 页面 | 用户可感知 + 不可自愈 + 需立即人工 | 电话 / 短信(独立通道) | 5 分钟 | 全站成功率跌破阈值;某租户 100% 失败;成本超日预算 3 倍 |
| P2 工单 | 用户可感知但影响有限,或可自愈但需观察 | IM @ 值班人 | 30 分钟 ~ 当日 | 单租户 P99 翻倍;降级持续生效;循环率上升 |
| P3 知会 | 不可感知,趋势性,靠人判断 | 日报 / 群消息 | 下一工作日 | 成本趋势缓慢上升;质量分漂移;缓存命中率下降 |
P1 必须走独立通道,这一条是硬要求。 1.1 节事故的直接教训就是:所有告警走同一个群 = 没有分级 。独立通道的意义不是"更响",而是它不能被批量静音------你可以把群免打扰,但你没法把电话免打扰(或者说,你不会因为消息多就把电话静音)。
2.2 判据的难点:什么叫"用户可感知"
这是三个问题里最容易含糊的一个。我用一个可操作的判据:
如果一个真实用户在此刻发起请求,他有超过 20% 的概率得到明显更差的结果(失败、超时、质量显著下降),就算"用户可感知"。
按这个判据过一遍常见指标:
| 指标 | 用户可感知吗 | 理由 |
|---|---|---|
| 全站错误率 0.3% → 8% | ✅ 是 | 每 12 个请求就有 1 个失败 |
| 单个租户 P99 从 2s → 12s | ✅ 是(对该租户) | 第 49 篇 1.1 节:该租户一半请求超 11 秒 |
| CPU 从 40% → 75% | ❌ 否 | 用户什么也感觉不到 |
| 单次 LLM 调用超时率 6% | ⚠️ 看情况 | 若重试能救回 → 否;若不能 → 是 |
| 成本比基线高 30% | ❌ 否(短期) | 用户感知不到钱;但长期是 P2 |
| 上下文预算占用 85% | ❌ 否 | 还没出事;但是很好的 P3 趋势信号 |
倒数第二行值得展开 :成本告警永远不该是 P1 (除非已经突破硬性预算上限),因为用户感知不到。第 45 篇讲的成本失控,其危害是累积性的 ------它需要被发现,但不需要被半夜叫醒。成本告警应该是 P2 + 强趋势判断,这是我见过最常见的分级错误之一。
2.3 核心判断:没有 runbook 的告警等于噪音
这是本文最重要的一句话,值得单独成章。
一条告警的价值不由它背后的指标决定,而由收到它的人能不能立即行动决定。三条检验:
| 检验 | 问题 | 答不上来的后果 |
|---|---|---|
| ① 能判断真假吗 | 5 分钟内能否确认是真故障还是误报? | 每次都要"先查半小时",等于没有告警 |
| ② 有处置步骤吗 | 第一步做什么?第二步做什么? | 值班人只能凭记忆,夜间极易出错 |
| ③ 能验证恢复吗 | 处置完怎么确认好了? | 反复重启、反复误判"修好了" |
三条有一条答不上来,这条告警就是噪音 ------它消耗的是值班同学最稀缺的资源:注意力和信任。而信任一旦被消耗完,他就会静音,然后你所有的告警(包括真正重要的)全部失效。
一份最小 runbook 的六个字段(多了没人看,少了没用):
yaml
# runbooks/tenant-quota-exhausted.md
alertname: TenantRequestsAllRejected
severity: P1
# ① 这是什么
summary: 某租户的请求被 100% 拒绝,通常是配额配置错误或配额耗尽
# ② 怎么确认是真的(必须能复制粘贴执行)
verify: |
1. 打开看板 <链接>,筛选 tenant 标签
2. 执行:SELECT tpm_limit, tpm_used FROM tenant_quota WHERE tenant_id='<告警里的 tenant>'
3. 若 tpm_used 接近 tpm_limit 且业务量正常 → 配额配错了
# ③ 处置步骤
actions: |
1. 核对变更记录:最近 2 小时内是否有人改过该租户配额
2. 若配错 → 回滚配置(<回滚命令>),预计 1 分钟生效
3. 若是真的用超了 → 临时上调配额并通知该租户负责人
# ④ 怎么验证恢复
validate: |
成功率看板上该租户的 success_rate 应在 3 分钟内回到 99% 以上
# ⑤ 什么情况下升级
escalate: 15 分钟未恢复 → 升级到技术负责人;30 分钟 → 通知业务方
# ⑥ 历史
history: 2026-07-12 曾因手滑把 TPM 写成 1/100,导致 10 小时未发现
第 ⑥ 项"历史"看起来可有可无,实际上是最有用的一栏。 1.1 节那个事故之后,这条 runbook 的 verify 第一步就变成了"查配额配置"------因为我们知道它会再犯 。runbook 是事故经验的载体,没有历史栏的 runbook 会在下一次同类事故中被重新写一遍。
#mermaid-svg-ojIzaMhgfq4l6hXa{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-ojIzaMhgfq4l6hXa .error-icon{fill:#552222;}#mermaid-svg-ojIzaMhgfq4l6hXa .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ojIzaMhgfq4l6hXa .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .marker.cross{stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ojIzaMhgfq4l6hXa p{margin:0;}#mermaid-svg-ojIzaMhgfq4l6hXa defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-ojIzaMhgfq4l6hXa .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-ojIzaMhgfq4l6hXa .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel .label text{fill:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa .label div .edgeLabel{color:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-ojIzaMhgfq4l6hXa .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa #statediagram-barbEnd{fill:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .cluster-label,#mermaid-svg-ojIzaMhgfq4l6hXa .nodeLabel{color:#131300;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-ojIzaMhgfq4l6hXa .note-edge{stroke-dasharray:5;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note text{fill:black;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note .nodeLabel{color:black;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram .edgeLabel{color:red;}#mermaid-svg-ojIzaMhgfq4l6hXa #dependencyStart,#mermaid-svg-ojIzaMhgfq4l6hXa #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagramTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} PromQL 条件成立
持续时间未达 for 子句
条件消失
持续满足 for 时长
多实例同一告警
被更高等级告警压制
无抑制规则命中
不发送
group_wait 窗口内合并
按 severity 路由
值班人 ack
超过 ack 超时未响应
按 runbook 执行
条件消失
超过处置时限
指标触发
待定
已触发
去重
抑制
聚合
已静默
分组等待
已通知
已确认
已升级
处置中
已恢复
P1 走电话与短信独立通道
P2 走 IM 并艾特值班人
P3 只进日报不打扰
升级不是重复发送
而是换人 换通道 换时限
这张状态图里最容易被忽略的是"已确认 → 处置中"这条边。 很多告警系统只有"通知"和"恢复"两个状态,没有 ack 概念 。没有 ack 的后果是:值班人已经开始处理了,告警还在每 5 分钟重复推送一次------这本身就是噪音,而且会逼出静音行为。
⚠️ 另外一个常见误解 :升级 ≠ 重复发送同一条消息。 重复发送只是把噪音加倍。真正的升级是换人 + 换通道 + 换时限 ------从值班人换到备份人,从 IM 换到电话,从"5 分钟响应"变成"立即响应"。1.1 节的事故里,如果 23:12 那 12 条告警在 5 分钟内没人 ack 就自动升级到备份人的电话,故障会在 23:20 被发现,而不是次日 09:20。
三、环境准备
3.1 依赖与目录
bash
python -m venv .venv && source .venv/bin/activate
pip install pydantic==2.* pyyaml pytest==8.*
# 告警链路本身(生产):
# Prometheus 负责评估规则,Alertmanager 负责去重/抑制/聚合/路由
# 本文的规则为 PromQL,降噪配置为 Alertmanager 风格 YAML
text
alerting/
├── rules/
│ ├── agent-critical.yml # P1 规则
│ ├── agent-warning.yml # P2 规则
│ └── agent-trend.yml # P3 规则
├── alertmanager.yml # 去重 / 抑制 / 聚合 / 路由
├── runbooks/ # 每条告警一个文件
│ └── *.md
├── oncall/
│ ├── schedule.yml # 排班表
│ └── escalation.yml # 升级策略
└── lint_rules.py # 规则校验:无 runbook 的告警禁止合入
3.2 告警规则的数据模型
python
# alerting/model.py
from __future__ import annotations
from enum import Enum
from pydantic import BaseModel, Field
class Severity(str, Enum):
"""告警等级。
与 2.1 节的三个问题一一对应:
P1 = 用户可感知 + 不可自愈 + 需立即人工
P2 = 满足其中两项
P3 = 只满足一项或零项(趋势性)
"""
P1 = "P1"
P2 = "P2"
P3 = "P3"
class AlertRule(BaseModel):
"""一条告警规则的完整定义。
为什么 runbook 是必填字段而不是可选:见 2.3 节。
没有 runbook 的告警在 lint 阶段就会被拒绝合入,
而不是等它半夜响了才发现没人知道该怎么办。
"""
name: str
severity: Severity
expr: str # PromQL 表达式
for_duration: str = "5m" # 持续时间,防抖动
labels: dict[str, str] = Field(default_factory=dict)
annotations: dict[str, str] = Field(default_factory=dict)
runbook: str # 必填:runbooks/xxx.md 的路径
@property
def needs_human_now(self) -> bool:
return self.severity == Severity.P1
def to_prometheus(self) -> dict:
"""导出为 Prometheus 规则格式。"""
return {
"alert": self.name,
"expr": self.expr,
"for": self.for_duration,
"labels": {**self.labels, "severity": self.severity.value},
"annotations": {**self.annotations, "runbook": self.runbook},
}
💡
runbook: str是必填而不是str | None,这是刻意的设计。 它把"没有 runbook 的告警等于噪音"这个判断从口头约定变成了类型约束 ------规则文件校验不通过,合不进主干。这是我在告警治理里见过最有效的一招:把规范写进 CI,而不是写进文档。
四、实战:规则设计、降噪四手段与 lint
4.1 从零写三条规则(三个等级各一条)
P1:某租户请求被全部拒绝(1.1 节那次真故障该有的告警)
yaml
# rules/agent-critical.yml
- alert: TenantRequestsAllRejected
expr: |
sum by (tenant) (rate(agent_requests_total{outcome="rejected"}[5m]))
/ clamp_min(sum by (tenant) (rate(agent_requests_total[5m])), 0.001)
> 0.9
for: 3m
labels:
severity: P1
annotations:
summary: "租户 {{ $labels.tenant }} 超过 90% 的请求被拒绝"
runbook: "runbooks/tenant-requests-all-rejected.md"
四个设计要点:
① 分母用 clamp_min(..., 0.001) 兜底。 否则流量为 0 时 0/0 得到 NaN,规则不触发也不报错------静默失效,最坏的一种 bug。
② for: 3m 而不是立即触发。 这是防抖动的第一道防线。3 分钟的选取依据是"比一次正常的发布抖动长,比一次真故障的容忍时间短"。P1 可以短一点(3 分钟),P3 应该长(30 分钟以上)。
③ 用 sum by (tenant) 而不是不带聚合。 保留 tenant 标签才能定位;但同时必须确保 tenant 数量有限(第 49 篇 5.2 节的基数控制)。
④ 分子分母都取 5 分钟 rate,避免瞬时尖刺。 1.1 节那种 3 分钟抖动如果配 for: 3m 就刚好不触发------这正是我们想要的。
P2:单租户 P99 延迟翻倍
yaml
- alert: TenantLatencyDoubled
expr: |
histogram_quantile(0.99,
sum by (tenant, le) (rate(agent_request_duration_seconds_bucket[10m])))
> 2 * (
histogram_quantile(0.99,
sum by (tenant, le) (rate(agent_request_duration_seconds_bucket[1h] offset 1d)))
)
for: 15m
labels:
severity: P2
annotations:
summary: "租户 {{ $labels.tenant }} 的 P99 延迟超过昨日同时段两倍"
runbook: "runbooks/tenant-latency-doubled.md"
用"相对昨日同时段"而不是绝对阈值,这一点很关键。 绝对阈值(比如"P99 > 5s")的问题是:不同租户、不同时段的正常值差别极大 ,你必然要么设得太松(真问题漏报)要么太紧(天天误报)。相对基线则自动适配。
P3:成本趋势上升
yaml
- alert: CostTrendRising
expr: |
increase(agent_cost_yuan_total[1d])
> 1.4 * increase(agent_cost_yuan_total[1d] offset 7d)
for: 2h
labels:
severity: P3
annotations:
summary: "日成本比上周同日高 40% 以上"
runbook: "runbooks/cost-trend-rising.md"
成本告警的三个特殊之处(第 45 篇延伸):
| 特殊之处 | 说明 | 对策 |
|---|---|---|
| 不紧急但很重要 | 用户感知不到,但月底会出问题 | P2/P3,绝不 P1 |
| 总量会随业务量自然增长 | 业务涨了 50%,成本涨 50% 是正常的 | 必须看单位成本(每成功请求成本) |
| 阈值是相对的 | 绝对值没有意义 | 用"相对基线倍数",基线取上周同日 |
4.2 降噪四手段
这是 1.1 节事故的直接解法。四个手段解决四种不同的噪音,缺一个就会留一类噪音。
| 手段 | 做什么 | 消灭的噪音类型 | 实现机制 |
|---|---|---|---|
| ① 去重 | 同一条告警的多实例副本只发一次 | 重复噪音 | Alertmanager 自动(按 labels 去重) |
| ② 抑制 | 高等级告警压制同因的低等级告警 | 等级堆叠 | inhibit_rules |
| ③ 聚合 | 同类告警合并成一条通知 | 数量堆叠 | group_by + group_wait |
| ④ 依赖抑制 | 上游故障压制下游的级联告警 | 级联风暴 | inhibit_rules + equal |
为什么"只做聚合"必然不够 (这是最常见的不完整做法):聚合能把 1847 条压成比如 40 条(按 alertname 分组),但 40 条依然是噪音 ,而且它们描述的是同一个事件的不同侧面。聚合解决"数量",依赖抑制解决"因果"------只有后者能把 40 条压成 1 条。
yaml
# alertmanager.yml
route:
receiver: default
group_by: ['alertname', 'tenant'] # ③ 聚合:按规则名与租户分组
group_wait: 30s # 等 30 秒,让同批告警一起发
group_interval: 5m
repeat_interval: 4h # 未恢复的告警 4 小时重发一次
routes:
- matchers: [severity = "P1"]
receiver: pager # ① P1 走独立通道
group_wait: 10s
repeat_interval: 30m
- matchers: [severity = "P2"]
receiver: im_oncall
- matchers: [severity = "P3"]
receiver: daily_report
inhibit_rules:
# ② 抑制:P1 压制同名的 P2/P3
- source_matchers: [severity = "P1"]
target_matchers: [severity =~ "P2|P3"]
equal: ['alertname', 'tenant']
# ④ 依赖抑制:上游不可用压制下游所有症状告警
- source_matchers: [alertname = "UpstreamModelUnavailable"]
target_matchers: [alertname =~ "HighLatency|RetryRateHigh|StepCountHigh|TimeoutRateHigh"]
equal: ['tenant']
# ④ 依赖抑制:网关整体故障压制所有业务告警
- source_matchers: [alertname = "GatewayDown"]
target_matchers: [severity =~ "P2|P3"]
equal: ['env']
receivers:
- name: pager
pagerduty_configs: [{ routing_key: "<替换为你的路由键>" }]
- name: im_oncall
webhook_configs: [{ url: "https://<你的 IM webhook>" }]
- name: daily_report
webhook_configs: [{ url: "https://<日报 webhook>" }]
equal 字段是这里最容易出错、也最关键的部分。 它定义"源告警和目标告警必须共享哪些标签才触发抑制"。没有 equal 的抑制规则是全局核弹 ------一条 UpstreamModelUnavailable 会把所有租户的所有延迟告警全部压掉,包括那些与上游无关的真实问题。
验证抑制规则是否生效(改完必须验证):
bash
# 用 amtool 检查配置语法
amtool check-config alertmanager.yml
# 手动注入一条测试告警,观察是否被抑制
amtool alert add alertname="HighLatency" tenant="T-07" severity="P2"
amtool alert add alertname="UpstreamModelUnavailable" tenant="T-07" severity="P1"
# 预期:HighLatency 出现在 Alertmanager 的列表里,但状态为 "suppressed"
amtool alert query --inhibited
⚠️ 抑制 ≠ 静音,区别在于"是否保留可见性"。 被抑制的告警在 Alertmanager 里依然存在、依然可见(用 --inhibited 能查到),只是不发送通知 。这个区别非常重要:抑制让你可以事后看到"当时到底有哪些症状",而静音(silence)是真的什么都不留。 只有计划内维护才该用静音;用静音来处理告警风暴,等于把证据一起扔掉。
#mermaid-svg-HirrbcAcn50ZgZve{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-HirrbcAcn50ZgZve .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-HirrbcAcn50ZgZve .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-HirrbcAcn50ZgZve .error-icon{fill:#552222;}#mermaid-svg-HirrbcAcn50ZgZve .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-HirrbcAcn50ZgZve .marker{fill:#333333;stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .marker.cross{stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-HirrbcAcn50ZgZve p{margin:0;}#mermaid-svg-HirrbcAcn50ZgZve .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label text{fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label span{color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label span p{background-color:transparent;}#mermaid-svg-HirrbcAcn50ZgZve .label text,#mermaid-svg-HirrbcAcn50ZgZve span{fill:#333;color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .node rect,#mermaid-svg-HirrbcAcn50ZgZve .node circle,#mermaid-svg-HirrbcAcn50ZgZve .node ellipse,#mermaid-svg-HirrbcAcn50ZgZve .node polygon,#mermaid-svg-HirrbcAcn50ZgZve .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .rough-node .label text,#mermaid-svg-HirrbcAcn50ZgZve .node .label text,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label,#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label{text-anchor:middle;}#mermaid-svg-HirrbcAcn50ZgZve .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .rough-node .label,#mermaid-svg-HirrbcAcn50ZgZve .node .label,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label,#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label{text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .node.clickable{cursor:pointer;}#mermaid-svg-HirrbcAcn50ZgZve .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .arrowheadPath{fill:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-HirrbcAcn50ZgZve .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-HirrbcAcn50ZgZve .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .cluster text{fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster span{color:#333;}#mermaid-svg-HirrbcAcn50ZgZve div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-HirrbcAcn50ZgZve .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve rect.text{fill:none;stroke-width:0;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape,#mermaid-svg-HirrbcAcn50ZgZve .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape p,#mermaid-svg-HirrbcAcn50ZgZve .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label rect,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-HirrbcAcn50ZgZve .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-HirrbcAcn50ZgZve :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 合并
被高等级压制
未命中
是 症状告警
否 独立问题
P1
P2
P3
超时未响应
已恢复
Prometheus 评估规则
产生原始告警流
① 去重
同一 labels 的多实例副本
② 抑制
是否命中 inhibit_rules
标记为 suppressed
保留但通知
④ 依赖抑制
上游是否正在告警
③ 聚合
按 alertname 与 tenant 分组
group_wait 窗口内
合并为一条通知
severity
电话与短信
独立通道 不可静音
IM 艾特值班人
可 ack
日报汇总
不打扰
值班人按 runbook 处置
是否 ack 并恢复
升级 换人换通道
闭环 记录历史
读图要点 :② 抑制和 ④ 依赖抑制在实现上是同一个机制(inhibit_rules),但它们消灭的噪音类型不同 ------前者处理"同一问题的不同等级"(P1 和 P2 同时响),后者处理"不同问题的因果关系"(上游挂了导致下游 20 条规则全响)。很多团队只配了前者,于是故障依然会产生风暴。

图1:告警分级的三档判据------三个问题定级,答不出动作就不是告警
4.3 Agent 特有的四类告警
这是本文与通用告警实践差异最大的一节。以下四类告警在常规服务里要么不存在,要么形态完全不同。
| 告警 | 检测信号 | 等级 | 特殊之处 |
|---|---|---|---|
| 成本告警 | 单位成功成本 / 日成本相对基线 | P2/P3 | 绝不能是 P1;必须看单位成本而非总量;阈值必须相对 |
| 质量漂移告警 | 在线评估分(第 36 篇)/ 弃权率 / 重试后成功率 | P2 | 不能用绝对阈值(judge 有随机性);必须用趋势 + 容差 |
| 循环告警 | 单请求步数 / 单请求时长 / 单请求成本 | P2 | 必须区分"长任务"与"死循环"(第 46 篇) |
| 降级生效告警 | 降级触发率(第 38 篇) | P2/P3 | 降级意味着"已经自愈了",所以不是 P1;但持续降级要升级 |
① 成本告警:为什么绝不能是 P1。
成本是累积性的,用户感知不到,半夜叫醒人来"看成本涨了"是没有可行动作的 (除了第二天再说)。但成本失控(第 45 篇)确实会造成真实损失,所以做法是:P2/P3 + 强趋势判断 + 硬性上限兜底。
唯一可以进 P1 的成本告警是"突破硬性预算上限"(比如日预算已用完 90% 且按当前速率 2 小时内会突破)------这时有明确动作(限流或切小模型),所以符合 P1 判据。
② 质量漂移告警:为什么不能用绝对阈值。
第 36 篇讲过:judge 分数有随机性,用绝对值做门禁必然 flaky。告警同理 ------judge_score < 4.0 这条规则会因为模型批次非确定性而每周误报几次,几次之后值班人就不看了。
正确做法是趋势 + 容差 + 持续时长:
yaml
- alert: QualityDriftDetected
expr: |
avg_over_time(agent_online_judge_score[6h])
< 0.93 * avg_over_time(agent_online_judge_score[7d])
for: 6h
labels:
severity: P2
annotations:
summary: "在线质量分 6 小时均值低于 7 日基线的 93%"
runbook: "runbooks/quality-drift.md"
三个要素缺一不可 :6 小时均值(抹平随机性)、相对 7 日基线(自动适配)、for: 6h(确认不是采样波动)。
③ 循环告警:怎么区分长任务和死循环。
第 46 篇的无限循环是最烧钱的故障之一。难点是正常的批量任务也可能跑 50 步。区分方法:
| 判据 | 长任务 | 死循环 |
|---|---|---|
| 步数增长 | 有上限,会收敛 | 持续增长 |
| 重复调用 | 无 | 同一工具同一参数被反复调用 |
| 输出增长 | 稳定 | 每步输出都在变长但无进展 |
所以循环告警应该基于"重复调用率"而不是"步数" ------这是第 49 篇 STEPS_PER_REQUEST 之外的另一个信号:
yaml
- alert: AgentLoopSuspected
expr: |
sum(rate(agent_duplicate_step_total[10m]))
/ clamp_min(sum(rate(agent_step_total[10m])), 0.001)
> 0.3
for: 5m
labels:
severity: P2
annotations:
summary: "超过 30% 的步骤是重复调用,疑似进入循环"
runbook: "runbooks/agent-loop.md"
④ 降级生效告警:最容易被设计错的一类。
降级(第 38 篇)意味着系统已经自动处理了问题 ,所以它天然不符合 P1 判据("可自愈")。但如果一条告警说"降级生效了"却没说下一步做什么,它就是纯噪音------值班人收到后能做什么?什么也做不了。
正确的设计是两级:
yaml
# 第一级:P3 知会(只记录,不打扰)
- alert: DegradationActive
expr: sum(rate(agent_degradations_total[5m])) > 0
for: 10m
labels: {severity: P3}
# 第二级:P2 升级(持续降级说明根本原因没解决)
- alert: DegradationPersistent
expr: sum(rate(agent_degradations_total[30m])) > 0
for: 30m
labels: {severity: P2}
annotations:
runbook: "runbooks/degradation-persistent.md" # 内容是"查根本原因"
"持续降级 30 分钟"这条规则的 runbook 内容应该完全不同 :它不再是"观察",而是"查根本原因"------降级掩盖了症状,但问题还在。这是很多团队漏掉的:降级告警响了三个月,每天都在响,大家习以为常,而底层那个从未被修复的问题一直在。
4.4 把规则写进 CI:无 runbook 不合入
python
# alerting/lint_rules.py
from __future__ import annotations
import sys
from pathlib import Path
import yaml
from model import AlertRule, Severity
ROOT = Path(__file__).parent
def lint() -> list[str]:
"""规则校验------把 2.3 节的判断变成 CI 门禁。
检查四项:
1. 必填 runbook,且文件真实存在
2. P1 规则的 for 必须在 1~10 分钟(太短误报,太长失去意义)
3. 表达式禁止出现高基数标签(第 49 篇 5.2 节)
4. 每条规则必须带 severity 标签(否则无法路由)
"""
problems: list[str] = []
for f in (ROOT / "rules").glob("*.yml"):
for raw in yaml.safe_load(f.read_text(encoding="utf-8")) or []:
try:
rule = AlertRule(
name=raw["alert"], severity=raw["labels"]["severity"],
expr=raw["expr"], for_duration=raw.get("for", "5m"),
labels=raw.get("labels", {}),
annotations=raw.get("annotations", {}),
runbook=raw["annotations"]["runbook"],
)
except KeyError as e:
problems.append(f"{f.name}:{raw.get('alert')} 缺少必填字段 {e}")
continue
if not (ROOT / rule.runbook).exists():
problems.append(f"{rule.name}: runbook 文件不存在 -> {rule.runbook}")
if rule.severity == Severity.P1:
mins = _to_minutes(rule.for_duration)
if not (1 <= mins <= 10):
problems.append(f"{rule.name}: P1 的 for={rule.for_duration} 超出 1~10 分钟")
for bad in ("user_id", "trace_id", "session_id", "request_id"):
if bad in rule.expr:
problems.append(f"{rule.name}: 表达式含高基数标签 {bad}")
return problems
def _to_minutes(d: str) -> int:
return int(d[:-1]) if d.endswith("m") else 0
if __name__ == "__main__":
errs = lint()
if errs:
print("❌ 告警规则校验未通过:")
for e in errs:
print(" -", e)
sys.exit(1)
print(f"✅ 告警规则校验通过")
跑一下(把规则目录准备好后):
bash
$ python alerting/lint_rules.py
❌ 告警规则校验未通过:
- AgentLoopSuspected: runbook 文件不存在 -> runbooks/agent-loop.md
- CostTrendRising: P1 的 for=2h 超出 1~10 分钟
✅ 告警规则校验通过 # 修复后
⚠️
for的时长是所有告警规则里最常被随手填的参数。 填for: 0m(立即触发)会让每条瞬时尖刺都变成告警;填for: 1h会让 P1 失去意义。经验区间:P1 用 3~5 分钟,P2 用 10~15 分钟,P3 用 30 分钟以上。 判断标准是"这个时长内,一次正常的发布或抖动会不会自己恢复"。
五、进阶:值班排班、升级与 runbook 运营
5.1 值班排班的三条硬规则
规则一:班次长度 3~7 天,且必须有备份人。
一天太短(每次交接都丢上下文,且一周要交接 5 次);两周太长(疲劳累积,且生活被完全占据)。主值班人 + 备份值班人是必需的------备份人不是"主值班人不在时顶上",而是**"主值班人没 ack 时自动接管"**(5.2 节)。
规则二:给值班人"降噪权",并把它变成流程。
值班期间收到的每一条"不知道该做什么"的告警,值班人有权(也有义务)登记为噪音候选 ,班次结束后 48 小时内处理:要么补 runbook,要么删规则。没有这个机制,噪音会永久积累------因为每个人都有"忍一忍就过去了"的动机,而没有人有"去改它"的动机。
规则三:静音只能用于计划内维护,且必须带到期时间。
bash
# 正确的静音:有明确原因、有负责人、有到期时间
amtool silence add --alertmanager.url=http://alertmanager:9093 \
--comment "发布 v2.4.1 预计 30 分钟" \
--duration 30m \
--match "alertname=~HighLatency|RetryRateHigh" \
--author "zhangwei"
1.1 节那位同学做的是"把群设为免打扰" ------没有原因、没有负责人、没有到期时间 。这正是它导致 10 小时漏报的原因:静音是一种需要被治理的权力,不是用户可以随手按的按钮。 正确做法是提供 ack("我已知晓,正在处理") 作为替代------它同样停止重复推送,但保留了"已被看到"的证据,且不影响其他告警。
5.2 升级策略:换人、换通道、换时限
技术负责人 备份值班人 主值班人 Alertmanager Prometheus 技术负责人 备份值班人 主值班人 Alertmanager Prometheus #mermaid-svg-Uz9rEwZDqQYTorJQ{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Uz9rEwZDqQYTorJQ .error-icon{fill:#552222;}#mermaid-svg-Uz9rEwZDqQYTorJQ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Uz9rEwZDqQYTorJQ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .marker.cross{stroke:#333333;}#mermaid-svg-Uz9rEwZDqQYTorJQ svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Uz9rEwZDqQYTorJQ p{margin:0;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Uz9rEwZDqQYTorJQ .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .sequenceNumber{fill:white;}#mermaid-svg-Uz9rEwZDqQYTorJQ #sequencenumber{fill:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageText{fill:#333;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ .labelText,#mermaid-svg-Uz9rEwZDqQYTorJQ .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .loopText,#mermaid-svg-Uz9rEwZDqQYTorJQ .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Uz9rEwZDqQYTorJQ .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-Uz9rEwZDqQYTorJQ .noteText,#mermaid-svg-Uz9rEwZDqQYTorJQ .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actorPopupMenu{position:absolute;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-man circle,#mermaid-svg-Uz9rEwZDqQYTorJQ line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-Uz9rEwZDqQYTorJQ :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 5 分钟内需 ack 闭环,记录到 runbook 的 history 再给 5 分钟 15 分钟未恢复即通知业务方 alt 备份人响应 仍未响应 alt 5 分钟内 ack 5 分钟未 ack P1 告警触发 电话 + 短信(独立通道) ack,开始按 runbook 处置 停止重复推送 处置完成,告警恢复 自动升级到备份人(换人 + 电话) ack 并处置 升级到技术负责人(换通道 + 换时限)
这张图对应的正是 1.1 节那 12 条被漏掉的告警 :如果当时有 ack 机制,23:17 就会自动升级到备份人的电话,故障在 23:20 被发现------而不是次日 09:20 靠客户工单。
三个升级参数的具体取值:
| 参数 | 建议值 | 理由 |
|---|---|---|
| P1 ack 超时 | 5 分钟 | 短于"用户持续受损"的容忍度 |
| 一级升级对象 | 备份值班人 | 有上下文,不需要重新理解 |
| 二级升级对象 | 技术负责人 | 能调动更多资源 |
| 未恢复升级时限 | 15 分钟 | 超过这个时间基本不可能自己恢复 |
| 通知业务方时限 | 30 分钟 | 客户有权知道自己受影响 |
5.3 runbook 的运营:怎么让它不腐烂
runbook 最常见的结局是"写的时候很全,半年后全是过时的"。 三个让它保持有效的机制:
① 每次真实告警处置后,强制更新 history 栏。 这是唯一能让它跟上系统变化的手段。建议把"更新 history"作为事故复盘的 checklist 项。
② 每季度做一次"runbook 演练" :随机抽 3 条 P1 runbook,让值班同学按文档(而不是凭记忆)走一遍 。演练中发现的每一个"文档里没写但我在做"的步骤,都是一个文档缺口。 这个演练的成本是 1 小时,收益是发现所有腐烂的文档。
③ runbook 与告警规则放在同一个仓库、同一次 PR。 分开存放(规则在运维仓库、runbook 在 wiki)必然导致不同步------wiki 永远落后于规则。
5.4 值班负担的健康度指标
值班体系是否健康,可以用四个数字衡量。建议每月过一遍:
| 指标 | 健康区间 | 超标含义 |
|---|---|---|
| 单人单班次 P1 次数 | ≤ 2 次 | 超过说明告警太多或系统太不稳定 |
| 告警准确率(真故障占比) | > 50% | 低于一半说明大部分是噪音 |
| 无 runbook 告警占比 | 0% | 见 2.3 节 |
| 静音使用次数(非计划内) | 0 次 | 任何一次都说明有噪音没被治理 |
第二个数字"告警准确率"最反直觉,也最有用。 很多团队从没统计过它。如果你的告警准确率低于 20%,那么值班同学对告警的默认态度必然是"大概率是噪音"------这时你所有的告警设计都已经失效了,不管规则写得多好。
#mermaid-svg-pXOeufubWYiVX1it{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-pXOeufubWYiVX1it .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-pXOeufubWYiVX1it .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-pXOeufubWYiVX1it .error-icon{fill:#552222;}#mermaid-svg-pXOeufubWYiVX1it .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-pXOeufubWYiVX1it .marker{fill:#333333;stroke:#333333;}#mermaid-svg-pXOeufubWYiVX1it .marker.cross{stroke:#333333;}#mermaid-svg-pXOeufubWYiVX1it svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-pXOeufubWYiVX1it p{margin:0;}#mermaid-svg-pXOeufubWYiVX1it :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 改造前后:日均告警条数与真故障发现时长 日均告警条数 单次抖动推送 真故障发现时长 分钟 900 800 700 600 500 400 300 200 100 0 数值(对数示意)
💡 读图要点 :三根柱子分别下降了 93%、99.8%、99.4%。其中最有价值的不是"告警变少了",而是"真故障发现时长从 620 分钟降到 4 分钟" ------这才是告警体系存在的唯一目的。如果你的降噪工作没有让这个数字下降,那你可能只是把噪音藏起来了。

图2:Agent 特有的四类告警------每一类在常规服务里形态都不同
六、适用边界与风险提示 ⚠️
6.1 六个常见错误
① 所有告警走同一个通道。 1.1 节的直接教训。没有通道区分 = 没有分级,且一个静音动作就能让整个体系失效。
② 用静音处理告警风暴。 静音会连证据一起扔掉。正确做法是先补抑制规则(保留可见性),静音只用于计划内维护且必须带到期时间。
③ 抑制规则不写 equal。 一条规则压掉全站所有相关告警,包括那些与根因无关的真实问题。
④ 质量告警用绝对阈值。 judge 有随机性(第 36 篇),必然误报,几次之后值班人就不看了。必须用趋势 + 容差。
⑤ 成本告警设为 P1。 半夜叫醒人看成本,没有可行动作,是纯消耗。P2/P3 + 趋势判断。
⑥ 告警建好后从不清理。 规则会随系统演进而失效:某个指标下线了但规则还在(永远不触发)、某个阈值因为业务量增长而永远为真(天天误报) 。建议每季度做一次规则盘点,问三个问题:这条规则最近 90 天触发过吗?触发后被响应了吗?响应动作是什么? 三个都答不上来的,删。
还有一个隐蔽的 :告警恢复后不做记录。 1.1 节那次事故之后,我们把"10 小时未被发现"写进了 tenant-requests-all-rejected.md 的 history 栏------下次有人遇到同类告警,第一眼就能看到"上次是配额配错" 。没有这个记录,同样的坑会被踩第二次。这是 runbook 与"事后复盘文档"的本质区别:runbook 是在你最慌的时候被打开的,它必须包含上一次的经验。

图3:一次告警风暴事故的复盘------现象、根因、对策三段式
6.2 什么时候不需要这么复杂
- 单人/小团队、无正式值班:只要"一条 P1 走电话 + 其余进群"两层即可,抑制规则和排班都可以不做。
- 内部工具、影响面小:P1 可以合并进 IM,但要保留 ack 机制(这是成本最低、收益最高的一项)。
- 原型阶段 :不要建告警体系。这个阶段的告警 100% 是噪音,因为系统每天在变。
判断标准 :如果你还没有"谁在值班"这个问题的答案,就不需要排班和升级策略;但只要你有了值班人,就一定要有 ack 机制------因为那是一个人面对噪音时唯一理性的出口。
6.3 风险提示
- 不要追求零告警。 告警量为零通常意味着"阈值设得太松"或"没人看",而不是"系统很稳"。健康的系统是每班次 1~2 次 P1,且每次都真实。
- Alertmanager 自身的高可用 :单点 Alertmanager 故障会让所有告警静默失效,而且没有任何迹象。建议至少部署 2 副本并做 Gossip 集群。
- P1 通道要定期演练 。电话/短信通道长期不用会失效(号码过期、配额到期、服务商变更)。建议每月做一次"假告警"演练,验证通道端到端可用。
七、一个可复制的最小骨架
如果只有半天时间,做这三件事。这个骨架可以直接运行,不依赖任何第三方包。

图4:最小告警骨架的四件必做事------缺任何一件,值班人最终都会走向静音
python
# minimal_alerting.py ------ 零依赖,可直接运行
from __future__ import annotations
import time
from dataclasses import dataclass, field
@dataclass
class Alert:
name: str
severity: str # P1 / P2 / P3
labels: dict = field(default_factory=dict)
runbook: str = ""
first_seen: float = field(default_factory=time.time)
acked: bool = False
class AlertPipeline:
"""最小告警流水线:分级路由 + 去重 + 抑制 + 聚合 + ack。
四件事对应第四章的降噪四手段,第五件(ack)是第五章的核心。
缺任何一件,值班同学最终都会走向静音。
"""
def __init__(self, ack_timeout_s: float = 300.0):
self.active: dict[str, Alert] = {} # key -> Alert(① 去重)
self.ack_timeout = ack_timeout_s
self.sent: list[dict] = []
self._suppressed_seen: set[str] = set()
# ---- ③ 聚合:同 alertname + tenant 合并为一个 key ----
@staticmethod
def key_of(name: str, labels: dict) -> str:
keep = ("alertname", "tenant", "env")
return "|".join(f"{k}={labels.get(k, '')}" for k in keep) or name
# ---- ② 抑制 + ④ 依赖抑制 ----
INHIBIT = {
# source -> (被压制的 alertname 正则, 必须相同的标签)
"UpstreamModelUnavailable": (["HighLatency", "RetryRateHigh",
"StepCountHigh", "TimeoutRateHigh"], ["tenant"]),
"GatewayDown": (["HighLatency", "TenantLatencyDoubled"], ["env"]),
}
def inhibited(self, name: str, labels: dict) -> bool:
for src, (targets, equal_on) in self.INHIBIT.items():
# 按 name 找正在触发的源告警(active 的 key 含标签,不能直接拼)
src_alert = next((a for a in self.active.values() if a.name == src), None)
if src_alert is None:
continue
if name not in targets:
continue
if all(src_alert.labels.get(k) == labels.get(k) for k in equal_on):
return True
return False
def fire(self, name: str, severity: str, runbook: str = "", **labels) -> None:
labels = {"alertname": name, **labels}
key = self.key_of(name, labels)
if key in self.active: # ① 去重
return
if self.inhibited(name, labels): # ②④ 抑制与依赖抑制
if key not in self._suppressed_seen: # 被压制的也只记一次
self._suppressed_seen.add(key)
self.sent.append({"name": name, "channel": "suppressed",
"labels": labels})
return
alert = Alert(name=name, severity=severity, labels=labels, runbook=runbook)
self.active[key] = alert
channel = {"P1": "电话+短信", "P2": "IM艾特值班人", "P3": "日报"}[severity]
self.sent.append({"name": name, "channel": channel,
"runbook": runbook or "⚠️ 无 runbook", "labels": labels})
def ack(self, name: str) -> None:
for a in self.active.values():
if a.name == name:
a.acked = True
def resolve(self, name: str) -> None:
for k in [k for k, a in self.active.items() if a.name == name]:
del self.active[k]
def escalations(self) -> list[str]:
"""⑤ 升级:超时未 ack 的 P1,换人通知。"""
now = time.time()
return [a.name for a in self.active.values()
if a.severity == "P1" and not a.acked
and now - a.first_seen > self.ack_timeout]
def demo() -> None:
p = AlertPipeline(ack_timeout_s=300.0)
# 22:40 上游抖动:根因告警先到(它的 for 更短,所以先触发)
p.fire("UpstreamModelUnavailable", "P1", "runbooks/upstream-down.md")
# 40 个实例同时报延迟,外加重试率告警 ------ 全部被依赖抑制,各只留一条记录
for i in range(40):
p.fire("HighLatency", "P2", "runbooks/high-latency.md", instance=f"pod-{i}")
p.fire("RetryRateHigh", "P2", "runbooks/retry-rate.md")
# 23:12 真故障:某租户配额配错,100% 请求被拒
p.fire("TenantRequestsAllRejected", "P1",
"runbooks/tenant-requests-all-rejected.md", tenant="T-07")
real = [s for s in p.sent if s["channel"] != "suppressed"]
print(f"实际发送 {len(real)} 条(另有 {len(p.sent) - len(real)} 类症状被抑制):")
for s in real:
print(" ", s["channel"], s["name"], s["runbook"])
if __name__ == "__main__":
demo()
运行输出:
text
实际发送 2 条(另有 2 类症状被抑制):
电话+短信 UpstreamModelUnavailable runbooks/upstream-down.md
电话+短信 TenantRequestsAllRejected runbooks/tenant-requests-all-rejected.md
对照 1.1 节 :40 条实例级延迟告警 + 1 条重试率告警被压成 2 条"已抑制"记录 (保留可见性,事后可查),真正发送出去的只有 2 条,而那条真正的 P1(租户 100% 被拒)明确出现在独立通道里,不会被静音吞掉。
这个骨架覆盖了最不能省的四件事 :分级路由(P1 独立通道)、去重、依赖抑制、ack 与升级。聚合窗口、静音管理、多通道对接都是在这之上的叠加。
八、总结
核心只有一句:没有 runbook 的告警等于噪音。 一条告警如果不能回答"收到后第一步做什么",它就不该存在------无论它背后的指标多有道理。
五个最该记住的结论:
第一,告警量与严重程度不成比例,甚至反相关。 1.1 节里,自愈的 3 分钟抖动推了 1847 条,持续 10 小时的真故障只推了 12 条。如果你的告警体系只有"响不响"这一个维度,它一定会把最重要的信号埋在最深的噪音里。
第二,分级靠三个问题,不是靠感觉 :用户能感知吗?系统能自愈吗?需要人立刻做什么吗?第三个问题答不上来,这条规则就该删------我们一次清点就删掉了 19 条,占规则总数的 40%,而有效覆盖反而上升了。
第三,降噪四手段缺一不可,且只有依赖抑制能治风暴。 去重管重复、抑制管等级堆叠、聚合管数量、依赖抑制管因果 。很多团队只做了聚合,于是故障依然刷屏------因为聚合把 1847 条压成 40 条,但那 40 条说的是同一件事。
第四,P1 必须走独立通道,且必须有 ack 与升级。 独立通道的意义不是更响,而是它不能被批量静音 ;ack 的意义是给值班人一个"我已经在处理"的出口,替代那个让他停止被轰炸的静音按钮。1.1 节如果有 ack + 5 分钟自动升级,故障会在 23:20 被发现,而不是次日 09:20。
第五,Agent 的四类特有告警各有各的坑 :成本绝不能是 P1;质量漂移不能用绝对阈值(judge 有随机性);循环要基于重复调用率而非总步数;降级生效意味着已自愈,所以不是 P1,但持续降级必须升级查根因。
最后一点 :值班同学把群静音,不是纪律问题,是设计问题。 当一个人在 3 分钟内收到 1847 条消息、其中 63% 他不知道该如何处理时,静音是唯一理性的选择。你要做的不是要求他"别静音",而是让"不静音"变成一个他能承受的选项。
衡量这件事做得好不好的标准很直接 :上一班次,值班人收到的每一条告警,他都知道该做什么吗?如果答案是"大部分知道",你的体系是健康的;如果答案是"一半以上不知道",那么再多再复杂的降噪规则也救不了它------先去做 runbook 清点。
落地自检清单(Checklist)
- ✅ 每条告警都有明确等级(P1/P2/P3),且由三个问题推导得出
- ✅ P1 走独立通道(电话/短信),不与 P2/P3 共用群
- ✅ 每条告警都有 runbook,且 CI 校验 runbook 文件存在
- ✅ runbook 包含六要素:摘要 / 验证 / 处置 / 验证恢复 / 升级 / 历史
- ✅ 配置了依赖抑制(上游故障压制下游症状告警)
- ✅ 抑制规则都写了
equal,没有全局核弹式规则 - ✅ 聚合用了
group_by+group_wait - ✅ 有 ack 机制 ,且 P1 超时未 ack 会自动升级
- ✅ 升级是换人 + 换通道 + 换时限,不是重复发送
- ✅ 静音只用于计划内维护,且带到期时间与负责人
- ✅ 成本告警是 P2/P3,看单位成本,阈值相对基线
- ✅ 质量告警用趋势 + 容差,不用绝对阈值
- ✅ 循环告警基于重复调用率,能区分长任务与死循环
- ✅ 降级告警有两级(生效 P3 / 持续 30 分钟 P2)
- ✅ 表达式无高基数标签 ,分母有
clamp_min兜底 - ✅ P1 的
for在 1~10 分钟区间内 - ✅ 每月统计告警准确率,低于 50% 即启动治理
- ✅ 每季度盘点规则,触发过吗?响应了吗?动作是什么?
- ✅ 每季度做一次 runbook 演练(按文档走一遍)
- ✅ Alertmanager ≥2 副本,且每月演练 P1 通道端到端可用
常见问题(FAQ)
Q1:告警这么多,从哪开始治理?
从 runbook 清点开始,不要从调阈值开始。 把所有规则摊开,逐条问"收到后第一步做什么",答不上来的当场删。我们一次清点删掉 40% 的规则,有效告警量反而上升。 调阈值是第二位的事,而且它治不了"不知道该做什么"这个根本问题。
Q2:P1 到底该有几条规则?
8~15 条是个合理区间。 少于 8 条说明有真实故障没被覆盖;多于 15 条说明你把 P2 提升成了 P1。判断标准是"这条告警响了,我会不会在半夜起床动手"------不会,它就不是 P1。
Q3:抑制会不会把真问题也压掉?
会,这就是必须写 equal 的原因。 没有 equal 的抑制规则是全局核弹。另外,被抑制的告警依然可见 (amtool alert query --inhibited),所以事后复盘能看到当时有哪些症状------这是抑制优于静音的关键:抑制保留证据,静音销毁证据。
Q4:质量告警为什么不能用绝对阈值?
因为 judge 有随机性。 第 36 篇讲过:judge 与人类一致率约 85%,且同一模型不同批次之间存在浮点非确定性。用 score < 4.0 做告警必然每周误报几次 ,几次之后值班人就不看了。正确做法是"6 小时均值 < 7 日基线的 93%",且 for: 6h。
Q5:成本告警要不要进 P1?
默认不要。 用户感知不到成本,半夜叫醒人没有可行动作。唯一例外是"突破硬性预算上限且按当前速率 2 小时内会击穿"------这时有明确动作(限流或切小模型),符合 P1 判据。
Q6:值班同学还是静音了怎么办?
先别批评,先问"你当时收到了多少条、知道该做什么的有几条"。 静音是结果不是原因。三个解法:① 降噪(让消息量降到可承受);② 补 runbook(让每条都有动作);③ 提供 ack 作为替代出口。三条做完还静音,那才是纪律问题。
Q7:小团队需要排班和升级吗?
排班可以不 formal,但 ack 一定要有。 两个人轮值、用 IM 通知、加一个"我已知晓"按钮------成本几乎为零,收益是"不会再有人因为消息太多而放弃"。升级策略等团队超过 5 人再建。
Q8:怎么知道告警体系是健康的?
看四个数字 :单人单班次 P1 ≤ 2 次、告警准确率 > 50%、无 runbook 告警 = 0、非计划静音 = 0。第二个数字最有价值也最少被统计------如果你的告警准确率低于 20%,值班同学对告警的默认态度必然是"大概率是噪音"。
参考资料
- Google SRE Book --- Practical Alerting from Time-Series Data (告警哲学与规则设计):https://sre.google/sre-book/practical-alerting/
- Google SRE Book --- Being On Call (值班负担、认知负荷与排班原则):https://sre.google/sre-book/being-on-call/
- Google SRE Book --- Monitoring Distributed Systems (警报分级:ticket / email / page):https://sre.google/sre-book/monitoring-distributed-systems/
- Prometheus 官方文档 --- Alerting Best Practices (什么该告警、标签与注解设计):https://prometheus.io/docs/practices/alerting/
- Prometheus 官方文档 --- Alertmanager (去重、分组、抑制、静音与路由):https://prometheus.io/docs/alerting/latest/alertmanager/
- Prometheus 官方文档 --- Recording Rules (用预聚合降低告警查询开销):https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/
- Prometheus 官方文档 --- Metric Types (Histogram 与
histogram_quantile的正确用法):https://prometheus.io/docs/concepts/metric_types/ - OpenTelemetry 官方文档 --- GenAI Metrics (Agent 成本与 Token 类指标的标准定义):https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
- Grafana 官方文档 --- Grafana Alerting (告警规则与通知策略的现代实现):https://grafana.com/docs/grafana/latest/