Monitoring-Stack komplett aufbauen

Ein Server kann äusserlich ruhig wirken und intern trotzdem längst Probleme haben. Genau deshalb ist ein sauberer Monitoring-Stack so wertvoll: Du siehst nicht nur, ob ein Dienst erreichbar ist, sondern auch, wie sich CPU, RAM, Speicher, Container und Alarmierungen tatsächlich verhalten.

In dieser Anleitung bauen wir einen praxisnahen Monitoring-Stack auf Ubuntu auf, bestehend aus Prometheus, Node Exporter, Grafana und einer einfachen Alarmierung über Alertmanager. Ziel ist eine verständliche Grundlage, die du später für weitere Dienste und Server ausbauen kannst.

1. Was die einzelnen Komponenten machen

Bevor wir installieren, lohnt sich ein kurzer Überblick:

• Node Exporter liefert Metriken vom Server, zum Beispiel CPU, RAM, Dateisysteme und Netzwerk
• Prometheus sammelt diese Metriken regelmässig ein
• Grafana visualisiert die Daten in Dashboards
• Alertmanager verschickt Warnungen oder verarbeitet Alarme

Zusammen ergibt das eine solide Basis, mit der du einen Server nicht nur beobachten, sondern auch aktiv überwachen kannst.

2. Welche Architektur wir hier verwenden

Für diese Anleitung setzen wir die Komponenten mit Docker Compose auf einem Ubuntu-Server auf. Das ist für viele Self-Hosted-Umgebungen ein guter Mittelweg zwischen Übersicht und Flexibilität.

Unsere Komponenten:

• Prometheus als Zentrale für das Einsammeln von Metriken
• Node Exporter direkt auf dem Host oder als Container
• Grafana für Dashboards
• Alertmanager für Alarmierungen

Wenn du später weitere Server überwachen willst, installierst du dort zusätzlich Node Exporter und ergänzt die Ziele in Prometheus.

3. Arbeitsverzeichnis anlegen

Lege zuerst ein eigenes Stack-Verzeichnis an:

mkdir -p ~/monitoring-stack/prometheus
mkdir -p ~/monitoring-stack/grafana
mkdir -p ~/monitoring-stack/alertmanager
cd ~/monitoring-stack

Damit bleiben Konfiguration und Daten übersichtlich getrennt.

4. Prometheus-Konfiguration erstellen

Erstelle eine Datei ~/monitoring-stack/prometheus/prometheus.yml mit folgendem Grundgerüst:

global:
  scrape_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - alertmanager:9093

rule_files:
  - /etc/prometheus/alerts.yml

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

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

Diese Datei sagt Prometheus vereinfacht: überwache dich selbst, überwache Node Exporter und leite Alarme an Alertmanager weiter.

5. Erste Alarmregeln definieren

Erstelle zusätzlich ~/monitoring-stack/prometheus/alerts.yml:

groups:
  - name: basic-alerts
    rules:
      - alert: HostHighCpuLoad
        expr: avg by(instance) (rate(node_cpu_seconds_total{mode!="idle"}[5m])) > 0.85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Last auf {{ $labels.instance }}"
          description: "Die durchschnittliche CPU-Auslastung liegt seit 10 Minuten über 85 Prozent."

      - alert: HostLowDiskSpace
        expr: (node_filesystem_avail_bytes{fstype!="tmpfs"} / node_filesystem_size_bytes{fstype!="tmpfs"}) < 0.15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Wenig freier Speicher auf {{ $labels.instance }}"
          description: "Weniger als 15 Prozent freier Speicherplatz verfügbar."

Das ist bewusst schlank gehalten. Später kannst du weitere Regeln für RAM, Uptime, Zertifikate oder Container ergänzen.

6. Alertmanager konfigurieren

Lege die Datei ~/monitoring-stack/alertmanager/alertmanager.yml an:

route:
  receiver: default-mail

receivers:
  - name: default-mail
    email_configs:
      - to: alerts@example.com
        from: alerts@example.com
        smarthost: smtp.example.com:587
        auth_username: alerts@example.com
        auth_password: dein-smtp-passwort
        require_tls: true

Wenn du Mail noch nicht eingerichtet hast, kannst du Alertmanager zuerst auch ohne produktiven Empfänger starten und später die Zustellung ergänzen.

Wichtig: In echten produktiven Setups würde ich Passwörter nicht direkt in diese Datei schreiben, sondern sauber über Variablen oder ein Secret-Konzept lösen.

7. Compose-Datei für den Stack anlegen

Erstelle nun ~/monitoring-stack/compose.yaml:

services:
  prometheus:
    image: prom/prometheus:latest
    restart: unless-stopped
    command:
      - --config.file=/etc/prometheus/prometheus.yml
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/alerts.yml:/etc/prometheus/alerts.yml:ro
      - ./prometheus/data:/prometheus
    ports:
      - "9090:9090"

  node-exporter:
    image: prom/node-exporter:latest
    restart: unless-stopped
    command:
      - --path.rootfs=/host
    pid: host
    volumes:
      - /:/host:ro,rslave
    ports:
      - "9100:9100"

  grafana:
    image: grafana/grafana:latest
    restart: unless-stopped
    volumes:
      - ./grafana:/var/lib/grafana
    ports:
      - "3000:3000"

  alertmanager:
    image: prom/alertmanager:latest
    restart: unless-stopped
    command:
      - --config.file=/etc/alertmanager/alertmanager.yml
    volumes:
      - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
    ports:
      - "9093:9093"

Für den ersten Einstieg ist das bewusst direkt gehalten. In produktiven Umgebungen würde ich die Oberflächen später eher hinter einem Reverse Proxy veröffentlichen statt mehrere Ports offen zu lassen.

8. Stack starten

Starte nun alles im Hintergrund:

docker compose up -d

Prüfe danach den Status:

docker compose ps

Wenn etwas nicht sauber startet, sind die Logs der schnellste Weg:

docker compose logs --tail=100 prometheus
docker compose logs --tail=100 grafana
docker compose logs --tail=100 alertmanager

9. Ersten Zugriff prüfen

Du solltest nun erreichen:

• http://SERVER-IP:9090 für Prometheus
• http://SERVER-IP:3000 für Grafana
• http://SERVER-IP:9093 für Alertmanager
• http://SERVER-IP:9100/metrics für Node Exporter

Wenn du bei Node Exporter eine lange Metrikliste siehst, liefert der Exporter korrekt Daten. Das ist ein sehr guter erster Check.

10. Grafana mit Prometheus verbinden

Melde dich in Grafana an und füge Prometheus als Datenquelle hinzu. Für dieses Compose-Setup verwendest du im Normalfall als URL:

http://prometheus:9090

Wenn Grafana und Prometheus im selben Compose-Netzwerk laufen, funktioniert genau diese interne Adresse sauber. Danach kannst du erste Dashboards importieren oder eigene Ansichten bauen.

Typische sinnvolle Panels sind:

• CPU-Auslastung
• RAM-Verbrauch
• freier Speicherplatz
• Netzwerkverkehr
• Load Average
• Uptime

11. Alarmierung bewusst und sparsam beginnen

Zu Beginn ist weniger meist mehr. Wenn du zu viele Alarme auf einmal aktivierst, gewöhnst du dich schnell daran, sie zu ignorieren.

Ein guter Start sind wenige, klare Warnungen:

• CPU dauerhaft zu hoch
• RAM langfristig knapp
• Speicherplatz kritisch
• Node Exporter oder Prometheus nicht erreichbar

Später kannst du je nach Umgebung Zertifikate, Container-Status, Backups oder einzelne Anwendungen mit überwachen.

12. Sicherheit und Veröffentlichung

Monitoring-Oberflächen enthalten oft viele interne Details. Ich würde Prometheus, Grafana und Alertmanager deshalb nicht unnötig direkt offen ins Internet stellen.

Sinnvolle Wege sind:

• nur intern im LAN verfügbar
• über VPN erreichbar
• hinter Reverse Proxy mit zusätzlicher Absicherung
• optional hinter Authentik oder Authelia

Gerade Grafana wird häufig unterschätzt, weil Dashboards harmlos wirken. In Wahrheit verraten sie oft sehr viel über dein System.

13. Wie du den Stack später ausbauen kannst

Wenn die Basis läuft, bieten sich viele sinnvolle Erweiterungen an:

• weitere Server mit Node Exporter anbinden
• cAdvisor oder andere Container-Metriken ergänzen
• Blackbox Exporter für HTTP- und Zertifikatsprüfungen hinzufügen
• Uptime Kuma zusätzlich für Verfügbarkeitschecks verwenden
• Mail, Discord oder andere Alarmkanäle sauber integrieren

Du musst also nicht alles am ersten Tag perfekt bauen. Wichtig ist eine solide, verständliche Basis.

14. Fazit

Mit Prometheus, Node Exporter, Grafana und Alertmanager bekommst du auf Ubuntu einen sehr leistungsfähigen Monitoring-Stack, der sowohl für kleine Self-Hosted-Server als auch für wachsende Umgebungen eine starke Grundlage bildet.

Entscheidend ist, klein und sauber zu starten: wenige gute Metriken, ein verständliches Dashboard und nur die Alarme, die dir im Alltag wirklich helfen.

Tipp:
Baue zuerst den Überblick für CPU, RAM, Speicher und Alarmierung auf. Erst wenn das stabil läuft, erweiterst du Schritt für Schritt Richtung Container, Dienste und Spezialmetriken.