VPS-Überwachung mit Uptime Kuma und Grafana

Man kann nicht reparieren, was man nicht sehen kann. Dieser Leitfaden beschreibt die Einrichtung einer umfassenden Überwachung für deinen VPS – von einfachen Verfügbarkeitsprüfungen bis hin zu vollständigen Metrik-Dashboards.

Warum das wichtig ist

Ohne Monitoring erfährst du von Problemen erst, wenn Nutzer sich beschweren – oder wenn bereits alles ausgefallen ist. Gutes Monitoring bedeutet:

• Probleme erkennen, bevor Nutzer es merken – CPU-Auslastungsalarme vor einem Absturz
• Leistungstrends verstehen – Wissen, wann ein Upgrade fällig ist
• Schneller debuggen – Verlaufsdaten zeigen, was sich geändert hat
• Besser schlafen – Automatische Benachrichtigungen ersparen ständiges Nachschauen
• Verfügbarkeit nachweisen – Kunden zeigen, dass ihr SLA eingehalten wird

Voraussetzungen

• Ein VPS mit installiertem Docker (wir empfehlen Hostinger VPS für zuverlässige Leistungsmetriken)
• Grundkenntnisse in Docker Compose
• Ein Domainname (optional, aber empfohlen)

Schnellstart: Stack auswählen

Tool	Am besten für	Komplexität
Uptime Kuma	Verfügbarkeitsüberwachung, Statusseiten	Einfach
Grafana + Prometheus	Vollständige Metriken, Dashboards	Mittel
Netdata	Echtzeit-Systemüberwachung	Einfach
Vollständiger Stack	Produktionsumgebungen	Fortgeschritten

Teil 1: Uptime Kuma (Einfach & Effektiv)

Uptime Kuma ist ein selbst gehostetes Monitoring-Tool, das schön und einfach zu bedienen ist.

Schritt 1: Uptime Kuma deployen

# docker-compose.yml
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

volumes:
  uptime-kuma-data:

docker compose up -d

Zugang unter http://your-server:3001

Schritt 2: Monitore konfigurieren

Nach der Einrichtung Monitore hinzufügen für:

HTTP(S)-Überwachung:

• Website-URLs
• API-Endpunkte
• Admin-Panels

TCP-Port-Überwachung:

• Datenbankports (intern)
• Redis, Cache-Dienste

Docker-Container-Überwachung:

• Container-Gesundheit direkt überwachen

DNS-Überwachung:

• Sicherstellen, dass DNS korrekt aufgelöst wird

Schritt 3: Benachrichtigungen einrichten

Uptime Kuma unterstützt über 90 Benachrichtigungsdienste:

• Telegram – Sofortige mobile Benachrichtigungen
• Discord/Slack – Team-Kanäle
• E-Mail – Traditionell, aber zuverlässig
• Pushover – Premium-Push-Benachrichtigungen
• Webhook – Benutzerdefinierte Integrationen

Konfiguration unter: Einstellungen → Benachrichtigungen

Schritt 4: Statusseite erstellen

1. Zu Statusseiten gehen
2. Neue Seite erstellen
3. Monitore hinzufügen
4. Öffentliche URL mit Nutzern teilen

Teil 2: Vollständiger Metrik-Stack (Prometheus + Grafana)

Für umfassende Metrikerfassung und Visualisierung.

Schritt 1: Stack erstellen

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    ports:
      - "8080:8080"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Schritt 2: Prometheus konfigurieren

# prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: []

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

  # Add your applications
  - job_name: 'myapp'
    static_configs:
      - targets: ['myapp:3000']
    metrics_path: '/metrics'

Schritt 3: Stack starten

mkdir -p prometheus
# Create prometheus.yml as above
docker compose -f docker-compose.monitoring.yml up -d

Schritt 4: Grafana-Dashboards einrichten

1. Grafana unter http://your-server:3000 aufrufen

2. Mit admin / your-password anmelden

3. Prometheus-Datenquelle hinzufügen:

   • Konfiguration → Datenquellen → Hinzufügen
   • Prometheus auswählen
   • URL: http://prometheus:9090
   • Speichern & Testen

4. Vorgefertigte Dashboards importieren:

   • Dashboards → Importieren
   • Beliebte Dashboard-IDs:
     • 1860 – Node Exporter Full
     • 893 – Docker and System Monitoring
     • 14282 – cAdvisor Dashboard

Schritt 5: Benutzerdefinierte Alarme erstellen

In Grafana:

1. Alarmierung → Alarmregeln → Neu
2. Bedingungen auf Basis von Metriken erstellen
3. Benachrichtigungskanäle festlegen

Beispiel-Alarm: CPU > 80 % für 5 Minuten

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80

Teil 3: Netdata (Echtzeit-Überwachung)

Für sofortiges Monitoring ohne Konfiguration:

services:
  netdata:
    image: netdata/netdata
    container_name: netdata
    ports:
      - "19999:19999"
    cap_add:
      - SYS_PTRACE
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
    restart: unless-stopped

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

Zugang unter http://your-server:19999 – sofort schöne Dashboards!

Teil 4: Anwendungsebenen-Monitoring

Metriken zu deinen Apps hinzufügen

Node.js mit prom-client:

const client = require('prom-client');
const express = require('express');

// Collect default metrics
client.collectDefaultMetrics();

// Custom metrics
const httpRequestsTotal = new client.Counter({
  name: 'http_requests_total',
  help: 'Total HTTP requests',
  labelNames: ['method', 'path', 'status']
});

