Sistema de monitoreo Prometheus: te lo mereces

Prometheus es un sistema de monitoreo de servicios de código abierto y una base de datos de series temporales que proporciona un modelo de datos común e interfaces rápidas de recopilación, almacenamiento y consulta de datos. Su componente principal, el servidor Prometheus, extraerá periódicamente datos de objetivos de monitoreo configurados estáticamente o de objetivos configurados automáticamente en función del descubrimiento de servicios, y los datos recién extraídos se conservarán en el dispositivo de almacenamiento.

Cada host monitoreado puede proporcionar una interfaz para generar datos de monitoreo a través de un programa exportador dedicado. Recopilará datos de monitoreo en el destino y expondrá una interfaz HTTP para que el servidor Prometheus los consulte. Prometheus utiliza periódicamente métodos de extracción basados en HTTP. Datos recopilados sexualmente.
Si hay reglas de alarma, después de capturar los datos, se calcularán de acuerdo con las reglas. Si se cumplen las condiciones de alarma, se generará una alarma y se enviará a Alertmanager para completar el resumen y distribución de las alarmas.
Cuando el objetivo monitoreado necesita enviar datos activamente, el componente Pushgateway se puede usar para recibir y almacenar temporalmente los datos, y luego esperar a que el servidor Prometheus complete la recopilación de datos.

Cualquier objetivo monitoreado debe incluirse en el sistema de monitoreo con anticipación para la recopilación, el almacenamiento, las alarmas y la visualización de datos de series temporales. Los objetivos de monitoreo se pueden especificar de forma estática a través de la información de configuración, o Prometheus se puede administrar dinámicamente a través del mecanismo de descubrimiento de servicios.
Prometheus puede usar API Server directamente como un sistema de descubrimiento de servicios para descubrir y monitorear dinámicamente todos los objetos monitoreables en el clúster.

Prometheus 官网地址：https://prometheus.io

Prometheus github 地址：https://github.com/prometheus

2. Escenarios de aplicación

TSDB, como motor de almacenamiento de Prometheus, se adapta perfectamente al escenario de aplicación de monitoreo de datos
●La cantidad de datos almacenados es muy grande
●La mayoría de las veces es una operación de escritura
●Las operaciones de escritura se agregan casi secuencialmente, y la mayoría de las veces las los datos se clasifican por tiempo
●Muy Los datos rara vez se actualizan. En la mayoría de los casos, los datos se escribirán en la base de datos unos segundos o minutos después de su recopilación. ●
La operación de eliminación generalmente es una eliminación en bloque. Seleccione el tiempo histórico de inicio y especificar los bloques siguientes. Los datos en un momento determinado o en momentos aleatorios separados rara vez se eliminan.
● Los datos básicos son grandes y generalmente exceden el tamaño de la memoria. Generalmente, solo se selecciona una pequeña parte y no hay patrón, y el caché casi no tiene efecto. Las
operaciones de lectura son lecturas secuenciales muy típicas en orden ascendente o descendente
. Las operaciones de lectura altamente concurrentes son muy comunes.

3. Características de Prometeo

●Modelo de datos multidimensional : datos de series de tiempo identificados por nombres de métricas y pares clave-valor
Datos de series de tiempo: datos que registran los cambios de estado del sistema y del dispositivo en orden cronológico, cada dato se denomina muestra; datos de indicadores del servidor, datos de monitoreo del rendimiento de las aplicaciones, red Los datos, etc. son todos datos de series temporales.

●Base de datos de series temporales incorporada : Prometheus; el almacenamiento remoto externo generalmente usa: InfluxDB, OpenTSDB, etc.

●promQL es un lenguaje de consulta flexible que puede utilizar datos multidimensionales para completar consultas complejas.

● Recopilar datos de series temporales según el método de extracción HTTP.

●También es compatible con el componente PushGateway para recopilar datos.

●Descubrir objetivos a través de configuración estática o descubrimiento de servicios

●Admite el acceso a Grafana como fuente de datos.

4. Componentes ecológicos de Prometheus

Prometheus es responsable de la recopilación y el almacenamiento de datos de indicadores de series temporales, pero funciones como el análisis de datos, la agregación, la visualización y las alarmas no son responsables de Prometheus Server.
El ecosistema Prometheus contiene múltiples componentes, algunos de los cuales son opcionales:

(1) Servidor Prometheus: componente central del servicio

