Een Grafana + Prometheus monitoringstack opzetten op je VPS (Docker Compose-handleiding)

Als je nog niet zeker weet wat Prometheus en Grafana precies zijn, lees dan ons artikel over Prometheus vs Grafana. Ken je het verschil al, dan lees je hier hoe je ze samen draait.

Dit artikel is het praktische vervolg. Het zet Prometheus, Grafana en Node Exporter op één VPS neer met Docker Compose, plaatst HTTPS voor Grafana met Caddy, importeert het Node Exporter Full-dashboard (ID 1860) en laat zien hoe je een tweede VPS uitleest via WireGuard.

De oorspronkelijke test van april 2026 draaide op Ubuntu 24.04 LTS met Docker Engine 27.x en Docker Compose v2.30. De vastgezette versies in de configuratie hieronder zijn sindsdien bijgewerkt naar de nu ondersteunde releases. In die eerste test met vijf hosts gebruikte de hub ongeveer 300 MB RAM in rust en 530 tot 650 MB tijdens continu scrapen.

TL;DR

• De hub-VPS draait Prometheus, Grafana en Node Exporter in één Compose-stack, met Caddy als reverse proxy op de host geïnstalleerd.
• Prometheus en Grafana luisteren alleen op 127.0.0.1. Publieke toegang loopt via Caddy met automatische HTTPS.
• Voeg meer servers toe door op elke server Node Exporter te installeren en items toe te voegen aan prometheus.yml.
• WireGuard is het aanbevolen netwerkpad tussen hub en spokes. Een privénetwerk werkt prima als je servers al een privénetwerk delen.
• Een VPS van 2 GB was genoeg voor de test met vijf hosts hieronder, maar zie dat als richtlijn en niet als vaste regel per aantal hosts.

Wat je gaat bouwen

Zo ziet de opstelling er grofweg uit als je klaar bent.

                 +-------------------+
                 |  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. |
+-------------+                  +-------------+

Eén hub-VPS herbergt de volledige monitoringstack. Op elke andere VPS die je wilt monitoren draait alleen Node Exporter. Prometheus op de hub haalt van elk de metrieken op. Grafana visualiseert ze. Caddy regelt HTTPS.

Wat je nodig hebt

Voor precies deze opstelling heb je één Ubuntu-VPS als hub nodig, een domein en sudo-toegang.

• Een VPS met minstens 2 GB RAM die Ubuntu 24.04 LTS draait.
• Een domeinnaam met een A-record dat naar het publieke IP van de VPS wijst (bijvoorbeeld grafana.example.com). Nodig voor HTTPS.
• Root- of sudo-toegang via SSH.

Vervang in deze handleiding overal grafana.example.com door het subdomein dat je daadwerkelijk naar je monitoring-VPS hebt laten wijzen. Gebruik hetzelfde domein in de Grafana-omgevingsvariabele, de DNS-controle en het Caddyfile.

Wil je maar één server monitoren en heb je nog geen HTTPS nodig, dan kun je de Compose-stack op je bestaande VPS draaien zonder het stuk over de reverse proxy. De rest van de handleiding blijft gelden.

Stap 1: server voorbereiden

Log via SSH in op de hub-VPS met een gebruiker die sudo heeft. Voer eerst een systeemupdate uit.

sudo apt update && sudo apt upgrade -y

Installeer Docker Engine en de Compose-plug-in vanuit de officiële 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

Controleer of beide geïnstalleerd zijn.

docker --version
docker compose version

Beide commando's horen zonder fout een versie terug te geven. Welke versies van Docker Engine en Compose dat precies zijn, hangt af van wat de officiële repository levert op het moment dat je ze installeert.

sudo usermod -aG docker $USER

Log uit en weer in voordat je verdergaat, zodat het nieuwe groepslidmaatschap actief wordt. De groep docker geeft in de praktijk root-rechten, voeg er dus alleen vertrouwde beheerders aan toe.

Stel UFW zo in dat SSH, HTTP en HTTPS op de monitoringhub zijn toegestaan. Poort 80 verzorgt de omleiding van HTTP naar HTTPS en de ACME-validatie. Grafana zelf blijft achter Caddy.

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

Zet poort 3000, 9090 of 9100 niet open naar het publieke internet. De monitoringdiensten luisteren niet voor niets op 127.0.0.1.

Stap 2: de Compose-stack

Maak een map aan voor de stack en de Prometheus-configuratie.

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

Schrijf het Compose-bestand.

# ~/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:

Schrijf nu de Prometheus-configuratie.

# ~/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'

Maak een .env-bestand met het Grafana-adminwachtwoord. Kies een sterk wachtwoord. Commit dit bestand niet naar git.

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

Een paar van de vlaggen hierboven verdienen elk een zin uitleg.

• --web.listen-address=127.0.0.1:9090 zorgt ervoor dat Prometheus alleen op de loopback-interface van de host luistert. Poort 9090 blijft daarmee buiten het publieke netwerk, terwijl Grafana en lokaal beheer er nog wel bij kunnen.
• --web.enable-lifecycle schakelt POST /-/reload, zodat je wijzigingen in de Prometheus-configuratie kunt toepassen zonder de container te herstarten.
• pid: host, network_mode: host, de bind-mount van de host-root en --path.rootfs=/host geven de Node Exporter in de container de hostcontext die hij nodig heeft, in plaats van alleen zijn eigen containeromgeving te meten.
• GF_USERS_ALLOW_SIGN_UP=false voorkomt dat bezoekers zelf een Grafana-account aanmaken. Grafana wordt daarmee niet privé: de inlogpagina blijft publiek bereikbaar via Caddy.

Pro-tip: Wil je de handmatige installatie liever overslaan, dan biedt Cloudzy één-klik-deployments voor Grafana en Prometheus . De Prometheus-deployment kan ook Node Exporter installeren.

Stap 3: eerste start en controle

Start de stack.

cd ~/monitoring
docker compose up -d

Wacht een paar seconden en controleer dan of alle drie de containers draaien.

docker compose ps

Alle drie de services horen de status running te tonen.

Open vanaf je laptop een SSH-tunnel om de targets-pagina van Prometheus te controleren.

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

Ga daarna naar http://localhost:9090/targets in je browser. Je hoort twee targets te zien, allebei met status UP:

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

Staat er een op DOWN, ga dan naar het onderdeel Veelvoorkomende problemen. Ga niet verder voordat beide UP zijn.

Sluit de tunnel als je klaar bent met het controleren van de targets. Van buiten de VPS blijft Prometheus alleen via deze SSH-tunnel bereikbaar. In de volgende stap zetten we Grafana open via HTTPS.

Stap 4: reverse proxy met HTTPS via Caddy

Caddy is één binary en regelt HTTPS automatisch. Voor een reverse proxy met één site is de configuratie korter dan het vergelijkbare Nginx-blok.

Installeer Caddy vanuit de officiële 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

Controleer voor de volgende stap of je DNS A-record voor grafana.example.com naar het publieke IP van de VPS wijst. Zonder dat mislukt de ACME-validatie.

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

Bewerk het Caddyfile.

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

Herlaad Caddy.

sudo systemctl reload caddy

Caddy haalt en vernieuwt automatisch publiek vertrouwde TLS-certificaten via ACME, zodra het domein naar je server wijst en poort 80 en 443 bereikbaar zijn. Ga naar https://grafana.example.com in je browser: je hoort de inlogpagina van Grafana te zien over een geldige HTTPS-verbinding. Log in met admin en het wachtwoord uit je .env-bestand.

Stap 5: Prometheus toevoegen als databron en dashboard 1860 importeren

Ga in de Grafana-interface naar Verbindingen > Databronnen > Databron toevoegen en kies Prometheus.

Stel de URL in op:

http://127.0.0.1:9090

In deze opstelling delen Grafana en Prometheus het hostnetwerk, terwijl Prometheus alleen op loopback luistert. Klik op Save & test en bevestig dat Grafana de Prometheus-API kan bevragen. Je hoort "Successfully queried the Prometheus API" te zien.

Importeer nu het dashboard. Node Exporter Full (ID 1860 van rfmoz) is een veelgebruikt communitydashboard voor Node Exporter-metrieken. Het dekt CPU, geheugen, disk-I/O, netwerk, filedescriptors en hardwaretemperaturen als de host die aanlevert. Het heeft ook variabelen voor job en instance, dus het werkt zonder aanpassing in een hub-and-spoke-opzet.

Ga naar Dashboards > Nieuw > Dashboard importeren, voer dashboard-ID 1860 in, selecteer je Prometheus-databron en importeer het.

Het dashboard hoort zich te vullen zodra je Node Exporter-target UP is. Dashboard 1860 gebruikt voor sommige panelen ook metrieken van de optionele collectors systemd en processes, dus één leeg paneel betekent niet per se dat de target stuk is.

