Thanos 面试题

graph TD
    P1["Prom-1<br/>+Sidecar"] --> OS["对象存储 (S3/GCS)<br/>(Store Gateway 读取)"]
    P2["Prom-2<br/>+Sidecar"] --> OS
    P3["Prom-3<br/>+Sidecar"] --> OS
    OS --> TQ["Thanos Query<br/>(全局查询 + 去重)"]
    TQ --> Grafana["Grafana"]

Query → Store API (gRPC) → Sidecar (Prometheus 实时数据)
Query → Store API (gRPC) → Store Gateway (对象存储历史数据)
Query → Store API (gRPC) → Ruler (规则产生的指标)
Query → Store API (gRPC) → Receiver (Remote Write 数据)
Ruler → Store API (gRPC) → Query (用于规则评估)
Compactor → 对象存储 (读取和写入压缩后的数据)

graph TD
    A["Prometheus Server<br/>每 2h 生成一个 Block"] --> B["WAL to Head to<br/>冻结 Block 2h"]
    B --> C["Sidecar 检测到新 Block"]
    C -->|"上传路径"| D["上传到对象存储 S3/GCS<br/>压缩后的 Block 数据<br/>保留原始格式"]
    C -->|"查询路径"| E["提供 Store API<br/>gRPC :10901<br/>查询 Prometheus 实时数据<br/>返回 Head 中未压缩数据"]

# Pod 定义
containers:
  - name: prometheus
    image: prom/prometheus:v2.50.0
    args:
      - --storage.tsdb.retention.time=2h   # 仅保留 2h（数据已上传）
      - --storage.tsdb.min-block-duration=2h
      - --storage.tsdb.max-block-duration=2h
  - name: thanos-sidecar
    image: quay.io/thanos/thanos:v0.34.0
    args:
      - sidecar
      - --tsdb.path=/prometheus
      - --prometheus.url=http://localhost:9090
      - --objstore.config-file=/etc/thanos/objstore.yml
      - --grpc-address=0.0.0.0:10901
      - --http-address=0.0.0.0:10902

type: S3
config:
  bucket: thanos-metrics
  endpoint: s3.amazonaws.com
  access_key: AKIA...
  secret_key: ...
  insecure: false
  signature_version2: false
  put_user_metadata:
    "X-Amz-Storage-Class": "STANDARD_IA"

graph TD
    B1["Block-1<br/>(08:00)"] --> Merged["Merged Block<br/>(08:00-14:00)<br/>- 去重<br/>- 重新索引<br/>- 更小体积"]
    B2["Block-2<br/>(10:00)"] --> Merged
    B3["Block-3<br/>(12:00)"] --> Merged
    B4["Block-4<br/>(14:00)"] --> Merged

原始数据 (Raw):
  分辨率: 原始采集间隔（通常 15s）
  保留: 30 天

降采样 5m (5m):
  分辨率: 5 分钟聚合
  保留: 90 天
  数据量: 原始 × 1/20

降采样 1h (1h):
  分辨率: 1 小时聚合
  保留: 365 天
  数据量: 原始 × 1/240

# Compactor 启动参数
thanos:
  compactor:
    retentionResolutionRaw: 30d
    retentionResolution5m: 180d
    retentionResolution1h: 365d
    compactInterval: 1h
    consistencyDelay: 30m
    dataDir: /data
    blockFilesConcurrency: 10
    maxDownloadBlockSize: 64GB

Query 自动选择最佳分辨率:
  查询时间范围 < 30d → 原始数据（最高精度）
  30d < 查询时间范围 < 180d → 5m 降采样
  查询时间范围 > 180d → 1h 降采样

去重前提：两个时间序列具有完全相同的 Label Set

Thanos Sidecar 上传时自动添加:
  - replica: "0"  (从 Prometheus externalLabels 中继承)
  - thanos_replica: "0"

去重逻辑:
  1. Query 从多个 Store API 获取相同序列
  2. 比较标签集（排除 replica/thanos_replica）
  3. 标签相同时，选择时间戳最大的样本
  4. 丢弃副本标签，返回唯一序列

# Query 端去重（默认开启）
--query.replica-label=replica
--query.replica-label=thanos_replica

# 关闭去重（调试用）
--query.replica-label=""