Los datos de monitoreo se recopilan mediante el método pull y se transmiten a través del protocolo http; se almacenan datos de series temporales y se generan notificaciones de alarma en función de "reglas de alarma".
El servidor Prometheus consta de tres partes: Recuperación, Almacenamiento, PromQL
● Recuperación : Responsable de capturar datos de indicadores de monitoreo en hosts de destino activos.
● Almacenamiento : Almacenamiento, que almacena principalmente los datos recopilados en el disco. El valor predeterminado es 15 días.
● PromQL : Es el módulo de lenguaje de consulta proporcionado por Prometheus.

(2) Biblioteca del cliente: Biblioteca del cliente

El propósito es proporcionar una ruta de desarrollo conveniente para aplicaciones que desean proporcionar funcionalidad de instrumentación de forma nativa para sistemas de medición integrados en la aplicación.

(3)Exportadores: indicador expuesto

Responsable de recopilar datos de indicadores de rendimiento de aplicaciones o servicios que no admiten la instrumentación integrada y proporcionárselos a Prometheus Server a través de la interfaz HTTP.
En otras palabras, el Exportador es responsable de recopilar y agregar datos en el formato original de la aplicación de destino y de convertir o agregar los indicadores al formato Prometheus para exposición externa.
Exportadores de uso común :
●Node-Exporter : se utiliza para recopilar datos de estado de indicadores físicos de los nodos del servidor, como carga promedio, CPU, memoria, disco, red y otros datos indicadores de información de recursos, que deben implementarse en todos los nodos informáticos.
Introducción detallada de indicadores: https://github.com/prometheus/node_exporter

●exportador-mysqld/exportador-nginx

●Kube-State-Metrics : un exportador que recopila datos de recursos K8S para Prometheus. Recopila datos de indicadores de estado de objetos de recursos en el clúster de Kubernetes escuchando APIServer, como pod, implementación, servicio, etc. Al mismo tiempo, también proporciona sus propios datos, principalmente el número de recopilaciones de recursos y estadísticas sobre el número de excepciones que ocurren durante la recopilación.
Cabe señalar que kube-state-metrics simplemente proporciona datos de métricas y no almacena estos datos de métricas, por lo que puede usar Prometheus para capturar estos datos y almacenarlos, centrándose principalmente en algunos metadatos relacionados con el negocio, como la implementación. Pod, estado de la réplica, etc.; ¿cuántas réplicas están programadas? ¿Cuantos hay disponibles ahora? ¿Cuántos Pods hay en estado de ejecución/detenido/terminado? ¿Cuántas veces se ha reiniciado el Pod? ¿Cuántos trabajos se están ejecutando?

●cAdvisor : se utiliza para monitorear información sobre los recursos utilizados dentro del contenedor, como CPU, memoria, E/S de red y E/S de disco.

●blackbox-exporter : monitorea la capacidad de supervivencia de los contenedores comerciales.

(4) Descubrimiento de servicios: descubrimiento de servicios

Utilizado para descubrir dinámicamente objetivos a monitorear, Prometheus admite múltiples mecanismos de descubrimiento de servicios: archivos, DNS, Consul, Kubernetes, etc. El descubrimiento de servicios se puede realizar a través de una interfaz proporcionada por un tercero. Prometheus consulta la lista de objetivos que deben monitorearse y luego sondea estos objetivos para obtener datos de monitoreo. Este componente actualmente es compatible con Prometheus Server.

(5) Alertmanager: Es un módulo de alarma independiente.

Después de recibir la "notificación de alarma" del servidor Prometheus, se deduplicará, agrupará y enrutará al destinatario correspondiente para emitir una alarma. Los métodos de recepción comunes incluyen: correo electrónico, DingTalk, WeChat corporativo, etc.
Prometheus Server solo es responsable de generar instrucciones de alarma. El comportamiento específico de la alarma es manejado por otra aplicación independiente, AlertManager. Las instrucciones de alerta son calculadas y generadas periódicamente por Prometheus Server en función de las reglas de alarma proporcionadas por el usuario. Después de que Alertmanager recibe las instrucciones de alarma de Servidor Prometheus, envía información de alarma a destinatarios de alarma según rutas de alarma definidas por el usuario.

(6) Pushgateway: similar a una estación de transferencia

El lado del servidor de Prometheus solo usará el método de extracción para extraer datos, pero algunos nodos solo pueden usar el método de inserción para enviar datos por algunas razones, por lo que se usa para recibir datos de inserción y exponerlos al retransmisión del servidor de Prometheus. .pararse.
Se puede entender que el host de destino puede informar datos de tareas a corto plazo a Pushgateway, y luego el servidor Prometheus extrae los datos de Pushgateway.

