想象你是一座大型智慧社区新上任的物业经理。社区里有几十栋楼,住着不同租户(应用),楼顶有配电房、水泵房、中央空调机房。你要为整个社区建一套“状态巡检体系”:哪些设备在健康运转,哪些已经过载,近期用电走势如何。你不能给每家装电话让他们自己汇报——那样太乱、也永远不知道谁没打来。于是你决定派巡检员定期上门抄表。这就是 Prometheus 的核心思路:主动拉取(pull),而不是被动接收。接下来的旅程中,你会跟着物业团队一步步完成:挑选合适的智能仪表(Exporter)、建立住户自动登记册(服务发现)、搭建账本档案室(TSDB)、把老账本归档到城市档案馆(长期存储)、建立分区物业中心并汇总到总部(联邦与高可用),最后为算力大厦装上专用传感器(GPU 与推理监控)。这条路走完,你就掌握了构建一套可扩展的 Prometheus 指标采集平台的全部关键决策。

岗位关联

掌握 Prometheus 指标采集全链路设计,是云原生平台工程师搭建可观测性底座的核心能力,能直接支撑大规模集群的容量规划与稳定性保障。

目录
  1. 可视化演示
  2. 核心架构理念
  3. Exporter选型
  4. 服务发现机制
  5. 数据存储方案
  6. 长期存储方案
  7. 联邦集群高可用
  8. 云原生生态整合
  9. AI场景监控
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

本节配有交互动效(进入视口后自动加载,约 3KB)。

核心架构理念

小李接手了一座大型智慧社区。社区里几十栋楼、上百套设备,第一件事是定规矩:设备状态怎么上报?有人提议给每家装部电话,让住户主动打来报数——可这样物业会接到成百上千通电话,谁没打、谁家电话坏了,你根本说不清。小李坚持另一套方案:巡检员按固定路线、固定周期,亲自上门查表。查表时发现哪家门敲不开,立刻就知道出了问题。这就是 Prometheus 的 pull 模型:采集器不等待上报,而是主动发起 HTTP 请求,到目标暴露的 /metrics 端点取数。

这套“上门抄表”的思路贯穿整个平台设计。每个被采集的对象(目标)都是一个“住户”,通过 Exporter 把内部状态翻译成标准指标。Prometheus 的指标模型由三部分组成:指标名、标签和样本值。指标名说明“这是什么”(比如总请求数),标签说明“这是哪一类的”(哪个接口、哪个服务),样本值就是当时的读数。

按照数值性质,指标分为四类:Counter 只增不减,适合累计请求数;Gauge 可增可减,适合当前温度、内存水位;Histogram 记录数值分布区间;Summary 记录分位数。一条完整的时间序列长这样:

账本条目一旦有了“哪栋楼、哪根水管、什么时间”这些标签,物业想统计任意切片——比如“所有 GET 请求”“所有 5 开头错误”——只需按标签过滤后聚合,不用改任何埋点。选对命名和标签设计,是整套巡检体系的第一块地基。

http_requests_total{method="GET",code="200"}=1024\displaystyle \text{http\_requests\_total}\{ \text{method} = "GET", \text{code} = "200" \} = 1024
这条公式表示:方法为 GET 且返回码为 200 的请求,截止到当前时刻累计共 1024 次。
  1. 指标名称http_requests_total 是这条序列的名字,好比账本上的“总请求量”这一条目。
    http_requests_total\text{http\_requests\_total}
  2. 标签组花括号里用键值对描述维度,method 与 code 两个标签把总量拆成不同切片,便于后续聚合。
    {method="GET",code="200"}\{ \text{method} = "GET", \text{code} = "200" \}
  3. 样本值等号右侧的 1024 是当前读数,配合时间戳就构成一个数据点。
    =1024= 1024

Exporter选型

