Monitoring, zanim przyjdzie lekarz!
Jesień, deszcz, prawie zero prądu z paneli słonecznych – czas na pełne badania kontrolne: która warstwa monitoringu w homelabie sprawdza co, dlaczego serwer, który leży, nie może sam tego zgłosić, mały uptime check z domu i co tak naprawdę mierzy wartość pressure.

🌐 Także w: English · Deutsch · Français · Español · Italiano · Português · Nederlands
Od 17:00 natura przełącza się na dark mode – w całym systemie, bez przełącznika, bez opt-out. W przeciwieństwie do tego bloga nie da się tego wyklikać. 🌑 Rano temperatura jednocyfrowa, a w szare dni tu, na południu Niemiec, panele słoneczne produkują akurat tyle, żeby starczyło na jedną kawę – espresso, nie cappuccino. ☕ Myśli wracają do ostatnich wakacji na Majorce: słońce, morze i Playa de Palma. W domu impreza jest spokojniejsza: serwery zamiast sangrii, dashboardy zamiast parkietu. 🍹
A teraz na poważnie.
Serwery, a zwłaszcza aplikacje webowe, chorują tak samo jak prawdziwi pacjenci. Mają gorączkę (CPU na granicy), duszności (pełny dysk), zaniki pamięci (kończy się RAM) albo po prostu gorszy dzień i odpowiadają wolniej niż zwykle. Niektóre objawy mijają same, inne są pierwszymi oznakami czegoś poważnego i trzeba im się przyjrzeć. Dokładnie tym jest monitoring: regularne mierzenie pulsu, temperatury i ciśnienia, wyłapywanie anomalii, zanim zamienią się w nagły wypadek, i wiedza, gdzie szukać, kiedy robi się poważnie.
I jak u lekarza: jeśli mierzysz tylko własny puls, nie zauważysz własnego zatrzymania krążenia. To była dokładnie ta luka, która jeszcze została w tutejszym monitoringu.
Spis treści
🩺 Badania kontrolne: kto sprawdza co?
Dla orientacji: są tu dwa światy. W internecie stoją trzy wynajęte serwery – blog i dwie instancje Nextcloud. W domu jest mała szafa rack z moim własnym sprzętem, w tym serwer NAS i backupowy, który i tak działa całą dobę i przez większość czasu się nudzi. Przez miesiące w obu światach wyrosły warstwy monitoringu. Każda odpowiada na inne pytanie.
Na trzech serwerach w internecie – każdy pilnuje sam siebie:
| Warstwa | Jak często | Co zauważa |
|---|---|---|
| Monit | co 2 min | zatrzymana usługa, zniknięty jail fail2ban, bany i firewall nie są zsynchronizowane, zawieszony pod, certyfikat < 21 dni, za stary backup, błędy doręczania maili |
| Prometheus + Grafana | na bieżąco | dysk, RAM, CPU, kontenery na limicie, pętle restartów, OOM kille, nasycony PHP-FPM |
| Heartbeaty | na bieżąco | nocne zadanie (AIDE, rkhunter, ClamAV, aktualizacje …) się nie zgłosiło |
| Loki | na bieżąco | odmowy SELinux, błędy fail2ban, OOM jądra, usługa zapisująca za dużo błędów |
| Testy działania | przy każdym uruchomieniu playbooka | łańcuch banów, filtry, domeny SELinux, obecność metryk |
Z serwera NAS w domu – spojrzenie z zewnątrz i na mój własny sprzęt:
| Warstwa | Jak często | Patrzy na | Co zauważa |
|---|---|---|---|
| Przegląd ataków | codziennie | serwery w internecie | serie POST na punkty wejścia PHP, crashe PHP-FPM |
| Widok z zewnątrz | co tydzień | serwery w internecie | otwarte porty, certyfikaty, wersje, zapomniane stare serwery |
| Temperatury | co 10 min | tylko rack w domu | historia temperatur mojego własnego sprzętu; prawdziwe przegrzanie iLO zgłasza mailem samo. Serwery w internecie stoją w centrum danych – ich temperatura to sprawa hostera. |
Wniosek: każda warstwa istnieje dla jednego rodzaju awarii. Monit widzi, czy coś działa, Prometheus, czy to wystarcza, Loki, dlaczego się zacięło, heartbeaty, czy w ogóle cokolwiek się wydarzyło.
🚑 Luka: kto wezwie lekarza, gdy pacjent upadnie?
Pierwsza tabela to zdradza: wszystko w niej działa na serwerze, którego pilnuje. Jeśli serwer całkowicie padnie, hoster ma awarię albo zniknie sieć, Monit, Grafana i Loki padają razem z nim. Nikt nie wysyła maila – a w skrzynce cisza wygląda dokładnie jak “wszystko w porządku”. Niemonitorowany serwer to serwer Schrödingera: jednocześnie działa i nie działa – dopóki ktoś nie otworzy pudełka, zwykle użytkownik z telefonem w ręce. 🐈📦
Do tej pory zauważyłbyś to po cotygodniowym mailu testowym, który nie dochodzi, albo po poniedziałkowym sprawdzeniu z zewnątrz. W najgorszym razie po kilku dniach. Jest też drugi przypadek: wszystkie usługi działają, ale strona pokazuje tylko “Error establishing a database connection” albo Nextcloud utknął w trybie konserwacji. Dla Monita wszystko jest zielone. Pytanie ma zresztą prawie dwa tysiące lat – Juwenalis zadał je w swoich Satyrach: Quis custodiet ipsos custodes? Kto pilnuje strażników?
Chodzi tu o coś więcej niż technikę: chcę sam zauważyć awarię, zanim ktoś się do mnie z nią zgłosi. Na tym polega różnica między reaktywnym a proaktywnym. Reaktywnie znaczy działać, gdy problem już wyszedł na jaw – zwykle dlatego, że ktoś dzwoni albo pisze “chmura nie działa”. Wtedy szkoda już się stała, a użytkownik zobaczył to przede mną. Proaktywnie znaczy zadbać z góry, żeby samemu i wcześnie wyłapywać problemy – najlepiej zanim ktokolwiek je zauważy, a co najmniej tak, żeby na pierwszą wiadomość odpowiedzieć “Wiem, już się tym zajmuję.” Każda warstwa w tabelach powyżej to kawałek proaktywności; bez spojrzenia z zewnątrz największa awaria ze wszystkich pozostawała reaktywna. Są dwa rodzaje adminów: ci, którzy dowiadują się o awarii z monitoringu – i ci, którzy dowiadują się od użytkowników.
Wniosek: monitoring działający na tej samej maszynie co pacjent nie zgłosi jej całkowitej awarii. Do tego potrzebny jest ktoś z zewnątrz.
🏠 Wizyta domowa: uptime check z domu
Rozwiązanie jest celowo małe i nie wymaga nowego sprzętu – serwer NAS w domu i tak nie śpi. Skrypt w Pythonie co 5 minut odwiedza każdą z trzech stron w internecie tak, jak zrobiłby to gość, tylko bez przeglądarki:
- WordPress: strona główna odpowiada 200 i jest prawdziwą stroną, a nie stroną błędu bazy danych ani komunikatem o konserwacji.
- Nextcloud:
status.phpzgłasza “installed”, “not in maintenance” i “no pending database upgrade”. - Collabora:
/hosting/discoveryzwraca XML WOPI, którego Nextcloud potrzebuje do otwierania dokumentów. - Certyfikat: raz dziennie – nieważny albo ważny krócej niż 14 dni to znalezisko.
Mail wychodzi tylko przy zmianie: “down” po dwóch nieudanych przebiegach z rzędu (pojedyncza czkawka to nie alarm), “back” z czasem trwania awarii i przypomnienie co 12 godzin, dopóki coś nie działa. Jeśli wszystkie cele zawiodą naraz, skrypt najpierw sprawdza dwie neutralne strony w internecie – jeśli one też zniknęły, to wina własnego łącza i nie ma fałszywego alarmu. W miniaturze to informatyczny problem dwóch generałów: gdy nie wraca żadna odpowiedź, nie wiesz, czy padł odbiorca, czy posłaniec – więc pytasz kogoś trzeciego.
User agent zawiera “uptime”, żeby statystyki odwiedzin nie liczyły 288 dziennych wizyt z mojego własnego salonu. I ukłon w stronę Heisenberga: pomiar powinien jak najmniej zmieniać to, co mierzy – dwanaście żądań na godzinę ginie w szumie tła.
Jego własna granica: jeśli serwer NAS jest wyłączony albo łącze w domu leży, nikt nie sprawdza. Mimo to duży krok – wcześniej jedyne sprawdzenie z zewnątrz odbywało się raz w tygodniu.
Wniosek: sprawdzaj z zewnątrz to, co widzi użytkownik, a nie to, czy działa proces. I zgłaszaj zmiany stanu, a nie stany – inaczej maile szybko lądują nieprzeczytane w archiwum. Alarm, który dzwoni bez przerwy, to czujnik dymu w saunie. 🔥
💓 Pomiar ciśnienia: co znaczy “pressure”
Nowa na dashboardzie jest też wartość, która długo była pusta: pressure (Pressure Stall Information, PSI). Nie mierzy, jak bardzo coś jest pełne, tylko jak długo programy musiały czekać, bo zasobu brakowało. CPU może być zajęty w 100 %, a nikt nie czeka – dopiero czekanie sprawia, że serwer wydaje się wolny. W końcu przy kasie w supermarkecie nikogo nie obchodzi, jak bardzo zajęta jest kasjerka – tylko jak długa jest kolejka.
$ 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: czekano na czas CPU, na wolną pamięć (jądro musiało najpierw ją odzyskać – najwcześniejszy sygnał przed OOM kill) albo na dysk.
- some: udział czasu, w którym czekał co najmniej jeden proces.
- full: udział czasu, w którym czekały wszystkie i nic nie posuwało się naprzód – poważniejsza wartość.
- avg10 / avg60 / avg300: procent czasu, uśredniony z 10 sekund, 1 i 5 minut.
Zasada kciuka: kilka procent to norma. some przez dłuższy czas powyżej 10–20 % rzuca się w oczy; full dla pamięci lub dysku wyraźnie powyżej 0 przez jakiś czas to znalezisko.
Przy okazji mój własny błąd: na tych serwerach PSI jest domyślnie wyłączone w jądrze i włącza się je parametrem rozruchowym psi=1. Ustawienie poszło szybko – ale działa dopiero przy następnym starcie. Blog zrestartował się następnej nocy; dwa serwery Nextcloud chodziły jeszcze półtora dnia z pustym panelem, aż zrestartowałem je ręcznie.
Wniosek: parametr rozruchowy liczy się dopiero po rozruchu. Zmiana jest gotowa dopiero wtedy, gdy wartość dociera tam, gdzie chcesz ją widzieć.
🔍 Znalezisko podczas badań
Przejrzenie wszystkiego ujawniło jeszcze jedno: skrypt temperatur dla racka w domu – mierzy tylko mój własny sprzęt, nie serwery w internecie – nie ma skonfigurowanego maila. Pierwsza obawa: nikt nie zgłosi przegrzania. Rzut oka na iLO pokazał, że jego własny AlertMail był ustawiony dawno temu i sam zgłasza krytyczne temperatury. Skrypt dokłada w swoim raporcie tylko wczesne, ciche wskazówki.
Wniosek: zanim zbudujesz nowy alert, sprawdź, co już alarmuje. Zdublowane alarmy nic nie dają.
🔭 Co dalej: precyzyjniej, nie więcej
Taki monitoring nigdy nie jest skończony. Rozwijanie go nie oznacza tu jednak dodawania nowych narzędzi – oznacza wyostrzanie i uszczegóławianie istniejących testów. Kilka przemyśleń, realistycznych i niewymagających nowej infrastruktury – pomysły, nie obietnice:
- Funkcja zamiast osiągalności: konto testowe loguje się do Nextcloud, wysyła mały plik przez WebDAV, pobiera go z powrotem i porównuje sumę kontrolną. To sprawdza logowanie, storage, bazę danych i Redis za jednym zamachem.
- Treść zamiast kodu statusu: na blogu test otwiera konkretny wpis i oczekuje jego nagłówka – strona może odpowiedzieć 200, a mimo to być pusta albo pochodzić z nieaktualnego cache.
- Wolno przed zepsute: zapisywać czas odpowiedzi i ostrzegać, gdy jest wyraźnie powyżej własnej mediany z ostatnich dni. Większość awarii zapowiada się najpierw jako “ospałość”.
- Wzajemne sprawdzanie: trzy serwery w internecie sprawdzają się nawzajem – dzięki temu ktoś czuwa, nawet gdy łącze w domu leży.
- Kto sprawdza wizytę domową? Sam check potrzebuje heartbeatu, na przykład znacznika czasu, którego brak zauważy monitor w internecie, gdy przestanie przychodzić. Juwenalis pozdrawia.
Do tego dochodzi dostrajanie: progi, które odpalają za często albo za rzadko, są korygowane, a każdy prawdziwy incydent, którego nie zauważył żaden test, zamienia się w pytanie: który test by go znalazł?
Wniosek: monitoring dojrzewa z każdym incydentem. Im bardziej konkretny test, tym bliżej tego, co naprawdę robi użytkownik.
📜 Skrypt
Tylko biblioteka standardowa Pythona, mail przez lokalne polecenie mail (tutaj msmtp). Konfiguracja z adresami i odbiorcą maili leży obok, poniżej z przykładowymi wartościami.
#!/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()
Konfiguracja uptime_check.conf (przykładowe wartości):
# 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/
I wpis w crontabie:
*/5 * * * * cd $HOME/uptime-check && python3 -I uptime_check.py >> cron.log 2>&1
Do wypróbowania: --dry-run tylko wypisuje maile, --status pokazuje zapisany stan. Awarię najłatwiej przetestować dodatkowym celem wskazującym na adres, który nie istnieje (.invalid) – a nie błędnymi ścieżkami na własnym serwerze, bo inaczej fail2ban zbanuje twoje własne łącze.
🎯 Wnioski
- Monitoring na samym serwerze nie zgłosi jego całkowitej awarii – ktoś musi patrzeć z zewnątrz.
- Sprawdzaj to, co widzi użytkownik: prawdziwą stronę, “installed: true” – a nie tylko działający proces.
- Zgłaszaj zmiany stanu, nie stany; dwie porażki przed alarmem odfiltrowują czkawki.
- Pressure pokazuje czekanie, nie obciążenie – to, co użytkownicy odczuwają jako “wolno”.
- Parametr rozruchowy działa dopiero po rozruchu; gotowe jest dopiero wtedy, gdy wartość dociera.
A teraz: ogrzewanie włączone, czajnik włączony, jeszcze jedno spojrzenie na zdjęcia z Majorki. Serwery zadzwonią, kiedy będzie potrzebny lekarz. There’s no place like 127.0.0.1 – ale 127.0.0.1 to właśnie ten, który nikomu nie powie, że sam leży. Od tego jest teraz wizyta domowa. 😉
