容器化部署Prometheus普罗米修斯

陌殇殇殇2026-04-25 18:41

1. Monitor介绍

（1）架构图
（2）Prometheus Server

介绍：

Prometheus Server 是整个监控系统的核心，它负责从各个被监控的目标（targets）中以 pull（拉取）的方式收集时序数据。数据通常采用 HTTP 协议的 REST API 格式暴露，Prometheus 通过配置抓取间隔（scrape interval）定期请求这些数据，并将采集到的数据存储到本地时间序列数据库中。默认端口为 9090。

工作原理：

  • 抓取数据： Prometheus 根据配置文件中定义的目标地址，周期性地向目标发送 HTTP 请求以采集指标数据。
  • 数据存储： 采集到的数据以时间序列的形式存储到本地存储中，支持高效的时序数据存储和查询。
  • 查询语言： 提供强大的 PromQL（Prometheus Query Language），方便用户通过查询语言对数据进行实时分析、聚合和告警判断。
  • 告警规则： 用户可以在配置文件中定义告警规则，当数据满足特定条件时，Prometheus 会生成告警信息并发送到 Alertmanager。
（3）NodeExporter

介绍：

NodeExporter 是一个运行在被监控主机上的小型守护进程，专门用于收集操作系统及硬件相关指标，如 CPU 使用率、内存使用、磁盘 I/O、网络流量等。其默认暴露的端口为 9100。

工作原理：

  • 数据导出： NodeExporter 定期采集主机的各项硬件和系统指标，并通过 HTTP 接口以预定格式暴露这些数据。
  • 无状态设计： 该组件主要负责数据采集，不涉及数据存储和复杂计算。
  • 与 Prometheus 的配合： Prometheus Server 按照预先配置的抓取规则，通过 HTTP 请求获取 NodeExporter 导出的指标数据。
（4）cAdvisor

介绍：

cAdvisor（Container Advisor）主要用于监控运行在主机上的容器。它可以实时收集容器的资源使用情况、性能指标以及运行状态等信息，并通过 HTTP 接口提供这些数据。默认端口为 8080。

工作原理：

  • 容器监控： cAdvisor 定期收集每个容器的 CPU、内存、网络和磁盘等资源使用数据，同时记录容器的生命周期信息。
  • 数据展示： 除了暴露数据接口供 Prometheus 抓取外，cAdvisor 也提供一个基本的 Web UI 来直观展示容器的实时状态。
  • 与 Prometheus 的配合： Prometheus Server 可根据配置抓取 cAdvisor 提供的接口数据，从而将容器级别的监控数据纳入到整体监控系统中。
（5）Grafana

介绍：

Grafana 是一款功能强大的开源数据可视化和仪表盘展示工具。它并不直接负责数据采集，而是通过连接到 Prometheus Server（或其他数据源）来查询数据并进行图形化展示。默认端口为 3000。

工作原理：

  • 数据查询： Grafana 利用 PromQL（或其他查询语言）从 Prometheus 中查询数据。
  • 可视化配置： 用户可以使用 Grafana 提供的各种图表、表格和仪表盘模板来自定义数据展示方式。
  • 实时监控： Grafana 支持实时刷新数据，为运维人员提供直观的监控界面，从而及时了解系统运行状况。
（6）Alertmanager

介绍：

Alertmanager 负责管理和处理 Prometheus Server 发送过来的告警信息。它的主要任务是对告警进行去重、分组、抑制以及路由，将经过处理的告警信息通过邮件、短信、IM 等方式发送给最终的接收人。

工作原理：

  • 告警接收： 当 Prometheus 根据告警规则检测到异常状态时，会将告警信息发送到 Alertmanager。
  • 告警处理： Alertmanager 对收到的告警信息进行分组（根据告警标签）、去重和抑制等处理，避免相同问题产生大量重复告警。
  • 告警路由： 根据预先配置的路由规则，将处理后的告警转发到不同的通知渠道，如邮件、Slack、微信等，确保相关人员能及时收到警报信息。
（7）整体工作流程
  1. 数据采集阶段：
    • Prometheus Server 根据配置定期向各个被监控目标发起 HTTP 抓取请求。
    • NodeExporter 提供主机级的系统和硬件数据；
    • cAdvisor 提供容器级的运行状态和资源使用数据。
  2. 数据存储与查询阶段：
    • 采集到的数据被 Prometheus 存储在其时序数据库中。
    • 用户或 Grafana 可以使用 PromQL 对数据进行查询、聚合和分析。
  3. 告警生成与处理阶段：
    • 基于定义好的告警规则，Prometheus 对采集到的数据进行监控和评估。
    • 当检测到异常时，Prometheus 生成告警信息并发送到 Alertmanager。
  4. 告警通知阶段：
    • Alertmanager 对告警信息进行分组、去重和路由，然后将最终的告警通知发送给预先定义的接收人（例如运维人员）。
  5. 数据展示阶段：
    • Grafana 通过与 Prometheus 连接，实时查询监控数据并将数据以图表、仪表盘等形式展示出来，方便用户直观地了解系统运行情况。

2. 容器化部署Node-Exporter

编写 Dockerfile 文件构建exporter镜像，要求基于centos完成Node-Exporter服务的安装与配置,并设置服务开机自启。

