- 1.Prometheus 概述
- （1）TSDB 作为 Prometheus 的存储引擎完美契合了监控数据的应用场景
- （2）Prometheus 的特点
- （3）Prometheus的主要组件
- （1）prometheus server
- （2）exporter
- （3）alertmanager
- （4）pushgateway
- （5）grafana
- （4）Prometheus 的局限性
- 2.Zabbix和Prometheus的区别？如何选择？
- （1）Zabbix
- （2）Prometheus
- 3.Prometheus的工作流程
- 4.helm快速部署 Prometheus 和 Grafana
- 5.部署 Prometheus
- 6.部署 Exporters
- （1）部署 Node Exporter 监控系统级指标
- （2）监控 MySQL 配置示例
- （3）监控 Nginx 配置示例
- 7.部署 Grafana 进行展示
- 8.部署 Prometheus 服务发现
- （1）基于文件的服务发现
- （2）基于 Consul 的服务发现
- （3）基于 Kubernetes API 的服务发现
- 9.Kubernetes 集群部署 Prometheus 和 Grafana
- （1）实验环境
- （2）node-exporter 安装
- （3）Prometheus 安装和配置
- （4）Prometheus 配置热加载
- （5）Grafana 安装
- （6）Grafana 配置
- （7）k8s 部署 kube-state-metrics 组件
- （8）kubernetes 配置 alertmanager 发送报警到邮箱
- （1）Prometheus报警处理流程
- （2）Prometheus 及 Alertmanager 配置
- （3）处理 kube-proxy 监控告警
1.Prometheus 概述
Prometheus是一个开源的服务监控系统和时序数据库，其提供了通用的数据模型和快捷数据采集、存储和查询接口。它的核心组件 Prometheus server 会定期从静态配置的监控目标或者基于服务发现自动配置的目标中进行拉取数据，新拉取到的数据会持久化到存储设备当中。
每个被监控的主机都可以通过专用的 exporter 程序提供输出监控指标数据的接口，它会在目标处收集监控数据，并暴露出一个 HTTP 接口供 Prometheus server 查询， Prometheus 通过基于 HTTP 的 pull 的方式来周期性的采集数据，默认时间是 15s 抓取一次。
抓取到的指标数据会被以时间序列的形式保存在内存中，并且定时刷到磁盘上，默认是两个小时回刷一次。并且为了防止 Prometheus 发生崩溃或重启时能够恢复数据， Prometheus 也提供了类似 MySQL 中 binlog 一样的 wal 预写日志，当 Prometheus 崩溃重启时，会读这个预写日志来恢复数据。
对于短时间执行的脚本任务或者不好直接 pull 指标数据的服务，Prometheus 提供了 Pushgateway 给这些任务将服务指标数据主动 push 到 Pushgateway 并临时存储，然后等待 Prometheus server 完成数据的采集。
任何被监控的目标都需要事先纳入到监控系统中才能进行时序数据采集、存储、告警和展示，监控目标可以通过配置信息以静态形式指定，也可以让 Prometheus 通过服务发现的机制进行动态管理。
Prometheus 能够直接把K8S的 API Server 作为服务发现系统使用，进而动态发现和监控K8S集群中的所有可被监控的对象。
Prometheus 官网地址：https://prometheus.io
Prometheus github 地址：https://github.com/prometheus
（1）TSDB 作为 Prometheus 的存储引擎完美契合了监控数据的应用场景
●存储的数据量级十分庞大
●大部分时间都是写入操作
●写入操作几乎是顺序添加，大多数时候数据都以时间排序
●很少更新数据，大多数情况在数据被采集到数秒或者数分钟后就会被写入数据库
●删除操作一般为区块删除，选定开始的历史时间并指定后续的区块。很少单独删除某个时间或者分开的随机时间的数据
●基本数据大，一般超过内存大小。一般选取的只是其一小部分且没有规律，缓存几乎不起任何作用
●读操作是十分典型的升序或者降序的顺序读
●高并发的读操作十分常见
（2）Prometheus 的特点
●多维数据模型：由度量名称和键值对标识的时间序列数据
时间序列数据：按照时间顺序记录系统、设备状态变化的数据，每个数据称为一个样本；服务器指标数据、应用程序性能监控数据、网络数据等都是时序数据
●内置时间序列（Time Series）数据库：Prometheus ；外置的远端存储通常会用：InfluxDB、OpenTSDB 等
●promQL 一种灵活的查询语言，可以利用多维数据完成复杂查询
●基于 HTTP 的 pull（拉取）方式采集时间序列数据
●同时支持 PushGateway 组件收集数据
●通过静态配置或服务发现发现目标
●支持作为数据源接入 Grafana
（3）Prometheus的主要组件
（1）prometheus server
是Prometheus服务的核心组件。通过http pull拉取的方式从监控目标采集监控指标数据（时序数据）；作为时序数据库持久化存储监控指标数据；
配置告警规则，当触告警时会生成告警通知发送给alertmanager；配置service discovery服务发现，可通过文件、cousul、K8S等方式自动发现监控目标target
（2）exporter
指标暴露器，用于从原生不支持prometheus直接采集监控指标数据的系统或应用等对象收集和汇总监控指标数据，并暴露http接口供prometheus server采集数据
node-exporter、kube-state-matrics、nginx/mysqld/redis-exporter、cADvisor、blackbox-exporter
（3）alertmanager
接收prometheus server发来的告警通知，负责对告警通知分组、去重，再通过邮件、钉钉、企业微信等方式发送给接收人
（4）pushgateway
作为临时中转站，接收一些短期任务或只能推送数据的任务发送的监控指标数据，临时存储这些监控指标数据并统一供prometheus server采集数据
（5）grafana
外置的监控数据展示平台，接入prometheus的数据源，通过promQL查询数据，以图形化形式展示监控数据
（4）Prometheus 的局限性
●Prometheus 是一款指标监控系统，不适合存储事件及日志等；它更多地展示的是趋势性的监控，而非精准数据；
●Prometheus 认为只有最近的监控数据才有查询的需要，其本地存储的设计初衷只是保存短期（例如一个月）数据，因而不支持针对大量的历史数据进行存储；
若需要存储长期的历史数据，建议基于远端存储机制将数据保存于 InfluxDB 或 OpenTSDB 等系统中；
●Prometheus 的集群机制成熟度不高，可基于 Thanos 或 Cortex 实现 Prometheus 集群的高可用及联邦集群。
2.Zabbix和Prometheus的区别？如何选择？
（1）Zabbix
更适合于传统业务架构的物理机、虚拟机环境的监控，对服务器系统和传统应用组件监控比较成熟，但是对容器的支持比较差。
数据存储主要采用的是关系型数据库，会随着被监控节点数量的增加，关系型数据库的负载压力也会变大，监控数据的读写也会变慢。
对大规模集群监控的性能比prometheus要弱一些，可适用于单集群规模不超过1000台节点的场景。
（2）Prometheus
除了传统业务架构，还能支持云环境、K8S容器集群的监控，是目前容器监控最好的解决方案。
数据存储采用的是时序数据库，大大的节省存储空间，还能提升查询效率。
单集群能支持的节点规模更大，通常超过2000台节点、服务数量大于1000个的时候建议直接上Prometheus。
3.Prometheus的工作流程
1）prometheus server通过静态配置或服务发现的方式获取监控目标target（通过exporter或pushgateway暴露的http接口）
2）prometheus server通过http pull拉取的方式从监控目标target采集监控指标数据
3）prometheus server将采集到的监控指标数据通过时序数据库持久化存储到本地磁盘或外置存储中
4）prometheus server通过将采集到的监控指标数据与本地配置的监控告警规则进行计算比对，如果触发告警则生成告警通知发送给alertmanager
5）alertmanager接收到prometheus server发来的告警通知后，对告警通知分组、去重，再通过邮件、钉钉、企业微信等方式发送给接收人
6）prometheus支持原生的web UI或grafana接入prometheus数据源，通过promQL查询数据，以图形化形式展示监控数据
4.helm快速部署 Prometheus 和 Grafana
master
node
pv1、2
master
一键部署Prometheus
等待pod开启
一键部署Grafana
镜像加速
5.部署 Prometheus
Prometheust Server 端安装和相关配置
（1）上传 prometheus-2.35.0.linux-amd64.tar.gz 到 /opt 目录中，并解压
systemctl stop firewalld
setenforce 0cd /opt/
tar xf prometheus-2.35.0.linux-amd64.tar.gz
mv prometheus-2.35.0.linux-amd64 /usr/local/prometheuscat /usr/local/prometheus/prometheus.yml | grep -v "^#"
global: #用于prometheus的全局配置，比如采集间隔，抓取超时时间等scrape_interval: 15s #采集目标主机监控数据的时间间隔，默认为1mevaluation_interval: 15s #触发告警生成alert的时间间隔，默认是1m# scrape_timeout is set to the global default (10s).scrape_timeout: 10s #数据采集超时时间，默认10salerting: #用于alertmanager实例的配置，支持静态配置和动态服务发现的机制alertmanagers:- static_configs:- targets:# - alertmanager:9093rule_files: #用于加载告警规则相关的文件路径的配置，可以使用文件名通配机制# - "first_rules.yml"# - "second_rules.yml"scrape_configs: #用于采集时序数据源的配置# The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.- job_name: "prometheus" #每个被监控实例的集合用job_name命名，支持静态配置（static_configs）和动态服务发现的机制（*_sd_configs）# metrics_path defaults to '/metrics'metrics_path: '/metrics' #指标数据采集路径，默认为 /metrics# scheme defaults to 'http'.static_configs: #静态目标配置，固定从某个target拉取数据- targets: ["localhost:9090"]
（2）配置系统启动文件，启动 Prometheust
cat > /usr/lib/systemd/system/prometheus.service <<'EOF'
[Unit]
Description=Prometheus Server
Documentation=https://prometheus.io
After=network.target[Service]
Type=simple
ExecStart=/usr/local/prometheus/prometheus \
--config.file=/usr/local/prometheus/prometheus.yml \
--storage.tsdb.path=/usr/local/prometheus/data/ \
--storage.tsdb.retention.time=15d \
--web.enable-lifecycleExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure[Install]
WantedBy=multi-user.target
EOF
（3）启动
systemctl start prometheus
systemctl enable prometheusnetstat -natp | grep :9090
浏览器访问：http://192.168.80.30:9090 ，访问到 Prometheus 的 Web UI 界面
点击页面的 Status -> Targets，如看到 Target 状态都为 UP，说明 Prometheus 能正常采集到数据
http://192.168.80.30:9090/metrics ，可以看到 Prometheus 采集到自己的指标数据，其中 Help 字段用于解释当前指标的含义，Type 字段用于说明数据的类型
以 go_ 为前缀的指标是关于 Go 运行时相关的指标，比如垃圾回收时间、goroutine 数量等，这些都是 Go 客户端库特有的
6.部署 Exporters
（1）部署 Node Exporter 监控系统级指标
（1）上传 node_exporter-1.3.1.linux-amd64.tar.gz 到 /opt 目录中，并解压
cd /opt/
tar xf node_exporter-1.3.1.linux-amd64.tar.gz
mv node_exporter-1.3.1.linux-amd64/node_exporter /usr/local/bin
（2）配置启动文件
cat > /usr/lib/systemd/system/node_exporter.service <<'EOF'
[Unit]
Description=node_exporter
Documentation=https://prometheus.io/
After=network.target[Service]
Type=simple
ExecStart=/usr/local/bin/node_exporter \
--collector.ntp \
--collector.mountstats \
--collector.systemd \
--collector.tcpstatExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure[Install]
WantedBy=multi-user.target
EOF
（3）启动
systemctl start node_exporter
systemctl enable node_exporter
netstat -natp | grep :9100
浏览器访问：http://192.168.80.30:9100/metrics ，可以看到 Node Exporter 采集到的指标数据
常用的各指标：
●node_cpu_seconds_total
●node_memory_MemTotal_bytes
●node_filesystem_size_bytes{mount_point=PATH}
●node_system_unit_state{name=}
●node_vmstat_pswpin：系统每秒从磁盘读到内存的字节数
●node_vmstat_pswpout：系统每秒钟从内存写到磁盘的字节数
更多指标介绍：https://github.com/prometheus/node_exporter
（4）修改 prometheus 配置文件，加入到 prometheus 监控中
vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容- job_name: nodesmetrics_path: "/metrics"static_configs:- targets:- 192.168.80.30:9100- 192.168.80.11:9100- 192.168.80.12:9100labels:service: kubernetes
（5）重新载入配置
curl -X POST http://192.168.80.30:9090/-/reload 或 systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets
（2）监控 MySQL 配置示例
在 MySQL 服务器上操作
（1）上传 mysqld_exporter-0.14.0.linux-amd64.tar.gz 到 /opt 目录中，并解压
cd /opt/
tar xf mysqld_exporter-0.14.0.linux-amd64.tar.gz
mv mysqld_exporter-0.14.0.linux-amd64/mysqld_exporter /usr/local/bin/
（2）配置启动文件
cat > /usr/lib/systemd/system/mysqld_exporter.service <<'EOF'
[Unit]
Description=mysqld_exporter
Documentation=https://prometheus.io/
After=network.target[Service]
Type=simple
ExecStart=/usr/local/bin/mysqld_exporter --config.my-cnf=/etc/my.cnfExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure[Install]
WantedBy=multi-user.target
EOF
（3）修改 MySQL 配置文件
vim /etc/my.cnf
[client]
......
host=localhost
user=exporter
password=abc123
（4）授权 exporter 用户
mysql -uroot -pabc123
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost' IDENTIFIED BY 'abc123';
（5）重启服务
systemctl restart mysqld
systemctl start mysqld_exporter
systemctl enable mysqld_exporternetstat -natp | grep :9104
在 Prometheus 服务器上操作
（1）修改 prometheus 配置文件，加入到 prometheus 监控中
vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容- job_name: mysqldmetrics_path: "/metrics"static_configs:- targets:- 192.168.80.15:9104labels:service: mysqld
（2）重新载入配置
curl -X POST http://192.168.80.30:9090/-/reload 或 systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets
（3）监控 Nginx 配置示例
在 Nginx 服务器上操作
下载 nginx-exporter 地址：https://github.com/hnlq715/nginx-vts-exporter/releases/download/v0.10.3/nginx-vts-exporter-0.10.3.linux-amd64.tar.gz
下载 nginx 地址：http://nginx.org/download/
下载 nginx 插件地址：https://github.com/vozlt/nginx-module-vts/tags
（1）解压 nginx 插件
cd /opt
tar xf nginx-module-vts-0.1.18.tar.gz
mv nginx-module-vts-0.1.18 /usr/local/nginx-module-vts
（2）安装 Nginx
yum -y install pcre-devel zlib-devel openssl-devel gcc gcc-c++ make
useradd -M -s /sbin/nologin nginxcd /opt
tar xf nginx-1.18.0.tar.gzcd nginx-1.18.0/
./configure --prefix=/usr/local/nginx \
--user=nginx \
--group=nginx \
--with-http_stub_status_module \
--with-http_ssl_module \
--add-module=/usr/local/nginx-module-vtsmake & make install
（3）修改 nginx 配置文件，启动 nginx
vim /usr/local/nginx/conf/nginx.conf
http {vhost_traffic_status_zone; #添加vhost_traffic_status_filter_by_host on; #添加，开启此功能，在 Nginx 配置有多个 server_name 的情况下，会根据不同的 server_name 进行流量的统计，否则默认会把流量全部计算到第一个 server_name 上......server {......}server {vhost_traffic_status off; #在不想统计流量的 server 区域，可禁用 vhost_traffic_statuslisten 8080;allow 127.0.0.1;allow 192.168.80.30; #设置为 prometheus 的 ip 地址location /nginx-status {stub_status on;access_log off;}location /status {vhost_traffic_status_display;vhost_traffic_status_display_format html;}}
}#假如 nginx 没有规范配置 server_name 或者无需进行监控的 server 上，那么建议在此 vhost 上禁用统计监控功能。否则会出现 127.0.0.1、hostname 等的域名监控信息。ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/
nginx -tcat > /lib/systemd/system/nginx.service <<'EOF'
[Unit]
Description=nginx
After=network.target[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStart=/usr/local/nginx/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true[Install]
WantedBy=multi-user.target
EOFsystemctl start nginx
systemctl enable nginx
浏览器访问：http://192.168.80.15:8080/status ，可以看到 Nginx Vhost Traffic Status 的页面信息
（4）解压 nginx-exporter，启动 nginx-exporter
cd /opt/
tar -zxvf nginx-vts-exporter-0.10.3.linux-amd64.tar.gz
mv nginx-vts-exporter-0.10.3.linux-amd64/nginx-vts-exporter /usr/local/bin/cat > /usr/lib/systemd/system/nginx-exporter.service <<'EOF'
[Unit]
Description=nginx-exporter
Documentation=https://prometheus.io/
After=network.target[Service]
Type=simple
ExecStart=/usr/local/bin/nginx-vts-exporter -nginx.scrape_uri=http://localhost:8080/status/format/jsonExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure[Install]
WantedBy=multi-user.target
EOFsystemctl start nginx-exporter
systemctl enable nginx-exporter
netstat -natp | grep :9913
在 Prometheus 服务器上操作
（1）修改 prometheus 配置文件，加入到 prometheus 监控中
vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容- job_name: nginxmetrics_path: "/metrics"static_configs:- targets:- 192.168.80.15:9913labels:service: nginx
（2）重新载入配置
curl -X POST http://192.168.80.30:9090/-/reload 或 systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets
7.部署 Grafana 进行展示
（1）下载和安装
下载地址：https://grafana.com/grafana/download
https://mirrors.bfsu.edu.cn/grafana/yum/rpm/
yum install -y grafana-7.4.0-1.x86_64.rpm
systemctl start grafana-server
systemctl enable grafana-server
netstat -natp | grep :3000
浏览器访问：http://192.168.80.30:3000 ，默认账号和密码为 admin/admin
（2）配置数据源
Configuration -> Data Sources -> Add data source -> 选择 Prometheus
HTTP -> URL 输入 http://192.168.80.30:9090
点击 Save & Test
点击 上方菜单 Dashboards，Import 所有默认模板
Dashboards -> Manage ，选择 Prometheus 2.0 Stats 或 Prometheus Stats 即可看到 Prometheus job 实例的监控图像
（3）导入 grafana 监控面板
浏览器访问：https://grafana.com/grafana/dashboards ，在页面中搜索 node exporter ，选择适合的面板，点击 Copy ID 或者 Download JSON
在 grafana 页面中，+ Create -> Import ，输入面板 ID 号或者上传 JSON 文件，点击 Load，即可导入监控面板
8.部署 Prometheus 服务发现
（1）基于文件的服务发现
基于文件的服务发现是仅仅略优于静态配置的服务发现方式，它不依赖于任何平台或第三方服务，因而也是最为简单和通用的实现方式。
Prometheus Server 会定期从文件中加载 Target 信息，文件可使用 YAML 和 JSON 格式，它含有定义的 Target 列表，以及可选的标签信息。
（1）创建用于服务发现的文件，在文件中配置所需的 target
cd /usr/local/prometheus
mkdir targetsvim targets/node-exporter.yaml
- targets:- 192.168.80.30:9100- 192.168.80.15:9100labels:app: node-exporterjob: nodevim targets/mysqld-exporter.yaml
- targets:- 192.168.80.30:9104- 192.168.80.15:9104labels:app: mysqld-exporterjob: mysqld#修改 prometheus 配置文件，发现 target 的配置，定义在配置文件的 job 之中
vim /usr/local/prometheus/prometheus.yml
......
scrape_configs:- job_name: nodesfile_sd_configs: #指定使用文件服务发现- files: #指定要加载的文件列表- targets/node*.yaml #文件加载支持通配符refresh_interval: 2m #每隔 2 分钟重新加载一次文件中定义的 Targets，默认为 5m- job_name: mysqldfile_sd_configs:- files:- targets/mysqld*.yamlrefresh_interval: 2msystemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets
（2）基于 Consul 的服务发现
Consul 是一款基于 golang 开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现和配置管理的功能。
提供服务注册/发现、健康检查、Key/Value存储、多数据中心和分布式一致性保证等功能。
下载地址：https://www.consul.io/downloads/
（1）部署 Consul 服务
cd /opt/
unzip consul_1.9.2_linux_amd64.zip
mv consul /usr/local/bin/#创建 Consul 服务的数据目录和配置目录
mkdir -p /usr/local/consul/{data,conf,logs}#使用 server 模式启动 Consul 服务
consul agent \
-server \
-bootstrap \
-ui \
-data-dir=/usr/local/consul/data \
-config-dir=/usr/local/consul/conf \
-bind=192.168.80.14 \
-client=0.0.0.0 \
-node=consul-server01 &> /usr/local/consul/logs/consul.log &#查看 consul 集群成员
consul members
（2）在 Consul 上注册 Services
在配置目录中添加文件
vim /usr/local/consul/conf/nodes.json
{"services": [{"id": "node_exporter-node01","name": "node01","address": "192.168.80.30","port": 9100,"tags": ["nodes"],"checks": [{"http": "http://192.168.80.30:9100/metrics","interval": "5s"}]},{"id": "node_exporter-node02","name": "node02","address": "192.168.80.15","port": 9100,"tags": ["nodes"],"checks": [{"http": "http://192.168.80.15:9100/metrics","interval": "5s"}]}]
}#让 consul 重新加载配置信息
consul reload 浏览器访问：http://192.168.80.30:8500
（3）修改 prometheus 配置文件
vim /usr/local/prometheus/prometheus.yml
......- job_name: nodesconsul_sd_configs: #指定使用 consul 服务发现- server: 192.168.80.30:8500 #指定 consul 服务的端点列表tags: #指定 consul 服务发现的 services 中哪些 service 能够加入到 prometheus 监控的标签- nodesrefresh_interval: 2msystemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets#让 consul 注销 Service
consul services deregister -id="node_exporter-node02"#重新注册
consul services register /etc/consul/nodes.json
（3）基于 Kubernetes API 的服务发现
基于 Kubernetes API 的服务发现机制，支持将 API Server 中 Node、Service、Endpoint、Pod 和 Ingress 等资源类型下相应的各资源对象视作 target， 并持续监视相关资源的变动
●Node、Service、Endpoint、Pod 和 Ingress 资源分别由各自的发现机制进行定义
●负责发现每种类型资源对象的组件，在 Prometheus 中称为一个 role
●支持在集群上基于 DaemonSet 控制器部署 node-exporter 后发现各 Node 节点，也可以通过 kubelet 来作为 Prometheus 发现各 Node 节点的入口
基于 Kubernetes 发现机制的部分配置参数
# The API server addresses. If left empty, Prometheus is assumed to run inside of the cluster and will discover API servers automatically
and use the pod's
# CA certificate and bearer token file at /var/run/secrets/kubernetes.io/serviceaccount/.
[ api_server: <host> ]# The Kubernetes role of entities that should be discovered. One of endpoints, service, pod, node, or ingress.
role: <string># Optional authentication information used to authenticate to the API server.
# Note that 'basic_auth', 'bearer_token'和'bearer_token_file' 等认证方式互斥；
[ bearer_token: <secret> ]
[ bearer_token_file: <filename> ]# TLS configuration.
tls_config:
# CA certificate to validate API server certificate with.
[ ca_file: <filename> ]# Certificate and key files for client cert authentication to the server.
[ cert_file: <filename> ]
[ key_file: <filename> ]# ServerName extension to indicate the name of the server.
[ server_name: <string> ]# Optional namespace discovery. If omitted, all namespaces are used.
namespaces:
names:
[ - <string> ]
9.Kubernetes 集群部署 Prometheus 和 Grafana
（1）实验环境
控制节点/master01 192.168.80.10
工作节点/node01 192.168.80.11
工作节点/node02 192.168.80.12
（2）node-exporter 安装
#创建监控 namespace
kubectl create ns monitor-sa#部署 node-exporter
mkdir /opt/prometheus
cd /opt/prometheus/vim node-export.yaml
---
apiVersion: apps/v1
kind: DaemonSet #可以保证 k8s 集群的每个节点都运行完全一样的 pod
metadata:name: node-exporternamespace: monitor-salabels:name: node-exporter
spec:selector:matchLabels:name: node-exportertemplate:metadata:labels:name: node-exporterspec:hostPID: truehostIPC: truehostNetwork: truecontainers:- name: node-exporterimage: prom/node-exporter:v0.16.0ports:- containerPort: 9100resources:requests:cpu: 0.15 #这个容器运行至少需要0.15核cpusecurityContext:privileged: true #开启特权模式args:- --path.procfs- /host/proc- --path.sysfs- /host/sys- --collector.filesystem.ignored-mount-points- '"^/(sys|proc|dev|host|etc)($|/)"'volumeMounts:- name: devmountPath: /host/dev- name: procmountPath: /host/proc- name: sysmountPath: /host/sys- name: rootfsmountPath: /rootfstolerations:- key: "node-role.kubernetes.io/master"operator: "Exists"effect: "NoSchedule"volumes:- name: prochostPath:path: /proc- name: devhostPath:path: /dev- name: syshostPath:path: /sys- name: rootfshostPath:path: /#hostNetwork、hostIPC、hostPID都为True时，表示这个Pod里的所有容器，会直接使用宿主机的网络，直接与宿主机进行IPC（进程间通信）通信，可以看到宿主机里正在运行的所有进程。加入了hostNetwork:true会直接将我们的宿主机的9100端口映射出来，从而不需要创建service在我们的宿主机上就会有一个9100的端口。kubectl apply -f node-export.yamlkubectl get pods -n monitor-sa -o wide#通过 node-exporter 采集数据
node-exporter 默认的监听端口是 9100，可以执行 curl http://主机ip:9100/metrics 获取到主机的所有监控数据curl -Ls http://192.168.80.10:9100/metrics | grep node_cpu_seconds
# HELP node_cpu_seconds_total Seconds the cpus spent in each mode. #Help 用于解释当前指标的含义
# TYPE node_cpu_seconds_total counter #Type 用于说明数据的类型，这是一个 counter（计数器）类型的数据
node_cpu_seconds_total{cpu="0",mode="idle"} 1076.15 #接下来就是具体的指标的值
node_cpu_seconds_total{cpu="0",mode="iowait"} 0.99
node_cpu_seconds_total{cpu="0",mode="irq"} 0
node_cpu_seconds_total{cpu="0",mode="nice"} 0
node_cpu_seconds_total{cpu="0",mode="softirq"} 3.15
node_cpu_seconds_total{cpu="0",mode="steal"} 0
node_cpu_seconds_total{cpu="0",mode="system"} 23.17
node_cpu_seconds_total{cpu="0",mode="user"} 24.49
node_cpu_seconds_total{cpu="1",mode="idle"} 1079.71
node_cpu_seconds_total{cpu="1",mode="iowait"} 0.75
node_cpu_seconds_total{cpu="1",mode="irq"} 0
node_cpu_seconds_total{cpu="1",mode="nice"} 0
node_cpu_seconds_total{cpu="1",mode="softirq"} 3.6
node_cpu_seconds_total{cpu="1",mode="steal"} 0
node_cpu_seconds_total{cpu="1",mode="system"} 22.04
node_cpu_seconds_total{cpu="1",mode="user"} 25.6curl -Ls http://192.168.80.10:9100/metrics | grep node_load
# HELP node_load1 1m load average.
# TYPE node_load1 gauge
node_load1 0.24
# HELP node_load15 15m load average.
# TYPE node_load15 gauge
node_load15 0.16
# HELP node_load5 5m load average.
# TYPE node_load5 gauge
node_load5 0.18
（3）Prometheus 安装和配置
（1）创建 sa 账号，对 sa 做 rbac 授权
创建一个 sa 账号 monitor
kubectl create serviceaccount monitor -n monitor-sa#把 sa 账号 monitor 通过 clusterrolebing 绑定到 clusterrole 上
kubectl create clusterrolebinding monitor-clusterrolebinding -n monitor-sa --clusterrole=cluster-admin --serviceaccount=monitor-sa:monitor
（2）创建一个 configmap 存储卷，用来存放 prometheus 配置信息
vim prometheus-cfg.yaml
---
kind: ConfigMap
apiVersion: v1
metadata:labels:app: prometheusname: prometheus-confignamespace: monitor-sa
data:prometheus.yml: |global: #指定prometheus的全局配置，比如采集间隔，抓取超时时间等scrape_interval: 15s #采集目标主机监控数据的时间间隔，默认为1mscrape_timeout: 10s #数据采集超时时间，默认10sevaluation_interval: 1m #触发告警生成alert的时间间隔，默认是1mscrape_configs: #配置数据源，称为target，每个target用job_name命名。又分为静态配置和服务发现- job_name: 'kubernetes-node'kubernetes_sd_configs: # *_sd_configs 指定的是k8s的服务发现- role: node #使用node角色，它使用默认的kubelet提供的http端口来发现集群中每个node节点relabel_configs: #重新标记- source_labels: [__address__] #配置的原始标签，匹配地址regex: '(.*):10250' #匹配带有10250端口的urlreplacement: '${1}:9100' #把匹配到的ip:10250的ip保留target_label: __address__ #新生成的url是${1}获取到的ip:9100action: replace #动作替换- action: labelmapregex: __meta_kubernetes_node_label_(.+) #匹配到下面正则表达式的标签会被保留,如果不做regex正则的话，默认只是会显示instance标签- job_name: 'kubernetes-node-cadvisor' #抓取cAdvisor数据，是获取kubelet上/metrics/cadvisor接口数据来获取容器的资源使用情况kubernetes_sd_configs:- role: nodescheme: httpstls_config:ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crtbearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/tokenrelabel_configs:- action: labelmap #把匹配到的标签保留regex: __meta_kubernetes_node_label_(.+) #保留匹配到的具有__meta_kubernetes_node_label的标签- target_label: __address__ #获取到的地址：__address__="192.168.80.20:10250"replacement: kubernetes.default.svc:443 #把获取到的地址替换成新的地址kubernetes.default.svc:443- source_labels: [__meta_kubernetes_node_name]regex: (.+) #把原始标签中__meta_kubernetes_node_name值匹配到target_label: __metrics_path__ #获取__metrics_path__对应的值replacement: /api/v1/nodes/${1}/proxy/metrics/cadvisor #把metrics替换成新的值api/v1/nodes/<node_name>/proxy/metrics/cadvisor#${1}是__meta_kubernetes_node_name获取到的值#最后通过https://<apiserver_address>/api/v1/nodes/<node_name>/proxy/metrics/cadvisor来获取对应节点cadvisor监控数据- job_name: 'kubernetes-apiserver'kubernetes_sd_configs:- role: endpoints #使用k8s中的endpoint服务发现，采集apiserver 6443端口获取到的数据scheme: httpstls_config:ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crtbearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/tokenrelabel_configs:- source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name] #[endpoint这个对象的名称空间,endpoint对象的服务名,exnpoint的端口名称]action: keep #采集满足条件的实例，其他实例不采集regex: default;kubernetes;https #正则匹配到的默认空间下的service名字是kubernetes，协议是https的endpoint类型保留下来- job_name: 'kubernetes-service-endpoints'kubernetes_sd_configs:- role: endpointsrelabel_configs:- source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]action: keepregex: true#重新打标仅抓取到的具有"prometheus.io/scrape: true"的annotation的端点， 意思是说如果某个service具有prometheus.io/scrape = true的annotation声明则抓取，annotation本身也是键值结构， 所以这里的源标签设置为键，而regex设置值true，当值匹配到regex设定的内容时则执行keep动作也就是保留，其余则丢弃。- source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]action: replacetarget_label: __scheme__regex: (https?)#重新设置scheme，匹配源标签__meta_kubernetes_service_annotation_prometheus_io_scheme也就是prometheus.io/scheme annotation，如果源标签的值匹配到regex，则把值替换为__scheme__对应的值。- source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]action: replacetarget_label: __metrics_path__regex: (.+)#应用中自定义暴露的指标，也许你暴露的API接口不是/metrics这个路径，那么你可以在这个POD对应的service中做一个 "prometheus.io/path = /mymetrics" 声明，上面的意思就是把你声明的这个路径赋值给__metrics_path__， 其实就是让prometheus来获取自定义应用暴露的metrices的具体路径， 不过这里写的要和service中做好约定，如果service中这样写 prometheus.io/app-metrics-path: '/metrics' 那么你这里就要__meta_kubernetes_service_annotation_prometheus_io_app_metrics_path这样写。- source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_port]action: replacetarget_label: __address__regex: ([^:]+)(?::\d+)?;(\d+)replacement: $1:$2#暴露自定义的应用的端口，就是把地址和你在service中定义的 "prometheus.io/port = <port>" 声明做一个拼接， 然后赋值给__address__，这样prometheus就能获取自定义应用的端口，然后通过这个端口再结合__metrics_path__来获取指标，如果__metrics_path__值不是默认的/metrics那么就要使用上面的标签替换来获取真正暴露的具体路径。- action: labelmap #保留下面匹配到的标签regex: __meta_kubernetes_service_label_(.+)- source_labels: [__meta_kubernetes_namespace]action: replace #替换__meta_kubernetes_namespace变成kubernetes_namespacetarget_label: kubernetes_namespace- source_labels: [__meta_kubernetes_service_name]action: replacetarget_label: kubernetes_namekubectl apply -f prometheus-cfg.yaml
（3）通过 deployment 部署 prometheus
将 prometheus 调度到 node1 节点，在 node1 节点创建 prometheus 数据存储目录
mkdir /data && chmod 777 /data#通过 deployment 部署 prometheus
vim prometheus-deploy.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:name: prometheus-servernamespace: monitor-salabels:app: prometheus
spec:replicas: 1selector:matchLabels:app: prometheuscomponent: server#matchExpressions:#- {key: app, operator: In, values: [prometheus]}#- {key: component, operator: In, values: [server]}template:metadata:labels:app: prometheuscomponent: serverannotations:prometheus.io/scrape: 'false'spec:nodeName: node01 #指定pod调度到哪个节点上 serviceAccountName: monitorcontainers:- name: prometheusimage: prom/prometheus:v2.2.1imagePullPolicy: IfNotPresentcommand:- prometheus- --config.file=/etc/prometheus/prometheus.yml- --storage.tsdb.path=/prometheus #数据存储目录- --storage.tsdb.retention=720h #数据保存时长- --web.enable-lifecycle #开启热加载ports:- containerPort: 9090protocol: TCPvolumeMounts:- mountPath: /etc/prometheus/prometheus.ymlname: prometheus-configsubPath: prometheus.yml- mountPath: /prometheus/name: prometheus-storage-volumevolumes:- name: prometheus-configconfigMap:name: prometheus-configitems:- key: prometheus.ymlpath: prometheus.ymlmode: 0644- name: prometheus-storage-volumehostPath:path: /datatype: Directorykubectl apply -f prometheus-deploy.yaml
kubectl get pods -o wide -n monitor-sa
（4）给 prometheus pod 创建一个 service
vim prometheus-svc.yaml
---
apiVersion: v1
kind: Service
metadata:name: prometheusnamespace: monitor-salabels:app: prometheus
spec:type: NodePortports:- port: 9090targetPort: 9090protocol: TCPnodePort: 31000selector:app: prometheuscomponent: serverkubectl apply -f prometheus-svc.yaml
kubectl get svc -n monitor-sa
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
prometheus NodePort 10.107.188.51 <none> 9090:31000/TCP 86s#通过上面可以看到 service 在 node 节点上映射的端口是 31000，这样我们访问 k8s 集群的 node 节点的 ip:31000，就可以访问到 prometheus 的 web ui 界面了。
浏览器访问 http://192.168.80.11:31000#点击页面的Status->Targets，如看到所有 Target 状态都为 UP，说明我们配置的服务发现可以正常采集数据#查询 K8S 集群中一分钟之内每个 Pod 的 CPU 使用率
sum by (name)( rate(container_cpu_usage_seconds_total{image!="", name!=""}[1m] ) )
（4）Prometheus 配置热加载
为了每次修改配置文件可以热加载prometheus，也就是不停止prometheus，就可以使配置生效，想要使配置生效可用如下热加载命令：
kubectl get pods -n monitor-sa -o wide -l app=prometheus
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
prometheus-server-75fb7f8fc6-8vxwj 1/1 Running 0 18h 10.244.1.3 node01 <none> <none>#想要使配置生效可用如下命令热加载
curl -X POST -Ls http://10.244.1.3:9090/-/reload #查看 log
kubectl logs -n monitor-sa prometheus-server-75fb7f8fc6-8vxwj | grep "Loading configuration file" ###一般热加载速度比较慢，可以暴力重启prometheus，如修改上面的 prometheus-cfg.yaml 文件之后，可用如下命令：
#可执行先强制删除，然后再通过 apply 更新
kubectl delete -f prometheus-cfg.yaml
kubectl delete -f prometheus-deploy.yaml
kubectl apply -f prometheus-cfg.yaml
kubectl apply -f prometheus-deploy.yaml注意：线上环境最好使用热加载，暴力删除可能造成监控数据的丢失
（5）Grafana 安装
vim grafana.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:name: monitoring-grafananamespace: kube-system
spec:replicas: 1selector:matchLabels:task: monitoringk8s-app: grafanatemplate:metadata:labels:task: monitoringk8s-app: grafanaspec:containers:- name: grafanaimage: grafana/grafana:5.0.4ports:- containerPort: 3000protocol: TCPvolumeMounts:- mountPath: /etc/ssl/certsname: ca-certificatesreadOnly: true- mountPath: /varname: grafana-storageenv:- name: INFLUXDB_HOSTvalue: monitoring-influxdb- name: GF_SERVER_HTTP_PORTvalue: "3000"# The following env variables are required to make Grafana accessible via# the kubernetes api-server proxy. On production clusters, we recommend# removing these env variables, setup auth for grafana, and expose the grafana# service using a LoadBalancer or a public IP.- name: GF_AUTH_BASIC_ENABLEDvalue: "false"- name: GF_AUTH_ANONYMOUS_ENABLEDvalue: "true"- name: GF_AUTH_ANONYMOUS_ORG_ROLEvalue: Admin- name: GF_SERVER_ROOT_URL# If you're only using the API Server proxy, set this value instead:# value: /api/v1/namespaces/kube-system/services/monitoring-grafana/proxyvalue: /volumes:- name: ca-certificateshostPath:path: /etc/ssl/certs- name: grafana-storageemptyDir: {}
---
apiVersion: v1
kind: Service
metadata:labels:# For use as a Cluster add-on (https://github.com/kubernetes/kubernetes/tree/master/cluster/addons)# If you are NOT using this as an addon, you should comment out this line.kubernetes.io/cluster-service: 'true'kubernetes.io/name: monitoring-grafananame: monitoring-grafananamespace: kube-system
spec:# In a production setup, we recommend accessing Grafana through an external Loadbalancer# or through a public IP.# type: LoadBalancer# You could also use NodePort to expose the service at a randomly-generated port# type: NodePortports:- port: 80targetPort: 3000selector:k8s-app: grafanatype: NodePortkubectl apply -f grafana.yaml
kubectl get pods -n kube-system -l task=monitoring -o widekubectl get svc -n kube-system | grep grafana
monitoring-grafana NodePort 10.96.53.95 <none> 80:32087/TCP 26s
（6）Grafana 配置
（1）浏览器访问http://192.168.80.11:32087 ，登陆 grafana
（2）开始配置 grafana 的 web 界面：选择 Add data source
【Name】设置成 Prometheus
【Type】选择 Prometheus
【URL】设置成 http://prometheus.monitor-sa.svc:9090 #使用service的集群内部端口配置服务端地址
点击 【Save & Test】
（3）导入监控模板
官方链接搜索：https://grafana.com/dashboards?dataSource=prometheus&search=kubernetes
（4）监控 node 状态
点击左侧+号选择【Import】
点击【Upload .json File】导入 node_exporter.json 模板
【Prometheus】选择 Prometheus
点击【Import】
（5）监控 容器 状态
点击左侧+号选择【Import】
点击【Upload .json File】导入 docker_rev1.json 模板
【Prometheus】选择 Prometheus
点击【Import】
（7）k8s 部署 kube-state-metrics 组件
（1）安装 kube-state-metrics 组件
创建 sa，并对 sa 授权
vim kube-state-metrics-rbac.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:name: kube-state-metricsnamespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:name: kube-state-metrics
rules:
- apiGroups: [""]resources: ["nodes", "pods", "services", "resourcequotas", "replicationcontrollers", "limitranges", "persistentvolumeclaims", "persistentvolumes", "namespaces", "endpoints"]verbs: ["list", "watch"]
- apiGroups: ["extensions"]resources: ["daemonsets", "deployments", "replicasets"]verbs: ["list", "watch"]
- apiGroups: ["apps"]resources: ["statefulsets"]verbs: ["list", "watch"]
- apiGroups: ["batch"]resources: ["cronjobs", "jobs"]verbs: ["list", "watch"]
- apiGroups: ["autoscaling"]resources: ["horizontalpodautoscalers"]verbs: ["list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:name: kube-state-metrics
roleRef:apiGroup: rbac.authorization.k8s.iokind: ClusterRolename: kube-state-metrics
subjects:
- kind: ServiceAccountname: kube-state-metricsnamespace: kube-systemkubectl apply -f kube-state-metrics-rbac.yaml#安装 kube-state-metrics 组件和 service
vim kube-state-metrics-deploy.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:name: kube-state-metricsnamespace: kube-system
spec:replicas: 1selector:matchLabels:app: kube-state-metricstemplate:metadata:labels:app: kube-state-metricsspec:serviceAccountName: kube-state-metricscontainers:- name: kube-state-metricsimage: quay.io/coreos/kube-state-metrics:v1.9.0ports:- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:annotations:prometheus.io/scrape: 'true'name: kube-state-metricsnamespace: kube-systemlabels:app: kube-state-metrics
spec:ports:- name: kube-state-metricsport: 8080protocol: TCPselector:app: kube-state-metricskubectl apply -f kube-state-metrics-deploy_svc.yaml
kubectl get pods,svc -n kube-system -l app=kube-state-metrics
（2）Grafana 配置
监控 k8s 群集状态
点击左侧+号选择【Import】
点击【Upload .json File】导入 kubernetes-cluster-prometheus_rev4.json 模板
【Prometheus】选择 Prometheus
点击【Import】
监控 k8s 群集性能状态
点击左侧+号选择【Import】
点击【Upload .json File】导入 kubernetes-cluster-monitoring-via-prometheus_rev3.json 模板
【Prometheus】选择 Prometheus
点击【Import】
（8）kubernetes 配置 alertmanager 发送报警到邮箱
（1）Prometheus报警处理流程
1）Prometheus Server 监控目标主机上暴露的 http接口（假设接口A），通过Promethes配置的'scrape_interval' 定义的时间间隔， 定期采集目标主机上监控数据。
2）当接口A不可用的时候，Server 端会持续的尝试从接口中取数据，直到 "scrape_timeout" 时间后停止尝试。 这时候把接口的状态变为 "DOWN"。
3）Prometheus 同时根据配置的 evaluation_interval 的时间间隔，定期（默认1min）的对 Alert Rule 进行评估； 当到达评估周期的时候，发现接口A为 DOWN，即 UP=0 为真，激活 Alert，进入 PENDING 状态，并记录当前 active 的时间；
4）当下一个 alert rule 的评估周期到来的时候，发现 UP=0 继续为真，然后判断警报 Active 的时间是否已经超出 rule 里的 for 持续时间，如果未超出，则进入下一个评估周期；如果时间超出，则 alert 的状态变为 FIRING；同时调用 Alertmanager 接口， 发送相关报警数据。
5）AlertManager 收到报警数据后，会将警报信息进行分组，然后根据 alertmanager 配置的 group_wait 时间先进行等待。等 wait 时间过后再发送报警信息。
6）属于同一个 Alert Group的警报，在等待的过程中可能进入新的 alert，如果之前的报警已经成功发出，那么间隔 group_interval 的时间间隔后再重新发送报警信息。比如配置的是邮件报警，那么同属一个 group 的报警信息会汇总在一个邮件里进行发送。
7）如果 Alert Group里的警报一直没发生变化并且已经成功发送，等待 repeat_interval 时间间隔之后再重复发送相同的报警邮件； 如果之前的警报没有成功发送，则相当于触发第6条条件，则需要等待 group_interval 时间间隔后重复发送。
8）同时最后至于警报信息具体发给谁，满足什么样的条件下指定警报接收人，设置不同报警发送频率，这里使用 alertmanager 的 route 路由规则进行配置。
（2）Prometheus 及 Alertmanager 配置
（1）创建 alertmanager 配置文件
vim alertmanager-cm.yaml
---
kind: ConfigMap
apiVersion: v1
metadata:name: alertmanagernamespace: monitor-sa
data:alertmanager.yml: |-global: #设置发件人邮箱信息resolve_timeout: 1msmtp_smarthost: 'smtp.qq.com:25'smtp_from: 'qwe4546456@qq.com'smtp_auth_username: 'qwe4546456@qq.com'smtp_auth_password: 'zzkqqtejcbenbidh' #此处为授权码，登录QQ邮箱【设置】->【账户】中的【生成授权码】获取smtp_require_tls: falseroute: #用于设置告警的分发策略group_by: [alertname] #采用哪个标签来作为分组依据group_wait: 10s #组告警等待时间。也就是告警产生后等待10s，如果有同组告警一起发出group_interval: 10s #上下两组发送告警的间隔时间repeat_interval: 10m #重复发送告警的时间，减少相同邮件的发送频率，默认是1hreceiver: default-receiver #定义谁来收告警receivers: #设置收件人邮箱信息- name: 'default-receiver'email_configs:- to: 'qwe4546456@wo.cn' #设置收件人邮箱地址send_resolved: truekubectl apply -f alertmanager-cm.yaml
（2）创建 prometheus 和告警规则配置文件
上传 prometheus-alertmanager-cfg.yaml 文件
#删除之前的配置，更新配置
kubectl delete -f prometheus-cfg.yaml
kubectl apply -f prometheus-alertmanager-cfg.yamlkubectl get cm -n monitor-sa
alertmanager 1 2m29s
kube-root-ca.crt 1 14h
prometheus-config 2 29s
（3）安装 prometheus 和 alertmanager
生成一个 secret 资源 etcd-certs，这个在部署 prometheus 需要，用于监控 etcd 相关资源
kubectl -n monitor-sa create secret generic etcd-certs --from-file=/etc/kubernetes/pki/etcd/server.key --from-file=/etc/kubernetes/pki/etcd/server.crt --from-file=/etc/kubernetes/pki/etcd/ca.crt#更新资源清单 yaml 文件，安装 prometheus 和 alertmanager
vim prometheus-alertmanager-deploy.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:name: prometheus-servernamespace: monitor-salabels:app: prometheus
spec:replicas: 1selector:matchLabels:app: prometheuscomponent: server#matchExpressions:#- {key: app, operator: In, values: [prometheus]}#- {key: component, operator: In, values: [server]}template:metadata:labels:app: prometheuscomponent: serverannotations:prometheus.io/scrape: 'false'spec:nodeName: node01serviceAccountName: monitorcontainers:- name: prometheusimage: prom/prometheus:v2.2.1imagePullPolicy: IfNotPresentcommand:- "/bin/prometheus"args:- "--config.file=/etc/prometheus/prometheus.yml"- "--storage.tsdb.path=/prometheus"- "--storage.tsdb.retention=24h"- "--web.enable-lifecycle"ports:- containerPort: 9090protocol: TCPvolumeMounts:- mountPath: /etc/prometheusname: prometheus-config- mountPath: /prometheus/name: prometheus-storage-volume- name: k8s-certsmountPath: /var/run/secrets/kubernetes.io/k8s-certs/etcd/- name: localtimemountPath: /etc/localtime- name: alertmanagerimage: prom/alertmanager:v0.14.0imagePullPolicy: IfNotPresentargs:- "--config.file=/etc/alertmanager/alertmanager.yml"- "--log.level=debug"ports:- containerPort: 9093protocol: TCPname: alertmanagervolumeMounts:- name: alertmanager-configmountPath: /etc/alertmanager- name: alertmanager-storagemountPath: /alertmanager- name: localtimemountPath: /etc/localtimevolumes:- name: prometheus-configconfigMap:name: prometheus-config- name: prometheus-storage-volumehostPath:path: /datatype: Directory- name: k8s-certssecret:secretName: etcd-certs- name: alertmanager-configconfigMap:name: alertmanager- name: alertmanager-storagehostPath:path: /data/alertmanagertype: DirectoryOrCreate- name: localtimehostPath:path: /usr/share/zoneinfo/Asia/Shanghaikubectl delete -f prometheus-deploy.yaml
kubectl apply -f prometheus-alertmanager-deploy.yaml
kubectl get pods -n monitor-sa | grep prometheus
（4）部署 alertmanager 的 service，方便在浏览器访问
vim alertmanager-svc.yaml
---
apiVersion: v1
kind: Service
metadata:labels:name: prometheuskubernetes.io/cluster-service: 'true'name: alertmanagernamespace: monitor-sa
spec:ports:- name: alertmanagernodePort: 30066port: 9093protocol: TCPtargetPort: 9093selector:app: prometheussessionAffinity: Nonetype: NodePortkubectl apply -f alertmanager-svc.yaml#查看 service 在物理机映射的端口
kubectl get svc -n monitor-sa
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
alertmanager NodePort 10.105.125.219 <none> 9093:30066/TCP 38s
prometheus NodePort 10.107.188.51 <none> 9090:31000/TCP 23h
#此时可以看到 prometheus 的 service 在物理机映射的端口是 31000，alertmanager 的 service 在物理机映射的端口是 30066
浏览器访问 http://192.168.80.11:30066/#/alerts ，登陆 alertmanager
查看接收到的邮件报警，可以发现与 alertmanager 显示的告警一致
浏览器访问 http://192.168.80.11:31000 ，点击页面的 Status->Targets，查看 prometheus 的 targets
（3）处理 kube-proxy 监控告警
kubectl edit configmap kube-proxy -n kube-system
......
metricsBindAddress: "0.0.0.0:10249"
#因为 kube-proxy 默认端口10249是监听在 127.0.0.1 上的，需要改成监听到物理节点上#重新启动 kube-proxy
kubectl get pods -n kube-system | grep kube-proxy |awk '{print $1}' | xargs kubectl delete pods -n kube-systemss -antulp |grep :10249
tcp LISTEN 0 128 :::10249 :::* users:(("kube-proxy",pid=55675,fd=15))#alert 查看
点击 prometheus 页面的 Alerts，点开一个告警项，FIRING 表示 prometheus 已经将告警发给 alertmanager，在 Alertmanager 中可以看到有一个 alert。登录到 浏览器访问 http://192.168.80.11:30066/#/alerts ，登陆 alertmanager 即可看到。
