Engineering

Como usar o Prometheus para monitorar aplicativos e infraestrutura complexos

December 2, 2020

min

Tabela de conteúdo

Exemplo H2

O Prometheus é um software de monitoramento de código aberto projetado para monitorar aplicativos em contêineres em uma arquitetura de microsserviços. Dada a crescente complexidade da infraestrutura moderna, não é fácil rastrear o estado, a integridade e o desempenho de um aplicativo. A falha de um aplicativo pode afetar a capacidade de execução correta de outros aplicativos. O Prometheus ajuda a monitorar a condição, o desempenho ou qualquer métrica personalizada de um aplicativo ao longo do tempo, o que permite que um engenheiro evite situações inesperadas e melhore a funcionalidade geral da infraestrutura de microsserviços. No entanto, os engenheiros também podem usar o Prometheus para monitorar a infraestrutura monolítica.

Antes de nos aprofundarmos nos detalhes de Prometheus, devemos discutir alguns termos importantes:

Métrico: Um número com um nome, cuja medida tem um significado. Por exemplo: “cpu_usage = 1000 mícrons” é uma métrica.
Alvo: qualquer aplicativo em contêiner que exporte métricas no endpoint HTTP '/metrics' no formato Prometheus.
Exportador: uma biblioteca/código que converte métricas existentes no formato Prometheus.
Raspar: Extrair métricas do alvo fazendo uma solicitação HTTP.

Arquitetura Prometheus

O Prometheus tem três componentes principais:

Recuperação: esse componente é responsável por coletar as métricas de todos os alvos em intervalos de tempo configurados.
Série temporal DB: armazena as métricas coletadas em intervalos regulares de tempo como dados de séries temporais ou como um vetor.
Servidor HTTP: aceita consultas sobre dados de séries temporais como uma solicitação HTTP e retorna o resultado como uma resposta HTTP. A linguagem de consulta usada aqui é ProMQL.

Prometheus Architecture — Arquitetura Prometheus

Tipos métricos do Prometheus

O Prometheus fornece métricas diferentes. Destes, o contador, o medidor, o resumo e o histograma funcionam na maioria das situações. O trabalho do aplicativo é fornecer as métricas em um formato predefinido que o Prometheus entenda. É fácil publicar essas métricas do seu aplicativo usando as bibliotecas de cliente fornecidas. Atualmente, existem bibliotecas para linguagens populares como GO, Python, Java, Ruby etc.

Neste blog, abordaremos a versão python. No entanto, é fácil traduzir esses conceitos para outros idiomas.

Contador

Qualquer valor que aumente com o tempo, como contagem de solicitações HTTP, contagem de respostas de erro HTTP etc., pode usar métricas de contador. Uma métrica que pode diminuir nunca pode usar métricas contadoras. O contador tem a vantagem de consultar a taxa na qual o valor aumenta usando a função rate ().

No exemplo abaixo, estamos contando o número de chamadas de função para um python def:

de prometheus_client import start_http_server, Counter
importação aleatória
hora de importação

COUNTER = Counter ('function_calls', 'número de vezes que a função é chamada', ['module'])

def process_request (t):
 “" "Uma função fictícia que leva algum tempo." "”
 Counter.labels ('counter_demo') .inc ()
 time.sleep (t)

se __name__ == '__main__':
 start_http_server (8001)
 enquanto verdadeiro:
 solicitação_de_processo (random.random ())

Esse código gera uma contadora métrica chamada função_chamadas_total. Estamos incrementando função_chamadas_total toda vez que chamamos a função solicitação_de_processo. As métricas do Prometheus têm rótulos para identificar métricas semelhantes geradas por aplicativos diferentes. No código acima, função_chamadas_total tem um rótulo chamado módulo com um valor igual a counter_demo

A saída de

curl http://localhost:8001/metrics

será:

# HELP function_calls_total de vezes que a função é chamada
# DIGITE function_calls_total counter
function_calls_total {module="counter_demo "} 22.0
# HELP function_calls_created número de vezes que a função é chamada
# DIGITE o medidor function_calls_created
function_calls_created {module="counter_demo "} 1.6061945420716858e+09

Calibre

Qualquer valor que aumente ou diminua com o tempo usa métricas de medição, como uso da CPU, uso da memória e tempo de processamento.

No exemplo abaixo, estamos calculando o tempo gasto para a última chamada de função de python def process_request:

de prometheus_client, importe start_http_server, Gauge
importação aleatória
hora de importação

TIME = Gauge ('process_time', 'tempo gasto para cada chamada de função', ['módulo'])

def process_request (t):
 “" "Uma função fictícia que leva algum tempo." "”
 time.labels ('gauge_demo') .set (t)
 time.sleep (t)

se __name__ == '__main__':
 start_http_server (8002)
 enquanto verdadeiro:
 solicitação_de_processo (random.random ())

Suportes métricos de calibre set (x), inc (x) e dec (x) métodos para definir a métrica, incrementar a métrica e diminuir a métrica em x, respectivamente.

A saída de http://localhost:8002/metrics será:

# HELP python_info Informações sobre a plataforma Python
# DIGITE python_info gauge
python_info {implementation="cPython”, major="3", minor="9", patchlevel="0", version="3.9.0"} 1.0
# HELP process_time número de vezes que a função é chamada
# DIGITE process_time gauge
process_time {module="gauge_demo "} 0,4709189918033123

Histograma

O histograma tem compartimentos predefinidos de tamanhos diferentes, de 0,005 a 10. Por exemplo, se você quiser medir/observar a duração de cada solicitação HTTP que chega ao seu aplicativo, cada duração da solicitação pode estar em qualquer intervalo predefinido. Se a duração de uma solicitação for dez, o valor do intervalo de tamanho dez será incrementado em um. O histograma também tem a soma da duração de todas as solicitações e do número de solicitações.

No exemplo abaixo, estamos observando a duração de uma chamada de função de definição de python: process_request:

h = Histograma ('request_duration', 'Descrição do histograma', ['módulo'])
HIST = h.labels ('histogram_demo')

def process_request (t):
 “" "Uma função fictícia que leva algum tempo." "”
 Hist.observe (t)
 time.sleep (t)

A saída de curl http://localhost:8003/metrics será:

# HELP request_duration Descrição do histograma
# TIPO de histograma request_duration
request_duration_bucket {le="0,005", módulo="histogram_demo "} 0,0
request_duration_bucket {le="0,01", módulo="histogram_demo "} 0,0
request_duration_bucket {le="0,025", módulo="histogram_demo "} 0,0
request_duration_bucket {le="0,05", módulo="histogram_demo "} 2,0
request_duration_bucket {le="0,075", módulo="histogram_demo "} 3,0
request_duration_bucket {le="0,1", módulo="histogram_demo "} 3,0
request_duration_bucket {le="0,25", módulo="histogram_demo "} 5,0
request_duration_bucket {le="0,5", módulo="histogram_demo "} 9,0
request_duration_bucket {le="0,75", módulo="histogram_demo "} 11,0
request_duration_bucket {le="1.0", módulo="histogram_demo "} 16.0
request_duration_bucket {le="2.5", módulo="histogram_demo "} 16.0
request_duration_bucket {le="5.0", módulo="histogram_demo "} 16.0
request_duration_bucket {le="7,5", módulo="histogram_demo "} 16,0
request_duration_bucket {le="10,0", módulo="histogram_demo "} 16,0
request_duration_bucket {LE="+inf”, módulo="histogram_demo "} 16.0
request_duration_count {module="histogram_demo "} 16,0
request_duration_sum {module="histogram_demo "} 7.188765686771258
# HELP request_duration_created Descrição do histograma
# DIGITE o medidor request_duration_created
request_duration_created {module="histogram_demo "} 1.60620555290144e+09

request_duration_bucket são os intervalos de tamanho que variam de 0,005 a 10.
request_duration_sum é a soma das durações de cada chamada de função.
request_duration_count é o número total de chamadas de função.

Resumo

Um resumo é muito semelhante a um histograma, exceto que ele não armazena as informações do bucket, mas tem apenas a soma das observações e a contagem do total de observações.

No exemplo abaixo, estamos observando a duração de uma chamada de função de python def:

s = Resumo ('request_processing_seconds', 'Tempo gasto\ ') 
solicitação de processamento', ['módulo'])
SUMM = s.labels ('pymo')

@SUMM .time ()
def process_request (t):
 “" "Uma função fictícia que leva algum tempo." "”
 time.sleep (t)

A saída de curl http://localhost:8004/metrics será:

# HELP request_processing_seconds Tempo gasto processando a solicitação
# TIPO de resumo request_processing_seconds
request_processing_seconds_count {module="pymo "} 20,0
request_processing_seconds_sum {module="pymo "} 8.590708531
# HELP request_processing_seconds_created Tempo gasto processando a solicitação
# DIGITE o medidor request_processing_seconds_created
request_processing_seconds_created {module="pymo "} 1.606206054827252e+09

Configurando o Prometheus

Até agora, vimos os diferentes tipos de métricas e como gerá-las. Agora vamos ver como configurar o Prometheus para monitorar as métricas que desenvolvemos. O Prometheus usa um arquivo YAML para definir a configuração.


prometheus.yaml
global:
 intervalo de raspagem: 15s 
 intervalo_de_avaliação: 15s 
 scrape_timeout: 10s 
scrape_configs:
 - nome_do_trabalho: 'prometheus_demo'
 static_configs:
 - destinos: ['localhost:8001', 'localhost:8002', 'localhost:8003', 'localhost:8004']

As quatro seções de configuração primárias usadas na maioria das situações são:

intervalo de raspagem define o intervalo no qual o Prometheus raspa os alvos
intervalo_de_avaliação determina com que frequência o Prometheus avalia as regras definidas no arquivo de regras.
nome_do_trabalho definido será adicionado como um rótulo a qualquer série temporal extraída dessa configuração.
talvos definir a lista de endpoints HTTP para obter métricas

Iniciando o Prometheus

tar xvfz prometheus-*.tar.gz
. /prometheus --config.file=prometheus.yaml

Docker

docker run\
 -p 9090:9090\
 -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml\
 baile/prometheus

Acessando a UI

http://localhost:9090/graph

Você também pode ver dados de séries temporais como gráficos.

Alertando

Se você precisar de um alerta em function_calls_total > 100, precisará configurar regras de alerta e gerenciadores de alertas. O Prometheus usa outro arquivo YAML para definir regras de alerta.

alertrules.yaml
grupos:
- nome: exemplo
 regras:
 - alerta: exampleAlertName
 expr: function_calls_total {module="counter_demo "} > 100
 para: 10s
 rótulos:
 severidade: baixa
 anotações:
 resumo: exemplo de resumo

prometheus.yaml
global:
 intervalo de raspagem: 15s 
 intervalo_de_avaliação: 15s 
 scrape_timeout: 10s 
arquivos_regras:
 - alertrules.yml
scrape_configs:
 - nome_do_trabalho: 'prometheus_demo'
 static_configs:
 - destinos: ['localhost:8001', 'localhost:8002', 'localhost:8003', 'localhost:8004']

Depois de reiniciar o Prometheus com a nova configuração, você poderá ver os alertas listados na seção de alertas da interface do usuário do Prometheus. Mas esses alertas chegam ao seu canal ou e-mail do Slack somente se você configurar e configurar o gerenciador de alertas.