确定“上门抄表”后,小李发现每台设备长着不同的“表盘”——MySQL 的内部计数器、Redis 的内存统计、Nginx 的连接数,格式五花八门。Prometheus 无法直接读懂每家设备,需要一种“翻译电表”:Exporter。它把软件内部状态翻译成统一格式的指标,暴露在一个 /metrics 端点,供巡检员读取。

选择 Exporter 有三条路。官方 Exporter 是国标电表,node_exporter、mysqld_exporter、redis_exporter 等由 Prometheus 社区维护,质量最稳;第三方 Exporter 是经过认证的仪表,kube-state-metrics 等由云原生生态维护;自研 Exporter 是定制的专用表,用官方 SDK 在业务代码里暴露自定义指标。选型时先问三个问题:维护方是否活跃、暴露的指标基数有多大、每次抓取的开销是否可控。

电表通常只记录累计度数,但物业真正关心的是“最近一小时耗电增速”。Prometheus 通过 rate 函数从 Counter 类指标计算速率:

选好表、读好数,还要留意“表本身别出错”——抓取超时、重试、把用户 ID 放进标签,都会撑爆账本。如同物业不会给每台设备都装最贵的传感器,合理控制指标基数,才能让整套系统轻盈可扩展。

rate(http_requests_total[5m])=ΔcounterΔt\displaystyle \text{rate}(\text{http\_requests\_total}[5m]) = \frac{\Delta \text{counter}}{\Delta t}
rate 的通俗理解:把 5 分钟窗口首尾的累计读数相减,再除以时间,得到每秒平均增速。
  1. Counter 累计值http_requests_total 是从 0 开始只增不减的计数,单独看它无法判断请求是快是慢。
    http_requests_total\text{http\_requests\_total}
  2. 时间窗口[5m] 表示取最近 5 分钟的样本序列,窗口越短越灵敏、越长越平滑。
    [5m][5m]
  3. 增量比时间用窗口内计数增量除以时长,得到每秒请求速率。
    ΔcounterΔt\frac{\Delta \text{counter}}{\Delta t}

服务发现机制

小区住户流动性大,三号楼搬来一家创业公司,五号楼撤走一个机房。如果物业手里的住户名单靠手写,巡检员就会敲错门、漏抄表。幸运的是,在云原生社区里,Kubernetes 的 API Server 就是那本实时更新的“住户登记册”——每个 Pod、Service、Endpoints 的起落都会自动登记。

Prometheus 通过服务发现机制订阅这份登记册,支持多种来源:最常遇见的 kubernetes_sd_configs 直接对接 API Server;虚拟机或物理机场景常用 file_sd_configs 读取文件;云厂商可用 ec2_sd_configs。服务发现产出的是目标列表,还需要 relabeling(标签重写)来处理:筛选掉不该采集的命名空间、把服务名映射成统一标签。经过筛选后,真正纳入采集的目标数是:

服务发现的意义在于“人走不误事”:Pod 扩容到 20 个副本,登记册自动更新,巡检员下一轮抄表就多跑 20 家;Pod 崩溃,目标消失,Prometheus 立刻标记下线。物业团队从此告别手工维护 target 清单,这是平台能横向扩展的关键前提。

Tactive=Tdiscovered−Tdropped\displaystyle T_{\text{active}} = T_{\text{discovered}} - T_{\text{dropped}}
这个减法说明:并非登记册里所有目标都会被采集,relabel 规则是唯一的“闸门”。
  1. 发现总数T_discovered 是服务发现从登记册中自动发现的目标总数,如 50 个 Pod。
    TdiscoveredT_{\text{discovered}}
  2. 筛选剔除T_dropped 是经 relabel 规则(排除命名空间、标签正则不匹配等)被丢弃的目标数。
    TdroppedT_{\text{dropped}}
  3. 实际采集两者相减,得到真正进入采集队列、会被巡检员上门的目标数。
    Tactive=Tdiscovered−TdroppedT_{\text{active}} = T_{\text{discovered}} - T_{\text{dropped}}

数据存储方案

