docker + prom + grafana + altermanager

conceptos básicos de docker

docker run -it --name centos -v $HOME:/tmp -p 8080:8080 centos

docker inspect container   #查看已启动容器启动命令

docker container prune    #删除退出的容器
docker ps -a --no-trunc    #查看容器启动参数

Dockerfile de verificación inversa

方法一：
docker history --format {{.CreatedBy}} --no-trunc=true 0e0218889c33|sed "s?/bin/sh\ -c\ \#(nop)\ ??g"|sed "s?/bin/sh\ -c?RUN?g" | tac

方法二：
apt-get install npm    #管理前端包工具
npm install npx
npx dockerfile-from-image node:8 > dockerfile   #解析dockerfile

Modificar el comando de inicio de la imagen del contenedor - Docker modifica el comando de inicio

#使用宿主机网络，并将容器名称修改为prometheus，-d后台运行
docker run -d -p 9090:9090 --name prometheus --net=host prom/prometheus

#将容器里文件拷贝出来到root目录
docker cp prometheus:/etc/prometheus/prometheus.yml /root/

#修改后挂载加进去
docker run -d -v /opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml   \
-p 9090:9090 --name prometheus --net=host prom/prometheus

docker logs contianid   #查看日志

docker search  java    #从docker hub中搜索java镜像，可以查看版本

Puerto de contenedores

9100 nodo de exportación
9090 prometheus
3000 grafana

puesta en marcha

• Iniciar exportador de nodos

docker run -d --name=node-exporter -p 9100:9100 prom/node-exporter

• Iniciar grafana

  密码：admin，admin；配置文件/etc/grafana
  docker run -d --name=grafana -p 3000:3000 grafana/grafana

• Iniciar prom

  
  #将容器里文件拷贝出来到root目录
  docker cp prometheus:/etc/prometheus/prometheus.yml /root/

# Después de la modificación, agregue el montaje a docker run -d -v /opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
-p 9090: 9090 --name prometheus --net = host prom / prometheus

# docker 镜像自启动
- 在运行docker容器时可以加如下参数来保证每次docker服务重启后容器也自动重启：

docker run --restart = always
Si se ha iniciado, puede usar el siguiente comando:
docker update --restart = always <ID DE CONTENEDOR>

# 配置文件
## prom配置
配置帮助
```yaml

global:
  #默认情况下抓取目标的频率.
  [ scrape_interval: <duration> | default = 1m ]

  # 抓取超时时间.
  [ scrape_timeout: <duration> | default = 10s ]

  # 评估规则的频率.
  [ evaluation_interval: <duration> | default = 1m ]

  # 与外部系统通信时添加到任何时间序列或警报的标签
  #（联合，远程存储，Alertma# nager）.
  external_labels:
    [ <labelname>: <labelvalue> ... ]

# 规则文件指定了一个globs列表. 
# 从所有匹配的文件中读取规则和警报.
rule_files:
  [ - <filepath_glob> ... ]

# 抓取配置列表.
scrape_configs:
  [ - <scrape_config> ... ]

# 警报指定与Alertmanager相关的设置.
alerting:
  alert_relabel_configs:
    [ - <relabel_config> ... ]
  alertmanagers:
    [ - <alertmanager_config> ... ]

# 与远程写入功能相关的设置.
remote_write:
  [ - <remote_write> ... ]

# 与远程读取功能相关的设置.
remote_read:
  [ - <remote_read> ... ]

Colocación específica

root@ubuntu:~# cat 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:
      # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_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.
    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

  - job_name: prometheus
    static_configs:
    - targets: ['192.168.191.128:9090']
      labels:
        instance: prometheus
  - job_name: 'consul' #prometheus与consul配置段
    consul_sd_configs:
      - server: '192.168.191.128:8500'
        services: [ ]
  - job_name: node-exporter
    static_configs:
    - targets: ['192.168.191.128:9100']
      labels:
        instance: node-exporter

Configuración dinámica file_sd_config:

• Modifique /usr/local/prometheus/*.json para agregar y eliminar, admitir actualización dinámica

  
  在prometheus.yaml配置文件最后增加
  - job_name: 'node-discorvery'   #发现规则名称
  file_sd_configs:                       #选择适配器
    - files: 
      - /usr/local/prometheus/*.json   #匹配文件

Agregue el directorio correspondiente /usr/local/prometheus/*.json, y el contenedor debe montarse cuando se inicie.
[
{
"Target": ["10.10.2.99:9100"],
"labels": {
"job": "linux- bj ",
" idc ":" bj-jiuxianqiao "
}
},
{
" objetivos ": [" 10.10.2.62:9100","10.10.1.35:9100 "],
" etiquetas ": {
" trabajo ":" linux- gx ",
" idc ":" gz-daxuecheng "
}
}
]

## rule_files:配置
- 配置告警规则，在prometheus.yml中指定规则文件目录
- prometheus根据这些规则信息，会推送报警信息到alertmanager中。
```yaml

