Prometheus 笔记

Prometheus概述

什么是Prometheus

Prometheus是一种开源的系统监控和报警工具，最早由SoundCloud开发，现已成为CNCF（Cloud Native Computing Foundation）的一部分。Prometheus以其高效的数据收集、存储和查询能力，在云原生环境中广泛应用。

Prometheus主要用于采集时间序列数据（如系统性能指标、应用性能数据等），并且提供强大的查询语言（PromQL）用于数据分析和报警设置。它的架构设计使其非常适合动态环境，如微服务和容器化部署。

Prometheus的主要功能和特点

1. 多维数据模型

   • 指标（Metric）和标签（Label）： Prometheus的数据模型基于指标和标签，每个指标可以有多个标签，用于多维数据分类和查询。

2. 灵活的查询语言（PromQL）

   • 查询和聚合： PromQL允许用户通过灵活的查询和聚合操作来分析数据，实现复杂的监控需求。
   • 实时性： 提供实时数据查询和报警，支持快速响应系统变化。

3. 主动抓取数据

   • Scraping: Prometheus通过HTTP拉取（scrape）方式主动从被监控的目标系统收集数据，支持各种服务发现机制（如Kubernetes、Consul等）。
   • 多种抓取目标: 支持从各种导出器（Exporter）和自定义应用中抓取数据。

4. 时间序列数据库（TSDB）

   • 高效存储: 使用高效的时间序列数据库存储数据，支持高吞吐量的数据写入和读取。
   • 持久化和压缩: 数据持久化和压缩机制确保长时间存储的高效性和可靠性。

5. 报警和通知

   • 告警规则: 基于PromQL定义告警规则，支持多种告警条件和复杂告警表达式。
   • Alertmanager: 集成Alertmanager，支持告警的分组、路由、抑制和通知（如Email、Slack、PagerDuty等）。

6. 多种集成和扩展

   • 导出器: 提供丰富的导出器，用于监控操作系统、数据库、中间件等。
   • Grafana: 与Grafana无缝集成，提供强大的数据可视化能力。
   • 自定义集成: 支持自定义导出器和集成，满足特定监控需求。

使用Prometheus的优势

1. 灵活性和可扩展性

   • 适应多种环境: Prometheus能够适应容器化、微服务架构和传统的单体应用，提供灵活的监控方案。
   • 横向扩展: 支持分布式部署和高可用性架构，能够处理大规模的监控需求。

2. 强大的数据分析能力

   • 实时分析: 提供实时的数据分析和报警能力，帮助快速识别和响应系统问题。
   • 复杂查询: 支持复杂的查询和数据处理操作，满足深入分析和定制监控的需求。

3. 社区和生态系统

   • 活跃社区: Prometheus拥有一个活跃的开源社区，提供持续的改进和支持。
   • 丰富的资源: 广泛的文档、教程和社区资源帮助用户快速上手和解决问题。
   • 生态系统: Prometheus生态系统中有丰富的导出器、集成工具和扩展，能够满足各种监控需求。

4. 开源和免费

   • 无许可成本: 作为一个开源项目，Prometheus免费使用，没有许可成本。
   • 透明和可定制: 开源代码和透明的开发过程使得用户可以根据需要进行定制和优化。

Prometheus作为一款功能强大、灵活性高的监控工具，已经成为现代云原生监控解决方案的首选。通过深入了解其功能和特点，可以更好地利用Prometheus进行系统监控和性能优化。

Prometheus的架构

数据模型

Prometheus的数据模型是其监控系统的核心，旨在高效地收集、存储和查询时间序列数据。

1. 时间序列（Time Series）

   • 定义: 时间序列是一组按照时间顺序排列的数据点，每个数据点由一个时间戳和一个对应的值组成。
   • 唯一标识: 每个时间序列由指标名称（Metric Name）和一组标签（Labels）唯一标识。标签是键值对，用于描述时间序列的附加信息。

2. 指标（Metrics）

   • 类型: Prometheus支持四种指标类型：
     • Counter: 单调递增的计数器，表示一个累计值，如请求数、任务数等。
     • Gauge: 可上下波动的指标，表示瞬时值，如温度、内存使用量等。
     • Histogram: 直方图，用于表示数据的分布，如请求延迟。
     • Summary: 用于计算分位数（Percentiles）的摘要，类似于直方图，但更注重准确度。

3. 标签（Labels）

   • 用途: 标签用于为时间序列增加维度，便于细粒度的查询和聚合。例如，HTTP请求的响应时间指标可以使用标签区分不同的HTTP方法和状态码。

数据存储

Prometheus的数据存储设计为高效处理大规模时间序列数据。

1. 本地存储

   • 时间序列数据库（TSDB）: Prometheus内置的时间序列数据库，用于高效存储和压缩时间序列数据。数据按照时间块（Block）进行存储和管理。
   • 存储周期: 数据被分成2小时的块，每个块包含原始样本和索引。过期数据（默认15天）会被自动删除。
   • 压缩: 使用Gorilla压缩算法，有效减少存储空间。

2. 远程存储

   • 远程写入和读取: Prometheus支持将数据写入外部存储系统（如Thanos、Cortex）以实现长时间存储和高可用性。
   • 扩展: 通过远程存储集成，可以扩展Prometheus的存储能力和查询性能。

Prometheus组件

Prometheus的架构由多个关键组件组成，每个组件承担特定的功能，以实现全面的监控和告警能力。

1. Prometheus Server

   • 数据抓取: 定期从配置的抓取目标（Scrape Targets）获取指标数据。
   • 存储: 将收集到的数据存储在本地时间序列数据库中。
   • 查询: 提供PromQL查询接口，供用户和可视化工具查询数据。
   • 告警: 根据预定义的告警规则（Alert Rules）评估数据，并生成告警。

