VictoriaLogs 面试题

Elasticsearch： 倒排索引 → 高内存 → 功能全面
Loki:           Logstream + TSDB → 中内存 → 高效
VictoriaLogs:   日志流 + 列式压缩 → 极低内存 → 极致简单

# docker-compose
version: '3'
services:
  victorialogs:
    image: victoriametrics/victorialogs:latest
    ports:
      - "9428:9428"
    volumes:
      - ./victorialogs-data:/victoria-logs-data
    command:
      - -storageDataPath=/victoria-logs-data
      - -httpListenAddr=:9428
      - -retentionPeriod=30d

Log Record = {
  _time:    ISO8601 时间戳（纳秒精度）
  _stream: 日志流标识（JSON 对象，如 {"app":"nginx","env":"prod"}）
  _msg:    日志消息正文
  [其他自定义字段]
}

# 数据写入时指定 _stream
{
  "_time": "2026-05-26T10:00:00Z",
  "_stream": {"app": "nginx", "env": "production", "host": "web-1"},
  "_msg": "GET /api/users 200",
  "status": 200,
  "latency_ms": 45,
  "method": "GET"
}

# 基础全文搜索（匹配 _msg 字段）
error

# 字段匹配
status:500
method:POST

# 流匹配
_stream:{app="nginx", env="production"}

# 时间范围
_time:[2026-05-25T00:00:00Z, 2026-05-26T00:00:00Z]

# 组合查询
error AND _stream:{app="nginx"} | stats count() by status

# 统计
error | stats count() by status

# 字段提取
json | stats count() by level

# 排序
error | sort by (_time) desc

# 限制
error | limit 100

# 字段计算
error | stats avg(latency_ms) by method

# 单条写入
curl -X POST "http://localhost:9428/insert/jsonline" \
  -d '{"_time":"2026-05-26T10:00:00Z","_stream":{"app":"nginx"},"_msg":"GET /api 200","status":200}'

# 批量写入
curl -X POST "http://localhost:9428/insert/jsonline?_stream_fields=app,env" \
  -d '{"_time":"2026-05-26T10:00:00Z","app":"nginx","env":"prod","_msg":"log1","status":200}
{"_time":"2026-05-26T10:00:01Z","app":"nginx","env":"prod","_msg":"log2","status":500}'

# Filebeat 配置
output.elasticsearch:
  hosts: ["localhost:9428"]
  path: "/insert/elasticsearch"
  index: "logs"
  pipeline: "victorialogs"

# Logstash 配置
output {
  elasticsearch {
    hosts => ["http://localhost:9428/insert/elasticsearch"]
    index => "logs-%{+YYYY-MM-dd}"
  }
}

# Promtail 写入 VictoriaLogs
# promtail.yaml
clients:
  - url: http://victorialogs:9428/insert/loki/api/v1/push

[sinks.victorialogs]
type = "http"
inputs = ["parsed_logs"]
uri = "http://victorialogs:9428/insert/jsonline"
encoding.codec = "json"

/data/victoria-logs-data/
├── partitions/           # 时间分区
│   ├── 202605/          # 按月分区
│   │   ├── streams/     # Stream 索引
│   │   └── data/        # 日志数据块
│   └── 202606/
└── metadata/            # 元数据

写入 → 内存缓存 → 定期 flush → 磁盘块
                                    ↓
                              后台合并（Merge）
                                    ↓
                              按分区压缩存储

原始日志量 = 10 GB/天
VictoriaLogs 存储 ≈ 10 GB / 10 (压缩比) ≈ 1 GB/天
30 天保留 ≈ 30 GB

对比：
  Elasticsearch ≈ 10 GB × 1.3(索引) × 2(副本) = 26 GB/天
  Loki ≈ 10 GB / 3 (压缩) ≈ 3.3 GB/天
  VictoriaLogs ≈ 10 GB / 10 (压缩) ≈ 1 GB/天

# 按状态码统计
status:* | stats count() by status

# 计算平均延迟
latency:* | stats avg(latency_ms)

