Wer eine professionelle IT-Infrastruktur betreibt, braucht mehr als nur funktionierende Server – er braucht absolute Gewissheit über den Systemzustand in Echtzeit. Wenn Dienste ausfallen, VPN-Tunnel wegbrechen oder Ressourcen volllaufen, will man nicht erst durch Zufall oder Kundenbeschwerden darauf stoßen. Die Checkmk Community Edition (CE) ist hierbei eines der mächtigsten Open-Source-Monitoring-Werkzeuge am Markt.

In diesem massiven Praxis-Artikel zeigen wir dir nicht nur, wie du Checkmk sauber auf einer frischen Debian 13 (Trixie) Instanz aufsetzt. Wir gehen tief in die Architektur: Von der ordnerbasierten Host-Verwaltung, über verteilte Multisite-Umgebungen (Distributed Monitoring), eigene Skripte und automatisierte Rollouts bis hin zu modernen Gotify-Push-Notifications.

1. Dimensionierung & Ressourcen unter Debian 13

Checkmk arbeitet extrem performant, verbraucht bei wachsender Host-Anzahl aber spürbar Arbeitsspeicher und I/O-Leistung.

• CPU & RAM: Für eine kleine bis mittlere Instanz (bis zu 50–100 Hosts und einige hundert Services) empfehlen sich mindestens 2 bis 4 vCPUs und 4 bis 8 GB RAM. Checkmk hält viele Daten im Arbeitsspeicher vor, um Abfragen in Millisekunden zu ermöglichen.
• Storage & I/O (RRDs): Checkmk schreibt permanent Performance-Metriken in sogenannte Round Robin Databases (RRDs). Eine langsame Festplatte führt hier schnell zu I/O-Waits und einem trägen Web-Interface. Eine schnelle NVMe- oder SSD-Anbindung (idealerweise auf einem ZFS- oder ext4-Dateisystem) ist absoluter Pflichtfaktor.

2. Schritt-für-Schritt: Installation von Checkmk CE auf Debian 13

Bevor das eigentliche Paket eingespielt wird, müssen die Systemquellen und grundlegende Abhängigkeiten (wie GnuPG) vorbereitet werden.

Schritt 1: System aktualisieren und Abhängigkeiten laden

apt update && apt upgrade -y
apt install wget curl apt-transport-https gnupg dos2unix -y
        

Schritt 2: Checkmk-Paket herunterladen und installieren
Lade das passende Debian-Paket direkt von der Checkmk-Website herunter. Nutze zur Installation zwingend apt, damit eventuell fehlende System-Abhängigkeiten direkt mit aufgelöst werden:

# Beispiel für den Download (passe die Version an deine Zielversion an)
wget https://download.checkmk.com/checkmk/2.3.0pXX/check-mk-raw-2.3.0pXX_0.trixie_amd64.deb
apt install ./check-mk-raw-*.deb -y
        

Schritt 3: OMD-Instanz anlegen und starten
Checkmk läuft in isolierten Instanzen über das Open Monitoring Distribution (OMD) Framework:

# Instanz erstellen (Name hier beispielhaft: "monitoring")
omd create monitoring

# Instanz starten
omd start monitoring
        

Danach ist die Instanz über den Browser unter http://[server-ip]/monitoring erreichbar (Standard-Login: cmkadmin mit dem bei der Erstellung generierten Passwort).

3. Best Practice: Ordnerstruktur und der erste Host

Ein häufiger Fehler bei neuen Checkmk-Setups ist es, alle Hosts unstrukturiert in das Hauptverzeichnis (Main Directory) zu werfen. Checkmk nutzt eine geniale Vererbungslogik. Du solltest im Management-Bereich (Setup) immer mit Ordnern arbeiten (z. B. "Linux Server", "Windows", "Netzwerk", "Standort Berlin").

Der große Vorteil: Du kannst Regeln (z. B. "SSH-Checks ausführen", Anmeldedaten für SNMP oder Schwellenwerte für CPU-Auslastung) direkt auf einen Ordner anwenden. Jeder Host in diesem Ordner erbt die Einstellungen automatisch. Das spart bei wachsenden IT-Umgebungen massiv Zeit.

Den ersten Host aufnehmen (Der Monitoring-Server selbst):

