Prometheus 面试题

graph TD
    A["Targets<br/>(Exporters)"] -->|"/metrics (Pull)"| B["Prometheus Server<br/>(TSDB + 采集)"]
    B --> C["Alertmanager"]
    B --> D["Grafana"]
    B --> E["Remote Storage"]

Pull 模型:
  - 长期运行的 Service/Worker
  - K8s 环境（Pod 生命周期匹配）
  - 需要健康检测的场景

Push 模型（Pushgateway/Remote Write）:
  - 批处理任务（CronJob、CI 任务）
  - 短生命周期任务
  - NAT 网络环境
  - 边缘设备采集

# rate() - 5m 内平均每秒请求数
rate(http_requests_total[5m])

# irate() - 最后两个点的瞬时速率
irate(http_requests_total[5m])

rate()：
  - 告警规则（避免峰值误告警）
  - 容量规划（关注趋势而非毛刺）
  - 长时间窗口（1h/1d）的聚合

irate()：
  - Grafana 图表（显示更精细的曲线）
  - 短时间窗口的快速指标
  - 故障排查（观察最新变化）

/data/
  ├── 01EM6Q6A1Z1Z1Z1Z1Z1Z1Z1Z1Z1/   # Block 目录（ULID 命名）
  │   ├── chunks/
  │   │   └── 000001                   # 压缩后的样本数据块
  │   ├── index                        # 倒排索引（Label → Series）
  │   ├── meta.json                    # Block 元数据（时间范围、样本数）
  │   ├── tombstones                   # 删除标记
  │   └── wal/                         # WAL（预写日志）
  │       ├── 000001.wal
  │       └── 000002.wal
  ├── 01EM6Q6A1Z1Z1Z1Z1Z1Z1Z1Z1Z2/
  ├── chunks_head/                     # 当前正在写入的 chunk
  │   └── 000001
  ├── wal/                             # 当前 WAL
  │   ├── 000003.wal
  │   └── 000004.wal
  └── lock                             # 文件锁

```mermaid
graph TD
    A["样本到达"] --> B["内存中 Head Chunk"]
    B -->|"写入 WAL（故障恢复）"| WAL["WAL"]
    B --> C["Head Chunk 满 2h"]
    C --> D["冻结"]
    D --> E["写入磁盘 Block"]
    E --> F["Block 压缩"]
    F --> G["合并"]
    G --> H["删除过期 Block"]

**压缩合并：**

scrape_configs:
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_label_app]
        action: keep
        regex: myapp
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: "true"

scrape_configs:
  - job_name: 'file-based-targets'
    file_sd_configs:
      - files:
          - /etc/prometheus/targets/*.json
        refresh_interval: 5m

relabel_configs:
  # 1. 只采集带有 annotation 的 Pod
  - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
    action: keep
    regex: "true"

  # 2. 设置采集路径
  - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
    action: replace
    target_label: __metrics_path__
    regex: (.+)

  # 3. 映射 K8s 标签到最终标签
  - source_labels: [__meta_kubernetes_pod_label_app]
    action: replace
    target_label: app

  # 4. 删除高基数标签
  - regex: "__meta_kubernetes_pod_uid|__meta_kubernetes_pod_controller_uid"
    action: labeldrop

  # 5. 保留特定标签
  - regex: "app|component|tier|namespace"
    action: labelkeep

1. 从 SD 获取 __meta_* 标签
2. 应用 relabel_configs（顺序执行）
3. 应用 metric_relabel_configs
4. 写入 TSDB

graph TD
    START["评估规则"] --> PENDING["Pending<br/>首次触发（未到 for 持续时间）"]
    PENDING -->|"for 持续期间"| FIRING["Firing<br/>持续触发（发送通知）"]
    FIRING -->|"规则恢复（不再触发）"| RESOLVED["Resolved<br/>已解决（可选发送）"]
    RESOLVED --> DONE["(恢复正常)"]

groups:
  - name: node-alerts
    interval: 10s
    rules:
      - alert: NodeCPUUsageHigh
        expr: (100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Node XQOPEN $labels.instance XQCLOSE CPU usage > 80%"
          description: "Node XQOPEN $labels.instance XQCLOSE CPU usage is XQOPEN $value | humanizePercentage XQCLOSE"

      - alert: NodeDiskSpaceFull
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) < 0.1
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Node XQOPEN $labels.instance XQCLOSE disk space < 10%"

route:
  receiver: 'default'
  routes:
    - match:
        severity: critical
      receiver: 'pagerduty'
    - match:
        severity: warning
      receiver: 'slack'

receivers:
  - name: 'pagerduty'
    pagerduty_configs:
      - routing_key: <key>
  - name: 'slack'
    slack_configs:
      - api_url: <webhook>
        channel: '#alerts'

groups:
  - name: node-recording
    interval: 1m
    rules:
      - record: node:node_cpu_utilization:ratio
        expr: (1 - avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])))

      - record: node:node_memory_utilization:ratio
        expr: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)

      - record: node:node_disk_utilization:ratio
        expr: (1 - avg by(instance, device) (rate(node_disk_io_time_seconds_total[5m])))

命名规范: level:metric:aggregation
  例如: node:node_cpu_utilization:ratio
  - level: 数据来源层（node/container/service）
  - metric: 指标名称
  - aggregation: 聚合方式（ratio/avg/p99/rate）

注意事项：
  - 避免递归引用
  - 设置合适的评估间隔
  - 监控记录规则的性能和资源消耗
  - 及时清理不再使用的记录规则

```mermaid
graph TD
    A["Prometheus Server"] -->|"Remote Write<br/>Snappy 压缩 + Protobuf 编码"| B["接收端<br/>Cortex / Thanos Receiver / VictoriaMetrics"]
    B --> C["长期存储 / 全局视图"]