巡检员每天抄回数百条读数,总得有个地方归档。Prometheus 自带的 TSDB(时间序列数据库)就是物业的账本档案室。数据按时间戳组织,每两小时形成一个 block 区块——好比账本每隔两天装订成一册;写入前先落 WAL 预写日志,如同会计先在草稿本上记账、再誊抄到正式账本,防止断电丢账。

档案室面积有限,账本不能无限堆积。TSDB 默认保留 15 天,到期区块自动清理。设计容量时,磁盘空间按四要素估算:

生产环境还要考虑持久化——为 Prometheus 挂载持久卷,避免 Pod 重建导致账本丢失;本地盘和云盘按吞吐量选择。当序列数超过几十万时,单机 TSDB 会逼近性能上限,这时就该考虑后面的联邦与长期存储方案。理解“本地存储是有限资源”这个前提,才能顺理成章地引入档案馆。

D=Nseries×Ssample×fscrape×Tretention\displaystyle D = N_{\text{series}} \times S_{\text{sample}} \times f_{\text{scrape}} \times T_{\text{retention}}
以 100 条序列、15 秒抓取一次、保留 15 天、每样本 2 字节估算,约需 17 MB。
  1. 序列数N_series 是所有指标名与标签组合的总数,例如 100 条不同维度的时间序列。
    NseriesN_{\text{series}}
  2. 样本体积S_sample 是单个样本在磁盘上占用的字节数,经验值约 1~2 字节。
    SsampleS_{\text{sample}}
  3. 抓取频率f_scrape 是每秒抓取次数,15 秒一次即 1/15。
    fscrape=115f_{\text{scrape}} = \frac{1}{15}
  4. 保留时长T_retention 是数据保留秒数,15 天即 1,296,000 秒;四者相乘就是磁盘需求。
    Tretention=15×86400T_{\text{retention}} = 15 \times 86400

长期存储方案

年底物业要出一份年度用电报告,需要一年前的逐时数据,可小区账本只留了 15 天。怎么办?小李决定把老账本定期“扫描归档”到城市档案馆——归档后把原件清理掉,小区只留近期账本,查询历史时再去档案馆调阅。这套体系在 Prometheus 世界里的名字叫 Thanos。

Thanos 由几个核心组件组成:Sidecar 跟随每个 Prometheus 实例,把本地 block 上传到对象存储(S3、MinIO、OSS 等);Querier 作为统一查询入口,同时读取本地和归档数据,对外表现成一个超大 Prometheus。为了压缩成本、加快查询,归档数据会做降采样——把高精度原始点合并成低精度摘要:

除了 Thanos,Cortex 是另一条路线:多租户、分布式、兼容 PromQL。无论哪条路,核心设计理念一致:本地存储管“热”数据,对象存储管“冷”数据,查询层透明路由。城市档案馆让物业不必扩建自家档案室,还让历史数据“要啥有啥”——这就是长期存储的价值。

S5m=Sraw60,S1h=S5m12\displaystyle S_{5m} = \frac{S_{\text{raw}}}{60}, \qquad S_{1h} = \frac{S_{5m}}{12}
降采样后,一年前的数据点只需原始规模的约七百二十分之一,查询速度大幅提升。
  1. 原始样本S_raw 表示每 5 秒一个点的高精度原始数据量。
    SrawS_{\text{raw}}
  2. 五分钟桶每 60 个原始点聚合为 1 个 5 分钟桶,数据量降为六十分之一。
    S5m=Sraw60S_{5m} = \frac{S_{\text{raw}}}{60}
  3. 小时桶再把 12 个 5 分钟桶聚合为 1 个 1 小时桶,进一步缩减十二倍。
    S1h=S5m12S_{1h} = \frac{S_{5m}}{12}

联邦集群高可用

社区版图越来越大,分成东区、西区、南区十几个分区,每个分区都有自己的物业中心。总部领导不关心某个机房的细节,但想看全社区的总览。解决方案是层级汇报:每个分区 Prometheus 先把本区数据抓齐,总部通过联邦机制从分区汇总。

