Monitoring tot de dokter komt!

Herfst, regen, nauwelijks zonne-opbrengst – tijd voor een volledige check-up: welke monitoringlaag in het homelab wat controleert, waarom een server die plat ligt zichzelf niet kan melden, een kleine uptime-check vanuit huis en wat de pressure-waarde eigenlijk meet.

Illustratie: een dokter en een verpleegster aan een tafel aan zee met monitoringschermen en bier

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

Vanaf 17 uur schakelt de natuur over op dark mode – systeembreed, zonder schakelaar, zonder opt-out. Anders dan hier op de blog kun je het niet wegklikken. 🌑 ’s Ochtends één cijfer op de thermometer, en op grijze dagen hier in Zuid-Duitsland leveren de zonnepanelen net genoeg voor één kop koffie – espresso, geen cappuccino. ☕ Mijn gedachten dwalen af naar de laatste vakantie op Mallorca: zon, zee en Playa de Palma. Thuis is het feest rustiger: servers in plaats van sangria, dashboards in plaats van een dansvloer. 🍹


Nu serieus.

Servers, en webapplicaties in het bijzonder, worden ziek net als echte patiënten. Ze krijgen koorts (CPU aan de limiet), raken buiten adem (schijf vol), lijden aan geheugenverlies (RAM raakt op) of hebben gewoon een slechte dag en antwoorden trager dan normaal. Sommige symptomen verdwijnen vanzelf, andere zijn de eerste tekenen van iets ernstigs en moeten onderzocht worden. Precies dat is monitoring: regelmatig pols, temperatuur en bloeddruk meten, afwijkingen zien voordat ze een noodgeval worden, en weten waar je moet kijken als het serieus wordt.

En net als bij een dokter: als je alleen je eigen pols meet, merk je je eigen hartstilstand niet op. Dat was precies het gat dat in de monitoring hier nog over was.

Inhoud

🩺 De check-up: wie controleert wat?

Ter oriëntatie: er zijn hier twee werelden. Op het internet staan drie gehuurde servers – de blog en twee Nextcloud-instanties. Thuis staat een klein rack met eigen hardware, waaronder de NAS- en backupserver, die toch al de klok rond draait en het grootste deel van de tijd staat te idlen. In de loop van de maanden zijn er in beide werelden monitoringlagen gegroeid. Elke laag beantwoordt een andere vraag.

Op de drie servers op het internet – elke server bewaakt zichzelf:

LaagHoe vaakWat hij opmerkt
Monitelke 2 minservice gestopt, fail2ban-jail weg, bans en firewall niet synchroon, pod hangt, certificaat < 21 dagen, backup te oud, fouten bij mailaflevering
Prometheus + Grafanacontinuschijf, RAM, CPU, containers aan hun limiet, restart-loops, OOM-kills, PHP-FPM verzadigd
Heartbeatscontinueen nachtelijke job (AIDE, rkhunter, ClamAV, updates …) heeft zich niet gemeld
LokicontinuSELinux-denials, fail2ban-fouten, kernel-OOM, een service die te veel fouten schrijft
Werkingstestsbij elke playbook-runban-keten, filters, SELinux-domeinen, metrics aanwezig

Vanaf de NAS-server thuis – de blik van buitenaf en op mijn eigen hardware:

LaagHoe vaakKijkt naarWat hij opmerkt
Aanvalsreviewdagelijksde servers op het internetPOST-bursts op PHP-entrypoints, PHP-FPM-crashes
Blik van buitenwekelijksde servers op het internetopen poorten, certificaten, versies, vergeten oude servers
Temperaturenelke 10 minalleen het rack thuiswarmtegeschiedenis van mijn eigen hardware; echte oververhitting mailt de iLO zelf. De servers op het internet staan in een datacenter – hun temperatuur is de zaak van de hoster.

De les: elke laag bestaat voor één soort storing. Monit ziet of iets draait, Prometheus of het genoeg is, Loki waarom het vastzit, de heartbeats of er überhaupt iets gebeurd is.

🚑 Het gat: wie belt de dokter als de patiënt in elkaar zakt?

De eerste tabel verraadt het al: alles daarin draait op de server die het bewaakt. Als een server volledig crasht, de hoster een storing heeft of het netwerk weg is, gaan Monit, Grafana en Loki mee onderuit. Niemand stuurt een mail – en in de inbox ziet stilte er precies zo uit als “alles in orde”. Een server zonder monitoring is de server van Schrödinger: tegelijk up en down – tot iemand de doos opent, meestal een gebruiker met een telefoon in de hand. 🐈📦