(需要的包在Technology_packageV1.0.iso 中 Monitor.tar.gz.）

（1） 基础镜像:centos:centos7.9.2009

（2） 使用二进制包 node_exporter-0.18.1.linux-amd64.tar.gz 安装node-exporter 服务

（3） 声明端口:9100

（4） 设置服务开机自启

请使用docker build命令进行构建镜像并使用 docker run命令运行该容器

将 docker run -d --name exporter-test monitor-exporter:v1.0 && sleep 5 &&docker exec exporter-test ps -aux && docker rm -f exporter-test 命令的返回结果提交到答题框

（1）基础环境准备
python 复制代码 
[root@k8s-master ~]# tar -zxvf Monitor.tar.gz
[root@k8s-master ~]# cd Monitor/
[root@k8s-master ~]# for i in `ls *.tar.gz`; do tar xf $i; done
[root@k8s-master Monitor]# docker load -i CentOS_7.9.2009.tar
Loaded image: centos:centos7.9.2009
（2）编写Node启动脚本
python 复制代码 
[root@k8s-master Monitor]# vim exporter.sh
#!/bin/bash
./node_exporter
（3）编写Dockerfile文件
dockerfile 复制代码 
[root@k8s-master Monitor]# vim Dockerfile-exporter
FROM centos:centos7.9.2009
MAINTAINER gxl 1902038408@qq.com
ADD node_exporter-0.18.1.linux-amd64.tar.gz /opt
RUN mv /opt/node_exporter-0.18.1.linux-amd64 /opt/node_exporter
COPY exporter.sh /opt/node_exporter
WORKDIR /opt/node_exporter
EXPOSE 9100
CMD ["/bin/bash","/opt/node_exporter/exporter.sh"]
（4）构建镜像
python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-exporter -t monitor-exporter:v1.0 .
（5）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# docker run -d --name exporter-test monitor-exporter:v1.0 && sleep 5 && docker exec exporter-test ps -aux && docker rm -f exporter-test
ab85e33ffc7d8c565e38a0bf3c69eb8926e99478ac5726f2526c5fa75984e0ae
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.2  0.0  11688  1324 ?        Ss   06:41   0:00 /bin/bash /data/node_exporter/exporter.sh
root          7  0.0  0.1 113420  4984 ?        Sl   06:41   0:00 ./node_exporter
root         11  0.0  0.0  51732  1700 ?        Rs   06:41   0:00 ps -aux
exporter-test

3. 容器化部署Alertmanager

编写Dockerfile 文件构建alert镜像,要求基于centos: latest元放 Alertmanage服务的安装与配置，并设置服务开机自启。

(需要的包在Technology_packageV1.0.iso 中 Monitor.tar.gz.）

（1）基础镜像:centos:centos7.9.2009

（2）使用提供的二进制包 alertmanager-0.19.0.linux-amd64.tar.gz 安装 Alertmanage服务

（3）声明端口:9093、9094

（4）设置服务开机自启

请使用docker build命令进行构建镜像并使用 docker run命令运行该容器

将 docker run -d --name alert-test monitor-alert:v1.0 && sleep 5 && docker exec alert-test ps -aux && docker rm -f alert-test 命令的返回结果提交到答题框

（1）编写Alert启动脚本
python 复制代码 
[root@k8s-master Monitor]# vim alert.sh
#!/bin/bash
./alertmanager --config.file="alertmanager.yml"
（2）配置告警规则

复制 smtp 模块内容

python 复制代码 
[root@k8s-master Monitor]# cat alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m
  smtp_smarthost: '114463512@.163.com:465'
  smtp_from: 'alert@163.com'
  smtp_auth_username: '114463512@163.com'
  smtp_auth_password: 'flwlf[a;'
  smtp_require_tls: false

route:
  receiver: 'default'
  group_wait: 10s
  group_interval: 1m
  repeat_interval: 1h
  group_by: ['alertname']

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

将 smtp 配置复制到源文件中

python 复制代码 
[root@k8s-master Monitor]# tar -zxvf alertmanager-0.19.0.linux-amd64.tar.gz
[root@k8s-master Monitor]# vim alertmanager-0.19.0.linux-amd64/alertmanager.yml
### (把刚刚复制的粘贴到下面的位置)
global:
  resolve_timeout: 5m                      # 解决告警的超时时间，若告警在此时间内未解决，将会自动清除告警状态
  smtp_smarthost: '114463512@.163.com:465' # 发送邮件时的SMTP服务器地址及端口，这里使用了网易邮箱的465端口（SSL）
  smtp_from: 'alert@163.com'               # 告警邮件的发件人地址
  smtp_auth_username: '114463512@163.com'  # SMTP认证的用户名，即发送邮件的邮箱地址
  smtp_auth_password: 'flwlf[a;'           # SMTP认证的密码或授权码，用于验证邮箱身份
  smtp_require_tls: false                  # 是否要求TLS连接，这里设为false表示不使用TLS连接

route:
  group_by: ['alertname']                  # 告警分组方式，将具有相同alertname的告警分为一组
  group_wait: 10s                          # 初始等待时间，表示当新告警产生后，等待10秒再发送，便于将短时间内触发的告警合并
  group_interval: 10s                      # 告警组间隔时间，在发送告警组后，等待10秒以接收新告警并合并后再发送
  repeat_interval: 1h                      # 重复告警间隔时间，若告警持续未解决，则每1小时重复发送一次通知
  receiver: 'web.hook'                     # 默认接收器名称，这里设置为 'web.hook'（在下面定义）

receivers:
- name: 'web.hook'                         # 接收器名称定义
  webhook_configs:
  - url: 'http://127.0.0.1:5001/'          # Webhook配置，指定告警通知将发送至的URL地址，此处为本地服务器的端口5001

inhibit_rules:
  - source_match:
      severity: 'critical'                 # 触发抑制规则的源告警条件，severity为critical
    target_match:
      severity: 'warning'                  # 被抑制的目标告警条件，severity为warning
    equal: ['alertname', 'dev', 'instance'] # 抑制规则生效的条件，即source和target告警的alertname、dev、instance必须相同
（3）编写Dockerfile文件
dockerfile 复制代码 
[root@k8s-master Monitor]# vim Dockerfile-alert
FROM centos:centos7.9.2009
MAINTAINER gxl 1902038408@qq.com
ADD alertmanager-0.19.0.linux-amd64.tar.gz /opt/
RUN mv /opt/alertmanager-0.19.0.linux-amd64/ /opt/alertmanager
COPY alertmanager-0.19.0.linux-amd64/alertmanager.yml /opt/alertmanager
COPY alert.sh /opt/alertmanager
WORKDIR /opt/alertmanager
EXPOSE 9093 9094
CMD ["/bin/bash","/opt/alertmanager/alert.sh"]
（4）构建镜像
python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-alert -t monitor-alert:v1.0 .
（5）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# docker run -d --name alert-test monitor-alert:v1.0 && sleep 5 && docker exec alert-test ps -aux && docker rm -f alert-test2a0c07eb71795c516b3f1aafa5236b73a1ed3c6681f8b757212a9d84905f8421
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.2  0.0  11688  1336 ?        Ss   07:01   0:00 /bin/bash /opt/alertmanager/alert.sh
root          7  1.0  0.4 123152 19324 ?        Sl   07:01   0:00 ./alertmanager --config.file=alertmanager.yml
root         16  0.0  0.0  51732  1696 ?        Rs   07:01   0:00 ps -aux
alert-test

4. 容器化部署Grafana

编写 Dockerfile 文件构建grafana镜像,要求基于centos完成Grafana服务的安装与配置,并设置服务开机自启。

(需要的包在 Technology_packageV1.0.iso中Monitor.tar.gz)

（1）基础镜像:centos:centos7.9.2009

（2）使用提供的二进制包 grafana-6.4.1.linux-amd64.tar.gz 安装grafana服务

（3）声明端口:3000

（4）设置Grafana服务开机自启

请使用 docker build命令进行构建镜像并使用 docker run命令运行该容器

将 docker run -d --name grafana-test monitor-grafana:v1.0 && sleep 5 && docker exec grafana-test ps -aux && docker rm -f grafana-test 命令命令

（1）编写Grafana启动脚本
python 复制代码 
[root@k8s-master Monitor]# vim grafana.sh
#!/bin/bash
./grafana-server
（2）编写Dockerfile文件
dockerfile 复制代码 
[root@k8s-master Monitor]# cat Dockerfile-grafana
FROM centos:centos7.9.2009
MAINTAINER gxl 1902038408@qq.com
ADD grafana-6.4.1.linux-amd64.tar.gz /opt
RUN mv /opt/grafana-6.4.1 /opt/grafana
COPY grafana.sh /opt/grafana/bin/
WORKDIR /opt/grafana/bin/
EXPOSE 3000
CMD ["/bin/bash","/opt/grafana/bin/grafana.sh"]
（3）构建镜像
python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-grafana -t monitor-grafana:v1.0 .
（4）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# docker run -d --name grafana-test monitor-grafana:v1.0 && sleep 5 && docker exec grafana-test ps -aux && docker rm -f grafana-test
766680b483665e911df2280033e5668bf2dc623c4a369db81d579e26fdf7550c
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.2  0.0  11688  1320 ?        Ss   07:13   0:00 /bin/bash grafana.sh
root          7  3.6  0.7 414912 28344 ?        Sl   07:13   0:00 ./grafana-server
root         16  0.0  0.0  51732  1700 ?        Rs   07:13   0:00 ps -aux
grafana-test

5. 容器化部署Prometheus

编写 Dockerfile文件构建 prometheus 镜像,要求基于centos完成 Promethues服务的安装与配置,并设置服务开机自启。

(需要的包在Technology _packageV1.0.iso中 Monitor.tar. gz)

（1）基础镜像:centos:centos7.9.2009;

（2）使用提供的二进制包 prometheus-2.13.0.linux-amd64.tar.gz 安装promethues服务;

（3）编写prometheus.yml文件,创建3个任务模板:prometheus、node和alertmanager，并将该文件铂贝到/data/prometheus/目录下;

（4）声明端口:9090;

（5）设置服务开机自启

请使用docker build命令进行构建镜像并使用 docker run命令运行该容器。

将 docker run -d --name prometheus-test monitor-prometheus:v1.0 && sleep 5 && docker exec prometheus-test ps -aux && docker rm -f prometheus-test 命令的返回结果提交到答题框

（1）编写Prometheus启动脚本
python 复制代码 
[root@k8s-master Monitor]# vim prometheus.sh
#!/bin/bash
./prometheus --config.file="prometheus.yml"
（2）配置Prometheus主文件
python 复制代码 
[root@k8s-master Monitor]# vim prometheus-2.13.0.linux-amd64/prometheus.yml
# my global config                             # 我的全局配置（全局配置项）
global:                                        # 全局配置块，用于设置全局参数
  scrape_interval:     15s                     # 指定抓取数据（scrape）的间隔为15秒（默认为1分钟）
  evaluation_interval: 15s                     # 指定规则评估（evaluation）的间隔为15秒（默认1分钟）
  # scrape_timeout is set to the global default (10s).     # 抓取超时未显式设置，使用全局默认值（10秒）

# Alertmanager configuration                   # Alertmanager 告警管理器的配置
alerting:                                      # alerting 节点用于配置如何联动 Alertmanager
  alertmanagers:                               # 指定一组 Alertmanager 实例
  - static_configs:                            # 使用静态配置方式指定 Alertmanager 目标
    - targets:                                 # 列出要联动的 Alertmanager 的地址
      - monitor-alertmanager:9093              # 目标 Alertmanager 地址为 monitor-alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.  
# 根据全局 evaluation_interval 的设置，加载规则并定期评估它们
rule_files:                                    # 指定 Prometheus 需要加载的告警规则文件
  - "*rules.yml"                               # 加载当前目录下所有符合 *rules.yml 模式的规则文件
  # - "second_rules.yml"                       # 也可以加载其它规则文件，此行被注释掉表示暂不加载

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.                 # 配置数据抓取，下面配置包含了多个被监控目标；第一组为 Prometheus 自身
scrape_configs:                                # scrape_configs 用于定义抓取目标及相关配置
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  # 各抓取任务会自动为抓取到的时间序列加上标签 job=<job_name>
  - job_name: 'prometheus'                     # 定义抓取任务名称为 'prometheus'
    # metrics_path defaults to '/metrics'      # 提示：metrics_path 默认为 '/metrics'
    # scheme defaults to 'http'.               # 提示：通信协议 scheme 默认为 'http'
    static_configs:                            # 静态配置块，指定抓取目标
    - targets: ['monitor-prometheus:9090']     # 指定抓取目标为 monitor-prometheus:9090

  - job_name: ''                               # 定义抓取任务，但此处 job_name 设为空字符串
    static_configs:                            # 静态配置块
    - targets: ['monitor-node:9100']           # 指定抓取目标为 monitor-node:9100（一般用于监控节点 exporter，如 node_exporter）

  - job_name: 'monitor-alertmanager'           # 定义抓取任务名称为 'monitor-alertmanager'
    static_configs:                            # 静态配置块
    - targets: ['monitor-alertmanager:9093']   # 指定抓取目标为 monitor-alertmanager:9093

  - job_name: 'monitor-grafana'                # 定义抓取任务名称为 'monitor-grafana'
    static_configs:                            # 静态配置块
    - targets: ['monitor-grafana:3000']        # 指定抓取目标为 monitor-grafana:3000
（3）配置Docker告警规则
yaml 复制代码 
[root@k8s-master Monitor]# vim docker-rules.yml
groups:
- name: node-up
  rules:
  - alert: node-up
    expr: up{job="cadvisor"} == 0
    for: 30s
    labels:
      severity: critical
      team: node
    annotations:
      summary: "{{ $labels.instance }} 已停止运行超过 30s！"

- name: Docker的告警规则
  rules:
  - alert: 容器CPU利用率高
    expr: sum(rate(container_cpu_usage_seconds_total{name!=""}[5m])) by (instance,name) * 100 > 70
    for: 3m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}CPU利用率高"
      description: "容器{{ $labels.name }}的CPU利用率当前为{{ $value | printf \"%.2f\" }}%，超过了70%的阈值。"

  - alert: 容器内存利用率高
    expr: |
      sum(container_memory_working_set_bytes{name!=""}) by (instance,name) /
      sum(container_spec_memory_limit_bytes{name!=""} unless on(instance, name) (container_spec_memory_limit_bytes{name!=""} == 0)) by (instance,name) * 100 > 70  # 阈值调整为70%
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}内存利用率高"
      description: "容器{{ $labels.name }}的内存使用率已达{{ $value | printf \"%.2f\" }}%，超过限制的70%。"

  - alert: 容器整体内存利用率高
    expr: sum(container_memory_working_set_bytes{name!=""}) / sum(machine_memory_bytes) * 100 > 70
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "所有容器的总内存利用率高"
      description: "当前所有容器占用物理内存的总量为{{ $value | printf \"%.2f\" }}%，超过了物理内存的70%阈值。"

  - alert: 容器网络发送速率过高
    expr: sum(rate(container_network_transmit_bytes_total{name!=""}[5m])) by (instance,job,name) * 8 / 1024 / 1024 > 100
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}网络发送速率过高"
      description: "容器{{ $labels.name }}的网络发送速率达到{{ $value | printf \"%.2f\" }}Mbps，超过100Mbps阈值。"

  - alert: 容器网络接收速率过高
    expr: sum(rate(container_network_receive_bytes_total{name!=""}[5m])) by (instance,job,name) * 8 / 1024 / 1024 > 100
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}网络接收速率过高"
      description: "容器{{ $labels.name }}的网络接收速率达到{{ $value | printf \"%.2f\" }}Mbps，超过100Mbps阈值。"

  - alert: 容器停止时间过长
    expr: time() - container_last_seen{name!=""} > 120
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}已停止"
      description: "容器{{ $labels.name }}已停止运行超过120秒。当前停止时长{{ $value | printf \"%.0f\" }}秒。"

  - alert: 容器文件系统使用率高
    expr: (container_fs_usage_bytes{name!="",device!~"tmpfs|shm"} / container_fs_limit_bytes{name!="",device!~"tmpfs|shm"}) * 100 > 70
    for: 15m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}文件系统使用率过高"
      description: "容器{{ $labels.name }}的文件系统({{ $labels.device }})使用率已达{{ $value | printf \"%.2f\" }}%，超过70%阈值。"

  - alert: 容器磁盘读取IO过高
    expr: rate(container_fs_reads_total{name!=""}[10m]) > 1500
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}磁盘读取IOPS过高"
      description: "容器{{ $labels.name }}的磁盘读取IOPS为{{ $value | printf \"%.0f\" }}/s，超过1500次/秒的阈值。"

  - alert: 容器磁盘写入IO过高
    expr: rate(container_fs_writes_total{name!=""}[10m]) > 1500
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}磁盘写入IOPS过高"
      description: "容器{{ $labels.name }}的磁盘写入IOPS为{{ $value | printf \"%.0f\" }}/s，超过1500次/秒的阈值。"

  - alert: 容器网络接收错误率高
    expr: rate(container_network_receive_errors_total{name!=""}[10m]) > 20
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}网络接收错误率过高"
      description: "容器{{ $labels.name }}的网络接收错误率为{{ $value | printf \"%.2f\" }}/s，超过20 errors/s阈值。"

  - alert: 容器网络发送错误率高
    expr: rate(container_network_transmit_errors_total{name!=""}[10m]) > 20
    for: 8m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}网络发送错误率过高"
      description: "容器{{ $labels.name }}的网络发送错误率为{{ $value | printf \"%.2f\" }}/s，超过20 errors/s阈值。"

  - alert: 容器频繁重启
    expr: increase(container_restarts{name!=""}[2h]) > 10
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}频繁重启"
      description: "容器{{ $labels.name }}在过去2小时内重启了{{ $value | printf \"%.0f\" }}次，超过10次阈值。"

  - alert: 容器非运行状态
    expr: container_state{name!="", state!="running"} == 1
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}处于{{ $labels.state }}状态"
      description: "容器{{ $labels.name }}处于{{ $labels.state }}状态超过10分钟。"

  - alert: 容器磁盘空间即将耗尽
    expr: (container_fs_limit_bytes{name!="",device!~"tmpfs|shm"} - container_fs_usage_bytes{name!="",device!~"tmpfs|shm"}) / 1024 / 1024 < 500  # 磁盘空间阈值（500MB），保持不变
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }}磁盘剩余空间不足"
      description: "容器{{ $labels.name }}磁盘({{ $labels.device }})可用空间小于500MB（当前约{{ $value | printf \"%.0f\" }}MB），请及时清理或扩容。"

  - alert: 容器inode使用率高
    expr: (container_fs_inodes_usage{name!="",device!~"tmpfs|shm"} / container_fs_inodes_total{name!="",device!~"tmpfs|shm"}) * 100 > 70  # 阈值调整为70%
    for: 15m
    labels:
      severity: warning
    annotations:
      summary: "实例{{ $labels.instance }}的容器{{ $labels.name }} inode 使用率高"
      description: "容器{{ $labels.name }}的 inode 使用率为 {{ $value | printf \"%.2f\" }}%，可能会导致无法新建文件。"
