VPS Monitoring met Uptime Kuma en Grafana

Je kunt niet oplossen wat je niet kunt zien. Deze gids behandelt het opzetten van uitgebreide monitoring voor je VPS — van eenvoudige uptime-controles tot volledige metrieken-dashboards.

Waarom Dit Belangrijk Is

Zonder monitoring kom je problemen pas aan de weet als gebruikers klagen — of als alles al kapot is. Goede monitoring betekent:

• Problemen opmerken voor gebruikers dat doen - CPU-pieklmeldingen vóór crashes
• Prestatietrends begrijpen - Weet wanneer je moet upgraden
• Sneller debuggen - Historische data laat zien wat er veranderd is
• Rustiger slapen - Geautomatiseerde meldingen betekenen dat je niet constant hoeft te controleren
• Uptime aantonen - Laat clients zien dat hun SLA wordt gehaald

Vereisten

• Een VPS met Docker geïnstalleerd (we raden Hostinger VPS aan voor betrouwbare prestatiegegevens)
• Basiskennis van Docker Compose
• Een domeinnaam (optioneel, maar aanbevolen)

Snel Starten: Kies je Stack

Tool	Het beste voor	Complexiteit
Uptime Kuma	Uptime-bewaking, statuspagina’s	Eenvoudig
Grafana + Prometheus	Volledige metrieken, dashboards	Gemiddeld
Netdata	Real-time systeembewaking	Eenvoudig
Volledige stack	Productieomgevingen	Geavanceerd

Deel 1: Uptime Kuma (Eenvoudig & Effectief)

Uptime Kuma is een zelfgehoste monitoringtool die mooi en eenvoudig te gebruiken is.

Stap 1: Uptime Kuma Deployen

# docker-compose.yml
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

volumes:
  uptime-kuma-data:

docker compose up -d

Toegankelijk via http://jouw-server:3001

Stap 2: Monitors Configureren

Voeg na de installatie monitors toe voor:

HTTP(S)-bewaking:

• Je website-URL’s
• API-eindpunten
• Beheerpanelen

TCP-poortbewaking:

• Databasepoorten (intern)
• Redis, cacheservices

Docker Container-bewaking:

• Bewaak de containerstatus rechtstreeks

DNS-bewaking:

• Zorg dat DNS correct wordt opgelost

Stap 3: Meldingen Instellen

Uptime Kuma ondersteunt meer dan 90 meldingsservices:

• Telegram - Directe meldingen op mobiel
• Discord/Slack - Teamkanalen
• E-mail - Traditioneel maar betrouwbaar
• Pushover - Premium pushmeldingen
• Webhook - Aangepaste integraties

Configureer via: Instellingen → Meldingen

Stap 4: Een Statuspagina Aanmaken

1. Ga naar Statuspagina’s
2. Maak een nieuwe pagina aan
3. Voeg je monitors toe
4. Deel de publieke URL met gebruikers

Deel 2: Volledige Metrieken Stack (Prometheus + Grafana)

Voor uitgebreide metrikenverzameling en -visualisatie.

Stap 1: De Stack Aanmaken

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    ports:
      - "8080:8080"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Stap 2: Prometheus Configureren

# prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: []

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

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

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

  # Add your applications
  - job_name: 'myapp'
    static_configs:
      - targets: ['myapp:3000']
    metrics_path: '/metrics'

Stap 3: De Stack Starten

mkdir -p prometheus
# Create prometheus.yml as above
docker compose -f docker-compose.monitoring.yml up -d

Stap 4: Grafana Dashboards Instellen

1. Open Grafana via http://jouw-server:3000

2. Log in met admin / jouw-wachtwoord

3. Voeg Prometheus toe als databron:

   • Configuratie → Databronnen → Toevoegen
   • Selecteer Prometheus
   • URL: http://prometheus:9090
   • Opslaan & Testen

4. Kant-en-klare dashboards importeren:

   • Dashboards → Importeren
   • Populaire dashboard-ID’s:
     • 1860 - Node Exporter Full
     • 893 - Docker and System Monitoring
     • 14282 - cAdvisor Dashboard

Stap 5: Aangepaste Meldingen Aanmaken

In Grafana:

1. Meldingen → Meldingsregels → Nieuw
2. Stel voorwaarden in op basis van metrieken
3. Stel meldingskanalen in

Voorbeeldmelding: CPU > 80% gedurende 5 minuten

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80

Deel 3: Netdata (Real-Time Bewaking)

Voor directe bewaking zonder configuratie:

services:
  netdata:
    image: netdata/netdata
    container_name: netdata
    ports:
      - "19999:19999"
    cap_add:
      - SYS_PTRACE
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
    restart: unless-stopped

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

Toegankelijk via http://jouw-server:19999 - direct prachtige dashboards!

Deel 4: Bewaking op Applicatieniveau

Metrieken Toevoegen aan je Apps

Node.js met prom-client:

const client = require('prom-client');
const express = require('express');

// Collect default metrics
client.collectDefaultMetrics();

// Custom metrics
const httpRequestsTotal = new client.Counter({
  name: 'http_requests_total',
  help: 'Total HTTP requests',
  labelNames: ['method', 'path', 'status']
});