联邦抓取利用 /federate 端点,顶层 Prometheus 按 match[] 参数选择需要汇总的指标,类似总部只要求分区上报“大类指标”而不是全部细账。同时,高可用依赖双副本:每个分区部署两个完全相同的 Prometheus 实例,抓同一批目标。查询端(如 Thanos Querier)对两个副本的结果做去重,告警端 Alertmanager 做分组与抑制,避免同一问题触发两次告警。汇总出的在线目标总数可以用公式表达:

双人轮班加总部汇总,物业体系既不怕单个巡检员请假,也能在总部一张屏上纵览全局。联邦不是越多层越好——层级过深会增加查询延迟,一般控制在两层以内,与组织架构一样保持扁平。

Nonline=sum(up{cluster="east"})\displaystyle N_{\text{online}} = \text{sum}(\text{up}\{ \text{cluster} = "east" \})
这条公式汇总出东部集群当前在线的目标总数,是联邦大屏上最常见的“健康读数”。
  1. 存活指标up 是 Prometheus 为每个目标自动生成的指标,值为 1 表示在线、0 表示离线。
    up\text{up}
  2. 标签选择花括号中的 cluster="east" 把范围限定在东部集群。
    {cluster="east"}\{ \text{cluster} = "east" \}
  3. 求和聚合sum 把所有在线目标求和,得到东部集群当前的在线目标总数。
    sum(up{cluster="east"})\text{sum}(\text{up}\{ \text{cluster} = "east" \})

云原生生态整合

社区里的电梯、供水、中央空调由不同厂商维护,但物业不需要自己研究每台设备的内部结构——厂商都装了标准传感器。K8s 集群同样自带三个“标准传感器”:node_exporter 采集主机层的 CPU、内存、磁盘、网络;cadvisor 嵌在 Kubelet 中采集每个容器的资源使用;kube-state-metrics 从 API Server 读取 Deployment、ReplicaSet、Pod 的期望与实况。三者叠加,形成“机器—容器—工作负载”三层观测。

实际部署常借助 kube-prometheus-stack(Prometheus Operator 全家桶),一键把 Prometheus、三大 Exporter、Grafana、告警规则装进集群。通过 ServiceMonitor 声明“哪些服务要被抓取”,Prometheus 自动更新抓取配置,无需手工改文件。容器 CPU 利用率是最常看的指标之一:

公共传感器装好,物业的“公共设施巡检盘”就齐了。但在 AI 时代,社区里还有一类特殊设备不在标准传感器覆盖范围内——算力大厦里的 GPU,这正是下一节的主角。

Ucpu=rate(container_cpu_usage_seconds_total[1m])\displaystyle U_{\text{cpu}} = \text{rate}(\text{container\_cpu\_usage\_seconds\_total}[1m])
它把容器累计的 CPU 秒数转换成一分钟平均利用率,对应“电梯这个月累计运行了多少小时”与“现在是否满负荷”之间的换算。
  1. 累计 CPU 秒container_cpu_usage_seconds_total 记录容器从启动以来累计消耗的 CPU 时间。
    container_cpu_usage_seconds_total\text{container\_cpu\_usage\_seconds\_total}
  2. 速率转换rate 在 1 分钟窗口内求每秒增量,把累计值转成每秒消耗的 CPU 秒数。
    rate(container_cpu_usage_seconds_total[1m])\text{rate}(\text{container\_cpu\_usage\_seconds\_total}[1m])
  3. 百分比口径结果乘以 100 即 CPU 利用率百分比,与配额 limit 对比可判断是否打满。
    Ucpu×100%U_{\text{cpu}} \times 100\%

AI场景监控

社区数据中心新装了几百张 GPU 卡,每张价值数万,利用率直接决定运营成本。普通电表(node_exporter)只能看到整机功耗,看不到 GPU 内部的算力引擎是否空转。NVIDIA 提供了专用传感器 DCGM Exporter,暴露 SM 利用率、显存占用、温度、功耗等细粒度指标。

