容量规划 #

容量规划的重要性：

┌─────────────────────────────────────────────┐
│ 1. 避免资源不足                             │
├─────────────────────────────────────────────┤
│ • 存储空间耗尽                              │
│ • 内存溢出                                  │
│ • 性能下降                                  │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 2. 控制成本                                 │
├─────────────────────────────────────────────┤
│ • 避免过度配置                              │
│ • 合理分配资源                              │
│ • 优化成本                                  │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 3. 提前规划                                 │
├─────────────────────────────────────────────┤
│ • 预测增长趋势                              │
│ • 提前扩容                                  │
│ • 避免服务中断                              │
└─────────────────────────────────────────────┘

存储容量计算：

┌─────────────────────────────────────────────┐
│ 存储需求 = 时间序列数 × 样本大小 × 保留天数 │
└─────────────────────────────────────────────┘

详细计算：

时间序列数 = 采集目标数 × 每目标指标数 × 标签组合数

样本大小 ≈ 1-2 字节/样本（压缩后）

日存储量 = 时间序列数 × 采集频率(次/秒) × 86400秒 × 1.5字节

总存储量 = 日存储量 × 保留天数 × 1.5（安全系数）

示例计算：

假设：
• 采集目标数：100个
• 每目标指标数：1000个
• 标签组合数：平均2个
• 采集频率：15秒一次
• 保留天数：30天

计算：
时间序列数 = 100 × 1000 × 2 = 200,000

每秒样本数 = 200,000 / 15 = 13,333

日样本数 = 13,333 × 86,400 = 1,152,000,000

日存储量 = 1,152,000,000 × 1.5字节 ≈ 1.6GB

总存储量 = 1.6GB × 30 × 1.5 ≈ 72GB

建议配置：100GB SSD存储

# 当前存储使用
prometheus_tsdb_storage_blocks_bytes

# 存储增长速率
deriv(prometheus_tsdb_storage_blocks_bytes[1d])

# 预测存储使用
predict_linear(prometheus_tsdb_storage_blocks_bytes[1d], 30*24*3600)

# 磁盘使用率
node_filesystem_avail_bytes{mountpoint="/prometheus"} 
/ 
node_filesystem_size_bytes{mountpoint="/prometheus"} * 100

内存需求计算：

┌─────────────────────────────────────────────┐
│ 内存需求 = 基础内存 + 数据内存 + 查询内存  │
└─────────────────────────────────────────────┘

详细计算：

基础内存 ≈ 500MB

数据内存 = 时间序列数 × 3KB（Head Block）

查询内存 = 并发查询数 × 每查询内存

总内存 = 基础内存 + 数据内存 + 查询内存

示例计算：

假设：
• 时间序列数：200,000
• 并发查询数：20
• 每查询内存：100MB

计算：
基础内存 = 500MB

数据内存 = 200,000 × 3KB = 600MB

查询内存 = 20 × 100MB = 2GB

总内存 = 500MB + 600MB + 2GB ≈ 3.1GB

建议配置：8GB内存（考虑峰值和安全系数）

# 进程内存使用
process_resident_memory_bytes

# Go堆内存
go_memstats_heap_inuse_bytes

# Head Block内存
prometheus_tsdb_head_series

# 内存使用率
process_resident_memory_bytes / node_memory_MemTotal_bytes * 100

CPU需求计算：

┌─────────────────────────────────────────────┐
│ CPU需求 = 采集CPU + 查询CPU + 压缩CPU      │
└─────────────────────────────────────────────┘

经验值：
• 每10,000个时间序列需要约0.1 CPU核心
• 查询密集型需要更多CPU
• 压缩期间CPU使用会升高

建议：
• 最少2核
• 推荐4核以上
• 生产环境8核以上

# 进程CPU使用
rate(process_cpu_seconds_total[5m])

# 系统CPU使用
rate(node_cpu_seconds_total[5m])

# CPU使用率
rate(process_cpu_seconds_total[5m]) * 100

网络带宽计算：

┌─────────────────────────────────────────────┐
│ 带宽需求 = 采集数据量 + 查询数据量          │
└─────────────────────────────────────────────┘

采集数据量：
每秒样本数 × 样本大小 × 标签大小

示例：
• 每秒样本数：13,333
• 样本大小：8字节
• 标签大小：约100字节

每秒数据量 = 13,333 × 108 ≈ 1.4MB/s

建议：千兆网络

垂直扩容（Scale Up）：

┌─────────────────────────────────────────────┐
│ 增加单机资源                                │
├─────────────────────────────────────────────┤
│ • 增加CPU核心数                             │
│ • 增加内存                                  │
│ • 增加存储                                  │
│ • 使用更快的存储                            │
└─────────────────────────────────────────────┘

适用场景：
• 时间序列数 < 100万
• 单机资源充足
• 简单快速

水平扩容（Scale Out）：

┌─────────────────────────────────────────────┐
│ 增加实例数量                                │
├─────────────────────────────────────────────┤
│ • 分片采集                                  │
│ • 联邦架构                                  │
│ • 远程存储                                  │
└─────────────────────────────────────────────┘

适用场景：
• 时间序列数 > 100万
• 需要高可用
• 长期存储需求

# 时间序列数量
prometheus_tsdb_head_series

# 采集目标数量
count(up)

# 查询QPS
rate(prometheus_http_requests_total{handler=~"/api/v1/.*"}[5m])

# 存储使用率
prometheus_tsdb_storage_blocks_bytes

# 内存使用率
process_resident_memory_bytes / node_memory_MemTotal_bytes

小型部署（<10万时间序列）：

┌─────────────────────────────────────────────┐
│ 配置建议                                    │
├─────────────────────────────────────────────┤
│ CPU: 2核                                   │
│ 内存: 4GB                                  │
│ 存储: 50GB SSD                             │
│ 网络: 百兆                                 │
│ 保留时间: 15天                             │
└─────────────────────────────────────────────┘

中型部署（10-100万时间序列）：

┌─────────────────────────────────────────────┐
│ 配置建议                                    │
├─────────────────────────────────────────────┤
│ CPU: 4-8核                                 │
│ 内存: 8-16GB                               │
│ 存储: 200GB-1TB SSD                        │
│ 网络: 千兆                                 │
│ 保留时间: 30天                             │
└─────────────────────────────────────────────┘

大型部署（>100万时间序列）：

┌─────────────────────────────────────────────┐
│ 配置建议                                    │
├─────────────────────────────────────────────┤
│ 架构: 分片+联邦+远程存储                    │
│ CPU: 每实例8核以上                          │
│ 内存: 每实例16GB以上                        │
│ 存储: 远程存储(对象存储)                    │
│ 网络: 万兆                                  │
│ 保留时间: 根据需求                          │
└─────────────────────────────────────────────┘