Monitorizar CPU, RAM e rede de servidores auto-hospedados com Prometheus e Grafana no Ubuntu Server

Quem gere mesmo que apenas alguns servidores auto-hospedados — um NAS, um VPS para projetos pessoais, um pequeno homelab com duas ou três máquinas — acaba sempre a fazer a mesma pergunta: como saber se um nó está a ficar sem RAM, se a CPU está sob forte carga, ou se o tráfego de rede tem um pico anómalo, sem ter de aceder manualmente de cada vez? A resposta mais difundida no mundo open source é uma dupla de ferramentas que se tornou um padrão de facto: Prometheus para recolher as métricas e Grafana para as apresentar em painéis claros e personalizáveis.

Neste guia vamos montar um cluster de monitorização leve no Ubuntu Server, pensado para vigiar a CPU, a RAM e o tráfego de rede de vários nós auto-hospedados, com um impacto mínimo nos recursos das máquinas monitorizadas. Não é preciso ser um administrador de sistemas experiente: cada passo é explicado juntamente com os conceitos básicos subjacentes.

Por que monitorizar os seus servidores auto-hospedados

Quem hospeda os próprios serviços — um site, um servidor de e-mail, um NAS, uma instância do Nextcloud ou um pequeno cluster para projetos pessoais — muitas vezes só descobre os problemas quando o serviço já está inacessível: disco cheio, memória esgotada por um processo com fuga, uma interface de rede saturada de tráfego. Um sistema de monitorização permite:

• Detetar sinais de alerta com antecedência: um uso de RAM que cresce de forma constante durante vários dias antes de uma falha, por exemplo, é visível num gráfico muito antes de se tornar um problema real.
• Compreender as causas das lentidões: se um site responde lentamente, um gráfico histórico de CPU e I/O de rede ajuda a determinar se a causa é um pico de carga ou outra coisa.
• Planear atualizações: observar o uso de recursos ao longo do tempo é a forma mais simples de saber quando é realmente necessário mais RAM ou largura de banda, em vez de atualizar "por sensação".
• Receber alertas: uma vez recolhidas as métricas, é possível configurar alertas automáticos (por exemplo através do Alertmanager, a ferramenta complementar do Prometheus) sempre que um limite for ultrapassado.

As ferramentas: Prometheus, Node Exporter e Grafana

Antes de instalar qualquer coisa, vale a pena entender o que cada componente faz, já que a stack é composta por três peças distintas que trabalham em conjunto:

• Prometheus é uma base de dados de séries temporais especializada na recolha de métricas. Ao contrário de muitos sistemas de monitorização mais antigos, o Prometheus funciona num modelo de "pull": a intervalos regulares, é ele que consulta as máquinas monitorizadas para pedir os dados mais recentes, em vez de esperar que essas máquinas os enviem.
• Node Exporter é um pequeno programa que precisa de ser instalado em cada máquina que se queira monitorizar. A sua função é expor as métricas do sistema (uso de CPU, RAM, disco, interfaces de rede, etc.) num formato que o Prometheus consiga ler, através de uma simples página web interna na porta 9100.
• Grafana é a camada visual: liga-se ao Prometheus como "fonte de dados" e permite construir painéis com gráficos, limites coloridos, alertas visuais e muito mais, sem precisar de escrever código.

Na prática: o Node Exporter recolhe os dados em bruto em cada nó, o Prometheus vai buscá-los periodicamente e armazena-os, e o Grafana lê-os a partir do Prometheus e representa-os.

Requisitos e arquitetura do cluster leve

Para este guia partimos de uma arquitetura simples mas realista para um homelab ou um pequeno conjunto de VPS:

• Um nó "central" com Ubuntu Server (tanto serve a versão 24.04 LTS, ainda a mais usada em muitos homelabs, como a mais recente 26.04 LTS), onde instalaremos o Prometheus e o Grafana. 1 vCPU e 1-2 GB de RAM são suficientes para monitorizar cerca de dez nós com métricas básicas.
• Um ou mais nós "a monitorizar" (podendo incluir o próprio nó central), em cada um dos quais instalaremos apenas o Node Exporter, um processo extremamente leve (poucos MB de RAM).
• Acesso SSH com privilégios sudo em todas as máquinas envolvidas.

