Sådan opsætter du en Grafana + Prometheus-overvågningsstak på din VPS (Docker Compose-guide)

Hvis du er i tvivl om, hvad Prometheus og Grafana overhovedet er, så læs vores artikel om Prometheus vs Grafana. Kender du allerede forskellen, så her er, hvordan du kører dem sammen.

Denne artikel er den praktiske del. Den installerer Prometheus, Grafana og Node Exporter på én VPS med Docker Compose, sætter HTTPS foran Grafana med Caddy, importerer Node Exporter Full-dashboardet (ID 1860) og viser, hvordan du henter metrikker fra en anden VPS over WireGuard.

Den oprindelige test i april 2026 kørte på Ubuntu 24.04 LTS med Docker Engine 27.x og Docker Compose v2.30. Versionerne, der er låst i konfigurationen nedenfor, er sidenhen opdateret til de aktuelt understøttede udgivelser. I den oprindelige test med fem hosts brugte hubben omkring 300 MB RAM i tomgang og 530 til 650 MB under løbende scraping.

TL;DR

• Hub-VPS'en kører Prometheus, Grafana og Node Exporter i én Compose-stak, med Caddy installeret på værten som reverse proxy.
• Prometheus og Grafana lytter kun på 127.0.0.1. Offentlig adgang går gennem Caddy med automatisk HTTPS.
• Tilføj flere servere ved at installere Node Exporter på hver enkelt og føje poster til prometheus.yml.
• WireGuard er den anbefalede netværkssti mellem hub og spokes. Privat netværk fungerer fint, når dine servere allerede deler et privat netværk.
• En VPS med 2 GB var nok til testen med fem hosts nedenfor, men betragt det som et udgangspunkt frem for en fast regel per antal hosts.

Det, du skal bygge

Sådan kommer opsætningen groft sagt til at se ud, når du er færdig.

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

Én hub-VPS rummer hele overvågningsstakken. Hver anden VPS, du vil overvåge, kører kun Node Exporter. Prometheus på hubben henter metrikker fra hver enkelt. Grafana visualiserer dem. Caddy står for HTTPS.

Det skal du bruge

Til præcis denne opsætning skal du bruge én Ubuntu-VPS som hub, et domæne og sudo-adgang.

• En VPS med mindst 2 GB RAM, der kører Ubuntu 24.04 LTS.
• Et domænenavn med en A-record, der peger på VPS'ens offentlige IP (for eksempel grafana.example.com). Nødvendigt for HTTPS.
• Root- eller sudo-adgang via SSH.

Igennem hele denne guide skal du erstatte grafana.example.com med det subdomæne, du reelt har peget mod din overvågnings-VPS. Brug det samme domæne i Grafana-miljøvariablen, DNS-tjekket og Caddyfile.

Vil du kun overvåge én server, og har du ikke brug for HTTPS endnu, kan du køre Compose-stakken på din nuværende VPS uden afsnittet om reverse proxy. Resten af guiden gælder stadig.

Trin 1: Klargøring af serveren

Log ind på hub-VPS'en via SSH med en bruger, der har sudo. Kør en systemopdatering først.

sudo apt update && sudo apt upgrade -y

Installer Docker Engine og Compose-pluginnet fra det officielle 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

Bekræft, at begge er installeret.

docker --version
docker compose version

Begge kommandoer bør returnere et versionsnummer uden fejl. De præcise versioner af Docker Engine og Compose afhænger af, hvad det officielle repository leverer, når du installerer dem.

sudo usermod -aG docker $USER

Log ud og ind igen, før du går videre, så det nye gruppemedlemskab træder i kraft. Gruppen docker giver reelt rettigheder på root-niveau, så tilføj kun betroede administratorer.

Konfigurer UFW, så SSH, HTTP og HTTPS er tilladt på overvågningshubben. Port 80 håndterer omdirigering fra HTTP til HTTPS samt ACME-validering. Selve Grafana bliver bag Caddy.

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

Åbn ikke port 3000, 9090 eller 9100 mod det offentlige internet. Overvågningstjenesterne lytter på 127.0.0.1 af en grund.

Trin 2: Compose-stakken

Opret en mappe til stakken og Prometheus-konfigurationen.

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

Skriv Compose-filen.

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

Skriv nu Prometheus-konfigurationen.

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

Opret en .env-fil med Grafana-adminadgangskoden. Brug en stærk adgangskode, og commit ikke denne fil til git.

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

Et par af flagene ovenfor fortjener hver en sætning.

• --web.listen-address=127.0.0.1:9090 får Prometheus til kun at lytte på værtens loopback-grænseflade. Dermed holdes port 9090 væk fra det offentlige netværk, mens Grafana og lokal administration stadig kan nå den.
• --web.enable-lifecycle aktiverer POST /-/reload, så du kan anvende ændringer i Prometheus-konfigurationen uden at genstarte containeren.
• pid: host, network_mode: host, bind-mountet af værtens rod og --path.rootfs=/host giver den containeriserede Node Exporter den værtskontekst, den har brug for, i stedet for kun at overvåge sit eget containermiljø.
• GF_USERS_ALLOW_SIGN_UP=false forhindrer besøgende i selv at oprette Grafana-konti. Det gør ikke Grafana privat: login-siden er stadig offentligt tilgængelig gennem Caddy.

Pro-tip: Vil du helst springe den manuelle installation over, tilbyder Cloudzy ét-kliks-udrulninger af Grafana og Prometheus . Prometheus-udrulningen kan også installere Node Exporter.

Trin 3: Første opstart og verifikation

Start stakken.

cd ~/monitoring
docker compose up -d

Vent et par sekunder, og tjek så, at alle tre containere kører.

docker compose ps

Alle tre tjenester bør vise status running.

Åbn en SSH-tunnel fra din bærbare for at tjekke Prometheus' targets-side.

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

Gå derefter til http://localhost:9090/targets i din browser. Du bør se to targets, begge med status UP:

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

Er en af dem DOWN, så spring til afsnittet Almindelige problemer. Fortsæt ikke, før begge er UP.

Luk tunnelen, når du er færdig med at tjekke targets. Udefra vil Prometheus kun være tilgængelig gennem denne SSH-tunnel. Næste trin eksponerer Grafana over HTTPS.

Trin 4: Reverse proxy med HTTPS ved hjælp af Caddy

Caddy er én enkelt binær fil og håndterer HTTPS automatisk. Til en reverse proxy med ét site er konfigurationen kortere end den tilsvarende Nginx-blok.

Installer Caddy fra det officielle 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

Bekræft før næste trin, at din DNS A-record for grafana.example.com peger på VPS'ens offentlige IP. Uden det fejler ACME-valideringen.

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

Rediger Caddyfile.

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

Genindlæs Caddy.

sudo systemctl reload caddy

Caddy henter og fornyer automatisk offentligt betroede TLS-certifikater via ACME, så snart domænet peger på din server, og port 80 og 443 kan nås. Gå til https://grafana.example.com i din browser: du bør se Grafanas login-side over en gyldig HTTPS-forbindelse. Log ind med admin og adgangskoden fra din .env-fil.

Trin 5: Tilføj Prometheus som datakilde, og importer dashboard 1860

Gå til følgende i Grafanas brugerflade: Forbindelser > Datakilder > Tilføj datakilde og vælg Prometheus.

Sæt URL'en til:

http://127.0.0.1:9090

I denne opsætning deler Grafana og Prometheus værtens netværk, mens Prometheus kun lytter på loopback. Klik på Save & test og bekræft, at Grafana kan forespørge Prometheus-API'en. Du bør se "Successfully queried the Prometheus API".

Importer nu dashboardet. Node Exporter Full (ID 1860 af rfmoz) er et udbredt community-dashboard til Node Exporter-metrikker. Det dækker CPU, hukommelse, disk-I/O, netværk, fildeskriptorer og hardwaretemperaturer, hvor værten leverer dem. Det har også variabler for job og instance, så det virker til hub-and-spoke uden ændringer.

Gå til Dashboards > Ny > Importer dashboard, indtast dashboard-ID 1860, vælg din Prometheus-datakilde, og importer det.

Dashboardet bør fyldes op, så snart dit Node Exporter-target er UP. Dashboard 1860 bruger til nogle paneler også metrikker fra de valgfrie collectors systemd og processes, så et enkelt tomt panel betyder ikke nødvendigvis, at targetet er i stykker.

