Uptime Kuma: Dein Open-Source Monitoring-Tool einfach mit Docker installieren

Was ist Uptime Kuma?

Uptime Kuma ist ein beliebtes, selbst gehostetes Monitoring-Tool. mit dem ihr eure Webseiten, Server und eigentlich fast jeden Onlinedienst überwachen könnt. Es ist übersichtlich gestaltet und bietet vielfältige Benachrichtigungsoptionen. So erfahrt ihr immer als Erstes, wenn eure Seite oder euer Dienst nicht mehr funktioniert. Es zeichnet sich durch eine moderne und reaktive Benutzeroberfläche aus und bietet eine breite Palette an Überwachungsfunktionen:

• HTTP(s) / TCP / HTTP(s) Keyword / HTTP(s) Json Query
• Ping / DNS Record / Push
• Steam Game Server / Docker Container
• Benachrichtigungen über 90+ Dienste (Telegram, Discord, E-Mail etc.)
• Kurze Überwachungsintervalle (bis zu 20 Sekunden)
• Mehrsprachigkeit
• Erstellung mehrerer Statusseiten, auch mit Zuordnung zu eigenen Domains
• Zertifikatsinformationen und Ping-Charts
• Proxy- und 2FA-Unterstützung

Das Beste daran: Es ist Open Source und ihr behaltet die volle Kontrolle über eure Daten.

Voraussetzungen

• Ein VPS (z.B. mit Ubuntu 24.04 oder einer anderen Linux-Distribution).
• Docker und Docker Compose müssen auf dem Server installiert sein.
• Grundlegende Kenntnisse im Umgang mit der Kommandozeile.
• (Optional) Eine Domain, wenn du Uptime Kuma später über einen Reverse Proxy mit einer eigenen Adresse erreichbar machen möchtest.

Installation mit Docker Compose

Wir werden Uptime Kuma mithilfe von Docker Compose installieren. Dies ermöglicht uns eine flexible Konfiguration, insbesondere wenn wir später eine separate Datenbank oder einen Reverse Proxy hinzufügen möchten.

1. Verbindung zum Server und Verzeichnis erstellen Verbinde dich per SSH mit deinem VPS. Erstelle dann ein Verzeichnis für Uptime Kuma und wechsle hinein, darin erstellen wir auch ein Unterverzeichnis für die Daten:

   mkdir uptime-kuma
   cd uptime-kuma
   mkdir data

2. Docker Compose Datei erstellen Erstelle eine compose.yaml-Datei mit einem Texteditor deiner Wahl (z.B. nano):

   nano compose.yaml

   Füge folgenden Inhalt ein. Dieser Basis-Setup startet Uptime Kuma mit einer integrierten SQLite-Datenbank, was für viele Anwendungsfälle ausreichend ist.

   services:
       uptime-kuma:
           image: louislam/uptime-kuma:1 # Empfohlene stabile Version
           container_name: uptime-kuma
           volumes:
               - ./data:/app/data
           ports:
               - "3001:3001" # <Host-Port>:<Container-Port>
           restart: always

   • image: louislam/uptime-kuma:1: Dies ist das offizielle stabile Image von Docker Hub. Es gibt auch Beta-Versionen (z.B. ghcr.io/louislam/uptime-kuma:beta), wenn du experimentierfreudiger bist.
   • container_name: uptime-kuma: Ein benutzerdefinierter Name für unseren Container.
   • volumes: ./data:/app/data: Sehr wichtig! Hiermit legen wir fest, dass die Daten von Uptime Kuma (Konfiguration, Checks, etc.) im Unterordner data auf unserem Host gespeichert werden. So bleiben die Daten auch erhalten, wenn wir den Container neu starten oder aktualisieren.
   • ports: "3001:3001": Uptime Kuma läuft im Container auf Port 3001. Wir mappen diesen auf den Port 3001 unseres VPS. Wenn Port 3001 bei dir schon belegt ist, kannst du den Host-Port ändern (z.B. "3002:3001").
   • restart: always: Stellt sicher, dass der Container automatisch neu startet, falls der Server mal neu gestartet wird oder der Container abstürzt.

   Speichere die Datei (bei nano mit Strg+O, Enter, dann Strg+X).