2. Pushgateway

   • 用途: 用于短生命周期的作业（如批处理任务）推送指标数据。因为这些作业的生命周期太短，Prometheus无法定期抓取它们的数据。
   • 工作原理: 作业在运行结束时将指标数据推送到Pushgateway，Prometheus则从Pushgateway中抓取这些数据。

3. Alertmanager

   • 告警管理: 接收Prometheus Server发送的告警，进行分组、抑制、去重和路由。
   • 通知: 将处理后的告警通过配置的通知渠道（如Email、Slack、PagerDuty等）发送给用户。
   • 配置: 支持告警的分组和路由规则，灵活管理告警通知。

4. Exporter

   • 作用: 用于暴露特定系统、服务或应用的指标数据。Prometheus通过HTTP抓取Exporter提供的数据。
   • 常见Exporter: Node Exporter（用于监控操作系统层面的指标）、MySQL Exporter、Kafka Exporter等。
   • 自定义Exporter: 用户可以根据需要开发自定义Exporter，以满足特定监控需求。

5. Service Discovery

   • 自动发现: 支持通过多种服务发现机制（如Kubernetes、Consul、EC2等）自动发现抓取目标，适应动态变化的环境。
   • 配置: 使用配置文件指定服务发现机制和参数，实现自动化监控配置。

Prometheus的架构设计使其具备高度的灵活性和可扩展性，适用于各种规模和复杂度的监控需求。通过理解和利用这些组件，可以有效地监控和管理系统的性能和健康状态。

安装Prometheus

安装前的准备工作

在安装Prometheus之前，需要进行一些准备工作，以确保安装过程顺利进行。

1. 系统要求

   • 操作系统: Prometheus可以运行在大多数主流操作系统上，如Linux、Windows和macOS。通常推荐在Linux服务器上部署，以获得更好的性能和稳定性。
   • 硬件要求: 确保有足够的CPU、内存和存储资源。具体需求取决于监控目标的数量和数据量。

2. 网络配置

   • 防火墙: 确保Prometheus服务器能够访问所有需要监控的目标，以及配置防火墙规则以允许Prometheus的抓取请求。
   • 端口: 默认情况下，Prometheus使用端口9090进行Web UI和API访问。确保此端口在防火墙规则中是开放的。

3. 用户权限

   • 权限: 确保安装和运行Prometheus的用户具有必要的系统权限，特别是在Linux上，建议创建一个专用用户来运行Prometheus。

4. 依赖软件

   • 包管理器: 在Linux上使用包管理器（如apt、yum等）可以简化安装过程。在Windows上，可以使用Chocolaty来管理软件包。
   • Docker: 如果选择使用Docker方式安装Prometheus，请确保Docker已正确安装和配置。

不同平台的安装步骤

在Linux上安装Prometheus

1. 下载Prometheus

   • 访问Prometheus的官方下载页面，下载最新版本的Prometheus tar包。
   • 使用wget命令下载：

     wget https://github.com/prometheus/prometheus/releases/download/v<version>/prometheus-<version>.linux-amd64.tar.gz
     

2. 解压文件

   • 使用tar命令解压下载的tar包：

     tar -xvf prometheus-<version>.linux-amd64.tar.gz
     

3. 移动文件

   • 将解压后的Prometheus二进制文件和配置文件移动到适当的位置：

     sudo mv prometheus-<version>.linux-amd64/prometheus /usr/local/bin/
     sudo mv prometheus-<version>.linux-amd64/promtool /usr/local/bin/
     sudo mv prometheus-<version>.linux-amd64/prometheus.yml /etc/prometheus/prometheus.yml
     

4. 创建Prometheus用户和目录

   • 创建Prometheus用户和数据目录：

     sudo useradd -rs /bin/false prometheus
     sudo mkdir /var/lib/prometheus
     sudo chown prometheus:prometheus /var/lib/prometheus
     

5. 创建Systemd服务

   • 创建Prometheus的systemd服务文件：

     sudo nano /etc/systemd/system/prometheus.service

   • 添加以下内容：

     [Unit]
     Description=Prometheus
     Wants=network-online.target
     After=network-online.target
      
     [Service]
     User=prometheus
     Group=prometheus
     Type=simple
     ExecStart=/usr/local/bin/prometheus \
       --config.file /etc/prometheus/prometheus.yml \
       --storage.tsdb.path /var/lib/prometheus/
      
     [Install]
     WantedBy=multi-user.target
     

6. 启动Prometheus

   • 重新加载systemd并启动Prometheus服务：

     sudo systemctl daemon-reload
     sudo systemctl start prometheus
     sudo systemctl enable prometheus
     

在Windows上安装Prometheus

1. 下载Prometheus

   • 访问Prometheus的官方下载页面，下载最新版本的Prometheus zip包。

2. 解压文件

   • 解压下载的zip包到一个方便的位置，例如：C:\prometheus\

3. 配置Prometheus

   • 编辑解压目录中的prometheus.yml文件，根据需要配置抓取目标和其他设置。

4. 创建Windows服务

   • 打开命令提示符，使用nssm工具将Prometheus注册为Windows服务（需要先安装nssm工具）：

     nssm install Prometheus C:\prometheus\prometheus.exe --config.file C:\prometheus\prometheus.yml
     

5. 启动Prometheus

   • 启动Prometheus服务：

     nssm start Prometheus

使用Docker安装Prometheus

1. 拉取Prometheus Docker镜像

   • 使用以下命令从Docker Hub拉取Prometheus镜像：

     docker pull prom/prometheus