# 没有去重 → 返回重复序列
  up{instance="node1", job="node", replica="0"} 1
  up{instance="node1", job="node", replica="1"} 1
  up{instance="node2", job="node", replica="0"} 1
  up{instance="node2", job="node", replica="1"} 1

# 去重后 → 返回唯一序列
  up{instance="node1", job="node"} 1
  up{instance="node2", job="node"} 1

graph TD
    Prom["Prometheus"] -->|Remote Write| RCVR
    subgraph RCVR["Thanos Receiver"]
        SA["Store API (gRPC)"] --> Q["Query 实时查询"]
        TSDB["TSDB"] --> L["本地存储（短期）"]
        OSS["对象存储"] --> LT["长期存储"]
    end

# Receiver 配置
thanos:
  receiver:
    # 接收端 gRPC
    grpcAddress: 0.0.0.0:10901
    # Remote Write HTTP
    httpAddress: 0.0.0.0:10902
    # 对象存储（长期）
    objstoreConfig:
      type: S3
      config:
        bucket: thanos-receive
    # 本地 TSDB 保留期
    tsdbRetention: 24h
    # 一致性哈希分片
    hashring:
      - hashring: default
        endpoints:
          - thanos-receiver-0:10901
          - thanos-receiver-1:10901
          - thanos-receiver-2:10901
    # 转发配置
    forwardTimeout: 5s

Ruler 规则评估流程:

1. 查询数据
   Ruler → Store API → Query/Sidecar/Store Gateway

2. 评估规则
   根据 PromQL 计算记录规则和告警规则

3. 存储结果
   记录规则的结果 → 写入 Ruler 本地 TSDB
   告警 → 发送到 Alertmanager

4. 暴露结果
   Ruler TSDB → Store API → Query 可以查询

