ARQUITETURA DE MONITORAMENTO PROMETHEUS + GRAFANA Alvos node_exporter :9100 cAdvisor :8080 scrape Prometheus TSDB Storage PromQL Engine Alert Rules :9090 alertas Alertmanager :9093 consulta Grafana Dashboards Panels & Graphs Alert Contacts :3000 ver Navegador Dashboards em tempo real & Alertas

Saber o que esta acontecendo nos seus servidores nao e opcional — e essencial. Seja gerenciando um unico VPS ou uma frota de maquinas de producao, a visibilidade em tempo real do uso de CPU, consumo de memoria, E/S de disco e trafego de rede e o que separa o gerenciamento proativo de infraestrutura de apagar incendios. Prometheus e Grafana juntos formam o stack de monitoramento de codigo aberto mais amplamente adotado na industria, potencializando a observabilidade em organizacoes desde startups ate grandes empresas.

Este guia leva voce por todo o processo: instalar Prometheus e node_exporter para coletar metricas do sistema, configurar Grafana para visualizacao, escrever consultas PromQL, configurar alertas com Alertmanager e monitorar containers Docker com cAdvisor. No final, voce tera um stack de monitoramento totalmente funcional rodando no Ubuntu.

Pre-requisitos

Antes de comecar, certifique-se de ter:

  • Um servidor rodando Ubuntu 22.04 ou 24.04 (edicao desktop ou servidor)
  • Acesso ao terminal com privilegios sudo
  • Pelo menos 2 GB de RAM e 20 GB de espaco livre em disco
  • Portas 9090 (Prometheus), 9100 (node_exporter), 3000 (Grafana) e 9093 (Alertmanager) disponiveis
  • Familiaridade basica com a linha de comando do Linux e sintaxe YAML
  • Docker instalado (opcional, para a secao do cAdvisor) — consulte nosso guia de instalacao do Docker

Nota: Todos os comandos neste guia sao para Ubuntu na arquitetura amd64. Se voce esta rodando ARM64, ajuste as URLs de download para usar as variantes de binarios linux-arm64.

O que sao Prometheus e Grafana?

Prometheus e um conjunto de ferramentas de monitoramento e alertas de sistemas de codigo aberto, originalmente construido no SoundCloud em 2012. Ele coleta metricas raspando endpoints HTTP em intervalos regulares, armazena-as em um banco de dados de series temporais (TSDB) e fornece uma poderosa linguagem de consulta chamada PromQL para analise. Prometheus segue um modelo baseado em pull — ele ativamente busca metricas dos seus servidores em vez de esperar que os dados sejam enviados.

Grafana e uma plataforma de analise e visualizacao interativa de codigo aberto. Ela se conecta a fontes de dados como Prometheus, Elasticsearch, InfluxDB e PostgreSQL para renderizar dashboards em tempo real com graficos, tabelas, mapas de calor e alertas. Grafana nao armazena dados por si so; ele consulta a fonte de dados subjacente sob demanda.

Juntos, eles formam um pipeline de monitoramento completo:

  1. Exportadores (como node_exporter) expoem metricas em endpoints HTTP
  2. Prometheus raspa e armazena essas metricas
  3. Grafana consulta o Prometheus e exibe os dados visualmente
  4. Alertmanager gerencia as notificacoes quando as metricas ultrapassam limites definidos

Visao Geral da Arquitetura de Monitoramento

Entender o fluxo de dados e critico antes de implantar o stack:

┌─────────────────┐     scrape      ┌──────────────┐     query     ┌──────────────┐
│  node_exporter  │────────────────>│  Prometheus   │<─────────────│   Grafana    │
│  :9100          │  /metrics       │  :9090        │              │   :3000      │
└─────────────────┘                 │              │              │              │
                                    │  TSDB        │              │  Dashboards  │
┌─────────────────┐     scrape      │  PromQL      │              │  Panels      │
│  cAdvisor       │────────────────>│  Alert Rules  │              │  Alerts      │
│  :8080          │  /metrics       │              │              └──────────────┘
└─────────────────┘                 └──────┬───────┘
                                           │ fire alerts
                                    ┌──────▼───────┐
                                    │ Alertmanager  │──> Email / Slack / PagerDuty
                                    │ :9093         │
                                    └──────────────┘

Prometheus usa um modelo pull: ele periodicamente envia requisicoes HTTP GET para os alvos configurados (exportadores) para buscar as metricas mais recentes. Cada exportador expoe um endpoint /metrics que retorna dados no formato de exposicao do Prometheus. Esta arquitetura significa que os alvos nao precisam saber sobre o Prometheus — eles simplesmente servem suas metricas quando solicitados.

Instalacao do Prometheus