2. 运行Prometheus容器

   • 运行Prometheus容器，并挂载本地配置文件和数据目录：

     docker run -d \
       --name prometheus \
       -p 9090:9090 \
       -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml \
       -v /path/to/prometheus_data:/prometheus \
       prom/prometheus
     

通过上述步骤，你可以在不同平台上成功安装和运行Prometheus。安装完成后，可以通过浏览器访问http://<服务器IP>:9090，进入Prometheus的Web界面，进行进一步的配置和使用。

抓取数据

在Prometheus中，抓取数据是其核心功能之一。抓取目标（scrape targets）是Prometheus定期从中获取指标数据的端点。抓取目标的配置有两种主要方式：静态配置和使用服务发现（Service Discovery）。以下是这两种方式的详细说明。

抓取目标（scrape targets）的定义

抓取目标是Prometheus配置中的一部分，它定义了Prometheus应该从哪些端点抓取指标数据。抓取目标配置包含在prometheus.yml文件中，主要包括以下内容：

1. job_name

   • 每个抓取配置（job）都有一个唯一的名称，用于区分不同的抓取任务。
   • 示例：

     - job_name: 'node_exporter'

2. scrape_interval

   • 定义Prometheus抓取数据的频率。默认是15s，即每15秒抓取一次。
   • 示例：

     scrape_interval: '15s'

3. scrape_timeout

   • 定义Prometheus等待目标响应的时间。如果超时，将放弃此次抓取。默认是10s。
   • 示例：

     scrape_timeout: '10s'

4. metrics_path

   • 定义Prometheus在目标上抓取指标数据的路径。默认是/metrics。
   • 示例：

     metrics_path: '/metrics'
     

5. static_configs 或 service_discovery_configs

   • 定义抓取目标的具体地址，静态配置使用static_configs，而服务发现配置使用service_discovery_configs。

使用Service Discovery发现抓取目标

服务发现（Service Discovery）使得Prometheus可以动态地发现和更新抓取目标，适应云环境和微服务架构中不断变化的服务。Prometheus支持多种服务发现机制，如Kubernetes、Consul、AWS EC2等。

1. Kubernetes Service Discovery

   • Prometheus通过Kubernetes API动态发现Pod、服务和节点。
   • 示例配置：

     - job_name: 'kubernetes-pods'
       kubernetes_sd_configs:
         - role: pod
       relabel_configs:
         - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
           action: keep
           regex: true
         - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
           action: replace
           target_label: __metrics_path__
           regex: (.+)
         - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
           action: replace
           target_label: __address__
           regex: (.+):(?:\d+);(\d+)
           replacement: $1:$2
     

2. Consul Service Discovery

   • Prometheus通过Consul API动态发现注册在Consul中的服务。
   • 示例配置：

     - job_name: 'consul-services'
       consul_sd_configs:
         - server: 'localhost:8500'
           services: []
       relabel_configs:
         - source_labels: [__meta_consul_tags]
           action: keep
           regex: .*,prometheus,.*
     

3. EC2 Service Discovery

   • Prometheus通过AWS EC2 API动态发现运行中的EC2实例。
   • 示例配置：

     - job_name: 'ec2-instances'
       ec2_sd_configs:
         - region: us-east-1
       relabel_configs:
         - source_labels: [__meta_ec2_tag_Prometheus]
           action: keep
           regex: true
     

静态配置抓取目标

静态配置适用于抓取目标固定且不经常变化的场景。配置直接在prometheus.yml文件中定义。

1. 基本静态配置

   • 示例：

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']
     

2. 多个抓取目标

   • 示例：

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100', 'remotehost:9100']
     

3. 标签配置

   • 可以为抓取目标添加额外的标签，便于在查询时进行区分和过滤。
   • 示例：

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']
             labels:
               env: 'production'
               instance: 'localhost'
     

通过以上配置方式，Prometheus可以灵活地定义和管理抓取目标，无论是在静态环境还是动态环境中。抓取数据是Prometheus监控的基础，通过合理配置，可以确保Prometheus高效、准确地收集所需的指标数据。

指标（Metrics）类型

Prometheus支持四种主要的指标类型：Counter、Gauge、Histogram和Summary。每种类型的指标适用于不同的监控需求，帮助用户准确收集和分析系统的性能数据。

Counter

Counter是一种单调递增的计数器，用于记录累计值。它只能增加或重置为零，不能减少。典型的使用场景包括请求数、任务完成数、错误数等。

1. 特性

   • 单调递增: 值只能增加，适用于累计计数。
   • 重置: 只有在进程重启时才会重置为零。

2. 使用场景

   • HTTP请求数: 记录服务接收到的HTTP请求总数。
   • 错误计数: 记录发生的错误总数。
   • 任务完成数: 记录已完成任务的总数。

3. 示例

   var (
       requests = prometheus.NewCounter(
           prometheus.CounterOpts{
               Name: "http_requests_total",
               Help: "Total number of HTTP requests.",
           },
       )
   )
    
   func handler() {
       requests.Inc()
       // handle request
   }
   

Gauge

Gauge是一种可变指标，用于记录可以上下波动的值。它可以增加、减少或设置为任意值。典型的使用场景包括温度、内存使用量、CPU利用率等。

1. 特性

   • 可变: 值可以随时增加、减少或设置。
   • 瞬时值: 记录某一时刻的瞬时值，适用于监控当前状态。

2. 使用场景

   • 温度: 记录当前温度值。
   • 内存使用量: 记录当前系统或应用的内存使用量。
   • CPU利用率: 记录当前的CPU利用率。