(7)Grafana

Es una herramienta de visualización y análisis de mediciones de código abierto multiplataforma que puede mostrar visualmente los datos recopilados y notificar al receptor de la alarma de manera oportuna. Su biblioteca oficial tiene una gran cantidad de complementos de panel.

5. Modo de trabajo de Prometheus

●Prometheus Server obtiene el objetivo (Target) a monitorear según el mecanismo de descubrimiento de servicios o la configuración estática, y recopila datos del indicador (Scrape) a través del exportador de indicadores en cada objetivo;

●Prometheus Server tiene un almacenamiento de series de tiempo basado en archivos incorporado para almacenar datos de indicadores de manera persistente. Los usuarios pueden usar la interfaz PromQL para recuperar datos y también pueden enviar requisitos de alarma a Alertmanager a pedido para completar el envío del contenido de la alarma;

●El ciclo de vida de algunos trabajos de ejecución corta es demasiado corto para proporcionar de manera efectiva los datos de indicador necesarios al servidor. Generalmente usan push (Push) para generar datos de indicador. Prometheus usa Pushgateway para recibir estos datos enviados y luego Fetch en el servidor. lado

6. Flujo de trabajo de Prometeo

(1) Prometheus toma Prometheus Server como núcleo y se utiliza para recopilar y almacenar datos de series temporales. Prometheus Server extrae datos del indicador del objetivo de monitoreo mediante el método pull, o extrae los datos recopilados al servidor Prometheus a través de pushgateway.
(2) El servidor Prometheus almacena los datos del indicador de monitoreo recopilados en el HDD/SSD local a través de TSDB.
(3) Los datos del indicador de monitoreo recopilados por Prometheus se almacenan en series de tiempo y la notificación de alarma activada se envía a Alertmanager mediante la configuración de reglas de alarma.
(4) Alertmanager envía alarmas por correo electrónico, DingTalk o WeChat corporativo configurando el receptor de alarmas.
(5) La propia interfaz de usuario web de Prometheus proporciona un lenguaje de consulta PromQL para consultar datos de monitoreo.
(6) Grafana se puede conectar a la fuente de datos de Prometheus para mostrar datos de monitoreo en forma gráfica.

7. Limitaciones de Prometeo

●Prometheus es un sistema de seguimiento de indicadores y no es adecuado para almacenar eventos y registros; muestra más seguimiento de tendencias que datos precisos;

●Prometheus cree que solo es necesario consultar los datos de monitoreo recientes. Su almacenamiento local solo está diseñado para almacenar datos a corto plazo (como un mes), por lo que no admite el almacenamiento de grandes cantidades de datos históricos. almacenar datos históricos a largo plazo, se
recomienda Guardar datos en sistemas como InfluxDB u OpenTSDB basados en mecanismos de almacenamiento remoto;

●El mecanismo de clúster de Prometheus no está muy maduro. Se pueden implementar clústeres federados y de alta disponibilidad de clústeres de Prometheus basados en Thanos o Cortex.

Dos: implementar Prometheus

1. Instalación del servidor Prometheust y configuración relacionada

(1) Cargue prometheus-2.35.0.linux-amd64.tar.gz al directorio /opt y descomprímalo

systemctl stop firewalld
setenforce 0

cd /opt/
tar xf prometheus-2.37.0.linux-amd64.tar.gz
mv prometheus-2.37.0.linux-amd64 /usr/local/prometheus

cat /usr/local/prometheus/prometheus.yml | grep -v "^#"
global:                    #用于prometheus的全局配置，比如采集间隔，抓取超时时间等
  scrape_interval: 15s            #采集目标主机监控数据的时间间隔，默认为1m
  evaluation_interval: 15s         #触发告警生成alert的时间间隔，默认是1m
  # scrape_timeout is set to the global default (10s).
  scrape_timeout: 10s            #数据采集超时时间，默认10s

alerting:                #用于alertmanager实例的配置，支持静态配置和动态服务发现的机制
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

rule_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) Configure el archivo de inicio del sistema e inicie 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=15d \
--web.enable-lifecycle
  
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

(3) Inicio

systemctl start prometheus
systemctl enable prometheus

netstat -natp | grep :9090