# P99 延迟分析
latency:* | stats quantile(0.99, latency_ms) by method

# 按服务统计错误数
error AND _stream:{app="nginx"} | stats count() by host

# 唯一 IP 计数
ip:* | stats count_unique(ip)

# 按分钟统计请求量
request:* | stats rate() by (_time:1m)

graph TD
    A[VMSelect<br/>查询入口 HTTP :9428]
    A --> B[VMStorage Node 1<br/>数据存储]
    A --> C[VMStorage Node 2<br/>数据存储]
    A --> D[VMStorage Node 3<br/>数据存储]
    B --> E[磁盘]
    C --> F[磁盘]
    D --> G[磁盘]

# docker-compose cluster
version: '3'
services:
  vmselect:
    image: victoriametrics/vmselect:v1.103.0
    command:
      - -storageNode=vmstorage-1:8401,vmstorage-2:8401,vmstorage-3:8401
    ports:
      - "9428:9428"

  vmstorage-1:
    image: victoriametrics/vmstorage:v1.103.0
    command:
      - -storageDataPath=/storage
      - -retentionPeriod=30d
    volumes:
      - ./storage1:/storage

  vmstorage-2:
    image: victoriametrics/vmstorage:v1.103.0
    volumes:
      - ./storage2:/storage

  vmstorage-3:
    image: victoriametrics/vmstorage:v1.103.0
    volumes:
      - ./storage3:/storage

分片算法：一致性哈希（基于 _stream）
同一 stream 的日志 → 同一 VMStorage 节点
跨 stream 查询 → VMSelect 归并结果

优点：
- Stream 级别查询高性能
- 增加节点只需 rehash
- 不影响现有数据分布

apiVersion: apps/v1
kind: Deployment
metadata:
  name: victorialogs
spec:
  replicas: 1
  selector:
    matchLabels:
      app: victorialogs
  template:
    metadata:
      labels:
        app: victorialogs
    spec:
      containers:
        - name: victorialogs
          image: victoriametrics/victorialogs:latest
          args:
            - -storageDataPath=/data
            - -retentionPeriod=30d
            - -httpListenAddr=:9428
          ports:
            - containerPort: 9428
          resources:
            requests:
              memory: "256Mi"
              cpu: "100m"
            limits:
              memory: "1Gi"
              cpu: "1"
          volumeMounts:
            - name: data
              mountPath: /data
      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: victorialogs-pvc
apiVersion: v1
kind: Service
metadata:
  name: victorialogs
spec:
  ports:
    - port: 9428
      targetPort: 9428
  selector:
    app: victorialogs
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: victorialogs-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi

推荐：
  _stream: {"app":"nginx", "env":"production"}       ✓
  _stream: {"namespace":"prod", "service":"api"}      ✓

不推荐：
  _stream: {"request_id":"abc-123"}                   ✗（高基数）
  _stream: {"timestamp":"2026-05-26T10:00:00Z"}       ✗（时间不是流字段）
  _stream: {"message":"actual log content"}            ✗（流字段过多）

# 写入时指定 stream_fields
curl -X POST "http://localhost:9428/insert/jsonline?_stream_fields=app,env" \
  -d '{"_time":"...","app":"nginx","env":"prod","_msg":"log1"}'

_stream:{app="nginx"}               → 精确匹配，高性能
_stream:{app=~"nginx|apache"}       → 多路匹配，中等性能
_stream:{app="nginx",env="prod"}   → 组合匹配，高性能（利用压缩）

# 原始日志
# _msg: '{"level":"ERROR","method":"GET","path":"/api","latency_ms":1500}'

# JSON 解析
_msg:"{"* | json

# 解析后查询
json AND level:ERROR AND latency_ms:>1000

# Nginx 访问日志解析
# _msg: '192.168.1.1 - - [26/May/2026:10:00:00 +0800] "GET /api HTTP/1.1" 200 1234'

