Loki 面试题

Promtail/其他采集端 → Distributor → Ingester → 对象存储（S3/MinIO/GCS）
                                      ↑            ↓
                                Querier ←→ 对象存储 + Index Gateway
                                      ↑
                              Query Frontend ← Grafana

# 基础查询：Label 匹配 + 关键词过滤
{job="nginx", namespace="production"} |= "error"

# 正则匹配
{job="nginx"} |~ "status=(5\\d{2})"

# 排除匹配
{job="nginx"} != "healthcheck"

# JSON 解析
{job="nginx"} | json | status >= 500

# 日志模式解析
{job="nginx"} | logfmt | level = "error"

# 标签提取（regex）
{namespace="prod"} | regex "(?P<method>\\w+) (?P<path>[\\w/]+)"

# 日志速率
rate({job="nginx"} |= "error" [5m])

# 计数
count_over_time({job="nginx"}[5m])

# 标签值聚合
sum by (namespace) (rate({job="nginx"} |= "error" [5m]))

日志流选择器 → 行过滤器 → 解析器 → 标签过滤 → 指标函数
{job="nginx"} |= "500" | json | status > 500 | rate[5m]

1. 查询性能：比 BoltDB 模式快 10-100 倍
2. 存储效率：索引压缩比更高
3. 内存使用：索引查询可流式处理，不要求全量加载
4. 扩展性：支持索引分片和并发查询
5. 简化运维：无需 Index Gateway 组件

# Helm values.yaml
loki:
  schemaConfig:
    configs:
    - from: "2024-01-01"
      store: tsdb
      object_store: s3
      schema: v13
      index:
        prefix: index_
        period: 24h

Distributor 分发日志到 Ingester
  → Ingester 将日志追加到内存中的 Chunk
  → Chunk 达到阈值（大小/时间/行数）后：
    1. 关闭 Chunk（不再接受新数据）
    2. 压缩 Chunk（Snappy 或 gzip）
    3. 上传到对象存储
    4. 元数据写入索引（TSDB）

Ingester 无状态（依赖 Replication 和 Receiver）
  → 数据写入前先复制到 3 个 Ingester（默认 replication_factor=3）
  → Ingester 宕机 → 其他 Ingester 有副本
  → 启动后从对象存储恢复数据（wal 目录）

水平扩展：增加 Ingester 副本数
缩容前需等待 Chunk 刷盘完成（drain）
Ingester 无状态设计使其适合 K8s 部署

