Monitoraggio finché non arriva il dottore!
Autunno, pioggia, quasi niente resa solare: è ora di un check-up completo. Quale livello di monitoraggio nel homelab controlla cosa, perché un server spento non può segnalarsi da solo, un piccolo uptime check da casa e cosa misura davvero il valore di pressione.

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
Dalle 17 la natura passa al dark mode – a livello di sistema, senza interruttore, senza opt-out. A differenza che qui sul blog, non puoi disattivarlo con un clic. 🌑 Al mattino si scende sotto i dieci gradi, e nelle giornate grigie qui nel sud della Germania i pannelli solari producono giusto abbastanza per un caffè – espresso, non cappuccino. ☕ I miei pensieri tornano all’ultima vacanza a Maiorca: sole, mare e Playa de Palma. A casa la festa è più tranquilla: server invece di sangria, dashboard invece di una pista da ballo. 🍹
Ora sul serio.
I server, e in particolare le applicazioni web, si ammalano proprio come i pazienti veri. Hanno la febbre (CPU al limite), il fiato corto (disco pieno), perdono la memoria (RAM che finisce) o semplicemente hanno una giornata storta e rispondono più lentamente del solito. Alcuni sintomi passano da soli, altri sono i primi segni di qualcosa di serio e vanno esaminati. È esattamente questo il monitoraggio: misurare regolarmente polso, temperatura e pressione, accorgersi delle anomalie prima che diventino un’emergenza e sapere dove guardare quando la cosa si fa seria.
E come con un medico: se ti misuri solo il polso da solo, non ti accorgerai del tuo arresto cardiaco. Era proprio questo il buco rimasto nel monitoraggio qui.
Indice
🩺 Il check-up: chi controlla cosa?
Per orientarsi: qui ci sono due mondi. Su internet ci sono tre server in affitto – il blog e due istanze Nextcloud. A casa c’è un piccolo rack con il mio hardware, tra cui il server NAS e di backup, che gira comunque giorno e notte e passa la maggior parte del tempo a girarsi i pollici. Nel corso dei mesi in entrambi i mondi sono cresciuti dei livelli di monitoraggio. Ognuno risponde a una domanda diversa.
Sui tre server su internet – ognuno sorveglia se stesso:
| Livello | Con che frequenza | Cosa nota |
|---|---|---|
| Monit | ogni 2 min | servizio fermo, jail di fail2ban sparita, ban e firewall non allineati, pod bloccato, certificato < 21 giorni, backup troppo vecchio, errori di consegna mail |
| Prometheus + Grafana | di continuo | disco, RAM, CPU, container al limite, loop di riavvio, OOM kill, PHP-FPM saturo |
| Heartbeat | di continuo | un job notturno (AIDE, rkhunter, ClamAV, aggiornamenti …) non si è fatto vivo |
| Loki | di continuo | denial di SELinux, errori di fail2ban, OOM del kernel, un servizio che scrive troppi errori |
| Test di efficacia | a ogni esecuzione del playbook | catena dei ban, filtri, domini SELinux, metriche presenti |
Dal server NAS a casa – la vista da fuori e sul mio hardware:
| Livello | Con che frequenza | Guarda | Cosa nota |
|---|---|---|---|
| Revisione degli attacchi | ogni giorno | i server su internet | raffiche di POST sugli entry point PHP, crash di PHP-FPM |
| Vista da fuori | ogni settimana | i server su internet | porte aperte, certificati, versioni, vecchi server dimenticati |
| Temperature | ogni 10 min | solo il rack di casa | storico delle temperature del mio hardware; il vero surriscaldamento lo segnala via mail l’iLO stesso. I server su internet stanno in un data center – la loro temperatura è affare dell’hoster. |
Il succo: ogni livello esiste per un tipo di guasto. Monit vede se qualcosa gira, Prometheus se basta, Loki perché si è piantato, gli heartbeat se è successo qualcosa in assoluto.
🚑 Il buco: chi chiama il dottore quando il paziente crolla?
La prima tabella lo tradisce: tutto ciò che contiene gira sul server che sorveglia. Se un server si pianta del tutto, l’hoster ha un guasto o la rete sparisce, Monit, Grafana e Loki vanno giù con lui. Nessuno manda una mail – e nella casella di posta il silenzio sembra esattamente “tutto a posto”. Un server non monitorato è il server di Schrödinger: acceso e spento allo stesso tempo – finché qualcuno non apre la scatola, di solito un utente con il telefono in mano. 🐈📦
Finora te ne saresti accorto per la mail di test settimanale che non arriva, o per il controllo del lunedì da fuori. Nel caso peggiore dopo giorni. E c’è anche un secondo caso: tutti i servizi girano, ma il sito mostra solo “Error establishing a database connection”, oppure Nextcloud è bloccato in modalità manutenzione. Per Monit è tutto verde. La domanda, tra l’altro, ha quasi duemila anni – Giovenale la pose nelle sue Satire: Quis custodiet ipsos custodes? Chi sorveglia i sorveglianti?
Non si tratta solo di tecnica: voglio accorgermi di un guasto da solo prima che qualcuno mi contatti per segnalarlo. È la differenza tra reattivo e proattivo. Reattivo significa agire dopo che un problema è emerso – di solito perché qualcuno chiama o scrive “il cloud non funziona”. A quel punto il danno è fatto, e l’utente l’ha visto prima di me. Proattivo significa assicurarsi in anticipo di individuare i problemi da soli e presto – idealmente prima che qualcuno se ne accorga, come minimo per poter rispondere al primo messaggio con “Lo so, ci sto lavorando.” Ogni livello nelle tabelle qui sopra è un pezzo di proattività; senza una vista da fuori, il guasto più grande di tutti restava reattivo. Esistono due tipi di admin: quelli che vengono a sapere di un guasto dal loro monitoraggio – e quelli che lo vengono a sapere dai loro utenti.
Il succo: un monitoraggio che gira sulla stessa macchina del paziente non può segnalare il suo collasso totale. Serve qualcuno da fuori.
🏠 La visita a domicilio: un uptime check da casa
La soluzione è volutamente piccola e non richiede hardware nuovo – il server NAS di casa è comunque sveglio. Uno script Python lì chiama ogni 5 minuti ciascuno dei tre siti su internet come farebbe un visitatore, solo senza browser:
- WordPress: la home page risponde 200 ed è una pagina vera, non una pagina di errore del database o un avviso di manutenzione.
- Nextcloud:
status.phpriporta “installed”, “not in maintenance” e “nessun upgrade del database in sospeso”. - Collabora:
/hosting/discoveryrestituisce l’XML WOPI che serve a Nextcloud per aprire i documenti. - Certificato: una volta al giorno – non valido o valido per meno di 14 giorni è un reperto.
Le mail partono solo a un cambiamento: “down” dopo due esecuzioni fallite di fila (un singolo singhiozzo non è un allarme), “di nuovo su” con la durata del guasto, e un promemoria ogni 12 ore finché qualcosa resta giù. Se falliscono tutti i target contemporaneamente, lo script controlla prima due siti neutrali su internet – se mancano anche quelli, è la mia linea, e non c’è nessun falso allarme. In miniatura è il problema dei due generali dell’informatica: quando non torna nessuna risposta, non puoi sapere se è caduto il destinatario o il messaggero – quindi chiedi a un terzo.
Lo user agent contiene “uptime”, così le statistiche dei visitatori non contano le 288 visite giornaliere dal mio soggiorno. E un cenno a Heisenberg: una misura dovrebbe cambiare il meno possibile ciò che misura – dodici richieste all’ora spariscono nel rumore di fondo.
Il suo limite: se il server NAS è spento o la linea di casa è giù, nessuno controlla. Resta comunque un grande passo avanti – prima l’unico controllo da fuori girava una volta alla settimana.
Il succo: controlla da fuori ciò che vede l’utente, non se un processo gira. E segnala i cambiamenti di stato, non gli stati – altrimenti le mail finiscono presto non lette nell’archivio. Un allarme che suona di continuo è un rilevatore di fumo in una sauna. 🔥
💓 Misurare la pressione: cosa significa “pressure”
Nuovo sulla dashboard c’è anche un valore rimasto vuoto a lungo: pressure (Pressure Stall Information, PSI). Non misura quanto è pieno qualcosa, ma per quanto tempo i programmi hanno dovuto aspettare perché una risorsa scarseggiava. Una CPU può essere occupata al 100 % senza che nessuno aspetti – solo l’attesa fa sembrare lento un server. Del resto, alla cassa del supermercato a nessuno importa quanto sia occupata la cassiera – solo quanto è lunga la fila.
$ cat /proc/pressure/memory
some avg10=0.00 avg60=0.00 avg300=0.00 total=31
full avg10=0.00 avg60=0.00 avg300=0.00 total=31
- cpu / memory / io: atteso tempo di CPU, memoria libera (il kernel ha dovuto prima recuperarne – il primo segnale prima degli OOM kill) o il disco.
- some: quota di tempo in cui almeno un processo aspettava.
- full: quota di tempo in cui aspettavano tutti e nulla andava avanti – il valore più serio.
- avg10 / avg60 / avg300: percentuale del tempo, mediata su 10 secondi, 1 e 5 minuti.
Regola pratica: qualche punto percentuale è normale. some sopra il 10–20 % a lungo è degno di nota; full su memoria o disco chiaramente sopra 0 per un po’ è un reperto.
Un errore mio, di passaggio: su questi server PSI è disattivato di default nel kernel e si attiva con il parametro di boot psi=1. Impostarlo è stato rapido – ma ha effetto solo al boot successivo. Il blog si è riavviato la notte seguente; i due server Nextcloud hanno girato per un altro giorno e mezzo con un pannello vuoto, finché non li ho riavviati a mano.
Il succo: un parametro di boot conta solo dopo il boot. Una modifica è finita solo quando il valore arriva dove vuoi vederlo.
🔍 Un reperto durante il check-up
Passando tutto in rassegna è saltata fuori un’altra cosa: lo script delle temperature per il rack di casa – misura solo il mio hardware, non i server su internet – non ha nessuna mail configurata. La prima preoccupazione è stata che nessuno avrebbe segnalato un surriscaldamento. Uno sguardo nell’iLO ha mostrato che il suo AlertMail era stato configurato da tempo e segnala da solo le temperature critiche. Lo script aggiunge solo i primi, silenziosi indizi nel suo report.
Il succo: prima di costruire un nuovo allarme, guarda cosa allarma già. Gli allarmi doppi non sono un guadagno.
🔭 Cosa viene dopo: più precisi, non di più
Un monitoraggio così non è mai finito. Svilupparlo però qui non significa aggiungere nuovi strumenti – significa rendere i test esistenti più precisi e più specifici. Qualche riflessione realistica che non richiede nuova infrastruttura – idee, non promesse:
- Funzione invece di raggiungibilità: un account di test fa login su Nextcloud, carica un piccolo file via WebDAV, lo riscarica e confronta il checksum. Così si controllano login, storage, database e Redis in un colpo solo.
- Contenuto invece di status code: sul blog un test apre un post specifico e si aspetta il suo titolo – una pagina può rispondere 200 ed essere comunque vuota o venire da una cache vecchia.
- Lento prima di rotto: registrare il tempo di risposta e avvisare quando è chiaramente sopra la propria mediana degli ultimi giorni. La maggior parte dei guasti si annuncia prima come “lento”.
- Controlli reciproci: i tre server su internet si controllano a vicenda – così qualcuno resta sveglio anche quando la linea di casa è giù.
- Chi controlla la visita a domicilio? Il controllo stesso ha bisogno di un heartbeat, per esempio un timestamp che un monitor su internet nota mancare quando smette di arrivare. Giovenale saluta.
In più c’è la messa a punto: le soglie che scattano troppo spesso o troppo di rado vengono regolate, e ogni incidente reale che nessun test ha notato diventa una domanda: quale test l’avrebbe trovato?
Il succo: il monitoraggio matura a ogni incidente. Più un test è specifico, più si avvicina a ciò che fa davvero un utente.
📜 Lo script
Solo libreria standard di Python, mail tramite il comando locale mail (qui msmtp). La configurazione con indirizzi e destinatario delle mail sta accanto, mostrata qui sotto con valori di esempio.
#!/usr/bin/env python3
"""
uptime_check.py - is every site still reachable and working, seen from outside?
Monit, Prometheus, Grafana and Loki run on the servers they watch. If a whole
server goes down (crash, hoster outage, network), they go down with it and
nobody sends a mail. This script runs on a machine at home every 5 minutes,
checks each site the way a visitor would and mails only when the state
changes: DOWN after <fail_after> failed runs in a row, UP again with the
downtime, a reminder every <remind_hours> while it stays down.
uptime_check.py run all checks (cron)
uptime_check.py --dry-run run all checks, print mails instead of sending
uptime_check.py --status show the stored state
Kinds of checks (uptime_check.conf, [targets]):
wordpress page answers 200 and is a real page, not a database error
nextcloud status.php: installed, not in maintenance, no pending DB upgrade
collabora /hosting/discovery answers with the WOPI discovery XML
Every target also gets a TLS certificate check (warning below cert_warn_days).
Standard library only. Mail goes through the local "mail" command (msmtp).
"""
import configparser, datetime as dt, json, os, socket, ssl, subprocess, sys, time
import urllib.error, urllib.request
from urllib.parse import urlsplit
HERE = os.path.dirname(os.path.abspath(__file__))
CONF = os.path.join(HERE, "uptime_check.conf")
STATE = os.path.join(HERE, "state.json")
LOG = os.path.join(HERE, "uptime_check.log")
UA = "uptime-check/1.0 (+homelab)" # "uptime" keeps it out of the visitor statistics
def log(msg):
with open(LOG, "a") as f:
f.write(f"{dt.datetime.now():%Y-%m-%d %H:%M:%S} {msg}\n")
def fetch(url, timeout):
"""GET url -> (status, body text, seconds). Raises on network errors."""
req = urllib.request.Request(url, headers={"User-Agent": UA})
t0 = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
body = r.read(2_000_000).decode("utf-8", "replace")
return r.status, body, time.monotonic() - t0
except urllib.error.HTTPError as e:
return e.code, "", time.monotonic() - t0
# Each check returns None when everything is fine, otherwise a short reason.
def check_wordpress(base, timeout):
status, body, secs = fetch(base, timeout)
if status != 200:
return f"HTTP {status}"
if "Error establishing a database connection" in body:
return "WordPress meldet: keine Datenbankverbindung"
if "Briefly unavailable for scheduled maintenance" in body:
return "WordPress steckt im Wartungsmodus"
if "wp-content" not in body or "</html>" not in body:
return "Antwort ist keine vollständige WordPress-Seite"
return None
def check_nextcloud(base, timeout):
status, body, secs = fetch(base.rstrip("/") + "/status.php", timeout)
if status != 200:
return f"status.php: HTTP {status}"
try:
s = json.loads(body)
except ValueError:
return "status.php liefert kein JSON"
if not s.get("installed"):
return "status.php: installed = false"
if s.get("maintenance"):
return "Nextcloud ist im Wartungsmodus"
if s.get("needsDbUpgrade"):
return "Nextcloud wartet auf ein Datenbank-Upgrade (occ upgrade)"
return None
def check_collabora(base, timeout):
status, body, secs = fetch(base.rstrip("/") + "/hosting/discovery", timeout)
if status != 200:
return f"discovery: HTTP {status}"
if "<wopi-discovery" not in body:
return "discovery liefert kein WOPI-XML"
return None
CHECKS = {"wordpress": check_wordpress, "nextcloud": check_nextcloud, "collabora": check_collabora}
def cert_days_left(base, timeout):
host = urlsplit(base).hostname
ctx = ssl.create_default_context() # also fails on an invalid or wrong-name certificate
with socket.create_connection((host, 443), timeout=timeout) as sock:
with ctx.wrap_socket(sock, server_hostname=host) as tls:
not_after = ssl.cert_time_to_seconds(tls.getpeercert()["notAfter"])
return int((not_after - time.time()) // 86400)
def run_check(kind, base, timeout):
try:
return CHECKS[kind](base, timeout)
except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError, ssl.SSLError, OSError) as e:
reason = getattr(e, "reason", e)
return f"nicht erreichbar ({reason})"
def online(refs, timeout):
"""Is this machine itself online? True if any reference URL answers at all."""
for url in refs:
try:
fetch(url, timeout)
return True
except Exception:
continue
return False
def fmt_duration(seconds):
m = int(seconds // 60)
return f"{m // 60} h {m % 60} min" if m >= 60 else f"{m} min"
def send_mail(to, subject, text, dry_run):
if dry_run:
print(f"--- MAIL an {to}: {subject}\n{text}\n---")
return
r = subprocess.run(["mail", "-s", subject, to], input=text, text=True, capture_output=True)
if r.returncode != 0:
log(f"MAIL FEHLER rc={r.returncode}: {r.stderr.strip()}")
def main():
dry_run = "--dry-run" in sys.argv
cfg = configparser.ConfigParser()
if not cfg.read(CONF):
sys.exit(f"config missing: {CONF}")
g = cfg["general"]
timeout = g.getint("timeout", 20)
fail_after = g.getint("fail_after", 2)
remind = g.getint("remind_hours", 12) * 3600
cert_warn = g.getint("cert_warn_days", 14)
refs = g.get("reference_urls", "").split()
mail_to = g["mail_to"]
try:
state = json.load(open(STATE))
except (OSError, ValueError):
state = {}
if "--status" in sys.argv:
print(json.dumps(state, indent=2, ensure_ascii=False))
return
now = int(time.time())
targets = {name: val.split(None, 1) for name, val in cfg["targets"].items()}
results = {name: run_check(kind, url, timeout) for name, (kind, url) in targets.items()}
# Everything failed at once? Then it is more likely this machine's own
# line than all servers - check a neutral reference before alarming.
if all(results.values()) and not online(refs, timeout):
log("alle Ziele fehlgeschlagen und Referenz nicht erreichbar - eigene Leitung offline, nichts gezählt")
return
mails = []
for name, (kind, url) in targets.items():
st = state.setdefault(name, {"status": "up", "fails": 0, "since": now, "last_mail": 0})
reason = results[name]
if reason is None:
if st["status"] == "down":
mails.append(f"WIEDER DA {name} ({url}) nach {fmt_duration(now - st['since'])}")
log(f"UP {name} nach {fmt_duration(now - st['since'])}")
st.update(status="up", since=now)
st["fails"] = 0
else:
st["fails"] += 1
log(f"FAIL {name} ({st['fails']}x): {reason}")
if st["status"] == "up" and st["fails"] >= fail_after:
st.update(status="down", since=now, last_mail=now, reason=reason)
mails.append(f"AUSFALL {name} ({url}): {reason}")
elif st["status"] == "down" and now - st["last_mail"] >= remind:
st["last_mail"] = now
mails.append(f"NOCH DOWN {name} ({url}) seit {fmt_duration(now - st['since'])}: {reason}")
# Certificate: checked once per target and day, so at most one warning a day.
if reason is None and now - st.get("cert_checked", 0) >= 86400:
st["cert_checked"] = now
try:
days = cert_days_left(url, timeout)
if days < cert_warn:
mails.append(f"ZERTIFIKAT {name}: läuft in {days} Tagen ab (Erneuerung hängt?)")
except Exception as e:
mails.append(f"ZERTIFIKAT {name}: Prüfung fehlgeschlagen ({e})")
if mails:
down = sum(1 for s in state.values() if s["status"] == "down")
subject = f"Erreichbarkeit: {down} Ziel(e) down" if down else "Erreichbarkeit: alles wieder erreichbar"
text = "\n".join(mails) + f"\n\nGeprüft {dt.datetime.now():%Y-%m-%d %H:%M} von {socket.gethostname()}.\n"
send_mail(mail_to, subject, text, dry_run)
if not dry_run:
tmp = STATE + ".tmp"
with open(tmp, "w") as f:
json.dump(state, f, indent=1)
os.replace(tmp, STATE)
if __name__ == "__main__":
main()
La configurazione uptime_check.conf (valori di esempio):
# uptime_check.conf - chmod 600 (contains the mail address)
[general]
mail_to = you@example.org
# seconds per request
timeout = 20
# failed runs in a row before a DOWN mail (cron every 5 min -> 10 min)
fail_after = 2
remind_hours = 12
cert_warn_days = 14
# neutral sites: if ALL targets fail, these tell "server down" from "own line down"
reference_urls = https://www.google.com/generate_204 https://one.one.one.one/
[targets]
# name = kind base-url
blog = wordpress https://blog.example.org/
cloud = nextcloud https://cloud.example.org/
office = collabora https://office.example.org/
E la voce di crontab:
*/5 * * * * cd $HOME/uptime-check && python3 -I uptime_check.py >> cron.log 2>&1
Per provarlo: --dry-run stampa solo le mail, --status mostra lo stato salvato. Il modo più semplice per testare un guasto è un target in più che punta a un indirizzo inesistente (.invalid) – non percorsi sbagliati sul tuo server, altrimenti fail2ban banna la tua linea.
🎯 Le lezioni
- Il monitoraggio sul server stesso non può segnalare il suo collasso totale – qualcuno deve guardare da fuori.
- Controlla ciò che vede l’utente: una pagina vera, un “installed: true” – non solo un processo in esecuzione.
- Segnala i cambiamenti di stato, non gli stati; due fallimenti prima dell’allarme filtrano i singhiozzi.
- La pressure mostra l’attesa, non l’utilizzo – la cosa che gli utenti percepiscono come “lento”.
- Un parametro di boot funziona solo dopo il boot; è finito solo quando il valore arriva.
E ora: riscaldamento acceso, bollitore acceso, un altro sguardo alle foto di Maiorca. I server chiameranno quando servirà il dottore. There’s no place like 127.0.0.1 – ma 127.0.0.1 è proprio quello che non può dire a nessuno di essere giù. È a questo che serve ora la visita a domicilio. 😉
