Prometheus & Grafana: Server-Monitoring einrichten

Wer Linux-Server betreibt, kommt um ein solides Monitoring nicht herum. Ausfälle erkennen, bevor sie zum Problem werden, Ressourcenengpässe frühzeitig identifizieren und historische Daten auswerten – genau dafür ist die Kombination aus Prometheus und Grafana der De-facto-Standard in der modernen Infrastrukturüberwachung. In dieser Anleitung richten wir beide Tools Schritt für Schritt auf einem Linux-Server ein, konfigurieren einen Exporter, bauen ein Dashboard und definieren Alerting-Regeln.

Warum Prometheus und Grafana?

Prometheus ist eine Open-Source-Zeitreihendatenbank, die Metriken über ein Pull-Modell sammelt. Sie fragt Endpoints in regelmäßigen Intervallen ab und speichert die Ergebnisse effizient. Grafana ergänzt dieses Setup als Visualisierungsplattform: Es verbindet sich mit Prometheus als Datenquelle und stellt die gesammelten Metriken in interaktiven Dashboards dar.

Die Vorteile dieses Stacks im Überblick:

• Kostenlos und Open Source – keine Lizenzgebühren
• Skalierbar – von einem einzelnen Server bis zu tausenden Nodes
• Flexibles Alerting – Benachrichtigungen per E-Mail, Slack oder PagerDuty
• Riesige Community – hunderte vorgefertigte Dashboards und Exporter

Voraussetzungen

Für diese Anleitung benötigst du einen Linux-Server (Ubuntu 22.04 oder Debian 12) mit Root-Zugang. Die Beispiele funktionieren analog auch auf RHEL-basierten Distributionen. Folgende Ports sollten in der Firewall freigegeben sein:

Dienst	Port
Prometheus	9090
Grafana	3000
Node Exporter	9100

Prometheus installieren und konfigurieren

Benutzer und Verzeichnisse anlegen

Zunächst erstellen wir einen dedizierten Systembenutzer und die nötigen Verzeichnisse:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Prometheus herunterladen

Lade die aktuelle Version von der offiziellen Release-Seite herunter:

PROM_VERSION="2.53.0"
cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v${PROM_VERSION}/prometheus-${PROM_VERSION}.linux-amd64.tar.gz
tar xvf prometheus-${PROM_VERSION}.linux-amd64.tar.gz
sudo cp prometheus-${PROM_VERSION}.linux-amd64/{prometheus,promtool} /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/{prometheus,promtool}

Konfigurationsdatei erstellen

Die zentrale Konfiguration von Prometheus liegt unter /etc/prometheus/prometheus.yml. Hier definieren wir das Scrape-Intervall und die Targets:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "alert_rules.yml"

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

  - job_name: "node_exporter"
    static_configs:
      - targets: ["localhost:9100"]

sudo cp prometheus.yml /etc/prometheus/
sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Systemd-Service einrichten

Damit Prometheus beim Serverstart automatisch läuft, erstellen wir eine Systemd-Unit:

sudo cat > /etc/systemd/system/prometheus.service << 'EOF'
[Unit]
Description=Prometheus Monitoring
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --storage.tsdb.retention.time=30d \
  --web.enable-lifecycle

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Prüfe den Status mit sudo systemctl status prometheus. Die Web-Oberfläche ist jetzt unter http://<server-ip>:9090 erreichbar.

Node Exporter installieren

Der Node Exporter stellt System-Metriken wie CPU-Auslastung, RAM-Verbrauch, Festplattennutzung und Netzwerktraffic als Prometheus-Endpoint bereit.

NODE_VERSION="1.8.1"
cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v${NODE_VERSION}/node_exporter-${NODE_VERSION}.linux-amd64.tar.gz
tar xvf node_exporter-${NODE_VERSION}.linux-amd64.tar.gz
sudo cp node_exporter-${NODE_VERSION}.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter

sudo cat > /etc/systemd/system/node_exporter.service << 'EOF'
[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter \
  --collector.systemd \
  --collector.processes

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter

Teste den Exporter mit curl http://localhost:9100/metrics. Du solltest hunderte Metriken-Zeilen sehen. In der Prometheus-Oberfläche kannst du unter Status → Targets prüfen, ob der Node Exporter als UP angezeigt wird.

Grafana installieren und einrichten

Installation über das offizielle Repository

sudo apt-get install -y apt-transport-https software-properties-common
sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install -y grafana
sudo systemctl enable --now grafana-server

Grafana ist jetzt unter http://<server-ip>:3000 erreichbar. Die Standard-Zugangsdaten lauten admin / admin – ändere das Passwort sofort beim ersten Login.

Prometheus als Datenquelle hinzufügen

1. Navigiere zu Connections → Data Sources → Add data source
2. Wähle Prometheus aus
3. Trage als URL http://localhost:9090 ein
4. Klicke auf Save & Test

Bei erfolgreicher Verbindung erscheint die Meldung „Successfully queried the Prometheus API".

Dashboard importieren

Statt ein Dashboard von Grund auf zu bauen, importieren wir das bewährte Node Exporter Full Dashboard (ID: 1860):

1. Gehe zu Dashboards → New → Import
2. Gib die ID 1860 ein und klicke auf Load
3. Wähle deine Prometheus-Datenquelle aus
4. Klicke auf Import

Du siehst sofort CPU-Auslastung, RAM-Nutzung, Disk I/O, Netzwerktraffic und viele weitere Metriken in übersichtlichen Panels. Dieses Dashboard ist ein hervorragender Ausgangspunkt für dein Server-Monitoring.

Alerting-Regeln konfigurieren

Ein Monitoring-System ohne Alerts ist nur halb so viel wert. Wir erstellen Regeln, die bei kritischen Zuständen auslösen.

Alert-Regeln in Prometheus

Erstelle die Datei /etc/prometheus/alert_rules.yml:

groups:
  - name: server_alerts
    rules:
      - alert: HighCpuUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Auslastung auf {{ $labels.instance }}"
          description: "CPU-Auslastung liegt seit 5 Minuten über 85% (aktuell: {{ $value | printf \"%.1f\" }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Wenig Speicherplatz auf {{ $labels.instance }}"
          description: "Freier Speicherplatz auf / liegt unter 15%"

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Hohe RAM-Auslastung auf {{ $labels.instance }}"

sudo chown prometheus:prometheus /etc/prometheus/alert_rules.yml
sudo promtool check rules /etc/prometheus/alert_rules.yml
sudo systemctl reload prometheus

Alerting in Grafana einrichten

Für die tatsächliche Benachrichtigung empfiehlt sich Grafana Alerting mit einem Contact Point. Unter Alerting → Contact Points kannst du E-Mail, Slack oder Webhook konfigurieren. Ein Beispiel für die Grafana-Konfiguration in /etc/grafana/grafana.ini:

[smtp]
enabled = true
host = smtp.example.com:587
user = [email protected]
password = dein-sicheres-passwort
from_address = [email protected]

Nach einem Neustart von Grafana (sudo systemctl restart grafana-server) stehen E-Mail-Benachrichtigungen zur Verfügung.

Absicherung mit Nginx Reverse Proxy

Für den Produktivbetrieb solltest du Grafana hinter einen Reverse Proxy mit TLS stellen:

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

    ssl_certificate     /etc/letsencrypt/live/monitoring.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/monitoring.example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:3000;
        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;
    }
}

Prometheus selbst sollte nicht öffentlich erreichbar sein. Beschränke den Zugriff auf localhost oder nutze Firewall-Regeln:

sudo ufw allow from 127.0.0.1 to any port 9090
sudo ufw deny 9090

Fazit

Mit Prometheus und Grafana hast du in unter einer Stunde ein professionelles Server-Monitoring aufgesetzt, das sich mit Enterprise-Lösungen messen kann. Der Node Exporter liefert detaillierte System-Metriken, Prometheus speichert sie zuverlässig und Grafana macht sie in aussagekräftigen Dashboards sichtbar. Die konfigurierten Alerting-Regeln sorgen dafür, dass du bei kritischen Zuständen sofort informiert wirst.

Als nächste Schritte bieten sich an: weitere Exporter hinzufügen (etwa mysqld_exporter oder blackbox_exporter für HTTP-Checks), die Retention-Policy an deine Speicherkapazität anpassen und zusätzliche Dashboards für spezifische Anwendungsfälle erstellen. Wer mehrere Server überwacht, sollte außerdem einen Blick auf Service Discovery werfen, um Targets automatisch zu erkennen statt sie statisch zu pflegen.