Home Chi Sono
Servizi ▼
WordPress Sviluppo Web Server & Hosting Assistenza Tecnica Windows Android
Blog ▼
Tutti gli Articoli WordPress Hosting Plesk Assistenza Computer Windows Android A.I.
Contatti

Come Monitoro le Risorse Server su Plesk con Grafana e Prometheus: Guida al Setup Completo

Se gestisci uno o più server con Plesk, saprai bene quanto sia fondamentale avere visibilità in tempo reale su CPU, RAM, disco e rete. Per anni mi sono affidato ai grafici base del pannello, ma quando ho iniziato a gestire più macchine contemporaneamente ho capito che serviva qualcosa di più potente. La risposta? Grafana e Prometheus: il duo che oggi rappresenta lo standard de facto per il monitoraggio server professionale.

In questa guida vi mostro passo dopo passo come ho configurato il mio stack di monitoring su un server Plesk con Prometheus, Node Exporter e Grafana, ottenendo dashboard interattive, alerting via email e una visione completa della salute dell’infrastruttura. Non è una guida teorica: è la procedura che uso in produzione, con i problemi che ho incontrato e le soluzioni che hanno funzionato.

Se avete già letto la mia guida su come configuro i cronjob su Plesk per automatizzare backup e manutenzione, saprete che mi piace avere il server sotto controllo. Questo articolo è il passo successivo: monitorare tutto con dashboard professionali.

Perché Monitorare il Server Plesk con Grafana e Prometheus

Plesk offre già un sistema di Monitoring integrato basato sull’estensione Advanced Monitoring, che lavora in tandem con l’estensione Grafana ufficiale per visualizzare le metriche del server. Tuttavia, nella mia esperienza, questo approccio ha diversi limiti: la versione di Grafana inclusa è datata, i dashboard non sono personalizzabili a fondo e non è possibile centralizzare il monitoraggio di più server in un’unica interfaccia.

Installando Prometheus come sistema di raccolta metriche e un’istanza Grafana esterna e aggiornata, si ottiene una soluzione flessibile, scalabile e completamente sotto il proprio controllo. Prometheus utilizza un modello pull-based: interroga periodicamente gli endpoint HTTP che espongono metriche (tipicamente sulla porta 9100 tramite Node Exporter), le immagazzina come time-series data e le rende interrogabili tramite PromQL.

Grafana, dal canto suo, si collega a Prometheus come data source e trasforma quei dati grezzi in grafici, gauge e tabelle interattive. In più, offre un potente sistema di alerting che vi notifica quando qualcosa non va — ad esempio se la CPU supera l’80% per più di 5 minuti.

Prerequisiti e Architettura dello Stack di Monitoring

Prima di iniziare, ecco cosa vi serve:

  • Un server con Plesk Obsidian (18.x) su Linux (Ubuntu 22.04/24.04 o AlmaLinux 8/9)
  • Accesso SSH root al server
  • Porte 9090 (Prometheus), 9100 (Node Exporter) e 3000 (Grafana) disponibili
  • Almeno 1 GB di RAM libera per lo stack completo

L’architettura è semplice: Node Exporter gira sul server Plesk ed espone le metriche hardware su localhost:9100/metrics. Prometheus effettua lo scraping di queste metriche ogni 15 secondi e le salva nel suo database time-series. Grafana si collega a Prometheus e visualizza tutto su dashboard personalizzabili.

Step 1: Installare Node Exporter sul Server Plesk

Node Exporter è l’agente leggero che espone le metriche hardware e kernel del sistema operativo. È il componente ufficiale di Prometheus per il monitoraggio di host Linux.

Download e installazione

Collegatevi in SSH al server e scaricate l’ultima versione stabile:

# Creare un utente dedicato per sicurezza
useradd --no-create-home --shell /bin/false node_exporter

# Scaricare Node Exporter (verificate l'ultima versione su github.com/prometheus/node_exporter/releases)
wget https://github.com/prometheus/node_exporter/releases/download/v1.10.2/node_exporter-1.10.2.linux-amd64.tar.gz