app.use((req, res, next) => {
  res.on('finish', () => {
    httpRequestsTotal.inc({
      method: req.method,
      path: req.route?.path || req.path,
      status: res.statusCode
    });
  });
  next();
});

// Expose metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

Python mit prometheus-client:

from prometheus_client import Counter, Histogram, generate_latest
from flask import Flask, Response

app = Flask(__name__)

REQUEST_COUNT = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

Teil 5: Log-Monitoring mit Loki

Zentralisiertes Logging hinzufügen:

services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - loki_data:/loki
    restart: unless-stopped

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml
    restart: unless-stopped

volumes:
  loki_data:

Promtail-Konfiguration:

# promtail-config.yml
server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*log

  - job_name: docker
    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*log

Loki als Grafana-Datenquelle hinzufügen und Logs neben Metriken abfragen!

Empfohlenes Monitoring-Setup

Für die meisten VPS-Deployments:

# docker-compose.monitoring.yml - Complete recommended stack
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    ports:
      - "3000:3000"
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    restart: unless-stopped

volumes:
  uptime-kuma-data:
  grafana_data:
  prometheus_data:

Best Practices

1. Von außen überwachen – Externe Prüfungen erkennen Netzwerkprobleme
2. Sinnvolle Schwellenwerte setzen – Alarm-Übermüdung vermeiden
3. Monitoring schichten – Verfügbarkeit + Metriken + Logs
4. Daten angemessen aufbewahren – 15–30 Tage für Metriken, länger für Aggregate
5. Runbooks dokumentieren – Was tun, wenn Alarm X ausgelöst wird?
6. Alarme testen – Sicherstellen, dass sie tatsächlich ankommen
7. Die Monitore überwachen – Externen Dienst nutzen, um das eigene Monitoring zu beobachten
8. Dashboards absichern – Metriken können sensible Informationen offenbaren (siehe unseren VPS-Sicherheitsleitfaden)

Häufige Fehler vermeiden

❌ Zu viele Alarme – Alarm-Übermüdung führt dazu, echte Probleme zu ignorieren

❌ Kein externes Monitoring – Wenn der Server ausfällt, fällt auch das Monitoring aus

❌ Metriken öffentlich zugänglich machen – Authentifizierung oder interne Netzwerke verwenden

❌ Keine Aufbewahrungsfristen festlegen – Die Festplatte füllt sich mit alten Daten

❌ Monitoring ohne Handeln – Dashboards lösen keine Probleme

❌ Einzelner Benachrichtigungskanal – E-Mail ausgefallen? Keine Alarme

❌ Kein Ausgangswert – Man muss wissen, wie „normal” aussieht

❌ Übermäßiges Monitoring – Einfach anfangen, Komplexität bei Bedarf erhöhen

Wichtige Metriken im Blick behalten

Systemmetriken

• CPU-Auslastung – Alarm bei dauerhaft über 80 %
• Arbeitsspeichernutzung – Alarm bei über 85 %
• Festplattennutzung – Alarm bei über 80 % (Festplatten füllen sich schnell)
• Festplatten-I/O – Hohe Wartezeiten weisen auf einen Speicherengpass hin
• Netzwerkdurchsatz – Ausgangswert und Anomalieerkennung

Anwendungsmetriken

• Antwortzeit – p50-, p95-, p99-Latenzen
• Fehlerrate – Prozentualer Anteil der 5xx-Antworten
• Anfragerate – Verkehrsmuster
• Aktive Verbindungen – Datenbankpool-Auslastung
• Warteschlangentiefe – Rückstände bei Hintergrundjobs

Geschäftsmetriken

• Anmeldungen/Käufe – Rückgang weist auf Probleme hin
• Aktive Nutzer – Gesundheit des Engagements
• Umsatz – Die ultimative Metrik

FAQ

Wie viele Ressourcen verbraucht das Monitoring?

Minimal. Uptime Kuma: ~100 MB RAM. Vollständiger Prometheus/Grafana-Stack: ~500 MB–1 GB. Angesichts der gewonnenen Transparenz lohnt sich das.

Sollte ich Cloud-Monitoring oder selbst gehostetes verwenden?

Selbst gehostet für Kostenkontrolle und Datenhoheit. Cloud (Datadog, New Relic), wenn das Budget vorhanden ist und eine verwaltete Lösung gewünscht wird. Hostinger VPS bietet genug Ressourcen für selbst gehostetes Monitoring.

Wie überwache ich von außerhalb meines Netzwerks?

Externe Dienste verwenden wie:

• Uptime Robot (kostenloser Tarif)
• Pingdom
• Better Uptime
• StatusCake

Diese erkennen Probleme, die das selbst gehostete Monitoring nicht sehen kann.

Welche Alarm-Schwellenwerte sollte ich setzen?

Konservativ beginnen und auf Basis von Erfahrungen anpassen:

• CPU: 80 % für 5 Minuten
• Arbeitsspeicher: 85 %
• Festplatte: 80 %
• Antwortzeit: 2× der eigene p95-Ausgangswert

Wie lange sollte ich Metriken aufbewahren?

• Hochauflösend (15 s): 7–15 Tage
• Aggregiert (5 min): 30–90 Tage
• Weiter aggregiert: 1–2 Jahre

Detailtiefe und Speicherkosten abwägen.

Kann ich mehrere Server überwachen?

Ja! Prometheus + Node Exporter skalieren gut. Einfach neue Ziele zur Scrape-Konfiguration hinzufügen und über 100 Server von einem einzigen Dashboard aus überwachen.

---

Dein Monitoring-Stack ist bereit! Kombiniere ihn mit unserem Backup-Leitfaden und Sicherheitsleitfaden für einen produktionsreifen VPS.