3. Uptime Kuma starten Da wir uns im Verzeichnis mit der compose.yaml-Datei befinden, können wir die Container einfach starten:

   sudo docker compose up -d

   Docker wird nun das Uptime Kuma Image herunterladen (das kann beim ersten Mal einen Moment dauern) und den Container im Hintergrund starten (-d für detached mode).

   Du kannst den Status der Container überprüfen:

   sudo docker compose ps

   Und die Logs einsehen:

   sudo docker compose logs uptime-kuma

   Um den Ressourcenverbrauch zu sehen:

   sudo docker compose stats

Ersteinrichtung von Uptime Kuma

Öffne nun deinen Webbrowser und gib die IP-Adresse deines Servers gefolgt von Port 3001 ein: http://DEINE_SERVER_IP:3001.

Du wirst vom Einrichtungsassistenten begrüßt:

1. Sprache auswählen: Wähle deine bevorzugte Sprache.
2. Benutzerkonto erstellen: Lege einen Administrator-Benutzernamen und ein sicheres Passwort fest.
3. Datenbank-Typ (optional für diese Anleitung): Mit der obigen compose.yaml wird standardmäßig SQLite verwendet, was in Uptime Kuma integriert ist und keine weitere Konfiguration benötigt. In der Beta kann man eine integrierte MySQL Datenbank wählen oder eine zusätzliche MariaDB/MySQL-Datenbank betreiben und diese wählen.

Klicke auf “Erstellen” und du landest im Dashboard von Uptime Kuma.

Uptime Kuma erkunden und konfigurieren

Dashboard

Das Dashboard ist deine zentrale Anlaufstelle. Hier siehst du alle deine Monitore und deren aktuellen Status.

Einstellungen (Settings)

Klicke oben rechts auf dein Profilbild und dann auf “Einstellungen”. Hier einige wichtige Punkte:

• Allgemein (General):
  • Zeitzone (Time Zone): Stelle deine lokale Zeitzone ein.
  • Primäre Basis-URL (Primary Base URL): Wichtig, wenn du später einen Reverse Proxy nutzt.
  • Sichtbarkeit für Suchmaschinen (Search Engine Visibility): Verhindere, dass deine Uptime Kuma Instanz von Google indexiert wird.
• Erscheinungsbild (Appearance): Wähle zwischen hellem, dunklem oder automatischem Theme.
• Benachrichtigungen (Notifications): Das Herzstück! Richte hier deine Benachrichtigungskanäle ein.
  • Klicke auf “Benachrichtigung einrichten”.
  • Wähle den Typ (z.B. E-Mail (SMTP), Telegram, Discord).
  • Gib die erforderlichen Daten ein. Für SMTP benötigst du die Daten deines Mailservers oder eines Dienstes wie Maileroo Affiliate Link.
  • Du kannst Testbenachrichtigungen senden.
• Über (About):
  • Hier kannst du nach Updates suchen. Wenn du die Beta-Version nutzt, setze den Haken bei “Beta-Release prüfen”.

Einen Monitor hinzufügen

Gehe zurück zum Dashboard und klicke auf ”+ Monitor hinzufügen”.

1. Monitortyp: Wähle den passenden Typ aus. Für eine Webseite ist “HTTP(s)” üblich.
2. Anzeigename: Ein beschreibender Name, z.B. “Meine Webseite”.
3. URL: Die vollständige URL, z.B. https://deployn.de.
4. Überwachungsintervall: Wie oft geprüft werden soll (z.B. alle 60 Sekunden).
5. Wiederholungen bei Ausfall: Wie oft ein Fehler auftreten muss, bevor der Dienst als “Down” markiert wird.
6. Benachrichtigungen: Wähle hier deine zuvor eingerichteten Benachrichtigungskanäle aus, die für diesen Monitor zuständig sein sollen.
7. Weitere Einstellungen: Du kannst z.B. erwartete HTTP-Statuscodes festlegen oder nach Keywords im Seiteninhalt suchen.

Klicke auf “Speichern”. Dein Monitor erscheint nun im Dashboard und wird regelmäßig geprüft.

Eine Statusseite erstellen

Mit Uptime Kuma kannst du öffentliche oder private Statusseiten erstellen, um den Zustand deiner Dienste anzuzeigen.