Stap 6: een tweede VPS toevoegen (hub-and-spoke)

Zorg voordat je Node Exporter start dat het privé-IP waaraan je wilt binden al bestaat op de tweede VPS. Gebruik je WireGuard, rond dan eerst die configuratie af.

Installeer op de tweede VPS Docker via het Docker-installatiedeel van stap 1, maar zet poort 80 of 443 niet open puur voor monitoring. Draai daarna alleen 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

Vervang 10.10.0.2 door het privé-monitoring-IP van deze server. Gebruik je WireGuard, neem dan het WireGuard-IP. Gebruik je het privénetwerk van Cloudzy, neem dan het IP van de privé-interface van de VPS. Is UFW al actief op deze VPS, sta dan alleen de monitoringhub toe om Node Exporter te bereiken. Als het privé-IP van de hub bijvoorbeeld 10.10.0.1 is:

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

Vervang 10.10.0.1 door het echte privé-IP van de hub. Is UFW niet actief, dan houdt het expliciete --web.listen-address Node Exporter nog steeds van de publieke interface af, maar andere machines die dat privénetwerk kunnen bereiken, komen ook bij poort 9100.

Twee goede opties voor het netwerkpad tussen hub en spokes:

1. WireGuard-netwerk. Elke VPS sluit zich aan bij een WireGuard-netwerk en Prometheus scrapet privé-IP's. Na de eenmalige WireGuard-installatie is dit de veiligste optie. Wij bieden WireGuard als één-klik-deployment aan en hebben ook een bestaande installatiehandleiding erover.
2. Privénetwerk van Cloudzy. Cloudzy VPS-instanties in dezelfde regio krijgen een privé-interface voor oost-westverkeer, dus je kunt dat adres scrapen in plaats van een aparte WireGuard-tunnel op te zetten.

LEES

WireGuard VPN instellen op VPS | Ubuntu-handleiding

Zodra Node Exporter op de tweede VPS draait en bereikbaar is op het privé-IP, vervang je de bestaande node-job in prometheus.yml op de hub door het blok hieronder.

# 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'

Herlaad Prometheus zonder de container te herstarten.

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

Open de SSH-tunnel uit stap 3 opnieuw en ga naar http://localhost:9090/targets. Het nieuwe target hoort als UP te verschijnen. Open het Node Exporter Full-dashboard, zet de variabele instance bovenaan op de nieuwe server en je zou de grafieken moeten zien.

Resourcegebruik en wanneer je moet upgraden

Deze cijfers komen uit de oorspronkelijke test van april 2026 op een Ubuntu-VPS met 2 GB en vijf gemonitorde hosts. Zie ze als richtlijn voor deze werklast, niet als vaste dimensioneringsgarantie voor nieuwere releases.

Upgrade wanneer de hub krap in het geheugen of de schijfruimte komt te zitten. Alleen naar het aantal hosts kijken is een slechte maatstaf, want seriekardinaliteit, ingeschakelde collectors, scrape-interval en bewaartermijn veranderen allemaal het verbruik. Voor centrale opslag op langere termijn ondersteunt Prometheus remote-storage-integraties. VictoriaMetrics is een Prometheus-compatibele optie.

Veelvoorkomende problemen

De zeven problemen die het vaakst voorkomen, met oplossingen.

1. Prometheus is bereikbaar vanaf het publieke internet. Een kale poortmapping 9090:9090 stelt Prometheus bloot aan de hele wereld. Oplossing: houd --web.listen-address=127.0.0.1:9090 in het Prometheus-commando, zoals hierboven getoond. Daarmee luistert Prometheus alleen op de loopback-interface van de host.
2. De Grafana-databron kan Prometheus niet bereiken. Deze stack gebruikt hostnetwerken, dus Grafana kan Prometheus bereiken op http://127.0.0.1:9090. Controleer of Prometheus draait en nog steeds op loopback luistert.
3. Het Node Exporter-dashboard toont "No data". Drie gebruikelijke oorzaken. (a) Prometheus scrapet de target niet. Controleer /targets. (b) Het job-label in de dashboardvariabele komt niet overeen met de job_name in de scrape-config. (c) Een firewall blokkeert poort 9100 tussen hub en target.
4. Het Grafana-adminwachtwoord staat nog op admin/admin in productie. Instellen GF_SECURITY_ADMIN_PASSWORD vanuit een .env-bestand vóór de eerste start. Ben je dat vergeten, verander het dan bij de eerste login en zet registratie uit.
5. Caddy meldt "ACME challenge failed". Het DNS A-record is nog niet gepropageerd, of poort 80 is geblokkeerd. Voer ufw allow 80,443/tcpuit, wacht op DNS en voer sudo systemctl reload caddyuit. Gebruik dig +short om de propagatie te bevestigen.
6. De schijf van Prometheus loopt vol. Labels met hoge kardinaliteit of korte scrape-intervallen bij veel hosts vullen het volume snel. Houd prometheus_tsdb_head_series en de volumegrootte in de gaten. Maatregelen: schakel ongebruikte Node Exporter-collectors uit, verleng scrape_interval naar 30s of verkort de bewaartermijn.
7. Rechtenfouten bij bind-mounts. Mount je een hostmap in plaats van een named volume, dan heeft de container-UID (65534 voor Prometheus, 472 voor Grafana) schrijfrechten nodig. Named volumes, zoals in het Compose-bestand hierboven, voorkomen dit.