除了硬件,AI 推理服务本身也需要“出餐监控”:请求量(QPS)反映客流量,P99 延迟反映最慢的出餐节奏,批处理大小与队列长度反映厨房拥堵情况。这些指标通过在推理服务中埋点暴露,常用的延迟指标是直方图(Histogram),Prometheus 用 histogram_quantile 估算分位数:

有了这些指标,弹性伸缩才有依据:GPU 利用率长期低于 30% 就触发缩容或合并批处理;推理 P99 超过 200ms 就触发扩容或切流。告警联动 K8s HPA 与 Cluster Autoscaler,形成“感知—决策—执行”闭环。至此,从普通住宅到算力大厦,从公共设施到 AI 服务,整套巡检体系覆盖了社区每一个角落。

p99=histogram_quantile(0.99,sum_rate(inference_duration_seconds_bucket[5m]))\displaystyle \text{p99} = \text{histogram\_quantile}(0.99, \text{sum\_rate}(\text{inference\_duration\_seconds\_bucket}[5m]))
p99 的意思是 99% 的请求延迟都小于该值,它比平均值更能暴露“少数慢请求拖垮体验”的问题。
  1. 直方图桶inference_duration_seconds_bucket 是延迟直方图,每个桶记录“延迟不超过该值”的请求累计数。
    inference_duration_seconds_bucket\text{inference\_duration\_seconds\_bucket}
  2. 速率求和sum_rate 在 5 分钟窗口求各桶增速,再跨实例求和得到集群级分布。
    sum_rate(inference_duration_seconds_bucket[5m])\text{sum\_rate}(\text{inference\_duration\_seconds\_bucket}[5m])
  3. 分位插值histogram_quantile(0.99) 在相邻桶之间插值,估算出第 99 百分位延迟。
    histogram_quantile(0.99,…)\text{histogram\_quantile}(0.99, \ldots)

AI 应用场景

云原生平台可观测性底座建设

阶段:数据采集与基础设施监控

解决的问题:传统方式要登录每台机器手动查看 CPU、内存,再逐个检查服务是否存活,规模一大就完全失控。基于 Prometheus 的 kube-prometheus-stack 可以在 K8s 集群一键部署,自动发现所有节点、容器与工作负载,配合 Grafana 大屏可视化,将“人找故障”变成“指标找故障”。

具体案例:某互联网公司对 5 个生产集群、500 台节点统一接入指标体系,共管理 2 万条时间序列。节点宕机后 1 分钟内在告警群收到 up 指标跳变通知,定位时间从小时级缩短到分钟级。

电商大促容量预测与弹性扩容

阶段:容量预测与弹性调度

解决的问题:大促前人工估算 QPS 常常偏差巨大——估少了系统雪崩,估多了资源浪费。利用历史指标(rate、increase 函数)分析订单接口的流量曲线,可以预测峰值 QPS,配合 HPA 在高峰期自动扩容 Pod,低谷期自动缩容。

具体案例:某电商在双 11 前基于近 30 天订单接口的 rate 指标外推峰值,提前扩容 3 倍并配置 80% 水位告警;大促当天实际峰值与预测偏差小于 15%,全程无容量事故。

AI 推理平台 GPU 成本优化

阶段:AI 服务运维与成本治理

解决的问题:GPU 利用率低却无人感知,推理延迟偶发超标却定位不到瓶颈。通过 DCGM Exporter 采集 GPU 利用率与显存,结合推理服务的直方图延迟指标,可以量化“每张卡到底在忙什么”,驱动缩容、合并 batch、调度优化。

具体案例:某 LLM 推理平台监控 200 张 A100 显卡,发现平均利用率仅 35%。通过指标驱动缩容 40 张卡并调大 batch 大小,整体成本下降约 40%,P99 延迟保持稳定。