每个 Kubernetes 节点运行一个 Promtail DaemonSet
  → 读取 /var/log/pods/*.log（容器标准输出）
  → 为日志添加 K8s Label（pod_name, namespace, container 等）
  → 通过 HTTP/gRPC 推送到 Loki Distributor

scrape_configs:
- job_name: kubernetes-pods
  kubernetes_sd_configs:
  - role: pod
  pipeline_stages:
  # 添加 K8s 元数据标签
  - labels:
      pod: ""
      namespace: ""
      container: ""

  # 解析 Docker 日志格式
  - docker: {}

  # 匹配多行日志（如 Java 异常栈）
  - multiline:
      firstline: '^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'

  # 丢弃不需要的日志
  - drop:
      expression: "healthcheck"

- job_name: kubernetes-events
  pipeline_stages:
  - json: {}
  relabel_configs:
  - source_labels: [__meta_kubernetes_namespace]
    target_label: namespace

# 按状态码统计请求数
sum by (status) (count_over_time({job="nginx"} | json [5m]))

# 计算 P99 响应时间
quantile_over_time(0.99,
  {job="nginx"} | json | unwrap duration [5m]
)

groups:
- name: loki-alerts
  rules:
  - alert: HighErrorRate
    expr: |
      sum(rate({job="nginx"} | json | status >= 500 [5m])) > 10      
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Nginx 5xx error rate > 10/s"

  - alert: NoLogsForApp
    expr: |
      absent_over_time({job="myapp", namespace="production"}[10m])      
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "No logs from myapp for 10 minutes"

Grafana → Loki 数据源 → LogQL 查询 → 基于日志的告警规则

# 通用对象存储配置
storage_config:
  # S3 / MinIO 兼容
  aws:
    s3: s3://region/bucket
    endpoint: s3.amazonaws.com
    access_key_id: AKIA...
    secret_access_key: ...
    insecure: false
    s3forcepathstyle: true      # MinIO 需要

  # GCS
  gcs:
    bucket_name: loki-logs
    service_account: /etc/gcs/sa.json

  # Azure Blob
  azure:
    storage_account_name: lokilogs
    storage_account_key: ...
    container_name: loki

  # 本地文件系统（单节点测试用）
  filesystem:
    directory: /tmp/loki/chunks

schema_config:
  configs:
  - from: "2020-10-01"
    store: tsdb
    object_store: s3
    schema: v13
    index:
      prefix: index_
      period: 24h

# Compactor 保留策略
compactor:
  working_directory: /data/loki/compactor
  retention_enabled: true
  retention_delete_delay: 2h
  retention_delete_worker_count: 10

  # 按天配置保留期
  retention_rules:
  # 命名空间粒度
  - selector:
      namespace: "production"
    priority: 1
    period: 30d

  - selector:
      namespace: "staging"
    priority: 2
    period: 14d

  # 所有日志默认保留
  - selector: {}
    priority: 10
    period: 7d

# Table Manager 方式（旧版）
table_manager:
  retention_deletes_enabled: true
  retention_period: 720h   # 30 天

ingester:
  # 内存中 Chunk 的最长保留
  max_chunk_age: 2h
  # Chunk 上传对象存储后保留本地
  # 本地保留用于快速查询
  # 长期保留依赖对象存储

Compactor 定时扫描所有 Index/Chunk
  → 检查 retention_rules
  → 超期的数据标记删除
  → 清理对象存储中的已删除数据

query_frontend:
  # 查询分片
  max_outstanding_per_tenant: 2048
  log_queries_longer_than: 5s

  # 结果缓存
  cache_results: true
  results_cache:
    cache:
      # Redis 缓存
      redis:
        endpoint: redis:6379
        expiration: 1h

  # 查询分片配置
  parallelize_shardable_queries: true
  querier:
    max_concurrent: 10

# ❌ 慢查询：大范围无过滤
{namespace="prod"} |= "error"

# ✅ 快查询：缩小时间范围 + 精确匹配
{namespace="prod", app="nginx"} |= "error"

# 也可以指定时间范围
{namespace="prod", app="nginx"} |= "500"
# 查询 Grafana 侧限定时间如 1h

# 启用多租户模式
loki:
  auth_enabled: true   # 开启后每个请求必须携带 X-Scope-OrgID Header

# Promtail 配置（每个租户独立实例）
clients:
- url: http://loki:3100/loki/api/v1/push
  tenant_id: team-a

# 或 single tenant 模式
# 如果 Promtail 不能携带租户 ID，可通过代理添加 Header

# Grafana 数据源中设置 Tenant ID
# 每个租户只能查自己的数据

# API 直接查询
curl -H "X-Scope-OrgID: team-a" http://loki:3100/loki/api/v1/query_range

租户 A（生产团队）：tenant_id = "prod-team"
租户 B（开发团队）：tenant_id = "dev-team"

同一 Loki 集群，数据和查询完全隔离
全局管理员通过跳过租户检查查看所有数据

apiVersion: 1
datasources:
- name: Loki
  type: loki
  url: http://loki:3100
  access: proxy
  jsonData:
    maxLines: 1000
    derivedFields:
    # 从日志提取字段跳转到 Tempo（链路追踪）
    - name: traceID
      type: string
      matcherType: regex
      matcherRegex: "trace_id=(\\w+)"
      url: "$${__value.raw}"
      datasourceName: Tempo

# Grafana 变量
- name: namespace
  type: query
  query: label_values(namespace)

- name: pod
  type: query
  query: label_values({namespace="$namespace"}, pod)

ruler:
  storage:
    type: s3
    s3:
      bucket: loki-rules
  rule_path: /tmp/loki/rules
  alertmanager_url: http://alertmanager:9093
  ring:
    kvstore:
      store: memberlist

  # 规则存储
  # 支持本地磁盘 / S3 / GCS
  storage_config:
    s3:
      bucket: loki-rules

groups:
- name: loki-rules
  rules:
  - alert: HighErrorRate
    expr: |
      sum(rate({app="nginx"} | json | status >= 500 [5m])) > 10      
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "High error rate for nginx"

多副本 Ruler 通过 Ring 协调
只有 Leader 执行规则评估
Leader 故障后自动切换

1. 创建（Ingester 内存）
  → 接收 Distributor 分发的日志行
  → 写入内存 Chunk（包含压缩）

2. 刷盘（Flush）
  → Chunk 达到阈值（大小/时间/空闲）
  → 关闭 Chunk（不可变）
  → 压缩后上传到对象存储
  → 索引信息写入 TSDB

3. 查询
  → Querier 从 Ingester 读热数据（内存 Chunk）
  → Querier 从对象存储读历史数据（已刷盘的 Chunk）

4. 合并（Compactor）
  → 小 Chunk 合并为大 Chunk
  → 覆盖对象的元数据

5. 删除（Retention）
  → Compactor 根据保留策略删除过期 Chunk

ingester:
  chunk_target_size: 1572864     # 1.5MB（压缩后）
  chunk_block_size: 262144       # 256KB
  chunk_idle_period: 30m
  chunk_retain_period: 5m
  max_chunk_age: 2h

distributor:
  ring:
    kvstore:
      store: memberlist

  # 写入限制
  ingester_heartbeat_timeout: 5s
  rate_store:
    max_parallel: 10

  # 接收限制
  receiever:
    max_recv_msg_size: 4194304          # 4MB 最大消息
    max_connection_age_grace: 0s

Promtail 推送日志流 → Distributor
  → 1. 验证 Label 格式（不能为空、不能超过标签数限制）
  → 2. 验证时间戳（不能太旧或太新）
  → 3. 验证日志行大小（单行不能超过 max_line_size）
  → 4. 将日志流散列到指定 Ingester（一致性哈希）
  → 5. 复制到 replication_factor 个 Ingester
  → 6. 至少半数 Ingester 写入成功即返回成功

distributor:
  # 验证
  extend_wal: true
  max_line_size: 1048576           # 单行最大 1MB
  max_label_name_length: 1024      # Label 名最大长度
  max_label_value_length: 2048     # Label 值最大长度
  max_label_names_per_series: 20   # 单日志流最多标​​签数

grafana:
  datasources:
  - name: Prometheus
    type: prometheus
    url: http://prometheus:9090
  - name: Loki
    type: loki
    url: http://loki:3100
    jsonData:
      derivedFields:              # 日志 → 指标 联动
      - datasourceName: Prometheus
        matcherRegex: "namespace=(\\w+)"
        name: namespace
        url: '$${__value.raw}'

# 同一 Alertmanager 同时处理 Prometheus 和 Loki 的告警
# Prometheus 告警: rate(node_cpu_seconds_total[5m])
# Loki 告警: rate({app="nginx"}[5m])
alertmanager:
  receivers:
  - name: team-alerts
    slack_configs:
    - channel: '#alerts'

# Grafana 变量可以混合 Prometheus 和 Loki 数据源
- name: namespace
  type: query
  query: label_values(namespace)      # Prometheus
  # 或
  query: label_values(namespace)      # Loki

统一告警平台：Prometheus（指标） + Loki（日志） → Alertmanager
统一可视化：Prometheus（趋势图） + Loki（日志面板） → Grafana
统一服务发现：Prometheus 和 Promtail 使用相同的 K8s 元数据

# 微服务模式（推荐生产）
loki:
  structuredConfig:
    ingester:
      replication_factor: 3        # 每个日志流写入 3 个 Ingester
    distributor:
      ring:
        kvstore:
          store: memberlist
    querier:
      max_concurrent: 20

# Helm 多副本
ingester:
  replicas: 3
  resources:
    requests:
      memory: 4Gi
      cpu: 2

distributor:
  replicas: 2

querier:
  replicas: 2

queryFrontend:
  replicas: 2

compactor:
  replicas: 1

# Single binary 模式（所有组件同一进程）
loki -config.file=loki.yaml -target=all

# 读写分离模式
loki -config.file=loki.yaml -target=read     # Querier + QueryFrontend
loki -config.file=loki.yaml -target=write    # Distributor + Ingester

# 添加仓库
helm repo add grafana https://grafana.github.io/helm-charts
helm repo update

# 安装单进程模式（测试）
helm upgrade --install loki grafana/loki \
  --namespace=loki --create-namespace \
  --values single-binary-values.yaml

# 安装微服务模式（生产）
helm upgrade --install loki grafana/loki \
  --namespace=loki --create-namespace \
  --values microservices-values.yaml

loki:
  auth_enabled: false
  commonConfig:
    replication_factor: 3
  storage:
    type: s3
    bucketNames:
      chunks: loki-chunks
      ruler: loki-ruler
      admin: loki-admin
    s3:
      endpoint: minio.minio:9000
      region: us-east-1
      secretAccessKey: minio123
      accessKeyId: minio
      s3ForcePathStyle: true
      insecure: true

ingester:
  replicas: 3
  persistence:
    enabled: true
    size: 10Gi
  zoneAwareReplication:
    enabled: false

distributor:
  replicas: 2

querier:
  replicas: 2

queryFrontend:
  replicas: 2

compactor:
  enabled: true
  replicas: 1

monitoring:
  dashboards:
    enabled: true
  alerts:
    enabled: true
  serviceMonitor:
    enabled: true

Ingester 写入 Chunk → 上传到对象存储
  → 同时将 BoltDB 索引文件上传到对象存储
  → Querier 从对象存储下载索引文件
  → 基于本地缓存快速查询

不需要独立的 Index Gateway
每个 Querier 直接读取共享索引

# BoltDB Shipper 配置
storage_config:
  boltdb_shipper:
    active_index_directory: /data/loki/index
    shared_store: s3
    cache_location: /data/loki/boltdb-cache
    cache_ttl: 24h     # 索引缓存时间

1. Ingester 每 15 分钟将 BoltDB 索引文件上传到 S3
2. Querier 定期从 S3 同步索引文件到本地缓存
3. 查询时优先查本地缓存，缓存未命中再从 S3 获取
4. 索引文件按时间分割（通常每 24h 一个索引）

scrape_configs:
- job_name: java-app
  pipeline_stages:
  # 多行合并
  - multiline:
      # 第一行匹配：以日期开头（Java 异常栈起始标志）
      firstline: '^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
      # 最大等待时间
      max_wait_time: 3s
      # 最大行数
      max_lines: 128

  # 解析后添加 Label
  - labels:
      app: "java-app"

# Java 异常栈
multiline:
  firstline: '^\d{4}-\d{2}-\d{2}'

# Go panic
multiline:
  firstline: '^panic:'

# Python 回溯
multiline:
  firstline: '^Traceback'

# SQL 多行
multiline:
  firstline: '^(SELECT|INSERT|UPDATE|DELETE)'
  max_lines: 50

# ❌ 高基数标签（禁止）
# request_id: "req_abc123"       → 基数百万级
# user_id: "usr_12345"           → 基数百万级
# session_id: "sess_abc"         → 基数百万级
# ip: "10.0.0.1"                → 基数万级

# ✅ 正确做法：用 LogQL 解析器提取
{app="nginx"} | json
# 提取 user_id 等字段但不作为索引标签

Loki 建议每个日志流 5-10 个标签
单条日志流标签数上限：20（可配置）
标签总数建议：< 100 万活跃 Label 组合

# ❌ 高基数标签过滤→扫描大量数据
{pod="myapp-abc123"}  # → 需要扫索引找该 Pod

# ✅ 先缩小范围再过滤
{namespace="prod", app="nginx"} |= "500"

# 1. 日志速率（每秒行数）
rate({namespace="prod", app="nginx"}[5m])

# 2. 按状态码统计
sum by (status) (
  count_over_time({namespace="prod", app="nginx"} | json [5m])
)

# 3. Top 5 最慢请求
topk(5,
  avg by (path) (
    quantile_over_time(0.95,
      {namespace="prod", app="nginx"}
      | json
      | unwrap response_time [5m]
    )
  )
)

# 4. 错误比例
sum(rate({namespace="prod", app="nginx"} | json | status >= 500 [5m]))
/ sum(rate({namespace="prod", app="nginx"} | json [5m]))

# 5. 日志采样（取前 100 条）
topk(100, {namespace="prod", app="nginx"} |= "error" | json | status)

# 6. 异常日志模式识别（pattern 解析）
{namespace="prod"} | pattern "<ip> - - <method> <path> <status> <size>" | status >= 500

# 每 5 分钟错误趋势
sum by (namespace) (
  count_over_time({namespace="prod", app="nginx"} | json | status >= 500 [5m])
)

# 请求路径分布
topk(10,
  sum by (path) (
    count_over_time({app="nginx"} | json [1h])
  )
)

compactor:
  working_directory: /data/loki/compactor
  retention_enabled: true
  retention_delete_delay: 2h
  retention_delete_worker_count: 10

  # TSDB 模式
  tsdb:
    # 索引压缩
    compact_interval: 10m
    # 索引过期
    retention:
      minimum_interval: 1h

  # 对象存储
  shared_store: s3

1. 定期扫描对象存储中的索引文件
2. 合并小索引文件成大索引文件
3. 删除重复或过期的索引记录
4. 标记已删除的 Chunk（retention）
5. 清理对象存储中已标记删除的文件
6. 更新元数据

Compactor 是写入集中型组件
推荐独立部署，不与其他组件混部
需要足够的 CPU 和内存（索引合并是密集操作）
Compactor 的单副本设计（Leader 选举）

# 全局速率限制
loki:
  limits_config:
    # 每租户限制
    ingestion_rate_mb: 10           # 写入速率限制（MB/s）
    ingestion_burst_size_mb: 25     # 突发写入限制
    max_streams_per_user: 10000     # 每租户日志流上限
    max_global_streams_per_user: 0  # 全局日志流上限

    # 查询限制
    max_query_length: 721h          # 最大查询时间范围（30天）
    max_query_series: 500           # 单查询最大系列数
    max_query_range: 0              # 最大范围查询跨度

    # 行限制
    max_line_size: 1048576          # 单行最大长度（1MB）
    max_line_size_truncate: true    # 超长截断而非拒绝

    # 重试限制
    max_entries_limit_per_query: 5000  # 单查询最大条数

写入超过 ingestion_rate_mb：
  → 返回 429 Too Many Requests
  → Promtail 自动重试（指数退避）

查询超过 max_query_length：
  → 返回 400 Bad Request
  → 提示缩小查询时间范围

# 模式语法：<name> 表示提取字段
# 示例日志: "10.0.0.1 - GET /api/v1/users 200 1234"

# Pattern 解析
{job="nginx"}
  | pattern "<ip> - - <method> <path> <status> <size>"

# 解析后可以用提取的字段过滤
| status >= 500
| ip != "127.0.0.1"

# 原始日志: '[2024-01-01 12:00:00] [INFO] [request_id=abc123] user=admin action=login'

# Pattern 提取
| pattern "[<timestamp>] [<level>] [request_id=<request_id>] user=<user> action=<action>"

# 按用户统计动作
sum by (user, action) (
  count_over_time({app="myapp"} | pattern "[<timestamp>] [<level>] [request_id=<request_id>] user=<user> action=<action>" [5m])
)

# Pattern（更简单、性能更好）
| pattern "<ip> - - <method> <path> <status> <size>"

# Regex（更灵活、性能稍差）
| regex "(?P<ip>\\S+) - - (?P<method>\\S+) (?P<path>\\S+) (?P<status>\\d+) (?P<size>\\d+)"

# 1. 提取响应时间计算 P99
quantile_over_time(0.99,
  {app="nginx"} | json | unwrap response_time [5m]
)

# 2. 按路径统计平均响应时间
avg by (path) (
  avg_over_time(
    {app="nginx"} | json | unwrap response_time [5m]
  )
)

# 3. 字节量统计
sum by (method) (
  sum_over_time(
    {app="nginx"} | json | unwrap body_bytes [5m]
  )
)

# 4. 最大值
max_over_time(
  {app="nginx"} | json | unwrap upstream_time [5m]
)

# 5. 排序
sort(
  avg_over_time(
    {app="nginx"} | json | unwrap response_time [5m]
  )
)

# K8s 自动服务发现
scrape_configs:
- job_name: kubernetes-pods
  kubernetes_sd_configs:
  - role: pod
  pipeline_stages:
  - cri: {}                    # containerd 日志格式
  - docker: {}                 # Docker 日志格式
  - labels:
      pod: ""
      container: ""
      namespace: ""

# 文件日志
- job_name: system-logs
  static_configs:
  - targets: [localhost]
    labels:
      job: varlogs
      __path__: /var/log/*.log

output:
  name: loki
  match: *
  host: loki
  port: 3100
  labels: job=fluentbit, app=$TAG
  label_keys: $TAG
  auto_kubernetes_labels: on

# 1. 增大速率限制
limits_config:
  ingestion_rate_mb: 20
  ingestion_burst_size_mb: 50
  max_streams_per_user: 20000
  max_concurrent: 30

# 2. 客户端调整（Promtail）
clients:
  # 启用写缓冲
  backoff_config:
    min_period: 100ms
    max_period: 10s
    max_retries: 10
  # 本地缓冲（网络故障时）
  # 默认开启，缓冲目录 /tmp/promtail

# 被拒绝的写入请求
rate(loki_discarded_samples_total[5m])

# 速率限制器状态
loki_ingester_rate_limit_logs_per_second

K8s 环境、已有 Grafana、日志量大但查询简单 → Loki
需要全文搜索、复杂分析、企业合规要求 → ELK
混合部署：Loki 做运维日志快速查询，ELK 做审计/全文检索

groups:
- name: loki-alerts
  rules:
  - alert: LokiLogHighErrorRate
    expr: |
      sum(rate({app="nginx"} | json | status >= 500 [5m])) > 10      
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High error rate in nginx logs"
      description: "Error rate is XQOPEN $value XQCLOSE/s"

  - alert: LokiLogPanicDetected
    expr: |
      count_over_time({namespace="production"} |= "panic" [5m]) > 0      
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Panic detected in production"
      description: "Application panic found in logs"

  - alert: LokiLogNoOutput
    expr: |
      absent_over_time({app="myapp", namespace="production"}[15m])      
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "No logs from myapp for 15 minutes"

  - alert: LokiLogSlowRequests
    expr: |
      max_over_time(
        {app="nginx"} | json | unwrap request_time [5m]
      ) > 5      
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Slow requests detected"

- alert: LokiRequestErrors
  expr: |
    rate(loki_request_duration_seconds_count{status_code=~"5.."}[5m]) > 0.01    
  for: 5m
  labels:
    severity: warning

- alert: LokiDiskFull
  expr: |
    (loki_ingester_disk_usage_bytes / loki_ingester_disk_limit_bytes) > 0.9    
  for: 5m
  labels:
    severity: critical