# 正则提取
regex "(?P<ip>\S+) \S+ \S+ \[(?P<time>[^\]]+)\] \"(?P<method>\S+) (?P<path>\S+) HTTP/\S+\" (?P<status>\d+) (?P<bytes>\d+)"

# 结构化查询
status:500 | stats count() by path

# 日志格式: level=ERROR method=GET path=/api latency_ms=1500
fmt

# 等价于自动提取
level:ERROR AND latency_ms:>1000

# 多步骤解析
_stream:{app="nginx"} | regex "(?P<status>\d{3})" | stats count() by status

# JSON 解析后的嵌套统计
json | stats avg(latency_ms) by method

# 绝对时间范围
_time:[2026-05-25T00:00:00Z, 2026-05-26T00:00:00Z]

# 相对时间
_time:[now-1h, now]

# 开放式范围
_time:[2026-01-01, now]      # 从今年开始
_time:[, 2026-05-26]         # 到指定日期为止

# 精确时间点
_time:2026-05-26T10:00:00Z

# 按分钟统计
error | stats count() by (_time:1m)

# 按小时统计
error | stats count() by (_time:1h)

# 按天统计
error | stats count() by (_time:1d)

# 按服务分组趋势
_stream:{app="nginx"} | stats count() by (_time:5m, status)

Grafana 配置：
  Query: error | stats count() by (_time:1m)
  Type: Time Series
  Time Field: _time
  Value Field: count

# 启动参数
victorialogs \
  -storageDataPath=/data \
  -retentionPeriod=30d     # 30 天保留

# 支持的时间单位
# 30d   → 30 天
# 720h  → 720 小时（也等于 30 天）
# 3M    → 3 个月
# 1Y    → 1 年

1. 后台定时扫描（每小时）
2. 检查分区时间范围
3. 分区时间 < (now - retentionPeriod) → 删除分区目录
4. 删除为原子操作（分区级删除）

/data/victoria-logs-data/partitions/
├── 202606/           # 当前月（活跃）
├── 202605/           # 上个月
├── 202604/           # 过期（删除中）
├── 202603/           # 已删除
└── 202602/           # 已删除

# 修改保留期后重启
# 最长保留期取启动时 -retentionPeriod 参数

# 手动强制清理（不常用）
# 停止 VictoriaLogs
# 手动删除旧目录
# 重新启动

Grafana → Configuration → Data Sources → Add data source
  选择 "VictoriaLogs"
  配置 URL: http://victorialogs:9428
  Save & Test

Query Input（LogsQL）:
  全文搜索: error AND _stream:{app="nginx"}
  统计: error | stats count() by status
  
Visualization:
  Logs 面板: 原始日志查看
  Time Series: 时间序列统计
  Table: 聚合统计

# Grafana Loki 数据源配置
url: http://victorialogs:9428/insert/loki
# 使用 Loki API 兼容层查询
# 限制：部分 LogQL 功能不可用

# 使用 Grafana 模板变量
_stream:{app="$app"} $level

# 模板变量定义
$app → query: _stream_fields:app | stats count() by (_stream:app)
$level → query: level:* | stats count() by level

Grafana → Explore
  选择 VictoriaLogs 数据源
  输入 LogsQL 查询
  切换 Logs/Table/Time Series 视图

# promtail-config.yaml
clients:
  - url: http://victorialogs:9428/insert/loki/api/v1/push
    # 流字段映射
    external_labels:
      instance: ${HOSTNAME}
    # 请求超时
    backoff_config:
      min_period: 100ms
      max_period: 5s
      max_retries: 10
    # 批量写入
    batchwait: 1s
    batchsize: 1048576  # 1MB

scrape_configs:
  - job_name: kubernetes-pods
    kubernetes_sd_configs:
      - role: pod
    pipeline_stages:
      - cri: {}
      - pack:
          labels:
            - namespace
            - pod
            - container
      - output:
          source: log
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_label_app]
        target_label: app
      - source_labels: [__meta_kubernetes_namespace]
        target_label: namespace