thanos:
  ruler:
    # 查询端
    queryEndpoints:
      - thanos-query:10901
    # 告警端
    alertmanagers:
      - alertmanager:9093
    # 规则文件
    ruleFiles:
      - /etc/thanos/rules/*.yaml
    # 数据存储
    dataDir: /data
    # 评估间隔
    evalInterval: 30s
    # 对象存储
    objstoreConfig:
      type: S3
      config:
        bucket: thanos-ruler

groups:
  - name: thanos-rules
    interval: 30s
    rules:
      - record: thanos:node_cpu:avg_usage
        expr: avg by (instance) (rate(node_cpu_seconds_total{mode!="idle"}[5m]))
      - alert: HighLatency
        expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m])) > 5
        for: 5m

thanos:
  store:
    # Index Cache (内存)
    indexCacheSize: 2GB
    indexCacheType: inmemory

    # Chunk Cache (内存)
    chunkCacheSize: 4GB
    chunkCacheType: inmemory

    # Memcached 缓存后端
    # indexCacheType: memcached
    # memcached:
    #   addresses: ['memcached:11211']
    #   timeout: 500ms

    # 其他缓存配置
    maxRetries: 3
    maxItemSize: 64MB
    blockSyncInterval: 5m
    consistencyDelay: 30m

# 缓存命中率
rate(thanos_store_index_cache_hits_total[5m])
/
rate(thanos_store_index_cache_requests_total[5m])

# Chunk 缓存
rate(thanos_store_chunk_cache_hits_total[5m])
/
rate(thanos_store_chunk_cache_requests_total[5m])

# S3
type: S3
config:
  bucket: thanos-bucket
  endpoint: s3.amazonaws.com
  region: us-east-1
  access_key: AKIA...
  secret_key: ...
  insecure: false
  signature_version2: false
  put_user_metadata:
    "X-Amz-Storage-Class": "STANDARD_IA"
  http_config:
    idle_conn_timeout: 90s
    response_header_timeout: 2m
    insecure_skip_verify: false
  sse_config:
    type: SSE-S3

# GCS
type: GCS
config:
  bucket: thanos-gcs-bucket
  service_account: |
    {
      "type": "service_account",
      "project_id": "my-project"
    }    

# MinIO (S3 兼容)
type: S3
config:
  bucket: thanos-minio
  endpoint: minio:9000
  region: us-east-1
  access_key: minioadmin
  secret_key: minioadmin
  insecure: true

# 本地文件测试
type: FILESYSTEM
config:
  directory: /tmp/thanos-test

Query 查询流程:

1. 用户发起查询（时间范围 T1-T2）
2. Query 检查时间范围大小
3. 根据范围选择分辨率:
   - T2-T1 < 30d → 查询原始数据
   - 30d < T2-T1 < 180d → 查询 5m 降采样
   - T2-T1 > 180d → 查询 1h 降采样
4. 发送 Store API 请求到 Store Gateway
5. 返回对应分辨率的数据

thanos query \
  --query.auto-downsampling  # 自动降采样（默认开启）

# 已降采样的数据块
thanos_compact_downsampled_total

# 降采样延迟
thanos_compact_downsample_duration_seconds

# 降采样数据大小
thanos_store_data_blocks{resolution="5m"}
thanos_store_data_blocks{resolution="1h"}

# 查看 1 年内的 CPU 使用率趋势
# Query 自动使用 1h 降采样数据
avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[1h]))

# 强制使用原始数据查询
avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[1h])) @ start()

# 列出所有 Block
thanos bucket ls --objstore.config-file=objstore.yml

# 检查数据块一致性
thanos bucket verify --objstore.config-file=objstore.yml

# 检查重复块
thanos bucket inspect --objstore.config-file=objstore.yml

# 删除过期的降采样数据
thanos bucket retention --objstore.config-file=objstore.yml \
  --retention.resolution-raw=0d \
  --retention.resolution-5m=180d \
  --retention.resolution-1h=365d \
  --dry-run

# 数据块标记（标记需要 Compactor 处理的块）
thanos bucket label --objstore.config-file=objstore.yml \
  --metric=__block_id \
  --value=compactme

# 块总数
thanos_bucket_store_blocks_loaded

# 块大小分布
thanos_bucket_store_block_duration_seconds

# 列表操作延迟
thanos_bucket_store_series_data_fetch_duration_seconds

# Bucket 操作失败
rate(thanos_bucket_store_operation_failures_total[5m])

graph TD
    CA["集群 A: Thanos<br/>(Sidecar + Store + Query-A)"] --> GQ["Thanos Query (Global)<br/>(查询所有集群的 Store)"]
    CB["集群 B: Thanos<br/>(Sidecar + Store + Query-B)"] --> GQ
    CC["集群 C: Thanos<br/>(Sidecar + Store + Query-C)"] --> GQ
    GQ --> GF["Grafana"]

# 全局 Query 通过 Store API 连接多个集群
thanos:
  query:
    # 静态 Store
    stores:
      - thanos-query-cluster-a:10901
      - thanos-query-cluster-b:10901
      - thanos-query-cluster-c:10901

    # DNS 发现
    store.sd-files:
      - /etc/thanos/store-sd.yaml
    store.sd-interval: 5m

# 每个集群的 Sidecar 注入集群标签
sidecar:
  externalLabels:
    cluster: cluster-a
    environment: production
# 查询时按标签过滤
query:
  # 存储端标签
  store.labels:
    - replica
    - cluster

# 查询特定集群的数据
up{cluster="cluster-a"}

# 按集群聚合
count by (cluster) (up)

# 多集群对比
avg by (cluster) (rate(node_cpu_seconds_total[5m]))

service Store {
  // 查询时间序列
  rpc Series(SeriesRequest) returns (stream SeriesResponse);
  
  // 获取标签名
  rpc LabelNames(LabelNamesRequest) returns (LabelNamesResponse);
  
  // 获取标签值
  rpc LabelValues(LabelValuesRequest) returns (LabelValuesResponse);
  
  // 获取存储信息
  rpc Info(InfoRequest) returns (InfoResponse);
}

graph TD
    A["User Query PromQL"] --> B["Thanos Query"]
    B --> C["1. 向所有 Store 发送<br/>LabelValues 请求<br/>获取标签信息"]
    B --> D["2. 向所有 Store 发送<br/>Series 请求<br/>标签匹配器 + 时间范围"]
    B --> E["3. 接收所有 Store 返回的流式数据"]
    E --> E1["Sidecar 实时数据"]
    E --> E2["Store Gateway 历史数据"]
    E --> E3["Ruler 规则结果"]
    E --> E4["Receiver Remote Write 数据"]
    E1 & E2 & E3 & E4 --> F["4. 合并数据流"]
    F --> F1["按时间戳排序"]
    F --> F2["去重 replica 标签"]
    F1 & F2 --> G["Query Result"]

每个 Store 返回自己的元数据:
  LabelSets: 标签范围（如 cluster="a"）
  MinTime: 最早数据时间
  MaxTime: 最新数据时间
  StoreType: Sidecar/Store/Ruler/Receiver

1. Prometheus 版本 >= v2.2.1（支持存储 Block 上传）
2. 开启 --web.enable-admin-api（Sidecar 需要读取 TSDB 状态）
3. 设置 --storage.tsdb.min-block-duration=2h（默认即可）
4. 设置 --storage.tsdb.max-block-duration=2h（避免合并）
5. 配置 externalLabels（用于区分副本）

# Prometheus 配置（与 Sidecar 配合）
--storage.tsdb.retention.time=2h    # 仅保留 2h（数据已上传到对象存储）
--storage.tsdb.min-block-duration=2h
--storage.tsdb.max-block-duration=2h
--web.enable-admin-api              # Sidecar 需要
--web.enable-lifecycle              # Sidecar 需要

# AWS S3 存储类配置
type: S3
config:
  bucket: thanos-metrics
  put_user_metadata:
    "X-Amz-Storage-Class": "STANDARD_IA"  # 30 天后自动转为 STANDARD_IA

# 或者依赖 S3 生命周期策略
# S3 Lifecycle Rule:
#   - 当前版本: 30d → STANDARD_IA, 60d → GLACIER, 365d → EXPIRED

原始数据量: 每天 100GB
压缩比: ~10:1（Prometheus TSDB）
每月存储: 100GB × 30 / 10 = 300GB

降采样存储:
  原始 30d: 100GB × 30 = 300GB
  5m 降采样额外 90d: 300GB × (90/30) / 20 = 45GB
  1h 降采样额外 245d: 300GB × (245/30) / 240 = 10GB
  总计: 355GB

S3 存储成本:
  标准 (300GB): $0.023/GB = $6.90/月
  STANDARD_IA (45GB): $0.0125/GB = $0.56/月
  GLACIER (10GB): $0.004/GB = $0.04/月
  总计: ~$7.50/月

thanos:
  query:
    # 并行度
    maxConcurrent: 20
    maxConcurrentSelects: 10
    
    # 超时
    timeout: 2m
    lookbackDelta: 5m
    
    # Store 连接
    store.sd-interval: 5m
    store.responseTimeout: 10s
    
    # 查询优化
    auto-downsampling: true
    query.partial-response: false

  store:
    # 缓存
    indexCacheSize: 4GB
    chunkCacheSize: 8GB
    
    # 块同步
    blockSyncInterval: 5m
    consistencyDelay: 30m

1. 精确匹配标签
   up{instance="node1"}  → 快速（利用索引）
   up{job=~".+node"}     → 慢（全扫描）

2. 缩小时间范围
   查询 1h 数据 < 查询 24h 数据 < 查询 7d 数据

3. 利用降采样
   长时间范围查询 → 自动使用降采样数据

4. 减少查询的序列数
   按需聚合（sum by）而非返回所有原始序列

5. 使用记录规则
   预计算高频查询

原始块（未合并）:
  Block-A (prom-1, 08-10h)
  Block-B (prom-1, 10-12h)
  Block-C (prom-2, 08-10h)
  Block-D (prom-2, 10-12h)

Compactor 合并后:
  Block-AB (prom-1, 08-12h, 合并后的索引)
  Block-CD (prom-2, 08-12h, 合并后的索引)

多副本写入（同一序列写入多个 Block）:
  Series:
    node_cpu_seconds_total{instance="node1", mode="idle", replica="0"} @ T=1, value=100
    node_cpu_seconds_total{instance="node1", mode="idle", replica="1"} @ T=1, value=100

Compactor 去重（dedup）:
  消除 replica 标签差异
  选择时间戳最近的样本
  输出唯一序列:
    node_cpu_seconds_total{instance="node1", mode="idle"} @ T=1, value=100

# Sidecar 必须配置 externalLabels 以便去重识别
sidecar:
  externalLabels:
    prometheus_cluster: prometheus-a
    replica: 0

thanos:
  compactor:
    # 去重标记
    dedup.func: dedup
    # 合并延迟（等待所有副本上传完成）
    consistencyDelay: 30m
    # 合并间隔
    compactInterval: 1h
    # 最大待合并块数
    maxDownloadBlockSize: 64GB
    # 并发数
    blockFilesConcurrency: 10

# K8s Headless Service 方式
apiVersion: v1
kind: Service
metadata:
  name: thanos-store-gateway
spec:
  clusterIP: None
  selector:
    app: thanos-store
  ports:
    - name: grpc
      port: 10901

# Query 自动 DNS 发现
thanos:
  query:
    store.sd-dns-interval: 30s
    # 自动解析 DNS SRV 记录
    # _grpc._tcp.thanos-store-gateway.monitoring.svc.cluster.local

# /etc/thanos/store-sd.yaml
- targets:
    - thanos-sidecar-0:10901
    - thanos-sidecar-1:10901
  labels:
    cluster: prod-us-east
- targets:
    - thanos-store-0:10901
    - thanos-store-1:10901
  labels:
    type: store-gateway

多副本 Ruler:
  Ruler-A (replica=0) + Ruler-B (replica=1)

评估行为:
  两个 Ruler 评估相同的规则
  各自产生相同的数据
  通过 replica 标签区分
  Query 端去重

故障切换:
  Ruler-A 故障 → Ruler-B 继续服务
  不丢失告警和记录规则数据

thanos:
  ruler:
    replicas: 2
    evaluationInterval: 30s
    queryEndpoints:
      - thanos-query:10901
    alertmanagers:
      - alertmanager:9093
    externalLabels:
      ruler_replica: $(POD_NAME)
    ruleFiles:
      - /etc/thanos/rules/*.yaml

# 列出所有 Block
thanos tools bucket list \
  --objstore.config-file=objstore.yml

# 检查存储一致性
thanos tools bucket verify \
  --objstore.config-file=objstore.yml \
  --repair=false \
  --delete-blocks=false

# 检查重复块
thanos tools bucket inspect \
  --objstore.config-file=objstore.yml

# 数据块标记（用于 Compactor 处理）
thanos tools bucket label \
  --objstore.config-file=objstore.yml \
  --metric=__block_id \
  --value=compactme

# 删除标记的块
thanos tools bucket cleanup \
  --objstore.config-file=objstore.yml \
  --delete-delay=48h

# 数据保留管理
thanos tools bucket retention \
  --objstore.config-file=objstore.yml \
  --retention.resolution-raw=30d \
  --retention.resolution-5m=180d \
  --retention.resolution-1h=365d \
  --dry-run

# 块损坏修复
thanos tools bucket repair \
  --objstore.config-file=objstore.yml \
  --max-time=2h \
  --dry-run

# 索引重建
thanos tools bucket rewrite \
  --objstore.config-file=objstore.yml \
  --rewrite.to-block-id=<block-id>

Namespace: thanos

  Sidecar (与 Prometheus 同 Pod):
    prometheus + thanos-sidecar

  Store Gateway (Deployment):
    Store Gateway (2 副本)
    Service: thanos-store

  Query (Deployment):
    Query (2 副本)
    Service: thanos-query

  Compactor (StatefulSet/Job):
    Compactor (1 副本)
    PVC: 10GB

  Ruler (StatefulSet):
    Ruler (2 副本)
    PVC: 50GB

# values.yaml
query:
  enabled: true
  replicas: 2
  stores:
    - thanos-store:10901
    - thanos-sidecar:10901

store:
  enabled: true
  replicas: 2
  objstoreConfig:
    type: S3
    config:
      bucket: thanos-store
      endpoint: s3.amazonaws.com

compactor:
  enabled: true
  persistence:
    size: 10Gi
  objstoreConfig:
    type: S3
    config:
      bucket: thanos-compactor
      endpoint: s3.amazonaws.com
  retentionResolutionRaw: 30d
  retentionResolution5m: 180d
  retentionResolution1h: 365d

ruler:
  enabled: true
  replicas: 2
  alertmanagers:
    - http://alertmanager:9093
  queryEndpoints:
    - thanos-query:10901

Thanos:
  - 已有对象存储基础设施
  - 需要完全的 Prometheus 兼容性
  - 多集群统一查询
  - 团队熟悉微服务运维

VictoriaMetrics:
  - 追求运维简洁和低资源消耗
  - 需要更高的存储压缩比
  - 单集群大规模监控
  - 资源受限环境

# Thanos 组件启动参数（Jaeger 集成）
thanos:
  query:
    tracing.config: |
      type: JAEGER
      config:
        service_name: thanos-query
        sampler_type: const
        sampler_param: 1
        reporter:
          localAgentHostPort: jaeger-agent:6831      

每个查询请求的 Trace 包含:
  1. Query → Store API 请求
  2. Store Gateway 的索引查找
  3. Store Gateway 的块读取
  4. 对象存储的 GET 请求
  5. Query 端的数据合并和去重

通过 Trace 可以定位:
  - 哪个 Store 响应最慢
  - 对象存储的延迟瓶颈
  - 数据量大小

# Query 状态
GET /api/v1/status/tsdb       # TSDB 状态
GET /api/v1/status/store       # Store 连接状态
GET /api/v1/labels             # 标签列表

# Store 状态
GET /api/v1/status/blocks      # 已加载的块
GET /metrics                   # Prometheus 指标

# Compactor 状态
GET /api/v1/status/groups      # 压缩分组状态

# 日志级别
GET /debug/pprof/              # Go pprof 分析
GET /-/ready                   # 就绪检查
GET /-/healthy                 # 健康检查

1. 检查组件状态
   kubectl get pods -n thanos
   kubectl logs thanos-query-xxx -n thanos

2. 检查对象存储
   thanos tools bucket verify --objstore.config-file=objstore.yml

3. 检查 Store 连接
   curl thanos-query:10902/api/v1/status/store

4. 检查块状态
   curl thanos-store:10902/api/v1/status/blocks

5. 检查内存
   kubectl top pods -n thanos

6. 检查重启次数
   kubectl get pods -n thanos | grep CrashLoopBackOff

# 1. 对象存储跨区域复制
# AWS S3 CRR (Cross-Region Replication)
aws s3api put-bucket-replication \
  --bucket thanos-source \
  --replication-configuration file://crr-config.json

# 2. 定期 Bucket 快照
# 备份到另一个 Bucket
thanos tools bucket replicate \
  --objstore.config-file=source.yml \
  --objstore.target-config=backup.yml \
  --resolution=raw \
  --max-time=7d

# 3. 增量备份脚本
#!/bin/bash
# 每日增量备份到不同 Bucket
backup_bucket="thanos-backup-$(date +%Y%m%d)"
aws s3 sync s3://thanos-prod/ s3://$backup_bucket/

恢复步骤:

1. 确认故障范围
   - 单 Prometheus 故障 → 从对象存储恢复
   - 整个 Thanos 集群故障 → 重建集群
   - 对象存储不可用 → 使用备份

2. 重建 Thanos 集群
   helm install thanos ./thanos -f values.yaml

3. 恢复数据
   # 从备份 Bucket 恢复数据
   thanos tools bucket replicate \
     --objstore.config-file=backup.yml \
     --objstore.target-config=prod.yml \
     --resolution=raw

4. 验证数据完整性
   thanos tools bucket verify --objstore.config-file=prod.yml

5. 恢复查询服务
   # Query 自动发现 Store Gateway
   # 数据恢复后自动可查

对象存储多 AZ:
  RPO: 近零（同步复制）
  RTO: 分钟级（切换 AZ）

跨区域复制:
  RPO: 15 分钟（异步复制）
  RTO: 分钟级（切换 DNS）

定期备份:
  RPO: 24 小时（日备份）
  RTO: 小时级（恢复数据）

# 查看块标签
thanos tools bucket inspect \
  --objstore.config-file=objstore.yml

# 为块添加标签
thanos tools bucket label \
  --objstore.config-file=objstore.yml \
  --metric=__block_id \
  --value=compactme

# 根据标签选择
thanos tools bucket label \
  --objstore.config-file=objstore.yml \
  --metric=environment \
  --value=production \
  --selector='__block_id=compactme'

# Compactor 仅处理特定标签的块
thanos:
  compactor:
    # 标签选择器
    block-sync-concurrency: 20
    # 忽略指定标签的块
    block-label-drop:
      - unneeded-label
    # 选择要压缩的块
    block-files-concurrency: 10

# 每个 Sidecar/Receiver 的 externalLabels
thanos:
  sidecar:
    externalLabels:
      cluster: prod-us-east
      prometheus_replica: $(POD_NAME)
      replica: 0

  receiver:
    externalLabels:
      cluster: prod-us-east
      receiver: $(POD_NAME)

graph TD
    GF["Grafana"] --> QF["Query Frontend (HTTP)"]
    QF -->|缓存查询结果| Cache["Cache<br/>(Memcached/Redis/内存)"]
    Cache --> TQ["Thanos Query (gRPC)"]
    TQ --> SG["Store Gateway / Sidecar"]

thanos:
  queryFrontend:
    enabled: true
    # 缓存后端
    cache:
      type: memcached
      config:
        addresses:
          - memcached:11211
        timeout: 500ms
        maxItemSize: 1MB
    # 缓存配置
    splitQueriesByInterval: 24h
    maxRetries: 3
    # 响应缓存
    responseCacheSize: 100MB
    responseCacheTTL: 10m

缓存命中条件:
  - 完全相同的 PromQL 查询
  - 相同的标签匹配器
  - 相同的时间范围
  - 相同的 Step

缓存失效:
  - TTL 过期（默认 10 分钟）
  - 手动清理（DELETE /cache）
  - 缓存容量满（LRU 淘汰）

阶段 1: 上载
  Sidecar/Receiver → 对象存储
  状态: 不可查询（未超过一致性延迟）
  延迟: 30 分钟（consistencyDelay）

阶段 2: 可用
  状态: 可通过 Store Gateway 查询
  持续: 直到被 Compactor 处理

阶段 3: 压缩
  Compactor 合并小 Block
  状态: 原始块被标记为删除
  查询: 过渡期内新旧块同时可用

阶段 4: 降采样
  Compactor 生成低分辨率数据
  状态: 原始数据可选保留
  查询: 根据时间范围自动选择

阶段 5: 删除
  超过保留期
  状态: 从对象存储中删除
  触发: Compactor 定期清理

T+0h    Block 上传到对象存储
T+30m   一致性延迟结束，可查询
T+2h    小 Block 等待被合并
T+24h   首次 Compactor 处理
T+30d   原始数据保留期结束（可选删除）
T+180d  5m 降采样保留期结束
T+365d  1h 降采样保留期结束

graph TD
    subgraph Raw["原始块 (Raw)"]
        R1["时间序列: 15s 分辨率<br/>样本: 20,000 点/天/序列<br/>大小: ~1MB/块"]
    end
    subgraph DS5m["5m 降采样块"]
        D1["时间序列: 5m 分辨率<br/>聚合函数: min/max/avg<br/>样本: 288 点/天/序列<br/>大小: ~50KB/块<br/>数据量: 原始 x 1/20"]
    end
    subgraph DS1h["1h 降采样块"]
        H1["时间序列: 1h 分辨率<br/>聚合函数: min/max/avg<br/>样本: 24 点/天/序列<br/>大小: ~4KB/块<br/>数据量: 原始 x 1/240"]
    end
    Raw --> DS5m --> DS1h

# 原始数据查询
avg by (instance) (rate(node_cpu_seconds_total[5m]))
# 返回: 15s 精度的时序数据

# 降采样数据查询（自动选择）
avg by (instance) (rate(node_cpu_seconds_total[5m]))
# 30-180d 范围: 返回 5m 精度的聚合数据
# > 180d 范围: 返回 1h 精度的聚合数据

推荐升级顺序（从底层到上层）:

1. 对象存储（无变化，S3/GCS 自动兼容）

2. Store Gateway（无状态，先升级）
   - 不影响现有查询
   - 新版本自动重启

3. Compactor（有状态，需注意）
   - 等待当前压缩任务完成
   - 升级后自动检测未合并的块
   - 数据格式兼容性检查

4. Ruler（有状态，滚动升级）
   - 多副本轮替
   - 规则文件兼容性检查

5. Sidecar（与 Prometheus 同 Pod）
   - 滚动升级 Prometheus + Sidecar
   - 检查 Sidecar 版本兼容性

6. Query（无状态，最后升级）
   - 确保 Store 组件已就绪
   - 新版本兼容旧版 Store API

# K8s Deployment 滚动更新
query:
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

store:
  strategy:
    rollingUpdate:
      maxSurge: 0
      maxUnavailable: 1

compactor:
  # Compactor 建议先排空再升级
  lifecycle:
    preStop:
      exec:
        command: ["thanos", "tools", "bucket", "cleanup"]

1. 阅读 Release Notes
   - API 变更
   - 配置废弃
   - 数据格式兼容性

2. 备份配置
   - Helm values
   - 对象存储配置

3. 验证兼容性
   - 多组件版本依赖
   - Store API 版本

4. 灰度升级
   - 先在测试环境验证
   - 关注关键指标