Python 演示

python57 行
import timeimport randomfrom collections import deque  class FakeEndpoint:    """模拟一个暴露指标的 exporter, 每次抓取读数小幅增长"""     def __init__(self, name, base):        self.name = name        self.value = base     def scrape(self):        """模拟一次抓取, 返回 (指标名, 标签, 值, 时间戳)"""        self.value += random.uniform(0.1, 1.0)        return (self.name, {"job": "demo"}, round(self.value, 2), time.time())  class MiniPrometheus:    """简化版 Prometheus: 周期拉取目标并保存时间序列"""     def __init__(self, interval=1):        self.interval = interval        self.endpoints = []        self.series = {}        self.series_max = 60     def register(self, endpoint):        self.endpoints.append(endpoint)     def scrape_once(self):        """对每个目标执行一次拉取, 类似巡检员上门抄表"""        for ep in self.endpoints:            name, labels, value, ts = ep.scrape()            key = (name, frozenset(labels.items()))            bucket = self.series.setdefault(key, deque())            bucket.append((ts, value))            if len(bucket) > self.series_max:                bucket.popleft()        print("[%s] 完成一轮拉取, 序列数=%d" % (            time.strftime("%H:%M:%S"), len(self.series)))     def run(self, rounds):        for _ in range(rounds):            self.scrape_once()            time.sleep(self.interval)     def latest(self):        return {k[0]: v[-1][1] for k, v in self.series.items() if v}  if __name__ == "__main__":    prom = MiniPrometheus(interval=1)    prom.register(FakeEndpoint("node_cpu_seconds", 12))    prom.register(FakeEndpoint("http_requests_total", 35))    prom.run(5)    print("最新读数:", prom.latest())
目的:用约 50 行代码演示 Prometheus 的 pull 采集、序列存储与保留策略三大机制,可直接运行观察输出。
  1. key = (name, frozenset(labels.items()))把指标名与标签组转换成不可变键,确保每个“账本页”唯一。
  2. bucket = self.series.setdefault(key, deque())为每类指标维护一个队列,相当于给每类电表单独开一页账本。
  3. bucket.popleft()队列超过 60 个点就丢掉最旧的,模拟 retention 保留策略。
  4. ep.scrape()采集器主动调用目标暴露的方法,而不是等目标上报,这正是 pull 模型的核心动作。
  5. time.sleep(self.interval)两次抄表之间的间隔,对应 Prometheus 的 scrape_interval。
  6. prom.register(FakeEndpoint("http_requests_total", 35))把目标注册进采集列表,对应服务发现中的目标注册。

常见误区

误区我以为是应用自己把指标“打电话”报告给 Prometheus,这样服务端最省事,像日志上报一样。

正解恰恰相反,Prometheus 默认是 pull 模型,服务端按 scrape_interval 主动访问目标的 /metrics 端点。拉取的好处是服务端掌握节奏,能立即发现目标是否存活,也避免大量应用同时推送造成拥塞。只有短生命周期任务(批处理)才借助 Pushgateway 中转,而 Pushgateway 本身也是被 Prometheus 拉取的,并不是应用直推。

为何常见:很多人从日志上报、调用链上报的习惯出发,想当然地认为监控也是上行推送,忽略了 pull 模型在存活探测上的天然优势。

误区我打算把所有能找到的 Exporter 都装进集群,每个服务都暴露几百个指标,这样监控最全面、最放心。

正解每个 Exporter 都会产生几十到几百条指标序列,指标泛滥会让存储、查询、告警全面变慢,甚至拖垮采集器。正确做法是按需选型:优先官方维护的 Exporter,评估每类指标的基数(series 数),去掉无用标签,定期用 tsdb 分析工具检查高基数序列。就像物业不会给每把椅子都装传感器,只为影响安全的设备装。

为何常见:这是典型的“监控焦虑”——害怕漏掉关键数据,于是全量采集,反而制造了新的稳定性风险。

