---
title: "Caveman plan — Beelink naar Ubuntu Scrum4Me server"
status: draft
audience: [maintainer, operator]
language: nl
last_updated: 2026-05-09
---

# Caveman plan — Beelink naar Ubuntu Scrum4Me server

## Doel

Zet de Beelink mini-PC om naar een dual-boot machine waarop **Ubuntu Server 24.04 LTS** de standaard server-boot is. Windows blijft bestaan als fallback, maar Scrum4Me draait op Ubuntu.

Doelopstelling:

```text
Beelink mini-PC
├─ Windows fallback
└─ Ubuntu Server 24.04 LTS default
   ├─ Docker Engine
   ├─ Postgres
   ├─ Scrum4Me webserver
   ├─ worker-idea
   ├─ worker-implementation
   └─ worker-orchestrator
```

## Hardware

Bekende specs:

| Onderdeel | Waarde |
|---|---|
| Merk | Beelink |
| CPU | Intel Core i5-12450H |
| CPU boost | Tot 4,4 GHz |
| RAM | 32 GB DDR4 |
| Opslag | 1 TB |
| GPU | Intel integrated graphics |
| Vorm | Mini-PC |

Conclusie: geschikt voor Scrum4Me als single-user/small-team server, mits implementation-concurrency op 1 blijft en resource limits strak staan.

## Caveman Regels

- Geen Ubuntu Desktop installeren.
- Geen GPU-driver installeren tenzij beeld echt kapot is.
- Geen Docker Desktop.
- Geen Postgres-poort naar internet.
- Geen Docker socket mounten in workercontainers.
- Geen repos, caches of worktrees op de Windows-partitie.
- Alles onder `/srv/scrum4me`.
- Eerst één worker werkend krijgen, daarna pas drie.
- Eerst via lokaal IP testen, daarna pas domein/TLS.
- Ubuntu wordt default boot; Windows is fallback.

## Waarom Geen Drivergedoe Verwacht Wordt

De CPU heeft Intel integrated graphics. Ubuntu Server heeft geen desktop nodig. Intel geeft aan dat de meeste Linux-distributies Intel graphics drivers al meeleveren. Voor deze machine verwacht je de kernel-driver `i915`.

Na installatie alleen checken:

```bash
lspci -k | grep -EA3 'VGA|3D|Display'
lsmod | grep i915
```

Als `i915` zichtbaar is: klaar. Niet verder aan sleutelen.

## Fase 0 — Voorbereiding In Windows

1. Maak backup van belangrijke Windows-data.
2. Sla BitLocker recovery key op als BitLocker aan staat.
3. Zet Windows Fast Startup uit:
   - Control Panel
   - Power Options
   - Choose what the power buttons do
   - Turn off fast startup
4. Maak vrije ruimte:
   - Open Disk Management.
   - Shrink `C:`.
   - Laat ongeveer `600 GB` unallocated voor Ubuntu.

Aanbevolen diskverdeling:

```text
Windows:          250-300 GB
Ubuntu /:         120 GB
/srv/scrum4me:    rest van vrije ruimte
swapfile:         16 GB
EFI:              bestaande EFI behouden
```

## Fase 1 — Ubuntu USB Maken

1. Download Ubuntu Server 24.04 LTS amd64.
2. Maak USB-stick met Rufus of Balena Etcher.
3. Sluit ethernet aan op de Beelink.
4. Boot van USB.

Veelvoorkomende Beelink toetsen:

```text
Boot menu: F7
BIOS:      Del
```

BIOS-checks:

```text
UEFI boot: aan
Secure Boot: mag aan blijven, maar uitzetten als install gedoe geeft
Power on after power loss: aan
Ubuntu later als eerste boot entry
```

## Fase 2 — Ubuntu Installeren

Kies tijdens installatie:

```text
Install Ubuntu Server
OpenSSH server: YES
Desktop: NO
Storage: Custom layout
```

Storage:

```text
Bestaande EFI partition:
  mount: /boot/efi
  formatteren: NEE

Nieuwe ext4 partition 120 GB:
  mount: /

Nieuwe ext4 partition rest:
  mount: /srv/scrum4me
```

Niet kiezen:

```text
Use entire disk
```

Dat zou Windows verwijderen.

## Fase 3 — Eerste Boot

Login op Ubuntu.

```bash
sudo apt update
sudo apt upgrade -y
sudo reboot
```

Na reboot:

```bash
sudo hostnamectl set-hostname scrum4me-server
ip a
```

Zet in je router een DHCP reservation voor het IP-adres. Dat is simpeler dan handmatige netwerkconfiguratie.

## Fase 4 — Server Niet Laten Slapen

```bash
sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target
```

In BIOS:

```text
Power on after power loss: ON
Sleep: OFF als optie bestaat
Boot order: Ubuntu eerst
```

## Fase 5 — Basis Tools

```bash
sudo apt install -y git curl ca-certificates gnupg htop iotop ufw fail2ban unzip jq
```

Firewall:

```bash
sudo ufw allow OpenSSH
sudo ufw allow 80
sudo ufw allow 443
sudo ufw enable
sudo ufw status
```

Let op: Docker kan gepubliceerde containerpoorten buiten gewone `ufw`-verwachtingen om bereikbaar maken. Publiceer straks alleen reverse proxy poorten naar buiten.

## Fase 6 — Docker Engine Installeren

Gebruik Docker Engine native op Ubuntu. Geen Docker Desktop.

```bash
sudo apt update
sudo apt install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

```bash
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

```bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker $USER
sudo reboot
```

Na reboot:

```bash
docker run hello-world
docker compose version
```

## Fase 7 — Scrum4Me Directories