# Estrarre e installare il binario
tar xvfz node_exporter-1.10.2.linux-amd64.tar.gz
sudo mv node_exporter-1.10.2.linux-amd64/node_exporter /usr/local/bin/

# Impostare i permessi
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Creare il servizio systemd

Per far partire Node Exporter automaticamente al boot, create un file di servizio:

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

Inserite questo contenuto:

[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

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

[Install]
WantedBy=multi-user.target

Attivate e avviate il servizio:

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

Verificate che le metriche siano esposte visitando http://IP-SERVER:9100/metrics nel browser. Dovreste vedere una lunga lista di metriche in formato testo. All’inizio non funzionava perché il firewall di Plesk bloccava la porta 9100: ho dovuto aggiungere una regola specifica.

Step 2: Installare e Configurare Prometheus

Prometheus è il cuore del sistema: raccoglie, salva e rende interrogabili tutte le metriche.

Download e installazione

# Creare utente dedicato
useradd --no-create-home --shell /bin/false prometheus

# Creare le directory necessarie
sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

# Scaricare Prometheus
wget https://github.com/prometheus/prometheus/releases/download/v3.2.1/prometheus-3.2.1.linux-amd64.tar.gz
tar xvfz prometheus-3.2.1.linux-amd64.tar.gz
cd prometheus-3.2.1.linux-amd64

# Copiare i binari
sudo mv prometheus /usr/local/bin/
sudo mv promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

# Copiare i file di configurazione
sudo mv consoles /etc/prometheus
sudo mv console_libraries /etc/prometheus
sudo chown -R prometheus:prometheus /etc/prometheus

Configurare prometheus.yml

Il file di configurazione principale è dove definite cosa monitorare. Createlo così:

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

scrape_configs:
  # Monitorare Prometheus stesso
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # Monitorare il server Plesk tramite Node Exporter
  - job_name: 'plesk_server'
    static_configs:
      - targets: ['localhost:9100']
        labels:
          instance_name: 'plesk-main'
          environment: 'production'

Lo scrape_interval di 15 secondi è il valore standard. Vi consiglio di non scendere sotto i 10 secondi a meno che non abbiate esigenze specifiche, perché aumenta il carico sul database time-series.

Creare il servizio systemd per Prometheus

sudo nano /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Monitoring System
After=network.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=30d 
  --web.console.templates=/etc/prometheus/consoles 
  --web.console.libraries=/etc/prometheus/console_libraries
Restart=always

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

Verificate che Prometheus sia attivo su http://IP-SERVER:9090. Nella sezione Status → Targets dovreste vedere sia prometheus che plesk_server con stato UP.

Step 3: Installare Grafana sul Server Plesk

Plesk offre un’estensione Grafana nel suo marketplace, ma io preferisco installare Grafana in modo indipendente per avere sempre l’ultima versione e pieno controllo. Ecco come fare su sistemi Debian/Ubuntu:

# Aggiungere il repository 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

# Installare Grafana OSS
sudo apt-get update
sudo apt-get install grafana

# Avviare e abilitare il servizio
sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server

Grafana è ora accessibile su http://IP-SERVER:3000. Le credenziali di default sono admin/admin: vi verrà chiesto di cambiarle al primo accesso. Vi consiglio vivamente di farlo subito.

Step 4: Collegare Prometheus a Grafana e Creare le Dashboard

Aggiungere Prometheus come Data Source

Una volta loggati in Grafana:

  1. Andate su Configuration → Data Sources (icona ingranaggio nella sidebar)
  2. Cliccate su Add data source
  3. Selezionate Prometheus
  4. Nel campo URL inserite: http://localhost:9090
  5. Cliccate Save & Test

Se tutto è configurato correttamente, vedrete il messaggio verde “Data source is working”. Se ricevete errori di connessione, verificate che Prometheus sia in ascolto e che non ci siano regole firewall che bloccano la comunicazione sulla porta 9090.

Importare una dashboard pre-configurata

Invece di costruire tutto da zero, potete importare una delle tante dashboard community. La mia preferita per il monitoraggio server è la Node Exporter Full (ID: 1860):

  1. Andate su Dashboards → Import
  2. Inserite l’ID 1860 nel campo
  3. Cliccate Load
  4. Selezionate il data source Prometheus configurato
  5. Cliccate Import

In pochi secondi avrete una dashboard completa con CPU usage, RAM, disco, I/O, rete, uptime e decine di altre metriche, tutte aggiornate in tempo reale. È stato un momento davvero soddisfacente vedere finalmente tutto il server “in un colpo d’occhio”.

Step 5: Configurare gli Alert su Grafana

Le dashboard sono utilissime, ma il vero valore del monitoring sta negli alert automatici. Grafana permette di creare regole di alerting direttamente dall’interfaccia. Ecco un esempio pratico per ricevere un alert quando la CPU supera l’80%:

  1. Aprite un pannello della dashboard
  2. Cliccate Edit → Alert
  3. Create una nuova regola con questa query PromQL: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
  4. Impostate la condizione “for 5m” (evita falsi positivi da spike momentanei)
  5. Configurate il notification channel (email, Slack, Telegram)

Per il canale email, dovrete configurare l’SMTP nel file /etc/grafana/grafana.ini nella sezione [smtp]. Vi consiglio anche alert per RAM sopra il 90%, disco sopra l’85% e load average elevato.

Mettere in Sicurezza lo Stack di Monitoring

Un aspetto che spesso viene trascurato è la sicurezza. Non volete che le metriche del vostro server siano accessibili a chiunque. Ecco cosa ho fatto io:

  • Limitare l’accesso alle porte: Node Exporter (9100) e Prometheus (9090) devono ascoltare solo su localhost o essere protetti da firewall. Aggiungete --web.listen-address="127.0.0.1:9100" a Node Exporter e --web.listen-address="127.0.0.1:9090" a Prometheus
  • Reverse proxy con Nginx: esponete Grafana tramite un virtual host Nginx con HTTPS (usando Let’s Encrypt) invece di accedere direttamente sulla porta 3000
  • Autenticazione: cambiate immediatamente la password admin di Grafana e abilitate l’autenticazione a due fattori se disponibile

Se avete già configurato Fail2Ban su Plesk, potete aggiungere un jail anche per proteggere l’accesso a Grafana dai tentativi di brute force. Allo stesso modo, se avete seguito la mia guida su come abilitare HTTP/3 QUIC su Plesk con Nginx, potete sfruttare lo stesso setup per servire Grafana con le migliori performance.

Query PromQL Utili per il Monitoraggio del Server Plesk

Ecco le query PromQL che uso quotidianamente per tenere sotto controllo i miei server Plesk:

  • CPU Usage %: 100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  • RAM Utilizzata %: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100
  • Spazio Disco Usato %: (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100
  • Network Traffic In/Out: irate(node_network_receive_bytes_total{device="eth0"}[5m])
  • Server Uptime: time() - node_boot_time_seconds
  • Load Average: node_load1, node_load5, node_load15

Queste query le uso sia nelle dashboard che nelle regole di alerting. Vi consiglio di iniziare semplici e aggiungere complessità man mano che capite quali metriche sono più rilevanti per il vostro workload specifico.

Monitorare Più Server Plesk da un’Unica Dashboard

Se gestite più macchine, la vera forza di questo stack è la possibilità di centralizzare il monitoring. Basta installare Node Exporter su ogni server e aggiungere i target nel file prometheus.yml:

scrape_configs:
  - job_name: 'plesk_servers'
    static_configs:
      - targets:
        - 'server1-ip:9100'
        - 'server2-ip:9100'
        - 'server3-ip:9100'
        labels:
          environment: 'production'

In questo caso, è fondamentale che le porte 9100 siano raggiungibili tra i server, preferibilmente attraverso una rete privata o una VPN. Se avete seguito la mia guida sulla segmentazione VLAN e sicurezza di rete, sapete quanto sia importante isolare il traffico di monitoring dal traffico pubblico.

Backup delle Configurazioni e Retention dei Dati

Non dimenticate di includere nel vostro piano di backup:

  • /etc/prometheus/prometheus.yml — configurazione Prometheus
  • /var/lib/prometheus/ — database time-series
  • /var/lib/grafana/ — database Grafana (dashboard, utenti, alert)
  • /etc/grafana/grafana.ini — configurazione Grafana

Per la retention dei dati, nel servizio systemd ho impostato --storage.tsdb.retention.time=30d: Prometheus conserva 30 giorni di metriche. Regolatelo in base allo spazio disco disponibile. Su un server con monitoring di una singola macchina, 30 giorni occupano circa 1-2 GB. Se avete già configurato il backup remoto S3 con Wasabi, potete includere anche queste directory.

FAQ

Posso usare l’estensione Grafana integrata in Plesk insieme a Prometheus?

L’estensione Grafana di Plesk usa come data source l’estensione Advanced Monitoring (che raccoglie metriche tramite RRD). Questa istanza di Grafana è limitata e non facilmente personalizzabile. Nella mia configurazione, installo Grafana separatamente e uso Prometheus con Node Exporter come data source, ottenendo molte più metriche e dashboard completamente personalizzabili. Le due soluzioni possono coesistere sullo stesso server senza conflitti, a patto di usare porte diverse.

Quanto consuma in termini di risorse lo stack Prometheus + Grafana + Node Exporter?

Node Exporter è estremamente leggero: circa 10-15 MB di RAM. Prometheus con scrape_interval a 15 secondi e un solo target utilizza circa 100-200 MB di RAM. Grafana consuma circa 50-100 MB di RAM a riposo. In totale, lo stack completo richiede meno di 500 MB di RAM, il che lo rende adatto anche a server con risorse limitate.

È possibile monitorare anche i servizi specifici di Plesk come Apache, Nginx e MySQL?

Sì, e lo consiglio vivamente. Per MySQL/MariaDB potete usare il mysqld_exporter, per Nginx il nginx_exporter (che legge lo stub_status) e per Apache l’apache_exporter. Basta aggiungere i rispettivi target nel file prometheus.yml e importare le dashboard dedicate su Grafana.

Come aggiorno Prometheus e Node Exporter?

L’aggiornamento è semplice: scaricate la nuova versione dal sito ufficiale, fermate il servizio con sudo systemctl stop prometheus, sostituite il binario in /usr/local/bin/ e riavviate il servizio. La stessa procedura vale per Node Exporter. Le configurazioni e i dati vengono preservati.

Grafana può inviare alert su Telegram o Slack oltre che via email?

Assolutamente sì. Grafana supporta nativamente decine di notification channels tra cui Telegram, Slack, Discord, PagerDuty, OpsGenie e webhook personalizzati. Nella mia configurazione uso sia email che Telegram per le notifiche critiche, così ho sempre la situazione sotto controllo anche quando non sono al PC.

Conclusione: Monitorare il Server Plesk con Grafana e Prometheus è Essenziale

Configurare uno stack di monitoraggio risorse server su Plesk con Grafana e Prometheus è stato uno dei miglioramenti più significativi che ho apportato alla mia infrastruttura. Avere dashboard in tempo reale, alert automatici e storico delle metriche mi ha permesso di prevenire problemi invece che reagire quando ormai il danno è fatto.

La procedura richiede circa 30-45 minuti per un setup base, ma il ritorno in termini di controllo e tranquillità è impagabile. Se gestite siti WordPress su Plesk — e magari avete già affrontato il tema della sicurezza WordPress contro i brute force o dell’audit dei plugin per le vulnerabilità — il monitoring è il tassello che completa il quadro.

Se avete domande o volete condividere la vostra esperienza con il monitoring su Plesk, lasciate un commento qui sotto. Sono sempre curioso di scoprire come altri sysadmin configurano il loro stack!

Share: