Grafana para PME 2026: Dashboards de Monitorização com Prometheus

Software · Monitorização · Grafana · Prometheus  |  ✎ Duarte Spínola  |  2026-06-23

Neste artigo

  1. O que é Grafana e por que importa em 2026
  2. O papel do Prometheus como fonte de dados
  3. Requisitos e arquitetura para uma PME
  4. Instalar Prometheus no servidor
  5. Instalar Grafana e ligar ao Prometheus
  6. Configurar exporters para recolha de métricas
  7. Construir o primeiro dashboard
  8. Alertas e regras de notificação
  9. Segurança, utilizadores e permissões
  10. Erros Comuns
  11. Checklist rápido de verificação

1. O que é Grafana e por que importa em 2026

Grafana é uma plataforma de visualização de dados que transforma métricas em painéis interactivos — dashboards — acessíveis através do navegador. Em 2026, a versão atual (Grafana 11.x) consolidou-se como a ferramenta de referência para qualquer equipa de TI que precise de perceber o estado dos seus sistemas em tempo real. A boa notícia é que o núcleo é open-source, pelo que uma PME pode começar sem investir um cêntimo em licenças (Grafana Docs).

A analogia mais útil é pensar no Grafana como o painel de instrumentos de um automóvel: tal como o painel mostra velocidade, combustível e temperatura do motor num só olhar, o Grafana mostra uso de CPU, memória, disco e rede de todos os servidores numa única página. Sem ele, o sysadmin é como um condutor sem painel — só descobre que algo corre mal quando o carro para.

Para uma PME em 2026, os motivos para adoptar Grafana são concretos:

  • Custo zero na edição open-source (OSS);
  • Suporte multi-fonte: Prometheus, InfluxDB, PostgreSQL, MySQL, Loki, Elasticsearch;
  • Comunidade enorme com milhares de dashboards prontos a importar;
  • Alertas nativos sem precisar de ferramentas externas pagas;
  • API REST completa para integração com sistemas existentes.

ℹ️ Nota: Grafana Cloud oferece um tier gratuito generoso (até 10 000 séries métricas) que pode ser suficiente para PME pequenas. No entanto, este artigo foca-se na instalação self-hosted, que dá controlo total sobre os dados.

2. O papel do Prometheus como fonte de dados

Prometheus é um sistema de monitorização e alerta open-source criado na SoundCloud em 2012 e hoje é projeto graduado da CNCF (Cloud Native Computing Foundation). A sua função é recolher, armazenar e consultar métricas temporais — dados que mudam ao longo do tempo, como temperatura de um servidor a cada 15 segundos (Prometheus Overview).

Se o Grafana é o painel de instrumentos, o Prometheus é o sistema de sensores do carro. Os sensores medem variáveis físicas e enviam-nas para uma centralina; o Prometheus faz o mesmo com métricas de software e hardware. A diferença é que o Prometheus guarda histórico, não apenas o valor actual.

Modelo de dados Prometheus

O Prometheus armazena métricas como séries temporais identificadas por um nome e um conjunto de etiquetas (labels). Por exemplo:

Conceito Exemplo Explicação
Nome da métrica node_cpu_seconds_total Contador de segundos de CPU por núcleo
Labels cpu="0", mode="idle", instance="srv1:9100" Identificam núcleo, estado e origem
Tipo: Counter http_requests_total Só cresce (reinicia ao zerar)
Tipo: Gauge node_memory_MemAvailable_bytes Sobe e desce livremente
Tipo: Histogram http_request_duration_seconds_bucket Distribui valores em buckets

A linguagem de consulta do Prometheus chama-se PromQL e é o que se escreve nos painéis do Grafana para obter valores. Por exemplo, node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100 devolve a percentagem de memória livre.

ℹ️ Nota: Prometheus não foi desenhado para logs ou tracing — apenas métricas numéricas. Para logs, o complemento natural é Loki, também do ecossistema Grafana.

3. Requisitos e arququitectura para uma PME

Antes de instalar, vale a pena pensar na arquitetura. Para uma PME típica com 5 a 30 servidores, não é preciso nada extravagante.

Requisitos de hardware