浏览器访问：http://192.168.231.100:9090 ，访问到 Prometheus 的 Web UI 界面
        点击页面的 Status -> Targets，如看到 Target 状态都为 UP，说明 Prometheus 能正常采集到数据
        http://192.168.231.100:9090/metrics ，可以看到 Prometheus 采集到自己的指标数据，其中 Help 字段用于解释当前指标的含义，Type 字段用于说明数据的类型

2. Implementar exportadores

Implemente Node Exporter para monitorear los indicadores a nivel del sistema
(1) Cargue node_exporter-1.3.1.linux-amd64.tar.gz al directorio /opt y descomprímalo

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) Configurar el archivo de inicio

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.tcpstat

ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl start node_exporter
systemctl enable node_exporter

netstat -natp | grep :9100

(3) Prueba de acceso

Acceso al navegador: http://192.168.231.100:9100/metrics, puede ver los datos del indicador recopilados por 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) Modifique el archivo de configuración de Prometheus y agréguelo al monitoreo de Prometheus

vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容
  - job_name: nodes
    metrics_path: "/metrics"
    static_configs:
    - targets:
      - 192.168.231.102:9100
      - 192.168.231.103:9100
      - 192.168.231.110:9100
      labels:
        service: kubernetes

(5) Recargar configuración

curl -X POST http://192.168.231.100:9090/-/reload    或    systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets

Tres: ejemplo de configuración de Monitor MySQL

1. Cargue mysqld_exporter-0.14.0.linux-amd64.tar.gz al directorio /opt y descomprímalo

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. Configurar archivos de inicio

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.cnf

ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

3. Modifique el archivo de configuración de MySQL.

vim /etc/my.cnf
[client]
......
host=localhost
user=exporter
password=abc123

4. Autorizar usuario exportador

mysql -uroot -pabc123
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost' IDENTIFIED BY 'abc123';

5. Reinicie el servicio

systemctl restart mysqld
systemctl start mysqld_exporter
systemctl enable mysqld_exporter

netstat -natp | grep :9104

6. Operar en el servidor Prometheus.

(1) Modifique el archivo de configuración de Prometheus y agréguelo al monitoreo de Prometheus

vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容
  - job_name: mysqld
    metrics_path: "/metrics"
    static_configs:
    - targets:
          - 192.168.231.101:9104
      labels:
        service: mysqld

(2) Recargar la configuración

curl -X POST http://192.168.231.100:9090/-/reload    或    systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets

Cuatro: ejemplo de configuración de Monitor 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. Descomprima el complemento 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. Instale Nginx

yum -y install pcre-devel zlib-devel openssl-devel gcc gcc-c++ make
useradd -M -s /sbin/nologin nginx

cd /opt
tar xf nginx-1.24.0.tar.gz

cd nginx-1.24.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-vts

make & make install

(1) Modifique el archivo de configuración de nginx e inicie 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_status
        listen 8080;
        allow 127.0.0.1;
        allow 192.168.231.100;            #设置为 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 -t

cat > /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
EOF

systemctl start nginx
systemctl enable nginx


浏览器访问：http://192.168.231.111:8080/status ，可以看到 Nginx Vhost Traffic Status 的页面信息

(2) Descomprima nginx-exporter e inicie 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/json

ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl start nginx-exporter
systemctl enable nginx-exporter

netstat -natp | grep :9913

3. Operar en el servidor Prometheus.

(1) Modifique el archivo de configuración de Prometheus y agréguelo al monitoreo de Prometheus

vim /usr/local/prometheus/prometheus.yml
#在尾部增加如下内容
  - job_name: nginx
    metrics_path: "/metrics"
    static_configs:
    - targets:
          - 192.168.231.111:9913
      labels:
        service: nginx

(2) Vuelva a cargar la configuración
curl -X POST http://192.168.231.100:9090/-/reload o systemctl vuelva a cargar
el navegador prometheus para ver el Estado -> Destinos de la página Prometheus

Cinco: implementar Grafana

1. Descargar e instalar

下载地址：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.231.100:3000 ，默认账号和密码为 admin/admin

2. Configurar la fuente de datos

Configuration -> Data Sources -> Add data source -> 选择 Prometheus
HTTP -> URL 输入 http://192.168.231.100:9090
点击 Save & Test

点击 上方菜单 Dashboards，Import 所有默认模板
Dashboards -> Manage ，选择 Prometheus 2.0 Stats 或 Prometheus Stats 即可看到 Prometheus job 实例的监控图像

3. Importar panel de seguimiento de grafana

