Docker Guide (modulaire 4-componenten stack)
Deze handleiding beschrijft hoe je de vier componenten van het register als losse Docker images/services bouwt en draait.
Snelle releaseflow: zie ook RELEASE.md.
Tags: lees eerst
docs/DOCKER_RELEASE.md. Dat is sinds 2026-07-29 het geldende beleid over welke images we publiceren en hoe we ze taggen: kale component-semver (0.6.0) pluslatest, versie-tag onveranderlijk, altijdlinux/amd64. De tagsv06.00.01die je hieronder in de voorbeelden ziet staan volgen een vervallen schema — lees ze als "een willekeurig versienummer", niet als conventie.
Vier componenten
De stack bestaat uit vier onafhankelijke deelservices:
| Component | Image / service | Doel | Standaard poort |
|---|---|---|---|
| DB | postgres:16-alpine |
PostgreSQL database (data-opslag) | 5433 → 5432 |
| Filestore | minio/minio:latest |
MinIO S3-compatibele objectopslag (IDE-bestanden, modellen) | 9000 (API), 9001 (console) |
| BE (API) | markwestbroek/bitemp-go-api |
Go backend — REST, GraphQL, schema-API | 8082 → 8080 |
| FE | markwestbroek/bitemp-viz-frontend |
Vite/React frontend via nginx | 8083 → 80 |
Doel:
- Elk component eenvoudig apart vervangen/upgraden.
- Data behouden in aparte database- en filestore-volumes.
- Geen afhankelijkheid van één groot docker compose bestand.
Beschikbare Docker-varianten in deze repo
| Compose-bestand | Bevat | Gebruik |
|---|---|---|
docker-compose.yml |
DB + Filestore + BE (alles-in-één) | Lokale ontwikkeling |
docker-compose.devloop.yml |
DB + Filestore + BE (devloop/self-rebuild) | Ontwikkel/devloop-variant |
docker-compose.split.yml |
DB + Filestore + BE + FE (4 services) | Complete stack met aparte FE-image |
docker-compose.db-only.yml |
Alleen DB | Dockge/server: DB als losse stack |
docker-compose.filestore-only.yml |
Alleen Filestore (MinIO + init) | Dockge/server: filestore als losse stack |
docker-compose.api-only.yml |
Alleen BE (API) | Dockge/server: API als losse stack |
docker-compose.frontend-only.yml |
Alleen FE | FE tegen externe API |
deploy/vps/docker-compose.vps.yml |
DB + Filestore + BE + FE (+ OpenFTV via profile) | Publieke VPS achter Caddy/HTTPS — zie docs/VPS_DEPLOYMENT.md |
Bij de split-variant horen ook:
Dockerfile.api— bouwt alleen de Go-backend.Dockerfile.frontend— bouwt alleen de Vite/nginx-frontend.deploy/frontend/default.conf.template(voorheennginx.frontend.conf) — reverse proxy zodat frontend en API via dezelfde origin werken. Een template:API_UPSTREAM,FRAME_ANCESTORSenNGINX_RESOLVERworden bij het starten ingevuld;deploy/frontend/15-api-upstream.envshcontroleert de upstream. Defaults = het oude gedrag.
Aanbevolen stack-combinaties
Lokaal ontwikkelen (alles in één):
docker-compose.yml
Server/Dockge (3 losse stacks):
docker-compose.db-only.yml # stack 1: DB
docker-compose.filestore-only.yml # stack 2: Filestore
docker-compose.api-only.yml # stack 3: API
Alle drie draaien op het gedeelde bitemp-net netwerk.
Complete split (4 services in 1 compose):
docker-compose.split.yml # DB + Filestore + BE + FE
1. Vereisten
- Docker Engine op je machine of server.
- Een bereikbare PostgreSQL database (lokaal, remote of aparte container).
- Correcte PostgreSQL connectiestring in
DATABASE_URL. - Een bereikbare MinIO filestore (lokaal, remote of aparte container) voor bestandsopslag.
Voorbeelden van host in DATABASE_URL:
- PostgreSQL op Windows host vanuit container:
host.docker.internal - PostgreSQL op andere server: echte hostnaam of IP
- PostgreSQL in andere container op zelfde network: containernaam
1.1 Configuratie via .env.docker (aanrader)
Voor Dockge/compose is het netter om credentials en tags in een env-bestand te zetten.
Bestanden:
.env.docker.example(template).env.docker(jouw echte waarden, lokaal op server)
Maak je lokale env-bestand:
cp .env.docker.example .env.docker
Pas daarna minimaal aan in .env.docker:
POSTGRES_PASSWORDADMIN_DROP_PASSWORD- eventueel
API_IMAGE
1.1.1 Poorten aanpassen als lokale dev ook draait
De standaard host-poorten (API_PORT=8082, FRONTEND_PORT=8083) kunnen conflicteren als je tegelijk lokaal ontwikkelt (Go dev server op 8082, Vite op 5173/5174).
Zet in .env.docker andere host-poorten:
API_PORT=8085
FRONTEND_PORT=8086
De interne containerpoorten veranderen niet (API: 8080, Frontend: 80). Alleen de host-side mapping schuift op.
1.1.2 MinIO bucket-scheiding (dev vs. Docker)
Lokale dev en een Docker-instantie die dezelfde MinIO gebruiken, landen standaard in dezelfde bucket. Om te voorkomen dat testdata en dev-bestanden door elkaar lopen:
- Lokaal
.env:MINIO_BUCKET=ide-bestanden-dev .env.docker:MINIO_BUCKET=ide-bestanden-docker(ofide-bestandenvoor productie)
De API maakt de bucket automatisch aan bij startup als die nog niet bestaat. Geen verdere configuratie nodig.
De MinIO console (http://localhost:9001) is beschikbaar met de credentials uit MINIO_ACCESS_KEY / MINIO_SECRET_KEY (standaard: minioadmin / minioadmin).
1.2 Eerste deployment op nieuwe omgeving (database automatisch laten aanmaken)
De API kan bij startup optioneel zelf de database aanmaken als die nog niet bestaat.
Zet hiervoor in .env.docker:
AUTO_CREATE_DATABASE=true
Optioneel (aanrader in productie): geef een aparte admin connectie op met CREATEDB-rechten:
DATABASE_ADMIN_URL=postgres://postgres:<password>@<host>:5432/postgres?sslmode=disable
Gedrag:
- Als
AUTO_CREATE_DATABASE=true: app checkt of de database uitDATABASE_URLbestaat. - Bestaat die niet, dan probeert de app
CREATE DATABASEuit te voeren. - Zonder voldoende rechten krijg je een duidelijke foutmelding bij startup.
Voor bestaande omgevingen kun je dit uit laten (AUTO_CREATE_DATABASE=false of weglaten).
2. Image bouwen
Ga naar de map bitemporal_go_API_v05 en build de image.
De Dockerfile bouwt nu zelf:
- de Go API binary
- de React/Vite frontend naar statische assets in
web/react
Dus je hoeft vooraf lokaal geen npm run build meer te doen.
PowerShell
$commit = (git rev-parse --short HEAD)
$bt = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
docker build --no-cache --build-arg COMMIT=$commit --build-arg BUILD_TIME=$bt -t bitemp-go-api:v06.00.01 .
Bash
docker build --no-cache \
--build-arg COMMIT=$(git rev-parse --short HEAD) \
--build-arg BUILD_TIME="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-t bitemp-go-api:v06.00.01 .
Opmerking:
- De runtime-image bevat geen Node/Vite dev server.
- Alleen de Go binary en de benodigde statische
/vizassets worden meegenomen. - Build opnieuw na relevante frontend- of Dockerfile-wijzigingen en push een nieuwe tag.
2A. Frontend + backend als twee losse exporteerbare images
Als je backend en frontend los wilt uitrollen of als aparte .tar wilt exporteren, gebruik dan de nieuwe split-variant:
- compose:
docker-compose.split.yml - backend Dockerfile:
Dockerfile.api - frontend Dockerfile:
Dockerfile.frontend
Builden
docker compose -f docker-compose.split.yml build
Starten
docker compose -f docker-compose.split.yml up -d
Standaard draait dan:
- frontend op
http://localhost:8083/viz/react/ - API direct op
http://localhost:8082/
De frontend-image serveert alleen de Vite-build via nginx. Alle API-calls naar /api, /full, /registratie, /docs, /swagger, /redoc, enz. worden doorgeproxied naar de backend-container, zodat window.location.origin gewoon blijft werken.
Los exporteren als bestanden
docker save -o bitemp-go-api_v06-split.tar bitemp-go-api:v06-split
docker save -o bitemp-viz-frontend_v06-split.tar bitemp-viz-frontend:v06-split
Weer inladen op een andere machine
docker load -i bitemp-go-api_v06-split.tar
docker load -i bitemp-viz-frontend_v06-split.tar
Gebruik
FRONTEND_PORT,API_PORTenPG_PORTin.env.dockerals je deze stack naast een bestaande deployment wilt laten draaien.
2B. Alleen de frontend (tegen een externe API)
Als de API al ergens draait en je alleen de frontend wilt deployen:
# Bouw met de URL van de externe API
docker compose -f docker-compose.frontend-only.yml build \
--build-arg VITE_API_BASE_URL=https://api.example.com
# Start
docker compose -f docker-compose.frontend-only.yml up -d
De frontend draait dan op http://localhost:8083/viz/react/. Zorg dat VITE_API_BASE_URL naar je API wijst (inclusief protocol en poort).
2C. Selectieve domeinbuild (deelverzameling van modellen)
Het register bevat meerdere gegenereerde domeinen. Met het selectieve-build script (scripts/selectieve-build.ps1) kun je de API compileren met alleen de gewenste domeinen. De domeinen abuvwxy en register worden altijd meegenomen.
Optionele domeinen: np_loc, cg, configuratie, financieel.
Voorbeelden
# Alleen abuvwxy + register + np_loc
.\scripts\selectieve-build.ps1 -Include np_loc
# Alles behalve financieel en cg
.\scripts\selectieve-build.ps1 -Exclude financieel,cg
# Met Docker image erbij
.\scripts\selectieve-build.ps1 -Include np_loc -DockerBuild -DockerTag bitemp-api:np-loc
Hoe werkt het?
- Verplaatst de
model/{prefix}_*.gobestanden van uitgesloten domeinen naar_temp/model_exclude/. - Commentarieert de bijbehorende
init...()calls uit inmetaregistry_plumbing.go. - Voert
go build ./...uit (en optioneeldocker build). - Herstelt altijd alle bestanden naar de originele staat (ook bij fouten).
Routes, handlers en DB-setup zijn volledig generiek (gedreven door de MetaRegistry), dus die hoeven niet aangepast — alleen de model-bestanden en de init-registratie tellen.
3. API starten (zonder compose)
Belangrijk: vervang placeholders in DATABASE_URL door echte waarden.
Voorbeeld: DB op Windows host
docker run -d --name bitemp-go-api-v06 \
-p 8082:8080 \
-e DATABASE_URL="postgres://postgres:1234@host.docker.internal:5432/bitemp_go_db_v06?sslmode=disable" \
-e APP_ENV=production \
-e GIN_MODE=release \
-e ALLOW_DROP_TABLES=false \
-e ADMIN_DROP_PASSWORD="kies-een-sterk-geheim" \
--restart unless-stopped \
bitemp-go-api:v06.00.01
In 1 regeL:
docker run -d --name bitemp-go-api-v06 -p 8082:8080 -e DATABASE_URL="postgres://postgres:1234@host.docker.internal:5432/bitemp_go_db_v06?sslmode=disable" -e APP_ENV=production -e GIN_MODE=release -e ALLOW_DROP_TABLES=false -e ADMIN_DROP_PASSWORD="1234" --restart unless-stopped bitemp-go-api:v06.00.01
of met backticks:
docker run -d --name bitemp-go-api-v06 `
-p 8082:8080 `
-e DATABASE_URL="postgres://postgres:1234@host.docker.internal:5432/bitemp_go_db_v06?sslmode=disable" `
-e APP_ENV=production `
-e GIN_MODE=release `
-e ALLOW_DROP_TABLES=false `
-e ADMIN_DROP_PASSWORD="1234" `
--restart unless-stopped `
bitemp-go-api:v06.00.01
Voorbeeld: DB op aparte server
docker run -d --name bitemp-go-api-v06 \
-p 8082:8080 \
-e DATABASE_URL="postgres://USER:PASSWORD@10.0.0.25:5432/DB_NAME?sslmode=require" \
-e APP_ENV=production \
-e GIN_MODE=release \
-e ALLOW_DROP_TABLES=false \
-e ADMIN_DROP_PASSWORD="kies-een-sterk-geheim" \
--restart unless-stopped \
bitemp-go-api:v06.00.01
4. Handige controlecommando's
# Lopende containers
docker ps
# Ook gestopte containers
docker ps -a
# Logs
docker logs --tail 200 bitemp-go-api-v06
# API versie-endpoint
curl http://localhost:8082/version
5. Nieuwe API versie uitrollen zonder dataverlies
Omdat de database apart staat, kun je de API-container veilig vervangen.
# 1) Nieuwe image bouwen (voorbeeld tag v06.00.01)
$commit = (git rev-parse --short HEAD)
$bt = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
docker build --no-cache --build-arg COMMIT=$commit --build-arg BUILD_TIME=$bt -t bitemp-go-api:v06.00.01 .
# 2) Oude API stoppen/verwijderen
docker rm -f bitemp-go-api-v06
# 3) Nieuwe API starten met exact dezelfde DATABASE_URL
docker run -d --name bitemp-go-api-v06 \
-p 8082:8080 \
-e DATABASE_URL="postgres://..." \
-e APP_ENV=production \
-e GIN_MODE=release \
-e ALLOW_DROP_TABLES=false \
-e ADMIN_DROP_PASSWORD="kies-een-sterk-geheim" \
--restart unless-stopped \
bitemp-go-api:v06.00.01
Bijv.
docker run -d --name bitemp-go-api-v06
-p 8082:8080
-e DATABASE_URL="postgres://postgres:1234@host.docker.internal:5432/bitemp_go_db_v06?sslmode=disable"
-e APP_ENV=production
-e GIN_MODE=release
-e ALLOW_DROP_TABLES=false
-e ADMIN_DROP_PASSWORD="1234"
--restart unless-stopped
bitemp-go-api:v06.00.01
6. Image delen zonder registry (bestand)
Op bronmachine
docker save -o bitemp-go-api_v06.00.01.tar bitemp-go-api:v06.00.01
Kopieer bitemp-go-api_v06.00.01.tar naar de doelmachine.
NAS: \TRUENAS\share\Docker\Bitemporal\bitemp-go-api_v06.00.01.tar
Op doelmachine
docker load -i bitemp-go-api_v06.00.01.tar
docker run -d --name bitemp-go-api-v06 -p 8082:8080 -e DATABASE_URL="postgres://USER:PASSWORD@DB_HOST:5432/DB_NAME?sslmode=require" -e APP_ENV=production -e GIN_MODE=release -e ALLOW_DROP_TABLES=false -e ADMIN_DROP_PASSWORD="sterk-geheim" --restart unless-stopped bitemp-go-api:v06.00.01
bijv.:
docker run -d --name bitemp-go-api-v06
-p 8082:8080
-e DATABASE_URL="postgres://postgres:1234@host.docker.internal:5432/bitemp_go_db_v06?sslmode=disable"
-e APP_ENV=production
-e GIN_MODE=release
-e ALLOW_DROP_TABLES=false
-e ADMIN_DROP_PASSWORD="kies-een-sterk-geheim"
--restart unless-stopped
bitemp-go-api:v06.00.01
7. Image delen via registry (aanrader)
Tag en push
docker tag bitemp-go-api:v06.00.01 <registry-user>/bitemp-go-api:v06.00.01
docker push <registry-user>/bitemp-go-api:v06.00.01
Voorbeeld repository:
markwestbroek/bitemp-go-api
docker tag bitemp-go-api:v06.00.01 markwestbroek/bitemp-go-api:v06.00.01
docker push markwestbroek/bitemp-go-api:v06.00.01
``
### Op server pull en run
```powershell
docker pull <registry-user>/bitemp-go-api:v06.00.01
docker rm -f bitemp-go-api-v06
docker run -d --name bitemp-go-api-v06 -p 8082:8080 -e DATABASE_URL="postgres://..." -e APP_ENV=production -e GIN_MODE=release -e ALLOW_DROP_TABLES=false -e ADMIN_DROP_PASSWORD="kies-een-sterk-geheim" --restart unless-stopped <registry-user>/bitemp-go-api:v06.00.01
8. TrueNAS en Dockge (aanbevolen op server)
Als je TrueNAS gebruikt met Dockge, gebruik dan 3 aparte stacks:
- DB stack:
docker-compose.db-only.yml - Filestore stack:
docker-compose.filestore-only.yml - API stack:
docker-compose.api-only.yml
Zo blijven database en filestore zelfstandig draaien en kun je de API los upgraden.
8.1 Eenmalig: env-bestand klaarzetten
cp .env.docker.example .env.docker
Pas secrets aan in .env.docker voordat je deployt. Let op de MinIO-variabelen:
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=kies-een-sterk-geheim
MINIO_BUCKET=ide-bestanden
MINIO_ENDPOINT=bitemp-minio-v06:9000
8.2 Database stack deployen (eerst)
Gebruik bestand:
docker-compose.db-only.yml
docker compose -f docker-compose.db-only.yml up -d
Controle:
docker logs --tail 100 bitemp-postgres-v06
docker exec -it bitemp-postgres-v06 pg_isready -U postgres -d bitemp_go_db_v06
8.3 Filestore stack deployen (daarna)
Gebruik bestand:
docker-compose.filestore-only.yml
docker compose -f docker-compose.filestore-only.yml up -d
Controle:
docker logs --tail 50 bitemp-minio-v06
# MinIO console openen in browser:
# http://<server-ip>:9001 (login: MINIO_ACCESS_KEY / MINIO_SECRET_KEY)
De init-container maakt automatisch de bucket ide-bestanden aan (of bevestigt dat deze al bestaat).
8.4 API stack deployen (als laatste)
Gebruik bestand:
docker-compose.api-only.yml
docker compose -f docker-compose.api-only.yml up -d
Belangrijk:
- In deze opzet gebruikt de API als DB hostnaam:
bitemp-postgres-v06. - Dat werkt omdat beide stacks op dezelfde named network
bitemp-netzitten. - De network
bitemp-networdt automatisch aangemaakt door compose (als die nog niet bestaat). - Beide stacks lezen variabelen uit
.env.docker.
8.5 Updaten in Dockge
DB upgraden:
- Pas
image: postgres:...aan in de DB stack. - Redeploy de DB stack.
Filestore upgraden:
- Pas
image: minio/minio:...aan in de Filestore stack. - Redeploy de Filestore stack. Data blijft staan in het volume.
API upgraden:
- Push nieuwe image tag (bijv.
v06.00.01). - Pas
image: markwestbroek/bitemp-go-api:v06.00.01aan in de API stack. - Redeploy de API stack.
Voordeel:
- Elk component is onafhankelijk vervangbaar.
- Data blijft staan in de volumes van DB en Filestore stacks.
- Beheer via UI met behoud van reproduceerbare compose-config.
9. Veelvoorkomende fouten
Fout: containernaam bestaat al
Melding:
Conflict. The container name "/bitemp-go-api-v06" is already in use
Oplossing:
docker rm -f bitemp-go-api-v06
Fout: lookup DB_HOST ... no such host
Oorzaak:
DB_HOSTis placeholder en niet vervangen.
Oplossing:
- Gebruik een echte host in
DATABASE_URL. - Voor Windows host vanuit container vaak:
host.docker.internal.
10. Security advies
Gebruik in productie:
APP_ENV=productionGIN_MODE=releaseALLOW_DROP_TABLES=false- Sterk
ADMIN_DROP_PASSWORD - Sterke DB credentials
sslmode=require(of strenger) waar mogelijk- Sterke MinIO credentials (
MINIO_ACCESS_KEY/MINIO_SECRET_KEY) - MinIO console-poort (9001) niet publiek exposen tenzij nodig
Extra:
- Commit geen
.env.dockermet echte secrets naar Git.
11. Image lifecycle en opruimbeleid
Om te voorkomen dat je Docker Hub-repo volloopt, gebruik een vast bewaarbeleid.
Aanbevolen beleid:
- Bewaar de laatste 10 versie-tags (bijv.
v05.01.01t/mv05.01.10). - Bewaar altijd 1 bewezen rollback-tag naast de huidige productie-tag.
- Verwijder pre-release/test-tags na validatie.
Voorbeeld (huidig + rollback):
current:v05.01.10rollback:v05.01.09
11.1 Lokaal opruimen (build machine/server)
Verwijder ongebruikte images:
docker image prune -a
Verwijder een specifieke oude tag:
docker rmi markwestbroek/bitemp-go-api:v06.00.01
11.2 Docker Hub opruimen (remote)
Verwijder oude tags in Docker Hub UI:
- Open repository
markwestbroek/bitemp-go-api. - Ga naar tab
Tags. - Verwijder oude tags die buiten je bewaarbeleid vallen.
Praktische routine per release:
- Push nieuwe tag.
- Update productie naar die tag.
- Houd vorige productietag als rollback.
- Verwijder tags ouder dan je afgesproken venster (bijv. ouder dan laatste 10).
12. Release checklist (2 minuten)
Gebruik dit bij elke nieuwe API-versie. Volledige procedure incl. frontend en
tag-beleid: docs/DOCKER_RELEASE.md.
12.1 Build en push
Altijd twee tags: het versienummer én latest.
docker build -f Dockerfile.api \
--build-arg COMMIT=$(git rev-parse --short HEAD) \
--build-arg BUILD_TIME="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-t markwestbroek/bitemp-go-api:0.5.0 \
-t markwestbroek/bitemp-go-api:latest .
docker push markwestbroek/bitemp-go-api:0.5.0
docker push markwestbroek/bitemp-go-api:latest
12.2 Tag in stack bijwerken
Werk op de server in .env.docker bij:
API_IMAGE=markwestbroek/bitemp-go-api:0.5.0
12.3 API redeployen
docker compose -f docker-compose.api-only.yml up -d
12.4 Smoke test
curl http://<server-ip>:8082/version
curl http://<server-ip>:8082/viz/index_schema.html
docker logs --tail 100 bitemp-go-api-v06
12.5 Rollback (indien nodig)
Zet API_IMAGE terug naar de vorige stabiele tag en redeploy opnieuw:
docker compose -f docker-compose.api-only.yml up -d
13. MinIO / Filestore
MinIO is de S3-compatibele objectopslag voor het register. De API gebruikt MinIO voor:
- Opslag van IDE-bestanden (UML-editor exports, gepubliceerde V3 JSON modellen)
- Bestandsbeheer via de bestanden-handler (
/api/bestanden/...)
13.1 Configuratie-variabelen
| Variabele | Standaard | Beschrijving |
|---|---|---|
MINIO_ENDPOINT |
minio:9000 |
Endpoint dat de API gebruikt (containernaam:poort) |
MINIO_ACCESS_KEY |
minioadmin |
Toegangssleutel (equivalent van AWS access key) |
MINIO_SECRET_KEY |
minioadmin |
Geheime sleutel (equivalent van AWS secret key) |
MINIO_BUCKET |
ide-bestanden |
Naam van de bucket |
MINIO_USE_SSL |
false |
SSL gebruiken voor verbinding (true/false) |
MINIO_API_PORT |
9000 |
Host-poort voor MinIO API |
MINIO_CONSOLE_PORT |
9001 |
Host-poort voor MinIO webconsole |
13.2 Bucket-initialisatie
Alle compose-bestanden die MinIO bevatten hebben een minio-init service die automatisch:
- Een alias aanmaakt naar de MinIO-server.
- De bucket
ide-bestandenaanmaakt (of bevestigt dat deze al bestaat).
13.3 Handmatig beheer via MinIO console
Open http://localhost:9001 (of http://<server-ip>:9001) en log in met MINIO_ACCESS_KEY / MINIO_SECRET_KEY. Hier kun je:
- Bestanden bekijken en downloaden
- Buckets aanmaken/verwijderen
- Toegangsbeleid instellen
13.4 Data-persistentie
MinIO-data wordt opgeslagen in een named Docker volume:
docker-compose.yml:minio_datadocker-compose.devloop.yml:devloop_minio_datadocker-compose.split.yml:minio_data_splitdocker-compose.filestore-only.yml:bitemp-minio-data
Het volume blijft bestaan bij container-herstarts en -upgrades. Verwijder het volume alleen bewust met docker volume rm <naam>.