```bash
sudo mkdir -p /srv/scrum4me/{postgres,repos,worker-cache,worker-logs,worker-state,backups,compose,caddy}
sudo chown -R $USER:$USER /srv/scrum4me
```

Doelstructuur:

```text
/srv/scrum4me/postgres       database data
/srv/scrum4me/repos          cloned GitHub repos / mirrors
/srv/scrum4me/worker-cache   npm/git/cache
/srv/scrum4me/worker-logs    worker logs
/srv/scrum4me/worker-state   worker state
/srv/scrum4me/backups        local backup staging
/srv/scrum4me/compose        docker compose files
/srv/scrum4me/caddy          reverse proxy config
```

## Fase 8 — Services

Einddoel:

```text
postgres
scrum4me-web
worker-idea
worker-implementation
worker-orchestrator
caddy
```

Aanbevolen resource limits voor 32 GB RAM:

| Service | CPU limit | Memory limit | Opmerking |
|---|---:|---:|---|
| `postgres` | 2 CPU | 3-4 GB | Lokale DB |
| `scrum4me-web` | 2 CPU | 2-3 GB | Next.js runtime |
| `worker-idea` | 2 CPU | 4 GB | Grill, plan, chat |
| `worker-implementation` | 4-5 CPU | 10-12 GB | Zwaarste worker |
| `worker-orchestrator` | 2-3 CPU | 5-6 GB | PR review, CI triage, conflicts |
| `caddy` of `nginx` | 0.25 CPU | 256 MB | Reverse proxy |

Laat 5-7 GB vrij voor Ubuntu, Docker overhead, filesystem cache en pieken.

## Fase 9 — Tokens en Secrets

Maak aparte tokens per rol:

```text
SCRUM4ME_TOKEN_IDEA
SCRUM4ME_TOKEN_IMPLEMENTATION
SCRUM4ME_TOKEN_ORCHESTRATOR

GH_TOKEN_IDEA
GH_TOKEN_IMPLEMENTATION
GH_TOKEN_ORCHESTRATOR

CLAUDE_CODE_OAUTH_TOKEN_IDEA
CLAUDE_CODE_OAUTH_TOKEN_IMPLEMENTATION
CLAUDE_CODE_OAUTH_TOKEN_ORCHESTRATOR
```

Tokenbeleid:

| Token | Rechten |
|---|---|
| Idea | Read-only waar mogelijk, markdown/status updates via Scrum4Me |
| Implementation | GitHub contents RW + pull requests RW |
| Orchestrator | PR RW, contents RW alleen voor conflict/repair |

Bestandsrechten:

```bash
chmod 600 /srv/scrum4me/compose/*.env
```

Geen secrets in git.

## Fase 10 — Backups

Minimum:

```text
Elke nacht pg_dump
Elke nacht backup van /srv/scrum4me/compose
Offsite kopie naar cloud, NAS of externe disk
Backup restore maandelijks testen
```

Lokale backup alleen is onvoldoende. Als de SSD stuk gaat, is alles weg.

## Fase 11 — Monitoring

Simpel beginnen:

```bash
docker ps
docker stats
htop
iotop
df -h
du -sh /srv/scrum4me/*
journalctl -u docker --no-pager -n 100
```

Dagelijkse health checklist:

```text
Docker containers up?
Disk < 80% vol?
Backups gelukt?
Workers online?
Postgres bereikbaar?
Webserver bereikbaar via HTTPS?
Geen runaway logs?
```

## Fase 12 — Uitrolvolgorde

Niet alles tegelijk.

1. Ubuntu werkt.
2. SSH werkt.
3. Docker werkt.
4. Caddy/nginx testpagina werkt.
5. Postgres container werkt.
6. Scrum4Me webserver werkt lokaal.
7. Scrum4Me webserver werkt via HTTPS.
8. Eén worker werkt: `worker-idea`.
9. Tweede worker werkt: `worker-implementation`.
10. Derde worker werkt: `worker-orchestrator`.
11. Role-aware queue claiming aanzetten.
12. Backups testen.

## Eerste Smoke Test

Na installatie:

```bash
hostnamectl
free -h
df -h
lscpu
docker version
docker compose version
docker run hello-world
lspci -k | grep -EA3 'VGA|3D|Display'
lsmod | grep i915
```

Verwacht:

```text
Ubuntu 24.04 LTS
~32 GB RAM zichtbaar
Docker werkt
1 TB disk verdeeld zoals gepland
i915 zichtbaar voor Intel integrated graphics
```

## Foutscenario's

### Geen beeld na Ubuntu install

Eerst:

```text
Gebruik HDMI-poort 1
Gebruik andere kabel
Boot recovery mode
Probeer tijdelijk Secure Boot uit
```

Niet meteen drivers installeren.

### Windows start direct, geen Ubuntu menu

BIOS boot order aanpassen:

```text
Ubuntu boven Windows Boot Manager
```

### Docker permission denied

```bash
groups
```

Als `docker` ontbreekt:

```bash
sudo usermod -aG docker $USER
sudo reboot
```

### Server wordt traag

Check:

```bash
docker stats
free -h
htop
iotop
```

Eerste maatregel:

```text
implementation-worker alleen laten draaien
orchestrator zware builds verbieden
worker memory limits verlagen
```

## Bronnen

- Ubuntu Server requirements: <https://ubuntu.com/server/docs/reference/installation/system-requirements/>
- Ubuntu Server install docs: <https://ubuntu.com/server/docs/how-to/installation/>
- Intel Linux graphics guidance: <https://www.intel.com/content/www/us/en/support/articles/000005520/graphics.html>
- Docker Engine on Ubuntu: <https://docs.docker.com/installation/ubuntulinux/>
- Next.js self-hosting: <https://nextjs.org/docs/app/guides/self-hosting>
