Prometheus 监控实战

一、MySQL 监控

1. 数据库可用性监控

# 检查MySQL实例是否存活
mysql_up{instance="mysql-server:9104"} != 1

# 实例运行时长（秒）
mysql_global_status_uptime{instance="mysql-server:9104"}

2. 连接数监控

# 当前连接数
mysql_global_status_threads_connected{instance="mysql-server:9104"}

# 连接使用率（超过90%告警）
100 * mysql_global_status_threads_connected{instance="mysql-server:9104"} / 
mysql_global_variables_max_connections{instance="mysql-server:9104"} > 90

# 活跃连接数
mysql_global_status_threads_running{instance="mysql-server:9104"}

3. 查询性能监控

# QPS（每秒查询数）
rate(mysql_global_status_questions{instance="mysql-server:9104"}[5m])

# 慢查询数量（5分钟内）
rate(mysql_global_status_slow_queries{instance="mysql-server:9104"}[5m])

# 慢查询率
rate(mysql_global_status_slow_queries{instance="mysql-server:9104"}[5m]) / 
rate(mysql_global_status_questions{instance="mysql-server:9104"}[5m]) * 100

4. InnoDB 缓冲池监控

# 缓冲池命中率（低于95%告警）
(
  mysql_global_status_innodb_buffer_pool_read_requests{instance="mysql-server:9104"} - 
  mysql_global_status_innodb_buffer_pool_reads{instance="mysql-server:9104"}
) / mysql_global_status_innodb_buffer_pool_read_requests{instance="mysql-server:9104"} * 100 < 95

# 缓冲池使用率
mysql_global_status_innodb_buffer_pool_pages_total{instance="mysql-server:9104"} - 
mysql_global_status_innodb_buffer_pool_pages_free{instance="mysql-server:9104"}

5. 复制状态监控

# 主从复制延迟（秒）
mysql_slave_lag_seconds{instance="mysql-slave:9104"}

# 复制状态（0=正常，1=异常）
mysql_slave_sql_running{instance="mysql-slave:9104"} != 0

二、Redis 监控

1. 服务健康状态

# Redis是否存活
redis_up{instance="redis-server:9121"} != 1

# 运行时长（秒）
redis_uptime_in_seconds{instance="redis-server:9121"}

2. 内存使用监控

# 内存使用率（超过80%告警）
redis_memory_used_bytes{instance="redis-server:9121"} / 
redis_memory_max_bytes{instance="redis-server:9121"} * 100 > 80

# 内存碎片率
redis_memory_mem_fragmentation_ratio{instance="redis-server:9121"}

3. 连接数监控

# 当前连接数
redis_connected_clients{instance="redis-server:9121"}

# 连接使用率
redis_connected_clients{instance="redis-server:9121"} / 
redis_config_maxclients{instance="redis-server:9121"} * 100

# 被拒绝的连接数（1小时内）
increase(redis_rejected_connections_total{instance="redis-server:9121"}[1h])

4. 命中率监控

# 缓存命中率（低于90%告警）
(
  redis_keyspace_hits_total{instance="redis-server:9121"} / 
  (redis_keyspace_hits_total{instance="redis-server:9121"} + 
   redis_keyspace_misses_total{instance="redis-server:9121"})
) * 100 < 90

# 每秒命中数
rate(redis_keyspace_hits_total{instance="redis-server:9121"}[5m])

# 每秒未命中数
rate(redis_keyspace_misses_total{instance="redis-server:9121"}[5m])

5. 命令处理性能

# 每秒处理命令数（OPS）
rate(redis_commands_processed_total{instance="redis-server:9121"}[5m])

# 网络流量（字节/秒）
rate(redis_net_input_bytes_total{instance="redis-server:9121"}[5m]) + 
rate(redis_net_output_bytes_total{instance="redis-server:9121"}[5m])

三、CPU 监控

1. CPU 使用率

# 单实例CPU使用率
100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# 集群整体CPU使用率
100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# 按CPU核心查询使用率
100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance, cpu) * 100)