1. Navigiere im Webinterface zu Setup → Hosts → Main directory und erstelle einen Ordner "Monitoring-Infrastruktur".
2. Klicke in diesem Ordner auf Add Host.
3. Trage den Hostnamen deines Checkmk-Servers ein (z. B. srv-monitoring) und dessen IP-Adresse (oder 127.0.0.1).
4. Speichere und klicke auf Save & go to service configuration. Checkmk wird nun alle laufenden Dienste des eigenen Servers erkennen.
5. Aktiviere die Änderungen oben rechts (gelbes Ausrufezeichen) über Activate on selected sites.

4. Agenten-Deployment & TLS-Registrierung (Windows & Linux)

Damit der Server Daten von anderen Systemen einsammeln kann, benötigen diese den Checkmk-Agenten. Das Herunterladen über das WATO-Webinterface (unter Setup → Agents) ist besonders für Windows-Hosts der beste und komfortabelste Weg. Für Linux-Umgebungen empfiehlt sich hingegen der Weg über die Kommandozeile.

Die schnelle Windows-Installation:

1. Lade das fertige .msi-Installationspaket direkt aus dem WATO-Interface herunter.
2. Führe das Setup auf dem Windows-Server aus (der Agent installiert sich automatisch als Hintergrunddienst und konfiguriert die Windows Firewall für Port 6556).
3. Öffne eine administrative Eingabeaufforderung (CMD) und führe die notwendige TLS-Registrierung durch:

   "C:\Program Files (x86)\checkmk\service\cmk-agent-ctl.exe" register --server [checkmk-server-ip] --site monitoring --user cmkadmin

Die saubere Linux-Installation (Debian/Ubuntu):

Lade die .deb Datei per wget vom Checkmk-Server herunter und nutze zwingend apt install (statt dpkg -i). Nur so stellst du sicher, dass alle System-Abhängigkeiten (wie xinetd oder systemd-network-Tools), die der Agent benötigt, automatisch mitinstalliert werden:

# Agent vom Server laden (IP und Instanzname anpassen)
wget http://[checkmk-server-ip]/monitoring/check_mk/agents/check-mk-agent.deb

# Installation inklusive aller Abhängigkeiten
apt install ./check-mk-agent.deb -y
        

TLS-Registrierung für Linux:

cmk-agent-ctl register --server [checkmk-server-ip] --site monitoring --user cmkadmin

5. Bonus: Automatisches Massen-Deployment per Skript (CE-Workaround)

In der Enterprise Edition gibt es die "Agent Bakery", die Agenten und Plugins vollautomatisch verpackt und verteilt. In der Community Edition muss man das manuell machen – oder man nutzt dieses kleine Bash-Skript, um das Enterprise-Feature pragmatisch zu umgehen.

Das Skript liest eine Liste von IP-Adressen (server_liste.txt), lädt automatisch den aktuellsten Agenten sowie gewünschte Plugins (hier z. B. mk_apt) von deinem Checkmk-Server herunter und installiert diese via SSH auf allen Ziel-Hosts.

Wichtig: Das System, von dem du dieses Skript ausführst, benötigt zwingend SSH-Zugriff (idealerweise passwortlos per SSH-Key) auf alle Ziel-Server in der Liste.

#!/bin/bash

if [ -z "$1" ]; then
    echo "Nutzung: $0 <server_liste.txt>"
    exit 1
fi

SERVER_LISTE="$1"
REMOTE_USER="root"

# --- ANPASSEN ---
CMK_SERVER="checkmk.deine-domain.de"
SITE="monitoring"
# ----------------

BASE_URL="http://$CMK_SERVER/$SITE/check_mk/agents/"
PLUGIN_URL="${BASE_URL}plugins/mk_apt"

SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
LOCAL_DEB="$SCRIPT_DIR/check-mk-agent_install.deb"
LOCAL_PLUGIN="$SCRIPT_DIR/mk_apt"

if [ ! -f "$SERVER_LISTE" ]; then
    echo "Fehler: Datei $SERVER_LISTE nicht gefunden!"
    exit 1
fi

# 1. Version ermitteln & Download
echo "Ermittle Version von $CMK_SERVER..."
LATEST_AGENT_NAME=$(curl -s "$BASE_URL" | grep -oP 'check-mk-agent_[^"]+?_all\.deb' | head -n 1)

if [ -z "$LATEST_AGENT_NAME" ]; then
    echo "Fehler: Keine Version gefunden!"
    exit 1
fi

echo "Lade $LATEST_AGENT_NAME herunter..."
wget -q -O "$LOCAL_DEB" "${BASE_URL}${LATEST_AGENT_NAME}"
wget -q -O "$LOCAL_PLUGIN" "$PLUGIN_URL"

