Prometheus
Introdução
Na seção anterior, introduzimos o conceito de observabilidade e seus pilares. Vimos que as métricas são essenciais para entender a saúde e o desempenho de nossos sistemas em larga escala.
Agora, vamos explorar o Prometheus, uma das ferramentas mais populares para coleta e armazenamento de métricas.
O Prometheus é um projeto de código aberto, originalmente desenvolvido pela SoundCloud, que se tornou o padrão para monitoramento em ecossistemas de contêineres e microsserviços. Ele funciona como um banco de dados de séries temporais, coletando métricas de serviços configurados em intervalos específicos, avaliando regras de alerta e exibindo os resultados.
Prometheus e os Pilares da Observabilidade
O Prometheus é a personificação do pilar de Métricas.
Ele foi projetado para coletar, armazenar e consultar dados numéricos de séries temporais de forma altamente eficiente.
Arquitetura e Conceitos
A arquitetura do Prometheus é baseada em um modelo pull, onde o servidor Prometheus é responsável por puxar (coletar) as métricas de endpoints HTTP expostos pelos serviços monitorados, conhecidos como exporters.
Os principais componentes são:
- Prometheus Server: O coração do sistema, responsável por coletar e armazenar as métricas.
- Exporters: Pequenos serviços que rodam junto com as aplicações e expõem as métricas no formato que o Prometheus entende. Existem exporters para uma infinidade de tecnologias: bancos de dados, sistemas operacionais, hardware, etc.
- PromQL: A linguagem de consulta (Query Language) do Prometheus, projetada para trabalhar com dados de séries temporais.
- Alertmanager: Gerencia os alertas enviados pelo Prometheus, agrupando, deduplicando e enviando notificações para canais como Slack, E-mail, etc.
Configurando o Ambiente
Vamos começar configurando um ambiente local com Prometheus.
Exercício
Configuração do Prometheus
O Prometheus precisa de um arquivo de configuração para saber quais alvos (targets) ele deve monitorar.
Exercício
Exercício
Answer
O arquivo de configuração instrui o Prometheus a coletar métricas a cada 15 segundos, mas não foi especificado de quais serviços ele deve coletar essas métricas.
Docker Compose
Agora, vamos criar um docker-compose.yml para iniciar o servidor Prometheus.
Exercício
Exercício
Answer
O volume mapeia o arquivo de configuração prometheus.yml do diretório atual (onde o Docker Compose está sendo executado) para o caminho /etc/prometheus/prometheus.yml dentro do contêiner do Prometheus.
Isso permite que o Prometheus utilize a configuração personalizada definida no arquivo local.
Executando o Prometheus
Com os arquivos de configuração prontos, vamos iniciar o serviço.
Exercício
Exercício
Answer
Para o Prometheus saber quais serviços monitorar, precisamos definir targets no arquivo prometheus.yml.
Assim, o Prometheus irá coletar métricas desses serviços ao acessar a rota /metrics de cada target.
Exercício
Monitorando uma API
Vamos atualizar o Prometheus para monitorar uma API.
Exercício
Na pasta api, iremos criar uma série de arquivos:
api/main.py
import time
from fastapi import FastAPI
from prometheus_fastapi_instrumentator import Instrumentator
import random
app = FastAPI()
Instrumentator().instrument(app).expose(app)
# Database dummy
dummy_data = {}
id = 0
@app.get("/")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int):
"""Simula a leitura de um item de um banco de dados."""
# time.sleep(abs(random.gauss(5, 1))) # Simula um tempo de resposta
return {"item_id": item_id, "item": dummy_data.get(item_id, "Not Found")}
@app.post("/items/")
def create_item(item: dict):
"""Simula a criação de um item em um banco de dados."""
global id
id += 1
dummy_data[id] = item
return {"id": id}
api/Dockerfile
Exercício
Após criar os arquivos, volte para a pasta 11-observability/01-prometheus e atualize o arquivo docker-compose.yml para incluir o serviço da API:
services:
prometheus:
image: prom/prometheus:v3.6.0-rc.1
container_name: prometheus
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
command:
- '--config.file=/etc/prometheus/prometheus.yml'
api:
build: ./api
container_name: api
ports:
- "8000:8000"
volumes:
- ./api:/app
networks:
default:
driver: bridge
Atualize também o arquivo prometheus.yml para adicionar a API como um novo target:
global:
scrape_interval: 15s # Com que frequência coletar métricas
scrape_configs:
- job_name: "api"
static_configs:
- targets: [localhost:8000] # Para monitorar a API
Exercício
Exercício
Exercício
Exercício
Answer
Error scraping target: Get "http://localhost:8000/metrics": dial tcp [::1]:8000: connect: connection refused
Isto acontece porque o target para a API está incorreto. No arquivo prometheus.yml, o target está definido como localhost:8000, mas localhost é o próprio host onde o Prometheus está rodando, e não o contêiner da API!
Para corrigir, basta alterar o target para api:8000, onde api é o nome do serviço definido no docker-compose.yml.
Exercise
Exercise
Explorando o valor das Métricas
No menu Query da interface do Prometheus, você pode usar a linguagem PromQL para explorar as métricas coletadas.
Por exemplo, para ver a contagem total de requisições HTTP feitas à API, você pode executar a seguinte consulta:
Acesse o menu Graph e execute a consulta acima. Você verá o número total de requisições feitas à API desde que o Prometheus começou a coletar métricas.
Exercise
Exercise
Answer
Passe o mouse sobre o gráfico para ver os detalhes de cada rota!
Monitorando Outro Serviço com um Exporter
Vamos adicionar um node-exporter, que expõe métricas do sistema operacional do host (CPU, memória, disco, rede, etc.).
Exercício
Agora, precisamos dizer ao Prometheus para coletar as métricas do node-exporter.
Exercício
Exercício
Exercício
Consultando Métricas com PromQL
Vamos explorar as métricas do node-exporter.
Exercício
Vamos tentar algumas consultas básicas.
Exercício
Exercício
Exercício
Answer
A consulta para calcular a porcentagem de memória livre é:
Esta consulta divide a memória disponível (node_memory_MemAvailable_bytes) pela memória total (node_memory_MemTotal_bytes) e multiplica por 100 para obter a porcentagem.
Warning
Não é objetivo do curso aprofundar em PromQL. O foco é entender o conceito de métricas e como o Prometheus pode ser utilizado para coletá-las.
Sinta-se à vontade para utilizar IAg, sempre solicitando uma explicação do que está sendo feito.
Limpeza do Ambiente
Exercício
Na próxima seção, exploraremos como visualizar essas métricas de forma mais amigável usando o Grafana.