Introdução ao Prometheus

Monitoramento e Alerta para Ambientes Modernos

Introdução

Dando continuidade à discussão sobre Observabilidade e Monitoramento, vamos adentrar o universo do Prometheus, uma ferramenta poderosa que permite o monitoramento, coleta de métricas e alertas sobre o desempenho e a saúde de sistemas. O Prometheus é uma solução de código aberto, alinhada com os princípios da Cloud Native, caracterizando-se por sua alta escalabilidade e flexibilidade. Amplamente adotado pela comunidade de DevOps, o Prometheus oferece uma gama robusta de funcionalidades para monitoramento eficiente de infraestrutura e aplicações.

Neste artigo, vamos aprofundar nosso entendimento sobre o Prometheus, explorando seus conceitos fundamentais e apresentando um exemplo prático de como utilizá-lo para monitorar uma aplicação simples.O que é o Prometheus?

O que é o Prometheus?

O Prometheus é um sistema de monitoramento e alerta originalmente desenvolvido pelo SoundCloud em 2012. Desde então, foi adotado pela Cloud Native Computing Foundation (CNCF) e tornou-se uma das ferramentas de monitoramento mais populares na comunidade de desenvolvimento e operações.

Características

O Prometheus foi projetado com os seguintes princípios em mente:

• Modelo de dados dimensional: As métricas são identificadas por um nome e um conjunto de pares de chave/valor, chamados de rótulos, que permitem uma grande flexibilidade na modelagem e consulta das métricas.
• Coleta de dados multi-dimensional: O Prometheus coleta métricas de alvos (como aplicativos e sistemas) em intervalos regulares.
• Consulta flexível e poderosa: Ele oferece uma linguagem de consulta, chamada PromQL, que permite aos usuários realizar consultas complexas e ad-hoc sobre as métricas coletadas.
• Suporte para alertas: Além do monitoramento contínuo, o Prometheus permite configurar alertas com base em regras definidas pelo usuário, o que é crucial para a detecção precoce de problemas e ações proativas.

Componentes do Prometheus

Agora vamos começar a detalhar um pouco mais sobre como o Prometheus funciona internamente e quais são os diversos componentes que ele possui.

Essa imagem que estamos utilizando foi retirada do site oficial da documentação do Prometheus.

O Prometheus é composto por vários componentes, cada um desempenhando um papel específico no ecossistema de monitoramento:

1. Prometheus Server: Este é o núcleo do sistema, encarregado de coletar, armazenar e processar métricas. As métricas são medidas quantitativas que refletem o estado de um sistema em um determinado momento.
2. Prometheus Storage (TSDB): Trata-se de um banco de dados de séries temporais simples e eficiente, utilizado para armazenar as métricas coletadas ao longo do tempo.
3. Retrieval: Esse componente é responsável por acessar as aplicações configuradas, coletar suas métricas e armazenar os dados no TSDB (Time Series Database).
4. Exportadores (Exporters): São agentes que expõem métricas de sistemas e serviços que não estão diretamente compatíveis com o formato de métricas do Prometheus. Isso permite que o Prometheus colete essas métricas.
5. Pushgateway: Este componente possibilita que tarefas ou serviços enviem ativamente métricas para o Prometheus, em vez de esperar passivamente pelo Prometheus para coletá-las. Isso é particularmente útil para casos em que as métricas são geradas por jobs ou processos temporários que são executados rapidamente e não são facilmente detectados pelo Prometheus em seu ciclo de coleta padrão.
6. Service Discovery: A princípio, é necessário especificar todas as aplicações a serem monitoradas dentro de um arquivo de configuração do Prometheus. No entanto, o Service Discovery oferece uma opção para evitar essa configuração manual. Com ele, o Prometheus consegue descobrir automaticamente quais aplicações monitorar.
7. HTTP Server: Este componente, localizado no núcleo do Prometheus, é responsável por responder às requisições de uma API. Ele apresenta uma interface web (prometheus Web UI) que permite consultas ao banco de dados do Prometheus através da linguagem de consulta conhecida como PromQL. O PromQL é diferente do SQL tradicional, sendo uma linguagem peculiar e mais primitiva em comparação. É utilizada para interagir com a API disponibilizada pelo Prometheus. Essa API, além de promover a interoperabilidade com outras aplicações. Por exemplo, o Grafana faz uso da API e do PromQL para extrair dados e criar dashboards.
8. Prometheus Alertmanager: Esse componente gerencia os alertas disparados pelo Prometheus Server, roteando-os, silenciando-os, agrupando-os de acordo com regras de configuração e enviando-os para e-mails, serviços de monitoramento entre outras ferramentas de comunicação.