if [ ! -s "$LOCAL_DEB" ]; then
    echo "Fehler: Download fehlgeschlagen!"
    exit 1
fi

# 2. Liste bereinigen
/usr/bin/dos2unix "$SERVER_LISTE" 2>/dev/null

# 3. Deployment Loop
while read -r LINE; do
    [ -z "$LINE" ] && continue
    
    IP=$(echo "$LINE" | cut -d':' -f1)
    PORT=$(echo "$LINE" | cut -d':' -f2)
    [ "$IP" == "$PORT" ] && PORT=22
    
    echo "------------------------------------------------------"
    echo "Deployment auf: $IP (Port: $PORT)"
    
    if [ ! -f "$LOCAL_DEB" ]; then
        echo "Kritischer Fehler: Datei im Skript-Verzeichnis verschwunden!"
        exit 1
    fi
    
    # Kopieren
    scp -P "$PORT" -q "$LOCAL_DEB" "$LOCAL_PLUGIN" "$REMOTE_USER@$IP:/tmp/" < /dev/null
    
    # Remote Installation via apt (inklusive Abhängigkeiten)
    ssh -p "$PORT" -n "$REMOTE_USER@$IP" "apt install -y /tmp/check-mk-agent_install.deb > /dev/null && \
        mkdir -p /usr/lib/check_mk_agent/plugins/ && \
        mv /tmp/mk_apt /usr/lib/check_mk_agent/plugins/ && \
        chmod +x /usr/lib/check_mk_agent/plugins/mk_apt && \
        rm /tmp/check-mk-agent_install.deb"
    
    echo "Fertig mit $IP"
done < "$SERVER_LISTE"

# 4. Am Ende aufräumen
rm -f "$LOCAL_DEB" "$LOCAL_PLUGIN"
echo "------------------------------------------------------"
        

6. Ausfallsicherheit: Distributed Monitoring bei mehreren Standorten

Ein kritisches Architektur-Thema: Stell dir vor, dein Haupt-Monitoring-Server steht im Rechenzentrum, und du überwachst 50 Hosts an einem entfernten Standort über eine Site2Site-VPN-Verbindung. Wenn das VPN abreißt, färbt sich dein gesamtes Checkmk rot. Du weißt nicht: Sind die Server am Standort abgestürzt, oder ist nur das VPN down? Du fliegst komplett im Blindflug.

Die Lösung heißt Distributed Monitoring.
Anstatt jeden Host einzeln durch das VPN abzufragen, setzt du an jedem Außenstandort eine eigene, kleine Checkmk-Instanz auf. Diese lokale Instanz überwacht alle Server vor Ort. Im Haupt-Checkmk (Master) bindest du diese Remote-Instanz über Setup → Distributed Monitoring ein.

• Ausfallsicherheit: Bricht das VPN weg, sammelt die lokale Instanz am Standort weiterhin fröhlich Daten. Vor-Ort-Admins können sich auf dem lokalen Checkmk einloggen und sehen exakt, was los ist.
• Geringere Netzlast: Es gehen keine hunderte Einzel-Checks durch das VPN, sondern nur noch gebündelte Datenströme zwischen den beiden Checkmk-Cores.
• Zentrale Verwaltung: Du konfigurierst alles bequem im Master-System; dieses pusht die Konfiguration automatisch an die Satelliten-Standorte.

7. Monitoring erweitern: Eigene Skripte, Plugins und KI

Checkmk bringt tausende Checks von Haus aus mit. Aber was, wenn du einen spezifischen Dienst oder etwas hochgradig Individuelles überwachen willst? Hier glänzt Checkmk durch absolute Flexibilität.

Vorgefertigte Plugins aus WATO nutzen:
Du musst nicht für jeden Standard-Dienst das Internet durchforsten. Checkmk bringt bereits eine riesige Bibliothek an fertigen Plugins (inklusive Beispiel-Konfigurationen) mit. Diese findest du bequem im Webinterface unter Setup → Agents → Windows, Linux, Solaris, AIX. Lade das gewünschte Plugin einfach herunter und verteile es.

Auf dem überwachten Client (dem Host mit dem installierten Agenten) gibt es dafür zwei wichtige Verzeichnisse:

• /usr/lib/check_mk_agent/plugins → Hier legst du die vorgefertigten Plugins aus dem WATO oder der Community ab (z. B. für Docker, Nginx oder Postgres).
• /usr/lib/check_mk_agent/local → Hier landen deine eigenen Local Checks.

