告警风暴治理:300 条告警进,3 起事故出

举报
yd_286463689 发表于 2026/10/21 08:58:24 2026/10/21
【摘要】 先靠规则收敛,再让模型写摘要。一套 270 行、可运行的告警归并流水线,把一因多果、重复上报和阈值抖动一次解决。

告警风暴治理: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": ["还需要确认的信息"]}

三条底线:

  1. 只允许引用输入中的事实。 模型很擅长补全因果,而故障现场最怕的就是一个听起来很合理的错误结论。
  2. 不确定必须显式说。 "根因待确认"比编一个原因有价值得多。
  3. 输出结构化。 直接进工单、进群消息、进复盘文档,减少二次加工。

反面做法是把 300 条原始告警直接丢给模型"分析根因"。上下文被重复信息塞满,模型很容易抓住最后一条噪声当结论。这不是模型能力问题,是输入没有治理。

还有一个容易被忽略的点:同一事故在生命周期内只通知一次,等级升级时才重推。 收敛做完了但通知不去重,值班同学照样会被刷屏。


五、怎么证明没有收敛错

四个指标,建议都埋上:

指标 定义 看什么
收敛比 输入告警数 / 输出事故数 效果,但别单独看
误合并率 被错误合并的事故数 / 抽样事故数 质量,最重要
MTTD 从首条告警到人确认的时间 是否真的更快
确认率 无需补充信息即可确认的事故占比 摘要是否可用

收敛比做到 100:1 不难,难的是不把两个真实故障合成一个。建议每周人工抽 30~50 条事故复核,重点看两类:

  • 一个事故里出现了两个不相干的根因——说明归并窗口太宽;
  • 同一根因被拆成多条事故——说明指纹或根因类型没配好。

这两类错误的方向相反,调参时必然来回摇摆,所以要用固定样本持续校准,而不是拍脑袋改窗口。


六、落到华为云上

  • 告警源:CES 的告警规则负责产生原始告警,通过 SMN 或事件订阅推给收敛服务。
  • 收敛服务:轻量场景放 FunctionGraph,按事件触发、不用常驻;需要维护窗口状态、做多副本去重时放 CCE。
  • 存储与回放:原始告警和收敛结果都写 LTS,用同一个 incident_id 串起来,复盘时能完整还原。
  • 应用侧对齐:AOM 看应用指标,和基础设施告警放在同一根时间轴上,根因判断会快很多。
  • 通知:只把 P0/P1 推到值班群,P3 进日报。通知通道分级,比告警分级更容易被忽略,但同样重要。

七、上线前 checklist

  • [ ] 每条告警有稳定指纹,且 instance 参与计算
  • [ ] labels 序列化前做了排序
  • [ ] 根因类型清单明确,有负责人维护
  • [ ] 归并窗口有上限,不会无限吞并
  • [ ] 低优先级告警不进值班通道
  • [ ] 同一事故只通知一次,升级才重推
  • [ ] 每次合并都保留原始 members,可下钻
  • [ ] 模型只做摘要,不参与"合不合并"的决策
  • [ ] 每周抽检误合并,指标有趋势
  • [ ] 收敛前后都埋点,能对比 MTTD

写在最后

告警治理的目标从来不是"告警变少",而是"每条推出来的告警都值得人看一眼"。

规则擅长做确定的事:去重、归并、分级、路由。模型擅长做模糊的事:把一堆结构化字段写成一句人能秒懂的话。把这两件事放对位置,300 条变 3 条并不难;放反了,就是花更多算力制造更通顺的噪声。

代码在文中,直接复制就能跑。如果你也在做告警收敛,欢迎聊聊你们是怎么处理"误合并"的——这块比收敛本身难得多。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。