Componente CPU RAM Disco Notas
Servidor Prometheus 2 vCPU 4 GB 50 GB SSD Disco é o mais crítico — Prometheus escreve muito
Servidor Grafana 1 vCPU 1 GB 5 GB Pode correr na mesma máquina para PME pequenas
Node Exporter (por servidor monitorizado) < 0.5 vCPU 256 MB N/A Footprint mínimo
Rede Porta 9090/TCP (Prometheus) Porta 3000/TCP (Grafana) Porta 9100/TCP (Node Exporter) Abrir no firewall

⚠️ Atenção

O disco do Prometheus enche ao longo do tempo. Definir --storage.tsdb.retention.time=15d ou superior conforme a necessidade. Para PME, 15 a 30 dias é normalmente suficiente.

Arquitetura recomendada

┌─────────────────────────────────────────────────┐
│ Servidor de Monitorização │
│ │
│ ┌──────────┐ ┌─────────────┐ ┌─────────┐ │
│ │ Grafana │◄───│ Prometheus │◄───│ Exporters│ │
│ │ :3000 │ │ :9090 │ │ :9100 │ │
│ └──────────┘ └─────────────┘ └─────────┘ │
│ ▲ │
│ │ scrape (pull) │
│ ┌─────────┴──────────┐ │
│ │ srv1 srv2 srv3 │ │
│ │ db1 web1 app1 │ │
│ └────────────────────┘ │
└─────────────────────────────────────────────────┘

O Prometheus funciona por pull: é ele que vai buscar as métricas aos exporters, e não o contrário. Isto é diferente do Nagios, por exemplo, onde os agentes enviam dados activamente (push). A vantagem do pull é que o Prometheus sabe imediatamente se um alvo parou de responder — o falso sentimento de normalidade que o push pode dar não existe.

Instalar pré-requisitos

O comando seguinte instala as ferramentas base necessárias em Debian/Ubuntu.

sudo apt update && sudo apt install -y curl wget gnupg2 adduser libfontconfig1

Parâmetros do comando:

Parâmetro Função
apt update Actualiza a lista de pacotes disponíveis
curl Necessário para descarregar chaves de repositórios
wget Alternativa para descarregar ficheiros
gnupg2 Gestão de chaves GPG para validar pacotes
adduser Criar utilizador dedicado para Prometheus
libfontconfig1 Biblioteca de fontes necessária pelo Grafana

Para Red Hat / Fedora / CentOS Stream:

sudo dnf install -y curl wget gnupg2 fontconfig

Para Arch Linux:

sudo pacman -S –noconfirm curl wget gnupg fontconfig

4. Instalar Prometheus no servidor

Vamos instalar o Prometheus a partir do binário oficial, que garante a versão mais recente. O processo cria um utilizador dedicado, separa binários de configuração e configura o systemd para gerir o serviço.

Passo 1 — Criar utilizador e directórios

O comando seguinte cria um utilizador de sistema sem shell, para que o Prometheus corra com privilégios mínimos.

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

Parâmetros:

Parâmetro Função
--system Cria conta de sistema (sem expiração de password)
--no-create-home Não cria directório home (não é necessário)
--shell /bin/false Impede login interactivo
/etc/prometheus Onde fica a configuração
/var/lib/prometheus Onde ficam os dados (TSDB)

Passo 2 — Descarregar e instalar o binário

O comando seguinte descarrega a versão mais recente do Prometheus, extrai os binários e copia-os para /usr/local/bin.