# CPU使用率超过80%的实例
100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80

2. 系统负载

# 1分钟平均负载
node_load1{instance="node1:9100"}

# 5分钟平均负载
node_load5{instance="node1:9100"}

# 15分钟平均负载
node_load15{instance="node1:9100"}

# 负载超过CPU核心数的告警
node_load1{instance="node1:9100"} > count by (instance) (node_cpu_seconds_total{mode="idle"})

四、磁盘监控

1. 磁盘空间使用率

# 磁盘使用率（排除虚拟文件系统）
(
  node_filesystem_size_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"} - 
  node_filesystem_free_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"}
) / node_filesystem_size_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"} * 100

# 磁盘使用率超过85%告警
(
  node_filesystem_size_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"} - 
  node_filesystem_free_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"}
) / node_filesystem_size_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"} * 100 > 85

# 磁盘剩余空间（GB）
node_filesystem_free_bytes{fstype!~"tmpfs|fuse.lxcfs|squashfs"} / 1024 / 1024 / 1024

2. 磁盘IO性能

# 磁盘IO使用率
rate(node_disk_io_time_seconds_total[5m]) * 100

# 磁盘读写IOPS
rate(node_disk_reads_completed_total[5m]) + rate(node_disk_writes_completed_total[5m])

# 磁盘读写吞吐量（MB/s）
rate(node_disk_read_bytes_total[5m]) / 1024 / 1024 + 
rate(node_disk_written_bytes_total[5m]) / 1024 / 1024

# 磁盘读操作速率
rate(node_disk_reads_completed_total[5m])

# 磁盘写操作速率
rate(node_disk_writes_completed_total[5m])

五、内存监控

1. 内存使用率

# 准确的内存使用率（排除缓存和缓冲区）
(
  node_memory_MemTotal_bytes - node_memory_MemFree_bytes - 
  node_memory_Buffers_bytes - node_memory_Cached_bytes
) / node_memory_MemTotal_bytes * 100

# 内存可用率
node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100

# 内存使用率超过90%告警
(
  node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes
) / node_memory_MemTotal_bytes * 100 > 90

# Swap使用率
(
  node_memory_SwapTotal_bytes - node_memory_SwapFree_bytes
) / node_memory_SwapTotal_bytes * 100

2. 内存压力告警

