Uptime Kuma Installation – Self-Hosted Monitoring und Statusseite

Was ist Uptime Kuma?

Uptime Kuma ist ein modernes, selbst gehostetes Monitoring-Tool mit einer schönen Web-Oberfläche. Es ermöglicht die Überwachung von Webseiten, Diensten und APIs mit Benachrichtigungen bei Ausfällen. Im Gegensatz zu Cloud-Lösungen behalten Sie vollständige Kontrolle über Ihre Monitoring-Daten.

Hauptfeatures

• HTTP/HTTPS Monitoring
• TCP Port Monitoring
• DNS Monitoring
• Ping/ICMP Monitoring
• Keyword Überwachung (Prüft ob bestimmte Wörter in Response vorhanden sind)
• Öffentliche Status-Seiten
• Benachrichtigungen (E-Mail, Slack, Discord, Telegram, Webhook, etc.)
• Wartungsfenster (Geplante Downtime ausschließen)
• Responsive Mobile-UI
• Statistiken und Uptime-Reports

Vergleich: Uptime Kuma vs Zabbix vs Grafana/Prometheus

Feature	Uptime Kuma	Zabbix	Grafana/Prometheus
Installation complexity	Sehr einfach (2-5 Min mit Docker)	Mittel (30+ Min)	Komplex (1+ Std)
Resource usage	Minimal (~50 MB RAM)	Moderat (500 MB+ RAM)	Höher (2GB+ RAM)
Status pages	Built-in, öffentlich teilbar	Zusatz-Plugin nötig	Zusatz-Tool nötig
Notification channels	20+ (Email, Slack, Discord, Telegram, etc.)	30+ (sehr vielfältig)	15+ über AlertManager
Agent needed	Nein (HTTP/TCP basiert)	Ja (Agent auf Zielhost)	Ja (Prometheus exporters)
Best for	Kleine bis mittlere Setups, einfaches Uptime-Monitoring	Enterprise, komplexe Infrastruktur	Große Umgebungen, Custom Dashboards

Voraussetzungen

• Ubuntu 20.04 oder neuer
• Docker und Docker Compose
• Eine Domain für Zugriff (z.B. uptime.example.com)
• Nginx als Reverse Proxy
• Mindestens 512MB RAM, 5GB Speicher

Installation mit Docker Compose

Schritt 1: Verzeichnis erstellen

mkdir -p /opt/uptime-kuma
cd /opt/uptime-kuma
mkdir -p data

Schritt 2: docker-compose.yml erstellen

cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    container_name: uptime-kuma
    restart: always
    ports:
      - "3001:3001"
    environment:
      NODE_ENV: production
      PUID: 1000
      PGID: 1000
    volumes:
      - ./data:/app/data
    networks:
      - uptime-kuma-net

networks:
  uptime-kuma-net:
    driver: bridge
EOF

Schritt 3: Nginx Reverse Proxy konfigurieren

cat > /etc/nginx/sites-available/uptime-kuma << 'EOF'
upstream uptime_kuma {
    server 127.0.0.1:3001;
}