（4）编写Dockerfile文件
dockerfile 复制代码 
[root@k8s-master Monitor]# vim Dockerfile-alert
FROM centos:centos7.9.2009
MAINTAINER gxl 1902038408@qq.com
ADD prometheus-2.13.0.linux-amd64.tar.gz /opt
COPY prometheus.sh /opt/prometheus-2.13.0.linux-amd64
COPY alert-rules.yml /opt/prometheus-2.13.0.linux-amd64
COPY docker-rules.yml /opt/prometheus-2.13.0.linux-amd64
COPY prometheus-2.13.0.linux-amd64/prometheus.yml /opt/prometheus-2.13.0.linux-amd64
WORKDIR /opt/prometheus-2.13.0.linux-amd64
EXPOSE 9090
CMD ["/bin/bash","/opt/prometheus-2.13.0.linux-amd64/prometheus.sh"]
（5）构建镜像
python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-prometheus -t monitor-prometheus:v1.0 .
（6）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# docker run -d --name prometheus-test monitor-prometheus:v1.0 && sleep 5 && docker exec prometheus-test ps -aux && docker rm -f prometheus-test 
25693d3635a1b93a8058b9e270594573328f50872996619ff8dbe0a6ba9bfe1d
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  2.8  0.0  11688  1332 ?        Ss   11:50   0:00 /bin/bash /opt/prometheus-2.13.0.linux-amd64/prometheus.sh
root          7  4.5  0.2 161028 35060 ?        Sl   11:50   0:00 ./prometheus --config.file=prometheus.yml
root         20  5.0  0.0  51732  1704 ?        Rs   11:50   0:00 ps -aux
prometheus-test