Eigene Skripte (mit KI-Unterstützung) erstellen:
Ein eigenes Skript (Bash, Python, PHP etc.) im local-Verzeichnis muss lediglich ausführbar sein (chmod +x) und einen standardisierten Text-Output generieren, den Checkmk versteht.

Pro-Tipp: In der heutigen Zeit ist die Nutzung von KI (wie ChatGPT oder Claude) ein genialer Weg, um sich maßgeschneiderte Local-Check-Skripte für firmeninterne Anwendungen passgenau generieren zu lassen! Du musst der KI lediglich vorgeben, was geprüft werden soll und wie der Output aussehen muss.

Das geforderte Format ist simpel:
[STATUS] "[Service_Name]" - [Optionale Metriken] [Textmeldung]

Beispiel für ein Bash-Skript:

#!/bin/bash
# Status: 0=OK, 1=WARN, 2=CRIT, 3=UNKNOWN

if [ -f "/var/log/backup_success.lock" ]; then
    echo "0 \"Tägliches_Backup\" - Backup wurde erfolgreich abgeschlossen."
else
    echo "2 \"Tägliches_Backup\" - KRITISCH: Backup-Lockfile fehlt!"
fi
        

Checkmk erkennt dieses Skript beim nächsten Agent-Durchlauf vollautomatisch als neuen Service "Tägliches_Backup" und alarmiert dich sofort, falls die Datei fehlt.

8. Moderne Benachrichtigungen: Weg von SMTP, hin zu Gotify

Klassische E-Mail-Benachrichtigungen über lokale SMTP-Relays sind oft unzuverlässig, landen im Spam oder gehen im täglichen Postfach-Chaos unter. Wenn nachts ein Server stirbt, willst du eine direkte Push-Nachricht auf dem Smartphone.

Die Lösung: Gotify
Gotify ist ein blitzschneller, selbstgehosteter Push-Notification-Server. Checkmk kann über Webhooks extrem einfach HTTP-POST-Requests an die Gotify-API senden.

Einrichtung in Checkmk:

1. Erstelle in deiner Gotify-Oberfläche eine neue Applikation und kopiere den generierten App-Token.
2. Gehe in Checkmk auf Setup → Events → Notifications und lege eine neue Regel vom Typ Alert Webhook an.
3. Trage die URL deines Gotify-Servers ein:
   https://push.deinedomain.de/message?token=DEIN_APP_TOKEN
4. Definiere das JSON-Payload-Format, damit Titel und Nachrichtentext sauber an Gotify übergeben werden.

9. Für große Netzwerke: Wann lohnt sich die Checkmk Enterprise (Pro) Edition?

Die Community Edition (CE) ist für kleine bis mittlere Setups absolut gigantisch. Doch ab einer gewissen Größe (Konzern-Strukturen, hunderte Hosts, verteilte Landschaften) stoßen Open-Source-Kerne an ihre Grenzen. Die Enterprise Edition bietet hier entscheidende Architektur-Vorteile:

• Der CMC (Checkmk Micro Core): Die CE nutzt unter der Haube den klassischen Nagios-Core. Die Enterprise-Version setzt auf den in C++ geschriebenen CMC. Dieser verbraucht nur einen Bruchteil an CPU/RAM und bewältigt zehntausende Checks pro Sekunde ohne ins Schwitzen zu kommen.
• Agent Bakery (Agenten-Bäckerei): Statt Agenten manuell oder per Skript auf Linux- und Windows-Servern zu patchen, konfiguriert die Enterprise-Version maßgeschneiderte Agenten-Pakete zentral im Webinterface und verteilt Updates vollautomatisch an alle Server.
• SLA-Reporting & PDF-Berichte: Perfekt für IT-Dienstleister. Du kannst hochprofessionelle, automatisierte PDF-Berichte über Verfügbarkeiten generieren und direkt an Kunden oder das Management schicken lassen.
• Erweiterte Graphen & Vorhersagen: Bessere Metriken, längere Historien und Prognose-Algorithmen, die dich warnen, bevor eine Festplatte nächste Woche vollläuft.

Fazit

Die Kombination aus Debian 13, Checkmk und einem Push-Dienst wie Gotify ergibt ein extrem robustes, hochperformantes Monitoring-Setup. Wer eine saubere Ordnerstruktur pflegt, dezentrale Standorte per Distributed Monitoring anbindet und eigene Checks clever über das Agenten-Plugin-Verzeichnis ausrollt, behält auch in komplexesten IT-Landschaften immer die absolute Kontrolle.