Tot nu toe had je het gemerkt aan de wekelijkse testmail die niet aankomt, of aan de maandagcheck van buitenaf. In het ergste geval pas na dagen. Er is ook een tweede geval: alle services draaien, maar de site toont alleen nog “Error establishing a database connection”, of Nextcloud hangt in de onderhoudsmodus. Voor Monit is alles groen. De vraag is trouwens bijna tweeduizend jaar oud – Juvenalis stelde hem in zijn Satiren: Quis custodiet ipsos custodes? Wie bewaakt de bewakers?

Het gaat om meer dan techniek: ik wil een storing zelf opmerken voordat iemand mij erover benadert. Dat is het verschil tussen reactief en proactief. Reactief betekent handelen nadat een probleem aan het licht is gekomen – meestal omdat iemand belt of schrijft “de cloud doet het niet”. Dan is de schade al gedaan, en de gebruiker zag het eerder dan ik. Proactief betekent er vooraf voor zorgen dat je problemen zelf en vroeg ziet – liefst voordat iemand het merkt, op zijn minst zodat je het eerste bericht kunt beantwoorden met “Weet ik, ik ben ermee bezig.” Elke laag in de tabellen hierboven is een stukje proactiviteit; zonder blik van buitenaf bleef de grootste storing van allemaal reactief. Er zijn twee soorten admins: zij die van een storing horen via hun monitoring – en zij die het horen van hun gebruikers.

De les: monitoring die op dezelfde machine draait als de patiënt, kan diens totale uitval niet melden. Daar is iemand van buiten voor nodig.

🏠 Het huisbezoek: een uptime-check vanuit huis

De oplossing is bewust klein en heeft geen nieuwe hardware nodig – de NAS-server thuis is toch al wakker. Een Python-script daar roept elk van de drie sites op het internet elke 5 minuten aan zoals een bezoeker dat zou doen, alleen zonder browser:

  • WordPress: de homepage antwoordt met 200 en is een echte pagina, geen databasefoutpagina of onderhoudsmelding.
  • Nextcloud: status.php meldt “installed”, “not in maintenance” en “no pending database upgrade”.
  • Collabora: /hosting/discovery levert de WOPI-XML die Nextcloud nodig heeft om documenten te openen.
  • Certificaat: eens per dag – ongeldig of minder dan 14 dagen geldig is een bevinding.

Er gaat alleen mail uit bij een verandering: “down” na twee mislukte runs op rij (een enkele hik is geen alarm), “back” met de duur van de storing, en elke 12 uur een herinnering zolang iets down blijft. Als alle doelen tegelijk falen, controleert het script eerst twee neutrale sites op het internet – zijn die ook weg, dan ligt het aan de eigen lijn en komt er geen vals alarm. In het klein is dit het twee-generaalsprobleem uit de informatica: als er geen antwoord terugkomt, weet je niet of de ontvanger gevallen is of de boodschapper – dus vraag je het aan een derde.

De user agent bevat “uptime”, zodat de bezoekersstatistieken de 288 dagelijkse bezoeken vanuit mijn eigen woonkamer niet meetellen. En een knipoog naar Heisenberg: een meting moet zo weinig mogelijk veranderen aan wat ze meet – twaalf requests per uur verdwijnen in de achtergrondruis.

Zijn eigen grens: als de NAS-server uit staat of de lijn thuis plat ligt, controleert niemand. Toch een grote stap – vroeger draaide de enige check van buitenaf één keer per week.

De les: controleer van buitenaf wat de gebruiker ziet, niet of een proces draait. En meld toestandsveranderingen, geen toestanden – anders belanden de mails al snel ongelezen in het archief. Een alarm dat de hele tijd afgaat, is een rookmelder in een sauna. 🔥

💓 Bloeddruk meten: wat “pressure” betekent

Ook nieuw op het dashboard is een waarde die lang leeg bleef: pressure (Pressure Stall Information, PSI). Die meet niet hoe vol iets is, maar hoe lang programma’s moesten wachten omdat een resource schaars was. Een CPU kan 100 % bezet zijn zonder dat iemand wacht – pas het wachten laat een server traag aanvoelen. Bij de kassa in de supermarkt maakt het niemand uit hoe druk de caissière het heeft – alleen hoe lang de rij is.

$ 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: gewacht op CPU-tijd, op vrij geheugen (de kernel moest eerst geheugen terugwinnen – het vroegste teken vóór OOM-kills) of op de schijf.
  • some: aandeel van de tijd waarin minstens één proces wachtte.
  • full: aandeel van de tijd waarin alle processen wachtten en er niets vooruitging – de ernstigere waarde.
  • avg10 / avg60 / avg300: percentage van de tijd, gemiddeld over 10 seconden, 1 en 5 minuten.