A grande vantagem desta combinação é precisamente a sua leveza: ao contrário de soluções mais pesadas baseadas em agentes complexos ou bases de dados relacionais, o Prometheus e o Node Exporter são escritos em Go, compilados como binários únicos sem dependências a instalar, e pensados para consumir muito poucos recursos mesmo em hardware modesto (um Raspberry Pi ou um VPS económico funcionam perfeitamente).

Passo 1: instalar o Prometheus no nó central

Liguemo-nos via SSH ao nó central e criemos primeiro um utilizador de sistema dedicado, para que o Prometheus não seja executado com privilégios de root:

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

A seguir, descarregamos a versão estável mais recente do Prometheus (a série 3.x no momento em que este artigo foi escrito) a partir da página oficial de downloads. É boa prática verificar sempre a versão mais recente disponível em prometheus.io/download antes de continuar:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v3.15.1/prometheus-3.15.1.linux-amd64.tar.gz
tar xvf prometheus-3.15.1.linux-amd64.tar.gz
cd prometheus-3.15.1.linux-amd64

sudo cp prometheus promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles /etc/prometheus/console_libraries

Passo 2: criar o serviço systemd do Prometheus

Para que o Prometheus arranque automaticamente quando o servidor inicia e seja gerido pelo systemd (o componente do Ubuntu responsável por iniciar e supervisionar os serviços em segundo plano), vamos criar um ficheiro de unidade:

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

com o seguinte conteúdo:

[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
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 \
  --web.listen-address=0.0.0.0:9090
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Criemos também um ficheiro prometheus.yml mínimo para começar (vamos completá-lo no Passo 4):

sudo nano /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

Depois, iniciamos e ativamos o serviço:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Verificamos que está ativo com sudo systemctl status prometheus: deve mostrar active (running) em verde. Neste ponto, a interface web do Prometheus já está acessível em http://IP-DO-NO-CENTRAL:9090.

Passo 3: instalar o Node Exporter em cada nó a monitorizar

Este passo deve ser repetido em cada nó que se queira monitorizar (incluindo o nó central, caso também se queira monitorizar os seus próprios recursos). Criamos um utilizador dedicado e instalamos o binário:

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

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

Criamos também o serviço systemd para o Node Exporter:

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

[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
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

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

O Node Exporter expõe agora as métricas em bruto na porta 9100: podemos verificar isso com curl http://localhost:9100/metrics, que deve devolver centenas de linhas de dados sobre CPU, memória, sistemas de ficheiros e interfaces de rede.

Passo 4: configurar o Prometheus para recolher as métricas de todos os nós

Voltamos ao nó central e atualizamos /etc/prometheus/prometheus.yml, adicionando um "job" para cada nó a monitorizar, com o respetivo endereço IP e a porta 9100 do Node Exporter:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: "node_exporter"
    static_configs:
      - targets:
          - "localhost:9100"
          - "192.168.1.11:9100"
          - "192.168.1.12:9100"

Depois de cada alteração a este ficheiro, convém verificar a sua sintaxe com promtool check config /etc/prometheus/prometheus.yml e depois recarregar a configuração sem reiniciar o serviço:

sudo systemctl reload prometheus

A partir da interface do Prometheus (http://IP-DO-NO-CENTRAL:9090/targets) podemos verificar que todos os nós aparecem com o estado UP: esse é o sinal de que o Prometheus os está a consultar com sucesso.

Passo 5: abrir as portas necessárias na firewall

Se o ufw (a firewall predefinida do Ubuntu) estiver ativo nos nós, é preciso abrir as portas necessárias. No nó central, para permitir o acesso à interface do Prometheus e, mais tarde, à do Grafana:

sudo ufw allow 9090/tcp
sudo ufw allow 3000/tcp

Em cada nó monitorizado, por outro lado, a porta 9100 do Node Exporter deve ser aberta apenas para o endereço IP do nó central, e não para toda a Internet, de modo a não expor as métricas do sistema a qualquer pessoa:

sudo ufw allow from 192.168.1.10 to any port 9100 proto tcp

(substituindo 192.168.1.10 pelo IP real do nó central).

Passo 6: instalar o Grafana

O Grafana instala-se de forma mais prática através do repositório APT oficial, o que simplifica futuras atualizações com apt upgrade. No nó central:

sudo apt-get install -y apt-transport-https wget gnupg

sudo mkdir -p /etc/apt/keyrings
sudo wget -q -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

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

sudo apt-get update
sudo apt-get install -y grafana

Iniciamos e ativamos o serviço:

sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server

O Grafana já está acessível em http://IP-DO-NO-CENTRAL:3000. As credenciais predefinidas no primeiro acesso são admin / admin: o Grafana vai pedir imediatamente para alterar a palavra-passe, algo que se deve sempre fazer, especialmente se o servidor estiver exposto à Internet.

Passo 7: ligar o Grafana ao Prometheus

Uma vez dentro da interface do Grafana:

• No menu lateral, vamos a Connections > Data sources e escolhemos Add data source.
• Selecionamos Prometheus na lista.
• No campo URL, introduzimos http://localhost:9090 (visto que o Prometheus corre na mesma máquina; se estivesse noutro local, seria preciso usar o seu endereço IP).
• Clicamos em Save & test: se tudo estiver configurado corretamente, aparecerá uma mensagem de sucesso.

Passo 8: importar um painel já pronto para CPU, RAM e tráfego de rede

Não é preciso construir os gráficos do zero: a comunidade do Grafana partilha painéis já prontos e gratuitos. O mais utilizado para o Node Exporter é o painel "Node Exporter Full" (ID 1860), que mostra num único painel a CPU, a RAM, o espaço em disco, a I/O e o tráfego de rede de cada nó monitorizado.

Para o importar:

• No menu lateral, Dashboards > New > Import.
• No campo "Import via grafana.com", introduzimos 1860 e clicamos em Load.
• Selecionamos como fonte de dados a do Prometheus que acabámos de criar, e depois Import.

Em poucos segundos, o painel enche-se com dados reais de todos os nós monitorizados, com a possibilidade de escolher o nó a mostrar num menu pendente no topo.

Dicas para uma monitorização segura e sustentável

• Nunca exponha o Prometheus e o Node Exporter diretamente à Internet. Nenhum dos dois tem, por padrão, um sistema de autenticação: devem ficar numa rede privada (LAN, VPN como WireGuard ou Tailscale) ou por detrás de um proxy inverso com autenticação.
• Coloque o Grafana por detrás de HTTPS se for acessível a partir da Internet, por exemplo com um proxy inverso Nginx e um certificado Let's Encrypt.
• Defina um período de retenção de dados razoável. Por padrão, o Prometheus mantém os dados durante 15 dias; num homelab com pouco espaço em disco pode ser útil reduzir esse valor com a opção --storage.tsdb.retention.time, ou aumentá-lo se houver mais espaço disponível.
• Considere o Alertmanager para receber notificações automáticas (e-mail, Telegram, etc.) sempre que uma métrica ultrapassar um limite crítico, em vez de ter de verificar os painéis manualmente.
• Atualize periodicamente o Prometheus e o Node Exporter: sendo binários únicos, a atualização consiste simplesmente em repetir os passos de download e substituição do ficheiro, enquanto o Grafana se atualiza com apt upgrade depois de configurado o repositório.

Conclusão

Com apenas alguns comandos e um impacto mínimo nos recursos, o Prometheus, o Node Exporter e o Grafana permitem construir um sistema de monitorização de nível profissional mesmo para um simples homelab ou um pequeno conjunto de servidores pessoais. Depois de ganhar confiança com a stack, é fácil alargá-la com novos jobs de scraping (por exemplo para monitorizar também serviços de aplicação, e não apenas o hardware), novos painéis da comunidade e alertas automáticos através do Alertmanager.

Fontes oficiais

• Prometheus — Monitoring Linux host metrics with the Node Exporter
• Prometheus — página oficial de downloads
• Grafana — instalação em Debian/Ubuntu (documentação oficial)
• Grafana — painel da comunidade "Node Exporter Full" (ID 1860)