**配置：**

```yaml
remote_write:
  - url: "http://thanos-receiver:19291/api/v1/receive"
    name: "thanos-receive"
    write_relabel_configs:
      - source_labels: [__name__]
        regex: "node_.*"
        action: keep
    queue_config:
      capacity: 2500
      max_samples_per_send: 500
      batch_send_deadline: 5s
      min_backoff: 30ms
      max_backoff: 100ms

remote_read:
  - url: "http://thanos-query:9090/api/v1/read"
    read_recent: true
    required_matchers:
      job: "node"

Remote Write:
  - 失败数据本地保留（队列持久化）
  - 配置 write_relabel_configs 控制写入范围
  - 监控 remote_storage_queue_highest_sent_timestamp_seconds

Remote Read:
  - 默认不查询远程（仅本地）
  - 设置 read_recent=true 包含近期数据
  - 查询性能取决于远程存储

1. URL 路径作为标签（/api/users/123 → 每个用户一个序列）
2. Request ID/UUID 作为标签
3. 用户 ID / Session ID 作为标签
4. 精确时间戳作为标签
5. IP 地址 + Port 组合

# 1. Relabel 丢弃高基数标签
metric_relabel_configs:
  - source_labels: [__name__]
    regex: "http_request_duration_seconds"
    action: keep
  - source_labels: [url]
    regex: "/api/users/[0-9]+"
    replacement: "/api/users/{id}"
    action: replace

# 2. 聚合降精度（Recording Rules）
record: service:http_requests_total:rate5m
expr: sum by(service, method, status) (rate(http_requests_total[5m]))

# 3. 限制采集标签数
scrape_configs:
  - job_name: 'myapp'
    params:
      collect[]: ['default']
    relabel_configs:
      - regex: "request_id|session_id|user_id"
        action: labeldrop

# 时间序列数量
count by (__name__) ({__name__=~".+"})

# 标签基数
count(count by (url) (http_requests_total))

# 内存中序列数
prometheus_tsdb_head_series

全局 Prometheus（Global View）
    │
    ├── 区域 Prometheus-A（Region-A）
    │   ├── 节点采集器（Node Exporters）
    │   └── 应用采集器（App Exporters）
    │
    ├── 区域 Prometheus-B（Region-B）
    │   ├── 节点采集器
    │   └── 应用采集器
    │
    └── Service Mesh Prometheus
        └── 服务指标

# 全局 Prometheus 配置（从区域 Prometheus 拉取聚合指标）
scrape_configs:
  # 联邦采集（拉取预聚合指标）
  - job_name: 'federate-region-a'
    scrape_interval: 30s
    honor_labels: true
    metrics_path: '/federate'
    params:
      'match[]':
        - '{__name__=~"node:.*"}'
        - '{__name__=~"service:.*"}'
    static_configs:
      - targets:
          - 'prometheus-region-a:9090'
  - job_name: 'federate-region-b'
    scrape_interval: 30s
    metrics_path: '/federate'
    params:
      'match[]':
        - '{__name__=~"node:.*"}'
    static_configs:
      - targets:
          - 'prometheus-region-b:9090'

1. honor_labels: true 保持原始标签
2. 只采集聚合指标，避免原始指标重复
3. 全局 Prometheus 资源消耗较低（仅存储聚合数据）
4. 区域性 Prometheus 故障不影响全局视图
5. 联邦非实时，存在数据延迟（取决于 scrape_interval）

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: example-app
spec:
  selector:
    matchLabels:
      app: example-app
  endpoints:
    - port: http
      interval: 15s
      path: /metrics
  namespaceSelector:
    matchNames:
      - default

apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: k8s
spec:
  replicas: 2
  resources:
    requests:
      memory: 4Gi
  storage:
    volumeClaimTemplate:
      spec:
        storageClassName: ssd
        resources:
          requests:
            storage: 100Gi
  serviceMonitorSelector:
    matchLabels:
      app: monitored
  ruleSelector:
    matchLabels:
      role: alert-rules

# 启动参数
--storage.tsdb.retention.time=15d    # 数据保留时间（默认 15d）
--storage.tsdb.retention.size=100GB  # 数据保留大小限制
--storage.tsdb.retention.size=0      # 0=不限大小

graph TD
    subgraph "2h 块"
        A["Block-A<br/>14:00-16:00"]
        B["Block-B<br/>16:00-18:00"]
        C["Block-C<br/>18:00-20:00"]
        D["Block-D<br/>20:00-22:00"]
    end
    A --> AB["Block-A+B<br/>10h 块"]
    B --> AB
    C --> CD["Block-C+D"]
    D --> CD
    AB --> ABCD["Block-A+B+C+D<br/>合并最终块"]
    CD --> ABCD

8 个样本/序列 × 16 bytes = 128 bytes/原始样本
压缩后平均 ~1.3 bytes/样本

估算公式:
  序列数 × 样本数 × 1.3 bytes = 存储大小

示例:
  100 万序列 × 15s 间隔 × 15d
  = 100万 × (86400/15 × 15) × 1.3
  ≈ 100万 × 86400 × 1.3
  ≈ 112GB

内存 ≈ 活跃序列数 × 每个序列占用（~2KB）

分解:
  - 倒排索引: ~序列数 × 标签数 × 100 bytes
  - Head Chunk: ~序列数 × (chunk 大小) = ~序列数 × 1KB
  - WAL 缓存: ~序列数 × 0.5KB
  - 查询缓存: 额外开销

# 1. 启动参数优化
--storage.tsdb.min-block-duration=2h    # 默认 2h
--storage.tsdb.max-block-duration=48h   # 最大块大小
--storage.tsdb.retention.time=15d
--storage.tsdb.retention.size=100GB

# 2. 资源限制
--memory.series=500000                  # 最大序列数限制
--memory.chunks=500000                  # 最大 chunk 数限制

# 3. 采集优化
scrape_configs:
  - job_name: 'myapp'
    scrape_interval: 30s                 # 降低采集频率
    scrape_timeout: 10s
    relabel_configs:
      - action: labeldrop                # 丢弃高基数标签
        regex: "tmp|temp|request_id"

# TSDB Head 序列数
prometheus_tsdb_head_series

# 内存中的 Chunk 数
prometheus_tsdb_head_chunks

# 内存使用率
process_resident_memory_bytes / process_virtual_memory_bytes

# 每个序列的内存估算
process_resident_memory_bytes / prometheus_tsdb_head_series

scrape_configs:
  # 1. Pod 采集（基于 annotation）
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: "true"
      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
        action: replace
        regex: ([^:]+)(?::\d+)?;(\d+)
        replacement: $1:$2
        target_label: __address__

  # 2. Service 采集（基于 label）
  - job_name: 'kubernetes-services'
    kubernetes_sd_configs:
      - role: service
    relabel_configs:
      - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
        action: keep
        regex: "true"

  # 3. Node 采集
  - job_name: 'kubernetes-nodes'
    kubernetes_sd_configs:
      - role: node
    relabel_configs:
      - action: labelmap
        regex: __meta_kubernetes_node_label_(.+)

  # 4. Kubelet 采集
  - job_name: 'kubernetes-kubelet'
    kubernetes_sd_configs:
      - role: node
    scheme: https
    tls_config:
      ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
    bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
    relabel_configs:
      - target_label: __address__
        replacement: kubernetes.default.svc:443
      - source_labels: [__meta_kubernetes_node_name]
        regex: (.+)
        target_label: __metrics_path__
        replacement: /api/v1/nodes/$1/proxy/metrics

graph TD
    PROM["Prometheus"] -->|"Alert"| AM["Alertmanager"]
    AM --> GOSSIP["Gossip (Mesh)"]
    GOSSIP --> A["A"]
    GOSSIP --> B["B"]
    GOSSIP --> C["C"]
    AM --> SLACK["Slack"]
    AM --> EMAIL["Email"]

# Alertmanager 启动参数（三个节点）
alertmanager --cluster.listen-address=0.0.0.0:9094 \
             --cluster.peer=alertmanager-0:9094 \
             --cluster.peer=alertmanager-1:9094 \
             --cluster.peer=alertmanager-2:9094 \
             --config.file=/etc/alertmanager/alertmanager.yml

# 配置多个 Alertmanager
alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - alertmanager-0:9093
            - alertmanager-1:9093
            - alertmanager-2:9093
    scheme: http
    timeout: 10s
    api_version: v2

1. Prometheus 将告警发送到所有 Alertmanager 节点
2. Alertmanager 通过 Gossip 同步告警通知状态
3. 已发送的通知不会被重复发送（去重）
4. 一个节点故障，其他节点继续处理
5. 分组和抑制规则在所有节点一致

- 告警通知的已发送状态
- 静默规则
- 节点成员变更

# 瞬时查询
curl 'http://localhost:9090/api/v1/query?query=up{job="node"}&time=1717000000'

# 范围查询
curl 'http://localhost:9090/api/v1/query_range?query=rate(http_requests_total[5m])&start=1717000000&end=1717003600&step=15'

# 标签值查询
curl 'http://localhost:9090/api/v1/label/__name__/values'

# 创建快照
curl -XPOST 'http://localhost:9090/api/v1/admin/tsdb/snapshot'

/data/wal/
  ├── 000001.wal          # WAL 文件（按序号递增）
  ├── 000002.wal
  ├── 000003.wal
  └── checkpoint.000002/  # WAL 检查点
      ├── 000000.wal
      └── 000001.wal

```mermaid
graph TD
    A["样本到达"] --> B["写入 WAL（先写日志）"]
    B --> C["写入内存 Head Chunk（后写数据）"]
    C --> D["批量提交（2h 后冻结）"]
    D --> E["冻结 Chunk"]
    E --> F["删除对应 WAL 段"]
    F --> G["写入 Block"]