# victorialogs + promtail 集成
apiVersion: v1
kind: ConfigMap
metadata:
  name: promtail-config
  namespace: logging
data:
  promtail.yaml: |
    clients:
      - url: http://victorialogs:9428/insert/loki/api/v1/push
    scrape_configs:
      - job_name: kubernetes-pods
        kubernetes_sd_configs:
          - role: pod
        pipeline_stages:
          - cri: {}
        relabel_configs:
          - action: replace
            source_labels: [__meta_kubernetes_namespace]
            target_label: namespace
          - action: replace
            source_labels: [__meta_kubernetes_pod_name]
            target_label: pod
          - action: replace
            source_labels: [__meta_kubernetes_container_name]
            target_label: container    
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: promtail
  namespace: logging
spec:
  selector:
    matchLabels:
      app: promtail
  template:
    metadata:
      labels:
        app: promtail
    spec:
      serviceAccountName: promtail
      containers:
        - name: promtail
          image: grafana/promtail:2.9.0
          args:
            - -config.file=/etc/promtail/promtail.yaml
          volumeMounts:
            - name: config
              mountPath: /etc/promtail
            - name: varlog
              mountPath: /var/log
            - name: docker
              mountPath: /var/lib/docker/containers
              readOnly: true
      volumes:
        - name: config
          configMap:
            name: promtail-config
        - name: varlog
          hostPath:
            path: /var/log
        - name: docker
          hostPath:
            path: /var/lib/docker/containers

# 启动时启用 Syslog 接收
victorialogs \
  -syslog.enable \
  -syslog.listenAddr=:5514 \
  -syslog.useUDP=true \        # UDP 模式（默认）
  -syslog.useTCP=true          # TCP 模式
  -syslog.streamFields=app,host  # Stream 字段提取

Syslog 字段 → VictoriaLogs 字段

PRI          → _stream.facility, _stream.severity
Timestamp    → _time
Hostname     → _stream.host
App-Name     → _stream.app
Msg          → _msg
StructuredData → [_time,_msg 之外的自定义字段]

# docker-compose with Syslog
version: '3'
services:
  victorialogs:
    image: victoriametrics/victorialogs:latest
    ports:
      - "9428:9428"
      - "5514:5514/udp"
    command:
      - -storageDataPath=/data
      - -retentionPeriod=30d
      - -syslog.enable
      - -syslog.listenAddr=:5514
      - -syslog.useUDP=true
      - -syslog.useTCP=true
      - -syslog.streamFields=app,host
    volumes:
      - ./data:/data

# Linux rsyslog 发送到 VictoriaLogs
# /etc/rsyslog.conf
*.* @victorialogs:5514

# 使用 logger 命令测试
logger -n victorialogs -P 5514 "Test syslog message"

# 使用 nc 测试
echo "Test message" | nc -u victorialogs 5514

# GET 查询
curl "http://localhost:9428/select/logsql/query?query=error&limit=10"

# POST 查询
curl -X POST "http://localhost:9428/select/logsql/query" \
  -d "query=_stream:{app=\"nginx\"} AND status:500
       &limit=100
       &time=_time:[now-1h, now]"

# 统计查询
curl "http://localhost:9428/select/logsql/stats_query?query=error|stats+count()+by+level"

# Tail（流式读取最新日志）
curl -N "http://localhost:9428/select/logsql/tail?query=*"

{
  "title": "VictoriaLogs Dashboard",
  "panels": [
    {
      "title": "Ingestion Rate",
      "targets": [{
        "expr": "rate(vl_ingestion_rate_rows[5m])",
        "legendFormat": "rows/s"
      }]
    },
    {
      "title": "Disk Usage",
      "targets": [{
        "expr": "vl_data_size_bytes",
        "legendFormat": "bytes"
      }]
    },
    {
      "title": "Query Latency P99",
      "targets": [{
        "expr": "histogram_quantile(0.99, rate(vl_query_duration_seconds_bucket[5m]))",
        "legendFormat": "p99"
      }]
    }
  ]
}