cd /tmp
PROM_VERSION=$(curl -s https://api.github.com/repos/prometheus/prometheus/releases/latest | grep tag_name | cut -d ‘”‘ -f 4)
wget “https://github.com/prometheus/prometheus/releases/download/${PROM_VERSION}/prometheus-${PROM_VERSION}.linux-amd64.tar.gz”
tar xvf “prometheus-${PROM_VERSION}.linux-amd64.tar.gz”
cd “prometheus-${PROM_VERSION}.linux-amd64”
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/

Parâmetros:

Parâmetro Função
PROM_VERSION Detecta automaticamente a última versão via API do GitHub
promtool Ferramenta de validação de configuração e regras
consoles Templates de consolas web pré-feitas
chown -R Garante que o utilizador prometheus pode ler a config

💡 Dica

Depois de copiar, execute prometheus --version para confirmar que o binário funciona. Se aparecer “command not found”, verifique se /usr/local/bin está no $PATH.

Passo 3 — Criar o ficheiro de configuração

O ficheiro prometheus.yml define onde o Prometheus vai buscar as métricas. O exemplo seguinte configura o Prometheus para monitorizar a si próprio e um servidor remoto com Node Exporter.

global:
scrape_interval: 15s
evaluation_interval: 15s

scrape_configs:
– job_name: “prometheus”
static_configs:
– targets: [“localhost:9090”]

– job_name: “node_exporters”
static_configs:
– targets: [“localhost:9100”, “192.168.1.20:9100”, “192.168.1.30:9100”]
labels:
env: “producao”

Parâmetros do ficheiro:

Parâmetro Função
scrape_interval De quanto em quanto tempo o Prometheus vai buscar métricas (15s é o padrão)
evaluation_interval De quanto em quanto tempo avalia regras de alerta
job_name Agrupamento lógico de alvos sob um nome
targets Lista de endereços IP:porta dos exporters
labels Etiquetas extra aplicadas a todas as métricas deste job
env: "producao" Permite filtrar painéis por ambiente

Guardar o ficheiro em /etc/prometheus/prometheus.yml com permissões restritas:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo chmod 644 /etc/prometheus/prometheus.yml

Passo 4 — Criar serviço systemd

O ficheiro seguinte permite que o systemd gere o Prometheus: arraque automaticamente no boot, reinicie em caso de falha e mantenha logs no journal.

[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 \
–storage.tsdb.retention.time=15d \
–web.console.templates=/etc/prometheus/consoles \
–web.console.libraries=/etc/prometheus/console_libraries \
–web.listen-address=0.0.0.0:9090
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Parâmetros:

Parâmetro Função
--config.file Caminho para o ficheiro de configuração
--storage.tsdb.path Directório onde os dados temporais são guardados
--storage.tsdb.retention.time=15d Mantém 15 dias de histórico (ajustável)
--web.listen-address=0.0.0.0:9090 Escuta em todas as interfaces, porta 9090
Restart=always Reinicia o serviço mesmo se terminar limpo
RestartSec=5 Espera 5 segundos antes de reiniciar

Ativar e iniciar:

sudo systemctl daemon-reload
sudo systemctl enable –now prometheus
sudo systemctl status prometheus

✅ Verificação: Abrir http://IP-DO-SERVIDOR:9090/targets no navegador. Se o alvo prometheus aparecer como “UP”, está a funcionar.

5. Instalar Grafana e ligar ao Prometheus

O Grafana disponibiliza um repositório APT oficial que simplifica a instalação e actualização em Debian/Ubuntu.

Passo 1 — Adicionar repositório APT

O comando seguinte adiciona a chave GPG do Grafana e o repositório oficial à lista de fontes do APT.

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 oss main” | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt update

Parâmetros:

Parâmetro Função
gpg --dearmor Converte a chave ASCII para formato binário
signed-by= Indica ao APT qual chave valida este repositório
oss main Canal open-source (não Enterprise)

Para Red Hat / Fedora:

sudo tee /etc/yum.repos.d/grafana.repo <

Para Arch Linux:

sudo pacman -S –noconfirm grafana

Passo 2 — Instalar e iniciar

sudo apt install -y grafana
sudo systemctl enable –now grafana-server
sudo systemctl status grafana-server

O Grafana escuta por defeito na porta 3000. Abrir http://IP-DO-SERVIDOR:3000 no navegador. O login inicial é admin / admin — o sistema pede para trocar a password imediatamente (Grafana Installation).

Passo 3 — Adicionar Prometheus como fonte de dados

No Grafana, navegar em Connections → Data sources → Add data source → Prometheus e preencher:

Campo Valor Notas
Name Prometheus Nome interno no Grafana
URL http://localhost:9090 Se Grafana e Prometheus estão na mesma máquina
Auth None Para PME, sem auth interna é comum
Scrape interval 15s Deve corresponder ao scrape_interval do Prometheus
Query timeout 30s Tempo máximo para uma consulta PromQL
HTTP method POST Recomendado para consultas grandes

Clicar em Save & test. Se aparecer “Data source is working”, a ligação está funcional.

⚠️ Atenção

Se o Grafana estiver noutra máquina do Prometheus, usar http://IP-DO-PROMETHEUS:9090 e garantir que a porta 9090 está aberta no firewall entre os dois servidores.

6. Configurar exporters para recolha de métricas

Exporters são pequenos programas que expõem métricas de um sistema específico no formato Prometheus. O mais comum é o Node Exporter, que recolhe métricas de hardware e SO (CPU, memória, disco, rede) (Prometheus Installation).

Instalar Node Exporter

O comando seguinte instala o Node Exporter em cada servidor que se pretende monitorizar.

cd /tmp
NODE_VERSION=$(curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest | grep tag_name | cut -d ‘”‘ -f 4)
wget “https://github.com/prometheus/node_exporter/releases/download/${NODE_VERSION}/node_exporter-${NODE_VERSION}.linux-amd64.tar.gz”
tar xvf “node_exporter-${NODE_VERSION}.linux-amd64.tar.gz”
sudo cp “node_exporter-${NODE_VERSION}.linux-amd64/node_exporter” /usr/local/bin/
sudo useradd –system –no-create-home –shell /bin/false node_exporter 2>/dev/null || true

Criar serviço systemd:

[Unit]
Description=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

[Install]
WantedBy=multi-user.target

Guardar como /etc/systemd/system/node_exporter.service e ativar:

sudo systemctl daemon-reload
sudo systemctl enable –now node_exporter
sudo systemctl status node_exporter

Verificar que as métricas estão acessíveis:

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

Exporters adicionais recomendados para PME

Exporter O que monitoriza Porta Instalação
mysqld_exporter MySQL/MariaDB (queries, replicação, buffer pool) 9104 go install ou binário
postgres_exporter PostgreSQL (conexões, cache, locks) 9187 Binário oficial
nginx_exporter Nginx (requests, status, upstreams) 9113 Módulo stub_status
blackbox_exporter Disponibilidade externa (HTTP, ICMP, DNS, TCP) 9115 Binário oficial
smartctl_exporter Estado de discos físicos (SMART) 9633 Requer smartmontools

Exemplo: adicionar MySQL ao prometheus.yml

– job_name: “mysql”
static_configs:
– targets: [“192.168.1.10:9104”]
labels:
service: “base-dados”

Depois de qualquer alteração ao ficheiro, recarregar a configuração sem reiniciar o serviço:

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

ℹ️ Nota: Se o /-/reload não funcionar, adicionar --web.enable-lifecycle ao ExecStart do serviço Prometheus. Sem essa flag, o endpoint de reload fica desactivado por segurança.

7. Construir o primeiro dashboard

Com a fonte de dados ligada, é altura de criar o primeiro painel. O Grafana 11 tem um editor visual que gera PromQL automática para consultas simples, mas vale a pena entender a query manual para ter controlo total (Grafana Dashboards).

Passo 1 — Criar dashboard

Navegar em Dashboards → New → New Dashboard → Add visualization.

Passo 2 — Painel de CPU

Na secção Query, introduzir a seguinte expressão PromQL que calcula a percentagem de CPU usada (excluindo idle):

100 – (avg by (instance) (rate(node_cpu_seconds_total{mode=”idle”}[5m])) * 100)

Explicação da query:

Componente Função
node_cpu_seconds_total{mode="idle"} Segundos acumulados em que a CPU esteve idle
rate(...[5m]) Taxa de variação por segundo numa janela de 5 minutos
avg by (instance) Média por servidor (ignora núcleos individuais)
100 - (...) Inverte: 100% menos idle = uso real
* 100 Converte fracção em percentagem

Configurar o painel:

Campo Valor
Title CPU Usage por Servidor
Unit Percent (0-100)
Decimals 1
Color mode Background
Thresholds 70 (orange), 90 (red)

Passo 3 — Painel de memória

(node_memory_MemTotal_bytes – node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Passo 4 — Painel de disco

100 – (node_filesystem_avail_bytes{mountpoint=”/”,fstype!~”tmpfs|overlay”} / node_filesystem_size_bytes{mountpoint=”/”,fstype!~”tmpfs|overlay”} * 100)

Passo 5 — Importar dashboard comunitário

Em vez de construir tudo do zero, é possível importar dashboards criados pela comunidade. O mais popular para Node Exporter é o ID 1860 (Node Exporter Full).

Navegar em Dashboards → New → Import → 1860 → Load, seleccionar a fonte Prometheus e clicar em Import. O dashboard aparece instantaneamente com dezenas de painéis prontos.

💡 Dica

Explorar mais dashboards em grafana.com/grafana/dashboards. Filtrar por “Node Exporter” ou pela ferramenta que se pretende monitorizar.

8. Alertas e regras de notificação

O Prometheus tem um sistema de alertas nativo baseado em regras PromQL. Quando uma condição se verifica (ex: CPU acima de 90% durante 5 minutos), o Alertmanager envia notificações por email, Slack, Teams ou webhook.

Passo 1 — Instalar Alertmanager

cd /tmp
AM_VERSION=$(curl -s https://api.github.com/repos/prometheus/alertmanager/releases/latest | grep tag_name | cut -d ‘”‘ -f 4)
wget “https://github.com/prometheus/alertmanager/releases/download/${AM_VERSION}/alertmanager-${AM_VERSION}.linux-amd64.tar.gz”
tar xvf “alertmanager-${AM_VERSION}.linux-amd64.tar.gz”
sudo mkdir -p /etc/alertmanager /var/lib/alertmanager
sudo cp “alertmanager-${AM_VERSION}.linux-amd64/alertmanager” /usr/local/bin/
sudo cp “alertmanager-${AM_VERSION}.linux-amd64/amtool” /usr/local/bin/

Passo 2 — Configurar Alertmanager

O ficheiro seguinte define um receptor de email para alertas críticos.

global:
smtp_smarthost: “smtp.exemplo.pt:587”
smtp_from: “[email protected]”
smtp_auth_username: “[email protected]”
smtp_auth_password: “senha-app-aqui”

route:
group_by: [“alertname”, “instance”]
group_wait: 30s
group_interval: 5m
repeat_interval: 4h
receiver: “email-pme”

receivers:
– name: “email-pme”
email_configs:
– to: “[email protected]”
send_resolved: true

Parâmetros:

Parâmetro Função
smtp_smarthost Servidor SMTP e porta para envio
group_by Agrupa alertas com mesmo nome e instância
group_wait Tempo até enviar o primeiro alerta de um grupo
group_interval Intervalo entre notificações do mesmo grupo
repeat_interval Tempo até reenviar alerta não resolvido
send_resolved Envia notificação quando alerta deixa de se verificar

Passo 3 — Definir regras de alerta no Prometheus

Criar /etc/prometheus/rules.yml:

groups:
– name: regras-pme
rules:
– alert: AltaCpu
expr: 100 – (avg by (instance) (rate(node_cpu_seconds_total{mode=”idle”}[5m])) * 100) > 90
for: 5m
labels:
severity: critico
annotations:
summary: “CPU acima de 90% em {{ $labels.instance }}”
description: “Uso de CPU sustentado acima de 90% durante 5 minutos.”

– alert: DiscoCheio
expr: 100 – (node_filesystem_avail_bytes / node_filesystem_size_bytes * 100) > 85
for: 10m
labels:
severity: aviso
annotations:
summary: “Disco acima de 85% em {{ $labels.instance }}”
description: “Partição {{ $labels.mountpoint }} com pouco espaço.”

– alert: ServidorDown
expr: up{job=”node_exporters”} == 0
for: 1m
labels:
severity: critico
annotations:
summary: “Servidor {{ $labels.instance }} indisponível”
description: “Node Exporter não responde há mais de 1 minuto.”

Adicionar ao prometheus.yml:

rule_files:
– “rules.yml”

alerting:
alertmanagers:
– static_configs:
– targets: [“localhost:9093”]

Reiniciar ambos os serviços:

sudo systemctl restart prometheus alertmanager

Passo 4 — Alertas no Grafana

O Grafana 11 também permite definir alertas directamente no dashboard, sem precisar do Alertmanager. Navegar em Alerting → Alert rules → New alert rule e usar o editor visual. Para PME que preferem simplicidade, esta opção é mais rápida, embora menos flexível que as regras PromQL nativas.

ℹ️ Nota: Não duplicar alertas — se definir regras no Prometheus e no Grafana para a mesma métrica, vai receber notificações duplicadas. Escolher uma abordagem e manter consistência.

9. Segurança, utilizadores e permissões

Por defeito, o Grafana vem com login admin/admin, o que obviamente não é aceitável em produção. Esta secção cobre as medidas essenciais para uma PME.

Alterar password e criar utilizadores

Navegar em Administration → Users → Add user. Para cada elemento da equipa, criar uma conta com role adequada:

Role Permissões Uso recomendado
Viewer Ver dashboards, não editar Gestores, stakeholders
Editor Editar dashboards, não gerir fontes Devs, técnicos de operação
Admin Controlo total Sysadmins principais

ativar HTTPS

Para PME, a forma mais simples de proteger o acesso é colocar um reverse proxy Nginx à frente do Grafana com certificados Let’s Encrypt.

sudo apt install -y nginx certbot python3-certbot-nginx

Configurar Nginx:

server {
listen 80;
server_name grafana.exemplo.pt;

location / {
proxy_pass http://localhost:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}

Obter certificado:

sudo certbot –nginx -d grafana.exemplo.pt

Parâmetros:

Parâmetro Função
proxy_pass Encaminha tráfego para o Grafana na porta 3000
X-Real-IP Passa o IP real do cliente ao Grafana
X-Forwarded-Proto Indica que o pedido original veio por HTTPS
certbot --nginx Gera certificado e configura Nginx automaticamente

desativar registo aberto

No ficheiro /etc/grafana/grafana.ini:

[users]
allow_sign_up = false
allow_org_create = false
auto_assign_org = false

[auth.anonymous]
enabled = false

Reiniciar Grafana:

sudo systemctl restart grafana-server

⚠️ Atenção

Se o Grafana estiver acessível pela Internet sem HTTPS e sem proxy, qualquer pessoa pode tentar aceder. Usar sempre HTTPS ou restringir o acesso por VPN/IP no firewall.

10. Erros Comuns

Problema Causa Solução
Data source “client_error” Grafana não consegue chegar ao Prometheus Verificar URL da fonte; confirmar que a porta 9090 está aberta; testar com curl http://IP:9090/-/healthy
Targets em “DOWN” no Prometheus Node Exporter não corre ou firewall bloqueia Verificar systemctl status node_exporter no alvo; confirmar curl http://IP:9100/metrics
Dashboard vazio sem dados Métrica não existe ou label não corresponde Verificar na consola Prometheus (http://IP:9090/graph) se a query devolve valores; ajustar labels
Disco cheio do Prometheus Retention muito longo ou muitos exporters Reduzir retention.time; adicionar disco; considerar retention.size como limite adicional
Alertas não chegam por email SMTP mal configurado ou porta bloqueada Verificar credenciais no alertmanager.yml; testar conectividade telnet smtp.exemplo.pt 587; consultar logs do Alertmanager
Grafana login admin/admin não funciona Password já foi alterada Recuperar com grafana-cli admin reset-admin-password nova-senha
Painel mostra “No data” só em alguns servidores Node Exporter não instalado nesse servidor Instalar Node Exporter em todos os alvos listados em targets
Consumo de RAM elevado pelo Prometheus Muitas séries ou scrape_interval muito baixo Aumentar scrape_interval para 30s; reduzir exporters; ativar compaction

11. Checklist rápido de verificação

  • [ ] Prometheus instalado e a correr (systemctl status prometheus → active)
  • [ ] http://IP:9090/targets mostra todos os alvos como “UP”
  • [ ] Node Exporter instalado em todos os servidores monitorizados
  • [ ] Grafana instalado e acessível em http://IP:3000
  • [ ] Password admin alterada e registo aberto desactivado
  • [ ] Prometheus adicionado como data source no Grafana (“Save & test” → verde)
  • [ ] Pelo menos um dashboard criado ou importado (ID 1860 recomendado)
  • [ ] Ficheiro prometheus.yml validado com promtool check config
  • [ ] Alertmanager instalado e regras definidas em rules.yml
  • [ ] Teste de alerta disparado manualmente (parar Node Exporter e verificar notificação)
  • [ ] HTTPS activado via Nginx + Let’s Encrypt (ou acesso restrito por VPN)
  • [ ] Backup do /var/lib/prometheus e /etc/grafana configurado
  • [ ] Retention do Prometheus definido (15-30 dias conforme volume)

Artigos Relacionados

← Voltar ao Índice