3. 示例

   var (
       memoryUsage = prometheus.NewGauge(
           prometheus.GaugeOpts{
               Name: "memory_usage_bytes",
               Help: "Current memory usage in bytes.",
           },
       )
   )
    
   func updateMemoryUsage() {
       // Get the current memory usage
       memoryUsage.Set(currentMemoryUsage)
   }
   

Histogram

Histogram用于记录数据分布情况，并提供数据的计数和分桶（bucket）。典型的使用场景包括请求延迟、响应时间等。

1. 特性

   • 分桶: 将数据分配到不同的桶中，记录每个桶中的数据数量。
   • 计数和总和: 记录所有观测值的计数和总和，便于计算平均值等统计数据。

2. 使用场景

   • 请求延迟: 记录HTTP请求的延迟时间。
   • 响应时间: 记录系统或服务的响应时间。

3. 示例

   var (
       requestLatency = prometheus.NewHistogram(
           prometheus.HistogramOpts{
               Name:    "http_request_latency_seconds",
               Help:    "HTTP request latency in seconds.",
               Buckets: prometheus.DefBuckets,
           },
       )
   )
    
   func handler() {
       start := time.Now()
       // handle request
       requestLatency.Observe(time.Since(start).Seconds())
   }
   

Summary

Summary用于计算观测值的分位数（percentiles），类似于Histogram，但更加精确。它记录数据的总和、计数和指定分位数。典型的使用场景包括延迟时间的高精度统计。

1. 特性

   • 分位数: 计算并提供数据的分位数，如50%、90%、99%等。
   • 计数和总和: 记录所有观测值的计数和总和，便于计算平均值等统计数据。

2. 使用场景

   • 请求延迟: 高精度记录HTTP请求的延迟时间。
   • 响应时间: 高精度记录系统或服务的响应时间。

3. 示例

   var (
       requestLatencySummary = prometheus.NewSummary(
           prometheus.SummaryOpts{
               Name:       "http_request_latency_seconds",
               Help:       "HTTP request latency in seconds.",
               Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
           },
       )
   )
    
   func handler() {
       start := time.Now()
       // handle request
       requestLatencySummary.Observe(time.Since(start).Seconds())
   }
   

指标类型总结

• Counter: 用于累计计数，适用于请求数、错误数等。
• Gauge: 用于记录可变值，适用于温度、内存使用量等。
• Histogram: 用于记录数据分布，适用于请求延迟等。
• Summary: 用于高精度计算分位数，适用于高精度延迟统计等。

通过合理选择和使用不同类型的指标，可以有效监控和分析系统的性能，提供可靠的数据支持决策。

导出器（Exporters）

导出器（Exporters）是Prometheus生态系统的重要组成部分，用于从各种系统、服务和应用中收集指标数据。导出器将这些数据以Prometheus能够抓取的格式暴露出来，便于统一监控和分析。以下是导出器的详细讲解，包括Node Exporter、常见第三方Exporter和自定义Exporter。

Node Exporter

Node Exporter是Prometheus官方提供的导出器，用于收集和暴露Linux系统的硬件和操作系统级别的指标。这些指标包括CPU、内存、磁盘、网络等，适合于监控系统性能和健康状况。

1. 安装和运行

   • 下载和解压：

     wget https://github.com/prometheus/node_exporter/releases/download/v<version>/node_exporter-<version>.linux-amd64.tar.gz
     tar -xvf node_exporter-<version>.linux-amd64.tar.gz
     cd node_exporter-<version>.linux-amd64
     

   • 运行Node Exporter：

     ./node_exporter &

   • 配置Prometheus抓取Node Exporter数据： 在prometheus.yml中添加以下配置：

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']
     

2. 暴露的指标

   • CPU: CPU使用情况、上下文切换、进程数量等。
   • 内存: 内存使用量、交换分区使用量等。
   • 磁盘: 磁盘I/O操作、磁盘空间使用情况等。
   • 网络: 网络流量、网络错误、丢包等。

常见第三方Exporter

除了Node Exporter，社区和官方提供了许多用于不同系统和服务的导出器。这些导出器大大扩展了Prometheus的监控能力。以下是一些常见的第三方Exporter：

1. MySQL Exporter

   • 用途: 监控MySQL数据库的性能和健康状况。
   • 暴露的指标: 查询时间、连接数、缓存命中率、慢查询数等。
   • 安装和运行：

     docker run -d -p 9104:9104 \
       -e DATA_SOURCE_NAME="user:password@(hostname:port)/dbname" \
       prom/mysqld-exporter
     

2. Blackbox Exporter

   • 用途: 执行外部探测，例如HTTP、HTTPS、DNS、TCP等，监控服务的可用性和响应时间。
   • 暴露的指标: 探测成功率、响应时间等。
   • 安装和运行：

     docker run -d -p 9115:9115 prom/blackbox-exporter

3. Kafka Exporter

   • 用途: 监控Kafka集群的运行状况。
   • 暴露的指标: 消息数、主题分区、消费者偏移量等。
   • 安装和运行：

     docker run -d -p 9308:9308 \
       -e KAFKA_SERVER="kafka:9092" \
       danielqsj/kafka-exporter
     

4. PostgreSQL Exporter

   • 用途: 监控PostgreSQL数据库的性能和健康状况。
   • 暴露的指标: 查询时间、连接数、缓存命中率、慢查询数等。
   • 安装和运行：

     docker run -d -p 9187:9187 \
       -e DATA_SOURCE_NAME="postgresql://user:password@hostname:port/dbname" \
       wrouesnel/postgres_exporter
     

自定义Exporter

有时官方或第三方导出器无法满足特定的监控需求，这时可以创建自定义Exporter。自定义Exporter可以使用任何编程语言开发，只要它能够以Prometheus格式暴露指标数据。