groups:
  - name: victorialogs
    rules:
      - alert: VictoriaLogsDown
        expr: up{job="victorialogs"} == 0
        for: 1m

      - alert: VictoriaLogsHighCPU
        expr: rate(process_cpu_seconds_total[5m]) > 0.8
        for: 10m

      - alert: VictoriaLogsDiskRunningOut
        expr: vl_data_size_bytes / (vl_data_size_bytes + vl_free_disk_bytes) > 0.85
        for: 5m

# 1. 文件级备份（停机时）
# 冷备份：停止 VictoriaLogs 后拷贝数据目录
cp -r /data/victoria-logs-data /backup/victorialogs-$(date +%Y%m%d)

# 2. 快照备份（云环境）
# EBS 快照（AWS）
aws ec2 create-snapshot \
  --volume-id vol-xxx \
  --description "VictoriaLogs backup $(date +%Y%m%d)"

# 3. 定期备份脚本
#!/bin/bash
BACKUP_DIR="/backup/victorialogs"
DATA_DIR="/data/victoria-logs-data"
RETENTION_DAYS=30

# 创建备份
tar czf "${BACKUP_DIR}/vl-$(date +%Y%m%d-%H%M%S).tar.gz" \
  -C "$(dirname $DATA_DIR)" "$(basename $DATA_DIR)"

# 清理旧备份
find ${BACKUP_DIR} -name "vl-*.tar.gz" -mtime +${RETENTION_DAYS} -delete

# 仅绑定 localhost（生产环境建议反向代理）
victorialogs -httpListenAddr=127.0.0.1:9428

# 反向代理 + Basic Auth（Nginx 示例）
location / {
  auth_basic "VictoriaLogs";
  auth_basic_user_file /etc/nginx/.htpasswd;
  proxy_pass http://127.0.0.1:9428;
}

# ❌ 低效：全表扫描
json | stats count()

# ✅ 高效：先限定流和时间范围
_stream:{app="nginx"} _time:[now-1h,now] | json | stats count()

# ❌ 低效：正则解析后统计
regex "(?P<status>\d{3})" | stats count() by status

# ✅ 高效：已有字段直接统计
status:* | stats count() by status

# ❌ 低效：不限制返回条数
error

# ✅ 高效：限制返回
error | limit 100

VictoriaLogs 在内存中缓存：
- 分区元数据缓存
- Stream 索引缓存
- 最近写入的数据（写入后立即可查）

查询热点：
- 重复查询自动命中内存缓存
- 时间范围查询利用分区本地性

graph TD
    A[Grafana]
    A --> B[VictoriaMetrics<br/>Metrics]
    A --> C[VictoriaLogs<br/>Logs]
    A --> D[VictoriaTraces<br/>Traces]
    C --> E[VMAlert<br/>统一告警]
    A --> F[VMUtils<br/>vmctl/vmbackup]

# vmalert 规则示例
groups:
  - name: unified-alerting
    rules:
      # 基于 Metrics 的告警
      - alert: HighCPUUsage
        expr: node_cpu_seconds_total > 0.9
        for: 5m

      # 基于 Logs 的告警（通过 LogsQL API）
      - alert: TooManyErrors
        expr: >
          http_requests_total{status="500"} > 100          
        annotations:
          summary: "Error rate high, check logs"

# grafana datasources
apiVersion: 1
datasources:
  - name: VictoriaMetrics
    type: prometheus
    url: http://victoriametrics:8428
  - name: VictoriaLogs
    type: victorialogs
    url: http://victorialogs:9428

# LogQL：分阶段
{app="nginx"} |= "error" | json | level="error" | count() by (path)

# LogsQL：统一管道
_stream:{app="nginx"} error | json | stats count() by path

从 LogQL 迁移到 LogsQL 的关键差异：
1. 流匹配语法：{k="v"} → _stream:{k="v"}
2. 全文搜索：|= "kw" → kw（直接写）
3. 字段匹配：| level="error" → level:error
4. 统计：count() → stats count()
5. 时间范围：通过查询参数 → _time:[...]