浏览器访问：https://grafana.com/grafana/dashboards ，在页面中搜索 node exporter ，选择适合的面板，点击 Copy ID 或者 Download JSON

在 grafana 页面中，+ Create -> Import ，输入面板 ID 号或者上传 JSON 文件，点击 Load，即可导入监控面板

Seis: implementar el descubrimiento de servicios Prometheus

1. Descubrimiento de servicios basado en archivos

El descubrimiento de servicios basado en archivos es sólo ligeramente mejor que el descubrimiento de servicios de configuración estática y no depende de ninguna plataforma o servicio de terceros, por lo que también es el método de implementación más simple y común.
Prometheus Server carga periódicamente información de destino desde archivos. El archivo puede usar formatos YAML y JSON. Contiene una lista de destino definida e información de etiquetas opcional. (1) Cree un archivo para el descubrimiento de servicios y configure el destino requerido en el archivo

cd /usr/local/prometheus
mkdir targets

vim targets/node-exporter.yaml
- targets:
  - 192.168.231.102:9100
  - 192.168.231.103:9100
  labels:
    app: node-exporter
    job: node


vim targets/mysqld-exporter.yaml
- targets:
  - 192.168.231.101:9104
 
  labels:
    app: mysqld-exporter
    job: mysqld

#修改 prometheus 配置文件，发现 target 的配置，定义在配置文件的 job 之中
vim /usr/local/prometheus/prometheus.yml
......
scrape_configs:
  - job_name: nodes
    file_sd_configs:                  #指定使用文件服务发现
    - files:                          #指定要加载的文件列表
      - targets/node*.yaml            #文件加载支持通配符
      refresh_interval: 2m            #每隔 2 分钟重新加载一次文件中定义的 Targets，默认为 5m
  
  - job_name: mysqld
    file_sd_configs:
    - files:
      - targets/mysqld*.yaml
      refresh_interval: 2m


systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets

2. Descubrimiento de servicios basado en Consul

Consul es una herramienta de código abierto desarrollada en base a golang que proporciona principalmente funciones de registro de servicios, descubrimiento de servicios y gestión de configuración para sistemas distribuidos y orientados a servicios.
Proporciona funciones como registro/descubrimiento de servicios, verificación de estado, almacenamiento de claves/valores, centro de datos múltiples y garantía de coherencia distribuida.

下载地址：https://www.consul.io/downloads/

（1）部署 Consul 服务
cd /opt/
unzip consul_1.9.2_linux_amd64.zip
mv consul /usr/local/bin/

#创建 Consul 服务的数据目录和配置目录
mkdir /var/lib/consul-data
mkdir /etc/consul/

#使用 server 模式启动 Consul 服务
consul agent \
-server \
-bootstrap \
-ui \
-data-dir=/var/lib/consul-data \
-config-dir=/etc/consul/ \
-bind=192.168.80.30 \
-client=0.0.0.0 \
-node=consul-server01 &> /var/log/consul.log &

#查看 consul 集群成员
consul members

（2）在 Consul 上注册 Services
#在配置目录中添加文件
vim /etc/consul/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: nodes
    consul_sd_configs:                  #指定使用 consul 服务发现
    - server: 192.168.80.30:8500        #指定 consul 服务的端点列表
      tags:                             #指定 consul 服务发现的 services 中哪些 service 能够加入到 prometheus 监控的标签
      - nodes
      refresh_interval: 2m


systemctl reload prometheus
浏览器查看 Prometheus 页面的 Status -> Targets

#让 consul 注销 Service
consul services deregister -id="node_exporter-node02"

#重新注册
consul services register /etc/consul/nodes.json

3. Descubrimiento de servicios basado en la API de Kubernetes

El mecanismo de descubrimiento de servicios basado en la API de Kubernetes admite los objetos de recursos correspondientes en tipos de recursos como Nodo, Servicio, Punto final, Pod e Ingreso en el Servidor API como objetivos, y monitorea continuamente los cambios en los recursos relacionados.

●Los recursos de nodo, servicio, punto final, pod e ingreso se definen mediante sus respectivos mecanismos de descubrimiento.

●El componente responsable de descubrir cada tipo de objeto de recurso, llamado rol en Prometheus.

●Admite la implementación de node-exporter en el clúster basado en el controlador DaemonSet para descubrir cada nodo Node. También se puede utilizar como entrada para que Prometheus descubra cada nodo Node a través de kubelet.

#基于 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> ]