1. Klicke im Menü auf “Statusseiten”.
2. Klicke auf ”+ Neue Statusseite”.
3. Name: z.B. “Deployn Status”.
4. Slug: Ein URL-freundlicher Name, z.B. deployn-status.
5. Klicke auf “Weiter”.
6. Im nächsten Schritt (“Monitore hinzufügen”) wähle die Monitore aus, die auf dieser Statusseite angezeigt werden sollen.
7. Klicke auf “Speichern”.

Du erhältst einen Link zu deiner Statusseite (z.B. http://DEINE_SERVER_IP:3001/status/deployn-status). Diese kannst du teilen, um Nutzern Transparenz über deine Systemverfügbarkeit zu geben.

Erweiterung: Externe MariaDB-Datenbank (Optional)

Wenn du eine robustere Datenbanklösung bevorzugst oder bereits MariaDB nutzt, kannst du Uptime Kuma mit einer separaten MariaDB-Instanz verbinden.

1. Docker Compose anpassen: Stoppe zuerst deine laufenden Uptime Kuma Container und erstelle einen neuen Ordner für die MariaDB-Daten:

   sudo docker compose down
   mkdir mariadb-data

   Öffne deine compose.yaml und erweitere sie:

    services:
       uptime-kuma:
           image: ghcr.io/louislam/uptime-kuma:beta
           container_name: uptime-kuma
           volumes:
               - ./uptime-kuma-data:/app/data
           ports:
               - 3001:3001
           restart: always
           networks:
               - internal # Für interne Kommunikation
           depends_on:
               - uptime-kuma-db
   
       uptime-kuma-db:
           image: mariadb:11
           container_name: uptime-kuma-db
           restart: always
           networks:
               - internal
           volumes:
               - ./mariadb-data:/var/lib/mysql # Wichtig für Datenpersistenz der DB!
           environment:
               - MARIADB_ROOT_PASSWORD=uptimekumapassword # Root-Passwort für die DB
               - MARIADB_DATABASE=uptimekuma
               - MARIADB_USER=uptimekuma
               - MARIADB_PASSWORD=password
   networks:
       internal:
           external: false

   Wichtige Änderungen:

   • Wir haben einen neuen Service uptime-kuma-db für MariaDB hinzugefügt.
   • Passwörter und Namen anpassen!
   • Für uptime-kuma-db wird das Volume ./mariadb-data:/var/lib/mysql gemappt, um die Datenbankdaten persistent zu speichern.
   • Ein internal Netzwerk wurde für die Kommunikation zwischen den Containern definiert.

2. Container neu starten:

   sudo docker compose up -d

   Wenn du Uptime Kuma zum ersten Mal mit dieser Konfiguration startest und die ./data leer ist, wirst du wieder durch den Setup-Prozess geführt. Wähle dann “Externe MariaDB/MySQL” aus und trage die Daten ein: Host uptime-kuma-db, Port 3306, Benutzer, Passwort und Datenbankname wie in der Compose-Datei.

Erweiterung: Reverse Proxy mit Caddy (Optional)

Um Uptime Kuma über eine eigene Domain (z.B. status.deine-domain.de) mit HTTPS zu erreichen, ist ein Reverse Proxy ideal. Hier ein Beispiel mit Caddy.

1. Voraussetzung: Caddy ist bereits auf deinem Server installiert und läuft (z.B. auch als Docker Container). Du hast ein Docker-Netzwerk (hier proxy genannt), das Caddy und Uptime Kuma gemeinsam nutzen können.

   # Falls noch nicht vorhanden, erstelle ein externes Docker-Netzwerk
   sudo docker network create proxy

2. Caddyfile anpassen: Füge deiner Caddyfile (oder der entsprechenden Konfigurationsdatei) einen Eintrag für Uptime Kuma hinzu:

   status.deine-domain.de {
       reverse_proxy uptime-kuma:3001
   }

   • status.deine-domain.de: Ersetze dies mit deiner gewünschten Domain/Subdomain. Stelle sicher, dass der DNS-Eintrag dafür auf die IP deines Servers zeigt.
   • uptime-kuma:3001: Caddy leitet Anfragen an den Container uptime-kuma auf Port 3001 weiter.

3. Uptime Kuma Docker Compose anpassen: Öffne erneut die compose.yaml für Uptime Kuma:

   • Stelle sicher, dass die ports-Sektion für den uptime-kuma-Service auskommentiert oder entfernt ist, da Caddy den Zugriff übernimmt.
   • Füge den uptime-kuma-Service zum proxy-network hinzu und deklariere es als extern:

   services:
       uptime-kuma:
           # ... (andere Einstellungen) ...
           # ports: # Auskommentieren oder entfernen
           #  - "3001:3001"
           networks:
               - internal
               - proxy # Hinzufügen
           # ... (Rest der Einstellungen) ...
   
   networks:
       internal:
           external: false
       proxy: # Hinzufügen
           external: true

4. Container neu starten und Caddy neuladen:

   sudo docker compose up -d       # Startet Uptime Kuma neu mit den Netzwerkänderungen
   sudo docker reload caddy        # Oder der Befehl, um deine Caddy-Konfiguration neu zu laden

   Nun solltest du Uptime Kuma unter https://status.deine-domain.de erreichen können. In den Uptime Kuma Einstellungen unter “Primäre Basis-URL” kannst du diese neue Adresse eintragen.

Erweiterung: Docker Container überwachen (Optional)

Uptime Kuma kann auch den Status anderer Docker Container auf demselben Host überwachen.

1. Docker Socket in Uptime Kuma einbinden: Passe die docker-compose.yml für den uptime-kuma-Service an, um den Docker Socket read-only einzubinden:

   # ... (services -> uptime-kuma) ...
   volumes:
       - ./data:/app/data
       - /var/run/docker.sock:/var/run/docker.sock:ro # Hinzufügen
   # ... (Rest der Einstellungen) ...

   Achtung: Das Einbinden des Docker Sockets gibt dem Container potenziell weitreichende Kontrolle über Docker. Nutze dies mit Bedacht und verstehe die Sicherheitsimplikationen. :ro (read-only) ist hier ein wichtiger erster Schritt.

2. Container neu starten:

   sudo docker compose up -d

3. Docker Host in Uptime Kuma hinzufügen:

   • Gehe in Uptime Kuma zu Einstellungen -> Docker Host.
   • Klicke ”+ Docker Host hinzufügen”.
   • Anzeigename: z.B. “Lokaler Docker Host”.
   • Verbindungstyp: Wähle “Socket (/var/run/docker.sock)“.
   • Der Pfad /var/run/docker.sock sollte bereits korrekt sein.
   • Klicke “Speichern”.

4. Docker Container Monitor erstellen:

   • Gehe zum Dashboard und klicke ”+ Monitor hinzufügen”.
   • Monitortyp: “Docker Container”.
   • Docker Host: Wähle den zuvor erstellten “Lokaler Docker Host”.
   • Containername: Gib den exakten Namen des Containers ein, den du überwachen möchtest (z.B. caddy oder uptime-kuma-db).
   • Klicke “Speichern”.

   Uptime Kuma zeigt nun den Status (Up/Down) des angegebenen Containers an.

Backups nicht vergessen!

Ein Monitoring-Tool ist nur so gut wie seine Verfügbarkeit und die Sicherheit seiner Daten. Denke daran, regelmäßige Backups deiner persistenten Daten zu erstellen:

• Der Ordner ./data (enthält die Konfiguration und SQLite-DB, falls verwendet).
• Der Ordner ./mariadb-data (falls du eine externe MariaDB wie oben beschrieben nutzt).

Tools wie Duplicati (das du ebenfalls als Docker Container betreiben kannst) können dir dabei helfen, diese Ordner regelmäßig zu sichern, z.B. auf ein externes Laufwerk oder in die Cloud.

Fazit

Uptime Kuma ist mit Docker und Docker Compose wirklich schnell aufgesetzt und bietet eine tolle, moderne Möglichkeit, eure Dienste im Auge zu behalten. Die Flexibilität durch Docker Compose erlaubt es zudem, das Setup an die eigenen Bedürfnisse anzupassen, sei es durch eine externe Datenbank oder die Integration mit einem Reverse Proxy.

Ich hoffe, dieses Tutorial hat euch geholfen!