标签: Prometheus

  • 深入 SRE 告警治理:告别资源阈值风暴,基于多窗口 SLO 燃烧率与 Alertmanager 抑制实战

    生产环境绝大多数告警风暴源于粗放的“资源阈值”触发器。要真正给 On-Call 工程师减负,必须抛弃 CPU/内存使用率等原因导向告警,转向基于用户体验的 SLO(服务级别目标)现象导向告警。本文直接给出基于 Prometheus 的多窗口多燃烧率(Multi-Window Burn Rate)实现方案,结合 Alertmanager 路由抑制,彻底过滤瞬态抖动噪音。

    现场还原:被“阈值告警”淹没的真正故障

    近期排查过一个典型案例:某个核心交易链路出现 504 Gateway Timeout 雪崩。但在故障发生时的前 5 分钟内,On-Call 工程师的 Slack 和邮箱瞬间涌入 400 多条告警。

    其中 95% 的告警长这样:

    [FIRING] K8sNodeCpuHigh
    Severity: warning
    Summary: Node 10.x.x.x CPU usage is > 85%
    Description: CPU usage is at 92% for more than 3m.
    

    工程师的注意力完全被 Kubernetes 节点的 CPU 和 Pod 的重启告警吸引,试图去扩容 Node。但底层根因其实是:DB 连接池因慢查询耗尽,导致上游网关堆积请求,线程阻塞打满 CPU。高 CPU 只是结果,而非原因。 真正有价值的告警——“支付接口 P99 延迟突破 2s”被淹没在无穷无尽的资源告警噪音中。

    这种传统的告警配置策略(如 CPU > 80% 告警),在现代微服务和云原生架构中,除了消耗 SRE 的精力,毫无价值。

    为什么我们必须彻底抛弃静态资源利用率告警?

    传统的监控思路是自底向上的(Bottom-Up):监控机器 -> 监控 OS -> 监控 DB -> 监控应用。但在 K8S 集群中,Pod 随时在漂移,HPA(Horizontal Pod Autoscaler)会根据负载自动扩缩容。一个节点 CPU 跑到 90% 完全是资源利用率高的健康表现,只要服务的 RT(响应时间)和错误率达标,用户根本不关心你的 CPU 是 10% 还是 99%。

    防御性运维的核心思想是面向症状告警(Symptom-based Alerting)。 我们需要围绕 SLI(服务级别指示器)来构建监控体系,通常只关注四个黄金信号:延迟、流量、错误、饱和度。当且仅当错误预算(Error Budget)被快速消耗时,才触发 P1 级别 On-Call 呼叫。

    SLO 燃烧率告警核心架构与 PromQL 落地实战

    基于 Google SRE 实践,我们采用多时间窗口多燃烧率(Multi-Window, Multi-Burn-Rate)模型。

    假设我们的 SLO 是:API 过去 30 天的可用性达到 99.9%。 这意味着 30 天(730 小时)内的错误预算(Error Budget)为 0.1%。

    如果我们在 1 小时内消耗了整个月 2% 的错误预算,燃烧率(Burn Rate)计算如下: (2% / 100%) / (1h / 730h) ≈ 14.6(通常工程上取 14.4)。

    为了防止低频抖动触发告警(Flapping),我们引入双窗口:长窗口(1h)用于触发,短窗口(5m)用于确认当前故障仍在持续。只有当两个窗口的燃烧率同时超标时,才发出告警。

    1. 预计算 Recording Rules (Prometheus 2.45+)

    直接在告警规则中跑高基数(High Cardinality)的原始指标聚合会导致 Prometheus 评估超时。必须先使用 Recording Rules 将 SLI 降维。

    groups:
      - name: slo_sli_recordings
        interval: 1m
        rules:
          # 计算过去 5 分钟的错误率 SLI
          - record: job:request_error_rate5m
            expr: |
              sum by (job) (rate(http_requests_total{status=~"5.."}[5m]))
              /
              sum by (job) (rate(http_requests_total[5m]))
    
          # 计算过去 1 小时的错误率 SLI
          - record: job:request_error_rate1h
            expr: |
              sum by (job) (rate(http_requests_total{status=~"5.."}[1h]))
              /
              sum by (job) (rate(http_requests_total[1h]))
    

    2. 多窗口燃烧率告警规则

    在上述预计算指标的基础上,配置 14.4 燃烧率告警(严重告警,即刻 Page On-Call):

    groups:
      - name: slo_burn_rate_alerts
        rules:
          - alert: API_HighErrorBurnRate_Page
            # 条件:1小时的燃烧率 > 14.4 且 5分钟的燃烧率 > 14.4
            # SLO=99.9%, Budget=0.1% (0.001)
            # 14.4 * 0.001 = 0.0144 (即 1.44% 的绝对错误率阈值)
            expr: |
              (
                job:request_error_rate1h > 0.0144
                and
                job:request_error_rate5m > 0.0144
              )
            labels:
              severity: critical
              pager: "true"
            annotations:
              summary: "API 错误预算极速消耗 (Burn Rate > 14.4)"
              description: "服务 {{ $labels.job }} 在过去1小时内消耗了 2% 的月度错误预算,请立即介入排查。"
    

    通过这种多窗口机制,若只是 1 分钟的网络抖动,5m 窗口会很快回落,告警自动解除,On-Call 工程师根本不会被打扰;而如果是持续的底层熔断,1h 窗口和 5m 窗口同时达标,立刻触发电话告警。

    Alertmanager 高级减噪机制:Inhibit 与 Grouping

    即使有了 SLO 告警,在机房级网络割接或交换机故障时,仍会产生“服务级 SLO 全部崩塌”的并发告警。此时必须利用 Alertmanager (v0.26+) 的 group_byinhibit_rules 机制。

    1. 分组折叠 (Grouping)

    不要让每个容器的报错发一条消息,按服务或集群聚合:

    route:
      receiver: 'slack-oncall'
      group_by: ['job', 'cluster']
      group_wait: 30s      # 等待30秒收集同类告警
      group_interval: 5m   # 每5分钟发送一批新告警
      repeat_interval: 4h  # 未解决告警4小时后才重发
    

    2. 拓扑抑制 (Inhibition)

    底层基础组件宕机时,静默其上层所有应用的告警。例如:所在宿主机 NodeDown,则直接抑制该宿主机上所有 Pod 触发的 SLO 告警。

    inhibit_rules:
      - source_matchers:
          - alertname = "NodeDown"
          - severity = "critical"
        target_matchers:
          - severity =~ "warning|critical|info"
        # 只要 target 告警的 instance/node 标签和 source 匹配,就将其丢弃
        equal: ['node', 'cluster']
    

    通过抑制链设计:DatacenterDown -> 抑制 ClusterDown -> 抑制 NodeDown -> 抑制 AppSLOAlert,在灾难性故障现场,On-Call 工程师只会收到唯一一条最顶层的根因告警。

    常见问题

    Q:既然抛弃了静态资源告警,数据库磁盘满了或者证书过期这类问题怎么监控? A:不要陷入极端。基于症状的 SLO 告警针对的是用户请求链路。对于确定性的、必然导致宕机且有充足时间提前干预的“饱和度/容量指标”(如磁盘使用率 > 85%、TLS 证书 7 天后过期),依然需要配置静态阈值告警,但这部分告警级别通常设为 Warning,走工单或 IM 推送,白天处理即可,绝不能 Page 深夜的 On-Call。

    Q:对于流量极低的服务(比如每分钟只有几个请求),SLO 燃烧率计算会剧烈抖动,如何解决? A:低频服务的指标在计算 rate() 时极易出现“分母为0”或“1个错误=100%错误率”的噪音。解决方案是在 PromQL 中加入绝对流量过滤条件,例如 and sum by (job) (rate(http_requests_total[5m])) > 10,确保样本量具备统计学意义时才评估错误率。

    Q:如何定义异步消息队列(如 Kafka/RocketMQ 消费端)的 SLI? A:异步服务的核心用户体验不是“同步响应时间”,而是“消息堆积延迟”。SLI 可以定义为:过去 5 分钟内,99% 的消息从发送到被消费的端到端延迟(End-to-End Latency)小于 5 秒,或者更直白地以 Consumer Group 的 Lag 积压绝对值作为 SLI 指标,结合消费速率评估剩余处理时间(Time-to-critical)。

  • 突破 OOM 死亡循环:Prometheus 高基数指标引发的 TSDB 内存雪崩与底层结构解析实战

    结论先行:Prometheus 频繁 OOM 且 WAL 截断失败,99% 的根因是高基数(High Cardinality)标签打穿了 Head Block 的倒排索引。底层 Gorilla 压缩算法只能极大地优化时序“值”的存储(16字节压缩至约1.37字节),但救不了无限膨胀的 Label 组合。解决方案:通过 promtool tsdb analyze 定位基数元凶,用 metric_relabel_configs 在抓取阶段实行防御性清洗,并合理配置 TSDB 的 Block 压缩与落盘周期。

    某次排查过程中,我们线上一套监控几十个 K8S 集群的核心 Prometheus(v2.45.0)节点陷入了 CrashLoopBackOff 的死亡循环。告警静默,监控大屏一片空白。

    查看系统内核日志,死因极其明确——被 OOM Killer 制裁:

    $ dmesg -T | grep -i oom
    [xxx] prometheus invoked oom-killer: gfp_mask=0x100cca(GFP_HIGHUSER_MOVABLE), order=0, oom_score_adj=0
    [xxx] Memory cgroup out of memory: Killed process 12345 (prometheus) total-vm:85493200kB, anon-rss:67108864kB
    

    物理机分配了 64GB 内存给这个容器,居然在几分钟内被吃干抹净。这绝不是正常的指标写入量增长,而是典型的“高基数雪崩”。

    寻找雪崩元凶:拨开 WAL 与 Head Block 的迷雾

    Prometheus 的 TSDB 设计基于内存(Head Block)与磁盘(Persistent Block)的组合。最新采集的 2-3 小时数据全部驻留在内存中,并依靠 WAL(Write-Ahead Log)保证不丢数据。每次 Prometheus OOM 重启后,第一件事就是 Replaying WAL。如果导致 OOM 的高基数数据还在 WAL 里,重启过程必将再次吃满内存,形成死循环。

    为了强行中断这个循环,我们先将该节点的内存限制临时放大到 128GB 让其启动,随后立即使用官方神器 promtool 对本地数据目录进行离线解剖:

    $ promtool tsdb analyze /prometheus/data
    ...
    # Top 10 label names with high memory usage:
    1: trace_id
    2: client_ip
    3: pod_ip
    
    # Top 10 series count by metric names:
    1: 4501230  http_request_duration_seconds_bucket
    2: 2100450  http_requests_total
    ...
    

    破案了。某业务研发在 http_requests_total 和耗时直方图里,顺手加上了 trace_idclient_ip 作为 Label。

    为什么仅仅是多加了一个 Label,就会耗尽上百 GB 的内存?

    很多开发对时序数据库有误解,认为“Prometheus 压缩率很高,多加个字段无所谓”。这就必须深入 TSDB 的底层数据结构来解释。

    在 Prometheus 中,一条时间线(Series)由 Metric Name 和一组 Label 键值对唯一确定http_requests_total{method="GET", status="200", client_ip="192.168.1.10", trace_id="abc123xxx"}

    TSDB 处理数据分为两大核心路径:数据块(Chunks)倒排索引(Inverted Index)

    1. Chunks 的极致压缩(Gorilla 算法) 对于属于同一条时间线的连续样本数据 (Timestamp, Value),Prometheus 采用了类似 Facebook Gorilla 论文中的 XOR 增量压缩算法。因为时间戳通常是规律递增的(如 15s 一次),Value 往往变化极小。通过计算差值的差值(Delta-of-Delta),一对原本需要 16 Bytes(8 Byte int64 时间戳 + 8 Byte float64 值)的样本,能被压缩到平均 1.37 Bytes。这就是大家常说的“高压缩率”。

    2. 倒排索引的内存黑洞 Gorilla 压缩对 Label 完全无效。为了能让 PromQL 飞速查询,Prometheus 必须为每一个 Label 的 Name 和 Value 建立倒排索引映射: Label (client_ip="192.168.1.10") -> [Series ID 1, Series ID 205...] 当引入 trace_id 这种几乎每次请求都不同的 Label 时,Series 的数量等于所有 Label 基数的笛卡尔积。 百万级别的 trace_id 瞬间生成了数百万条独立的 Series。每条全新 Series 的诞生,都会在 Head Block 中分配新的字符串内存(Symbols table)、新的倒排索引指针(Postings list),以及独立的数据 Chunk。内存消耗呈现指数级爆炸,且完全无法被压缩。

    当这些海量的内存结构积压在 Head Block(默认驻留时间最多达 3 小时),内存自然会瞬间被打穿。

    落地实战:防御性清洗与架构调优

    对于这种毒瘤级的指标,我们绝不妥协,必须在网关侧/采集侧直接干掉,实施“防御性运维”。

    1. 采集端防御配置(metric_relabel_configs) 在 Prometheus 的 scrape_configs 中,利用 metric_relabel_configs 在指标进入 TSDB 引擎前将其截杀。注意,不要用 relabel_configs(作用于 target 发现阶段),必须用 metric_relabel_configs

    scrape_configs:
      - job_name: 'business-api'
        ...
        metric_relabel_configs:
          # 方案一:直接丢弃整个包含了违规 Label 的指标序列(下手最狠)
          - source_labels: [trace_id]
            regex: '.+'
            action: drop
    
          # 方案二:保留指标,但抹除高基数 Label(推荐,保证监控不丢失总并发量)
          - regex: '(trace_id|client_ip)'
            action: labeldrop
    

    加载配置 (curl -X POST http://localhost:9090/-/reload) 后,新的数据洪流被清洗干净。

    2. TSDB 块生命周期(Compaction)调优 为了让 Prometheus 尽快清理掉历史遗留的庞大 Head Block,我们需要理解 TSDB 的落盘(Compaction)机制。 Head Block 中的数据达到特定条件会切分成持久化的 Block 目录(包含 meta.json, index, chunks/, tombstones)。

    如果服务器内存吃紧,我们可以适当干预落盘周期(启动参数配置):

    # 默认 min-block-duration 为 2h,决定了 Head 块多久切片一次落盘。
    # 强制保持一致,避免块过大难以合并
    --storage.tsdb.min-block-duration=2h
    --storage.tsdb.max-block-duration=24h
    

    持久化到磁盘后的 Block 会被通过 mmap 的方式映射到虚拟内存空间(VIRT),此时只要不进行全量范围的 PromQL 查询,这部分数据对物理内存(RES)的占用将大幅度降低,由 Linux 内核的 PageCache 全权接管。

    3. 清理已存在的毒瘤数据(Tombstones 机制) 对于历史的脏数据,可以使用 Admin API 软删除:

    curl -X POST -g 'http://localhost:9090/api/v1/admin/tsdb/delete_series?match[]={trace_id=~".+"}'
    

    执行后,数据不会立刻从磁盘消失,而是写入到 Block 目录下的 tombstones 文件中。后续的 Compaction 过程会读取该文件并真正剔除无用数据。如果需要强制立即清理磁盘,可调用:

    curl -X POST http://localhost:9090/api/v1/admin/tsdb/clean_tombstones
    

    常见问题 (FAQ)

    Q1:为什么通过 metric_relabel_configs 删除了高基数 Label,Prometheus 的物理内存(RES)并没有立刻下降? A:这是符合预期的。由于 Prometheus TSDB Head Block 的机制,数据通常要在内存中攒满 2 小时(加上最长允许的 1 小时 overlap)才会执行落盘并释放内存。即使新抓取的数据不再含有高基数标签,旧的庞大倒排索引依然存活在内存里。你需要耐心等待下一次 Head 切片,或者干脆重启进程,配合之前放宽的内存上限让 WAL 重放完成后,内存自然回落。

    Q2:Prometheus 发生 OOM 重启后,启动特别慢,日志一直卡在 Replaying WAL 是什么情况? A:Prometheus 只有正常退出时,才会将 Head Block 里的内容做 Checkpoint 或者全量 Flush 落盘。OOM 属于非正常崩溃,内存数据丢失。重启后,它必须逐行读取 data/wal/ 目录下的日志以在内存中重建倒排索引和 Chunks。如果 WAL 高达几十个 GB,这个过程将极其漫长(且高度依赖磁盘 IOPS)。建议将 TSDB 部署在企业级 NVMe SSD 上,这是监控系统的底线。

    Q3:我可以通过降低抓取频率(将 scrape_interval 从 15s 调整为 60s)来缓解高基数导致的 OOM 吗? A:不能,这是经典误区。scrape_interval 影响的是同一条 Series 每分钟追加的样本点数量。这部分数据被 Gorilla XOR 算法高效压缩,占用极小。导致 OOM 的是 Series 的总数(基数规模)膨胀,进而撑爆了不可压缩的倒排索引表。无论是 15s 抓取一次还是 1 分钟抓取一次,只要这几百万个带唯一 trace_id 的 Label 依然存在,生成的索引内存消耗是一模一样的。