Wanneer deze stack overdreven is

Wil je alleen een melding als een URL niet meer reageert, dan is deze stack overdreven. Uptime Kuma is een veel lichtere optie als je genoeg hebt aan simpele uptime-checks.

Veelgestelde vragen

Wat is het verschil tussen Prometheus en Grafana?

Prometheus is een tijdreeksdatabase: hij haalt metrieken op bij ingestelde targets met het interval dat jij kiest, slaat ze op schijf op en beantwoordt PromQL-queries. Grafana is een visualisatielaag die verbinding maakt met Prometheus (en veel andere databronnen) en dashboards tekent. Vrijwel altijd wil je allebei: Prometheus om te verzamelen en op te slaan, Grafana om te tonen.

Hoeveel RAM heeft een opstelling met Prometheus + Grafana nodig?

Een monitoringhub die Prometheus, Grafana, Node Exporter en een reverse proxy op één VPS draait, gebruikt ongeveer 300 MB RAM in rust en 530 tot 650 MB wanneer hij vijf hosts actief scrapet met een interval van 15 seconden.

Kan ik meerdere servers monitoren met één Grafana-instantie?

Ja. Het standaardpatroon is hub-and-spoke. Eén Prometheus-instantie op een hub-VPS scrapet de Node Exporter op elke andere server die je wilt monitoren. Grafana op de hub bevraagt die ene Prometheus. Het Node Exporter Full-dashboard (ID 1860) heeft een instance-variabele, dus je wisselt vanuit één dashboard tussen servers.

Wat is het beste Grafana-dashboard voor Node Exporter?

Voor deze opstelling is Node Exporter Full (dashboard-ID 1860 van rfmoz) een sterke standaardkeuze. Het dekt de belangrijkste hostmetrieken van Node Exporter en ondersteunt de variabelen job en instance voor monitoring van meerdere servers. Sommige panelen leunen op optionele Node Exporter-collectors, dus een leeg paneel betekent niet per se dat de scrape-target stuk is.

Hoe stel ik Grafana beschikbaar via HTTPS?

Draai Grafana gebonden aan 127.0.0.1:3000 en zet er een reverse proxy voor die HTTPS afhandelt. Caddy is de eenvoudigste optie: een Caddyfile van vier regels met reverse_proxy 127.0.0.1:3000 en een domeinblok regelt alles, inclusief automatisch beheer van TLS-certificaten.

Zijn Prometheus + Grafana gratis voor commercieel gebruik?

Prometheus valt onder Apache 2.0. Grafana OSS valt onder AGPLv3. Intern en commercieel gebruik van ongewijzigde Grafana OSS is toegestaan, maar het aanpassen of verspreiden ervan, of een aangepaste versie via een netwerk aanbieden, kan onder de AGPL verplichtingen scheppen om broncode te delen. Voor Grafana Enterprise en Grafana Cloud gelden aparte commerciële voorwaarden.

Wanneer moet ik overstappen van Prometheus naar VictoriaMetrics?

Overweeg VictoriaMetrics wanneer een langere bewaartermijn, hoge seriekardinaliteit of meerdere Prometheus-instanties het lastiger maken om de lokale Prometheus-TSDB binnen het geheugen- en schijfbudget van je server te draaien. VictoriaMetrics kan Prometheus-data ontvangen en biedt een Prometheus-compatibele query-API, dus het kan dienen als langetermijnopslag of als metrics-backend voor Grafana. Benchmark het met je eigen werklast in plaats van over te stappen bij een vaste RAM-drempel.