Comece criando um usuario de sistema dedicado e os diretorios necessarios:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Baixe a ultima versao do Prometheus (verifique prometheus.io/download para a versao atual):

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.53.0/prometheus-2.53.0.linux-amd64.tar.gz
tar xvf prometheus-2.53.0.linux-amd64.tar.gz
cd prometheus-2.53.0.linux-amd64

Copie os binarios e arquivos de configuracao:

sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus

Verifique a instalacao:

prometheus --version

Voce devera ver uma saida exibindo a versao, data de compilacao e versao do Go.

Configuracao do Prometheus

O arquivo de configuracao principal e /etc/prometheus/prometheus.yml. Este arquivo YAML define as configuracoes globais, intervalos de raspagem e endpoints de destino.

Crie uma configuracao limpa:

sudo nano /etc/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - localhost:9093

rule_files:
  - "alert_rules.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]

Parametros chave de configuracao:

  • scrape_interval: Com que frequencia o Prometheus raspa os alvos (15 segundos e o padrao recomendado)
  • evaluation_interval: Com que frequencia o Prometheus avalia as regras de alertas
  • scrape_timeout: Tempo maximo de espera para uma resposta de raspagem antes de marcar o alvo como fora do ar
  • job_name: Um label aplicado a todas as metricas coletadas dos alvos neste grupo
  • static_configs: Uma lista de endpoints de destino para raspar

Crie um arquivo de servico systemd para o Prometheus:

sudo nano /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d \
  --web.enable-lifecycle
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Habilite e inicie o Prometheus:

sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus
sudo systemctl status prometheus

Prometheus agora deve estar rodando e acessivel em http://ip-do-seu-servidor:9090.

Instalacao e Configuracao do node_exporter

node_exporter e o exportador padrao do Prometheus para metricas de hardware e nivel de sistema operacional. Ele expoe estatisticas de CPU, memoria, disco, sistema de arquivos e rede na porta 9100.

Crie um usuario dedicado e baixe o node_exporter:

sudo useradd --no-create-home --shell /bin/false node_exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-amd64.tar.gz
tar xvf node_exporter-1.8.1.linux-amd64.tar.gz
sudo cp node_exporter-1.8.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Crie o servico systemd:

sudo nano /etc/systemd/system/node_exporter.service
[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter \
  --collector.systemd \
  --collector.processes
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Habilite e inicie o node_exporter:

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter

Verifique se as metricas estao sendo expostas:

curl -s http://localhost:9100/metrics | head -20

Voce devera ver linhas comecando com # HELP e # TYPE seguidas de nomes de metricas e valores. Confirme que o Prometheus esta raspando o node_exporter navegando ate http://ip-do-seu-servidor:9090/targets — o job node deve mostrar um status de UP.

Instalacao do Grafana

Adicione o repositorio APT oficial do Grafana:

sudo apt-get install -y apt-transport-https software-properties-common wget
sudo mkdir -p /etc/apt/keyrings/

wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

Instale e inicie o Grafana:

sudo apt-get update
sudo apt-get install grafana -y
sudo systemctl daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Verifique se o Grafana esta rodando:

sudo systemctl status grafana-server

Grafana agora esta acessivel em http://ip-do-seu-servidor:3000. As credenciais padrao sao admin / admin. Voce sera solicitado a alterar a senha no primeiro login.

Seguranca: Altere a senha padrao do administrador imediatamente. Em producao, configure o Grafana atras de um proxy reverso com HTTPS.

Criando seu Primeiro Dashboard

Apos fazer login no Grafana, adicione o Prometheus como fonte de dados:

  1. Navegue ate Connections > Data Sources > Add data source
  2. Selecione Prometheus
  3. Defina a URL como http://localhost:9090
  4. Clique em Save & Test — voce devera ver “Successfully queried the Prometheus API”

Importe o amplamente utilizado dashboard Node Exporter Full:

  1. Navegue ate Dashboards > New > Import
  2. Insira o ID do dashboard 1860 (Node Exporter Full por rfmoz)
  3. Selecione sua fonte de dados Prometheus
  4. Clique em Import

Este dashboard fornece paineis completos para uso de CPU, utilizacao de memoria, E/S de disco, trafego de rede, uso do sistema de arquivos e carga do sistema — tudo sem escrever uma unica consulta.

Para criar um painel personalizado:

  1. Clique em Add > Visualization em qualquer dashboard
  2. No editor de consultas, insira uma expressao PromQL como:
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  1. Isso calcula a porcentagem de uso total de CPU
  2. Configure o titulo do painel, legenda, limites e formato da unidade
  3. Clique em Apply para salvar o painel

Fundamentos de PromQL

PromQL (Prometheus Query Language) e uma linguagem de consulta funcional que permite selecionar, agregar e transformar dados de series temporais. Entender PromQL e essencial para construir dashboards e regras de alerta uteis.

Vetores instantaneos retornam o valor mais recente para cada serie temporal:

node_memory_MemAvailable_bytes

Vetores de intervalo retornam valores ao longo de uma janela de tempo:

node_cpu_seconds_total[5m]

rate() calcula a taxa media de incremento por segundo (essencial para contadores):

rate(node_cpu_seconds_total{mode="idle"}[5m])

Operadores de agregacao combinam multiplas series temporais:

# Uso medio de CPU em todos os nucleos
avg without(cpu) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

# Memoria total em todas as instancias
sum by(instance) (node_memory_MemTotal_bytes)

# Top 5 instancias por uso de CPU
topk(5, 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100))