# 内存使用率>90%且Swap使用率>50%
(
  (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / 
  node_memory_MemTotal_bytes * 100 > 90
) and (
  (node_memory_SwapTotal_bytes - node_memory_SwapFree_bytes) / 
  node_memory_SwapTotal_bytes * 100 > 50
)

六、网络监控

1. 网络流量监控

# 网络接收流量（MB/s）
rate(node_network_receive_bytes_total{device!~"lo|docker.*|veth.*"}[5m]) / 1024 / 1024

# 网络发送流量（MB/s）
rate(node_network_transmit_bytes_total{device!~"lo|docker.*|veth.*"}[5m]) / 1024 / 1024

# 网络接收包速率（packets/s）
rate(node_network_receive_packets_total{device!~"lo|docker.*|veth.*"}[5m])

# 网络发送包速率（packets/s）
rate(node_network_transmit_packets_total{device!~"lo|docker.*|veth.*"}[5m])

2. 网络错误率

# 网络错误包率
rate(node_network_receive_errs_total[5m]) + rate(node_network_transmit_errs_total[5m])

# TCP连接数
node_netstat_Tcp_CurrEstab

# TCP连接建立速率
rate(node_netstat_Tcp_PassiveOpens[5m]) + rate(node_netstat_Tcp_ActiveOpens[5m])

3. 网络带宽利用率

# 假设1Gbps带宽，计算利用率
rate(node_network_transmit_bytes_total{device="eth0"}[5m]) * 8 / 1000 / 1000 / 1000 * 100

七、Kafka 监控

1. Broker 监控

# Broker活跃控制器数量
kafka_controller_kafkacontroller_activecontrollercount

# 未复制分区数
kafka_controller_kafkacontroller_offlinepartitionscount

# 分区总数
kafka_log_log_size{}

# 消息流入速率（字节/秒）
rate(kafka_server_brokertopicmetrics_bytesin_total[5m])

# 消息流出速率（字节/秒）
rate(kafka_server_brokertopicmetrics_bytesout_total[5m])

2. Topic 监控

# 按Topic统计消息流入速率
sum by (topic) (rate(kafka_server_brokertopicmetrics_bytesin_total[5m]))

# 按Topic统计消息流出速率
sum by (topic) (rate(kafka_server_brokertopicmetrics_bytesout_total[5m]))

# Topic分区数
sum by (topic) (kafka_log_log_size{})

3. Consumer 监控

# Consumer Lag（消息积压）
kafka_consumer_consumer_lag{}

# Consumer消费速率
rate(kafka_consumer_consumer_fetch_manager_metrics_records_consumed_rate_total[5m])

# Consumer消费延迟
kafka_consumer_consumer_fetch_manager_metrics_fetch_latency_avg{}

# Consumer组状态
kafka_consumer_consumer_group_coordinator_metrics_consumer_group_state{}

4. Producer 监控

# Producer发送速率
rate(kafka_producer_producer_metrics_record_send_rate_total[5m])

# Producer发送延迟
kafka_producer_producer_metrics_record_send_latency_avg{}

# Producer失败率
rate(kafka_producer_producer_metrics_record_error_rate_total[5m]) / 
rate(kafka_producer_producer_metrics_record_send_rate_total[5m]) * 100

八、Kubernetes 监控

1. 节点资源监控

# 节点CPU使用率
100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# 节点内存使用率
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / 
node_memory_MemTotal_bytes * 100

# 节点磁盘使用率
(node_filesystem_size_bytes - node_filesystem_free_bytes) / 
node_filesystem_size_bytes * 100

# 节点可调度Pod数量
kube_node_status_allocatable{resource="pods"}

2. Pod 监控

# Pod CPU使用率
sum(rate(container_cpu_usage_seconds_total{pod!=""}[5m])) by (pod) / 
sum(container_spec_cpu_quota{pod!=""}/container_spec_cpu_period{pod!=""}) by (pod) * 100

# Pod内存使用率
sum(container_memory_usage_bytes{pod!=""}) by (pod) / 
sum(container_spec_memory_limit_bytes{pod!=""}) by (pod) * 100

# Pod重启次数
kube_pod_container_status_restarts_total{}

# Pod状态监控
kube_pod_status_phase{phase!="Running"}

3. Deployment 监控

# Deployment副本数
kube_deployment_status_replicas{}

# 可用副本数
kube_deployment_status_replicas_available{}

# 副本就绪率
kube_deployment_status_replicas_available{} / 
kube_deployment_spec_replicas{} * 100

# 副本更新状态
kube_deployment_status_condition{condition="Progressing"}

4. Service 监控

# Service端点数量
kube_endpoint_addresses{}

# Service端点就绪数量
kube_endpoint_addresses_ready{}

# Service就绪率
kube_endpoint_addresses_ready{} / kube_endpoint_addresses{} * 100

5. PVC 监控

# PVC使用率
(kubelet_volume_stats_used_bytes / kubelet_volume_stats_capacity_bytes) * 100

# PVC使用率超过85%告警
(kubelet_volume_stats_used_bytes / kubelet_volume_stats_capacity_bytes) * 100 > 85

九、Nginx 监控

1. 连接数监控

# 活跃连接数
nginx_connections_active{}

# 读取连接数
nginx_connections_reading{}

# 写入连接数
nginx_connections_writing{}

# 等待连接数
nginx_connections_waiting{}

2. 请求性能监控

# 总请求数
nginx_http_requests_total{}

# QPS（每秒请求数）
rate(nginx_http_requests_total[5m])

# 按状态码统计请求量
sum by (status) (rate(nginx_http_requests_total[5m]))

# 错误率（4xx和5xx）
(
  sum(rate(nginx_http_requests_total{status=~"4..|5.."}[5m])) / 
  sum(rate(nginx_http_requests_total[5m]))
) * 100

# 请求处理时间
nginx_http_request_time_seconds{}

3. 流量监控

# 接收流量（字节/秒）
rate(nginx_http_request_size_bytes_total[5m])

# 发送流量（字节/秒）
rate(nginx_http_response_size_bytes_total[5m])

# 总流量
rate(nginx_http_request_size_bytes_total[5m]) + 
rate(nginx_http_response_size_bytes_total[5m])

4. 按虚拟主机监控

# 按虚拟主机统计QPS
sum by (vhost) (rate(nginx_http_requests_total[5m]))

# 按虚拟主机统计错误率
sum by (vhost) (rate(nginx_http_requests_total{status=~"4..|5.."}[5m])) / 
sum by (vhost) (rate(nginx_http_requests_total[5m])) * 100

# 按虚拟主机统计响应时间
avg by (vhost) (nginx_http_request_time_seconds{})

十、告警规则示例

1. MySQL 告警规则

groups:
- name: mysql-alerts
  rules:
  - alert: MySQLHighConnections
    expr: 100 * mysql_global_status_threads_connected / mysql_global_variables_max_connections > 90
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "MySQL连接数使用率过高"
      description: "实例 {{ $labels.instance }} 连接数使用率达到 {{ $value }}%"

  - alert: MySQLSlowQueries
    expr: rate(mysql_global_status_slow_queries[5m]) > 10
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "MySQL慢查询数量异常"
      description: "实例 {{ $labels.instance }} 5分钟内慢查询数量达到 {{ $value }}"

2. Redis 告警规则

groups:
- name: redis-alerts
  rules:
  - alert: RedisHighMemoryUsage
    expr: redis_memory_used_bytes / redis_memory_max_bytes * 100 > 80
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Redis内存使用率过高"
      description: "实例 {{ $labels.instance }} 内存使用率达到 {{ $value }}%"

  - alert: RedisLowHitRate
    expr: redis_keyspace_hits_total / (redis_keyspace_hits_total + redis_keyspace_misses_total) * 100 < 90
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "Redis缓存命中率过低"
      description: "实例 {{ $labels.instance }} 缓存命中率仅为 {{ $value }}%"

3. 系统资源告警规则

groups:
- name: system-alerts
  rules:
  - alert: HighCPUUsage
    expr: 100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "CPU使用率过高"
      description: "实例 {{ $labels.instance }} CPU使用率达到 {{ $value }}%"

  - alert: HighMemoryUsage
    expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 90
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "内存使用率过高"
      description: "实例 {{ $labels.instance }} 内存使用率达到 {{ $value }}%"

  - alert: HighDiskUsage
    expr: (node_filesystem_size_bytes - node_filesystem_free_bytes) / node_filesystem_size_bytes * 100 > 85
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "磁盘使用率过高"
      description: "实例 {{ $labels.instance }} 磁盘使用率达到 {{ $value }}%"

十一、最佳实践建议

1. 监控策略

• 分级告警：设置多级告警阈值（警告、严重、紧急）
• 持续时间：避免瞬时波动误报，设置合理的 for 持续时间
• 标签过滤：使用具体的标签选择器，避免查询所有时间序列
• 时间窗口：根据监控需求选择合适的时间范围（如 [5m]、[1h]）

2. 性能优化

• Recording Rules：对复杂查询使用记录规则预计算
• 标签选择器优化：避免使用高基数标签进行聚合
• 时间范围优化：避免过长的时间窗口影响性能
• 聚合优化：推迟聚合操作，使用 group_left 和 group_right

3. 告警配置

• 告警静默：配置告警静默时段，避免夜间误报
• 多渠道通知：集成邮件、Slack、钉钉等多种通知渠道
• 告警分级：根据业务影响程度设置不同级别的告警
• 告警收敛：配置告警分组和抑制规则，避免告警风暴

通过以上完整的 PromQL 示例和最佳实践，您可以构建一套完善的监控告警体系，覆盖从基础设施到应用服务的全链路监控。