6. 编排部署监控系统

编写docker-compose.yaml 文件,使用镜像exporter、alert、grafana和prometheus完成监控系统的编排部署。(需要的包在 Technology_packageV1.0.iso中 Monitor.tar.gz)

（1）容器monitor-node;镜像:monitor-exporter:v1.0;端口映射:9100:9100

（2）容器monitor-alertmanager;镜像:monitor-alert:v1.0;端口映射:9093:9093、9094:9094

（3）容器 monitor-grafana;镜像:monitor-grafana:v1.0;端口映射:3000:3000

（4）容器monitor-prometheus;镜像:monitor-prometheus:v1.0;端口映射: 9090:9090

使用docker-compose ps 命令进行查看，将返回结果提交至答题框

将 curl -L http://$(hostname -i):9090/targets | grep up 命令的返回结果提交到答题框

（1）编写docker-compose文件
yaml 复制代码 
[root@k8s-master Monitor]# vim docker-compose.yaml
version: "3"
services:
  monitor-node:
    container_name: monitor-node
    image: monitor-exporter:v1.0
    ports:
    - 9100:9100
    restart: always

  monitor-alertmanager:
    container_name: monitor-alertmanager
    image: monitor-alert:v1.0
    depends_on:
    - monitor-node
    ports:
    - 9093:9093
    expose:
    - 9094
    restart: always

  monitor-grafana:
    container_name: monitor-grafana
    image: monitor-grafana:v1.0
    depends_on:
    - monitor-node
    - monitor-alertmanager
    ports:
    - 3000:3000
    restart: always

  monitor-prometheus:
    container_name: monitor-prometheus
    image: monitor-prometheus:v1.0
    depends_on:
    - monitor-node
    - monitor-alertmanager
    - monitor-grafana
    ports:
    - 9090:9090
    restart: always