Operacoes matematicas permitem combinar metricas:

# Porcentagem de uso de memoria
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# Porcentagem de uso de disco
(1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100

Filtragem por labels usa chaves:

# Filtrar por instancia especifica
node_cpu_seconds_total{instance="server1:9100", mode!="idle"}

# Correspondencia com regex
node_filesystem_avail_bytes{mountpoint=~"/|/home"}

Configuracao de Regras de Alertas

Prometheus avalia as regras de alertas no evaluation_interval definido na configuracao global. Quando uma condicao de regra e atendida, Prometheus dispara um alerta para o Alertmanager, que gerencia a deduplicacao, agrupamento e roteamento para canais de notificacao.

Crie um arquivo de regras de alerta:

sudo nano /etc/prometheus/alert_rules.yml
groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de CPU em {{ $labels.instance }}"
          description: "O uso de CPU esta acima de 85% por mais de 5 minutos (valor atual: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Alto uso de memoria em {{ $labels.instance }}"
          description: "O uso de memoria esta acima de 90% por mais de 5 minutos (valor atual: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Pouco espaco em disco em {{ $labels.instance }}"
          description: "O uso do sistema de arquivos raiz esta acima de 85% (valor atual: {{ $value }}%)"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "A instancia {{ $labels.instance }} esta fora do ar"
          description: "{{ $labels.instance }} do job {{ $labels.job }} esta fora do ar por mais de 2 minutos."

Valide o arquivo de regras:

promtool check rules /etc/prometheus/alert_rules.yml

Agora instale o Alertmanager:

cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.27.0/alertmanager-0.27.0.linux-amd64.tar.gz
tar xvf alertmanager-0.27.0.linux-amd64.tar.gz

sudo useradd --no-create-home --shell /bin/false alertmanager
sudo mkdir -p /etc/alertmanager /var/lib/alertmanager
sudo cp alertmanager-0.27.0.linux-amd64/alertmanager /usr/local/bin/
sudo cp alertmanager-0.27.0.linux-amd64/amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager /usr/local/bin/amtool

Configure o Alertmanager:

sudo nano /etc/alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m

route:
  group_by: ['alertname', 'severity']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'alertmanager@example.com'
        auth_password: 'your-app-password'
        require_tls: true

  - name: 'slack-notifications'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL'
        channel: '#alerts'
        send_resolved: true
        title: '{{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

Crie o servico systemd do Alertmanager:

sudo nano /etc/systemd/system/alertmanager.service
[Unit]
Description=Prometheus Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
  --config.file=/etc/alertmanager/alertmanager.yml \
  --storage.path=/var/lib/alertmanager/
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable alertmanager
sudo systemctl start alertmanager

Reinicie o Prometheus para carregar as novas regras de alerta:

sudo systemctl restart prometheus

Verifique seus alertas em http://ip-do-seu-servidor:9090/alerts e confira o Alertmanager em http://ip-do-seu-servidor:9093.

Monitoramento de Containers Docker com cAdvisor

cAdvisor (Container Advisor) fornece metricas de uso de recursos e desempenho a nivel de container. Ele roda como um container Docker e expoe metricas no formato Prometheus.

Inicie o cAdvisor:

docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --privileged \
  --device=/dev/kmsg \
  gcr.io/cadvisor/cadvisor:v0.49.1

Adicione o cAdvisor como um alvo de raspagem do Prometheus em /etc/prometheus/prometheus.yml:

  - job_name: "cadvisor"
    static_configs:
      - targets: ["localhost:8080"]

Recarregue o Prometheus:

curl -X POST http://localhost:9090/-/reload

Consultas PromQL uteis para cAdvisor:

# Uso de CPU do container
rate(container_cpu_usage_seconds_total{name!=""}[5m])

# Uso de memoria do container
container_memory_usage_bytes{name!=""}

# Bytes recebidos pela rede do container
rate(container_network_receive_bytes_total{name!=""}[5m])

# Uso do sistema de arquivos do container
container_fs_usage_bytes{name!=""}

Importe o dashboard do Grafana com ID 14282 (cAdvisor Exporter) para paineis de monitoramento de containers pre-construidos.

Referencia de Consultas PromQL Uteis

ConsultaDescricao
upVerificar se os alvos estao acessiveis (1 = ativo, 0 = fora do ar)
rate(node_cpu_seconds_total{mode="idle"}[5m])Taxa de inatividade de CPU por nucleo
node_memory_MemAvailable_bytes / 1024 / 1024Memoria disponivel em MB
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100Porcentagem de uso de memoria
rate(node_disk_read_bytes_total[5m])Throughput de leitura de disco
rate(node_disk_written_bytes_total[5m])Throughput de escrita de disco
rate(node_network_receive_bytes_total[5m])Trafego de rede de entrada
rate(node_network_transmit_bytes_total[5m])Trafego de rede de saida
node_filesystem_avail_bytes{mountpoint="/"}Espaco em disco disponivel na raiz
node_load1 / node_load5 / node_load15Medias de carga do sistema
rate(node_cpu_seconds_total{mode="iowait"}[5m])Porcentagem de espera de E/S
node_time_seconds - node_boot_time_secondsTempo de atividade do sistema em segundos
count(node_cpu_seconds_total{mode="idle"})Numero de nucleos de CPU
rate(container_cpu_usage_seconds_total{name!=""}[5m])Uso de CPU do container

Solucao de Problemas

Prometheus falha ao iniciar:

Verifique a sintaxe da configuracao:

promtool check config /etc/prometheus/prometheus.yml

Verifique os logs do servico:

sudo journalctl -u prometheus -f --no-pager

Problemas comuns incluem erros de indentacao YAML, intervalos de raspagem invalidos e problemas de permissao de arquivo em /var/lib/prometheus.

Alvo aparece como DOWN no Prometheus:

Verifique se o exportador esta rodando:

sudo systemctl status node_exporter
curl -v http://localhost:9100/metrics

Verifique o firewall:

sudo ufw status
sudo ufw allow 9100/tcp

Grafana nao consegue conectar ao Prometheus:

Certifique-se de que o Prometheus esta ouvindo no endereco correto. Se Grafana e Prometheus estao no mesmo servidor, use http://localhost:9090. Verifique a conectividade:

curl http://localhost:9090/api/v1/query?query=up

Sem dados nos paineis do Grafana:

Verifique o seletor de intervalo de tempo no dashboard. O padrao pode estar fora da sua janela de retencao de dados. Tambem confirme que a fonte de dados Prometheus esta selecionada no editor de consultas do painel.

Alto uso de memoria pelo Prometheus:

Reduza o numero de series temporais limitando os exportadores ou adicionando regras de reetiquetagem de metricas. Verifique a memoria atual e a contagem de series:

curl http://localhost:9090/api/v1/status/tsdb

Considere reduzir o tempo de retencao:

--storage.tsdb.retention.time=15d

Alertmanager nao envia notificacoes:

Teste a configuracao do Alertmanager:

amtool check-config /etc/alertmanager/alertmanager.yml

Envie um alerta de teste:

amtool alert add alertname=TestAlert severity=critical --alertmanager.url=http://localhost:9093

Resumo

Voce agora tem um stack de monitoramento completo rodando no seu servidor: Prometheus coletando metricas do node_exporter e cAdvisor, Grafana renderizando dashboards em tempo real, e Alertmanager entregando notificacoes quando as coisas dao errado. Esta configuracao oferece visibilidade profunda sobre a saude do sistema, desempenho de containers e utilizacao de recursos.

Pontos-chave deste guia:

  • Prometheus raspa metricas dos alvos em intervalos regulares e as armazena em um banco de dados de series temporais
  • node_exporter fornece metricas a nivel de sistema (CPU, memoria, disco, rede)
  • Grafana visualiza metricas com dashboards e paineis personalizaveis
  • PromQL e a linguagem de consulta para selecionar, filtrar e agregar metricas
  • Alertmanager roteia alertas para email, Slack, PagerDuty ou outros canais de notificacao
  • cAdvisor expoe metricas de recursos a nivel de container para ambientes Docker

Para a base sobre a qual este stack de monitoramento roda, certifique-se de que seu servidor esta devidamente protegido seguindo nossa lista de verificacao de seguranca de servidores Linux. Se voce ainda nao configurou o Docker para a secao do cAdvisor, siga nosso guia de instalacao do Docker no Ubuntu.

A medida que sua infraestrutura cresce, explore a federacao do Prometheus para configuracoes multi-servidor, Grafana Loki para agregacao de logs, e Thanos ou Cortex para armazenamento de longo prazo e alta disponibilidade.