分区策略：按月份自动分区

数据目录结构：
/data/victoria-logs-data/partitions/
├── 2026_04/          ← 4 月分区
│   └── streams/
│       ├── <stream_hash_1>/
│       └── <stream_hash_2>/
├── 2026_05/          ← 5 月分区（当前活跃）
│   └── streams/
└── 2026_06/          ← 6 月分区

分区生命周期：
Created (活跃) → Merged (合并) → Deleted (过期)

1. 小分区合并：
   同一 stream 的多个小数据块
   → 合并为一个大块
   → 减少文件数，提升查询性能

2. 分区内合并：
   同一月份内的小分区
   → 后台定期合并
   → 不跨月合并

3. 合并触发条件：
   - 分区内文件数超过阈值
   - 定时合并检查（每小时）

Stream 索引结构：
  stream_hash → stream_tags (JSON)
              → partition_info
              → data_block_pointers

优点：
  无需全局倒排索引
  内存占用固定（仅 stream 元数据）
  查询通过 hash 直接定位

# vector.toml
[sources.k8s_logs]
type = "kubernetes_logs"
auto_partial_merge = true

[transforms.parse_json]
type = "remap"
inputs = ["k8s_logs"]
source = '''
  # 解析 JSON 消息
  if exists(.message) {
    parsed = parse_json!(.message) ?? {}
    . = merge(., parsed)
  }

  # 添加流字段
  ._stream = {
    "namespace": .kubernetes.namespace_name ?? "default",
    "pod": .kubernetes.pod_name ?? "unknown",
    "container": .kubernetes.container_name ?? "unknown"
  }

  # 规范化时间
  ._time = now()
  ._msg = del(.message)
'''

[sinks.victorialogs]
type = "http"
inputs = ["parse_json"]
uri = "http://victorialogs:9428/insert/jsonline"

encoding.codec = "json"
encoding.except_fields = ["kubernetes", "stream"]

# 批量写入优化
batch.max_bytes = 10485760  # 10MB
batch.timeout_secs = 5

# 缓冲和重试
buffer.type = "memory"
buffer.max_events = 50000

request.concurrency = 4
request.retry_initial_backoff_secs = 0.5

# 字段自动识别
# 写入的 JSON 字段自动可查
status:500
latency_ms:>1000
method:POST

# 无需预定义 mapping
# 无需创建索引
# 无 schema

LogsQL 查询：_stream:{app="nginx"} status:500

执行流程：
1. 解析 _stream 条件 → 定位 Stream Hash
2. Stream 索引查找 → 定位数据块范围
3. 数据块内扫描 → 按列过滤 status 字段
4. 返回匹配结果

加速点：
  Step 1: O(1) Hash 查找
  Step 2: 定位精确数据块
  Step 3: 列式读取仅扫描 status 列

高频查询的字段 → 规划到 _stream 中
频繁过滤的条件 → 使用精确值匹配而非正则
时间范围查询 → 始终限定 _time 范围

# 检查 Stream 基数
# VictoriaLogs 在 /metrics 暴露 stream 基数指标
vl_streams_count

# 建议值：< 10000
# 警告：> 100000
# 严重：> 1000000

# 错误的高基数设计
_stream: {"request_id": "abc-123-def-456"}  ✗ 每秒都不同

# 正确的低基数设计
_stream: {"app": "nginx", "env": "prod"}      ✓ 固定组合
_stream: {"service": "api", "region": "us-east-1"}  ✓ 低基数

# 写入时降低 Stream 基数
# 使用 _stream_fields 仅选择低基数字段
curl -X POST "http://localhost:9428/insert/jsonline?_stream_fields=app,env" \
  -d '{"_time":"...","app":"nginx","env":"prod","host":"web-1","_msg":"log"}'
# host 作为普通字段，不作为 Stream 字段

# 批量写入参数
# 每批大小：1-10 MB（非条数）
# 压缩：gzip 压缩传输
# 并发：2-4 连接