（2）启动服务
python 复制代码 
[root@k8s-master Monitor]# docker-compose up -d
Creating network "monitor_default" with the default driver
Creating monitor-cadvisor ... done
Creating monitor-node     ... done
Creating monitor-alertmanager ... done
Creating monitor-grafana      ... done
Creating monitor-prometheus   ... done
（3）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# curl -L http://$(hostname -i):9090/targets | grep up
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 10958    0 10958    0     0  1600k      0 --:--:-- --:--:-- --:--:-- 1783k
                            <a href="#" class="nav-link dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Status <span class="caret"></span></a>
    <div id="showTargets" class="btn-group btn-group-toggle" data-toggle="buttons">
        <a id="job-monitor-alertmanager" href="#job-monitor-alertmanager">monitor-alertmanager (1/1 up)</a>
              <span class="alert alert-success state_indicator text-uppercase">up</span>
        <a id="job-monitor-grafana" href="#job-monitor-grafana">monitor-grafana (1/1 up)</a>
              <span class="alert alert-success state_indicator text-uppercase">up</span>
        <a id="job-monitor-node" href="#job-monitor-node">monitor-node (1/1 up)</a>
              <span class="alert alert-success state_indicator text-uppercase">up</span>
        <a id="job-monitor-prometheus" href="#job-monitor-prometheus">monitor-prometheus (1/1 up)</a>
              <span class="alert alert-success state_indicator text-uppercase">up</span>

7. 设置Prometheus为Grafana的数据源

完成后编排部署监控系统，将Prometheus设置为Grafana的数据源，并命名为Prometheus

在浏览器上通过http://IP:9090/targets访问Prometheus监控指标界面，如图所示：

在浏览器上通过http://IP:3000访问Grafana，如图所示：

登录（admin/admin）Grafana，如图所示：

切换到数据源界面，如图所示：

点击Add data source添加数据源，如图所示：

数据源选择Prometheus，如图所示：

点击Save&Test测试数据源连通性，如图所示：

点击Dashboards，选择Prometheus2.0 Stats，如图所示：

切换到解控看板界面，如图所示：

8. 容器化部署Cadvisor

编写 Dockerfile文件构建 prometheus 镜像,要求基于centos完成 Promethues 服务的安装与配置,并设置服务开机自启。

(需要的包在Technology _packageV1.0.iso中 Monitor.tar. gz)

（1）基础镜像:centos:centos7.9.2009;

（2）使用提供的二进制包 cadvisor_v0.37.5 安装cadvisor服务;

（3）声明端口:8080;

（4）设置服务开机自启

请使用docker build命令进行构建镜像并使用 docker run命令运行该容器。

将 docker run -d --name cadvisor-test monitor-cadvisor:v1.0 && sleep 5 && docker exec cadvisor-test ps -aux && docker rm -f cadvisor-test 命令的返回结果提交到答题框

（1）编写Dockerfile文件
dockerfile 复制代码 
[root@k8s-master Monitor]# vim Dockerfile-cadvisor
FROM centos:centos7.9.2009
MAINTAINER gxl 1902038408@qq.com
COPY cadvisor /usr/bin/cadvisor
RUN chmod +x /usr/bin/cadvisor
EXPOSE 8080
CMD ["/usr/bin/cadvisor", "-logtostderr"]
（2）构建镜像
python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-cadvisor -t monitor-cadvisor:v1.0 .
（3）命令执行结果
python 复制代码 
[root@k8s-master Monitor]# docker run -d --name cadvisor-test monitor-cadvisor:v1.0 && sleep 5 && docker exec cadvisor-test ps -aux && docker rm -f cadvisor-test
02a4cdaf11595a08f63e4e79254df6d9832b6047baafd007f38e21945abf4925
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.5  0.4 938004 17136 ?        Ssl  08:29   0:00 /usr/bin/cadvisor -logtostderr
root         15  0.0  0.0  51732  1696 ?        Rs   08:29   0:00 ps -aux
cadvisor-test
（4）配置Prometheus主文件
python 复制代码 
[root@k8s-master Monitor]# vim prometheus-2.13.0.linux-amd64/prometheus.yml
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      - monitor-alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  - "*rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'monitor-prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
    - targets: ['monitor-prometheus:9090']
  - job_name: 'monitor-node'
    static_configs:
    - targets: ['monitor-node:9100']
  - job_name: 'monitor-alertmanager'
    static_configs:
    - targets: ['monitor-alertmanager:9093']
  - job_name: 'monitor-grafana'
    static_configs:
    - targets: ['monitor-grafana:3000']
  - job_name: 'monitor-cadvisor'
    static_configs:
    - targets: ['monitor-cadvisor:8080']

重新构建Prometheus镜像

python 复制代码 
[root@k8s-master Monitor]# docker build -f Dockerfile-prometheus -t monitor-prometheus:v1.0 .
（5）编写docker-compose文件

添加Cadvisor到docker-compose文件中