alertmanager_config: configuración

• Especifique la instancia de Alertmanager a la que el servidor de Prometheus envía alertas
• Proporcione parámetros para configurar cómo comunicarse con estos Alertmanagers.
• Alertmanagers admite designación estática o designación de descubrimiento dinámico
• relabel_configs le permite seleccionar Alertmanagers de las entidades descubiertas y proporciona modificaciones avanzadas a la ruta de API utilizada, que se expone a través de la etiqueta __alerts_path__

  # Alertmanager configuration   #告警配置
  alerting:
  alertmanagers:  
  - static_configs:  #告警规则，也可以基于动态的方式进行告警。
  - targets:     
    # - alertmanager:9093

escritura_remota

Especifique la dirección de la API de escritura del almacenamiento de backend.

lectura_remota

Especifica la dirección api de lectura de almacenamiento del backend.

relabel_config

• Reetiquetar es una herramienta poderosa que puede reescribir dinámicamente el conjunto de etiquetas del objetivo antes de rastrear el objetivo. Cada configuración de rastreo se puede configurar con varios pasos de remarcado. Se aplican al conjunto de etiquetas de cada destino en el orden en que aparecen en el archivo de configuración. De forma predeterminada, puede ver las etiquetas relacionadas en la consola web de prometheus:
  

utilizar

uso de promtheus

node_cpu_seconds_total {cpu = "0"}

Usa grafana

dirección del panel de grafana

exportador prometheus

Monitoreo de procesos del exportador de procesos

docker search process-exporter   #查看排名最高的
docker pull opvizorpa/process-exporter   #下载
docker inspect 9ec6749205fc      #查看镜像启动配置信息:9256端口
apt-get install nginx         #安装nginx测试

docker run -d --rm -p 9256:9256 --privileged -v /proc:/host/proc -v `pwd`:/config ncabatoff/process-exporter --procfs /host/proc -config.path /config/filename.yml

# 本地安装
[root@host-10-10-2-62 ~]# wget https://github.com/ncabatoff/process-exporter/releases/download/v0.5.0/process-exporter-0.5.0.linux-amd64.tar.gz
[root@host-10-10-2-62 ~]# tar -xf process-exporter-0.5.0.linux-amd64.tar.gz -C /usr/local/

# 开机自启动
[root@host-10-10-2-62 process-exporter-0.5.0.linux-amd64]# cat /etc/systemd/system/process-exporter.service 
[Unit]
Description=node exporter
Documentation=node exporter

[Service]
ExecStart=/usr/local/process-exporter-0.5.0.linux-amd64/process-exporter -config.path /usr/local/process-exporter-0.5.0.linux-amd64/process-name.yaml 

[Install]
WantedBy=multi-user.target

# 配置文件根据变量名匹配到配置文件：  
{{.Comm}} 包含原始可执行文件的basename，/proc/stat 中的换句话说，2nd 字段  
{{.ExeBase}} 包含可执行文件的basename  
{{.ExeFull}} 包含可执行文件的完全限定路径  
{{.Matches}} 映射包含应用命令行tlb所产生的所有匹配项