# 批量写入示例（10k 条）
curl -X POST "http://victorialogs:9428/insert/jsonline" \
  -H "Content-Type: application/json" \
  -H "Content-Encoding: gzip" \
  --data-binary @batch.json.gz

#!/bin/bash
# 批量写入脚本
BATCH_SIZE=10000
BATCH_FILE="/tmp/vl_batch.json"

while IFS= read -r line; do
    echo "$line" >> "$BATCH_FILE"
    count=$((count + 1))
    if [ "$count" -ge "$BATCH_SIZE" ]; then
        gzip -c "$BATCH_FILE" | curl -X POST \
          "http://victorialogs:9428/insert/jsonline" \
          -H "Content-Encoding: gzip" \
          --data-binary @- \
          -w "\nBatch: HTTP %{http_code}, %{time_total}s\n"
        count=0
        > "$BATCH_FILE"
    fi
done

# 发送剩余数据
if [ -s "$BATCH_FILE" ]; then
    gzip -c "$BATCH_FILE" | curl -X POST \
      "http://victorialogs:9428/insert/jsonline" \
      -H "Content-Encoding: gzip" \
      --data-binary @-
fi

graph TD
    G["全球查询入口"] --> VS["VMSelect<br/>联邦查询层"]
    VS --> DC1["DC1<br/>VL"]
    VS --> DC2["DC2<br/>VL"]
    VS --> DC3["DC3<br/>VL"]

# VMSelect 配置多个 VL 数据源
vmselect \
  -storageNode=dc1-vl:8401 \
  -storageNode=dc2-vl:8401 \
  -storageNode=dc3-vl:8401

# Nginx 反向代理联邦查询
upstream vl_cluster {
    server dc1-victorialogs:9428;
    server dc2-victorialogs:9428;
    server dc3-victorialogs:9428;
}

server {
    listen 9428;
    location /select/logsql/query {
        proxy_pass http://vl_cluster;
        # 请求分发到所有集群
        # 结果需在应用层归并
    }
}

当前 VictoriaLogs 不提供原生的跨集群查询结果归并
需通过上层应用或 VMSelect 统一查询
跨集群查询的性能取决于最慢集群
建议：联邦用于管理面，日常查询单个集群

# victorialogs.yml
storageDataPath: /data/victoria-logs-data
httpListenAddr: :9428
retentionPeriod: 30d
logLevel: info
maxConcurrentRequests: 2048
maxInsertRequestSize: 64MB

syslog:
  enable: true
  listenAddr: :5514
  useUDP: true
  useTCP: true
  streamFields: [app, host]

memory:
  allowedPercent: 50

# 启动
victorialogs -config=victorialogs.yml

推荐场景：
  ✓ 中小规模日志存储（< 10TB/天）
  ✓ 资源受限环境（< 1GB 内存）
  ✓ 新项目日志基础设施
  ✓ K8s 集群日志采集（配合 Promtail/Vector）
  ✓ 低成本日志归档方案

不推荐场景：
  ✗ 大规模全文搜索（推荐 ES）
  ✗ 复杂日志分析（推荐 ES + Logstash）
  ✗ 超大集群（100+ 节点，推荐 Loki）
  ✗ 已有 ELK 体系平稳运行（可迁移但成本高）

# 关键词搜索
error

# 多关键词（AND）
error timeout

# 短语搜索
"connection refused"

# 正则全文
~"5\\d{2}"   # 匹配 5XX 错误码

# 否定
NOT debug

# 组合
error AND NOT timeout

# 字段正则
path:~"/api/v[12]/users"

# IP 范围
ip:~"192\\.168\\.1\\..*"

# 多值匹配
status:~"5[0-9]{2}"