1. 选择编程语言和库

   • Go: Prometheus官方提供了Go语言的客户端库prometheus/client_golang，适合高性能需求。
   • Python: 对于快速开发和原型验证，可以使用prometheus_client库。

2. 实现示例（Go语言）

   package main
    
   import (
       "net/http"
       "github.com/prometheus/client_golang/prometheus"
       "github.com/prometheus/client_golang/prometheus/promhttp"
   )
    
   var (
       myMetric = prometheus.NewGauge(prometheus.GaugeOpts{
           Name: "my_custom_metric",
           Help: "This is my custom metric",
       })
   )
    
   func init() {
       prometheus.MustRegister(myMetric)
   }
    
   func main() {
       http.Handle("/metrics", promhttp.Handler())
       go func() {
           for {
               myMetric.Set(42) // 设置自定义指标的值
               time.Sleep(10 * time.Second)
           }
       }()
       http.ListenAndServe(":8080", nil)
   }
   

3. 实现示例（Python语言）

   from prometheus_client import start_http_server, Gauge
   import time
    
   # 创建自定义指标
   my_metric = Gauge('my_custom_metric', 'This is my custom metric')
    
   def update_metrics():
       while True:
           my_metric.set(42)  # 设置自定义指标的值
           time.sleep(10)
    
   if __name__ == '__main__':
       start_http_server(8080)  # 启动HTTP服务器
       update_metrics()
   

4. 配置Prometheus抓取自定义Exporter数据 在prometheus.yml中添加以下配置：

   scrape_configs:
     - job_name: 'my_custom_exporter'
       static_configs:
         - targets: ['localhost:8080']
   

通过使用和开发各种导出器，Prometheus可以灵活地监控不同系统、服务和应用的性能和健康状况。官方和第三方导出器适用于大多数常见场景，而自定义导出器则可以满足特定需求。

PromQL基础

PromQL（Prometheus Query Language）是Prometheus的查询语言，用于提取和分析存储在Prometheus中的时间序列数据。掌握PromQL的语法和使用方法是充分利用Prometheus强大数据分析能力的关键。

PromQL语法

PromQL语法设计简单但功能强大，可以用于对时间序列数据进行过滤、选择、聚合和运算。PromQL查询的结果可以是多种数据类型，如瞬时向量（instant vector）、区间向量（range vector）、标量（scalar）和字符串（string）。

1. 基本结构

   • 指标名称： 选择指定的指标。

     http_requests_total

   • 标签过滤： 使用标签过滤特定的时间序列。

     http_requests_total{job="api", method="GET"}

   • 时间选择器： 限制查询在特定的时间范围内。

     http_requests_total{job="api"}[5m]

2. 操作符

   • 算术运算符： +, -, *, /, %, ^

     node_cpu_seconds_total / node_cpu_seconds_total{mode="idle"}

   • 比较运算符： ==, !=, >, <, >=, <=

     http_requests_total > 100

   • 逻辑运算符： and, or, unless

     http_requests_total{job="api"} and rate(http_requests_total[5m])
     

3. 函数

   • PromQL支持多种函数，用于数据处理和分析。

     rate(http_requests_total[1m])

基本查询示例

1. 瞬时向量查询

   • 查询当前所有http_requests_total的值：

     http_requests_total
     

2. 区间向量查询

   • 查询过去5分钟内所有http_requests_total的值：

     http_requests_total[5m]

3. 速率计算

   • 计算过去1分钟内http_requests_total的平均速率：

     rate(http_requests_total[1m])
     

4. 标签过滤

   • 查询来自名为“api”的job的http_requests_total：

     http_requests_total{job="api"}

5. 标签正则匹配

   • 查询所有method标签值以“GET”开头的http_requests_total：

     http_requests_total{method=~"GET.*"}

聚合操作

PromQL提供了一系列聚合操作，用于将多个时间序列聚合成单个时间序列或更少的时间序列。常见的聚合操作包括sum、avg、min、max、count等。

1. sum（求和）

   • 对所有时间序列的http_requests_total求和：

     sum(http_requests_total)

   • 按标签job对时间序列求和：

     sum by (job) (http_requests_total)

2. avg（平均值）

   • 对所有时间序列的http_requests_total求平均值：

     avg(http_requests_total)

   • 按标签job对时间序列求平均值：

     avg by (job) (http_requests_total)

3. min（最小值）

   • 对所有时间序列的http_requests_total求最小值：

     min(http_requests_total)

   • 按标签job对时间序列求最小值：

     min by (job) (http_requests_total)

4. max（最大值）

   • 对所有时间序列的http_requests_total求最大值：

     max(http_requests_total)

   • 按标签job对时间序列求最大值：

     max by (job) (http_requests_total)

5. count（计数）

   • 统计所有时间序列的数量：

     count(http_requests_total)

   • 按标签job统计时间序列的数量：

     count by (job) (http_requests_total)

6. 其他聚合操作

   • sum_over_time： 对区间向量的值求和：

     sum_over_time(http_requests_total[5m])

   • avg_over_time： 对区间向量的值求平均：

     avg_over_time(http_requests_total[5m])

   • max_over_time： 对区间向量的值求最大：

     max_over_time(http_requests_total[5m])

   • min_over_time： 对区间向量的值求最小：

     min_over_time(http_requests_total[5m])

   • rate： 计算区间向量的每秒平均速率：

     rate(http_requests_total[5m])

   • irate： 计算区间向量的即时速率：

     irate(http_requests_total[5m])

通过熟悉PromQL的基本语法、常见查询示例和聚合操作，可以有效地利用Prometheus进行复杂的监控数据分析和系统性能优化。

高级PromQL