**故障恢复：**

**WAL 配置：**

```bash
--storage.tsdb.wal-compression          # WAL 压缩（默认开启）
--storage.tsdb.wal-segment-size=128MB   # WAL 段大小（默认 128MB）

默认过期时间: 5 分钟（从最新样本开始）

判定逻辑:
  当前时间 - 最新样本的时间戳 > 5m → 标记为 stale
  标记为 stale 后 → 查询中不返回该序列

Stale Marker:
  目标离线时，Prometheus 写入一个 Stale NaN
  Stale Marker 后的序列在下次采集前不可见

# 查询结果受 stale 影响
up{job="node"}  # 如果 node 离线 >5m → 不返回结果

# rate() 函数对 stale 的处理
rate(http_requests_total[5m])  # 5m 窗口内无新数据 → 返回 0

# 使用 offset 可以查询即使被 staleness 的数据
up offset 10m  # 查 10 分钟前的数据

# 对于 pushgateway 这类非持续采集的目标
scrape_configs:
  - job_name: 'pushgateway'
    honor_labels: true
    static_configs:
      - targets: ['pushgateway:9091']

# 使用 keep_dropped_targets 配置保留周期

最佳实践：
  - 标签基数控制在 < 100 个唯一值
  - 区分维度（service、method、status）而非实体（user_id、request_id）
  - 统一命名风格（蛇形命名）
  - 标签值有界（method ∈ [GET,POST,PUT,DELETE]）
  - 避免在标签中嵌入可变信息（IP、时间戳）

反例：
  http_requests_total{user_id="12345", request_id="abc-def", timestamp="1717000000"}
  → 每个请求产生新序列，基数爆炸

正例：
  http_requests_total{service="api-gateway", method="GET", status="200"}
  → 序列数有限，可聚合

规则评估不能快于数据采集：
  evaluation_interval >= scrape_interval
  否则规则评估时取到的是重复的旧数据

PromQL 窗口大小建议 >= 4 × scrape_interval：
  rate(metric[5m]) 对 15s 采集间隔是合理的（20 个样本点）
  rate(metric[1m]) 对 15s 采集间隔偏小（4 个样本点）

global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - 'alerts.yml'
  - 'recording.yml'

groups:
  - name: example
    interval: 30s         # 覆盖全局 evaluation_interval
    rules:
      - alert: ...

```mermaid
graph TD
    A["批处理/CronJob"] --> B["生成 .prom 文件<br/>（自定义指标格式）"]
    B --> C["Node Exporter 定期读取<br/>（--collector.textfile.directory）"]
    C --> D["与 Node Exporter 指标合并"]
    D --> E["Prometheus 采集 /metrics"]