# 增加监控nginx配置文件
root@ubuntu:~# cat process-name.yaml 
process_names:
  - name: "{{.Matches}}"
    cmdline:
    - 'nginx'

# 监控所有进程
[root@host-10-10-2-62 process-exporter-0.5.0.linux-amd64]# cat process-name.yaml 
process_names:
  - name: "{{.Comm}}"
    cmdline:
    - '.+'

# prometheus server添加监控
  - job_name: 'process'
    static_configs: 
      - targets: ['10.10.2.62:9256']

# 进程查询
统计有多少个进程数：sum(namedprocess_namegroup_states)

统计有多少个僵尸进程：sum(namedprocess_namegroup_states{state="Zombie"})

puerta de entrada

Configuración

pasarela 9091

docker pull prom/pushgateway

docker run -d \
--name=pushgateway \
-p 9091:9091 \
prom/pushgateway

访问ip+9091

prometheus配置文件中prometheus.yml添加target：
  - job_name: pushgateway
    static_configs:
      - targets: ['192.168.191.128:9091']
        labels:
          instance: pushgateway

URL:http://<ip>:9091/metrics/job/<JOBNAME>{/<LABEL_NAME>/<LABEL_VALUE>}，

Prueba de datos push

echo "some_metric 3.14" | curl --data-binary @- http://192.168.191.128:9091/metrics/job/some_job

# 一次性推送多条数据
cat <<EOF | curl --data-binary @http://192.168.2.14:9091/metrics/job/some_job/instance/some_instance
 # TYPE some_metric counter
 some_metric{label="val1"} 42
# TYPE another_metric gauge
# HELP another_metric Just an example.
another_metric 2398.283
EOF

• Se puede encontrar que los datos en pushgateway generalmente están agrupados y clasificados por trabajo e instancia, por lo que estos dos parámetros son indispensables.

Cuente las conexiones concurrentes tcp actuales y empújelas para pushgateway

[root@host-10-10-2-109 ~]# cat count_netstat_esat_connections.sh 
#!/bin/bash
instance_name=`hostname -f | cut -d'.' -f1`  #获取本机名，用于后面的的标签
label="count_netstat_established_connections"  #定义key名
count_netstat_established_connections=`netstat -an | grep -i ESTABLISHED | wc -l`  #获取数据的命令
echo "$label: $count_netstat_established_connections"
echo "$label  $count_netstat_established_connections" | curl --data-binary @- http://10.10.2.109:9091/metrics/job/pushgateway_test/instance/$instance_name

• La etiqueta del nombre de dominio representa el nombre de la etiqueta, seguido del valor. La definición detrás de Job es pushgateway_test (consistente con la definición de prometheus, nombre de dominio), y la variable instance_name representa el nombre de host.

• Aquellos que tienen ojos agudos encontrarán que parece haber algo mal aquí. El nombre del trabajo del indicador que se acaba de enviar es exported_job = "pushgateway_test", y el trabajo se muestra como job = "pushgateway". Esto obviamente no es correcto. Entonces, ¿cuál es la razón de esto? De hecho, está determinado por un parámetro honor_labels (el valor predeterminado es falso) en la configuración de Prometheus.

  - job_name: pushgateway
    honor_labels: true
    static_configs:
      - targets: ['10.10.2.109:9091'] 
        labels:
          instance: pushgateway 

Empuje de datos de la puerta de enlace de la interfaz Python

1、安装prometheus\_client模块：
apt install python-pip
pip install prometheus_client

2、简单示例文件：

