
Hello,我是小兔大白糖。 读完能说明 TSDB 用什么换通用事务能力,以及它在监控/指标场景的边界。
估计阅读时间:37 分钟
TL;DR
时序数据库(Time-Series Database, TSDB)是为时间戳数据优化的专用存储系统,通过牺牲通用事务能力换取极致的写入吞吐和聚合查询性能,是交易监控、风控指标和系统可观测性的核心基础设施。
1. 概念定义(是什么)
1.1 核心概念解释
Time-Series Data(时序数据):按时间顺序索引的数据点序列,每条记录天然携带一个时间戳(Timestamp)。典型的时序数据包括服务器 CPU 利用率、交易每秒请求量(QPS)、账户登录频率、风控规则命中次数等。
Tag Set(标签集):描述数据的维度(Dimensions),通常是字符串类型的键值对,用于过滤和分组查询。例如 exchange=大型加密货币交易所, symbol=BTCUSDT, region=ap-southeast-1。Tag 会被索引。
Field Set(字段集):描述数据的实际度量值(Measurements),通常是数值型,如 price=42000.50, volume=1.25, latency_ms=45。Field 默认不被索引(InfluxDB 中)。
Cardinality(基数):由 Tag 组合产生的唯一时间线(Time Series)数量。例如 symbol 有 1000 个值,region 有 5 个值,则基数为 5000。高基数是时序数据库的头号杀手。
Shard(分片):时序数据库按时间范围(如 7 天)对数据进行水平切分的单元。老 Shard 只读,新 Shard 可写,便于生命周期管理和并发查询。
Retention Policy(保留策略):定义数据的存活时间和副本数。过期数据自动删除或降级到冷存储(如 S3)。
Downsampling(降采样):将高频率原始数据聚合为低频率统计值(如 1 秒数据 -> 1 分钟均值/最大/最小值),以减少存储压力和加速历史查询。
Compaction(压缩/合并):后台将多个小数据文件合并为更大、更紧凑的文件,并清理已标记删除的数据。这是 LSM-Tree 家族的核心机制。
1.2 类比说明
类比:医院的体温记录表
想象一个 ICU 病房,护士每小时给每位病人记录一次体温、血压和心率。
- Timestamp:记录时间(2024-01-15 08:00)。
- Tag:病人 ID、病房号、床位号(用于找到"哪位病人"的数据)。
- Field:体温 37.2C、血压 120/80(实际的测量值)。
- Time Series:"病房A-床位1-体温" 构成一条时间线。
- Cardinality:如果医院有 1000 位病人,每人 3 个指标,那就是 3000 条时间线。
- Downsampling:院长不需要看每小时的数据,只需要每天的最高体温和平均体温。
- Retention:3 年前的体温记录会被销毁或归档到档案室(冷存储)。
这个类比揭示了时序数据的核心特征:写入是追加-only、查询总是带时间范围、维度过滤比点查更频繁、历史数据价值递减。
1.3 为什么需要它(解决了什么问题)
关系型数据库(如 MySQL)在处理时序数据时存在根本性瓶颈:
| 维度 | 关系型数据库 | 时序数据库 |
|---|---|---|
| 写入模式 | 随机写入,需更新索引 | 顺序追加写入,批量提交 |
| 时间范围查询 | B+ Tree 范围扫描,回表开销大 | 按时间分片,直接顺序读取 |
| 聚合查询 | 全表扫描或大范围索引扫描 | 预聚合、向量化执行 |
| 数据生命周期 | 手动 DELETE,产生碎片 | 自动 Retention,整 Shard 丢弃 |
| 存储成本 | 行存储,压缩率低 | 列存储或专用编码(Gorilla、Delta-of-Delta),压缩率 10:1 以上 |
在交易系统中,一个撮合引擎每秒可能产生数万到数十万个指标点(每笔订单的延迟、每个风控规则的执行时间、每台机器的 GC 停顿)。MySQL 在这种写入压力下很快会成为瓶颈,而 InfluxDB 或 Prometheus 可以轻松处理每秒百万级的写入。
2. 核心原理与图解
2.1 时序数据模型: everything is a time series
时序数据库的数据模型可以抽象为:
Measurement + Tag Set + Field Set + Timestamp
Example:
Measurement: order_latency
Tags: exchange=大型加密货币交易所, symbol=BTCUSDT, engine=matching-01
Fields: p50=12, p99=45, p999=120, count=150000
Timestamp: 2024-01-15T08:00:00Z
关键设计决策:
- Measurement 类比为表名,但无严格 Schema,同一 Measurement 在不同时间点可以有不同的 Field。
- Tag 与 Field 分离:Tag 用于 WHERE / GROUP BY,必须索引;Field 用于 SELECT 计算,通常不索引。这种分离避免了索引膨胀。
- Timestamp 是主键的第一列:所有数据按时间排序,这是物理存储布局的基石。
2.2 存储引擎原理:TSM vs LSM-Tree vs B+ Tree
B+ Tree 的困境
MySQL InnoDB 使用 B+ Tree 存储数据。对于时序场景:
- 写入是随机的(如果按时间戳 + Tag 组合做 PK),导致大量页分裂和随机 I/O。
- 即使主键是
(timestamp, tag),高并发写入也会造成 B+ Tree 的叶子节点竞争(latch contention)。 - 历史数据删除需要逐行标记或页回收,代价高昂。
LSM-Tree(Log-Structured Merge Tree)
LSM-Tree 将写入转换为顺序追加:
- 写入先进入内存中的 MemTable(通常是有序数据结构,如跳表)。
- MemTable 写满后,冻结为 Immutable MemTable,并异步刷盘为 SSTable(Sorted String Table)。
- 后台 Compaction 过程将多个小 SSTable 合并为大 SSTable,清理过期和重复数据。
- 读取时,需要查询 MemTable + 多个 SSTable(读放大)。
LSM-Tree 的优势:
- 写入吞吐量极高(顺序写)。
- 数据天然按 key 有序,范围查询友好。
- 删除只需写一条 Tombstone,由 Compaction 清理。
劣势:
- 读放大(需查多层)。
- 写放大(Compaction 反复重写数据)。
- 空间放大(Compaction 前存在多版本数据)。
InfluxDB TSM(Time-Structured Merge Tree)
InfluxDB 的 TSM 是专为时序数据定制的 LSM-Tree 变体:
- WAL(Write-Ahead Log):写入先持久化到 WAL,保证宕机不丢数据。
- Cache:内存中的 Hash Map,按 Time Series 组织,存储最近的 Points。
- TSM File:只读的数据文件,包含:
- Index:每个 Time Series 的索引,指向数据块位置。
- Blocks:按时间顺序压缩存储的 Field 值。使用 Gorilla 或 Delta-of-Delta 压缩。
- Compaction:
- Level 0:将 Cache 快照写入 TSM(类似 LSM 的 L0)。
- Level 1-3:将多个小的 TSM 合并为更大、压缩率更高的 TSM。高级别的 TSM 覆盖更长的时间范围。
TSM 针对时序数据的优化:
- 时间列独立压缩:时间戳使用 Delta-of-Delta 编码,压缩率极高(例如从 8 bytes 降到 0.3 bytes / point)。
- 浮点值 Gorilla 压缩:XOR 相邻值的二进制表示,适合缓慢变化的监控指标。
- 按 Time Series 分块:每个 Time Series 的数据在文件中连续存放,查询单个时间线只需一次顺序读取。
Prometheus 存储引擎
Prometheus 2.0 后使用自定义的 TSDB(基于 LevelDB 的思想,但完全重写):
- Head Block:内存中的活跃数据,最近 2 小时(默认)。使用 mmap 映射内存。
- WAL:保证 Head Block 的持久化。
- Checkpoint:定期将 WAL 截断,减少重启重放时间。
- Persistent Block:每 2 小时将 Head Block 刷盘为只读 Block,并进行 Compaction(合并、索引、压缩)。
- Index:每个 Block 包含独立的倒排索引(Posting Lists),支持 Label 快速查找。
Prometheus 的存储不依赖外部 LSM-Tree,而是针对 Pull 模式和短周期数据(15 天默认)做了极致优化。
2.3 架构对比图解
2.4 降采样(Downsampling)与预聚合
降采样是时序数据库应对"历史数据查询慢"的核心策略。
原理:
- 原始数据保留短周期(如 7 天,精度 1 秒)。
- 降采样任务定期将原始数据聚合为粗粒度(如 30 天,精度 1 分钟,只保留 mean/max/min/sum/count)。
- 查询历史时自动路由到降采样后的数据。
InfluxDB 1.x:Continuous Query(CQ)
CREATE CONTINUOUS QUERY "cq_order_latency" ON "risk_monitor"
BEGIN
SELECT mean("p99"), max("p99"), min("p99"), count("p99")
INTO "risk_monitor"."rp_30d"."order_latency_1m"
FROM "order_latency"
GROUP BY time(1m), "symbol", "engine"
ENDInfluxDB 2.x / Flux:Task
option task = {name: "downsample_order_latency", every: 1m}
from(bucket: "risk_monitor")
|> range(start: -task.every)
|> filter(fn: (r) => r._measurement == "order_latency")
|> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
|> to(bucket: "risk_monitor_1m")Prometheus:Recording Rule
groups:
- name: risk_metrics.rules
interval: 30s
rules:
- record: risk:order_latency:p99_5m
expr: histogram_quantile(0.99, sum(rate(order_latency_bucket[5m])) by (le, symbol))
- record: risk:rule_hit_rate_1m
expr: sum(rate(rule_hit_total[1m])) by (rule_id, severity) / sum(rate(rule_eval_total[1m])) by (rule_id, severity)降采样 vs 预聚合的区别:
- Downsampling:对原始数据做时间维度的粗化,减少数据点数量,但保留维度信息。查询时仍可按原始维度过滤。
- Pre-aggregation(预聚合):预先计算好常见的聚合结果(如全局 QPS、不分 symbol 的总延迟),查询时直接命中预计算结果,速度最快,但丢失了下钻(drill-down)能力。
2.5 高基数(High Cardinality)问题
高基数是生产环境中时序数据库性能断崖式下降的首要原因。
成因:
- 将 user_id、order_id、ip_address 等高唯一度字段放入 Tag。
- 100 万用户每分钟产生一条数据,则基数为 100 万条时间线。
- InfluxDB 的索引(Series Index)需要为每条时间线维护元数据,内存与查询成本线性增长。
解决策略:
- 将高基数字段转为 Field:如果不需要按该维度 GROUP BY 或 WHERE,就放入 Field。
- 基数限制与采样:只保留关键维度,或对用户做分桶(如按 user_id 哈希到 100 个桶)。
- 使用宽表模型:将相关指标放入同一个 Measurement 的不同 Field,而非不同 Tag。
- 分片 Shard 隔离:确保高基数只影响当前活跃 Shard,历史 Shard 只读且可能被压缩。
- 选型转向列式存储:InfluxDB IOx(Apache Arrow)或 ClickHouse 对高基数有更好的向量化处理能力。
3. 语法详解与代码示例(怎么用)
3.1 InfluxDB Line Protocol 写入
Line Protocol 是 InfluxDB 的原生写入格式,设计目标是极致的解析速度和紧凑性:
<measurement>[,<tag_key>=<tag_value>...] <field_key>=<field_value>[,...] <timestamp>
交易监控指标写入示例:
order_latency,exchange=大型加密货币交易所,symbol=BTCUSDT,engine=matching-01 p50=12.3,p99=45.6,p999=120.8,count=150000 1705312800000000000
rule_evaluation,exchange=大型加密货币交易所,rule_id=kyc-aml-001,severity=critical hit=1,eval_time_ms=5.2 1705312800000000000
login_frequency,exchange=大型加密货币交易所,region=ap-southeast-1,user_type=vip success=120,failure=3,blocked=1 1705312800000000000
3.2 Java 集成:Spring Boot + Micrometer + Prometheus
Prometheus 是云原生监控的事实标准,通过 Micrometer 可以无缝集成到 Spring Boot 应用。
pom.xml 依赖:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-influx</artifactId>
</dependency>
</dependencies>application.yml 配置:
management:
endpoints:
web:
exposure:
include: prometheus,health,metrics
metrics:
tags:
application: ${spring.application.name}
exchange: 大型加密货币交易所
export:
prometheus:
enabled: true
influx:
enabled: true
db: risk_monitor
uri: http://influxdb:8086
step: 10s
auto-create-db: true自定义交易风控指标注册(Service 层):
package com.大型加密货币交易所.risk.metrics;
import io.micrometer.core.instrument.*;
import io.micrometer.core.instrument.distribution.DistributionStatisticConfig;
import org.springframework.stereotype.Component;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
@Component
public class RiskMetricsRegistry {
private final MeterRegistry meterRegistry;
// 交易延迟分布(用于 P99/P999 监控)
private final Timer orderLatencyTimer;
// 风控规则执行计数器
private final Counter ruleHitCounter;
private final Counter ruleEvalCounter;
// 用户行为频率(每用户每分钟登录次数,需配合外部聚合)
private final Counter loginSuccessCounter;
private final Counter loginFailureCounter;
// 反欺诈模型打分时延
private final Timer fraudModelScoreTimer;
// 当前活跃风险事件数(Gauge)
private final AtomicInteger activeRiskEvents;
public RiskMetricsRegistry(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
// 1. 订单延迟 Timer:配置 SLA 边界用于 histogram_quantile
this.orderLatencyTimer = Timer.builder("risk.order.latency")
.description("Order processing latency through risk engine")
.tags("engine", "risk-engine-01", "tier", "critical")
.publishPercentiles(0.50, 0.90, 0.99, 0.999)
.publishPercentileHistogram()
.sla(Duration.ofMillis(10), Duration.ofMillis(50), Duration.ofMillis(100))
.register(meterRegistry);
// 2. 规则命中计数器
this.ruleHitCounter = Counter.builder("risk.rule.hit")
.description("Risk rule hit count")
.tag("rule_id", "global")
.register(meterRegistry);
// 3. 规则执行计数器(用于计算命中率)
this.ruleEvalCounter = Counter.builder("risk.rule.eval")
.description("Risk rule evaluation count")
.tag("rule_id", "global")
.register(meterRegistry);
// 4. 登录频率计数器
this.loginSuccessCounter = Counter.builder("risk.login.success")
.description("Successful login count")
.register(meterRegistry);
this.loginFailureCounter = Counter.builder("risk.login.failure")
.description("Failed login count")
.register(meterRegistry);
// 5. 反欺诈模型打分时延
this.fraudModelScoreTimer = Timer.builder("risk.fraud.score.latency")
.description("Anti-fraud model scoring latency")
.publishPercentiles(0.50, 0.99)
.register(meterRegistry);
// 6. 活跃风险事件 Gauge
this.activeRiskEvents = new AtomicInteger(0);
Gauge.builder("risk.events.active", activeRiskEvents, AtomicInteger::get)
.description("Number of active risk events requiring review")
.register(meterRegistry);
}
public void recordOrderLatency(long latencyMs, String symbol, String engine) {
// 动态 Tag 需要谨慎使用,避免高基数问题
// 建议 symbol 只保留主流交易对,或做分桶处理
orderLatencyTimer.record(latencyMs, TimeUnit.MILLISECONDS);
}
public void recordRuleHit(String ruleId, String severity) {
meterRegistry.counter("risk.rule.hit", "rule_id", ruleId, "severity", severity).increment();
}
public void recordRuleEval(String ruleId, String severity) {
meterRegistry.counter("risk.rule.eval", "rule_id", ruleId, "severity", severity).increment();
}
public void recordFraudScoreLatency(long latencyMs, String modelVersion) {
// 注意:modelVersion 如果频繁变更, cardinality 会很高,建议作为 Tag 还是 Field 需权衡
fraudModelScoreTimer.record(latencyMs, TimeUnit.MILLISECONDS);
}
public void incrementActiveRiskEvent() {
activeRiskEvents.incrementAndGet();
}
public void decrementActiveRiskEvent() {
activeRiskEvents.decrementAndGet();
}
}在业务代码中使用(Aspect / Interceptor 模式):
package com.大型加密货币交易所.risk.aspect;
import com.大型加密货币交易所.risk.metrics.RiskMetricsRegistry;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class RiskEngineMetricsAspect {
private final RiskMetricsRegistry metrics;
public RiskEngineMetricsAspect(RiskMetricsRegistry metrics) {
this.metrics = metrics;
}
@Around("@annotation(com.大型加密货币交易所.risk.annotation.MonitoredRiskRule)")
public Object aroundRiskRule(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
String ruleId = extractRuleId(pjp);
String severity = extractSeverity(pjp);
metrics.recordRuleEval(ruleId, severity);
try {
Object result = pjp.proceed();
// 假设返回对象包含 isHit() 方法
if (result instanceof RuleResult rr && rr.isHit()) {
metrics.recordRuleHit(ruleId, severity);
}
return result;
} finally {
long latency = System.currentTimeMillis() - start;
// 记录规则执行延迟
metrics.recordOrderLatency(latency, "N/A", "risk-engine-01");
}
}
// ... helper methods
}3.3 PromQL 查询示例(风控监控告警)
PromQL(Prometheus Query Language)是 Prometheus 的查询语言,专为时序聚合设计。
1. 计算交易 QPS(每秒请求率):
# 过去 5 分钟,按交易对聚合的每秒订单数
sum(rate(risk_order_latency_count[5m])) by (symbol)
# 过去 1 分钟,全局 QPS
sum(rate(risk_order_latency_count[1m]))2. 计算 P99 延迟:
# 基于 histogram 计算 P99(要求 Timer 启用了 publishPercentileHistogram)
histogram_quantile(0.99,
sum(rate(risk_order_latency_bucket[5m])) by (le, engine)
)
# 基于预计算的 percentile(如果启用了 publishPercentiles)
# Micrometer 会导出 risk_order_latency{quantile="0.99"}
risk_order_latency{quantile="0.99", tier="critical"}3. 风控规则命中率趋势:
# 过去 5 分钟,各规则命中率
sum(rate(risk_rule_hit_total[5m])) by (rule_id)
/
sum(rate(risk_rule_eval_total[5m])) by (rule_id)
# 命中率低于 1% 的规则(可能是规则失效或配置错误)
(
sum(rate(risk_rule_hit_total[1h])) by (rule_id)
/
sum(rate(risk_rule_eval_total[1h])) by (rule_id)
) < 0.014. 异常检测:延迟突增(Z-Score 简化版):
# 当前 P99 延迟相比过去 1 小时的均值突增 3 倍以上
(
histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine))
/
avg_over_time(
histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine))[1h:2m]
)
) > 35. 用户登录频率异常(配合 Recording Rule):
# 假设已预聚合为每分钟登录次数
# 单个用户过去 10 分钟登录次数突增(可能暴力破解)
(
sum(rate(risk_login_success_total[10m])) by (user_id)
/
sum(rate(risk_login_success_total[1h])) by (user_id)
) > 53.4 InfluxDB Flux 查询示例(风控时序分析)
Flux 是 InfluxDB 2.x 的查询语言,功能比 PromQL 更通用(支持 JOIN、透视等)。
// 查询过去 1 小时,各风控引擎的 P99 延迟趋势
from(bucket: "risk_monitor")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "risk_order_latency")
|> filter(fn: (r) => r._field == "p99")
|> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
|> yield(name: "p99_trend")
// 查询规则命中率(需要 JOIN hit 和 eval)
hit = from(bucket: "risk_monitor")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "risk_rule_hit")
|> aggregateWindow(every: 5m, fn: sum, createEmpty: false)
|> set(key: "_join_key", value: "rule")
eval = from(bucket: "risk_monitor")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "risk_rule_eval")
|> aggregateWindow(every: 5m, fn: sum, createEmpty: false)
|> set(key: "_join_key", value: "rule")
join(
tables: {hit: hit, eval: eval},
on: ["rule_id", "_time"]
)
|> map(fn: (r) => ({
_time: r._time,
rule_id: r.rule_id,
hit_rate: r._value_hit / r._value_eval * 100.0
}))
|> yield(name: "rule_hit_rate")3.5 完整 Demo:交易监控指标上报与告警规则
docker-compose.yml(本地测试环境):
version: '3.8'
services:
influxdb:
image: influxdb:2.7
ports:
- "8086:8086"
environment:
- INFLUXDB_DB=risk_monitor
- INFLUXDB_ADMIN_USER=admin
- INFLUXDB_ADMIN_PASSWORD=admin123
volumes:
- influxdb-data:/var/lib/influxdb2
prometheus:
image: prom/prometheus:v2.47.0
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus-data:/prometheus
grafana:
image: grafana/grafana:10.1.0
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- grafana-data:/var/lib/grafana
volumes:
influxdb-data:
prometheus-data:
grafana-data:prometheus.yml:
global:
scrape_interval: 10s
evaluation_interval: 10s
scrape_configs:
- job_name: 'risk-engine'
metrics_path: '/actuator/prometheus'
static_configs:
- targets: ['host.docker.internal:8080']
labels:
env: 'dev'
rule_files:
- /etc/prometheus/rules/*.yml告警规则 /etc/prometheus/rules/risk_alerts.yml:
groups:
- name: risk_critical
rules:
- alert: RiskEngineHighLatency
expr: histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine)) > 100
for: 2m
labels:
severity: critical
team: risk-platform
annotations:
summary: "Risk engine P99 latency > 100ms"
description: "Engine {{ $labels.engine }} P99 latency is {{ $value }}ms"
- alert: RiskRuleHitRateAnomaly
expr: |
(
sum(rate(risk_rule_hit_total[10m])) by (rule_id)
/
sum(rate(risk_rule_eval_total[10m])) by (rule_id)
) > 0.5
for: 5m
labels:
severity: warning
annotations:
summary: "Risk rule {{ $labels.rule_id }} hit rate is abnormally high"
- alert: FraudModelScoreLatencyHigh
expr: histogram_quantile(0.99, sum(rate(risk_fraud_score_latency_bucket[5m])) by (le)) > 500
for: 3m
labels:
severity: critical
annotations:
summary: "Fraud model scoring P99 > 500ms, blocking order flow"4. 业界案例
4.1 阿里巴巴:双 11 交易峰值下的时序存储架构
背景:阿里巴巴在双 11 期间需要监控数百万容器、数万微服务的实时指标,峰值时写入量达到每秒数亿个数据点。
架构演进:
- 早期:使用 OpenTSDB + HBase。HBase 的 Compaction 在高峰期造成毛刺,且 HBase Region 分裂期间查询不稳定。
- 中期:自研 HiTSDB(High Performance Time Series Database),基于 LSM-Tree + SSD 优化,支持分布式集群。
- 当前:演化为 Lindorm 时序引擎,采用云原生架构:
- 写入层:多节点无状态写入网关,支持 Line Protocol。
- 存储层:基于 Raft 的多副本 Shard,支持冷热分层(热数据 SSD,冷数据 OSS)。
- 查询层:支持 SQL-like 查询和 PromQL 兼容语法。
- 降采样:自动按策略降采样,7 天内的数据精度 10 秒,30 天精度 1 分钟,1 年精度 1 小时。
踩过的坑:
- Tag 滥用导致 OOM:某业务线将
trace_id作为 Tag 写入, cardinality 瞬间突破千万级,导致倒排索引内存耗尽,整集群雪崩。修复方案:将trace_id改为 Field,只索引关键维度(服务名、机房)。 - Compaction 引发延迟毛刺:旧版本的 Compaction 与写入共用 I/O 线程池,在数据量大时造成写入延迟飙升到秒级。修复方案:引入独立的 Compaction 线程池和 I/O 隔离(cgroups + ionice)。
- 时间线膨胀(Series Churn):K8s 环境下 Pod 频繁启停,每个 Pod 产生新的时间线,Series 数量无限增长。修复方案:引入 Series 限速和自动过期机制,同时优化索引结构为内存 + 磁盘混合索引。
4.2 字节跳动:万亿级监控指标与 VictoriaMetrics
背景:字节跳动内部监控系统需要处理超过 10 亿条活跃时间线,每日新增万亿级数据点,覆盖抖音、TikTok、飞书等全产品线。
架构选择:
- 早期使用 Prometheus 联邦集群(Federation),但随着规模增长,联邦方案的查询复杂度和存储碎片化无法忍受。
- 最终大规模迁移到 VictoriaMetrics(兼容 PromQL 的时序数据库,单机性能是 Prometheus 的 10 倍以上)。
- 架构为 VictoriaMetrics Cluster(vminsert -> vmstorage -> vmselect),配合 vmagent 做边缘采集。
风控场景的实践:
- 反欺诈实时看板:利用 VictoriaMetrics 的即时查询能力(Instant Query),在 Grafana 上展示每秒的风控拦截率、模型推理延迟、特征服务命中率。
- 高基数处理:风控规则 ID 有数万个,user_id 更是海量。字节的做法是将 user_id 级别的高基数据下沉到 ClickHouse(OLAP),而 VictoriaMetrics 只保留聚合后的指标(如按规则 ID、按地区、按风险等级)。
- Recording Rule 大规模应用:预计算了超过 10 万个 Recording Rule,将常用查询的响应时间从秒级降到毫秒级。
踩过的坑:
- 拉取模式(Pull)的网络瓶颈:vmagent 拉取数万目标时,TCP 连接数爆炸。解决方案:采用 Pushgateway 模式或 vmagent 的 Stream Aggregation 在边缘做预聚合后再上报。
- 数据回溯(Backfilling)困难:当补录历史数据时,VictoriaMetrics 的 vmstorage 需要重建索引,造成 CPU 飙升。解决方案:限制回溯速率,使用 vmctl 做离线导入而非实时写入。
- Churn 导致索引膨胀:微服务版本频繁发布,每个新版本产生新的
versionTag 组合。解决方案:将version从 Tag 中移除,改为日志字段,监控只看服务名维度。
5. 业务场景对照与注意事项
5.1 风控 / Risk 场景如何应用
时序数据库在风控系统中不是"可选项",而是支撑实时决策和事后分析的核心基础设施。
| 风控场景 | 时序数据模型 | 查询模式 | 技术选型建议 |
|---|---|---|---|
| 交易 QPS/TPS 实时监控 | Measurement: trade_throughput, Tags: symbol, engine, Fields: qps, tps | 实时仪表盘,rate() 聚合 | Prometheus + Grafana |
| 风控规则命中率趋势 | Measurement: rule_hit, Tags: rule_id, severity, Fields: hit_count | 时间范围聚合,同比环比 | InfluxDB / VictoriaMetrics |
| 用户行为频率聚合 | Measurement: user_action, Tags: action_type, region, Fields: user_id(Field 非 Tag) | 高频滑动窗口计数 | ClickHouse + 物化视图(高基数) |
| 延迟 P99/P999 监控 | Measurement: engine_latency, Tags: engine, method, Fields: 用 Histogram | histogram_quantile() | Prometheus |
| 反欺诈模型打分时延 | Measurement: fraud_score_latency, Tags: model_version, feature_set, Fields: latency_ms | 阈值告警,延迟分布 | InfluxDB + Flux |
| 资金流转异常检测 | Measurement: fund_flow, Tags: currency, channel, Fields: amount, count | 时间序列异常检测(ARIMA / Prophet) | InfluxDB + 外部算法引擎 |
关键设计原则:
- Metric 与 Trace 分离:时序数据存储聚合指标(秒级/分钟级),原始 Trace(单笔订单全链路)应放在 Jaeger/ClickHouse,不要试图用 TSDB 存储 Trace。
- 维度设计决定生死:
- Tag 维度控制在 5 个以内。
- 避免将用户 ID、订单 ID、IP 地址作为 Tag。
- 如果必须按用户分析,采用"高基数据走日志/OLAP,低基聚合指标走时序库"的分层架构。
- TTL 与成本:
- 原始数据:7 天(SSD)。
- 分钟级降采样:30 天(SSD)。
- 小时级降采样:1 年(对象存储)。
- 告警与查询解耦:
- 告警用 Recording Rule 或 CQ 预聚合后的数据,确保告警检查在毫秒级完成。
- ad-hoc 查询走原始数据,但要限制时间范围(如最多查 6 小时)。
5.2 常见误区 vs 正确做法
| ❌ 常见误区 | ✅ 正确做法 | 原因 |
|---|---|---|
| 把时序数据库当万能数据库,存储原始日志和用户行为明细 | 时序库存聚合指标,原始明细走日志系统 / OLAP | TSDB 的压缩和索引针对时间序列优化,不适合大文本和高基数明细 |
| 所有字段都设为 Tag,方便任意维度查询 | 严格区分 Tag(索引,低基数)和 Field(值,高基数或数值) | Tag 进入倒排索引,高基数会导致内存爆炸和查询退化 |
| 不做降采样,期望随时查询 3 年前的每秒数据 | 配置多级 Retention 和 Continuous Query / Recording Rule | 存储成本随时间线性增长,历史查询性能断崖式下降 |
| 在 Tag 中使用动态生成的 UUID、TraceID、UserID | 高基数字段放入 Field,或在应用层做分桶(如 user_id % 100) | Cardinality 是 TSDB 的第一杀手 |
使用 InfluxDB 的 SELECT * 做范围查询 | 只选择需要的 Field,带时间范围上限 | SELECT * 需读取所有 Field 列,且大数据集可能 OOM |
| Prometheus 单实例存储超过 15 天数据 | 使用 Thanos / Cortex / VictoriaMetrics 做长期存储 | Prometheus 本地存储为单节点设计,长期存储需远程后端 |
| 忽略 WAL 和副本配置,认为"时序数据丢了没关系" | 关键风控指标配置多副本或远程备份 | 交易监控数据是审计和故障复盘的核心证据 |
5.3 选型建议(When to use / When NOT to use)
推荐使用 TSDB 的场景:
- 数据模型天然是"时间 + 维度 + 数值"。
- 写入远大于更新(append-only,极少 UPDATE/DELETE)。
- 查询总是带时间范围,且需要做聚合(SUM/AVG/PERCENTILE)。
- 需要自动的数据过期和降采样。
- 监控、告警、仪表盘是主要消费方式。
不推荐 / 需要谨慎的场景:
- 需要复杂的多表 JOIN 和事务一致性(ACID)。此时用关系型数据库或数据仓库。
- 数据没有明显的时间属性,或时间只是普通字段之一。
- 需要频繁的随机点查(如
SELECT * WHERE id = 123),而非范围扫描。 - 高基数字段需要作为查询过滤条件(如"查询用户 A 过去一年的所有操作"),此时 ClickHouse、Druid、StarRocks 更合适。
- 数据量极小(日增几千条),用 MySQL + 时间索引足够。
大型加密货币交易所 场景下的具体选型建议:
- 实时交易监控与告警:Prometheus(Pull)+ VictoriaMetrics(长期存储)+ Grafana。PromQL 生态成熟,告警规则与 K8s 原生集成。
- 风控规则执行分析:InfluxDB IOx 或 ClickHouse。需要灵活的 SQL 查询做规则效果分析,且可能需要 JOIN 规则配置表。
- 用户行为时序分析(反欺诈):高基数的 user_id 场景下,采用"Kafka -> Flink 预聚合 -> InfluxDB/VictoriaMetrics 存储聚合指标"的架构。原始明细入 Hive/Iceberg。
- 全球多机房部署:避免单点 Prometheus,使用 Thanos Sidecar + Query 做全局视图,或直接使用 VictoriaMetrics Cluster。
6. FAQ 与高频追问
Q1: 时序数据库和关系型数据库的本质区别是什么?为什么不能用 MySQL 加时序索引来替代?
答:
本质区别在存储布局、写入模型和查询优化目标三个层面:
-
存储布局:
- MySQL InnoDB 是行存储(Row-oriented),B+ Tree 按主键聚簇。即使主键是
(timestamp, tag),数据在磁盘上按行连续存储,查询SELECT AVG(latency)仍需读取整行,I/O 放大严重。 - TSDB 是列存储或混合布局(如 TSM 按 Time Series 分块)。同一列的数据连续存放,压缩率极高( Gorilla 压缩可达 10:1 以上),聚合查询只需读取目标列。
- MySQL InnoDB 是行存储(Row-oriented),B+ Tree 按主键聚簇。即使主键是
-
写入模型:
- MySQL 的写入是随机 I/O(B+ Tree 的页更新),高并发写入时锁竞争严重。
- TSDB 基于 LSM-Tree 或类 LSM 结构,写入转换为顺序追加,内存批量合并后刷盘,写入吞吐量高 1-2 个数量级。
-
查询优化:
- MySQL 的优化器为通用 OLTP 设计,对时间范围聚合没有特殊优化。
- TSDB 的查询引擎内置时间分片、向量化执行、预聚合和降采样路由。例如 Prometheus 的
rate()函数直接在引擎内计算相邻 counter 差值,无需应用层处理。
-
生命周期管理:
- MySQL 删除旧数据需要执行
DELETE,产生碎片和锁。 - TSDB 按 Shard 管理时间范围,过期 Shard 整文件删除(或移至冷存),成本极低。
- MySQL 删除旧数据需要执行
结论:MySQL 可以存时序数据,但在写入吞吐、存储成本和聚合性能上会被专用 TSDB 碾压。类比:用轿车拉货 vs 用卡车拉货,轿车能拉,但效率和经济性不在一个量级。
Q2: InfluxDB 的 TSM 存储引擎原理是什么?它与标准 LSM-Tree 有何不同?
答:
TSM(Time-Structured Merge Tree)是 InfluxDB 为时序数据定制的存储引擎,核心思想继承 LSM-Tree(顺序写 + 后台合并),但在数据结构和压缩算法上有深度优化:
相同点:
- 写入先写 WAL,再进入内存 Cache(类比 MemTable)。
- 内存满后刷盘为不可变文件(TSM File,类比 SSTable)。
- 后台 Compaction 合并小文件为大文件,清理过期/删除数据。
不同点:
-
索引结构:
- 标准 LSM-Tree(如 RocksDB)的索引是全局有序 KV 的 Bloom Filter + Block Index。
- TSM 维护一个时序专用索引:按 Time Series(Measurement + Tag Set)组织,每个 Series 指向一个或多个数据块(Block)。查询时先通过倒排索引定位 Series ID,再通过 Series Index 找到对应 Block,无需扫描无关数据。
-
数据块编码:
- TSM 将同一 Time Series 同一时间范围的数据组织为 Block。
- 时间戳使用 Delta-of-Delta 编码:如果数据每秒一个点,第一个差值是 1s,后续差值几乎为 0,可用 1 bit 表示。
- 浮点值使用 Gorilla XOR 编码:相邻值的二进制 XOR 结果通常前导零和后缀零很多,只需存储中间变化位。
- 这种编码在监控指标(变化缓慢)上压缩率极高。
-
Compaction 策略:
- 标准 LSM-Tree 按层数(Level)合并,每层大小呈指数增长。
- TSM 按时间范围和文件大小合并。Level 0 是最新数据(时间范围小、未压缩),高层级覆盖更大的时间范围且压缩率更高。这种设计让按时间范围查询只需读取少量高层级文件。
-
Field 分离存储:
- TSM 将不同 Field 分开存储为独立的 Block。查询
SELECT field_a无需读取 field_b,进一步减少 I/O。
- TSM 将不同 Field 分开存储为独立的 Block。查询
Q3: Prometheus 的 Pull 模式有什么优缺点?为什么 Pushgateway 通常不推荐作为默认方案?
答:
Pull 模式的优点:
- 控制平面集中:Prometheus Server 决定何时拉取、拉取谁、拉取频率。新增目标只需配置 Service Discovery(如 K8s),无需修改被监控端。
- 天然支持多副本去重:如果两个 Prometheus 实例拉取同一个目标,数据各自独立,不会互相干扰。
- 健康检测内建:拉取失败本身就是告警条件(InstanceDown),无需额外的 heartbeat 机制。
- 易于本地调试:
curl localhost:8080/actuator/prometheus即可看到当前指标状态。
Pull 模式的缺点:
- 网络可达性要求高:Prometheus 必须能访问被监控目标,跨 VPC / 防火墙 / 边缘设备时困难。
- 短生命周期 Job 监控困难:Batch Job(如定时风控对账任务)可能运行 30 秒就结束,Prometheus 还没来得及拉取就消失了。此时需要 Pushgateway。
- 拉取目标过多时的性能瓶颈:单 Prometheus 建议不超过 1000 个拉取目标,大规模需要联邦或分片。
Pushgateway 不推荐作为默认方案的原因:
- Pushgateway 是临时指标中转站,设计目标是 Batch Job。如果所有服务都 Push,会造成:
- 单点瓶颈:所有流量汇聚到 Pushgateway,高可用和扩展性成为问题。
- 丢失 Instance 维度:多个实例 Push 到同一个 Group,Prometheus 无法区分哪个实例的数据,InstanceDown 告警失效。
- 内存泄漏风险:Pushgateway 不会自动清理过期数据,如果 Job 不主动清理,指标会永远存在。
- 正确做法:常驻服务用 Pull,Batch Job 用 Pushgateway 并设置
--persistence.file和 TTL。
Q4: 降采样(Downsampling)和预聚合(Pre-aggregation)有什么区别?分别在什么场景下使用?
答:
| 维度 | Downsampling | Pre-aggregation |
|---|---|---|
| 定义 | 将高频原始数据转为低频统计数据,保留维度信息 | 预先计算好查询结果,丢弃原始维度细节 |
| 数据量 | 减少数据点数量,但维度数不变 | 数据量大幅减少,因为维度被聚合掉了 |
| 灵活性 | 高,仍可按原始维度过滤和下钻 | 低,只能查询预定义的维度组合 |
| 存储位置 | 通常在同一数据库的不同 Retention Policy / Bucket | 可以是同一数据库,也可以是专门的汇总表 |
| 典型工具 | InfluxDB CQ / Task, Prometheus Recording Rule | Prometheus Recording Rule, Flink 实时聚合, 物化视图 |
使用场景:
-
Downsampling 适用:你需要查看"过去一年的 CPU 使用率趋势",但不需要每秒的精度。降到 1 小时一个点即可。保留
host、cpu维度,可以下钻到某台机器。 -
Pre-aggregation 适用:Dashboard 上有一个固定面板显示"全局交易 QPS"。你不需要按 symbol 拆分,每次
sum(rate(...))计算代价高。用 Recording Rule 预计算global_trade_qps,查询时直接取结果。
生产最佳实践:两者通常结合使用。
- 第一层:原始数据保留 7 天(1 秒精度)。
- 第二层:Downsampling 到 1 分钟,保留 30 天。
- 第三层:Pre-aggregation 计算全局/关键维度的聚合值,保留 1 年。
Q5: 高基数(High Cardinality)问题如何解决?在交易系统中,如果必须按 user_id 查询怎么办?
答:
高基数问题的本质是倒排索引的爆炸。时序数据库的索引通常将每个唯一的 Tag 组合映射到一个 Series ID。如果 user_id 有 1 亿个,那就产生 1 亿条时间线,内存和查询成本都不可承受。
解决策略分层:
1. 设计层避免高基数:
- 将
user_id从 Tag 移到 Field。查询时使用|> filter(fn: (r) => r.user_id == "123")。代价是全表扫描,但适合低频查询。 - 对
user_id做分桶:user_bucket = hash(user_id) % 1000,只将user_bucket(1000 个值)作为 Tag。
2. 架构层分流:
- 指标(Metrics) vs 事件(Events)分离:聚合指标(如每分钟登录失败次数)走 TSDB,单笔用户事件走日志系统(ELK / ClickHouse)。
- 双层存储:
- 热数据(最近 1 小时):Kafka + Flink 实时处理,支持 user_id 级别查询。
- 冷数据(历史):ClickHouse / Druid 按 user_id 分区,支持秒级扫描亿级记录。
- 聚合指标:VictoriaMetrics / InfluxDB,低基数维度。
3. 引擎层选型:
- 如果高基数是刚需,考虑 ClickHouse(稀疏索引,不怕高基数)或 Druid(位图索引 + 预聚合)。
- InfluxDB IOx(基于 Apache Arrow DataFusion)通过列存和向量化执行,对高基数的耐受度比 TSM 好很多。
交易系统中的 user_id 查询方案:
假设需要分析"用户 A 过去 7 天的所有风控触发记录":
- 不要在 Prometheus / InfluxDB TSM 中以
user_id为 Tag 存储。 - 正确架构:
- 风控引擎触发时,发送一条 Kafka Event(包含 user_id、rule_id、timestamp、context)。
- Flink 实时消费,产出两份数据:
- 聚合指标:
rule_hit_count{rule_id="xxx"}-> VictoriaMetrics(低基数)。 - 原始事件:写入 ClickHouse,按
user_id+timestamp排序键分区。
- 聚合指标:
- 查询 user_id 明细时,直接查 ClickHouse:
SELECT * FROM risk_events WHERE user_id = 'A' AND ts > now() - 7d。 - 查询全局趋势时,查 VictoriaMetrics 的预聚合指标。
这种分层架构是大型交易平台的通用实践:TSDB 负责"看趋势",OLAP 负责"查明细"。
Q6: 在交易监控中,如何确保时序数据的写入不丢点、查询低延迟,同时控制成本?
答:
这是典型的"不可能三角"(不丢数据、低延迟、低成本)在时序场景的工程平衡。实际解法是通过数据分层和差异化 SLA 来破解:
1. 写入可靠性(不丢点):
- WAL 双写:客户端(如 Micrometer)本地缓存 + 批量上报,服务端先写 WAL 再 Ack。
- Kafka 缓冲:交易指标先写入 Kafka(3 副本),Consumer 异步刷入 TSDB。即使 TSDB 宕机,数据在 Kafka 中可回放。
- 关键指标同步写,非关键指标异步写:P99 延迟、资金相关指标同步确认;DEBUG 级别指标可丢。
2. 查询低延迟:
- 边缘预聚合:在采集端(如 vmagent / Telegraf)配置 Stream Aggregation,上报的已经是 10 秒聚合值,减少服务端计算。
- Recording Rule 全覆盖:将所有 Dashboard 查询和告警条件转化为 Recording Rule,确保查询命中预计算结果。
- 内存缓存热点数据:对最近 1 小时的原始数据,TSDB 常驻内存(Prometheus Head Block / InfluxDB Cache)。
- 查询限流与降级:ad-hoc 查询超过 10 秒自动熔断,返回降采样数据;只影响即席查询,不影响告警。
3. 成本控制:
- 冷热分层:热数据(7 天)SSD,温数据(30 天)SATA,冷数据(1 年+)对象存储(S3/OSS)。Thanos / Cortex / InfluxDB IOx 都支持 S3 后端。
- 降采样策略自动化:原始 1 秒 -> 7 天后 1 分钟 -> 30 天后 1 小时。
- 丢弃低价值指标:定期审计 Metrics,删除未被查询和告警使用的 Series(Prometheus 的
metric_relabel_configs可配置丢弃)。
大型加密货币交易所 场景下的实践要点:
- 交易撮合引擎的延迟指标(亚毫秒级)要求秒级精度和秒级查询延迟,这部分数据量小但价值极高,应给予最高 SLA(多副本、SSD、内存缓存)。
- 用户行为统计(如每分钟登录次数)数据量大但精度要求低(分钟级足够),可接受分钟级查询延迟,适合降采样和冷存。
- 成本敏感的非核心服务监控,可直接使用远端 SaaS 时序库(如托管 VictoriaMetrics),降低自运维成本。