**使用场景：**

**配置示例：**

```bash
# Node Exporter 启动
./node_exporter --collector.textfile.directory=/var/lib/node_exporter/textfile

# CronJob 生成指标
#!/bin/bash
echo "# HELP backup_last_success Backups last success timestamp" > /var/lib/node_exporter/textfile/backup.prom
echo "# TYPE backup_last_success gauge" >> /var/lib/node_exporter/textfile/backup.prom
echo "backup_last_success $(date +%s)" >> /var/lib/node_exporter/textfile/backup.prom

# HELP my_metric Description
# TYPE my_metric gauge
my_metric{label="value"} 42 1717000000

```mermaid
graph TD
    A["批处理任务"] -->|"Push<br/>HTTP PUT/POST"| B["Pushgateway (:9091)"]
    B -->|"Pull<br/>/metrics"| C["Prometheus Server"]

**正确场景 vs 错误场景：**

| 场景 | 是否推荐 | 原因 |
|------|---------|------|
| **CronJob 执行结果** | 推荐 | 任务执行完即消失 |
| **CI/CD 流水线** | 推荐 | Pipeline 执行状态 |
| **批处理脚本** | 推荐 | 无法长期运行 |
| **Service 指标** | 不推荐 | 应使用 Pull 模型 |
| **高频率指标** | 不推荐 | Pushgateway 成为瓶颈 |
| **实例级指标** | 不推荐 | 无法区分实例 |