Trin 6: Tilføj en anden VPS (hub-and-spoke)

Sørg for, at den private IP, du vil binde til, allerede findes på den anden VPS, før du starter Node Exporter. Bruger du WireGuard, så færdiggør WireGuard-opsætningen først.

Installer Docker på den anden VPS med Docker-installationsdelen fra trin 1, men åbn ikke port 80 eller 443 bare for overvågningens skyld. Kør derefter kun 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

Erstat 10.10.0.2 med denne servers private overvågnings-IP. Bruger du WireGuard, så brug dens WireGuard-IP; bruger du Cloudzys private netværk, så brug IP'en på VPS'ens private grænseflade. Er UFW allerede aktiv på denne VPS, så tillad kun overvågningshubben at nå Node Exporter. Hvis hubbens private IP for eksempel er 10.10.0.1:

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

Erstat 10.10.0.1 med hubbens faktiske private IP. Er UFW inaktiv, holder den eksplicitte --web.listen-address stadig Node Exporter væk fra den offentlige grænseflade, men andre maskiner, der kan nå det private netværk, kan også nå port 9100.

To gode muligheder for netværksstien mellem hub og spokes:

1. WireGuard-netværk. Hver VPS kobles på et WireGuard-netværk, og Prometheus scraper private IP'er. Efter den indledende WireGuard-opsætning er det den sikreste løsning. Vi tilbyder WireGuard som ét-kliks-udrulning og har desuden en eksisterende opsætningsguide om det.
2. Cloudzys private netværk. Cloudzy VPS-instanser i samme region får en privat grænseflade til øst-vest-trafik, så du kan scrape den adresse i stedet for at bygge en separat WireGuard-tunnel.

LÆS

Sådan konfigureres WireGuard VPN på VPS | Ubuntu vejledning

Når Node Exporter kører på den anden VPS og kan nås på dens private IP, skal du erstatte det eksisterende node-job i prometheus.yml på hubben med blokken nedenfor.

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

Genindlæs Prometheus uden at genstarte containeren.

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

Åbn SSH-tunnelen fra trin 3 igen, og gå til http://localhost:9090/targets. Det nye target bør vises som UP. Åbn Node Exporter Full-dashboardet, skift instance-variablen øverst til den nye server, og du bør se dens grafer.

Ressourceforbrug, og hvornår du bør opgradere

Tallene stammer fra den oprindelige test i april 2026 på en Ubuntu-VPS med 2 GB og fem overvågede hosts. Betragt dem som et udgangspunkt for denne arbejdsbyrde frem for en fast garanti for dimensionering med nyere udgivelser.

Opgrader, når hubben begynder at mangle hukommelse eller diskplads. Antallet af hosts alene er et dårligt pejlemærke, for seriekardinalitet, aktiverede collectors, scrape-interval og opbevaringstid ændrer alle forbruget. Til mere langsigtet central lagring understøtter Prometheus integrationer med fjernlagring. VictoriaMetrics er en Prometheus-kompatibel mulighed.

Almindelige problemer

De syv problemer, der oftest dukker op, med løsninger.

1. Prometheus kan nås fra det offentlige internet. En bar portmapping på 9090:9090 eksponerer Prometheus for hele verden. Løsning: behold --web.listen-address=127.0.0.1:9090 i Prometheus-kommandoen som vist ovenfor. Så lytter Prometheus kun på værtens loopback-grænseflade.
2. Grafana-datakilden kan ikke nå Prometheus. Denne stak bruger værtsnetværk, så Grafana kan nå Prometheus på http://127.0.0.1:9090. Tjek, at Prometheus kører og stadig lytter på loopback.
3. Node Exporter-dashboardet viser "No data". Tre sædvanlige årsager. (a) Prometheus scraper ikke targetet. Tjek /targets. (b) job-labelen i dashboardvariablen matcher ikke job_name i scrape-konfigurationen. (c) En firewall blokerer port 9100 mellem hub og target.
4. Grafanas adminadgangskode er stadig admin/admin i produktion. Indstil GF_SECURITY_ADMIN_PASSWORD fra en .env-fil før første opstart. Har du glemt det, så skift adgangskoden ved første login, og slå tilmelding fra.
5. Caddy melder "ACME challenge failed". DNS A-recorden er endnu ikke propageret, eller port 80 er blokeret. Kør ufw allow 80,443/tcp, vent på DNS, og kør sudo systemctl reload caddy. Brug dig +short til at bekræfte propageringen.
6. Prometheus' disk fyldes op. Labels med høj kardinalitet eller korte scrape-intervaller på mange hosts kan hurtigt fylde volumenet. Hold øje med prometheus_tsdb_head_series og volumenstørrelsen. Afhjælpning: slå ubrugte Node Exporter-collectors fra, forlæng scrape_interval til 30s, eller forkort opbevaringstiden.
7. Rettighedsfejl ved bind-mounts. Monterer du en værtsmappe i stedet for et navngivet volumen, skal containerens UID (65534 for Prometheus, 472 for Grafana) have skriveadgang. Navngivne volumener, som i Compose-filen ovenfor, undgår det.

