Monitorare CPU, RAM e rete dei server self-hosted con Prometheus e Grafana su Ubuntu Server

Chi gestisce anche solo un paio di server self-hosted — un NAS, una VPS per i propri progetti, un piccolo homelab con due o tre macchine — arriva presto a farsi la stessa domanda: come faccio a sapere se un nodo sta per esaurire la RAM, se la CPU è sotto stress o se il traffico di rete sta avendo un picco anomalo, senza doverci accedere manualmente ogni volta? La risposta più diffusa nel mondo open source è una coppia di strumenti ormai diventata uno standard de facto: Prometheus per la raccolta delle metriche e Grafana per visualizzarle in dashboard chiare e personalizzabili.

In questa guida vediamo come mettere in piedi un cluster di monitoraggio leggero su Ubuntu Server, pensato per tenere sotto controllo CPU, memoria RAM e traffico di rete di più nodi self-hosted, con un impatto minimo sulle risorse delle macchine monitorate. Non serve essere amministratori di sistema esperti: ogni passaggio è spiegato anche nei concetti di base.

Perché monitorare i propri server self-hosted

Chi ospita servizi in proprio — un sito, un server di posta, un NAS, un'istanza Nextcloud o un piccolo cluster per progetti personali — spesso scopre i problemi solo quando il servizio è già irraggiungibile: disco pieno, memoria esaurita da un processo che perde RAM, una interfaccia di rete satura di traffico. Un sistema di monitoraggio permette di:

• Vedere in anticipo i segnali: un uso di RAM che cresce costantemente nei giorni prima di un crash, ad esempio, è visibile su un grafico molto prima che diventi un problema.
• Capire le cause dei rallentamenti: se un sito risponde lentamente, un grafico storico di CPU e I/O di rete aiuta a capire se la causa è un picco di carico o qualcos'altro.
• Pianificare gli upgrade: osservare l'uso delle risorse nel tempo è il modo più semplice per sapere quando serve davvero più RAM o banda, evitando upgrade fatti "a sensazione".
• Ricevere notifiche: una volta raccolte le metriche, è possibile impostare avvisi automatici (ad esempio via Alertmanager, lo strumento companion di Prometheus) quando una soglia viene superata.

Gli strumenti: Prometheus, Node Exporter e Grafana

Prima di installare qualcosa, vale la pena capire cosa fa ciascun componente, perché lo stack è composto da tre pezzi distinti che lavorano insieme:

• Prometheus è un database di serie temporali (time-series database) specializzato nella raccolta di metriche. A differenza di molti sistemi di monitoraggio più vecchi, Prometheus funziona a "pull": è lui che, a intervalli regolari, va a interrogare le macchine da monitorare per chiedere i dati più recenti, invece di aspettare che siano le macchine a inviarglieli.
• Node Exporter è un piccolo programma che va installato su ogni macchina che si vuole monitorare. Il suo compito è esporre le metriche di sistema (uso di CPU, RAM, disco, interfacce di rete, ecc.) in un formato che Prometheus sa leggere, tramite una semplice pagina web interna sulla porta 9100.
• Grafana è la parte visiva: si collega a Prometheus come "fonte dati" (data source) e permette di costruire dashboard con grafici, soglie colorate, allarmi visivi e molto altro, senza dover scrivere codice.

In pratica: Node Exporter raccoglie i dati grezzi su ogni nodo, Prometheus li va a prendere periodicamente e li archivia, Grafana li legge da Prometheus e li disegna.

Requisiti e architettura del cluster leggero

Per questa guida ipotizziamo un'architettura semplice ma realistica per un homelab o un piccolo set di VPS:

• Un nodo "centrale" con Ubuntu Server (va bene la versione 24.04 LTS, ancora la più diffusa su molti homelab, così come la più recente 26.04 LTS), su cui installeremo Prometheus e Grafana. Bastano 1 vCPU e 1-2 GB di RAM per monitorare una decina di nodi con metriche di base.
• Uno o più nodi "da monitorare" (compreso eventualmente lo stesso nodo centrale), su ciascuno dei quali installeremo solo Node Exporter, un processo estremamente leggero (pochi MB di RAM).
• Accesso SSH con permessi sudo su tutte le macchine coinvolte.

Il grosso vantaggio di questa accoppiata è proprio la leggerezza: a differenza di soluzioni più pesanti basate su agenti complessi o database relazionali, Prometheus e Node Exporter sono scritti in Go, compilati come binari singoli senza dipendenze da installare, e pensati per consumare pochissime risorse anche su hardware modesto (va benissimo anche un Raspberry Pi o una VPS economica).

Passo 1: installare Prometheus sul nodo centrale

Colleghiamoci via SSH al nodo centrale e creiamo prima un utente di sistema dedicato, così Prometheus non girerà con privilegi 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

Scarichiamo quindi l'ultima versione stabile di Prometheus (al momento della scrittura la serie 3.x) dalla pagina ufficiale dei download. È buona norma controllare sempre la versione più recente disponibile su prometheus.io/download prima di procedere:

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: creare il servizio systemd di Prometheus

Per far partire Prometheus automaticamente all'avvio del server e farlo gestire da systemd (il sistema che su Ubuntu si occupa di avviare e tenere sotto controllo i servizi in background), creiamo un file di unità:

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

con questo contenuto:

[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

Creiamo anche un file prometheus.yml minimo di partenza (lo completeremo al 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"]

Poi avviamo e abilitiamo il servizio:

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

Verifichiamo che sia attivo con sudo systemctl status prometheus: dovrebbe mostrare active (running) in verde. A questo punto l'interfaccia web di Prometheus è già raggiungibile su http://IP-DEL-NODO-CENTRALE:9090.

Passo 3: installare Node Exporter su ogni nodo da monitorare

Questo passaggio va ripetuto su ciascun nodo che si vuole monitorare (incluso il nodo centrale, se vogliamo monitorare anche le sue risorse). Creiamo un utente dedicato e installiamo il binario:

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

Creiamo il servizio systemd anche per 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

Node Exporter espone ora le metriche grezze sulla porta 9100: possiamo verificarlo con curl http://localhost:9100/metrics, che dovrebbe restituire centinaia di righe di dati su CPU, memoria, filesystem e interfacce di rete.

Passo 4: configurare Prometheus per raccogliere le metriche di tutti i nodi

Torniamo sul nodo centrale e aggiorniamo /etc/prometheus/prometheus.yml aggiungendo un "job" per ogni nodo da monitorare, con il relativo indirizzo IP e la porta 9100 di 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"

Dopo ogni modifica di questo file conviene verificarne la sintassi con promtool check config /etc/prometheus/prometheus.yml, quindi ricaricare la configurazione senza riavviare il servizio:

sudo systemctl reload prometheus

Dall'interfaccia di Prometheus (http://IP-DEL-NODO-CENTRALE:9090/targets) possiamo verificare che tutti i nodi appaiano con stato UP: è il segnale che Prometheus li sta effettivamente interrogando con successo.

Passo 5: aprire le porte necessarie nel firewall

Se sui nodi è attivo ufw (il firewall predefinito di Ubuntu), vanno aperte le porte necessarie. Sul nodo centrale, per permettere l'accesso all'interfaccia di Prometheus e, più avanti, di Grafana:

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

Su ogni nodo monitorato, invece, la porta 9100 di Node Exporter va aperta solo verso l'indirizzo IP del nodo centrale, non verso tutto Internet, per non esporre metriche di sistema a chiunque:

sudo ufw allow from 192.168.1.10 to any port 9100 proto tcp

(sostituendo 192.168.1.10 con l'IP reale del nodo centrale).

Passo 6: installare Grafana

Grafana si installa più comodamente tramite il repository APT ufficiale, che garantisce aggiornamenti futuri semplici con apt upgrade. Sul nodo centrale:

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

Avviamo e abilitiamo il servizio:

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

Grafana è ora raggiungibile su http://IP-DEL-NODO-CENTRALE:3000. Le credenziali predefinite al primo accesso sono admin / admin: Grafana chiederà subito di cambiare la password, operazione da fare sempre, specialmente se il server è esposto su Internet.

Passo 7: collegare Grafana a Prometheus

Una volta dentro l'interfaccia di Grafana:

• Dal menu laterale, andiamo su Connections > Data sources e scegliamo Add data source.
• Selezioniamo Prometheus dall'elenco.
• Nel campo URL inseriamo http://localhost:9090 (dato che Prometheus gira sulla stessa macchina; se fosse altrove, va usato il suo indirizzo IP).
• Clicchiamo su Save & test: se tutto è configurato correttamente, apparirà un messaggio di connessione riuscita.

Passo 8: importare una dashboard pronta per CPU, RAM e traffico di rete

Non è necessario costruire i grafici da zero: la community di Grafana condivide dashboard già pronte e gratuite. La più usata per Node Exporter è la dashboard "Node Exporter Full" (ID 1860), che mostra in un unico pannello CPU, memoria RAM, spazio disco, I/O e traffico di rete di ogni nodo monitorato.

Per importarla:

• Dal menu laterale, Dashboards > New > Import.
• Nel campo "Import via grafana.com" inseriamo 1860 e clicchiamo Load.
• Selezioniamo come data source la fonte Prometheus appena creata, poi Import.

In pochi secondi la dashboard si popola con i dati reali di tutti i nodi monitorati, con la possibilità di scegliere il nodo da visualizzare da un menu a tendina in alto.

Consigli per un monitoraggio sicuro e sostenibile

• Non esporre Prometheus e Node Exporter direttamente su Internet. Nessuno dei due ha, di default, un sistema di autenticazione: vanno tenuti su rete privata (LAN, VPN come WireGuard o Tailscale) oppure dietro un reverse proxy con autenticazione.
• Metti Grafana dietro HTTPS se è raggiungibile da Internet, ad esempio con un reverse proxy Nginx e un certificato Let's Encrypt.
• Imposta una retention dei dati ragionevole. Per impostazione predefinita Prometheus conserva i dati per 15 giorni; su un homelab con poco spazio disco può essere utile ridurla con il flag --storage.tsdb.retention.time, oppure aumentarla se si dispone di più spazio.
• Valuta Alertmanager per ricevere notifiche automatiche (email, Telegram, ecc.) quando una metrica supera una soglia critica, invece di dover controllare le dashboard manualmente.
• Aggiorna periodicamente Prometheus e Node Exporter: essendo binari singoli, l'aggiornamento consiste semplicemente nel ripetere i passaggi di download e sostituzione del file, mentre Grafana si aggiorna con apt upgrade una volta configurato il repository.

Conclusione

Con pochi comandi e un impatto minimo sulle risorse, Prometheus, Node Exporter e Grafana permettono di costruire un sistema di monitoraggio professionale anche per un semplice homelab o un piccolo set di server personali. Una volta presa confidenza con lo stack, è facile ampliarlo con nuovi job di scraping (ad esempio per monitorare anche servizi applicativi, non solo l'hardware), nuove dashboard della community, e allarmi automatici tramite Alertmanager.

Fonti ufficiali

• Prometheus — Monitoring Linux host metrics with the Node Exporter
• Prometheus — pagina ufficiale dei download
• Grafana — installazione su Debian/Ubuntu (documentazione ufficiale)
• Grafana — dashboard community "Node Exporter Full" (ID 1860)