Conceitos Importantes

Conceitos são termos essenciais que vamos utilizar ao longo deste artigo e é válido formalizá-los para que vocês compreendam e assimilem o significado de cada um. Vamos lá!

Métricas: São medidas numéricas de dados relacionados aos elementos de uma aplicação ou à infraestrutura relacionada a ela. Geralmente, esses dados são numéricos e estão associados a uma linha temporal. Uma métrica representa o que você deseja monitorar, ou seja, o objeto do qual você quer obter informações. Por exemplo, podemos monitorar a quantidade de requisições feitas em nossa API ou o tempo que nossa API leva para responder. Um exemplo fora do escopo de aplicações de API poderia ser a temperatura do processador.

Tipos de Métricas

Outro conceito fundamental no Prometheus são os tipos de métricas. Existem apenas quatro tipos de métricas, e é possível modelar o monitoramento usando um desses quatro tipos. Vamos falar agora sobre cada um deles.

Contador: Funciona como uma variável que só aumenta, nunca diminui. Um exemplo seria o contador de chamadas feitas em sua API. O número de chamadas sempre aumenta; nunca diminui. Essa métrica do tipo contador é armazenada na memória da aplicação e é incrementada conforme recebe as requisições. Se a aplicação for reiniciada, o contador é zerado.

Gauge: É um valor que pode aumentar ou diminuir arbitrariamente ao longo do tempo. Por exemplo, a quantidade de memória livre em uma máquina ou a temperatura da CPU. Essas métricas podem variar aleatoriamente ao longo do tempo.

Histograma e Sumário: Ambos servem para medir a distribuição de uma métrica, como o tempo de resposta de uma aplicação. Medir apenas a média do tempo de resposta pode fornecer pouca informação, pois perde-se muitos detalhes. Tanto o histograma quanto o sumário permitem entender a distribuição dos dados. A diferença entre eles é sutil: o histograma mede a frequência de eventos em intervalos determinados, enquanto o sumário apresenta percentis específicos dos dados, como 50%, 90% e 99%.

Apesar de serem conceitos relativamente complexos, tanto o histograma quanto o sumário servem para o mesmo propósito final: entender a distribuição dos dados e melhorar o monitoramento da aplicação.

Labels: São variações das métricas, mas são distintas. Uma abordagem comum seria criar uma métrica diferente para cada possível variação. Por exemplo, para o contador de requisições feitas na API, poderíamos ter uma variação para o método GET e outra para o método POST, e assim por diante. No entanto, é preferível trabalhar com uma única métrica e variá-la utilizando rótulos (labels).

Exemplo:

# Métrica
http_requests_total {
  # Rótulos
  method="post", code="200"
}

Séries Temporais: Falando de forma simplificada, seria como uma tabela no banco de dados para armazenar uma determinada informação ao longo do tempo.

Amostras: Cada observação realizada em uma série temporal.

Scraping: É o ato de acessar uma aplicação e observar suas métricas. Geralmente, acessamos o endpoint /metrics da aplicação para coletar e salvar essas métricas no banco de dados de séries temporais. Essa ação é chamada de scraping.

Instalação do Prometheus

Para instalar o Prometheus no Ubuntu, você pode seguir os seguintes passos:

Passo 1: Baixar o Prometheus

1. Abra um terminal.
2. Baixe a última versão estável do Prometheus do site oficial:

wget https://github.com/prometheus/prometheus/releases/download/v2.34.0/prometheus-2.34.0.linux-amd64.tar.gz

Passo 2: Extrair o arquivo baixado

tar -xvzf prometheus-2.34.0.linux-amd64.tar.gz

Passo 3: Entrar no diretório Prometheus

cd prometheus-2.34.0.linux-amd64

Passo 4: Executar o Prometheus

./prometheus

Por padrão, o Prometheus usará a configuração padrão localizada no arquivo prometheus.yml.

Passo 5: Acessar o Prometheus UI

Abra um navegador da web e acesse http://localhost:9090 para acessar a interface do usuário do Prometheus.

Passo 6 (opcional): Configurar o Prometheus como um serviço do sistema

Se você deseja executar o Prometheus como um serviço do sistema, siga estes passos:

Crie um arquivo de serviço para o Prometheus:

sudo nano /etc/systemd/system/prometheus.service

Cole o seguinte conteúdo no arquivo:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target
[Service]
Type=simple
User=prometheus
Group=prometheus
ExecStart=~/prometheus-2.34.0.linux-amd64/prometheus --config.file=~/prometheus-2.34.0.linux-amd64/prometheus.yml
[Install]
WantedBy=multi-user.target

