Guia prático para configurar Prometheus e Grafana com Docker Compose em VPS

Por · Publicado em · Atualizado em · 9 min de leitura

Tablet sobre mesa exibindo gráficos e dashboards, ao lado de celular e xícara de café
Tela com gráficos e métricas, representando monitoramento de infraestrutura e containers. Foto: AS Photography / Pexels

Guia prático: configurar Prometheus e Grafana com Docker Compose em VPS, incluindo Node Exporter, cAdvisor, Alertmanager, regras de alertas e provisionamento de datasource. Ao final, você terá um stack funcional de monitoramento para sistemas e containers, pronto para métricas, dashboards e alertas confiáveis.

Antes de começar: pré‑requisitos e arquitetura do stack

Você precisa de uma VPS Linux 64‑bits com acesso root ou sudo, Docker e Docker Compose instalados, portas liberadas e um usuário para operar. Comece com recursos modestos e aumente conforme o volume de métricas e retenção crescer.

A arquitetura inclui Prometheus (coleta/armazenamento), Node Exporter (métricas do host), cAdvisor (métricas de containers), Alertmanager (rotas de alerta) e Grafana (dashboards e alertas).

Se ainda vai instalar Docker e Compose, siga este passo: instalar Docker e Docker Compose no Linux. Em dúvida sobre tamanho? Veja como escolher o tamanho certo de VPS.

Componentes e portas padrão do ambiente interno:

Componente Porta Função URL interna
Prometheus 9090 TSDB e scraping http://prometheus:9090
Alertmanager 9093 Agrupa e envia alertas http://alertmanager:9093
Node Exporter 9100 Métricas do host http://node-exporter:9100/metrics
cAdvisor 8080 Métricas de containers http://cadvisor:8080/metrics
Grafana 3000 Dashboards e alertas http://grafana:3000

Preparar diretórios, variáveis e permissões na VPS

Crie uma pasta de projeto, separe configurações e dados persistentes e defina variáveis sensíveis fora do versionamento. Execute como um usuário com sudo.

Usaremos um arquivo .env para a senha inicial do Grafana. Ajuste nomes e caminhos conforme política da sua VPS.

  • Estrutura separa configs versionáveis dos volumes persistentes.
  • Use um gerenciador de senhas para guardar credenciais.
  • Evite senhas fracas; habilite MFA no Grafana depois do primeiro acesso.
# Crie a estrutura de diretórios
test -d monitoring || mkdir -p monitoring/{prometheus/rules,alertmanager,grafana/provisioning/{datasources,dashboards}}
cd monitoring

# Defina variáveis sensíveis (não comitar este arquivo)
cat > .env << 'EOF'
GF_SECURITY_ADMIN_USER=admin
GF_SECURITY_ADMIN_PASSWORD=altere-esta-senha
EOF

# Opcional: restrinja permissões do .env
chmod 600 .env

Docker Compose: Prometheus, Grafana, Alertmanager, Node Exporter e cAdvisor

Este docker-compose cria a rede, define volumes persistentes e sobe todos os serviços. Ele habilita reload no Prometheus e provisionamento no Grafana.

Troque tags de imagem conforme sua política. Você pode gerenciar containers por UI com Portainer se preferir.

Ao seguir estes passos, você consegue configurar Prometheus e Grafana com Docker Compose em VPS de forma reprodutível.

  • Volumes persistentes evitam perda de dados em recriações.
  • Tags de imagem fixas reduzem surpresas em updates.
  • A senha do Grafana vem do .env para não vazar no repositório.
version: "3.8"

networks:
  monitoring:
    driver: bridge

volumes:
  prometheus_data:
  grafana_data:
  alertmanager_data:

services:
  prometheus:
    image: prom/prometheus:v2.53.0
    container_name: prometheus
    restart: unless-stopped
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.path=/prometheus
      - --web.enable-lifecycle
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/rules:/etc/prometheus/rules:ro
      - prometheus_data:/prometheus
    networks: [monitoring]

  alertmanager:
    image: prom/alertmanager:v0.27.0
    container_name: alertmanager
    restart: unless-stopped
    command: ["--config.file=/etc/alertmanager/alertmanager.yml"]
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
      - alertmanager_data:/alertmanager
    networks: [monitoring]

  node-exporter:
    image: prom/node-exporter:v1.7.0
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    command: ["--path.rootfs=/host"]
    volumes:
      - /:/host:ro,rslave
    ports:
      - "9100:9100"
    networks: [monitoring]

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:v0.47.2
    container_name: cadvisor
    restart: unless-stopped
    privileged: true
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    networks: [monitoring]

  grafana:
    image: grafana/grafana:10.4.3
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=${GF_SECURITY_ADMIN_USER}
      - GF_SECURITY_ADMIN_PASSWORD=${GF_SECURITY_ADMIN_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on: [prometheus]
    networks: [monitoring]

Configurar Prometheus: scrape_configs e regras

O Prometheus fará scrape de si mesmo, do Node Exporter e do cAdvisor. Também apontamos para o Alertmanager e carregamos regras de alerta do diretório rules.

Você pode ajustar scrape_interval conforme o volume de métricas e tamanho do disco. Intervalos menores aumentam uso de CPU e armazenamento.

  • Mantenha nomes de job curtos e descritivos.
  • Centralize regras em arquivos separados para organização.
  • Habilitamos reload por HTTP para aplicar mudanças sem reiniciar.
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ["alertmanager:9093"]

rule_files:
  - /etc/prometheus/rules/*.yml

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

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

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

Alertmanager: rotas e entrega de alertas

Defina como os alertas serão agrupados, rateados e entregues (e‑mail, webhook, chat). Comece simples com SMTP. Substitua valores fictícios por credenciais válidas.

Teste a entrega de alertas com uma regra propositalmente sensível e depois ajuste limiares para reduzir ruído.

  • Agrupe por alertname e instance para evitar tempestades.
  • Ajuste group_wait e repeat_interval conforme criticidade.
  • Use senhas de aplicativo para SMTP quando possível.
route:
  receiver: "email-default"
  group_by: ["alertname", "instance"]
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 3h

receivers:
  - name: "email-default"
    email_configs:
      - to: "[email protected]"
        from: "[email protected]"
        smarthost: "smtp.seu-dominio.com:587"
        auth_username: "[email protected]"
        auth_password: "SENHA-OU-TOKEN"
        require_tls: true

# Você pode adicionar outros receivers (webhook, chat) conforme necessidade.

Regras de alertas úteis para começar

Crie um arquivo de regras com condições de disponibilidade e saturação. Evite regras ruidosas no início; refine após observar seu ambiente.

Os exemplos abaixo cobrem indisponibilidade, CPU alta, memória baixa e disco cheio. Ajuste limiares à sua realidade.

  • Use labels para severidade e equipe responsável.
  • Adicione annotations com next steps claros.
  • Teste localmente as expressões no console do Prometheus.
groups:
  - name: infra-basics
    rules:
      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instância fora do ar"
          description: "{{ $labels.instance }} não responde a scrape."

      - alert: NodeHighCpu
        expr: (1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))) > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU alta no host"
          description: "Uso de CPU acima de 80% por 5m em {{ $labels.instance }}."

      - alert: NodeLowMemory
        expr: (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) < 0.1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Memória disponível baixa"
          description: "Menos de 10% de memória livre em {{ $labels.instance }}."

      - alert: NodeDiskAlmostFull
        expr: (node_filesystem_avail_bytes{fstype=~"ext4|xfs",mountpoint!~"/(run|var/lib/docker.*)"} / node_filesystem_size_bytes{fstype=~"ext4|xfs",mountpoint!~"/(run|var/lib/docker.*)"}) < 0.1
        for: 15m
        labels:
          severity: critical
        annotations:
          summary: "Disco quase cheio"
          description: "Menos de 10% livre em {{ $labels.instance }} filesystem."

Provisionar o Grafana: datasource e primeiros dashboards

Provisione o datasource do Prometheus para evitar configuração manual. Depois, acesse o Grafana, faça login e importe dashboards pelo menu Import.

Para containers, crie painéis de CPU, memória e reinicializações por serviço. Para o host, adicione gráficos de load, I/O e filesystem. Evite painéis enormes no começo; itere aos poucos.

  • Datasource padrão evita erros de URL.
  • Organize dashboards por domínio: Infra, Docker, App.
  • Use variáveis de dashboard para filtrar por instância.
# grafana/provisioning/datasources/datasource.yml
apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    editable: false

Subir os serviços, verificar métricas e validar alertas

Agora é hora de subir e validar. Estes comandos alteram serviços do host; execute com cautela.

Abra as UIs locais para checar: Prometheus em :9090, Alertmanager em :9093, Grafana em :3000. Teste reload de config e verifique se regras carregaram.

Com isso, você conclui como configurar Prometheus e Grafana com Docker Compose em VPS e valida o fluxo de monitoramento end‑to‑end.

  • Use docker compose logs para investigar erros de inicialização.
  • No Prometheus, confira Status > Targets e Status > Rules.
  • Dispare um alerta temporário para validar entrega (ex.: reduzindo limiar).
# Subir em background
docker compose up -d

# Verificar status
docker compose ps

# Listar alvos no Prometheus (espera-se 200 OK)
curl -sS http://localhost:9090/targets | head -n 20

# Checar Alertmanager
curl -sS http://localhost:9093 | head -n 5

# Recarregar configuração do Prometheus após editar arquivos
echo "Reload Prometheus" && curl -X POST http://localhost:9090/-/reload

# Logs de um serviço específico
docker compose logs -f prometheus

Hardening, backup e próximos passos

Para expor Grafana e bloquear acessos diretos, use um proxy reverso com TLS e autenticação. O guia de SSL com Let's Encrypt ajuda a emitir certificados válidos.

Restrinja portas externas com firewall; libere somente o necessário. Faça backup periódico dos volumes e dos arquivos de configuração versionados.

Quando tudo estiver estável, considere separar métricas por ambientes e ajustar retenção de séries conforme o disco disponível.

  • Proteja o Grafana atrás de proxy e TLS: veja gerar SSL grátis.
  • Aplique regras no UFW: veja firewall no Ubuntu com UFW.
  • Faça snapshot/backup dos volumes prometheus_data e grafana_data.
  • Defina uma janela de retenção coerente com seu disco.
  • Implemente gravação remota se precisar centralizar métricas.

Perguntas frequentes

Qual tamanho de VPS devo usar para Prometheus e Grafana?

Depende do scrape_interval, número de alvos e retenção. Para poucos hosts e intervalos de 15s, CPUs e memória moderadas costumam bastar. Monitore uso de CPU, memória e I/O do host e ajuste verticalmente. Em crescentes, aumente disco primeiro, depois CPU/RAM.

Como persistir dados entre recriações dos containers?

Use volumes nomeados no Docker Compose para Prometheus, Grafana e Alertmanager. Eles ficam fora do ciclo de vida dos containers. Faça backup periódico dos volumes e dos arquivos de configuração (.yml). Antes de mudanças grandes, crie um snapshot do disco da VPS.

Como proteger o Grafana em produção?

Coloque o Grafana atrás de um proxy reverso com TLS, limite o acesso por firewall, desative sign-up público, ative MFA e use senhas fortes. Se for expor na internet, gere certificados válidos e mantenha o Grafana atualizado. Revise permissões de pastas e equipes periodicamente.

Posso monitorar múltiplas VPS com esse setup?

Sim. Instale Node Exporter em cada VPS e adicione seus IPs/portas em scrape_configs do Prometheus. Para expostos na internet, use firewall, TLS/ACLs ou um túnel seguro. Também é possível rodar exportadores como containers em cada host remoto.

Quais canais de notificação posso usar no Alertmanager?

E-mail via SMTP é simples para começar. Depois, adicione webhooks para integrar com chats ou automações. Defina rotas por severidade e serviço, agrupe alertas para reduzir ruído e ajuste tempos de espera (group_wait, repeat_interval) conforme a criticidade.

Como atualizar as imagens sem perder dados?

Atualize tags no docker-compose.yml, faça backup dos volumes e suba novamente com docker compose pull && docker compose up -d. Como os dados estão em volumes, eles permanecem. Valide em staging quando possível e monitore logs e métricas após o update.

Precisa adaptar este stack ao seu ambiente?

Se quiser revisar regras, dimensionar retenção ou integrar alertas ao seu fluxo, fale comigo para destravar a próxima etapa do seu monitoramento.

Conversar sobre monitoramento

Veja também