app.use((req, res, next) => {
  res.on('finish', () => {
    httpRequestsTotal.inc({
      method: req.method,
      path: req.route?.path || req.path,
      status: res.statusCode
    });
  });
  next();
});

// Expose metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

Python met prometheus-client:

from prometheus_client import Counter, Histogram, generate_latest
from flask import Flask, Response

app = Flask(__name__)

REQUEST_COUNT = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

Deel 5: Logbewaking met Loki

Gecentraliseerde logging toevoegen:

services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - loki_data:/loki
    restart: unless-stopped

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml
    restart: unless-stopped

volumes:
  loki_data:

Promtail-configuratie:

# promtail-config.yml
server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*log

  - job_name: docker
    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*log

Voeg Loki toe als Grafana-databron en bevraag logs naast metrieken!

Aanbevolen Monitoringconfiguratie

Voor de meeste VPS-implementaties:

# docker-compose.monitoring.yml - Complete recommended stack
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    ports:
      - "3000:3000"
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    restart: unless-stopped

volumes:
  uptime-kuma-data:
  grafana_data:
  prometheus_data:

Best Practices

1. Monitor van buitenaf - Externe controles detecteren netwerkproblemen
2. Stel redelijke drempelwaarden in - Voorkom meldingsmoeheid
3. Laag je monitoring - Uptime + metrieken + logs
4. Bewaar data op de juiste manier - 15-30 dagen voor metrieken, langer voor aggregaten
5. Documenteer runbooks - Wat te doen als melding X afgaat
6. Test je meldingen - Zorg dat ze je daadwerkelijk bereiken
7. Bewaak de monitors - Gebruik een externe service om je monitoring in de gaten te houden
8. Beveilig je dashboards - Metrieken kunnen gevoelige informatie onthullen (zie onze VPS beveiligingsgids)

Veelgemaakte Fouten

❌ Te veel meldingen - Meldingsmoeheid zorgt dat echte problemen worden genegeerd

❌ Geen externe bewaking - Als je server down is, is je monitoring dat ook

❌ Metrieken publiek toegankelijk maken - Gebruik authenticatie of interne netwerken

❌ Geen retentie instellen - Schijf raakt vol met oude data

❌ Monitoren zonder actie - Dashboards lossen problemen niet op

❌ Eén meldingskanaal - E-mail down? Geen meldingen

❌ Geen basislijn - Je moet weten hoe “normaal” eruitziet

❌ Te veel monitoren - Begin eenvoudig, voeg complexiteit toe naargelang nodig

Belangrijke Metrieken om te Bewaken

Systeemmetrieken

• CPU-gebruik - Melding bij 80%+ aanhoudend
• Geheugengebruik - Melding bij 85%+
• Schijfgebruik - Melding bij 80%+ (schijven lopen snel vol)
• Schijf I/O - Hoge wachttijd duidt op een opslagknelpunt
• Netwerkdoorvoer - Basislijn en anomaliedetectie

Applicatiemetrieken

• Responstijd - p50, p95, p99 latencies
• Foutpercentage - Percentage 5xx-antwoorden
• Aanvraagsnelheid - Verkeerspatronen
• Actieve verbindingen - Databasepoolgebruik
• Wachtrijdiepte - Achterstand achtergrondtaken

Bedrijfsmetrieken

• Aanmeldingen/aankopen - Daling duidt op problemen
• Actieve gebruikers - Betrokkenheidsgezondheid
• Omzet - De ultieme metriek

Veelgestelde Vragen

Hoeveel resources gebruikt monitoring?

Minimaal. Uptime Kuma: ~100MB RAM. Volledige Prometheus/Grafana-stack: ~500MB-1GB. De moeite waard voor het inzicht.

Moet ik cloud- of zelfgehoste monitoring gebruiken?

Zelfgehost voor kostenbeheer en data-eigendom. Cloud (Datadog, New Relic) als je budget hebt en een beheerde oplossing wilt. Hostinger VPS heeft voldoende resources voor zelfgehoste monitoring.

Hoe monitor ik van buiten mijn netwerk?

Gebruik externe services zoals:

• Uptime Robot (gratis versie)
• Pingdom
• Better Uptime
• StatusCake

Deze detecteren problemen die je zelfgehoste monitoring niet kan zien.

Welke meldingsdrempelwaarden moet ik instellen?

Begin conservatief, pas aan op basis van ervaring:

• CPU: 80% gedurende 5 minuten
• Geheugen: 85%
• Schijf: 80%
• Responstijd: 2x je basislijn p95

Hoe lang moet ik metrieken bewaren?

• Hoge resolutie (15s): 7-15 dagen
• Geaggregeerd (5m): 30-90 dagen
• Verder geaggregeerd: 1-2 jaar

Balanceer detail vs. opslagkosten.

Kan ik meerdere servers monitoren?

Ja! Prometheus + Node Exporter schalen goed. Voeg gewoon nieuwe doelen toe aan je scrape-configuratie en je kunt 100+ servers bewaken vanuit één dashboard.

---

Je monitoringstack is klaar! Combineer dit met onze back-upgids en beveiligingsgids voor een productiegerede VPS.