docker + prom + grafana + altergerenciador

noções básicas do docker

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

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

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

Verificação reversa do dockerfile

方法一：
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

Modifique o comando de inicialização da imagem do contêiner - docker modifique o comando de inicialização

#使用宿主机网络，并将容器名称修改为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镜像，可以查看版本

Porto de contêineres

9100 node-export
9090 prometheus
3000 grafana

comece

• Iniciar exportador de nó

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

• Começar grafana

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

• Começar o baile

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

#Modifique a montagem e adicione-a no 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
Se tiver sido iniciado, você pode usar o seguinte comando:
docker update --restart = always <CONTAINER ID>

# 配置文件
## 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> ... ]

Posicionamento específico

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

Configuração dinâmica file_sd_config:

• Modifique /usr/local/prometheus/*.json para adicionar e excluir, oferecer suporte à atualização dinâmica

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

Adicione no diretório correspondente /usr/local/prometheus/*.json, e o contêiner precisa ser montado quando for iniciado.
[
{
"Targets": ["10.10.2.99:9100"],
"labels": {
"job": "linux- bj ",
" idc ":" bj-jiuxianqiao "
}
},
{
" targets ": [" 10.10.2.62:9100","10.10.1.35:9100 "],
" labels ": {
" job ":" linux- gx ",
" idc ":" gz-daxuecheng "
}
}
]

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

alertmanager_config: configuração

• Especifique a instância do Alertmanager para a qual o servidor Prometheus envia alertas
• Fornece parâmetros para configurar como se comunicar com esses Alertmanagers.
• Os Alertmanagers suportam designação estática ou designação de descoberta dinâmica
• relabel_configs permite que você selecione Alertmanagers das entidades descobertas e fornece modificações avançadas para o caminho da API usado, que é exposto por meio do rótulo __alerts_path__

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

remote_write

Especifique o endereço de API de gravação do armazenamento de back-end.

remote_read

Especifique o endereço da API de leitura do armazenamento de back-end.

relabel_config

• A reclassificação é uma ferramenta poderosa que pode reescrever dinamicamente o conjunto de tags do alvo antes de rastrear o alvo. Cada configuração de rastreamento pode ser configurada com várias etapas de remarcação. Eles são aplicados ao conjunto de tags de cada destino na ordem em que aparecem no arquivo de configuração. Por padrão, você pode ver as tags relacionadas no console da web do prometheus:
  

usar

uso promtheus

node_cpu_seconds_total {cpu = "0"}

Usar grafana

endereço do painel da grafana

exportador prometheus

Monitoramento do processo exportador de processo

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"})

portão de embarque

Configuração

pushgateway 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>}，

Teste de dados 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

• Pode-se constatar que os dados em pushgateway costumam ser agrupados e classificados por job e instância, portanto esses dois parâmetros são indispensáveis.

Conte as conexões concorrentes tcp atuais e envie-as 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

• O rótulo no nome de domínio representa o nome do rótulo, seguido pelo valor. A definição por trás de Job é pushgateway_test (consistente com a definição de prometheus, nome de domínio), e a variável instance_name representa o nome do host.

• Aqueles que são mais perspicazes descobrirão que parece haver algo errado aqui. O nome da tarefa do indicador que acabou de enviar é export_job = "pushgateway_test" e a tarefa é exibida como job = "pushgateway". Obviamente, isso não está correto. Qual é a razão para isso? Na verdade, ele é determinado por um parâmetro honor_labels (o padrão é false) na configuração do Prometheus.

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

Pushgateway de dados da interface 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 da consulta:

4. Faça uma pequena alteração e obtenha os dados 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

Vetor de alcance

• s - segundos
• m - minutos
• h - horas
• d - dias
• w - semanas
• Operação de turno de y-anos :
  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 ponto flutuante escalar

Os valores de ponto flutuante escalar podem ser escritos diretamente no formulário [-](digits)[.(digits)].

例如： 20
Um escalar tem apenas um número e nenhum tempo. Deve-se notar que ao usar a expressão count (http_requests_total), o tipo de dado retornado ainda é um vetor instantâneo. O usuário pode converter um único vetor instantâneo em um escalar por meio da função embutida scalar ().

String: string

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

Operador Promql

Além de usar o PromQL para consultar e filtrar convenientemente as séries temporais, o PromQL também oferece suporte a uma variedade de operadores. Os usuários podem usar esses operadores para processar posteriormente a sequência de eventos. Esses operadores incluem: operadores matemáticos, operadores lógicos, operadores booleanos e assim por diante.

computação

Todos os operadores matemáticos suportados pelo PromQL são os seguintes:

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

Por exemplo, se consultarmos o tamanho da memória do host, Bytes é retornado. Se eu quiser convertê-lo para G, posso usar a seguinte expressão:

node_memory_MemTotal_bytes / 1024 /1024 /1024

O resultado retornado é um vetor instantâneo. O cálculo matemático entre dois vetores instantâneos é por exemplo:

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

Então, descobriremos que as operações matemáticas são realizadas com base no rótulo da expressão para calcular o io de disco de vda e vdb, respectivamente.

Operação booleana

No PromQL, através do modo de correspondência de tags, o usuário pode consultá-los de acordo com as dimensões características da série temporal. A operação booleana permite que os usuários filtrem a série temporal com base no valor da amostra na série temporal, que é frequentemente usada em nossas regras de alarme.

O Prometheus oferece suporte aos seguintes operadores booleanos:

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

Use o modificador bool para retornar resultados de consulta correspondentes:

Por exemplo: por meio de operadores matemáticos, podemos calcular facilmente o uso de memória atual de todos os nós do host:

(node_memory_bytes_total - node_memory_free_bytes_total) / node_memory_bytes_total

Quando escrevemos as regras de alarme, precisamos filtrar os hosts cujo uso de memória excede 95%, você pode usar expressões booleanas:

(node_memory_bytes_total - node_memory_free_bytes_total) / node_memory_bytes_total > 0.95

Definir operador

A expressão vetorial instantânea pode ser usada para obter um conjunto contendo várias séries temporais, que chamamos de vetor instantâneo. Através das operações de ajuste, as operações de ajuste correspondentes podem ser realizadas entre dois vetores instantâneos e vetores instantâneos. Atualmente, o Prometheus oferece suporte aos seguintes operadores de conjunto:

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

vector1 e vector2 irão gerar um novo vetor composto pelos elementos de vector1. Este vetor contém elementos no vetor1 que correspondem exatamente aos do vetor2.

vector1 ou vector2 irá gerar um novo vetor que contém todos os dados de amostra em vector1 e os dados de amostra em vector2 que não correspondem a vector1.

vector1, a menos que o vector2 gere um novo vector e os elementos no novo vector são compostos por elementos no vector1 que não correspondem ao vector2.

Operador precedente

No sistema Prometheus, a ordem de prioridade dos operadores binários de alto a baixo é:

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

Operadores com a mesma precedência são associativos (associativo à esquerda). Por exemplo, 2 3% 2 é equivalente a (2 3)% 2. O operador ^ é uma exceção. ^ Satisfaz a associatividade à direita. Por exemplo, 2 ^ 3 ^ 2 é equivalente a 2 ^ (3 ^ 2).

Operação de agregação

O Prometheus também fornece os seguintes operadores de agregação integrados, que atuam em vetores instantâneos. Os dados de amostra retornados pela expressão instantânea podem ser agregados para formar uma nova série temporal.

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

A sintaxe para usar as operações de agregação é a seguinte:

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

Entre eles, apenas count_values, quantile, topk e bottomk suportam parâmetros.

sem é usado para remover as marcas enumeradas dos resultados do cálculo e manter outras marcas. Por é o oposto. Apenas as tags listadas são mantidas no vetor de resultado e as tags restantes são removidas. Por dentro e por fora, os dados podem ser agregados de acordo com exemplos de perguntas.

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

Se você só precisa calcular a quantidade total de solicitações HTTP para todo o aplicativo, pode usar diretamente a expressão:

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

Funções comuns

O Prometheus fornece várias funções de cálculo para diferentes tipos de dados. Um pequeno truque é conhecer o tipo de dados do contador. Antes de fazer qualquer operação, coloque uma função taxa () ou aumentar (). Aqui estão algumas funções mais comumente usadas para ajudar a entender:

função aumentar () :

Esta função é usada com o tipo de dados contador para obter a primeira e a última amostra no vetor de intervalo e retornar seu crescimento. Se você dividir por um determinado período, poderá obter a taxa média de crescimento durante esse período:

increase(node_cpu_seconds_total[2m]) / 120 #Host node uso médio da CPU nos últimos dois minutos

função taxa () :

Esta função é usada com dados do tipo contador, obtendo o incremento médio por segundo do contador neste período de tempo.

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

função sum () :

No trabalho real, a maioria das CPUs são multi-core, e node_cpu exibirá os dados de cada core separadamente.Na verdade, não nos importamos com a situação individual de cada core, mas com a situação geral da CPU. Depois de usar a função sum () para somar, você pode obter um total de dados, mas sum () soma os dados de todas as máquinas, então você pode retirar por (instância) ou por (nome do cluster) novamente. Dados da CPU de um único servidor ou grupo de servidores. A fórmula acima pode evoluir para:

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

Topk () : esta função pode extrair o valor N superior de uma grande quantidade de dados e N pode ser personalizado. Por exemplo, se você monitora 320 CPUs de 100 servidores, pode usar esta função para visualizar aqueles com maior carga atual para alarme:

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

função Predict_linear () : Calcula a taxa de mudança da curva e desempenha um certo papel preditivo. Por exemplo, a taxa de disponibilidade de disco da hora atual caiu drasticamente. Essa situação pode fazer com que o disco fique cheio rapidamente. Nesse momento, você pode usar esta função para prever o estado das próximas horas com os dados atuais de uma hora para obter um aviso prévio :

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

Desmontagem da expressão de utilização da CPU

1. Descubra a chave primeiro, por exemplo, para verificar o uso da CPU, então você deve usar a chave node_cpu

2. Filtre o tempo ocioso da CPU e todo o tempo da CPU com base na chave node_cpu e use {} para filtrar

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

3. Use a função boost () para pegar os dados de 1 minuto, neste momento, os dados de cada CPU são retirados.

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

4. Use a função sum () para somar os dados de cada CPU para obter um único dado:

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

5. Embora a função sum () some os dados de cada CPU, ela também soma os dados de cada servidor.Os dados da CPU de todos os servidores são os mesmos e precisam ser processados ​​uma vez. Aí vem uma nova função por (instância). Ele irá dividir o valor da soma somada de acordo com o método especificado, e instância representa o nome da máquina. Se você não escrever por (instância), você precisa especificar quais dados de instância são necessários em {}.

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

6. Obtenha a porcentagem de tempo ocioso da CPU:

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

7. Utilização da CPU:

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

O cálculo final pode ser negativo e muitos modelos Granafa podem ser assim: Quando a CPU está em uma situação de multi-core e baixa carga, a diferença de valor será amplificada, resultando em um número negativo.

Várias expressões comumente usadas

1. Calcule a taxa de utilização da cpu:

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

2. Uso de memória:

(node_memory_MemFree_bytes+node_memory_Cached_bytes+node_memory_Buffers_bytes) / node_memory_MemTotal_bytes * 100

3. Uso do disco

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

4. A porcentagem de cpu iowait do nó host:
avg(irate(node_cpu_seconds_total{mode="iowait"}[5m])) by (instance) * 100

5. A carga do sistema em 1 minuto:
sum by (instance) (node_load1)

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

Blog de referência

-alinode análise de imagem oficial e extração de Dockerfile | Teste de tecnologia da Web
site-hub.docker.com para grafana em docker, o documento de ajuda oficial
ncabatoff / process-exporter: Prometheus exporter