误区Prometheus 自带 TSDB,我把 --storage.tsdb.retention.time 改成 365 天,不就能存一年数据了吗?

正解本地存储受磁盘容量限制,默认 15 天是有依据的。调大保留时间只是把问题推迟,磁盘写满会导致整个采集链路失败。需要月级、年级历史数据时,应该用 Thanos 或 Cortex 把 block 归档到对象存储,查询时透明路由——小区账本放不下,就送去城市档案馆。

为何常见:习惯了单机时代“数据永久落盘”的思维,忽略了时序数据随抓取频率线性增长的速度。

误区我部署了两个完全一样的 Prometheus 副本,各抓各的目标,这样任何一台挂了都有数据,不就是高可用了?

正解双副本虽然实现了冗余,但两个副本会各自产生完整数据,查询端会出现重复序列;同样的告警规则会被触发两次,形成告警风暴。需要配合查询层去重(如 Thanos Querier 的 dedup)、Alertmanager 的分组与抑制、以及合理的联邦层级,才能真正实现高可用。

为何常见:把“冗余”等同于“高可用”,忽略了分布式系统中一致性和重复数据带来的新问题。

误区node_exporter 不是能看到 CPU、内存、磁盘吗?GPU 也是硬件,装上它应该就能监控 AI 服务的状态了。

正解node_exporter 只暴露主机层面的资源,看不到 GPU 内部的 SM 利用率、显存、温度、功耗,也看不到推理服务的 QPS 与延迟。GPU 需要 NVIDIA 官方的 DCGM Exporter;推理服务需要在应用内用 client_golang 暴露延迟直方图等业务指标。普通电表测不出超算的“算力利用率”,必须用专用传感器。

为何常见:以为“主机监控”覆盖所有硬件,不了解 AI 硬件与推理服务有专属的指标域。

面试题

Q1. Prometheus 默认采用哪种指标采集方式?

单选题 · easy

  • A.服务端定期拉取目标指标← 正确答案
  • B.目标主动推送指标到服务端
  • C.中间件转发指标到消息队列
  • D.人工脚本批量导入指标数据

答案:A。Prometheus 采用 pull 模型,采集器定期访问目标对象的 /metrics 端点拉取数据。推送模式只适用于短生命周期批处理任务(经 Pushgateway 中转),且中转节点本身仍是拉取方式。选项 A 准确描述了“巡检员上门抄表”的主动拉取行为。

Q2. 下列哪类指标描述的是“只增不减”型数值?

单选题 · easy

  • A.Counter 计数器← 正确答案
  • B.Gauge 仪表盘
  • C.Histogram 直方图
  • D.Summary 摘要

答案:A。Counter 类型的指标只增不减,适合累计请求数、累计错误数;Gauge 可增可减,适合内存水位、温度;Histogram 与 Summary 用于统计分布。只增不减的计数器就像电表上的累计度数,永远不会回拨。

Q3. 在 Kubernetes 中,Prometheus 最常通过什么机制自动发现采集目标?

单选题 · easy

  • A.人工维护静态配置文件
  • B.查询 API Server 发现目标← 正确答案
  • C.容器内部主动向服务端注册
  • D.使用 DNS 广播协议枚举

答案:B。K8s 环境中使用 kubernetes_sd_configs 对接 API Server,自动发现 Pod、Service、Endpoints 等资源,就像物业订阅社区的自动住户登记册。人工维护文件无法应对 Pod 频繁扩缩容;容器主动注册违背 pull 模型;DNS 广播不适用于云原生网络。

Q4. 联邦架构中,顶层 Prometheus 通过哪个端点汇总下级数据?

单选题 · mid

  • A.抓取端点 /metrics 指标
  • B.联邦端点 /federate 数据← 正确答案
  • C.查询端点 /api/v1/query
  • D.目标端点 /api/v1/targets

