Grafana + Prometheus Monitoring-Stack auf Ihrem VPS einrichten (Docker-Compose-Anleitung)

Wenn Sie noch nicht wissen, was Prometheus und Grafana überhaupt sind, lesen Sie unseren Beitrag zu Prometheus vs. Grafana. Wenn Sie den Unterschied bereits kennen, zeigen wir Ihnen hier, wie Sie beide zusammen betreiben.

Dieser Beitrag ist der praktische Teil. Er stellt Prometheus, Grafana und Node Exporter mit Docker Compose auf einem einzigen VPS bereit, setzt mit Caddy HTTPS vor Grafana, importiert das Dashboard Node Exporter Full (ID 1860) und zeigt, wie Sie Metriken von einem zweiten VPS über WireGuard abrufen.

Der ursprüngliche Test im April 2026 lief auf Ubuntu 24.04 LTS mit Docker Engine 27.x und Docker Compose v2.30. Die in der Konfiguration unten festgelegten Versionen wurden inzwischen auf die aktuell unterstützten Releases aktualisiert. In diesem ursprünglichen Test mit fünf Hosts belegte der Hub rund 300 MB RAM im Leerlauf und 530 bis 650 MB im laufenden Scraping-Betrieb.

Kurzfassung

• Der Hub-VPS betreibt Prometheus, Grafana und Node Exporter in einem einzigen Compose-Stack, mit Caddy als Reverse Proxy direkt auf dem Host.
• Prometheus und Grafana lauschen ausschließlich auf 127.0.0.1. Der öffentliche Zugriff läuft über Caddy mit automatischem HTTPS.
• Weitere Server fügen Sie hinzu, indem Sie auf jedem Node Exporter installieren und Einträge anhängen in prometheus.yml.
• WireGuard ist der empfohlene Netzwerkpfad zwischen Hub und Spokes. Ein privates Netzwerk funktioniert gut, wenn Ihre Server bereits ein solches teilen.
• Für den Test mit fünf Hosts weiter unten reichte ein VPS mit 2 GB, betrachten Sie das aber als Richtwert und nicht als feste Regel pro Hostanzahl.

Was Sie aufbauen

So sieht das Setup im Groben aus, wenn Sie fertig sind.

                 +-------------------+
                 |  Your laptop      |
                 +---------+---------+
                           | HTTPS
                           v
+--------------------------+----------------------------+
| MONITORING HUB VPS    (2 GB RAM starting point) |
|  Caddy        (reverse proxy, auto HTTPS)             |
|  Grafana      (port 3000, only via Caddy)             |
|  Prometheus   (port 9090, internal only)              |
|  Node Exporter (port 9100, scraped on localhost)      |
+----+---------------------------------+----------------+
     |                                 |
     | scrape over WireGuard           | scrape over WG
     v                                 v
+----+--------+                  +-----+-------+
|  App VPS 1  |                  |  App VPS 2  |
|  Node Expo. |                  |  Node Expo. |
+-------------+                  +-------------+

Ein einziger Hub-VPS beherbergt den kompletten Monitoring-Stack. Auf jedem weiteren VPS, den Sie überwachen wollen, läuft nur Node Exporter. Prometheus auf dem Hub holt sich von jedem die Metriken. Grafana stellt sie dar. Caddy kümmert sich um HTTPS.

Was Sie brauchen

Für genau dieses Setup brauchen Sie einen Ubuntu-VPS als Hub, eine Domain und sudo-Zugriff.

• Ein VPS mit mindestens 2 GB RAM unter Ubuntu 24.04 LTS.
• Eine Domain mit einem A-Record, der auf die öffentliche IP des VPS zeigt (zum Beispiel grafana.example.com). Für HTTPS erforderlich.
• Root- oder sudo-Zugriff über SSH.

Ersetzen Sie in dieser Anleitung durchgehend grafana.example.com durch die Subdomain, die Sie tatsächlich auf Ihren Monitoring-VPS zeigen lassen. Verwenden Sie dieselbe Domain in der Grafana-Umgebungsvariable, bei der DNS-Prüfung und im Caddyfile.

Wenn Sie nur einen Server überwachen wollen und HTTPS noch nicht brauchen, können Sie den Compose-Stack auf Ihrem vorhandenen VPS ohne den Reverse-Proxy-Abschnitt betreiben. Der Rest der Anleitung gilt weiterhin.

Schritt 1: Server vorbereiten

Melden Sie sich per SSH mit einem sudo-fähigen Benutzer am Hub-VPS an. Führen Sie zuerst ein System-Update aus.

sudo apt update && sudo apt upgrade -y

Installieren Sie Docker Engine und das Compose-Plugin aus dem offiziellen Docker-Repository.

# Install prerequisites
sudo apt install -y ca-certificates curl gnupg lsb-release

# Add Docker's official GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Prüfen Sie, ob beide installiert sind.

docker --version
docker compose version

Beide Befehle sollten fehlerfrei eine Version ausgeben. Welche Versionen von Docker Engine und Compose es genau sind, hängt davon ab, was das offizielle Repository zum Installationszeitpunkt ausliefert.

sudo usermod -aG docker $USER

Melden Sie sich ab und wieder an, bevor Sie fortfahren, damit die neue Gruppenmitgliedschaft wirksam wird. Die Gruppe docker verleiht faktisch root-Rechte, nehmen Sie also nur vertrauenswürdige Administratoren auf.

Konfigurieren Sie UFW so, dass SSH, HTTP und HTTPS auf dem Monitoring-Hub erlaubt sind. Port 80 übernimmt die Weiterleitung von HTTP auf HTTPS und die ACME-Validierung. Grafana selbst bleibt hinter Caddy.

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status

Öffnen Sie die Ports 3000, 9090 und 9100 nicht zum öffentlichen Internet. Die Monitoring-Dienste lauschen nicht ohne Grund auf 127.0.0.1.

Schritt 2: Der Compose-Stack

Legen Sie ein Verzeichnis für den Stack und die Prometheus-Konfiguration an.

mkdir -p ~/monitoring/prometheus
cd ~/monitoring

Schreiben Sie die Compose-Datei.

# ~/monitoring/docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:v3.13.2
    container_name: prometheus
    restart: unless-stopped
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=15d'
      - '--web.enable-lifecycle'
      - '--web.listen-address=127.0.0.1:9090'
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    network_mode: host
  node-exporter:
    image: prom/node-exporter:v1.12.1
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    network_mode: host
    command:
      - '--path.rootfs=/host'
      - '--web.listen-address=127.0.0.1:9100'
      - '--collector.filesystem.mount-points-exclude=^/(dev|proc|sys|var/lib/docker/.+|var/lib/kubelet/.+)($$|/)'
    volumes:
      - '/:/host:ro,rslave'
  grafana:
    image: grafana/grafana:13.1.3
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
      - GF_SERVER_ROOT_URL=https://grafana.example.com
      - GF_SERVER_HTTP_ADDR=127.0.0.1
    volumes:
      - grafana_data:/var/lib/grafana
    network_mode: host
    depends_on:
      - prometheus
volumes:
  prometheus_data:
  grafana_data:

Schreiben Sie nun die Prometheus-Konfiguration.

# ~/monitoring/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    monitor: 'monitoring-hub'
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['127.0.0.1:9090']
  - job_name: 'node'
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          host: 'monitoring-hub'

Legen Sie eine .env-Datei mit dem Grafana-Admin-Passwort an. Verwenden Sie ein starkes Passwort. Committen Sie diese Datei nicht in git.

cat > ~/monitoring/.env <<'EOF'
GRAFANA_ADMIN_PASSWORD='replace-with-a-strong-password'
EOF
chmod 600 ~/monitoring/.env

Ein paar der obigen Flags verdienen je einen Satz.

• --web.listen-address=127.0.0.1:9090 sorgt dafür, dass Prometheus nur auf dem Loopback-Interface des Hosts lauscht. Port 9090 bleibt damit außerhalb des öffentlichen Netzes, ist für Grafana und die lokale Administration aber weiterhin erreichbar.
• --web.enable-lifecycle aktiviert POST /-/reload, sodass Sie Änderungen an der Prometheus-Konfiguration ohne Neustart des Containers übernehmen können.
• pid: host, network_mode: host, der Bind-Mount des Host-Root-Verzeichnisses und --path.rootfs=/host geben dem containerisierten Node Exporter den Host-Kontext, den er braucht, statt nur seine eigene Container-Umgebung zu überwachen.
• GF_USERS_ALLOW_SIGN_UP=false verhindert, dass Besucher sich selbst Grafana-Konten anlegen. Privat wird Grafana dadurch nicht: Die Anmeldeseite bleibt über Caddy öffentlich erreichbar.

Profi-Tipp: Wenn Sie sich die manuelle Installation sparen möchten: Cloudzy bietet Ein-Klick-Deployments für Grafana und Prometheus . Das Prometheus-Deployment kann auch Node Exporter mitinstallieren.

Schritt 3: Erster Start und Überprüfung

Starten Sie den Stack.

cd ~/monitoring
docker compose up -d

Warten Sie ein paar Sekunden und prüfen Sie dann, ob alle drei Container laufen.

docker compose ps

Alle drei Dienste sollten den Status „running" anzeigen.

Öffnen Sie von Ihrem Laptop aus einen SSH-Tunnel, um die Targets-Seite von Prometheus zu prüfen.

ssh -L 9090:localhost:9090 your-user@your-vps-ip

Rufen Sie dann http://localhost:9090/targets im Browser auf. Sie sollten zwei Targets sehen, beide im Zustand UP:

prometheus            UP    http://127.0.0.1:9090/metrics
node                  UP    http://127.0.0.1:9100/metrics

Ist eines davon DOWN, springen Sie zum Abschnitt „Häufige Probleme". Machen Sie erst weiter, wenn beide UP sind.

Schließen Sie den Tunnel, wenn Sie die Targets geprüft haben. Von außerhalb des VPS bleibt Prometheus nur über diesen SSH-Tunnel erreichbar. Im nächsten Schritt geben wir Grafana über HTTPS frei.

Schritt 4: Reverse Proxy mit HTTPS über Caddy

Caddy ist eine einzige Binärdatei und kümmert sich automatisch um HTTPS. Für einen Reverse Proxy mit nur einer Site ist die Konfiguration kürzer als der entsprechende Nginx-Block.

Installieren Sie Caddy aus dem offiziellen Repository.

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | \
  sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | \
  sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install -y caddy

Bestätigen Sie vor dem nächsten Schritt, dass Ihr DNS-A-Record für grafana.example.com auf die öffentliche IP des VPS zeigt. Sonst schlägt die ACME-Validierung fehl.

dig +short grafana.example.com
# Should print the VPS public IP

Bearbeiten Sie das Caddyfile.

# /etc/caddy/Caddyfile
grafana.example.com {
    reverse_proxy 127.0.0.1:3000
    encode gzip
}

Laden Sie Caddy neu.

sudo systemctl reload caddy

Caddy holt und erneuert automatisch öffentlich vertrauenswürdige TLS-Zertifikate über ACME, sobald die Domain auf Ihren Server zeigt und die Ports 80 und 443 erreichbar sind. Rufen Sie https://grafana.example.com im Browser auf: Sie sollten die Grafana-Anmeldeseite über eine gültige HTTPS-Verbindung sehen. Melden Sie sich mit admin und dem Passwort aus Ihrer .env-Datei an.

Schritt 5: Prometheus als Datenquelle hinzufügen und Dashboard 1860 importieren

Gehen Sie in der Grafana-Oberfläche zu Verbindungen > Datenquellen > Datenquelle hinzufügen und wählen Sie Prometheus.

Setzen Sie die URL auf:

http://127.0.0.1:9090

In diesem Setup teilen sich Grafana und Prometheus das Host-Netzwerk, während Prometheus nur auf Loopback lauscht. Klicken Sie auf Save & test und bestätigen Sie, dass Grafana die Prometheus-API abfragen kann. Es sollte „Successfully queried the Prometheus API" erscheinen.

Importieren Sie nun das Dashboard. Node Exporter Full (ID 1860 von rfmoz) ist ein weit verbreitetes Community-Dashboard für Node-Exporter-Metriken. Es deckt CPU, Arbeitsspeicher, Disk-I/O, Netzwerk, Dateideskriptoren und Hardware-Temperaturen ab, sofern der Host sie bereitstellt. Es bringt außerdem Variablen für job und instance mit und funktioniert damit ohne Anpassung im Hub-and-Spoke-Betrieb.

Gehe zu Dashboards > Neu > Dashboard importieren, geben Sie die Dashboard-ID 1860 ein, wählen Sie Ihre Prometheus-Datenquelle aus und importieren Sie es.

Das Dashboard sollte sich füllen, sobald Ihr Node-Exporter-Target UP ist. Dashboard 1860 nutzt für einige Panels zusätzlich Metriken der optionalen Collectors systemd und processes, ein einzelnes leeres Panel bedeutet also nicht zwangsläufig, dass das Target kaputt ist.

Schritt 6: Einen zweiten VPS hinzufügen (Hub-and-Spoke)

Stellen Sie vor dem Start von Node Exporter sicher, dass die private IP, an die Sie binden wollen, auf dem zweiten VPS bereits existiert. Wenn Sie WireGuard nutzen, schließen Sie dessen Einrichtung zuerst ab.

Installieren Sie auf dem zweiten VPS Docker anhand des Docker-Installationsteils aus Schritt 1, öffnen Sie aber nicht die Ports 80 oder 443 nur fürs Monitoring. Starten Sie anschließend nur Node Exporter.

mkdir -p ~/node-exporter
cd ~/node-exporter

cat > docker-compose.yml <<'EOF'
services:
  node-exporter:
    image: prom/node-exporter:v1.12.1
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    command:
      - '--path.rootfs=/host'
      - '--web.listen-address=10.10.0.2:9100'  # bind to the private monitoring IP, never 0.0.0.0
    volumes:
      - '/:/host:ro,rslave'
    network_mode: host
EOF

docker compose up -d

Ersetzen Sie 10.10.0.2 durch die private Monitoring-IP dieses Servers. Bei WireGuard nehmen Sie dessen WireGuard-IP, beim privaten Netzwerk von Cloudzy die IP der privaten Schnittstelle des VPS. Ist UFW auf diesem VPS bereits aktiv, erlauben Sie nur dem Monitoring-Hub den Zugriff auf Node Exporter. Lautet die private IP des Hubs zum Beispiel 10.10.0.1:

sudo ufw allow proto tcp from 10.10.0.1 to any port 9100
sudo ufw status

Ersetzen Sie 10.10.0.1 durch die tatsächliche private IP des Hubs. Ist UFW inaktiv, hält das explizite --web.listen-address Node Exporter weiterhin von der öffentlichen Schnittstelle fern, andere Maschinen mit Zugang zu diesem privaten Netzwerk erreichen Port 9100 aber ebenfalls.

Zwei gute Optionen für den Netzwerkpfad zwischen Hub und Spokes:

1. WireGuard-Netzwerk. Jeder VPS tritt einem WireGuard-Netzwerk bei, und Prometheus scrapt private IPs. Nach der einmaligen WireGuard-Einrichtung ist das die sicherste Variante. Wir bieten WireGuard als Ein-Klick-Deployment an und haben außerdem ein bestehendes Einrichtungs-Tutorial dazu.
2. Privates Netzwerk von Cloudzy. VPS-Instanzen von Cloudzy in derselben Region erhalten eine private Schnittstelle für Ost-West-Verkehr, Sie können also diese Adresse scrapen, statt einen separaten WireGuard-Tunnel aufzubauen.

LESEN

So richtest du WireGuard VPN auf VPS ein | Ubuntu Anleitung

Sobald Node Exporter auf dem zweiten VPS läuft und über dessen private IP erreichbar ist, ersetzen Sie den vorhandenen node-Job in prometheus.yml auf dem Hub durch den folgenden Block.

# Update the existing 'node' job in ~/monitoring/prometheus/prometheus.yml
  - job_name: 'node'
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          host: 'monitoring-hub'
      - targets: ['10.10.0.2:9100']
        labels:
          host: 'app-vps-1'
          tier: 'production'

Laden Sie Prometheus neu, ohne den Container neu zu starten.

curl -X POST http://localhost:9090/-/reload

Öffnen Sie den SSH-Tunnel aus Schritt 3 erneut und rufen Sie http://localhost:9090/targets auf. Das neue Target sollte als UP erscheinen. Öffnen Sie das Dashboard Node Exporter Full, stellen Sie die Variable instance oben auf den neuen Server um, und Sie sollten dessen Graphen sehen.

Ressourcenverbrauch und wann Sie aufrüsten sollten

Diese Zahlen stammen aus dem ursprünglichen Test von April 2026 auf einem Ubuntu-VPS mit 2 GB und fünf überwachten Hosts. Betrachten Sie sie als Richtwert für diese Last, nicht als feste Dimensionierungsgarantie für neuere Releases.

Rüsten Sie auf, wenn dem Hub Arbeitsspeicher oder Plattenreserve knapp wird. Die reine Hostanzahl ist ein schlechter Auslöser für die Dimensionierung, denn Serien-Kardinalität, aktivierte Collectors, Scrape-Intervall und Aufbewahrungsdauer verändern den Verbrauch alle. Für längerfristige zentrale Speicherung unterstützt Prometheus Remote-Storage-Integrationen. VictoriaMetrics ist eine Prometheus-kompatible Option.

Häufige Probleme

Die sieben Probleme, die am häufigsten auftreten, samt Lösungen.

1. Prometheus ist aus dem öffentlichen Internet erreichbar. Ein simples Port-Mapping 9090:9090 gibt Prometheus für alle frei. Lösung: Behalten Sie --web.listen-address=127.0.0.1:9090 im Prometheus-Befehl bei, wie oben gezeigt. Damit lauscht Prometheus nur auf dem Loopback-Interface des Hosts.
2. Die Grafana-Datenquelle erreicht Prometheus nicht. Dieser Stack nutzt Host-Networking, Grafana erreicht Prometheus also unter http://127.0.0.1:9090. Prüfen Sie, ob Prometheus läuft und weiterhin auf Loopback lauscht.
3. Das Node-Exporter-Dashboard zeigt „No data". Drei übliche Ursachen. (a) Prometheus scrapt das Target nicht. Prüfen Sie /targets. (b) Das job-Label in der Dashboard-Variable stimmt nicht mit dem job_name in der Scrape-Konfiguration überein. (c) Eine Firewall blockiert Port 9100 zwischen Hub und Target.
4. Das Grafana-Admin-Passwort ist noch admin/admin in der Produktion. Setze GF_SECURITY_ADMIN_PASSWORD aus einer .env-Datei vor dem ersten Start. Falls Sie das versäumt haben, ändern Sie es bei der ersten Anmeldung und deaktivieren Sie die Registrierung.
5. Caddy meldet „ACME challenge failed". Der DNS-A-Record ist noch nicht propagiert, oder Port 80 ist blockiert. Führen Sie ufw allow 80,443/tcpaus, warten Sie auf das DNS und führen Sie sudo systemctl reload caddyaus. Verwenden Sie dig +short , um die Propagierung zu bestätigen.
6. Die Festplatte von Prometheus läuft voll. Labels mit hoher Kardinalität oder kurze Scrape-Intervalle bei vielen Hosts füllen das Volume schnell. Beobachten Sie prometheus_tsdb_head_series und die Volume-Größe. Gegenmaßnahmen: ungenutzte Node-Exporter-Collectors deaktivieren, das scrape_interval auf 30s verlängern oder die Aufbewahrungsdauer verkürzen.
7. Berechtigungsfehler bei Bind-Mounts. Wenn Sie ein Host-Verzeichnis statt eines benannten Volumes einhängen, braucht die Container-UID (65534 für Prometheus, 472 für Grafana) Schreibzugriff. Benannte Volumes, wie in der Compose-Datei oben, umgehen das.

Wann dieser Stack überdimensioniert ist

Wenn Sie nur eine Benachrichtigung wollen, sobald eine URL nicht mehr antwortet, ist dieser Stack überdimensioniert. Uptime Kuma ist deutlich schlanker, wenn Ihnen einfache Verfügbarkeitschecks reichen.

Häufig gestellte Fragen

Was ist der Unterschied zwischen Prometheus und Grafana?

Prometheus ist eine Zeitreihendatenbank: Sie scrapt Metriken von konfigurierten Targets in dem von Ihnen gewählten Intervall, legt sie auf der Platte ab und beantwortet PromQL-Abfragen. Grafana ist eine Visualisierungsschicht, die sich mit Prometheus (und vielen anderen Datenquellen) verbindet und Dashboards rendert. Fast immer wollen Sie beides: Prometheus zum Sammeln und Speichern, Grafana zum Anzeigen.

Wie viel RAM braucht ein Setup aus Prometheus und Grafana?

Ein Monitoring-Hub, auf dem Prometheus, Grafana, Node Exporter und ein Reverse Proxy auf einem einzigen VPS laufen, belegt rund 300 MB RAM im Leerlauf und 530 bis 650 MB, wenn er fünf Hosts im 15-Sekunden-Takt scrapt.

Kann ich mehrere Server mit einer einzigen Grafana-Instanz überwachen?

Ja. Das Standardmuster ist Hub-and-Spoke. Eine einzige Prometheus-Instanz auf einem Hub-VPS scrapt den Node Exporter auf jedem weiteren Server, den Sie überwachen wollen. Grafana auf dem Hub fragt genau dieses eine Prometheus ab. Das Dashboard Node Exporter Full (ID 1860) bringt eine instance-Variable mit, sodass Sie aus einem Dashboard zwischen Servern wechseln.

Welches ist das beste Grafana-Dashboard für Node Exporter?

Für dieses Setup ist Node Exporter Full (Dashboard-ID 1860 von rfmoz) eine sehr gute Standardwahl. Es deckt die wichtigsten Host-Metriken von Node Exporter ab und unterstützt die Variablen job und instance für die Überwachung mehrerer Server. Einige Panels hängen von optionalen Node-Exporter-Collectors ab, ein einzelnes leeres Panel bedeutet also nicht zwangsläufig, dass das Scrape-Target kaputt ist.

Wie stelle ich Grafana über HTTPS bereit?

Betreiben Sie Grafana gebunden an 127.0.0.1:3000 und setzen Sie einen Reverse Proxy davor, der HTTPS übernimmt. Am einfachsten ist Caddy: ein vierzeiliges Caddyfile mit reverse_proxy 127.0.0.1:3000 und einem Domain-Block erledigt alles, inklusive der automatischen Verwaltung der TLS-Zertifikate.

Sind Prometheus und Grafana für die kommerzielle Nutzung kostenlos?

Prometheus steht unter Apache 2.0. Grafana OSS steht unter AGPLv3. Die interne und kommerzielle Nutzung von unverändertem Grafana OSS ist erlaubt, doch Änderungen, Weitergabe oder das Anbieten einer modifizierten Version über ein Netzwerk können nach der AGPL Pflichten zur Offenlegung des Quellcodes auslösen. Für Grafana Enterprise und Grafana Cloud gelten eigene kommerzielle Bedingungen.

Wann sollte ich von Prometheus zu VictoriaMetrics wechseln?

Ziehen Sie VictoriaMetrics in Betracht, wenn längere Aufbewahrung, hohe Serien-Kardinalität oder mehrere Prometheus-Instanzen den Betrieb der lokalen Prometheus-TSDB im Speicher- und Plattenbudget Ihres Servers erschweren. VictoriaMetrics kann Prometheus-Daten entgegennehmen und eine Prometheus-kompatible Abfrage-API bereitstellen, taugt also als Langzeitspeicher oder als Metrik-Backend für Grafana. Testen Sie es mit Ihrer eigenen Last, statt bei einer festen RAM-Schwelle zu wechseln.