Self-Hosted Monitoring: einen Stack aus Open-Source-Tools zusammenstellen

Server, Dienste und Websites müssen überwacht werden. Aber 15 $ pro Host und Monat an Datadog zu zahlen, tut weh — besonders wenn man fünf VPS und ein Dutzend Self-Hosted-Anwendungen hat. Gute Nachricht: Ein Open-Source-Monitoring-Stack ist in einer Stunde zusammengestellt und deckt 90 % der Anforderungen eines durchschnittlichen Projekts ab.

In dieser Anleitung bauen wir einen Stack: Prometheus (Metriken), Grafana (Dashboards), Loki (Logs), Node Exporter (Systemmetriken), Uptime Kuma (Website-Status). Alles in Docker Compose, alles mit Persistenz, alles mit Benachrichtigungen.

Schritt 1: Docker Compose

Erstellen Sie ein Verzeichnis monitoring und eine Datei docker-compose.yml:

version: "3.8"
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./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

  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"
    ports:
      - "9100:9100"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=changeme
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Schritt 2: Prometheus — Metriken sammeln

Erstellen Sie prometheus.yml:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: "node"
    static_configs:
      - targets: ["node-exporter:9100"]

  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

Node Exporter sammelt CPU, RAM, Festplatte, Netzwerk — alles Systemrelevante. Um mehrere Server zu überwachen, starten Sie Node Exporter auf jedem und tragen Sie deren IPs in targets ein.

Schritt 3: Grafana — Visualisierung

Rufen Sie http://ihr-server:3000 auf (Login: admin, Passwort: changeme). Fügen Sie Prometheus als Data Source hinzu (URL http://prometheus:9090).

Importieren Sie das Dashboard 1860 (Node Exporter Full) — das ist die beliebteste Vorlage für Systemmetriken. Nach dem Import sehen Sie schöne Diagramme.

Schritt 4: Loki — Logs

Fügen Sie Loki und Promtail zur docker-compose.yml hinzu:

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

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

Fügen Sie Loki in Grafana als Data Source hinzu und nutzen Sie Explore für die Log-Suche. Alle Container-Logs und System-Logs an einem Ort, mit Suche und Filterung.

Schritt 5: Uptime Kuma — Website-Status

Für die Überwachung der Verfügbarkeit von Websites und APIs starten Sie Uptime Kuma als separaten Container:

  uptime-kuma:
    image: louislam/uptime-kuma:latest
    volumes:
      - uptime_kuma_data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

Uptime Kuma kann pingen, HTTP-Status prüfen, SSL-Zertifikate, TCP-Ports und DNS-Einträge überwachen. Richten Sie Benachrichtigungen in Telegram, Discord oder per E-Mail ein.

Schritt 6: Benachrichtigungen

Prometheus unterstützt Alertmanager für Benachrichtigungen. Minimale Konfiguration — eine Regel in prometheus.yml:

rule_files:
  - "alert.rules.yml"

Und in alert.rules.yml:

groups:
  - name: node
    rules:
      - alert: HighCPU
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU über 80% auf {{ $labels.instance }}"

Alertmanager kann mit Telegram, E-Mail und Slack verbunden werden.

Was das an Ressourcen kostet

Der gesamte Stack auf einem VPS mit 2 GB RAM:

• Prometheus: ~200 MB RAM + Speicherplatz für Daten (abhängig von der Aufbewahrungsdauer)
• Grafana: ~150 MB RAM
• Loki: ~200 MB RAM
• Node Exporter: ~50 MB RAM
• Promtail: ~100 MB RAM
• Uptime Kuma: ~100 MB RAM

Gesamt: etwa 800 MB RAM für den vollständigen Monitoring-Stack. Die verbleibenden 1,2 GB reichen für Ihre Anwendungen.

Wie geht es weiter

Mit diesem Stack erhalten Sie:

• Echtzeit-Metriken aller Server
• Zentralisierte Logs mit Suche
• Schöne Dashboards in Grafana
• Benachrichtigungen bei Problemen
• Überwachung der Website-Verfügbarkeit

Wenn das Projekt wächst, können Sie ergänzen: cAdvisor (Container-Metriken), Blackbox Exporter (HTTP/DNS/TCP-Prüfungen), Grafana Tempo (Tracing).

Keine 15 $ pro Host. Nur Ihre Daten auf Ihrem Server.

Offizielle Prometheus-Website | Offizielle Grafana-Website | Uptime Kuma auf GitHub