# 前缀匹配（类通配符）
path:/api/*

# 大小写不敏感
# VictoriaLogs 默认大小写敏感
# 可通过写入时统一小写解决

# AND（空格或 AND）
error timeout
error AND timeout

# OR（OR）
error OR warning
status:500 OR status:503

# NOT（NOT）
NOT debug
NOT level:DEBUG

# 多条件组合
(error OR warning) AND NOT timeout
(status:500 OR status:503) AND _stream:{app="nginx"}

# 精确过滤
level:ERROR

# 数值比较
latency_ms:>1000
latency_ms:>=500
latency_ms:<100
latency_ms:500..1500  # 范围

# 存在性检查
latency_ms:*    # 有延迟字段的日志

# 不存在
NOT latency_ms:*

# 场景：Nginx 5XX 且延迟大于 1s
_stream:{app="nginx"} status:~"5[0-9]{2}" AND latency_ms:>1000

# 场景：非 DEBUG 级别的 JSON 日志
json AND NOT level:DEBUG

# 场景：多应用多级别的错误
_stream:{app="nginx" OR app="api"} AND (level:ERROR OR level:CRITICAL)

# 场景：排除健康检查
NOT path:/healthz AND NOT path:/readyz

优点：
- 原生支持 K8s 元数据注入
- 配置简单，一行 URL 即可
- Promtail 社区成熟

缺点：
- Pipeline 能力有限
- 无 VRL 表达式
- 不支持复杂的日志处理

优点：
- VRL 强大的数据处理能力
- 单元测试支持
- 灵活的数据映射

缺点：
- 需手动配置 _stream 映射
- K8s 元数据需额外处理
- 学习曲线较陡

简单的 K8s 日志采集 → Promtail
复杂的日志处理需求 → Vector
已有 Fluentd 体系 → Fluent Bit (ES Bulk)
标准化日志格式 → Filebeat

# 1. 检查当前版本
curl http://localhost:9428/metrics | grep vl_version

# 2. 下载新版本
wget https://github.com/VictoriaMetrics/VictoriaMetrics/releases/download/v1.103.0/victorialogs-linux-amd64.tar.gz
tar xzf victorialogs-linux-amd64.tar.gz

# 3. 停止旧版本（优雅停止）
kill -TERM $(pidof victorialogs)
# 等待进程完全退出

# 4. 备份数据目录（可选）
cp -r /data/victoria-logs-data /backup/vl-before-upgrade

# 5. 替换二进制
cp victorialogs-prod /usr/local/bin/victorialogs

# 6. 启动新版本
victorialogs -storageDataPath=/data/victoria-logs-data

# 拉取新版本
docker pull victoriametrics/victorialogs:latest

# 停止旧容器
docker stop victorialogs

# 使用相同 volume 启动新容器
docker run -d \
  --name victorialogs \
  -p 9428:9428 \
  -v ./victorialogs-data:/victoria-logs-data \
  victoriametrics/victorialogs:latest \
  -storageDataPath=/victoria-logs-data

每次升级前检查 CHANGELOG:
https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/VictoriaLogs/CHANGELOG.md

关注内容：
- 参数变更（废弃/新增）
- 行为变更（默认值、功能）
- 已知问题
- 数据库格式变更（需注意）

# 秒级精度
_time:2026-05-26T10:00:00Z

# 毫秒级精度
_time:2026-05-26T10:00:00.500Z

# 纳秒级精度
_time:2026-05-26T10:00:00.123456789Z

# 支持的输入格式
# 1. ISO8601（推荐）
2026-05-26T10:00:00Z
2026-05-26T10:00:00.123+08:00

# 2. RFC3339
2026-05-26T10:00:00+08:00

# 3. Unix 时间戳（秒）
curl -X POST "http://localhost:9428/insert/jsonline" \
  -d '{"_time":1716700000,"_msg":"test"}'

# 4. Unix 时间戳（纳秒）
curl -X POST "http://localhost:9428/insert/jsonline" \
  -d '{"_time":1716700000123456789,"_msg":"test"}'

推荐：所有日志统一使用 UTC 时间
  写入时：_time: 2026-05-26T10:00:00Z
  查询时：Grafana 按本地时区展示
  存储：UTC 统一存储

原因：
  避免时区转换混淆
  跨区域日志排序正确
  夏令时问题免除