server {
    listen 80;
    server_name uptime.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name uptime.example.com;

    ssl_certificate /etc/letsencrypt/live/uptime.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/uptime.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    client_max_body_size 10M;

    location / {
        proxy_pass http://uptime_kuma;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

Nginx aktivieren und SSL-Zertifikat

sudo ln -s /etc/nginx/sites-available/uptime-kuma /etc/nginx/sites-enabled/
sudo apt-get install certbot python3-certbot-nginx
sudo certbot certonly --nginx -d uptime.example.com
sudo nginx -t
sudo systemctl restart nginx

Uptime Kuma starten

cd /opt/uptime-kuma
docker-compose up -d

Überprüfen Sie die Logs:

docker-compose logs -f uptime-kuma

Initiale Konfiguration

Schritt 1: Uptime Kuma aufrufen

Öffnen Sie: https://uptime.example.com

Schritt 2: Admin-Konto erstellen

Auf der Willkommen-Seite erstellen Sie Ihr Admin-Passwort:

• Geben Sie ein starkes Passwort ein
• Bestätigen Sie das Passwort
• Klicken Sie "Save"

Dashboard-Überblick

Nach dem Login sehen Sie das leere Dashboard. Von hier aus können Sie:

• Neue Monitore hinzufügen
• Status-Seiten verwalten
• Benachrichtigungen konfigurieren
• Wartungsfenster erstellen

Monitor hinzufügen

HTTP Monitor (Website)

1. Klicken Sie "Add New Monitor"
2. Monitor Name: z.B. "Meine Website"
3. Monitor Type: HTTP(s)
4. URL: https://example.com
5. Interval: 60 (Sekunden zwischen Checks)
6. Timeout: 30 (Sekunden bis Timeout)
7. Save klicken

Keyword Monitor

1. Monitor Type: HTTP(s)
2. URL: https://example.com
3. Keyword: Geben Sie einen Text ein, der in der Response vorhanden sein muss (z.B. "Success")
4. Das System prüft dann, ob dieses Wort auf der Seite vorhanden ist

TCP Port Monitor

1. Monitor Type: TCP Port
2. Hostname: your-server.com
3. Port: 443 (oder 22 für SSH, 3306 für MySQL, etc.)
4. Interval: 60
5. Save klicken

DNS Monitor

1. Monitor Type: DNS
2. Hostname: example.com
3. DNS Server: 8.8.8.8 (Google DNS) oder leer für Systemstandard
4. Query Type: A (oder MX, CNAME, etc.)
5. Expected Value: Die erwartete IP-Adresse oder Wert

Ping Monitor (ICMP)

1. Monitor Type: Ping
2. Hostname: example.com
3. Interval: 60
4. Save klicken

Benachrichtigungen konfigurieren

Benachrichtigungskanal hinzufügen

1. Settings → Notifications
2. Klicken Sie auf den Benachrichtigungstyp, den Sie konfigurieren möchten

E-Mail-Benachrichtigungen

1. Notification Type: Email
2. SMTP Host: mail.example.com
3. SMTP Port: 587
4. Sender Email: uptime@example.com
5. SMTP Username: your-smtp-user
6. SMTP Password: your-smtp-password
7. Test senden klicken

Discord-Webhook

1. Notification Type: Discord
2. Webhook URL: (Aus Discord Server Einstellungen)
   1. Server → Einstellungen → Webhooks → Neuer Webhook
   2. Name: Uptime Kuma
   3. Channel: #alerts oder ähnlich
   4. Webhook URL kopieren
3. URL in Uptime Kuma einfügen
4. Test klicken

Telegram-Benachrichtigungen

1. Notification Type: Telegram
2. Bot Token: (Von BotFather auf Telegram erstellen)
   1. Schreiben Sie @BotFather auf Telegram
   2. /newbot
   3. Folgen Sie den Anweisungen um einen Bot zu erstellen
   4. Token kopieren
3. Chat ID: (Schreiben Sie dem Bot eine Nachricht, dann: https://api.telegram.org/botTOKEN/getUpdates)

Slack

1. Notification Type: Slack
2. Webhook URL: (Von Slack Workspace Einstellungen)

Monitor mit Benachrichtigungen verbinden

Benachrichtigungen zu Monitor hinzufügen

1. Monitor auswählen und bearbeiten
2. Scroll nach unten zu "Notifications"
3. Wählen Sie die Benachrichtigungskanäle aus, die Sie verwenden möchten
4. Save klicken

Öffentliche Status-Seite erstellen

Status Group erstellen

1. Status Page → Neuen erstellen
2. Title: "Service Status"
3. Slug: status
4. Description: "Real-time uptime status of our services"
5. Create klicken

Monitore zur Status Page hinzufügen

1. Status Page bearbeiten
2. Monitor Group hinzufügen
3. Monitore zur Gruppe hinzufügen
4. Save klicken

Status Page verteilen

Die öffentliche Status-Seite ist unter folgendem Link erreichbar:

https://uptime.example.com/status/status

Sie können diesen Link mit Kunden/Benutzern teilen.

Wartungsfenster (Planned Downtime)

Wartung einplanen

1. Settings → Maintenance
2. "New Maintenance" klicken
3. Title: z.B. "Server Migration"
4. Description: "Scheduled server upgrade"
5. Start Time und End Time setzen
6. Monitore auswählen, die betroffen sind
7. Create klicken

Während dieser Zeit wird der Downtime nicht als Fehler in den Statistiken gezählt.

Backup und Datenverwaltung

Automatisches Backup

Uptime Kuma speichert alle Daten in der data/ Ordner. Regelmäßiges Backup ist wichtig:

#!/bin/bash
BACKUP_DIR="/backups/uptime-kuma"
mkdir -p $BACKUP_DIR
DATE=$(date +%Y%m%d_%H%M%S)

tar -czf $BACKUP_DIR/uptime-kuma_$DATE.tar.gz /opt/uptime-kuma/data/

echo "Backup erstellt: $BACKUP_DIR/uptime-kuma_$DATE.tar.gz"

Mit Cron automatisieren

0 3 * * * /opt/uptime-kuma/backup.sh

Daten importieren/exportieren

1. Settings → Backup & Restore
2. "Export" um alle Monitore und Einstellungen zu exportieren
3. "Import" um von einer anderen Installation zu importieren

Erweiterte Konfiguration

Update durchführen

cd /opt/uptime-kuma
docker-compose pull
docker-compose down
docker-compose up -d

Custom Headers hinzufügen (für spezielle Endpoints)

Bei HTTP Monitor unter "Custom Headers" können Sie zusätzliche Header definieren:

Authorization: Bearer YOUR_TOKEN
X-Custom-Header: value

Basic Auth testen

1. HTTP Monitor auswählen
2. Username und Password felder ausfüllen
3. Das System schickt Basic Auth mit der Anfrage

Tipps und Best Practices

• Setzen Sie kürzere Intervals (30-60 Sekunden) für kritische Services
• Verwenden Sie verschiedene Benachrichtigungskanäle für verschiedene Schweregrade
• Erstellen Sie Status Pages für externe Stakeholder
• Überprüfen Sie regelmäßig die Uptimes um Muster zu erkennen
• Nutzen Sie Keyword-Monitoring für API-Endpunkte
• Kombinieren Sie mehrere Monitor-Typen für robuste Überwachung
• Planen Sie Wartungsfenster voraus um falsche Alarme zu vermeiden

Häufig gestellte Fragen

Wie oft kann ich monitoren?

Minimum Interval ist 20 Sekunden. Für die meisten Zwecke sind 60 Sekunden ausreichend.

Kann ich mehrere Uptime Kuma Instanzen haben?

Ja, Sie können mehrere unabhängige Instanzen betreiben. Allerdings teilen diese keine Daten.

Wo speichert Uptime Kuma die Daten?

Alle Daten werden in SQLite lokal in der data/ Ordner gespeichert.

Verwandte Artikel

• 📖 Docker Compose Grundlagen Anleitung
• 📖 Nginx Reverse Proxy Konfiguration
• 📖 Server Monitoring kostenlos & Statusseite
• 🔧 Enjyn Server Monitor – Kostenlose Uptime-Überwachung
• 🔧 Sichere Server bei Enjyn mieten

Weitere Ressourcen

• 🔧 Enjyn Server Monitor – Kostenlose Uptime-Überwachung
• 🔧 Sichere Server bei Enjyn mieten