Monitoraggioper Svogliati
Il disco si riempie alle 3 di notte, il certificato scade di domenica, il backup non parte da tre settimane. Puoi scoprirlo da un messaggio sul telefono, o da un cliente arrabbiato il lunedì. Questa guida è per la prima opzione, con il minimo sforzo.
"Abbiamo cento dashboard." — "E chi le guarda?" — "Nessuno, ma sono bellissime."
Dai grafici del traffico a Prometheus
Trent'anni per arrivare alla stessa conclusione: un buon avviso vale più di qualsiasi grafico.
Il primo sistema di monitoraggio di quasi ogni sistemista è stato uno script: un ping in un ciclo che mandava una mail se il server non rispondeva. Poi gli script sono diventati dieci, poi cento, poi qualcuno ha deciso che serviva un programma vero. Ogni strumento di questa storia è nato da qualcuno stanco dei suoi script.
MRTG
Tobias Oetiker disegna i grafici del traffico dei router. Nel 1999 ne estrae RRDtool, il database circolare su cui si sono basati strumenti per vent'anni.
NetSaint, poi Nagios
Ethan Galstad scrive un programma che lancia controlli e manda avvisi. Dal 2002 si chiama Nagios, e il suo formato dei plugin diventa uno standard che sopravvive ancora oggi.
Zabbix
Alexei Vladishev porta in un unico prodotto controlli, metriche, grafici e un'interfaccia web. Diventa lo standard di tante aziende, soprattutto per reti e apparati SNMP.
Prometheus
A SoundCloud nasce un sistema che raccoglie metriche da sé, interrogando i servizi, e le salva come serie temporali. Nel 2016 entra nella Cloud Native Computing Foundation, subito dopo Kubernetes.
Grafana
Torkel Ödegaard crea l'interfaccia per grafici che tutti avrebbero voluto. Oggi legge Prometheus, Zabbix, database, log: è il cruscotto di mezzo mondo.
Il ritorno al leggero
Accanto ai sistemi grandi tornano quelli piccoli: Uptime Kuma per i siti, Beszel per i server, un ping a un monitor alla fine di ogni backup. Per molte infrastrutture bastano questi.
Perché: saperlo prima che te lo dicano
Il monitoraggio non evita i guasti. Cambia chi se ne accorge per primo, e quanto tempo hai per sistemare.
Il disco pieno
Il guasto più banale e più frequente. Il database si ferma, i log smettono di scriversi, la posta rimbalza. Un avviso all'80% ti dà giorni.
Il certificato scaduto
Il rinnovo automatico si rompe in silenzio, e tre mesi dopo il sito dice "connessione non sicura". Let's Encrypt dal 2025 non manda più le email di scadenza: tocca a te.
Il backup fermo
Non dà errori: semplicemente non parte più. Lo scopri il giorno in cui serve (vedi Backup per Svogliati).
Il lento declino
La RAM che cresce ogni giorno, il sito che rallenta di settimana in settimana. Senza storico non vedi la tendenza, solo il crollo.
Il servizio caduto
systemd lo riavvia, poi smette di riprovare. Il server è acceso, ping risponde, e il servizio è morto da ore.
Il disco che muore
SMART avvisa spesso settimane prima. Se qualcuno legge gli avvisi.
Cosa sorvegliare, e cosa lasciar perdere
La domanda giusta non è "cosa posso misurare", ma "cosa mi fa alzare dal divano".
| Cosa | Avviso? | Soglia di partenza |
|---|---|---|
| Il servizio risponde da fuori (sito, posta, DNS) | Sì | Giù da 2-3 minuti |
| Disco | Sì | Libero sotto il 15%, o "pieno entro 24 ore" (sezione 8) |
| Certificati | Sì | Scadenza tra meno di 14 giorni |
| Backup | Sì | Nessun backup riuscito da 25 ore |
| Servizi systemd falliti | Sì | Qualsiasi failed |
| SMART dei dischi | Sì | Settori riallocati in aumento, test fallito |
| RAM e swap | Solo se fa danni | Swap usato a lungo, OOM killer nei log |
| CPU | Quasi mai | Al 100% per 30 minuti. Al 100% per 30 secondi è il server che lavora |
| Traffico di rete, processi, temperatura | Grafico, non avviso | Ti serve per capire dopo, non per svegliarti |
Il concetto chiave: controlli e metriche
Due famiglie di strumenti che rispondono a due domande diverse. Quasi tutti i malintesi nascono dal confonderle.
✅ Controlli: "va o non va?"
Ogni tot minuti si esegue un test: il sito risponde, il disco ha spazio, il certificato è valido. Il risultato è uno stato: OK, avviso, critico. Nagios, Icinga, Uptime Kuma. Facili da capire, ma senza storia: sai che adesso il disco è al 91%, non come ci è arrivato.
📈 Metriche: "com'è andata nel tempo?"
Numeri raccolti ogni pochi secondi e salvati: spazio libero, richieste al secondo, memoria. Prometheus, Zabbix, Beszel. Gli avvisi diventano condizioni sui numeri ("il disco si riempirà entro domani"), e quando qualcosa si rompe hai i grafici per capire perché.
Un controllo è la visita: il medico ti guarda e dice "sta bene" o "non sta bene". Una metrica è l'orologio che misura il battito tutto il giorno: non ti dice niente da solo, ma il giorno che stai male mostra che il problema è cominciato martedì. Ti servono tutti e due, ma per un sistemista svogliato si comincia dalla visita.
Prima da fuori
Quello che conta è cosa vede l'utente. Un controllo dall'esterno sul sito vale più di dieci metriche interne del server.
Avvisa sui sintomi, guarda le cause
"Il sito è lento" è un avviso. "CPU al 90%" è un grafico da guardare dopo, per capire il perché.
Il monitor non sta sul server che sorveglia
Se muore il server, muore anche il suo monitor, in silenzio. Almeno un controllo deve girare da un'altra parte (sezione 13).
| Parola | Cosa vuol dire |
|---|---|
| Pull | Il monitor va a chiedere i dati ai server (Prometheus). Sa subito se un server non risponde |
| Push | I server mandano i dati al monitor (agenti, healthchecks). Funziona anche dietro NAT e firewall |
| Agente | Un piccolo programma sul server che raccoglie i numeri (node_exporter, agente Zabbix, agente Beszel) |
| Retention | Per quanto tempo si tengono le metriche. Più storia, più disco |
Il minimo indispensabile, senza installare niente
Prima di ogni strumento: i comandi che dicono già quasi tutto, e uno script che ti scrive quando qualcosa non va.
systemctl --failed # servizi caduti
df -h -x tmpfs -x devtmpfs # spazio sui dischi veri
df -i # inode: "disco pieno" con spazio libero
journalctl -p err -b --no-pager | tail # errori dall'ultimo avvio
free -h # RAM e swap
sudo smartctl -H /dev/sda # salute del disco (pacchetto smartmontools)
# scadenza di un certificato
echo | openssl s_client -connect example.com:443 -servername example.com 2>/dev/null | openssl x509 -noout -enddate
#!/bin/bash
# TOKEN e CHAT in /etc/controlla.env (chmod 600), caricato dal servizio systemd
avvisi=""
while read -r uso punto; do
[ "${uso%\%}" -ge 85 ] && avvisi+="Disco $punto al $uso\n"
done < <(df --output=pcent,target -x tmpfs -x devtmpfs | tail -n +2)
falliti=$(systemctl --failed --no-legend --plain | awk '{print $1}')
[ -n "$falliti" ] && avvisi+="Servizi falliti: $falliti\n"
if [ -n "$avvisi" ]; then
curl -s -m 10 "https://api.telegram.org/bot$TOKEN/sendMessage" \
-d chat_id="$CHAT" --data-urlencode text="$(hostname): $(printf "$avvisi")" > /dev/null
fi
Da fuori: il sito risponde?
Il primo monitor da installare, e il più utile. Guarda i tuoi servizi come li guarda un utente.
| Strumento | Cos'è | Quando |
|---|---|---|
| Uptime Kuma | Monitor con interfaccia web: HTTP, TCP, ping, DNS, certificati, pagine di stato pubbliche, notifiche su Telegram e decine di altri canali | La scelta di default: un container e via |
| Un monitor minimale tuo | Uno script PHP o Python con SQLite che controlla una lista di URL (come up3w, quello che usa chi scrive) | Se vuoi qualcosa che capisci riga per riga e che gira ovunque |
| Servizi esterni | Monitor ospitati da altri, spesso con un piano gratuito | Come secondo parere: stanno fuori da tutta la tua infrastruttura |
| Blackbox exporter | Il controllo da fuori nel mondo Prometheus | Se usi già Prometheus |
🎯 Cosa controllare davvero
- Non solo il codice 200: cerca una parola che c'è solo nella pagina giusta. Un errore del database può rispondere 200 con scritto "Error establishing a database connection".
- La scadenza dei certificati, con avviso a 14 giorni.
- La posta: la porta 25 risponde, e il dominio non è in blacklist.
- Il DNS: il nome risolve all'indirizzo giusto.
- Da dove: il monitor non deve stare nella stessa rete o nello stesso datacenter dei servizi.
Un colpo d'occhio sui server: Beszel
Per chi ha da due a venti server e vuole vedere CPU, RAM, disco e container in una pagina, senza montare un sistema di metriche completo.
🪶 Come funziona
Un hub (interfaccia web e database) e un agente leggero su ogni server, scritto in Go. L'agente consuma pochissimo, va bene anche su un Raspberry Pi. L'hub mostra grafici di CPU, memoria, disco, rete, temperature e container Docker, con la storia degli ultimi giorni.
🔔 Avvisi inclusi
Soglie per CPU, memoria, disco, temperatura, e "server non raggiungibile", con notifiche su Telegram, email e altro. Non serve Alertmanager, non serve scrivere regole: si impostano dall'interfaccia.
services:
beszel:
image: henrygd/beszel:latest
restart: unless-stopped
ports:
- "127.0.0.1:8090:8090" # dietro un reverse proxy con HTTPS, non aperto a tutti
volumes:
- ./beszel_data:/beszel_data
# l'agente si installa su ogni server con il comando che l'hub ti mostra quando aggiungi il sistema
Prometheus: quando i server sono tanti
Il sistema di metriche più usato al mondo. Più lavoro all'inizio, ma scala, e ogni programma moderno parla già la sua lingua.
Ogni server (o programma) espone una pagina web, di solito su /metrics, con i suoi numeri in testo semplice. Prometheus passa da tutte le pagine ogni 15 secondi, legge i numeri e li salva. Se una pagina non risponde, lo sa subito: up diventa 0. I programmi che espongono i numeri di qualcos'altro si chiamano exporter: node_exporter per il sistema Linux, poi uno per MySQL, uno per nginx, uno per quasi tutto.
global:
scrape_interval: 15s
rule_files:
- /etc/prometheus/regole.yml
alerting:
alertmanagers:
- static_configs:
- targets: ['localhost:9093']
scrape_configs:
- job_name: server
static_configs:
- targets: ['web1:9100', 'db1:9100', 'backup1:9100'] # node_exporter su ogni server
# chi non risponde
up == 0
# spazio libero in percentuale, dischi veri
100 * node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes{fstype!~"tmpfs|overlay"}
# il disco si riempirà entro 24 ore, guardando le ultime 6
predict_linear(node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"}[6h], 24*3600) < 0
# CPU usata per server
100 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100
| Pezzo | Porta | Cosa fa |
|---|---|---|
| Prometheus | 9090 | Raccoglie e salva le metriche, valuta le regole |
| node_exporter | 9100 | Espone CPU, memoria, dischi, rete di un server Linux |
| Alertmanager | 9093 | Riceve gli avvisi, li raggruppa e li manda (sezione 11) |
| Grafana | 3000 | I grafici (sezione 9) |
/metrics racconta molto del server: versioni, dischi, processi. Fai ascoltare gli exporter solo sulla rete interna o sulla VPN, o proteggili con un firewall. Per tenere più storia: --storage.tsdb.retention.time=90d (il default è 15 giorni).
Grafana: dashboard senza perdere il weekend
Grafana è bellissimo, ed è proprio questo il pericolo.
✅ Fai
- Parti da una dashboard pronta: "Node Exporter Full" (ID 1860 su grafana.com) si importa in un minuto
- Una dashboard "panoramica": tutti i server, una riga ciascuno, verde o rosso
- Grafici con la stessa scala temporale, per confrontare
- Accesso con login, dietro HTTPS
❌ Non fare
- Quaranta pannelli per server "perché si può"
- Usare le dashboard al posto degli avvisi: nessuno le guarda alle 3 di notte
- Lasciare Grafana con
admin/admin - Passare una giornata sui colori prima di avere un avviso sul disco
Nagios, Zabbix e gli altri
Nagios non è più di moda. Il suo formato dei controlli sì: è ovunque, e un plugin scritto vent'anni fa funziona ancora.
#!/bin/bash
# uscita 0 = OK, 1 = WARNING, 2 = CRITICAL, 3 = UNKNOWN. Più una riga di testo.
# dopo il | i numeri per i grafici (performance data)
uso=$(df --output=pcent / | tail -1 | tr -dc '0-9')
if [ "$uso" -ge 95 ]; then echo "DISCO CRITICAL - / al $uso% | uso=$uso%"; exit 2
elif [ "$uso" -ge 85 ]; then echo "DISCO WARNING - / al $uso% | uso=$uso%"; exit 1
else echo "DISCO OK - / al $uso% | uso=$uso%"; exit 0; fi
| Strumento | Cos'è | Per chi |
|---|---|---|
| Nagios Core | L'originale. Configurazione a file di testo, interfaccia datata | Chi lo ha già e funziona: mantienilo, non installarlo da zero |
| Icinga 2 | Nato da un fork di Nagios nel 2009: stessa logica, configurazione migliore, API, interfaccia moderna | Chi vuole il modello a controlli fatto bene |
| Checkmk | Nato come aggiunta a Nagios, oggi prodotto a sé. Trova da solo cosa c'è da controllare su ogni server | Aziende con tanti server e poco tempo per configurarli |
| Zabbix | Controlli e metriche nello stesso prodotto, molto forte su SNMP e apparati di rete, con i proxy per le sedi remote | Reti con switch, router, stampanti, UPS; più sedi; chi vuole un solo strumento per tutto |
🛰️ Il punto forte di Zabbix: i proxy
Un Zabbix proxy è un piccolo server che sta nella sede remota (o nella rete del cliente, o dietro un NAT) e raccoglie i dati al posto del server centrale: controlla gli host, interroga gli apparati SNMP, riceve i dati degli agenti. Poi manda tutto al server centrale in un'unica connessione.
- Una porta sola: in modalità attiva è il proxy a collegarsi al server (porta 10051). Nella sede remota non apri niente in ingresso, e funziona anche dietro NAT.
- Se cade il collegamento il proxy continua a raccogliere e tiene i dati nel suo database; quando la linea torna li manda tutti. Niente buchi nei grafici.
- Meno carico sul server centrale: migliaia di controlli li fa il proxy, il server riceve solo i risultati.
- Leggero: gira bene su una VM piccola o un Raspberry, con SQLite come database.
- Dalla 7.0 i proxy si possono mettere in gruppo: se uno cade, gli host passano a un altro.
È il motivo per cui Zabbix resta la scelta naturale per chi sorveglia più sedi, o le reti dei clienti, da un punto solo.
Avvisi fatti bene
Un avviso deve essere vero, utile e raro. Se ne manca una delle tre, smetterai di leggerli.
groups:
- name: base
rules:
- alert: ServerGiu
expr: up == 0
for: 3m # deve durare 3 minuti: niente avvisi per un riavvio
labels: { severity: critical }
annotations:
summary: "{{ $labels.instance }} non risponde"
- alert: DiscoInEsaurimento
expr: predict_linear(node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"}[6h], 24*3600) < 0
for: 30m
labels: { severity: warning }
annotations:
summary: "{{ $labels.instance }}: {{ $labels.mountpoint }} pieno entro 24 ore"
route:
receiver: telegram
group_by: ['alertname', 'instance']
group_wait: 30s # raccoglie gli avvisi simili prima di mandarli
repeat_interval: 4h # se resta rotto, ricordalo ogni 4 ore, non ogni minuto
receivers:
- name: telegram
telegram_configs:
- bot_token: 'TOKEN_DEL_BOT'
chat_id: -1001234567890
Sempre un "for"
Un picco di 20 secondi non è un problema. Chiedi che la condizione duri qualche minuto prima di avvisare.
Due livelli, non cinque
Critico: ti sveglia. Avviso: lo guardi domattina. Tutto il resto è un grafico.
Ogni avviso dice cosa fare
"Disco / di web1 pieno entro 24 ore" è utile. "Alert 4532 triggered" no.
Log: quando servono in un posto solo
Le metriche dicono che qualcosa non va. I log dicono cosa. Con pochi server bastano journalctl e SSH.
journalctl -p warning --since "1 hour ago" # avvisi ed errori dell'ultima ora
journalctl -u nginx -f # segui un servizio in diretta
journalctl --disk-usage # quanto spazio occupano i log
# limite allo spazio: SystemMaxUse=1G in /etc/systemd/journald.conf
| Situazione | Soluzione |
|---|---|
| Pochi server | journalctl su ognuno, e lo script della sezione 5 che segnala gli errori |
| Tanti server, vuoi cercare in tutti insieme | Loki + Grafana: indicizza solo le etichette, non tutto il testo, quindi è leggero. I log arrivano con Grafana Alloy |
| Ricerche complesse, analisi di sicurezza | Elasticsearch / OpenSearch: potente, ma pesante e da mantenere |
| Devi conservare i log per obblighi di legge | Un server syslog centrale (rsyslog) con log non modificabili dai server di origine |
Chi sorveglia il sorvegliante?
Il silenzio non vuol dire che va tutto bene. Può voler dire che il monitor è morto.
Se il server del monitoraggio si spegne, non ti arriva nessun avviso. Né per lui, né per gli altri. E tu, vedendo il telefono tranquillo, pensi che vada tutto bene. Il monitoraggio va pensato con un pezzo che ti avvisa quando non riceve notizie, e con almeno un controllo che gira fuori dalla tua infrastruttura.
💓 Il dead man's switch
Il tuo sistema manda un "sono vivo" a un servizio esterno ogni pochi minuti (o alla fine di ogni backup). Se il segnale non arriva entro il tempo stabilito, è il servizio esterno ad avvisarti. healthchecks.io lo fa, anche installato in casa; Alertmanager ha l'avviso "Watchdog", sempre acceso apposta.
🔀 Due monitor che si guardano
Due monitor piccoli in due posti diversi (un server in datacenter e un Raspberry a casa, per esempio) che controllano i servizi e anche l'uno l'altro. Se cade un datacenter intero, quello dall'altra parte se ne accorge.
Errori tipici, tradotti
I problemi del monitoraggio sono quasi sempre di due tipi: avvisa troppo, oppure non avvisa affatto.
| Cosa vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
| Decine di avvisi al giorno, tutti ignorati | Soglie troppo strette, nessun for, avvisi su cause invece che su sintomi | Togli o alza ogni avviso che non ha richiesto un'azione nell'ultimo mese |
| Un guasto e 50 messaggi in un minuto | Ogni servizio del server caduto avvisa per conto suo | group_by in Alertmanager, dipendenze in Icinga |
| Il server è morto e non è arrivato niente | Il monitor girava su quel server, o il canale degli avvisi passava da lì | Monitor da fuori e dead man's switch (sezione 13) |
| "Disco pieno" con il 40% libero | Finiti gli inode: troppi file piccoli (cache, sessioni) | df -i, e un avviso anche sugli inode |
| Prometheus occupa tutto il disco | Troppa retention, o metriche con etichette che cambiano sempre (un ID utente come etichetta) | Riduci la retention, togli le etichette con troppi valori |
| Grafico vuoto: "No data" | Exporter non raggiungibile (firewall), nome della metrica sbagliato, intervallo di tempo sbagliato | Controlla up e la pagina Targets di Prometheus |
| Il sito risulta "su" ma gli utenti vedono un errore | Il controllo guarda solo il codice 200 | Cerca una parola del contenuto vero (sezione 6) |
| Avvisi del certificato che non arrivano più | Ci si affidava alle email di Let's Encrypt, che dal 2025 non le manda più | Un controllo di scadenza tuo, a 14 giorni |
| Tutto rosso dopo l'ora legale o un riavvio | Orologio sbagliato sul server o sul monitor | timedatectl: sincronizzazione NTP attiva ovunque |
Da dove continuare
Lo strumento conta meno di quanto pensi. Contano i cinque avvisi giusti e un modo sicuro per riceverli.
| Quanti server | Cosa usare |
|---|---|
| 1-2 | Lo script della sezione 5 con un timer, un monitor da fuori, un dead man's switch per i backup |
| 3-20 | Beszel, Uptime Kuma (o il tuo monitor) da fuori, healthchecks per i job |
| 20 e più, o metriche delle applicazioni | Prometheus + Alertmanager + Grafana, Loki per i log |
| Reti aziendali con SNMP e apparati misti | Zabbix o Checkmk |
| Più sedi, o le reti dei clienti | Zabbix con un proxy in ogni sede |
🗺️ Un percorso in quattro tappe
- Oggi: un controllo da fuori su ogni sito e servizio, con avviso su Telegram.
- Questa settimana: avvisi su disco, servizi falliti, certificati e backup. Solo quelli.
- Poi: Beszel o Prometheus per avere lo storico e capire le tendenze.
- Dopo: il dead man's switch del monitor stesso, e un avviso finto ogni mese per provare che tutto arriva.
| Risorsa | Cos'è |
|---|---|
| prometheus.io/docs | La documentazione di Prometheus, con le buone pratiche su nomi ed etichette |
| Awesome Prometheus Alerts (samber.github.io/awesome-prometheus-alerts) | Centinaia di regole di avviso pronte, da copiare e adattare |
| grafana.com/grafana/dashboards | Dashboard già fatte da importare |
| beszel.dev e github.com/louislam/uptime-kuma | Beszel e Uptime Kuma |
| healthchecks.io | Il dead man's switch |
| Backup · systemd · Bot Telegram per Svogliati | Le guide da leggere insieme a questa |