python 复制代码 
[root@k8s-master Monitor]# vim docker-compose.yaml
version: "3"
services:
  monitor-node:
    container_name: monitor-node
    image: monitor-exporter:v1.0
    ports:
    - 9100:9100
    restart: always

  monitor-alertmanager:
    container_name: monitor-alertmanager
    image: monitor-alert:v1.0
    depends_on:
    - monitor-node
    ports:
    - 9093:9093
    - 9094:9094
    restart: always

  monitor-grafana:
    container_name: monitor-grafana
    image: monitor-grafana:v1.0
    depends_on:
    - monitor-node
    - monitor-alertmanager
    ports:
    - 3000:3000
    restart: always
    environment:
    - GF_SECURITY_ADMIN_USER=admin
    - GF_SECURITY_ADMIN_PASSWORD=000000

  monitor-prometheus:
    container_name: monitor-prometheus
    image: monitor-prometheus:v1.0
    depends_on:
    - monitor-node
    - monitor-alertmanager
    - monitor-grafana
    ports:
    - 9090:9090
    restart: always

  monitor-cadvisor:
    container_name: monitor-cadvisor
    image: monitor-cadvisor:v1.0
    ports:
    - 8080:8080
    restart: always
    privileged: true
    volumes:
    - /:/rootfs:ro
    - /var/run:/var/run:rw
    - /sys:/sys:ro
    - /var/lib/docker/:/var/lib/docker:ro
    - /dev/disk/:/dev/disk:ro

查看路径

python 复制代码 
# 用于展示容器的层级结构和基本信息。通过访问这个路径，你可以看到所有正在运行的容器的树形结构，并且能获取每个容器的基本信息，例如容器的名称、ID、状态等
http://192.168.100.3:8080/containers/

# 用于展示 Docker 相关的信息。它会提供关于 Docker 守护进程的详细信息，包括 Docker 版本、镜像数量、容器数量等，还能查看 Docker 镜像和容器的统计信息
http://192.168.100.3:8080/docker/

# 用于获取 cAdvisor 收集的所有监控指标数据。这些数据以 Prometheus 兼容的格式呈现，包含了容器和宿主机的各种性能指标，如 CPU 使用率、内存使用率、磁盘 I/O、网络流量等
http://192.168.100.3:8080/metrics

/:/rootfs:ro

  • 含义 ：把宿主机的根目录 / 挂载到容器内的 /rootfs 目录，并且以只读（ro，即 read-only）模式挂载。
  • 用途 ：这一操作允许 cAdvisor 访问宿主机的整个文件系统，进而收集文件系统相关的信息，像磁盘使用情况、文件系统类型等。
  • 注意事项：采用只读模式挂载是为了保证容器无法对宿主机的文件系统进行修改，避免造成安全风险。

/var/run:/var/run:rw

  • 含义 ：将宿主机的 /var/run 目录挂载到容器内的 /var/run 目录，并且以读写（rw，即 read-write）模式挂载。
  • 用途 ：/var/run 目录一般用于存放系统运行时的临时文件和进程信息。通过挂载该目录，cAdvisor 能够访问宿主机上的进程信息和其他运行时数据，从而收集进程相关的监控指标。
  • 注意事项 ：使用读写模式挂载是因为 cAdvisor 可能需要在该目录下创建或修改一些临时文件。

/sys:/sys:ro

  • 含义 ：把宿主机的 /sys 目录挂载到容器内的 /sys 目录，并且以只读模式挂载。
  • 用途 ：/sys 目录是 Linux 内核的虚拟文件系统，用于提供内核数据结构的接口。通过挂载该目录，cAdvisor 可以访问宿主机的内核信息，例如 CPU 信息、内存信息、设备信息等，从而收集系统级别的监控指标。
  • 注意事项：采用只读模式挂载是为了保证容器无法对宿主机的内核信息进行修改，避免影响系统的稳定性。

/var/lib/docker/:/var/lib/docker:ro

  • 含义 ：将宿主机的 /var/lib/docker 目录挂载到容器内的 /var/lib/docker 目录，并且以只读模式挂载。
  • 用途 ：/var/lib/docker 目录是 Docker 的数据存储目录，包含了 Docker 镜像、容器、卷等相关的数据。通过挂载该目录，cAdvisor 能够访问 Docker 的内部数据，从而收集 Docker 容器和镜像的详细信息。
  • 注意事项：使用只读模式挂载是为了保证容器无法对宿主机的 Docker 数据进行修改，避免影响 Docker 的正常运行。

/dev/disk/:/dev/disk:ro

  • 含义 ：将宿主机的 /dev/disk/ 目录以只读（ro）模式挂载到容器内的 /dev/disk/ 目录。

  • 用途 ：/dev/disk/ 包含宿主机的磁盘设备信息（如分区、LVM 卷、磁盘标签等）。

    Cadvisor 通过访问该目录，可获取容器使用的磁盘设备名称、容量、类型等元数据，从而准确关联容器与物理磁盘的监控指标（如 container_fs_usage_bytes）。

  • 注意事项 ：只读模式避免容器修改宿主机的磁盘设备信息，确保系统安全。如果容器需要动态发现新插入的磁盘，需确保宿主机的 /dev/disk/ 目录具有适当的权限。

privileged: true

  • 含义 ：为容器启用特权模式（privileged），允许容器访问宿主机的所有设备并执行特权操作。

  • 用途：绕过容器的安全隔离机制，允许 Cadvisor：

    访问 /dev 下的特殊设备（如 /dev/kmsg、/dev/mem）。

    执行需要内核权限的操作（如读取内核统计信息、挂载文件系统）。

    收集更详细的硬件和内核级监控数据（如 CPU 微架构、PCI 设备信息）。

  • 注意事项：

    安全风险：特权模式可能暴露宿主机敏感信息，建议仅在可信环境中使用。

    替代方案 ：若不需要完全特权，可通过 --device 或 --cap-add 按需授予权限。

    资源影响：特权模式可能增加容器的资源消耗和攻击面。

若能读取内核参数，说明特权模式生效

bash 复制代码 
[root@k8s-master Monitor]# docker exec monitor-cadvisor cat /proc/sys/kernel/hostname
1bf9d6d02a7a

重启docker-compose

python 复制代码 
[root@k8s-master Monitor]# docker-compose restart
Restarting monitor-prometheus            ... done
Restarting monitor-grafana               ... done
Restarting monitor-alertmanager          ... done
Restarting monitor-cadvisor              ... done
Restarting monitor-node                  ... done

点击 Create & Import & 11600 模版，如图所示：

查看Dashboard，如图所示：

（6）测试Docker告警规则
python 复制代码 
[root@k8s-master Monitor]# vim simulate_alerts_alpine.sh
#!/bin/bash
# simulate_alerts_alpine.sh
# 本脚本利用 Alpine 镜像及 Docker 容器批量模拟以下场景，
# 以便测试 Prometheus/Alertmanager 告警规则：
# 1. 高 CPU 占用（无限循环占用 CPU）
# 2. 高内存占用（利用 stress 工具持续分配内存）
# 3. 磁盘空间占用高（不断写入大文件到宿主磁盘挂载目录）
# 4. 高网络流量（循环下载大文件）
# 5. 容器短暂运行后退出（模拟容器停止）
# 6. 容器频繁重启（故意退出让重启策略生效）
# 7. inode 使用率高（不断创建大量小文件）
# 8. 磁盘 IOPS 高（循环写入并删除文件）
#
# 注意：部分测试（例如磁盘和 inode 测试）需要将容器内部目录挂载到宿主实际磁盘上，
# 否则 /tmp 可能为 tmpfs，不会真实占用磁盘空间。
#
# 在开始前请确保 Docker 正在运行！

set -e

# 检查 Docker 是否正在运行
if ! docker info > /dev/null 2>&1; then
  echo "Docker 似乎未启动，请先启动 Docker。"
  exit 1
fi

echo "开始模拟各项测试..."

# 清理函数：检查并停止、删除同名容器
cleanup() {
  name="$1"
  if docker ps -a --format '{{.Names}}' | grep -qw "$name"; then
    echo "清理已存在的容器: $name"
    docker rm -f "$name" > /dev/null 2>&1 || true
  fi
}

# 为磁盘、inode、IOPS 测试准备宿主目录
HOST_DISK_DIR="$HOME/docker_disk_stress"
HOST_INODE_DIR="$HOME/docker_inode_stress"
HOST_IOPS_DIR="$HOME/docker_disk_iops"
for dir in "$HOST_DISK_DIR" "$HOST_INODE_DIR" "$HOST_IOPS_DIR"; do
  if [ ! -d "$dir" ]; then
    echo "创建宿主目录: $dir"
    mkdir -p "$dir"
  fi
done

##########################
# 1. CPU 占用高测试（无限循环占用 CPU）
##########################
echo "[1] 启动 CPU 占用测试容器..."
cleanup cpu_stress
docker run --rm -d --name cpu_stress alpine sh -c "while true; do :; done"

##########################
# 2. 内存占用高测试（利用 stress 工具持续分配内存）
##########################
echo "[2] 启动内存占用测试容器..."
cleanup mem_stress
# 使用 stress 工具，持续分配大约300MB内存；请注意 alpine 默认镜像可能未安装 stress，故在运行时安装
docker run --rm -d --name mem_stress alpine sh -c "apk add --no-cache stress && stress --vm 1 --vm-bytes 300M --timeout 3600s"

##########################
# 3. 磁盘空间占满测试（循环写入大文件到挂载目录）
##########################
echo "[3] 启动磁盘空间占用测试容器..."
cleanup disk_stress
docker run --rm -d --name disk_stress -v "$HOST_DISK_DIR":/data alpine sh -c "while true; do dd if=/dev/zero of=/data/bigfile_\$(date +%s) bs=1M count=50 oflag=direct; sleep 5; done"

##########################
# 4. 网络高流量测试（循环下载大文件）
##########################
echo "[4] 启动网络高流量测试容器..."
cleanup net_stress
docker run --rm -d --name net_stress alpine sh -c "apk add --no-cache wget && while true; do wget -q -O /dev/null http://speed.hetzner.de/100MB.bin; done"

##########################
# 5. 模拟容器停止（短暂运行后退出）
##########################
echo "[5] 启动短暂运行测试容器，模拟容器停止..."
cleanup short_lived
docker run --rm -d --name short_lived alpine sh -c "sleep 5"

##########################
# 6. 模拟容器频繁重启测试
##########################
echo "[6] 启动频繁重启测试容器..."
cleanup restart_stress
# 注意：--restart always 不能和 --rm 同时使用
docker run -d --name restart_stress --restart always alpine sh -c "while true; do echo 'crash'; exit 1; done"

##########################
# 7. 模拟 inode 使用率高测试（在挂载目录中大量创建小文件）
##########################
echo "[7] 启动 inode 使用率高测试容器..."
cleanup inode_stress
docker run --rm -d --name inode_stress -v "$HOST_INODE_DIR":/data alpine sh -c "mkdir -p /data/inodes && cd /data/inodes && while true; do for i in \$(seq 1 1000); do touch file_\$(date +%s%N)_\$i; done; sleep 1; done"

##########################
# 8. 模拟磁盘 IOPS 高测试（循环写入并删除文件）
##########################
echo "[8] 启动磁盘 IOPS 高测试容器..."
cleanup disk_iops_stress
docker run --rm -d --name disk_iops_stress -v "$HOST_IOPS_DIR":/data alpine sh -c "while true; do dd if=/dev/zero of=/data/testfile bs=512 count=2000 conv=fdatasync; rm -f /data/testfile; done"

# 显示正在运行的容器列表
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Image}}"

echo "测试启动完毕，请根据需要观察监控系统的告警情况。"
echo "所有模拟测试容器已启动。"
echo "如需停止某个测试容器，请执行："
echo "docker rm -f cpu_stress mem_stress disk_stress net_stress restart_stress inode_stress disk_iops_stress"
echo "注意：短暂运行的容器（short_lived）会自行退出。"

验证告警触发

  1. 等待规则评估：
  • 容器内存利用率高 规则的 for 时间为 8m，需等待至少 8 分钟
  1. 检查 Prometheus 告警：
  • 访问 Prometheus 界面（http:// :9090），进入 Alerts 页面
  • 确认 容器内存利用率高 告警状态为 firing
  1. 检查 Alertmanager：
  • 访问 Alertmanager 界面（http:// :9093），确认告警已接收

9. 配置QQ邮箱告警

（1）流程图
（2）测试连接

安装工具

python 复制代码 
[root@k8s-master Monitor]# yum install -y telnet

若连通，应看到 220 smtp.qq.com ESMTP ready 等响应；若失败，检查网络或防火墙，查看容器日志

若出现 535 Login fail，说明授权码错误（必须 16 位）

若出现 timeout，检查容器网络是否通畅（可通过 docker exec ... ping smtp.qq.com 测试）

python 复制代码 
[root@k8s-master Monitor]# telnet smtp.qq.com 587
Trying 120.232.69.34...
Connected to smtp.qq.com.
Escape character is '^]'.
220 newxmesmtplogicsvrsza29-0.qq.com XMail Esmtp QQ Mail Server.
（3）配置Alert告警

登录QQ邮箱点击右上角设置，如图所示：

点击账号与安全，设置安全首先开启POP3/IMAP/SMTP/Exchange/CardDAV 服务（已开启），如图所示：

点击生成授权码，微信扫码发送短信获取授权码，如图所示：

python 复制代码 
[root@k8s-master Monitor]# vim alertmanager-0.19.0.linux-amd64/alertmanager.yml
global:
  resolve_timeout: 5m                     # 当告警变为"恢复"状态后，Alertmanager 会等待5分钟（resolve_timeout）以确保问题已经解决，然后发送恢复通知
  smtp_from: '1902038408@qq.com'          # 配置邮件告警时使用的发件人地址，这里为 QQ 邮箱地址
  smtp_smarthost: 'smtp.qq.com:587'       # 配置用于发送告警邮件的 SMTP 服务器及端口，此处指定为 QQ 的 SMTP 服务（587 为 STARTTLS 端口）
  smtp_auth_username: '1902038408@qq.com' # SMTP 认证用户名，通常与发件人一致，QQ 邮箱地址
  smtp_auth_password: 'thlljoqwgeuydccd'  # SMTP 认证密码或授权码（QQ邮箱需要开启 SMTP 授权码）
  smtp_require_tls: true                  # 指定是否要求使用 TLS 加密与 SMTP 服务器通信，设置为 true 表示必须启用加密
  smtp_hello: 'qq.com'                    # SMTP 握手时的 HELO/EHLO 字符串，一般设置为发件人邮箱所属域名

templates:
- '/opt/alertmanager/alert.tmpl'          # 指定告警模板文件路径，用于自定义邮件或其他通知内容

route:
  group_by: ['alertname']                # 根据标签 "alertname" 对告警进行分组，所有具有相同 alertname 的告警会一起通知
  group_wait: 5s                         # 当第一个告警到达时，等待5秒钟以便收集同组内的其它告警后再发送通知
  group_interval: 5s                     # 同一分组中如果有后续新告警，每隔5秒发送一次更新通知
  repeat_interval: 5m                    # 对于长时间存在的告警，每隔5分钟重复发送一次通知
  receiver: 'email'                      # 默认接收者设置为 "email"，即所有告警默认发送给该接收器

receivers:
- name: 'email'                          # 定义名称为 "email" 的告警接收器
  email_configs:
  - to: '1902038408@qq.com'              # 邮件通知发送到的目标邮箱地址
    html: '{{ template "email.to.html" . }}' # 邮件正文使用名为 "email.to.html" 的 HTML 模板，模板由 Alertmanager 根据告警数据渲染
    send_resolved: true                    # 设置为 true 表示在告警恢复时也发送通知

inhibit_rules:
- source_match:
    severity: 'critical'                 # 抑制规则：当源告警的 severity 标签值为 "critical"
  target_match:
    severity: 'warning'                  # 并且目标告警的 severity 标签值为 "warning" 时
  equal: ['alertname', 'dev', 'instance']  # 如果这两个告警在 "alertname"、"dev" 和 "instance" 标签上完全匹配，则抑制目标告警（即不发送 warning 级别的通知，因为已经有更严重的 critical 告警）
（4）测试发送邮箱

发送故障告警测试

python 复制代码 
[root@k8s-master Monitor]# docker exec -it monitor-alertmanager bash
[root@c0fde43fe9db alertmanager]# curl -XPOST -H "Content-Type: application/json" \
-d '[{"labels": {"severity": "warning", "alertname": "TestAlert"}, "annotations": {"summary": "Test", "description": "Test"}, "startsAt": "2025-04-07T12:00:00Z", "status": "firing"}]' \
http://monitor-alertmanager:9093/api/v1/alerts

# 返回结果
{"status":"success"}

发送恢复告警测试

python 复制代码 
[root@c0fde43fe9db alertmanager]# curl -XPOST -H "Content-Type: application/json" \
-d '[{"labels": {"severity": "warning", "alertname": "TestAlert"}, "annotations": {"summary": "Test", "description": "Test"}, "startsAt": "2025-04-07T12:00:00Z", "endsAt": "2025-04-07T12:05:00Z", "status": "resolved"}]' \
http://monitor-alertmanager:9093/api/v1/alerts

# 返回结果
{"status":"success"}
（5）自定义告警模版
python 复制代码 
[root@k8s-master Monitor]# vim alert.tmpl
{{ define "email.from" }}Monitor@alert.com{{ end }}
{{ define "email.to" }}1902038408@qq.com{{ end }}

{{ define "email.to.html" }}
{{ range .Alerts }}
  {{ $status := .Status }}
  {{ $alertName := .Labels.alertname }}
  {{ $instance := .Labels.instance }}
  {{ $containerName := .Labels.name }}
  {{ $severity := .Labels.severity }}
  {{ $summary := .Annotations.summary }}
  {{ $description := .Annotations.description }}
  {{ $value := .Annotations.value }}
  {{ $startTime := (.StartsAt).Format "2006-01-02 15:04:05" }}
  {{ $endTime := (.EndsAt).Format "2006-01-02 15:04:05" }}

  {{ if eq $status "firing" }}
  <!-- 故障告警模板 -->
  <div style="border: 1px solid #ffcccc; padding: 15px; margin-bottom: 15px;">
    <h4>【故障告警】</h4>
    ====================告警详情====================<br>
    告警程序: prometheus_alert <br>
    告警级别: {{ $severity }} 级 <br>
    告警类型: {{ $alertName }} <br>
    故障主机: {{ $instance }} <br>
    告警主题: {{ $summary }} <br>
    告警详情: {{ $description }} <br>
    触发时间: {{ $startTime }}（北京时间）<br>
    ======================end====================<br>
  </div>

  {{ else if eq $status "resolved" }}
  <!-- 恢复告警模板 -->
  <div style="border: 1px solid #ccffcc; padding: 15px; margin-bottom: 15px;">
    <h4>【恢复告警】</h4>
    ====================恢复详情====================<br>
    告警程序: prometheus_alert <br>
    告警级别: {{ $severity }} 级 <br>
    告警类型: {{ $alertName }} <br>
    故障主机: {{ $instance }} <br>
    告警主题: {{ $summary }} <br>
    恢复详情: 容器{{ $containerName }}的{{ $alertName }}已恢复正常<br>
    恢复时间: {{ $endTime }}（北京时间）<br>
    ======================end====================<br>
  </div>

  {{ end }}
{{ end }}
{{ end }}

查看 Prometheus alerts 如图所示：

查看容器故障报警，如图所示：

查看容器恢复告警，如图所示：

热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点03近期有什么ai的新消息，新动态？ 2026.4月042026年4月AI大事件深度解读：大模型竞争进入“深水区“05codex app每次打开重连5次Reconnecting问题解决062026年AI前瞻：量子AI、具身智能与科学发现的新纪元07AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析08CC-Switch & Claude 基于 Linux 服务器安装使用指南092026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free10Ubuntu 26.04 换国内源 清华源 阿里源 中科大源 华为源