Come installare Monit su Ubuntu 22.04

Installare Monit su Ubuntu 22.04

Monit è un demone leggero per il controllo di processi, servizi e risorse di sistema. Su Ubuntu 22.04 si installa dai repository ufficiali e, in pochi passaggi, puoi usarlo per riavviare automaticamente servizi in errore, verificare l’occupazione delle risorse e ricevere notifiche quando qualcosa esce dai limiti stabiliti.

Il punto forte di Monit non è sostituire strumenti come Prometheus o Zabbix, ma coprire bene il controllo locale e le azioni automatiche immediate. È utile su server web, database piccoli e medi, macchine VPS e host dedicati dove vuoi una supervisione semplice, rapida e affidabile.

Prerequisiti e obiettivo

Questa procedura assume Ubuntu 22.04 aggiornato, accesso con privilegi amministrativi e un servizio di sistema già presente da monitorare, ad esempio Apache, Nginx, PHP-FPM, MySQL o Redis.

Obiettivo pratico:

• installare Monit;
• abilitare il servizio al boot;
• aprire l’interfaccia web locale in modo sicuro;
• aggiungere un controllo base su un servizio;
• verificare che il monitoraggio funzioni davvero.

Installazione del pacchetto

Su Ubuntu 22.04 Monit è nel repository standard. Aggiorna l’indice dei pacchetti e installa il pacchetto:

sudo apt update
sudo apt install monit

Dopo l’installazione controlla lo stato del servizio:

systemctl status monit

Atteso: servizio presente e non necessariamente già attivo, a seconda della configurazione iniziale. Se il pacchetto è stato installato correttamente, il binario sarà disponibile e la configurazione principale si troverà in /etc/monit/monitrc.

Verifica rapida della versione:

monit -V

Se il comando risponde con una versione, il pacchetto è funzionante. Se invece ottieni errore di permessi o file di configurazione mancante, il problema è quasi sempre legato ai permessi del file principale o a una configurazione incompleta.

Abilitare il servizio e controllare il file di configurazione

Su Ubuntu, il file principale è /etc/monit/monitrc. Dopo l’installazione conviene verificare che esista e che abbia i permessi corretti, perché Monit è molto rigido su questo punto.

ls -l /etc/monit/monitrc

Atteso: il file esiste e di norma ha permessi restrittivi. Se i permessi sono troppo aperti, Monit può rifiutarsi di partire.

Il servizio va abilitato al boot e avviato:

sudo systemctl enable --now monit

Controlla che sia attivo:

systemctl is-active monit

Atteso: active. Se ottieni failed, guarda i log:

journalctl -u monit -xe --no-pager

Qui di solito emergono errori di sintassi, permessi o path errati verso i servizi monitorati.

Configurazione base dell’interfaccia web

Monit può esporre una piccola interfaccia web locale, utile per consultare lo stato dei servizi e fare debug veloce. Non va esposta in chiaro su Internet senza protezione: meglio limitarla a localhost o a una rete amministrativa.

Apri il file principale:

sudo nano /etc/monit/monitrc

Cerca o aggiungi un blocco simile, adattando porta e credenziali:

set httpd port 2812
    use address 127.0.0.1
    allow localhost
    allow admin:password

Se vuoi accedere da un altro host amministrativo, sostituisci 127.0.0.1 con l’IP della macchina o con un’interfaccia specifica, e limita l’accesso con regole strette. Non lasciare l’interfaccia aperta su tutte le interfacce senza autenticazione adeguata.

Dopo le modifiche, verifica la sintassi prima di riavviare:

sudo monit -t

Atteso: Control file syntax OK. Se il test fallisce, correggi il file prima di andare avanti.

Riavvia il servizio:

sudo systemctl restart monit

e verifica che la porta sia in ascolto:

ss -ltnp | grep 2812

Atteso: un listener sulla porta configurata. Se non compare, controlla di nuovo il file e i log di sistema.

Regole di monitoraggio per un servizio

Monit lavora bene quando controlla un processo con un nome chiaro e un path preciso. Un esempio classico è il controllo di un demone systemd come Nginx o Apache. Il file di regola può stare in /etc/monit/conf-enabled/ o essere incluso dal file principale, a seconda della struttura che preferisci.

Per un servizio systemd, puoi usare un controllo di processo semplice. Ad esempio, per Nginx:

check process nginx with pidfile /run/nginx.pid
    start program = "/bin/systemctl start nginx"
    stop program  = "/bin/systemctl stop nginx"
    if failed host 127.0.0.1 port 80 protocol http then restart
    if 5 restarts within 5 cycles then timeout

Questo esempio combina il controllo del PID con una verifica HTTP sulla porta 80. Il vantaggio è che Monit non si limita a vedere il processo vivo, ma controlla anche che il servizio risponda davvero.

Un altro esempio per PHP-FPM, se il socket o il PID file sono noti:

check process php-fpm with pidfile /run/php/php8.1-fpm.pid
    start program = "/bin/systemctl start php8.1-fpm"
    stop program  = "/bin/systemctl stop php8.1-fpm"
    if failed unixsocket /run/php/php8.1-fpm.sock then restart

Se il tuo ambiente usa una versione diversa di PHP, adatta il path. Qui il dettaglio importante è non inventare: devi usare il pidfile e il socket reali del sistema.

Abilitare e includere i file di configurazione aggiuntivi

Su Ubuntu è comune usare la directory /etc/monit/conf-enabled/ per le regole aggiuntive. Verifica che il file principale includa quella directory. In genere trovi una riga simile:

include /etc/monit/conf-enabled/*

Se preferisci organizzare il monitoraggio per servizio, crea un file dedicato, ad esempio:

sudo nano /etc/monit/conf-enabled/nginx

Poi inserisci la regola del servizio. Dopo ogni modifica, esegui sempre il test della configurazione:

sudo monit -t

Atteso: nessun errore di parsing. Se il test fallisce, Monit non applicherà correttamente le regole e il restart del servizio può non avvenire.

Controllo di risorse: CPU, memoria e spazio disco

Una delle funzioni più utili di Monit è il controllo delle risorse di sistema. Questo aiuta a intercettare casi tipici come disco pieno, memoria insufficiente o carico anomalo prima che il servizio diventi instabile.

Per monitorare il filesystem root:

check device rootfs with path /
    if space usage > 80% then alert
    if space usage > 90% then exec "/usr/local/bin/disk-warning.sh"

Per la memoria:

check system localhost
    if memory usage > 80% then alert
    if cpu usage > 90% for 5 cycles then alert

Le soglie vanno tarate sul tuo server. Un VPS piccolo può essere stabile con soglie più permissive, mentre un host dedicato può avere limiti più stretti. Il punto è definire una metrica utile e non lasciare valori casuali.

Se aggiungi azioni automatiche, come script o restart, valuta sempre il blast radius: un controllo aggressivo può peggiorare una situazione transitoria e innescare riavvii a catena. Meglio partire con alert e solo dopo abilitare l’automazione.

Test della configurazione e avvio controllato

Prima di affidarti al sistema, fai un test completo. Questo è il passaggio che evita gran parte degli errori operativi.

sudo monit -t

Se il risultato è positivo, ricarica o riavvia Monit:

sudo systemctl restart monit

Verifica lo stato del demone:

systemctl status monit

e controlla la lista dei servizi monitorati:

sudo monit summary

Atteso: i processi configurati compaiono come Running o comunque in uno stato coerente con il sistema reale. Se qualcosa risulta Does not exist o Failed, il path del pidfile o il nome del processo è probabilmente errato.

Accesso alla web UI in modo sicuro

Se vuoi usare l’interfaccia web, la soluzione più prudente è mantenerla in locale e raggiungerla tramite SSH tunnel. In questo modo eviti di aprire la porta a tutta la rete.

Dal tuo PC amministrativo puoi creare il tunnel:

ssh -L 2812:127.0.0.1:2812 user@server

Poi apri nel browser http://127.0.0.1:2812. Se l’autenticazione è configurata correttamente, vedrai la dashboard di Monit.

Se invece vuoi esporla in rete, usa firewall e allow list stretti. Non pubblicare la porta senza protezione. L’interfaccia di Monit è leggera, ma resta un endpoint amministrativo che va trattato come tale.

Esempio completo minimo

Se vuoi una base essenziale, puoi partire con una configurazione come questa, adattando il servizio monitorato:

set daemon 60
set logfile syslog facility log_daemon

set httpd port 2812
    use address 127.0.0.1
    allow localhost
    allow admin:password

check system localhost
    if loadavg (1min) > 4 then alert
    if memory usage > 80% then alert
    if cpu usage > 90% for 5 cycles then alert

check process nginx with pidfile /run/nginx.pid
    start program = "/bin/systemctl start nginx"
    stop program  = "/bin/systemctl stop nginx"
    if failed host 127.0.0.1 port 80 protocol http then restart

Questo schema è semplice ma già utile: controlla sistema, salute generale e un servizio web. Da qui puoi aggiungere database, cache, code worker e controlli specifici applicativi.

Log e diagnosi dei problemi più comuni

Se Monit non parte, i casi più frequenti sono questi:

• file di configurazione con sintassi errata: verifica con sudo monit -t;
• permessi del file principale: controlla ls -l /etc/monit/monitrc;
• pidfile inesistente: controlla il path reale del servizio;
• porta già occupata: verifica con ss -ltnp | grep 2812;
• servizio non esistente o nome sbagliato: controlla systemctl status nome-servizio.

Per vedere i log del demone:

journalctl -u monit --no-pager -n 100

Se il servizio risulta attivo ma non esegue i restart, controlla le regole di soglia e il tipo di test configurato. Un controllo troppo permissivo non intercetta il guasto; uno troppo aggressivo può causare falsi positivi.

Buone pratiche operative

Monit funziona meglio quando le regole sono poche, chiare e verificabili. Evita di aggiungere decine di controlli tutti insieme senza una logica di priorità.

Conviene seguire queste regole operative:

• parti dai servizi critici, non da tutto il sistema;
• usa path assoluti per pidfile, socket e script;
• testa ogni modifica con monit -t;
• mantieni l’interfaccia web limitata o tunnelizzata;
• documenta soglie e azioni automatiche.

Se il server è in produzione, fai un backup del file di configurazione prima di modificarlo:

sudo cp /etc/monit/monitrc /etc/monit/monitrc.bak.$(date +%F-%H%M)

Questo ti dà un rollback immediato se una regola nuova introduce un errore o blocca il demone.

Verifica finale

Alla fine della procedura dovresti avere:

• pacchetto monit installato;
• servizio monit attivo con systemctl is-active monit;
• configurazione valida con sudo monit -t;
• almeno un servizio o una risorsa monitorata;
• interfaccia web raggiungibile solo in modo controllato.

Se questi punti sono veri, l’installazione è operativa e pronta per essere estesa con ulteriori controlli.

Assunzione: i path dei servizi monitorati, come pidfile e socket, vanno verificati sul server reale prima di copiare gli esempi.