PromQL不仅仅是一个简单的查询语言，它还提供了强大的函数库和复杂的查询能力，使用户能够进行深度的数据分析和处理。以下是高级PromQL的详细讲解，包括使用函数、复杂查询示例和时间序列数据处理。

使用函数

Prometheus提供了丰富的内置函数，用于对时间序列数据进行各种操作。这些函数可以分为以下几类：

1. 聚合函数

   • sum_over_time()：在指定时间范围内对时间序列求和。

     sum_over_time(http_requests_total[5m])

   • avg_over_time()：在指定时间范围内对时间序列求平均值。

     avg_over_time(http_requests_total[5m])

   • max_over_time()：在指定时间范围内对时间序列求最大值。

     max_over_time(http_requests_total[5m])

   • min_over_time()：在指定时间范围内对时间序列求最小值。

     min_over_time(http_requests_total[5m])

   • count_over_time()：在指定时间范围内对时间序列求数据点数量。

     count_over_time(http_requests_total[5m])

2. 速率和计数函数

   • rate()：计算计数器时间序列在指定时间范围内的每秒增量速率。

     rate(http_requests_total[5m])

   • irate()：计算计数器时间序列在指定时间范围内的即时速率（两个相邻数据点的速率）。

     irate(http_requests_total[5m])

   • increase()：计算计数器时间序列在指定时间范围内的增量。

     increase(http_requests_total[5m])

   • delta()：计算时间序列在指定时间范围内的变化量。

     delta(node_memory_MemFree_bytes[5m])

3. 统计函数

   • quantile_over_time()：在指定时间范围内计算时间序列的分位数。

     quantile_over_time(0.9, http_request_duration_seconds[5m])

   • stddev_over_time()：在指定时间范围内计算时间序列的标准偏差。

     stddev_over_time(http_request_duration_seconds[5m])

   • stdvar_over_time()：在指定时间范围内计算时间序列的方差。

     stdvar_over_time(http_request_duration_seconds[5m])

复杂查询示例

1. 查询多个条件的组合

   • 查询所有job为api且method为GET的HTTP请求总数：

     sum(http_requests_total{job="api", method="GET"})

2. 计算CPU使用率

   • 计算所有CPU使用率，排除idle和iowait：

     1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance)
     

3. 计算错误率

   • 计算所有HTTP请求的错误率（4xx和5xx状态码）：

     sum(rate(http_requests_total{status=~"4.."}[5m])) / sum(rate(http_requests_total[5m]))
     