Vuistregel: een paar procent is normaal. some langdurig boven 10–20 % valt op; full op geheugen of schijf een tijd lang duidelijk boven 0 is een bevinding.

Een eigen fout terzijde: op deze servers staat PSI standaard uit in de kernel en wordt het aangezet met de bootparameter psi=1. Instellen was zo gebeurd – maar het werkt pas bij de volgende boot. De blog rebootte de nacht erna; de twee Nextcloud-servers draaiden nog anderhalve dag met een leeg paneel tot ze met de hand herstart werden.

De les: een bootparameter telt pas na de boot. Een wijziging is pas klaar als de waarde aankomt waar je hem wilt zien.

🔍 Een bevinding tijdens de check-up

Alles doorlopen leverde nog iets op: het temperatuurscript voor het rack thuis – het meet alleen mijn eigen hardware, niet de servers op het internet – heeft geen mail geconfigureerd. De eerste zorg was dat niemand oververhitting zou melden. Een blik in de iLO liet zien dat de eigen AlertMail daarvan al lang geleden was ingesteld en kritieke temperaturen zelf meldt. Het script voegt in zijn rapport alleen de vroege, stille hints toe.

De les: kijk voordat je een nieuw alarm bouwt eerst wat er al alarmeert. Dubbele alarmen leveren niets op.

🔭 Wat er nu komt: scherper, niet meer

Monitoring als deze is nooit af. Verder ontwikkelen betekent hier echter niet nieuwe tools toevoegen – het betekent de bestaande tests scherper en specifieker maken. Een paar overwegingen die realistisch zijn en geen nieuwe infrastructuur nodig hebben – ideeën, geen beloftes:

  • Functie in plaats van bereikbaarheid: een testaccount logt in bij Nextcloud, uploadt een klein bestand via WebDAV, haalt het weer op en vergelijkt de checksum. Dat controleert login, opslag, database en Redis in één keer.
  • Inhoud in plaats van statuscode: op de blog opent een test een specifieke post en verwacht diens kop – een pagina kan 200 antwoorden en toch leeg zijn of uit een verouderde cache komen.
  • Traag vóór kapot: de responstijd vastleggen en waarschuwen als die duidelijk boven de eigen mediaan van de afgelopen dagen ligt. De meeste storingen kondigen zich eerst aan als “stroperig”.
  • Wederzijdse checks: de drie servers op het internet controleren elkaar – zo blijft er iemand wakker, ook als de lijn thuis plat ligt.
  • Wie controleert het huisbezoek? De check zelf heeft een heartbeat nodig, bijvoorbeeld een tijdstempel die een monitor op het internet mist als hij niet meer binnenkomt. Juvenalis laat je groeten.

Daar komt fijnafstemming bij: drempels die te vaak of te zelden afgaan worden bijgesteld, en elk echt incident dat geen enkele test opmerkte wordt een vraag: welke test had het gevonden?

De les: monitoring wordt volwassen met elk incident. Hoe specifieker een test, hoe dichter hij bij wat een gebruiker echt doet.

📜 Het script

Alleen de Python-standaardbibliotheek, mail via het lokale mail-commando (hier msmtp). De configuratie met adressen en de mailontvanger staat ernaast, hieronder getoond met voorbeeldwaarden.

#!/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()

De configuratie uptime_check.conf (voorbeeldwaarden):

# 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/

En de crontab-regel:

*/5 * * * * cd $HOME/uptime-check && python3 -I uptime_check.py >> cron.log 2>&1

Om het uit te proberen: --dry-run print alleen de mails, --status toont de opgeslagen toestand. Een storing test je het makkelijkst met een extra doel dat naar een adres wijst dat niet bestaat (.invalid) – niet met verkeerde paden op je eigen server, anders bant fail2ban je eigen lijn.

🎯 De lessen

  • Monitoring op de server zelf kan diens totale uitval niet melden – iemand moet van buitenaf kijken.
  • Controleer wat de gebruiker ziet: een echte pagina, een “installed: true” – niet alleen een draaiend proces.
  • Meld toestandsveranderingen, geen toestanden; twee fouten vóór het alarm filteren de hikjes eruit.
  • Pressure toont wachten, geen bezetting – precies wat gebruikers ervaren als “traag”.
  • Een bootparameter werkt pas na de boot; hij is pas klaar als de waarde aankomt.

En nu: verwarming aan, waterkoker aan, nog één blik op de Mallorca-foto’s. De servers bellen wel als de dokter nodig is. There’s no place like 127.0.0.1 – maar 127.0.0.1 is precies degene die niemand kan vertellen dat hij zelf down is. Daar is nu het huisbezoek voor. 😉

Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details