Certifique-se de substituir /caminho/para/o/seu/prometheus/ pelo caminho real onde o Prometheus está instalado.

Salve e feche o arquivo e carregue os serviços do systemd:

sudo systemctl daemon-reload

Inicie o serviço do Prometheus:

sudo systemctl start prometheus

Verifique o status do serviço para garantir que esteja em execução:

sudo systemctl status prometheus

Passo 7: Configurar Prometheus para iniciar automaticamente na inicialização

sudo systemctl enable prometheus

Agora o Prometheus estará configurado para iniciar automaticamente sempre que o sistema for reiniciado.

Instalação simplificada do Prometheus via Docker

Vamos aprender como instalar o Prometheus utilizando o Docker, que é um processo mais simples e rápido. Vamos lá!

Comando para Criar o Contêiner: O comando para criar o contêiner Docker do Prometheus é bastante simples. Abra o terminal e execute o seguinte comando:

docker run -d --name prometheus -p 9090:9090 prom/prometheus

Neste comando, estamos utilizando a imagem oficial do Prometheus disponível no Docker Hub. O parâmetro -d significa que o contêiner será executado em segundo plano (modo detached), o --name prometheus define o nome do contêiner como "prometheus" e -p 9090:9090 mapeia a porta 9090 do contêiner para a porta 9090 do seu computador, que é a porta padrão do Prometheus.

Acessando a Interface Web do Prometheus: Após executar o comando, o Docker irá baixar a imagem do Prometheus e iniciar o contêiner. Agora, você pode acessar a interface web do Prometheus digitando http://localhost:9090 em seu navegador.

Pesquisando métricas pré configuradas pelo Prometheus: Através do promQL faça uma pesquisa para verificar métricas pré configuradas pelo Prometheus,

Veficando a Configuração da métrica: É possível verificar a métrica através do endereço http://localhost:9090/metrics .

Personalizando a Configuração: Você pode personalizar a configuração do Prometheus passando um arquivo de configuração YAML personalizado para o contêiner. Para fazer isso, primeiro, crie um arquivo de configuração YAML conforme suas necessidades.

Por exemplo, suponha que você tenha um arquivo chamado prometheus.yml no diretório /path/to/config, e deseja montá-lo dentro do contêiner. O comando ficaria assim:

docker run -d --name prometheus -p 9090:9090 -v /pathlocal/to/config/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

Isso irá substituir o arquivo de configuração padrão do Prometheus dentro do contêiner pelo seu arquivo personalizado.

Reiniciando o Contêiner com uma Nova Configuração: Se você precisar fazer alterações na configuração do Prometheus, basta reiniciar o contêiner com o comando docker restart prometheus. Isso fará com que o Prometheus leia a nova configuração.

Exemplo Prático: Monitorando uma Aplicação com Prometheus

Vamos demonstrar um exemplo simples de como usar o Prometheus para monitorar uma aplicação NodeJS. Suponha que temos uma aplicação web em Node que deseja monitorar o tempo de resposta de uma página específica.

Entendendo o Formato de Métricas do Prometheus

Antes de começarmos, é importante entender o formato de métricas do Prometheus. Ele segue um padrão específico que consiste em um nome, zero ou mais pares de rótulos (labels) e um valor numérico. Por exemplo:

• nome_da_metrica{label1="valor1", label2="valor2"} 123

As métricas podem ser de diferentes tipos, como contadores, histogramas, entre outros.

Instrumentando a Aplicação

Para instrumentar nossa aplicação, precisamos adicionar código que registre métricas em pontos específicos do nosso código. Por exemplo, podemos adicionar contadores para contabilizar o número de requisições recebidas ou o tempo de execução de determinadas operações.

Vamos utilizar o exemplo de instrumentação em JavaScript, mas os conceitos podem ser aplicados a qualquer linguagem de programação. No site oficial do Prometheus, você pode encontrar bibliotecas oficiais e não oficiais para diversas linguagens de programação.

Exemplo em JavaScript

Para instrumentar nossa aplicação em JavaScript, vamos usar a biblioteca prom-client, que é uma das bibliotecas oficiais recomendadas pelo Prometheus.

Primeiro, instale a biblioteca prom-client em seu projeto:

• npm install prom-client

Em seguida, adicione o código de instrumentação em sua aplicação. Por exemplo, para registrar o tempo de resposta de uma requisição HTTP:

const prometheus = require('prom-client');
const express = require('express');

const app = express();
const port = 3000;
const register = prometheus.register;

