```html

Server monitoring met Grafana: logs, metrics en alerts op één plek

Je server draait, je applicatie is live, en alles lijkt in orde. Tot het moment dat een klant je belt omdat de site al twintig minuten plat ligt — en jij het als laatste weet. Herkenbaar? Dan is het tijd om serieus werk te maken van server monitoring. Met de juiste tooling zie je problemen aankomen voordat ze uitgroeien tot incidenten, en weet je precies wat er speelt op je infrastructuur.

In dit artikel duiken we in een praktische monitoring-stack met Grafana als hart van je dashboards en alerting, aangevuld met de juiste log-aggregatie en real-time metrics. Of je nu één VPS beheert of een cluster van tientallen servers runt — de principes zijn hetzelfde.

Waarom server monitoring niet optioneel is

Veel developers en systeembeheerders monitoren reactief: pas als iets kapot is, gaan ze zoeken. Dat is begrijpelijk als je druk bent, maar het is ook onnodig duur. Downtime kost geld, reputatie en zenuwen. Goede server monitoring draait om drie pijlers:

• Metrics: cijfermatige data over CPU, geheugen, schijfgebruik, netwerk en applicatieprestaties
• Logs: tekstuele gebeurtenissen uit je systeem, applicatie en services
• Alerts: automatische notificaties wanneer iets buiten de verwachte parameters valt

Zonder metrics weet je niet hoe gezond je server is. Zonder logs weet je niet waarom iets misging. Zonder alerts weet je niet wanneer het misging. De drie werken samen, en Grafana is het platform dat ze samenvoegt tot een coherent geheel.

De monitoring-stack: Grafana, Prometheus en Loki

Grafana is op zichzelf een visualisatietool en alerting-platform — het heeft een databron nodig. De meest gebruikte combinatie voor server monitoring ziet er als volgt uit:

• Prometheus — scrapt metrics van je servers en applicaties en slaat ze op als tijdreeksen
• Node Exporter — draait op elke server en exporteert systeemmetrics naar Prometheus
• Loki — log-aggregatiesysteem van Grafana Labs, geoptimaliseerd voor gebruik met Grafana
• Promtail — verzamelt logs van je systeem en stuurt ze naar Loki
• Grafana — visualiseert alles en verstuurt alerts

Deze stack is volledig open source, lichtgewicht en goed gedocumenteerd. Je kunt het draaien via Docker Compose, wat de installatie aanzienlijk vereenvoudigt.

Snelle installatie met Docker Compose

Maak een bestand aan genaamd docker-compose.yml met de volgende basisstructuur:

version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  node-exporter:
    image: prom/node-exporter:latest
    ports:
      - "9100:9100"
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log
      - ./promtail-config.yml:/etc/promtail/config.yml
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=jouwwachtwoord

Start de stack met docker compose up -d en open Grafana op poort 3000. Voeg Prometheus en Loki toe als databronnen via Configuration → Data Sources, en je bent klaar om je eerste dashboard te bouwen.

Metrics visualiseren in Grafana

Als de stack draait, is het tijd voor het leuke werk: dashboards bouwen. Grafana heeft een uitgebreide bibliotheek van kant-en-klare dashboards op grafana.com/grafana/dashboards. Voor Node Exporter is dashboard ID 1860 de standaard — import het met één klik en je hebt direct inzicht in CPU-gebruik, load average, geheugen, schijf-I/O en netwerkverkeer.

Wil je eigen panels toevoegen, dan schrijf je een PromQL-query. Een paar handige voorbeelden:

• CPU-gebruik in procenten: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
• Vrij geheugen: node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100
• Schijfgebruik: (node_filesystem_size_bytes - node_filesystem_free_bytes) / node_filesystem_size_bytes * 100

PromQL is krachtig maar heeft een leercurve. Begin eenvoudig, gebruik de autocomplete in de Grafana query-editor, en bouw van daaruit verder.

Alternatief: Netdata voor real-time monitoring

Wil je direct iets werkends zonder de volledige stack op te zetten? Dan is Netdata een uitstekend alternatief. Netdata installeert met één commando:

bash <(curl -Ss https://my-netdata.io/kickstart.sh)

Je krijgt direct een rijk dashboard met duizenden metrics, automatische anomaliedetectie en ingebouwde alerts. Netdata is ideaal voor snelle inzichten of als aanvulling op je Grafana-stack. Het kan ook als databron dienen voor Grafana via de Netdata Cloud-integratie.

Logs verzamelen en doorzoekbaar maken

Metrics vertellen je dat er iets mis is. Logs vertellen je wat en waarom. Een goede server monitoring-setup zonder log-aggregatie is als een auto zonder achteruitkijkspiegel: je ziet alleen wat voor je ligt.

Met Loki en Promtail verzamel je logs van /var/log/syslog, je Nginx- of Apache-access logs, applicatielogs en systeemservices. Promtail labelt de logs automatisch op basis van de bronlocatie, zodat je ze in Grafana kunt filteren per server, service of logniveau.

In Grafana gebruik je LogQL om logs te doorzoeken. Voorbeelden:

• Alle errors van Nginx: {job="nginx"} |= "error"
• SSH-inlogpogingen: {job="syslog"} |= "Failed password"
• Logs van de laatste vijf minuten met een specifieke string: {job="app"} |~ "timeout" [5m]

Koppel een log-panel aan je metrics-dashboard, zodat je bij een CPU-piek direct ook de bijbehorende applicatielogs ziet. Dat is waar de kracht van Grafana echt tot zijn recht komt: correlatie tussen metrics en logs in één interface.

Alerts instellen: meldingen voordat het te laat is

De meest onderschatte functie van server monitoring is een goed geconfigureerd alerting-systeem. Grafana heeft een ingebouwde alerting-engine die queries evalueert op basis van een tijdschema en bij afwijkingen notificaties verstuurt.

Stel alerts in via Alerting → Alert Rules. Een typische regel ziet er zo uit:

• Condition: CPU-gebruik hoger dan 85% gedurende 5 minuten
• Pending period: 2 minuten (voorkomt valse meldingen bij korte pieken)
• Notificatiekanaal: Slack, e-mail, PagerDuty of webhook

Configureer notificatiekanalen via Alerting → Contact Points. Grafana ondersteunt tientallen integraties. Voor een Nederlandse hosting-omgeving is Slack of e-mail vaak voldoende; grotere teams kiezen voor PagerDuty of OpsGenie voor on-call rotaties.

Praktische alertdrempels voor servers

Gebruik deze drempelwaarden als startpunt en pas ze aan op jouw workload:

• CPU: waarschuwing bij >75%, kritiek bij >90% gedurende 5 minuten
• Geheugen: waarschuwing bij >80%, kritiek bij >95%
• Schijf: waarschuwing bij >75%, kritiek bij >90%
• Load average: kritiek wanneer sustained load meer dan 2× het aantal CPU-cores bedraagt
• Service down: direct kritiek — gebruik een blackbox exporter of uptime check

Vermijd alert-moeheid: als je te veel alerts instelt die te snel afgaan, ga je ze negeren. Begin conservatief en verscher de drempels op basis van je baseline-data na een week of twee.

Praktische tips voor een solide monitoring-setup

Tot slot een aantal concrete aanbevelingen uit de praktijk:

• Monitor de monitoring zelf. Stel een alert in als Prometheus of Grafana niet meer bereikbaar is. Een monitoring-systeem dat zwijgt tijdens een storing is waardeloos.
• Gebruik retentiebeleid voor metrics. Prometheus slaat standaard 15 dagen aan data op. Overweeg langere retentie met Thanos of Cortex voor trendanalyse.
• Sluit je dashboards niet af voor het team. Maak Grafana toegankelijk voor developers — zichtbaarheid in productie verhoogt de kwaliteit van releases.
• Documenteer je alerts. Voeg aan elke alertregel een runbook-link toe. Dan weet de dienstdoende beheerder om drie uur 's nachts precies wat te doen.
• Test je alerts periodiek. Een alert die nooit afgaat, kan kapot zijn. Simuleer bewust een situatie die de alert zou moeten triggeren.

Conclusie

Server monitoring met Grafana, Prometheus, Loki en Node Exporter geeft je volledige observability over je infrastructuur: van real-time systeemmetrics tot doorzoekbare logs en proactieve alerts. De stack is open source, schaalbaar en goed geïntegreerd.

Begin klein: installeer de stack op één server, importeer een bestaand dashboard en stel drie alerts in. Bouw van daaruit verder. De investering van een middag setup-werk levert je terug in de vorm van nachten die je wél doorslaapt — omdat je weet dat Grafana je wakker maakt als dat nodig is.

De sleutel is niet de perfecte stack, maar een werkende stack die je daadwerkelijk gebruikt en onderhoudt.

```json

```