Hvornår denne stak er overkill

Vil du bare have en advarsel, når en URL holder op med at svare, er denne stak overkill. Uptime Kuma er et langt lettere valg, hvis du blot har brug for grundlæggende oppetidstjek.

Ofte stillede spørgsmål

Hvad er forskellen på Prometheus og Grafana?

Prometheus er en tidsseriedatabase: den henter metrikker fra de konfigurerede targets med det interval, du vælger, gemmer dem på disken og besvarer PromQL-forespørgsler. Grafana er et visualiseringslag, der kobler sig på Prometheus (og mange andre datakilder) og tegner dashboards. Næsten altid vil du have begge: Prometheus til at indsamle og gemme, Grafana til at vise.

Hvor meget RAM kræver en opsætning med Prometheus + Grafana?

En overvågningshub, der kører Prometheus, Grafana, Node Exporter og en reverse proxy på én VPS, bruger omkring 300 MB RAM i tomgang og 530 til 650 MB, når den aktivt scraper fem hosts med 15 sekunders interval.

Kan jeg overvåge flere servere med én Grafana-instans?

Ja. Standardmønsteret er hub-and-spoke. Én Prometheus-instans på en hub-VPS scraper den Node Exporter, der kører på hver anden server, du vil overvåge. Grafana på hubben forespørger blot den ene Prometheus. Node Exporter Full-dashboardet (ID 1860) understøtter en instance-variabel, så du kan skifte mellem servere fra ét dashboard.

Hvilket Grafana-dashboard er bedst til Node Exporter?

Til denne opsætning er Node Exporter Full (dashboard-ID 1860 af rfmoz) et stærkt standardvalg. Det dækker de vigtigste host-metrikker fra Node Exporter og understøtter variablerne job og instance til overvågning af flere servere. Nogle paneler afhænger af valgfrie Node Exporter-collectors, så et enkelt tomt panel betyder ikke nødvendigvis, at scrape-targetet er i stykker.

Hvordan eksponerer jeg Grafana over HTTPS?

Kør Grafana bundet til 127.0.0.1:3000, og sæt en reverse proxy foran, som håndterer HTTPS. Caddy er den enkleste mulighed: en Caddyfile på fire linjer med reverse_proxy 127.0.0.1:3000 og en domæneblok klarer det hele, inklusive automatisk håndtering af TLS-certifikater.

Er Prometheus + Grafana gratis til kommerciel brug?

Prometheus er licenseret under Apache 2.0. Grafana OSS er AGPLv3. Intern og kommerciel brug af uændret Grafana OSS er tilladt, men at ændre eller distribuere den, eller udbyde en ændret version over et netværk, kan udløse pligt til at dele kildekode efter AGPL. Grafana Enterprise og Grafana Cloud har separate kommercielle vilkår.

Hvornår bør jeg skifte fra Prometheus til VictoriaMetrics?

Overvej VictoriaMetrics, når længere opbevaring, høj seriekardinalitet eller flere Prometheus-instanser gør det sværere at drive den lokale Prometheus-TSDB inden for din servers hukommelses- og diskbudget. VictoriaMetrics kan modtage Prometheus-data og udstille en Prometheus-kompatibel forespørgsels-API, så den kan fungere som langtidslagring eller som metrik-backend for Grafana. Benchmark den mod din egen arbejdsbyrde i stedet for at skifte ved en fast RAM-grænse.