答案:B。联邦架构中顶层 Prometheus 抓取下级 Prometheus 的 /federate 端点,并通过 match[] 参数筛选需要汇总的指标。/metrics 是普通目标的指标端点,/api/v1/query 是用户查询接口,/targets 是调试用的目标列表端点。

Q5. 磁盘估算公式 D=N×S×f×T 中,字母 S 表示什么?

单选题 · hard

  • A.每秒写入样本的数量
  • B.单个样本占用的字节数← 正确答案
  • C.指标序列的基数总量
  • D.两次拉取的间隔秒数

答案:B。公式中 N 是序列数、S 是每样本字节数(约 1~2 字节)、f 是每秒抓取次数、T 是保留秒数。S 描述的是“一笔账目占多厚一页纸”,而不是写入速度或抓取间隔。理解每个符号的物理含义,才能正确估算容量。

Q6. 监控 NVIDIA GPU 利用率,推荐使用的采集器是?

单选题 · mid

  • A.主机通用采集器 node
  • B.GPU 专用采集器 DCGM← 正确答案
  • C.数据库采集器 mysqld
  • D.黑盒探针采集器 blackbox

答案:B。DCGM Exporter 是 NVIDIA 官方的 GPU 指标采集器,暴露利用率、显存、温度、功耗等专属指标。node_exporter 只能看主机整体状态,看不到 GPU 内部算力引擎的忙碌程度;mysqld 和 blackbox 分别针对数据库与网络探测,与 GPU 无关。

Q7. 降采样 downsampling 的主要作用是什么?

单选题 · mid

  • A.提升历史数据的采样精度
  • B.压缩长期历史数据的体积← 正确答案
  • C.缩短指标的抓取时间间隔
  • D.增加指标数据的标签维度

答案:B。降采样把高精度原始点合并成低精度摘要(如 raw → 5m → 1h),大幅压缩长期历史数据的体积,同时降低查询成本。它不会提升精度,也不会改变抓取频率或标签维度,而是用“牺牲细节换空间”的策略让年度级历史查询成为可能。

Q8. Prometheus 长期存储的常见方案有哪些?

多选题 · mid

  • A.Thanos 对接对象存储归档数据← 正确答案
  • B.Cortex 提供分布式存储方案← 正确答案
  • C.node_exporter 直接写本地磁盘
  • D.调大 Prometheus 本地磁盘容量

答案:AB。Thanos 把本地 block 归档到对象存储并统一查询,Cortex 提供多租户分布式存储,都是成熟的长期存储方案。node_exporter 只负责暴露指标,不承担存储职责;调大本地磁盘只是延迟问题,受单机容量上限约束。

Q9. 关于 Prometheus 高可用架构,正确的说法是?

多选题 · hard

  • A.双副本会产生重复数据,查询需去重← 正确答案
  • B.联邦架构可支撑多层级水平扩展← 正确答案
  • C.部署多套副本即可满足全部高可用
  • D.告警端需配合抑制与分组降噪← 正确答案

答案:ABD。双副本是冗余的基础,但会引入重复序列,查询端需要去重(如 Thanos Querier);多副本之间若不配合去重与告警抑制,反而可能造成告警风暴。联邦架构支持分层扩展,Alertmanager 的分组抑制是告警高可用的必要组成部分。仅仅“部署多套副本”不等于高可用。

Q10. 某集群有 100 条序列,抓取间隔 15 秒,保留 15 天,每样本约 2 字节,本地存储约需多大?

单选题 · extreme

  • A.约 1.7 MB
  • B.约 17 MB← 正确答案
  • C.约 170 MB
  • D.约 1.7 GB

答案:B。按公式 D=N×S×f×T 计算:15 天为 1,296,000 秒,每序列样本数 = 1,296,000÷15 = 86,400 个;100 条序列共 8,640,000 个样本;每样本 2 字节,得 17,280,000 字节,约 16.5 MB,最接近 17 MB。这道题考察四个参数能否正确代入公式,是容量规划的基本功。