**操作示例：**

```bash
# 推送单个指标
echo "job_duration_seconds 42.5" | curl --data-binary @- http://pushgateway:9091/metrics/job/myjob

# 推送带标签的指标
cat <<EOF | curl --data-binary @- http://pushgateway:9091/metrics/job/myjob/instance/myinstance
# TYPE job_success gauge
job_success{status="completed"} 1
# TYPE job_duration_seconds gauge
job_duration_seconds 42.5
EOF

# 删除 job 的所有指标
curl -X DELETE http://pushgateway:9091/metrics/job/myjob

1. Pushgateway 是"指标缓存"，不持久化
2. 务必在任务结束时 DELETE 清理指标
3. Pushgateway 不是 Prometheus 的替代品
4. 使用 honor_labels: true 保留 job/instance 标签
5. 监控 Pushgateway 自身指标（pushgateway_metrics_total）

# blackbox-exporter 配置
modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2"]
      valid_status_codes: [200, 301, 302]
      preferred_ip_protocol: "ip4"

  tcp_connect:
    prober: tcp
    timeout: 5s

  icmp:
    prober: icmp
    timeout: 5s
    icmp:
      preferred_ip_protocol: "ip4"

  dns:
    prober: dns
    dns:
      query_name: "example.com"
      query_type: "A"
      valid_rcodes: [NOERROR]

scrape_configs:
  - job_name: 'blackbox-http'
    metrics_path: /probe
    params:
      module: [http_2xx]
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox-exporter:9115
    static_configs:
      - targets:
          - 'https://example.com'
          - 'https://api.example.com/health'

  - job_name: 'blackbox-icmp'
    metrics_path: /probe
    params:
      module: [icmp]
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox-exporter:9115
    static_configs:
      - targets:
          - '192.168.1.1'
          - '10.0.0.1'

graph TD
    TA["Target-A"] --> P1["Prom-1"]
    TB["Target-B"] --> P2["Prom-2"]
    P1 --> GRAFANA["Grafana<br/>(PromQL 聚合)"]
    P2 --> GRAFANA

graph TD
    TA["Target-A"] --> P1["Prom-1<br/>+Sidecar"]
    TB["Target-B"] --> P2["Prom-2<br/>+Sidecar"]
    P1 --> TQ["Thanos<br/>Query"]
    P2 --> TQ
    TQ --> G["Grafana"]

双跑:
  - RTO: 分钟级（切换查询源）
  - RPO: 近零（双写）
  - 资源: 2× 存储和计算

Thanos:
  - RTO: 秒级（Query 无状态）
  - RPO: 近零（对象存储）
  - 资源: Prometheus + Sidecar + 对象存储

VictoriaMetrics:
  - RTO: 秒级（无状态组件）
  - RPO: 近零（副本机制）
  - 资源: VictoriaMetrics 集群

graph TD
    subgraph "1. 符号表 Symbol Table"
        A["'up' → ID=1<br/>'job' → ID=2<br/>'instance' → ID=3<br/>'api-server' → ID=4<br/>'localhost:9090' → ID=5<br/>..."]
    end
    subgraph "2. 倒排索引 Posting"
        B["job='api-server' → [1,5,10,15,...]<br/>instance='local' → [1,2,3,4,...]<br/>__name__='up' → [1,2,5,8,...]"]
    end
    subgraph "3. 序列文件 Series"
        C["Series ID: 1<br/>Labels: job='api-server'<br/>instance='localhost:9090'<br/>Chunks: [chunk1, chunk2]"]
    end
    A --> B --> C

up{job="api-server", instance="localhost:9090"}

1. 查找 __name__="up" → Posting List A [1, 2, 5, 8]
2. 查找 job="api-server" → Posting List B [1, 5, 10, 15]
3. 查找 instance="localhost:9090" → Posting List C [1, 2, 3]
4. Intersect(A, B, C) → [1]
5. 通过 Series ID=1 获取 Chunk 和样本数据

格式:
  metric_name{labels} value timestamp # {trace_id="abc123", span_id="def456"} 42

示例:
  http_request_duration_seconds_bucket{method="GET",le="0.1"} 15 1717000000 # {trace_id="abc123", span_id="def456"} 0.095

# Prometheus Server 开启 Exemplar 存储
--enable-feature=exemplar-storage

# 存储配置（默认 100000 个 Exemplar）
--storage.tsdb.exemplar-exemplars-per-series=100

# 查询 Exemplar 数据
http_request_duration_seconds_bucket{trace_id="abc123"}

# API 查询
GET /api/v1/query_exemplars?query=http_request_duration_seconds_bucket

1. 高延迟请求 → 查看具体 Trace
   发现 P99 延迟 > 1s，通过 Exemplar 找到对应的 Trace ID

2. 错误请求 → 关联详细日志
   Metrics 显示错误率升高，查 Exemplar 获取 Trace ID

3. 慢查询追踪
   Database 延迟异常，关联到具体的查询 Trace

# 慢查询（全序列扫描）
avg without(cpu, mode)(
  rate(node_cpu_seconds_total[5m])
)

# 优化（先缩小范围）
avg by(instance, mode)(
  rate(node_cpu_seconds_total{mode!="idle"}[5m])
)

# 使用记录规则预计算
groups:
  - name: prometheus_recording
    interval: 1m
    rules:
      - record: service:http_requests:rate1m
        expr: sum by(service, method, status) (rate(http_requests_total[1m]))

# 增加本地缓存
--storage.tsdb.retention.time=30d
--storage.tsdb.min-block-duration=2h
--query.max-concurrency=20
--query.timeout=2m
--query.max-samples=50000000

# Prometheus 采集带认证的目标
scrape_configs:
  - job_name: 'authenticated-target'
    scheme: https
    tls_config:
      ca_file: /etc/prometheus/ca.crt
      cert_file: /etc/prometheus/client.crt
      key_file: /etc/prometheus/client.key
      insecure_skip_verify: false
    basic_auth:
      username: 'prometheus'
      password_file: /etc/prometheus/.password
    # 或 Bearer Token
    authorization:
      type: Bearer
      credentials_file: /etc/prometheus/token
    # 或 OAuth2
    oauth2:
      client_id: 'prometheus'
      client_secret_file: /etc/prometheus/client_secret
      token_url: 'https://auth.example.com/token'
      scopes: ['metrics:read']

# Alertmanager Basic Auth
alerting:
  alertmanagers:
    - scheme: https
      tls_config:
        ca_file: /etc/prometheus/ca.crt
      basic_auth:
        username: 'alertmanager'
        password: '<password>'
      static_configs:
        - targets: ['alertmanager.example.com:9093']

# Nginx 反向代理 Prometheus API
server {
    listen 443 ssl;
    server_name prometheus.example.com;

    location / {
        auth_basic "Prometheus";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://localhost:9090;
    }

    location /api/v1/ {
        # 只允许特定角色访问写 API
        if ($request_method = POST) {
            satisfy any;
            allow 10.0.0.0/8;
            deny all;
        }
        proxy_pass http://localhost:9090;
    }
}