4. 百分比计算

   • 计算每个实例的内存使用率：

     (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes
     

5. 条件运算

   • 查找响应时间超过1秒的请求比例：

     sum(rate(http_request_duration_seconds_bucket{le="1"}[5m])) / sum(rate(http_request_duration_seconds_count[5m]))
     

时间序列数据处理

时间序列数据处理是PromQL的核心功能之一，可以对历史数据进行多种操作，以便进行详细分析。

1. 子查询

   • 使用子查询来计算一个时间范围内的速率，并对其进行进一步处理：

     avg_over_time(rate(http_requests_total[5m])[30m:])

2. 时间偏移

   • 使用offset关键字查询过去某个时间点的数据：

     http_requests_total{job="api"} offset 1h

3. 填充缺失数据

   • 使用absent函数查找缺失的时间序列并填充默认值：

     absent(http_requests_total{job="api"})

4. 复合运算

   • 计算过去5分钟的HTTP请求速率并将结果平滑处理：

     avg_over_time(rate(http_requests_total[1m])[5m:])

5. 数据归一化

   • 将不同时间范围内的数据进行归一化处理：

     rate(http_requests_total[5m]) / avg(rate(http_requests_total[5m])) by (job)
     

通过这些高级功能，PromQL可以对复杂的数据进行深入分析和处理，为用户提供更详细和有用的监控信息。这些功能使Prometheus不仅能够进行简单的监控，还可以进行复杂的性能分析和故障排除。

可视化工具

可视化工具在监控和分析系统性能时起着关键作用。Prometheus自带简单的图形界面，同时也可以与Grafana集成，创建和定制更加复杂和美观的仪表板。以下是详细讲解。

使用Prometheus自带的图形界面

Prometheus自带一个基本的图形界面，提供了一些基本的查询和可视化功能。

1. 访问Prometheus界面

   • 启动Prometheus服务器后，可以通过浏览器访问Prometheus的Web界面：

     http://<Prometheus-server-ip>:9090

2. 查询和图表展示

   • 输入查询：在顶栏的查询输入框中输入PromQL查询语句。
   • 执行查询：点击“Execute”按钮执行查询。
   • 图表展示：点击“Graph”选项卡，可以看到查询结果以图表形式展示。

3. 实例示例

   • 查询所有HTTP请求的总数并展示图表：

     http_requests_total

   • 查询过去5分钟内HTTP请求的速率并展示图表：

     rate(http_requests_total[5m])

4. 使用Tabular展示

   • 在执行查询后，点击“Table”选项卡，可以以表格形式查看查询结果的数值。

Prometheus自带的图形界面虽然简洁，但功能有限。为了更强大和灵活的可视化，推荐使用Grafana与Prometheus集成。

Grafana与Prometheus集成

Grafana是一个开源的可视化和监控工具，广泛用于时序数据库的数据展示。它与Prometheus的集成非常紧密，可以创建和定制复杂的仪表板。

1. 安装Grafana

   • Docker安装：

     docker run -d --name=grafana -p 3000:3000 grafana/grafana

   • 本地安装：
     • 访问Grafana的下载页面并根据操作系统选择合适的版本进行安装。

2. 访问Grafana界面

   • 安装并启动Grafana后，通过浏览器访问：

     http://<Grafana-server-ip>:3000

3. 添加Prometheus数据源

   • 登录Grafana：默认用户名和密码都是admin。
   • 添加数据源：
     • 点击左侧菜单的齿轮图标（Configuration），选择“Data Sources”。
     • 点击“Add data source”按钮，选择“Prometheus”。
     • 输入Prometheus的URL（例如http://<Prometheus-server-ip>:9090），点击“Save & Test”确认连接。

4. 创建和定制仪表板

5. 创建仪表板

   • 点击左侧菜单的“+”号，选择“Dashboard”。
   • 点击“Add new panel”，进入面板编辑页面。

6. 添加查询

   • 在“Query”部分，选择Prometheus作为数据源。
   • 输入PromQL查询语句，例如：

     rate(http_requests_total[5m])

7. 配置图表

   • 选择图表类型（如Graph、Singlestat、Table等）。
   • 配置图表标题、轴标签、单位等。
   • 点击“Apply”保存面板。

8. 定制面板

   • 添加多个面板以展示不同的指标。
   • 配置面板布局，调整面板大小和位置。
   • 添加变量，通过下拉菜单选择不同的指标或实例。

9. 保存仪表板

   • 点击页面顶部的“Save dashboard”按钮，输入仪表板名称并保存。

创建和定制仪表板

通过Grafana，用户可以创建和定制各种复杂的仪表板，以满足不同的监控需求。

1. 使用模板和插件

   • Grafana提供了大量预先构建的模板和插件，可以在Grafana插件页面浏览和安装。
   • 使用模板可以快速创建符合特定需求的仪表板。

2. 使用变量

   • 通过添加变量，可以使仪表板更加动态和灵活。
   • 在“Dashboard settings”中选择“Variables”，点击“Add variable”。
   • 配置变量类型（如Query、Interval等）和查询语句，例如：

     label_values(instance)

   • 在面板查询中使用变量，例如：

     rate(http_requests_total{instance="$instance"}[5m])

3. 报警配置

   • Grafana允许在仪表板中配置报警，当指标超出设定阈值时触发报警。
   • 在面板编辑页面选择“Alert”选项卡，点击“Create Alert”。
   • 配置报警条件、通知渠道等。

4. 共享和导出仪表板

   • 可以通过URL分享仪表板，或导出为JSON文件进行备份和导入。
   • 点击页面顶部的“Share dashboard”按钮，选择“Link”或“Export”。

通过使用Prometheus自带的图形界面和Grafana，用户可以直观地监控系统性能，及时发现和解决问题。Grafana的强大功能使得定制和创建复杂的仪表板变得简单易行，满足各种监控需求。

配置告警规则

在Prometheus中，告警规则（Alerting Rules）用于定义当某些条件满足时触发告警。配置合理的告警规则可以帮助我们及时发现并响应系统中的异常情况。以下是详细讲解告警规则的语法、创建简单告警规则以及复杂告警规则示例。

告警规则语法

告警规则的配置文件通常位于Prometheus的配置文件中，或者通过单独的文件引用。告警规则由以下几个部分组成：

1. 名称（alert）

   • 告警规则的名称，用于标识该规则。

2. 条件（expr）

   • 用PromQL表达式定义触发告警的条件。

3. 持续时间（for）

   • 条件必须满足的最短时间，超过该时间才会触发告警。

4. 标签（labels）

   • 为告警添加额外的标签，便于在Alertmanager中路由和分组。

5. 注释（annotations）

   • 为告警添加额外的信息，通常包括摘要和描述，便于通知和显示。

创建简单告警规则

1. 定义告警规则

   • 创建一个名为alerts.yml的文件，定义告警规则。

     groups:
       - name: example
         rules:
           - alert: HighCPUUsage
             expr: avg(rate(node_cpu_seconds_total{mode!="idle"}[1m])) by (instance) > 0.8
             for: 5m
             labels:
               severity: warning
             annotations:
               summary: "High CPU usage detected on instance {{ $labels.instance }}"
               description: "CPU usage has been above 80% for more than 5 minutes."
     

2. 加载告警规则

   • 在Prometheus的主配置文件prometheus.yml中引用告警规则文件。

     rule_files:
       - "alerts.yml"
     

3. 重启Prometheus

   • 使配置生效，需要重启Prometheus服务。

     sudo systemctl restart prometheus

复杂告警规则示例

1. 多条件告警

   • 定义一个告警规则，当内存使用率和CPU使用率都超过阈值时触发告警。

     groups:
       - name: complex
         rules:
           - alert: HighResourceUsage
             expr: (avg(rate(node_cpu_seconds_total{mode!="idle"}[1m])) by (instance) > 0.8) and (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes < 0.2)
             for: 5m
             labels:
               severity: critical
             annotations:
               summary: "High resource usage detected on instance {{ $labels.instance }}"
               description: "CPU usage > 80% and memory available < 20% for more than 5 minutes."
     

2. 基于百分位数的告警

   • 定义一个告警规则，当HTTP请求延迟超过某个百分位数时触发告警。

     groups:
       - name: latency
         rules:
           - alert: HighRequestLatency
             expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m])) > 1
             for: 10m
             labels:
               severity: warning
             annotations:
               summary: "High HTTP request latency detected"
               description: "99th percentile HTTP request latency has been above 1 second for more than 10 minutes."
     

3. 结合多个指标的告警

   • 定义一个告警规则，当磁盘使用率和inode使用率都超过阈值时触发告警。

     groups:
       - name: disk
         rules:
           - alert: DiskSpaceAndInodeUsage
             expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} < 0.1) and (node_filesystem_files_free{mountpoint="/"} / node_filesystem_files{mountpoint="/"} < 0.1)
             for: 15m
             labels:
               severity: critical
             annotations:
               summary: "Low disk space and inode availability on {{ $labels.instance }}"
               description: "Less than 10% disk space and inodes available on {{ $labels.instance }} for more than 15 minutes."
     