[root@host-10-10-2-109 ~]# cat client.py 
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway
registry = CollectorRegistry()
g = Gauge('job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry)
g.set_to_current_time()
push_to_gateway('localhost:9091', job='batchA', registry=registry)
#执行脚本
[root@host-10-10-2-109 ~]# python client.py 

3. Resultados de la consulta:

4.Haga un pequeño cambio y obtenga los datos de ping:

[root@host-10-10-2-109 ~]# cat client_ping.py 
#!/usr/bin/python
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway
registry = CollectorRegistry()
g = Gauge('ping', 'pingtime',['dst_ip','city'], registry=registry) #Guage(metric_name,HELP,labels_name,registry=registry)
g.labels('192.168.1.10','shenzhen').set(42.2)    #设置标签
g.labels('192.168.1.11','shenzhen').set(41.2)
g.labels('192.168.1.12','shenzhen').set(32.1)  
push_to_gateway('localhost:9091', job='ping_status', registry=registry)
[root@host-10-10-2-109 ~]# python client_ping.py 

promql

Vector de rango

• s - segundos
• m - minutos
• h - horas
• d - días
• w - semanas
• Operación por turnos de años y años :
  prometheus_http_requests_total{handler="/api/v1/query"}[5m]
  

  prometheus_http_requests_total{} offset 5m #返回5分钟前的样本，瞬时位移
  prometheus_http_requests_total{}[1d] offset 1d  #返回昨天一天的数据样本，区间位移

Valor de coma flotante escalar

Los valores de coma flotante escalar se pueden escribir directamente en forma [-](digits)[.(digits)].

例如： 20
Un escalar tiene solo un número y no tiene tiempo. Cabe señalar que cuando se usa la expresión count (http_requests_total), el tipo de datos devuelto sigue siendo un vector instantáneo. El usuario puede convertir un único vector instantáneo en un escalar a través de la función integrada escalar ().

Cadena: cadena

"this is a string"
'these are unescaped: \n \\ \t'
`these are not unescaped: \n ' " \t`

Operador promql

Además de usar PromQL para consultar y filtrar convenientemente series de tiempo, PromQL también admite una gran cantidad de operadores, los usuarios pueden usar estos operadores para procesar aún más la secuencia de eventos. Estos operadores incluyen: operadores matemáticos, operadores lógicos, operadores booleanos, etc.

cálculo

Todos los operadores matemáticos admitidos por PromQL son los siguientes:

 + (加法)
  - (减法)
  * (乘法)
  / (除法)
  % (求余)
  ^ (幂运算)

Por ejemplo, si consultamos el tamaño de la memoria del host, se devuelven Bytes. Si quiero convertirlo a G, puedo usar la siguiente expresión:

node_memory_MemTotal_bytes / 1024 /1024 /1024

El resultado devuelto es un vector instantáneo. El cálculo matemático entre dos vectores instantáneos es, por ejemplo:

node_disk_written_bytes_total + node_disk_read_bytes_total #返回的是多块磁盘之间的读写IO

Luego encontraremos que las operaciones matemáticas se realizan en base a la etiqueta de la expresión para calcular el disco io de vda y vdb respectivamente.

Operación booleana

En PromQL, a través del modo de coincidencia de etiquetas, los usuarios pueden consultarlas según las dimensiones características de la serie temporal. La operación booleana permite a los usuarios filtrar la serie de tiempo según el valor de la muestra en la serie de tiempo, que se usa a menudo en nuestras reglas de alarma.

Prometheus admite los siguientes operadores booleanos de la siguiente manera:

 == (相等)
 != (不相等)
 > (大于)
 < (小于)
 >= (大于等于)
 <= (小于等于)

Utilice el modificador bool para devolver resultados de consulta coincidentes:

Por ejemplo: a través de operadores matemáticos, podemos calcular fácilmente el uso de memoria actual de todos los nodos del host:

(node_memory_bytes_total - node_memory_free_bytes_total) / node_memory_bytes_total

Cuando escribimos las reglas de alarma, necesitamos filtrar los hosts cuyo uso de memoria excede el 95%, puede usar expresiones booleanas:

(node_memory_bytes_total - node_memory_free_bytes_total) / node_memory_bytes_total > 0.95

Establecer operador

La expresión de vector instantáneo se puede utilizar para obtener un conjunto que contiene múltiples series de tiempo, que llamamos vector instantáneo. A través de operaciones de conjuntos, las operaciones de conjuntos correspondientes se pueden realizar entre dos vectores instantáneos y vectores instantáneos. Actualmente, Prometheus admite los siguientes operadores de conjuntos:

and (并且)
or (或者)
unless (排除)

vector1 y vector2 generarán un nuevo vector compuesto por los elementos de vector1. Este vector contiene elementos en vector1 que coinciden exactamente con los de vector2.

vector1 o vector2 generará un nuevo vector que contiene todos los datos de muestra en vector1 y los datos de muestra en vector2 que no coinciden con vector1.

vector1 a menos que vector2 genere un nuevo vector, y los elementos en el nuevo vector se componen de elementos en vector1 que no coinciden con vector2.

Precedencia del operador

En el sistema Prometheus, el orden de prioridad de los operadores binarios de mayor a menor es:

 ^
*, /, %
 +, -
 ==, !=, <=, <, >=, >
 and, unless
or

Los operadores con la misma precedencia son asociativos (asociativos por la izquierda). Por ejemplo, 2 3% 2 es equivalente a (2 3)% 2. El operador ^ es una excepción, ^ satisface la asociatividad derecha, por ejemplo, 2 ^ 3 ^ 2 es equivalente a 2 ^ (3 ^ 2).

Operación de agregación

Prometheus también proporciona los siguientes operadores de agregación integrados, que actúan sobre vectores instantáneos. Los datos de muestra devueltos por la expresión instantánea se pueden agregar para formar una nueva serie de tiempo.

 sum (求和)
 min (最小值)
 max (最大值)
 avg (平均值)
 stddev (标准差)
 stdvar (标准差异)
 count (计数)
 count_values (对value进行计数)
 bottomk (后n条时序)
 topk (前n条时序)
 quantile (分布统计)

La sintaxis para usar operaciones de agregación es la siguiente:

<aggr-op>([parameter,] <vector expression>) [without|by (<label list>)]

Entre ellos, solo los parámetros de soporte count_values, quantile, topk y bottomk.

sin se utiliza para eliminar las etiquetas enumeradas de los resultados del cálculo y conservar otras etiquetas. By es lo opuesto. Solo las etiquetas enumeradas se mantienen en el vector de resultados y las etiquetas restantes se eliminan. Por fuera y por, los datos se pueden agregar de acuerdo con el problema de la muestra.

sum(http_requests_total) without (instance)
等于：
sum(http_requests_total) by (code,handler,job,method)

Si solo necesita calcular la cantidad total de solicitudes HTTP para toda la aplicación, puede usar directamente la expresión:

sum(http_requests_total)
查询数据的平均值：
avg(http_requests_total)
查询最靠前的3个值：
topk(3, http_requests_total)

Funciones comunes

Prometheus proporciona muchas funciones de cálculo para diferentes tipos de datos. Un pequeño truco es encontrar el tipo de datos del contador. Antes de realizar cualquier operación, coloque una función de tasa () o aumento (). Estas son algunas de las funciones más utilizadas para ayudar a comprender:

función aumentar () :

Esta función se utiliza con el tipo de datos del contador para obtener la primera y la última muestra en el vector de intervalo y devolver su crecimiento. Si divide por un tiempo determinado, puede obtener la tasa de crecimiento promedio durante ese tiempo:

increase(node_cpu_seconds_total[2m]) / 120 # Uso promedio de CPU del nodo anfitrión en los últimos dos minutos

función rate () :

Esta función se usa con datos de tipo contador, tomando el incremento promedio por segundo del contador en este período de tiempo.

rate(node_cpu_seconds_total[2m]) #直接计算区间向量在时间窗口内平均增长速率

función suma () :

En el trabajo real, la mayoría de las CPU son de múltiples núcleos, y node_cpu mostrará los datos de cada núcleo por separado. De hecho, no nos importa la situación individual de cada núcleo, sino la situación general de la CPU. Después de usar la función sum () para resumir, puede obtener un total de datos, pero sum () suma los datos de todas las máquinas, por lo que puede sacar por (instancia) o por (cluster_name) nuevamente. Datos de CPU de un solo servidor o un grupo de servidores. La fórmula anterior se puede convertir en:

sum( increase(node_cpu_seconds_total[1m]) ) #先找出每一个，然后再合并

Topk () : esta función puede extraer el valor N superior de una gran cantidad de datos, y N se puede personalizar. Por ejemplo, si monitorea 320 CPU de 100 servidores, puede usar esta función para ver las que tienen mayor carga de corriente para alarma:

topk(3, http_requests_total) #统计最靠前的3个值。

Función predict_linear () : Calcula la tasa de cambio de la curva y juega un papel predictivo determinado. Por ejemplo, la tasa de disponibilidad del disco de la hora actual ha disminuido drásticamente. Esta situación puede hacer que el disco se llene rápidamente. En este momento, puede usar esta función para predecir el estado de las próximas horas con los datos de la hora actual para lograr una alerta temprana. :

predict_linear( node_filesystem_free_bytes{mountpoint="/"}[1h],4*3600 ) < 0 #如果未来4小时后磁盘使用率为负数就会报警

Desmontaje de la expresión de utilización de la CPU

1. Primero busque la clave, por ejemplo, para verificar el uso de la CPU, luego se debe usar la clave node_cpu

2. Filtre el tiempo de CPU inactivo y todo el tiempo de CPU según la clave node_cpu, y use {} para filtrar

node_cpu_seconds_total{ mode='idle' }  #找出空闲CPU的值
node_cpu_seconds_total  #不写其他参数代表ALL

3. Utilice la función de aumento () para capturar los datos de 1 minuto En este momento, se eliminan los datos de cada CPU.

increase(node_cpu_seconds_totalmode='idle'}[1m])

