告警风暴治理:300 条告警进,3 起事故出
告警风暴治理:300 条告警进,3 起事故出
一个典型的夜班场景:两点十四分,监控平台开始刷屏。节点失联、八个业务的错误率同时飙升、三个网关 5xx、几十台机器报磁盘使用率超 90%。三百条告警,红成一片。
值班同学花了四十分钟逐条看完,最后发现真正要处理的只有一件事:某个节点挂了。
这不是监控不够——恰恰相反,是监控太够了,缺的是收敛。
很多团队一想到"告警太多",第一反应是接个大模型进来做智能分析。但如果没有前面的规则收敛,模型拿到的就是三百条高度重复的文本,它只会把噪声总结得更通顺。顺序很重要:规则负责把 300 变成 3,模型负责把 3 讲清楚。
下面是一套可以直接跑的收敛流水线,以及它在一份 300 条模拟告警上的实际输出。
一、风暴是四个机制叠出来的
| 机制 | 表现 | 对应手段 |
|---|---|---|
| 一因多果 | 1 个节点故障,放大成 N 个服务、N 类指标 | 根因归并 |
| 重复上报 | 同一条告警每 30 秒推一次,10 分钟推 20 次 | 指纹去重 |
| 阈值抖动 | 指标在阈值附近反复触发、恢复 | 时间窗聚合 |
| 分级缺失 | 磁盘 90% 和节点失联走同一个通道 | 分级路由 |
前三个是技术问题,第四个是产品问题,但它们可以由同一条流水线一起解决。
二、流水线的四步
第一步:指纹——先定义什么算"同一条"
去重的前提是有一个稳定的身份。我的做法是把关键维度拼起来做哈希:
raw = json.dumps([service, name, node, instance, labels], sort_keys=True, ensure_ascii=False)
key = sha1(raw.encode()).hexdigest()[:12]
有三个坑:
- instance 必须进指纹。 否则 29 台机器的磁盘告警会被合并成两条,信息全丢。
- labels 必须先排序再序列化。 否则
{"a":1,"b":2}和{"b":2,"a":1}会算出两个 key,去重直接失效。 - 不要用告警文本做 key。 描述里往往带当前数值和时间,每次都不一样,等于没去重。
第二步:根因归并——把症状挂到根因上
这一步是收敛效果的主要来源。规则很朴素:如果一条告警是公认的根因类型(节点失联、磁盘写满、内存压力),那么在它存活窗口内出现、且等级不高于它的告警,都挂到它下面。
lo, hi = root.first_ts - 60, root.last_ts + 120
if lo <= g.first_ts <= hi and SEVERITY[g.severity] >= SEVERITY[root.severity]:
members.append(g)
这里用的是"根因类型 + 存活窗口",没有引入完整拓扑图。真实环境里建议再加一层拓扑约束(同节点、同可用区、调用链上下游),否则跨集群的无关 P0 也可能被误挂。
一条原则:宁可少合并,不要错合并。 漏合并只是多几条告警,错合并会让值班同学漏掉一个真正独立的故障。
第三步:类型聚合——P3 只汇总,不打扰
高优先级按 服务 + 告警名 聚合,低优先级只按告警名汇总成一条:“29 个实例磁盘使用率超 90%”。
值班同学不需要为 29 台机器各接一次电话。低优先级告警的价值在趋势,不在实时性。
第四步:输出事故对象
最终输出的不是一个字符串,而是一个结构:
{
"title": "NodeNotReady @ node-1",
"severity": "P0",
"count": 218,
"services": 12,
"instances": 28,
"start": "02:14:00",
"end": "02:23:30",
"rule": "根因 + 拓扑 + 存活窗口"
}
注意 rule 字段。它回答的是"这条结论怎么来的",比结论本身更能建立信任——值班同学可以据此判断要不要展开看原始告警。
三、完整实现
单文件、零依赖。下面这份 300 条告警是脚本生成的模拟样本,覆盖"节点故障 + 上游放大 + 无关磁盘/证书噪声"三类情况;接真实数据时替换 generate() 即可。
"""alert_triage.py —— 告警收敛:指纹去重 -> 根因归并 -> 类型聚合 -> 分级输出。
单文件、零依赖:
py -3 alert_triage.py
数据由脚本生成,用于演示规则效果;接真实告警时替换 generate() 即可。
"""
from __future__ import annotations
import hashlib
import json
from collections import defaultdict
from dataclasses import dataclass, field
from datetime import datetime
SEVERITY = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
ROOT_CAUSES = {"NodeNotReady", "NodeDiskFull", "NodeMemoryPressure"}
@dataclass
class Alert:
ts: float
service: str
name: str
severity: str
node: str = ""
instance: str = ""
labels: tuple = ()
@dataclass
class Group:
key: str
service: str
name: str
node: str
severity: str
first_ts: float
last_ts: float
count: int = 1
instances: set = field(default_factory=set)
@dataclass
class Incident:
title: str
severity: str
rule: str
count: int
services: set
instances: set
start: float
end: float
members: list
def fingerprint(a: Alert) -> str:
"""同服务、同告警名、同节点、同实例、同标签,才算同一条告警。"""
raw = json.dumps([a.service, a.name, a.node, a.instance, list(a.labels)],
sort_keys=True, ensure_ascii=False)
return hashlib.sha1(raw.encode("utf-8")).hexdigest()[:12]
def dedupe(alerts):
groups = {}
for a in alerts:
key = fingerprint(a)
g = groups.get(key)
if g is None:
groups[key] = Group(key, a.service, a.name, a.node, a.severity, a.ts, a.ts, 1, {a.instance})
continue
g.count += 1
g.last_ts = max(g.last_ts, a.ts)
g.instances.add(a.instance)
if SEVERITY[a.severity] < SEVERITY[g.severity]:
g.severity = a.severity
return list(groups.values())
def build(members, rule):
worst = min(SEVERITY[g.severity] for g in members)
severity = next(k for k, v in SEVERITY.items() if v == worst)
root = max(members, key=lambda g: (-SEVERITY[g.severity], -g.first_ts))
instances = set().union(*(g.instances for g in members))
if rule.startswith("根因"):
title = f"{root.name} @ {root.node}"
if len(members) > 1:
title += f"(聚合 {len(members)} 组告警)"
elif len(members) == 1:
title = f"{root.name} @ {root.service}"
else:
title = f"{root.name}({len(instances)} 个实例)"
return Incident(
title=title,
severity=severity,
rule=rule,
count=sum(g.count for g in members),
services={g.service for g in members},
instances=instances,
start=min(g.first_ts for g in members),
end=max(g.last_ts for g in members),
members=members,
)
def rollup(groups):
"""根因告警存活期间,同等级及以下的症状一律挂到它下面。"""
used = set()
incidents = []
for root in [g for g in groups if g.name in ROOT_CAUSES]:
lo, hi = root.first_ts - 60, root.last_ts + 120
members = [root]
used.add(root.key)
for g in groups:
if g.key in used:
continue
if lo <= g.first_ts <= hi and SEVERITY[g.severity] >= SEVERITY[root.severity]:
members.append(g)
used.add(g.key)
incidents.append(build(members, "根因 + 拓扑 + 存活窗口"))
return incidents, [g for g in groups if g.key not in used]
def cluster_rest(groups, gap=600):
"""剩余告警:P0-P2 按服务聚合,P3 只按类型汇总,不逐条打扰。"""
buckets = defaultdict(list)
for g in groups:
key = f"{g.service}/{g.name}" if SEVERITY[g.severity] <= 1 else g.name
buckets[key].append(g)
incidents = []
for items in buckets.values():
items.sort(key=lambda g: g.first_ts)
current = [items[0]]
for g in items[1:]:
if g.first_ts - current[-1].last_ts <= gap:
current.append(g)
else:
incidents.append(build(current, "同类型时间窗聚合"))
current = [g]
incidents.append(build(current, "同类型时间窗聚合"))
return incidents
def triage(alerts):
groups = dedupe(alerts)
incidents, rest = rollup(groups)
incidents += cluster_rest(rest)
incidents.sort(key=lambda i: (SEVERITY[i.severity], i.start))
return groups, incidents
def report(alerts, groups, incidents):
print(f"输入告警 {len(alerts)}")
print(f"指纹去重后 {len(groups)} 组")
print(f"收敛为事故 {len(incidents)} 起")
print(f"收敛比 {len(alerts)} : {len(incidents)}")
print()
for i in incidents:
print(f"[{i.severity}] {i.title}")
print(f" {i.count} 条告警 / {len(i.instances)} 个实例 / {(i.end - i.start) / 60:.1f} 分钟")
print(f" {datetime.fromtimestamp(i.start):%H:%M:%S} -> {datetime.fromtimestamp(i.end):%H:%M:%S}"
f" 规则:{i.rule}")
print()
# ---------------------------------------------------------------- 模拟数据
def generate():
"""一次节点故障:1 条根因 + 198 条症状,外加 101 条无关的低优先级噪声。"""
t0 = datetime(2026, 10, 20, 2, 14, 0).timestamp()
alerts = []
for i in range(20):
alerts.append(Alert(t0 + i * 30, "kubelet", "NodeNotReady", "P0", "node-1", "node-1"))
for service in ("cart", "order", "payment", "inventory", "coupon", "user", "search", "notify"):
for name in ("HighErrorRate", "HighLatency", "PodRestart"):
for i in range(6):
alerts.append(Alert(t0 + 40 + i * 90, service, name, "P1", "node-1", f"{service}-{i % 3}"))
for service in ("gateway", "web-bff", "app-bff"):
for name in ("Upstream5xx", "UpstreamTimeout"):
for i in range(9):
alerts.append(Alert(t0 + 70 + i * 60, service, name, "P1", "", service))
disk = datetime(2026, 10, 20, 1, 5, 0).timestamp()
for n in range(29):
for i in range(2):
alerts.append(Alert(disk + n * 60 + i * 300, "node-exporter", "DiskUsageHigh",
"P3", f"node-{2 + n % 2}", f"host-{n:02d}"))
cert = datetime(2026, 10, 20, 0, 40, 0).timestamp()
for n in range(12):
for i in range(2):
alerts.append(Alert(cert + n * 120 + i * 600, "ingress", "CertExpiringSoon",
"P3", "", f"ing-{n}", ("days=7",)))
assert len(alerts) == 300, len(alerts)
return alerts
if __name__ == "__main__":
alerts = generate()
groups, incidents = triage(alerts)
report(alerts, groups, incidents)
运行结果:
输入告警 300
指纹去重后 120 组
收敛为事故 3 起
收敛比 300 : 3
[P0] NodeNotReady @ node-1(聚合 79 组告警)
218 条告警 / 28 个实例 / 9.5 分钟
02:14:00 -> 02:23:30 规则:根因 + 拓扑 + 存活窗口
[P3] CertExpiringSoon(12 个实例)
24 条告警 / 12 个实例 / 32.0 分钟
00:40:00 -> 01:12:00 规则:同类型时间窗聚合
[P3] DiskUsageHigh(29 个实例)
58 条告警 / 29 个实例 / 33.0 分钟
01:05:00 -> 01:38:00 规则:同类型时间窗聚合
218 条看起来吓人,拆开其实很简单:
- 20 条是
NodeNotReady本身,每 30 秒重复一次; - 144 条来自 8 个业务,每个业务 3 类症状(错误率、延迟、Pod 重启),每类 3 个实例、重复 2 次;
- 54 条来自 3 个网关的上游 5xx 和超时。
它们指向同一件事。收敛之后,信息并没有丢:28 个实例、12 个服务、9.5 分钟的时间范围都在 Incident 里,展开还能看到每一条原始告警。
这就是收敛和"静音"的区别:静音是扔掉,收敛是归档。
四、模型该放在哪一步
规则能解决"合并",解决不了"说人话"。所以模型放在最后一步——给已经收敛好的 Incident 写摘要,而不是让它面对原始告警流。
输入只给结构化字段,不给三百条原文:
事故:NodeNotReady @ node-1
等级:P0
影响:28 个实例、12 个服务,持续 9.5 分钟
关联告警:HighErrorRate / HighLatency / PodRestart / Upstream5xx / UpstreamTimeout
Prompt 可以很简短,但约束要写死:
你是值班助手。只根据给定的事故数据写摘要,不允许补充数据里没有的原因。
如果证据不足以判断根因,就写"根因待确认",不要猜。
输出 JSON:{"summary": "一句话结论", "impact": "影响面", "next_action": "建议动作", "missing": ["还需要确认的信息"]}
三条底线:
- 只允许引用输入中的事实。 模型很擅长补全因果,而故障现场最怕的就是一个听起来很合理的错误结论。
- 不确定必须显式说。 "根因待确认"比编一个原因有价值得多。
- 输出结构化。 直接进工单、进群消息、进复盘文档,减少二次加工。
反面做法是把 300 条原始告警直接丢给模型"分析根因"。上下文被重复信息塞满,模型很容易抓住最后一条噪声当结论。这不是模型能力问题,是输入没有治理。
还有一个容易被忽略的点:同一事故在生命周期内只通知一次,等级升级时才重推。 收敛做完了但通知不去重,值班同学照样会被刷屏。
五、怎么证明没有收敛错
四个指标,建议都埋上:
| 指标 | 定义 | 看什么 |
|---|---|---|
| 收敛比 | 输入告警数 / 输出事故数 | 效果,但别单独看 |
| 误合并率 | 被错误合并的事故数 / 抽样事故数 | 质量,最重要 |
| MTTD | 从首条告警到人确认的时间 | 是否真的更快 |
| 确认率 | 无需补充信息即可确认的事故占比 | 摘要是否可用 |
收敛比做到 100:1 不难,难的是不把两个真实故障合成一个。建议每周人工抽 30~50 条事故复核,重点看两类:
- 一个事故里出现了两个不相干的根因——说明归并窗口太宽;
- 同一根因被拆成多条事故——说明指纹或根因类型没配好。
这两类错误的方向相反,调参时必然来回摇摆,所以要用固定样本持续校准,而不是拍脑袋改窗口。
六、落到华为云上
- 告警源:CES 的告警规则负责产生原始告警,通过 SMN 或事件订阅推给收敛服务。
- 收敛服务:轻量场景放 FunctionGraph,按事件触发、不用常驻;需要维护窗口状态、做多副本去重时放 CCE。
- 存储与回放:原始告警和收敛结果都写 LTS,用同一个
incident_id串起来,复盘时能完整还原。 - 应用侧对齐:AOM 看应用指标,和基础设施告警放在同一根时间轴上,根因判断会快很多。
- 通知:只把 P0/P1 推到值班群,P3 进日报。通知通道分级,比告警分级更容易被忽略,但同样重要。
七、上线前 checklist
- [ ] 每条告警有稳定指纹,且 instance 参与计算
- [ ] labels 序列化前做了排序
- [ ] 根因类型清单明确,有负责人维护
- [ ] 归并窗口有上限,不会无限吞并
- [ ] 低优先级告警不进值班通道
- [ ] 同一事故只通知一次,升级才重推
- [ ] 每次合并都保留原始 members,可下钻
- [ ] 模型只做摘要,不参与"合不合并"的决策
- [ ] 每周抽检误合并,指标有趋势
- [ ] 收敛前后都埋点,能对比 MTTD
写在最后
告警治理的目标从来不是"告警变少",而是"每条推出来的告警都值得人看一眼"。
规则擅长做确定的事:去重、归并、分级、路由。模型擅长做模糊的事:把一堆结构化字段写成一句人能秒懂的话。把这两件事放对位置,300 条变 3 条并不难;放反了,就是花更多算力制造更通顺的噪声。
代码在文中,直接复制就能跑。如果你也在做告警收敛,欢迎聊聊你们是怎么处理"误合并"的——这块比收敛本身难得多。
- 点赞
- 收藏
- 关注作者
评论(0)