// Registrar a métrica de tempo de resposta
const httpRequestDurationMicroseconds = new prometheus.Histogram({
    name: 'http_request_duration_seconds',
    help: 'HTTP request duration in seconds',
    labelNames: ['route'],
    buckets: [0.1, 0.3, 1, 1.5, 2, 3, 5] // Definindo intervalos de tempo
});

app.use((req, res, next) => {
    const start = Date.now();
    res.on('finish', () => {
        const duration = Date.now() - start;
        httpRequestDurationMicroseconds.labels(req.route.path).observe(duration / 1000);
    });
    next();
});

app.get('/', (req, res) => {
    res.send('Hello World!');
});

app.get('/metrics', async (req, res) => {
    res.set(`Content-Type`, register.contentType);
    res.end(await register.metrics());
})

app.listen(port, () => {
    console.log(`App listening at http://localhost:${port}`);
});

Este código registra o tempo de resposta de cada requisição HTTP e armazena a métrica http_request_duration_seconds no formato adequado para o Prometheus.

Visualizando as Métricas

Depois de instrumentar a aplicação, você pode iniciar o servidor e acessar as métricas no endpoint padrão /metrics. Por exemplo, se estiver utilizando o Express.js, você pode acessar http://localhost:3000/metrics para visualizar as métricas registradas.

Rodando a aplicação

http://localhost:3000

http://localhost/metrics

Configurando o Prometheus

Por fim, é necessário configurar o Prometheus para coletar as métricas da sua aplicação. Você pode adicionar o endpoint /metrics da sua aplicação ao arquivo de configuração do Prometheus para que ele possa fazer scraping das métricas.

global:
  scrape_interval:     15s 
scrape_configs:
  - job_name: 'node-app'
    static_configs:
      - targets: ['localhost:3000']

Pare o container, remova-o e crie o mesmo novamente.

Consultando as métricas coletadas

Finalmente, podemos visualizar as métricas coletadas no Prometheus UI, acessando http://localhost:9090. Podemos escrever consultas PromQL para analisar essas métricas e configurar alertas conforme necessário.

Um pouquinho de PromQL

Com PromQL (Prometheus Query Language), você pode fazer uma variedade de consultas para analisar as métricas coletadas. Aqui estão alguns exemplos de consultas que você pode fazer:

Seleção de Métricas: Você pode selecionar métricas específicas usando seus nomes. Por exemplo, para selecionar todas as métricas que começam com http_, você pode usar:

http_*

Agregação de Métricas: Você pode agregar métricas usando funções como sum(), avg(), min(), max(), etc. Por exemplo, para calcular a soma das métricas http_requests_total, você pode usar:

sum(http_requests_total)

Filtragem de Métricas: Você pode filtrar métricas com base em rótulos usando operadores como ==, !=, =~, !~. Por exemplo, para selecionar apenas as métricas com o rótulo method igual a GET, você pode usar:

http_requests_total{method="GET"}

Cálculos de Taxa: Você pode calcular a taxa de alteração de uma métrica usando funções como rate(). Por exemplo, para calcular a taxa de alteração das métricas http_requests_total, você pode usar:

rate(http_requests_total[5m])

Agrupamento e Classificação: Você pode agrupar e classificar métricas usando as cláusulas by e sort. Por exemplo, para agrupar as métricas http_requests_total por código de status, você pode usar:

sum(http_requests_total) by (status)

Resultado tabela

Resultado gráfico

Esses são apenas alguns exemplos de consultas que você pode fazer com PromQL. A linguagem é bastante flexível e poderosa, permitindo que você analise e visualize suas métricas de várias maneiras. É altamente recomendável explorar a documentação do Prometheus para aprender mais sobre as capacidades e sintaxe do PromQL.

Conclusão

O Prometheus é uma ferramenta poderosa para monitoramento e alerta em ambientes modernos de desenvolvimento e operações. Sua arquitetura flexível, modelo de dados dimensional e linguagem de consulta poderosa o tornam uma escolha popular entre os engenheiros de DevOps. Neste artigo, exploramos os conceitos fundamentais do Prometheus e demonstramos um exemplo prático de como usá-lo para monitorar uma aplicação NodeJS.

Com sua capacidade de coletar, armazenar e processar métricas, o Prometheus desempenha um papel crucial na garantia de desempenho e confiabilidade dos sistemas em produção. Se você ainda não começou a explorar o Prometheus, agora é um ótimo momento para começar a usá-lo em seus projetos!

Próximo passo: Criar dashboards no Grafana utilizando como insumo, métricas coletadas pelo Prometheus.

Até a próxima!