告警规则总结

• 基础告警：通过简单的条件表达式设置基础告警，如CPU、内存使用率等。
• 复杂告警：结合多个条件或使用高级PromQL函数进行复杂告警设置，如结合多个指标、基于百分位数等。
• 标签和注释：使用标签便于Alertmanager路由和分组，使用注释提供详细告警信息便于分析和处理。

通过合理配置告警规则，可以帮助及时发现系统中的异常情况，确保系统的稳定性和可靠性。

Alertmanager配置

Alertmanager是Prometheus生态系统中的一部分，用于处理Prometheus发出的告警。它可以对告警进行分组、抑制、去重，并将告警路由到不同的接收渠道，如Email、Slack、Webhook等。以下是详细讲解安装和配置Alertmanager、配置告警接收渠道以及管理和抑制告警。

安装和配置Alertmanager

1. 安装Alertmanager

   • 下载并解压

     wget https://github.com/prometheus/alertmanager/releases/download/v<version>/alertmanager-<version>.linux-amd64.tar.gz
     tar -xvf alertmanager-<version>.linux-amd64.tar.gz
     cd alertmanager-<version>.linux-amd64
     

   • 运行Alertmanager

     ./alertmanager --config.file=alertmanager.yml &

2. 配置Alertmanager

   • 创建配置文件
     • 在Alertmanager目录下创建一个名为alertmanager.yml的配置文件。

     global:
       resolve_timeout: 5m
      
     route:
       receiver: 'default-receiver'
      
     receivers:
       - name: 'default-receiver'
         email_configs:
           - to: 'your-email@example.com'
             from: 'alertmanager@example.com'
             smarthost: 'smtp.example.com:587'
             auth_username: 'username'
             auth_password: 'password'
             auth_identity: 'username'
     

3. 将Alertmanager集成到Prometheus

   • 在Prometheus的配置文件prometheus.yml中添加Alertmanager的配置。

     alerting:
       alertmanagers:
         - static_configs:
             - targets:
                 - 'localhost:9093'
     

   • 重新启动Prometheus以应用配置。

     sudo systemctl restart prometheus

配置告警接收渠道（Email、Slack、Webhook等）

Alertmanager支持多种告警接收渠道，可以根据需要配置不同的接收方式。

1. Email配置

   • 在alertmanager.yml中配置Email接收器。

     receivers:
       - name: 'email-receiver'
         email_configs:
           - to: 'your-email@example.com'
             from: 'alertmanager@example.com'
             smarthost: 'smtp.example.com:587'
             auth_username: 'username'
             auth_password: 'password'
             auth_identity: 'username'
     

2. Slack配置

   • 创建Slack Webhook URL，并在alertmanager.yml中配置Slack接收器。

     receivers:
       - name: 'slack-receiver'
         slack_configs:
           - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
             channel: '#alerts'
             send_resolved: true
     

3. Webhook配置

   • 在alertmanager.yml中配置Webhook接收器，将告警信息发送到指定的Webhook URL。

     receivers:
       - name: 'webhook-receiver'
         webhook_configs:
           - url: 'http://example.com/alert'
             send_resolved: true
     

4. 多接收器配置

   • 可以为不同的告警配置不同的接收器，通过路由规则进行分配。

     route:
       receiver: 'default-receiver'
       routes:
         - match:
             severity: 'critical'
           receiver: 'slack-receiver'
         - match:
             severity: 'warning'
           receiver: 'email-receiver'
      
     receivers:
       - name: 'default-receiver'
       - name: 'email-receiver'
         email_configs:
           - to: 'your-email@example.com'
       - name: 'slack-receiver'
         slack_configs:
           - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
     

管理和抑制告警

1. 告警分组

   • 告警分组用于将相似的告警合并在一起，减少通知的冗余。

     route:
       group_by: ['alertname', 'severity']
       group_wait: 30s
       group_interval: 5m
       repeat_interval: 3h
       receiver: 'default-receiver'
     

2. 告警抑制

   • 告警抑制用于在某些条件下抑制告警，例如当某个告警已经触发时，抑制相关告警。

     inhibit_rules:
       - source_match:
           severity: 'critical'
         target_match:
           severity: 'warning'
         equal: ['alertname', 'instance']
     

3. 静默（Silence）

   • 静默功能允许在特定时间段内抑制某些告警，可以通过Alertmanager的Web界面进行设置。
   • 访问Alertmanager的Web界面：

     http://<Alertmanager-server-ip>:9093

   • 在静默页面中添加静默规则，设置静默的标签、持续时间和原因。

综合示例

以下是一个综合示例，展示如何配置多种接收器、分组和抑制规则。

global:
  resolve_timeout: 5m
 
route:
  group_by: ['alertname', 'severity']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 3h
  receiver: 'default-receiver'
  routes:
    - match:
        severity: 'critical'
      receiver: 'slack-receiver'
    - match:
        severity: 'warning'
      receiver: 'email-receiver'
 
receivers:
  - name: 'default-receiver'
    webhook_configs:
      - url: 'http://example.com/alert'
  - name: 'email-receiver'
    email_configs:
      - to: 'your-email@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'username'
        auth_password: 'password'
  - name: 'slack-receiver'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
        channel: '#alerts'
        send_resolved: true
 
inhibit_rules:
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['alertname', 'instance']

通过合理配置Alertmanager，可以高效地管理和处理Prometheus发出的告警，确保及时响应和处理系统异常，保持系统的稳定性和可靠性。