CPU, RAM und Netzwerk selbst gehosteter Server mit Prometheus und Grafana auf Ubuntu Server überwachen

Wer auch nur ein paar selbst gehostete Server betreibt — ein NAS, einen VPS für eigene Projekte, ein kleines Homelab mit zwei oder drei Maschinen — stellt sich früher oder später dieselbe Frage: Wie merke ich, dass einem Node der RAM ausgeht, die CPU stark belastet ist oder der Netzwerkverkehr ungewöhnlich ansteigt, ohne jedes Mal manuell nachsehen zu müssen? Die im Open-Source-Bereich verbreitetste Antwort ist ein Werkzeug-Duo, das sich zu einem De-facto-Standard entwickelt hat: Prometheus zum Sammeln der Metriken und Grafana, um sie in übersichtlichen, anpassbaren Dashboards darzustellen.

In dieser Anleitung richten wir einen schlanken Monitoring-Cluster auf Ubuntu Server ein, mit dem sich CPU, RAM und Netzwerkverkehr mehrerer selbst gehosteter Nodes überwachen lassen — bei minimaler Belastung der überwachten Maschinen. Dafür muss man kein erfahrener Systemadministrator sein: Jeder Schritt wird zusammen mit den grundlegenden Konzepten erklärt.

Warum man seine selbst gehosteten Server überwachen sollte

Wer eigene Dienste betreibt — eine Website, einen Mailserver, ein NAS, eine Nextcloud-Instanz oder einen kleinen Cluster für private Projekte — bemerkt Probleme oft erst, wenn der Dienst bereits nicht mehr erreichbar ist: eine volle Festplatte, durch einen speicherfressenden Prozess aufgebrauchter Arbeitsspeicher, eine mit Traffic überlastete Netzwerkschnittstelle. Ein Monitoring-System ermöglicht es, Folgendes zu tun:

• Warnsignale frühzeitig erkennen: Ein RAM-Verbrauch, der über mehrere Tage stetig ansteigt, bevor es zu einem Absturz kommt, ist beispielsweise auf einem Diagramm sichtbar, lange bevor er zu einem echten Problem wird.
• Ursachen von Verlangsamungen verstehen: Reagiert eine Website langsam, hilft ein historisches Diagramm von CPU- und Netzwerk-I/O-Last zu erkennen, ob die Ursache ein Lastspitze oder etwas anderes ist.
• Upgrades planen: Die Beobachtung der Ressourcennutzung über die Zeit ist der einfachste Weg zu wissen, wann wirklich mehr RAM oder Bandbreite nötig ist, statt nach Gefühl aufzurüsten.
• Benachrichtigungen erhalten: Sobald Metriken gesammelt werden, lassen sich automatische Alarme einrichten (zum Beispiel über Alertmanager, das Begleittool von Prometheus), sobald ein Schwellenwert überschritten wird.

Die Werkzeuge: Prometheus, Node Exporter und Grafana

Bevor etwas installiert wird, lohnt es sich zu verstehen, was jede Komponente tut, denn der Stack besteht aus drei eigenständigen Teilen, die zusammenarbeiten:

• Prometheus ist eine auf das Sammeln von Metriken spezialisierte Zeitreihendatenbank (time-series database). Anders als viele ältere Monitoring-Systeme arbeitet Prometheus nach dem „Pull“-Prinzip: Es fragt in regelmäßigen Abständen selbst bei den überwachten Maschinen die aktuellsten Daten ab, statt darauf zu warten, dass diese Maschinen sie von sich aus senden.
• Node Exporter ist ein kleines Programm, das auf jeder zu überwachenden Maschine installiert werden muss. Seine Aufgabe ist es, Systemmetriken (CPU-Nutzung, RAM, Festplatte, Netzwerkschnittstellen usw.) über eine einfache interne Webseite auf Port 9100 in einem Format bereitzustellen, das Prometheus lesen kann.
• Grafana bildet die visuelle Ebene: Es verbindet sich mit Prometheus als „Datenquelle“ und ermöglicht es, Dashboards mit Diagrammen, farbigen Schwellenwerten, visuellen Alarmen und vielem mehr zu erstellen — ganz ohne Programmieren.

In der Praxis: Node Exporter sammelt die Rohdaten auf jedem Node, Prometheus ruft sie regelmäßig ab und speichert sie, und Grafana liest sie aus Prometheus aus und stellt sie dar.

Voraussetzungen und Architektur des schlanken Clusters

Für diese Anleitung gehen wir von einem einfachen, aber realistischen Aufbau für ein Homelab oder eine kleine Gruppe von VPS-Instanzen aus:

• Ein „zentraler“ Node mit Ubuntu Server (geeignet ist sowohl die Version 24.04 LTS, die in vielen Homelabs noch am weitesten verbreitet ist, als auch die neuere 26.04 LTS), auf dem wir Prometheus und Grafana installieren. 1 vCPU und 1-2 GB RAM reichen aus, um rund zehn Nodes mit grundlegenden Metriken zu überwachen.
• Einen oder mehrere „zu überwachende“ Nodes (eventuell auch der zentrale Node selbst), auf denen jeweils nur Node Exporter installiert wird, ein extrem leichtgewichtiger Prozess (wenige MB RAM).
• SSH-Zugang mit sudo-Rechten auf allen beteiligten Maschinen.

Der große Vorteil dieser Kombination liegt gerade in ihrer Leichtigkeit: Im Gegensatz zu schwereren Lösungen mit komplexen Agenten oder relationalen Datenbanken sind Prometheus und Node Exporter in Go geschrieben, als einzelne Binärdateien ohne zu installierende Abhängigkeiten kompiliert und darauf ausgelegt, selbst auf bescheidener Hardware sehr wenige Ressourcen zu verbrauchen (auch ein Raspberry Pi oder ein günstiger VPS funktioniert hervorragend).

Schritt 1: Prometheus auf dem zentralen Node installieren

Verbinden wir uns per SSH mit dem zentralen Node und legen zunächst einen dedizierten Systembenutzer an, damit Prometheus nicht mit Root-Rechten läuft:

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

Anschließend laden wir die aktuelle stabile Version von Prometheus (zum Zeitpunkt der Erstellung dieses Artikels die 3.x-Reihe) von der offiziellen Download-Seite herunter. Es empfiehlt sich, vor dem Fortfahren immer die neueste verfügbare Version unter prometheus.io/download zu prüfen:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v3.15.1/prometheus-3.15.1.linux-amd64.tar.gz
tar xvf prometheus-3.15.1.linux-amd64.tar.gz
cd prometheus-3.15.1.linux-amd64

sudo cp prometheus promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles /etc/prometheus/console_libraries

Schritt 2: den systemd-Dienst von Prometheus anlegen

Damit Prometheus beim Serverstart automatisch startet und von systemd verwaltet wird (die Komponente von Ubuntu, die für das Starten und Überwachen von Hintergrunddiensten zuständig ist), erstellen wir eine Unit-Datei:

sudo nano /etc/systemd/system/prometheus.service

mit folgendem Inhalt:

[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --web.listen-address=0.0.0.0:9090
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Legen wir außerdem eine minimale prometheus.yml-Datei als Ausgangspunkt an (wir vervollständigen sie in Schritt 4):

sudo nano /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

Dann starten und aktivieren wir den Dienst:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Mit sudo systemctl status prometheus prüfen wir, ob er läuft: Es sollte in Grün active (running) angezeigt werden. Ab diesem Punkt ist die Weboberfläche von Prometheus bereits unter http://IP-DES-ZENTRALEN-NODES:9090 erreichbar.

Schritt 3: Node Exporter auf jedem zu überwachenden Node installieren

Dieser Schritt muss auf jedem Node wiederholt werden, der überwacht werden soll (einschließlich des zentralen Nodes, falls auch dessen Ressourcen überwacht werden sollen). Legen wir einen dedizierten Benutzer an und installieren die Binärdatei:

sudo useradd --no-create-home --shell /bin/false node_exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.12.1/node_exporter-1.12.1.linux-amd64.tar.gz
tar xvf node_exporter-1.12.1.linux-amd64.tar.gz
sudo cp node_exporter-1.12.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Legen wir auch den systemd-Dienst für Node Exporter an:

sudo nano /etc/systemd/system/node_exporter.service

[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
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

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

Node Exporter stellt nun die Rohmetriken auf Port 9100 bereit: Wir können das mit curl http://localhost:9100/metrics prüfen, was Hunderte von Datenzeilen zu CPU, Speicher, Dateisystemen und Netzwerkschnittstellen zurückgeben sollte.

Schritt 4: Prometheus zum Sammeln der Metriken aller Nodes konfigurieren

Zurück auf dem zentralen Node aktualisieren wir /etc/prometheus/prometheus.yml und fügen für jeden zu überwachenden Node einen „Job“ mit dessen IP-Adresse und Port 9100 von Node Exporter hinzu:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: "node_exporter"
    static_configs:
      - targets:
          - "localhost:9100"
          - "192.168.1.11:9100"
          - "192.168.1.12:9100"

Nach jeder Änderung dieser Datei ist es sinnvoll, ihre Syntax mit promtool check config /etc/prometheus/prometheus.yml zu prüfen und die Konfiguration anschließend ohne Neustart des Dienstes neu zu laden:

sudo systemctl reload prometheus

In der Prometheus-Oberfläche (http://IP-DES-ZENTRALEN-NODES:9090/targets) können wir prüfen, ob alle Nodes mit dem Status UP erscheinen: Das ist das Zeichen dafür, dass Prometheus sie erfolgreich abfragt.

Schritt 5: die erforderlichen Firewall-Ports öffnen

Ist auf den Nodes ufw (die Standard-Firewall von Ubuntu) aktiv, müssen die nötigen Ports geöffnet werden. Auf dem zentralen Node, um den Zugriff auf die Oberfläche von Prometheus und später auch von Grafana zu ermöglichen:

sudo ufw allow 9090/tcp
sudo ufw allow 3000/tcp

Auf jedem überwachten Node sollte dagegen Port 9100 von Node Exporter nur zur IP-Adresse des zentralen Nodes hin geöffnet werden, nicht zum gesamten Internet, um Systemmetriken nicht für jeden sichtbar zu machen:

sudo ufw allow from 192.168.1.10 to any port 9100 proto tcp

(wobei 192.168.1.10 durch die tatsächliche IP des zentralen Nodes zu ersetzen ist).

Schritt 6: Grafana installieren

Grafana lässt sich am bequemsten über das offizielle APT-Repository installieren, was künftige Updates mit apt upgrade stark vereinfacht. Auf dem zentralen Node:

sudo apt-get install -y apt-transport-https wget gnupg

sudo mkdir -p /etc/apt/keyrings
sudo wget -q -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] 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

Starten und aktivieren wir den Dienst:

sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server

Grafana ist nun unter http://IP-DES-ZENTRALEN-NODES:3000 erreichbar. Die Standard-Zugangsdaten beim ersten Login sind admin / admin: Grafana fordert sofort zur Änderung des Passworts auf, was man immer tun sollte, besonders wenn der Server im Internet erreichbar ist.

Schritt 7: Grafana mit Prometheus verbinden

Einmal in der Grafana-Oberfläche angemeldet:

• Im Seitenmenü zu Connections > Data sources gehen und Add data source wählen.
• Prometheus aus der Liste auswählen.
• Im Feld URL http://localhost:9090 eingeben (da Prometheus auf derselben Maschine läuft; befände es sich anderswo, müsste man dessen IP-Adresse verwenden).
• Auf Save & test klicken: Ist alles korrekt konfiguriert, erscheint eine Erfolgsmeldung.

Schritt 8: ein fertiges Dashboard für CPU, RAM und Netzwerkverkehr importieren

Die Diagramme müssen nicht von Grund auf neu erstellt werden: Die Grafana-Community teilt bereits fertige, kostenlose Dashboards. Das meistgenutzte für Node Exporter ist das Dashboard „Node Exporter Full“ (ID 1860), das CPU, RAM, Festplattenspeicher, I/O und Netzwerkverkehr jedes überwachten Nodes in einem einzigen Panel anzeigt.

Zum Importieren:

• Im Seitenmenü Dashboards > New > Import aufrufen.
• Im Feld „Import via grafana.com“ 1860 eingeben und auf Load klicken.
• Als Datenquelle die eben erstellte Prometheus-Quelle auswählen und dann auf Import klicken.

Innerhalb weniger Sekunden füllt sich das Dashboard mit echten Daten aller überwachten Nodes, wobei sich der anzuzeigende Node über ein Dropdown-Menü oben auswählen lässt.

Tipps für ein sicheres und nachhaltiges Monitoring

• Prometheus und Node Exporter niemals direkt ins Internet exponieren. Keines der beiden verfügt standardmäßig über eine Authentifizierung: Sie sollten in einem privaten Netzwerk (LAN, VPN wie WireGuard oder Tailscale) oder hinter einem Reverse-Proxy mit Authentifizierung betrieben werden.
• Grafana hinter HTTPS betreiben, wenn es vom Internet aus erreichbar ist, zum Beispiel mit einem Nginx-Reverse-Proxy und einem Let's-Encrypt-Zertifikat.
• Eine sinnvolle Aufbewahrungsdauer für die Daten festlegen. Standardmäßig speichert Prometheus die Daten 15 Tage lang; auf einem Homelab mit wenig Festplattenspeicher kann es sinnvoll sein, diese mit der Option --storage.tsdb.retention.time zu verkürzen, oder sie zu erhöhen, wenn mehr Speicherplatz zur Verfügung steht.
• Alertmanager in Betracht ziehen, um automatische Benachrichtigungen (E-Mail, Telegram usw.) zu erhalten, sobald eine Metrik einen kritischen Schwellenwert überschreitet, statt die Dashboards manuell prüfen zu müssen.
• Prometheus und Node Exporter regelmäßig aktualisieren: Da es sich um einzelne Binärdateien handelt, besteht die Aktualisierung einfach darin, die Schritte zum Herunterladen und Ersetzen der Datei zu wiederholen, während Grafana nach Einrichtung des Repositorys mit apt upgrade aktualisiert wird.

Fazit

Mit wenigen Befehlen und minimaler Ressourcenbelastung ermöglichen Prometheus, Node Exporter und Grafana den Aufbau eines professionellen Monitoring-Systems, selbst für ein einfaches Homelab oder eine kleine Gruppe privater Server. Sobald man mit dem Stack vertraut ist, lässt er sich leicht um neue Scrape-Jobs erweitern (zum Beispiel um nicht nur die Hardware, sondern auch Anwendungsdienste zu überwachen), um neue Community-Dashboards und um automatische Alarme über Alertmanager.

Offizielle Quellen

• Prometheus — Monitoring Linux host metrics with the Node Exporter
• Prometheus — offizielle Download-Seite
• Grafana — Installation auf Debian/Ubuntu (offizielle Dokumentation)
• Grafana — Community-Dashboard „Node Exporter Full“ (ID 1860)