4. Utilice la función sum () para sumar los datos de cada CPU para obtener un solo dato:

sum( increase(node_cpu_seconds_total{mode='idle'}[1m]) )

5. Aunque la función sum () suma los datos de cada CPU, también suma los datos de cada servidor. Los datos de la CPU de todos los servidores son iguales y deben procesarse una vez. Aquí viene una nueva función por (instancia). Dividirá la suma de la suma de acuerdo con el método especificado, y la instancia representa el nombre de la máquina. Si no escribe por (instancia), debe especificar qué datos de instancia se necesitan en {}.

sum( increase(node_cpu_seconds_total{mode='idle'}[1m]) ) by (instance) #空闲CPU一分钟增量

6. Obtenga el porcentaje de tiempo inactivo de la CPU:

sum(increase(node_cpu_seconds_total{mode="idle"}[1m])) by(instance) /sum(increase(node_cpu_seconds_total[1m])) by(instance)

7. Utilización de CPU:

1-(sum(increase(node_cpu_seconds_total{mode="idle"}[1m])) by(instance) /sum(increase(node_cpu_seconds_total[1m])) by(instance)) * 100

El cálculo final puede ser negativo, y muchas plantillas de granafa pueden ser así: cuando la CPU está en una situación de múltiples núcleos y baja carga, la diferencia de valor se amplificará, lo que dará como resultado un número negativo.

Varias expresiones de uso común

1. Calcule la tasa de utilización de la CPU:

100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance) * 100)

2. Uso de memoria:

(node_memory_MemFree_bytes+node_memory_Cached_bytes+node_memory_Buffers_bytes) / node_memory_MemTotal_bytes * 100

3. Uso del disco

100 - (node_filesystem_free_bytes{mountpoint="/",fstype=~"ext4|xfs|rootfs"} / node_filesystem_size_bytes{mountpoint="/",fstype=~"ext4|xfs|rootfs"} * 100)

4. El porcentaje de CPU del nodo host iowait:
avg(irate(node_cpu_seconds_total{mode="iowait"}[5m])) by (instance) * 100

5. La carga del sistema en 1 minuto:
sum by (instance) (node_load1)

6. Tráfico de tarjetas de red:
avg(irate(node_network_receive_bytes_total{device=~"eth0|eth1|ens33|ens37"}[1m]))by (environment,instance,device)

Blog de referencia

-Análisis de imagen oficial de Alinode y extracción de Dockerfile | Sitio de prueba de tecnología
web-Hub.docker.com para grafana en docker, el documento de ayuda oficial
ncabatoff / process-exporter: Prometheus exporter