Wat is Docker Desktop op Windows en hoe werkt het?

Docker is een manier en inmiddels een de facto standaard om software inclusief alle afhankelijkheden te verpakken in geïsoleerde en snel verwijderbare eenheden, zogeheten containers. Deze tool bestaat eigenlijk uit drie delen: Docker Engine, Docker CLI en Docker Compose. Docker Engine draait binnen WSL 2 (Windows Subsystem for Linux) en is verantwoordelijk is voor het bouwen, starten en stoppen van containers. De Docker CLI (command-line-interface) laat je via opdrachtregelcommando's direct communiceren met de engine. Met Docker Compose definieer je in een keer de gehele infrastructuur (stack), zoals netwerken en opslagvolumes, van meerdere container-applicaties in één configuratiebestand.

Docker Desktop bundelt deze onderdelen en bouwt daar een handige beheerschil omheen: een grafische interface met updates, veiligheidsscans, ingebouwde netwerk- en bestandsdeling en recent ook een AI-tool. Denk bijvoorbeeld aan een MCP-toolkit (Model Context Protocol) waarmee AI-agents toegang krijgen tot tools en databronnen.

Voor je met containers via Docker Desktop onder Windows start, wil je natuurlijk weten welke voordelen dit biedt ten opzichte van een kale Docker-installatie binnen WSL 2, een normale installatie in Windows of een traditionele virtuele machine.

De eerste optie biedt alvast geen dashboard om containers te beheren of logs en bronnen in de gaten te houden, omdat alles via de Linux-terminal verloopt. Je configureert en onderhoudt Docker dus zelf binnen je distributie. Ook de Windows-integratie blijft beperkt: Docker draait volledig in Linux en toegang tot Windows-mappen (via /mnt) is minder transparant en vaak trager. Zo'n aanpak is misschien meer iets voor hardcore Linux-gebruikers.

Installeer je complexere serversoftware, voor zover mogelijk, rechtstreeks op Windows, dan loop je sneller tegen 'dependency hell' aan, waarbij updates van de ene applicatie conflicteren met afhankelijkheden van een andere. Versies naast elkaar beheren wordt dus omslachtiger en ook migreren naar een andere pc is minder vanzelfsprekend. Immers, configuratiebestanden verspreiden zich vaak over diverse mappen en na verwijdering blijven geregeld restbestanden achter.

Kies je voor een traditionele VM, dan heb je een volledig gastbesturingssysteem nodig met extra opslag- en brongebruik. Hypervisors gaan tegenwoordig wel dynamischer om met geheugen en bieden sterkere isolatie, maar verbruiken doorgaans meer bronnen. Ze starten of stoppen ook trager dan containers, die je in enkele seconden opstart of afsluit of opnieuw uitrolt via één compose-bestand.

Heb je niet eerder met Docker (Desktop) gewerkt, dan helpen we je heel snel op weg. Daarna focussen we ons op concrete gebruiksscenario's die om diverse redenen een meerwaarde kunnen bieden voor Windows-gebruikers en belichten we tevens een aantal handige opties binnen Docker Desktop.

We gaan er alvast vanuit dat hardware-virtualisatie (Intel VT-x of AMD-V) in het BIOS-UEFI van je pc is ingeschakeld en dat ook de virtualisatielaag WSL 2 geactiveerd is. Dit laatste kun je installeren met een PowerShell- of opdrachtpromptcommando en vervolgens controleren met het tweede commando:

wsl -install

wsl -l -v

Zorg desnoods met het volgende commando dat versie 2 actief is:

wsl --set-default-version 2

Controleer daarna hoeveel geheugen en processorkernen WSL (en dus Docker) maximaal en dynamisch beschikbaar heeft met de commando's:

wsl free -h

wsl nproc

Je kunt dit desgewenst beperken voor alle containers samen door in de standaardmap C:\Users\<jouwnaam> het tekstbestand .wslconfig te creëren, bijvoorbeeld met de volgende inhoud:

[wsl2]

memory=6GB

processors=4

Voer hier na het volgende commando uit:

wsl --shutdown

Je kunt Docker Desktop downloaden via https://www.docker.com/products/docker-desktop/. Klik op Download Docker Desktop en kies Download for Windows – AMD64. Installeer het programma en na een herstart van Windows kun je met Docker Desktop aan de slag.

Linksonder in het programmavenster kun je de engine pauzeren en herstarten. Controleer de versies met de volgende twee opdrachtregelcommando's:

docker version

docker compose version

Start je eerste (test)container met:

docker run --rm hello-world

Docker controleert eerst of het bijbehorende image al lokaal beschikbaar is. Is dat niet het geval, dan downloadt het dit automatisch van Docker Hub. Vervolgens creëert Docker een geïsoleerde omgeving voor het image, koppelt indien nodig poorten, netwerken en volumes, en start de applicatie in de container, waarna in dit geval een welkomstbericht verschijnt: Docker werkt.

Je kunt natuurlijk veel meer doen met Docker. We starten met een eenvoudige webserver en tonen hoe je die veel sneller en eenvoudiger beheert dan via een VM of WSL.

Start Docker Desktop en open PowerShell of Windows Terminal. Haal de recentste versie van de webserver nginx op uit Docker Hub met het commando:

docker pull nginx:latest

Voer vervolgens het volgende commando uit:

docker run --rm -d --name test-nginx -p 8080:80 nginx:latest

Zo maak je een container van de image nginx:latest en laat je die op de achtergrond draaien. De schakeloptie -d betekent detached oftewel losgemaakt van de terminal. Je kunt dit weglaten tijdens testfases om Docker beter te kunnen monitoren. Binnen de container draait de service op poort 80, terwijl je die in Windows koppelt aan poort 8080 via -p 8080:80. Door --rm wordt de container automatisch verwijderd zodra hij stopt, wat handig is tijdens tests. Test de server uit via http://localhost:8080; je ziet nu de standaard startpagina. Verderop lees je bij 'Persistente opslag' hoe je met persistente volumes ook eigen webpagina's gebruikt.

Je stopt de container met het commando:
docker stop test-nginx

De volgende twee veelgebruikte commando's om de container opnieuw te starten zullen niet werken:
docker start test-nginx
docker restart test-nginx
Dit komt doordat je --rm gebruikte en de container wordt verwijderd als hij stopt. Je kunt dit alles ook vanuit de GUI doen. Open Docker Hub, waar je terecht kunt voor talrijke images (zoals homeassistant, jellyfin, Nextcloud en vele andere), zoek hier naar nginx en klik op nginx (official build). Kies de gewenste tag en klik op Pull. Ga daarna naar Images en klik op Run bij de image. Vul bij Optional settings een eigen naam evenals de hostport zoals 8080 in. Na Run verschijnt de container in de rubriek Containers.

Docker wordt pas echt interessant wanneer je meerdere diensten in meerdere samenhangende containers in één keer start met één commando. Dit blijft veel minder complex dan dezelfde opzet te bouwen met traditionele virtuele machines.

Als voorbeeld zetten we een WordPress-server op die een databaseserver MariaDB gebruikt om data op te slaan, zoals accounts, berichten, instellingen en meer.

Maak in een lege map, bijvoorbeeld d:\docker\wp-test, een tekstbestand aan met de naam compose.yml. Let goed op de inspringingen (twee extra spaties), want YAML luistert nauw:

services:

  db:

    image: mariadb:11

    restart: unless-stopped

    environment:

      MARIADB_DATABASE: wordpress

      MARIADB_USER: wp-gebruiker

      MARIADB_PASSWORD: wp-mijnwawo

      MARIADB_ROOT_PASSWORD: root-mijnwawo

  wordpress:

    image: wordpress:php8.2-apache

    restart: unless-stopped

    depends_on:

      - db

    ports:

      - 8080:80

    environment:

      WORDPRESS_DB_HOST: db:3306

      WORDPRESS_DB_NAME: wordpress

      WORDPRESS_DB_USER: wp-gebruiker

      WORDPRESS_DB_PASSWORD: wp-mijnwawo

De code spreekt grotendeels voor zich. Open PowerShell in deze map en voer het volgende commando uit:

docker compose up -d

Test daarna http://localhost:8080 in je browser en doorloop de WordPress-installatiewizard; je beschikt nu over een werkende site met een database.

Controleer of beide containers, WordPress en MariaDB, actief zijn met het volgende commando:

docker compose ps

Je kunt ze stoppen met het commando:

docker compose down

Je kunt dit natuurlijk ook vanuit de GUI beheren. In de alinea 'Persistent opslag' verderop in dit artikel lees je hoe je ook hier persistente volumes inzet voor site en database.

Wanneer je direct in Windows meerdere services met overlappende afhankelijkheden installeert en draait, krijg je al snel conflicten rond versies, poorten, installaties of padvermeldingen. Docker lost dit eleganter op; een eenvoudig voorbeeld maakt dit duidelijk door deze twee commando's uit te voeren:

docker run -d --name webserver1 -p 8081:80 nginx:latest

docker run -d --name webserver2 -p 8082:80 nginx:alpine

Voer je deze commando's na elkaar uit, dan zie je dat beide servers probleemloos naast elkaar draaien. Het gaat om twee verschillende imagevarianten van nginx (latest en alpine), elk met hun eigen runtime en afhankelijkheden. Intern gebruiken ze dezelfde poort (80), maar omdat je ze aan verschillende hostpoorten koppelt (8081 en 8082), ontstaat er op het Windows-systeem geen conflict.

Dankzij containerisolatie blijven programmabestanden en -bibliotheken net als de configuraties gescheiden, zonder invloed op elkaar of op het hostsysteem. Zowel de GUI als het commando docker ps (process status) tonen welke containers precies actief zijn.

Je wilt je Docker Desktop-experimenten natuurlijk niet tot vrijblijvende tests beperken. Op een bepaald moment wil je data ongetwijfeld ook blijvend opslaan. We illustreren dit met de eerder gebruikte voorbeelden nginx en de combinatie WordPress/MariaDB.

We starten met nginx. Wil je eigen webpagina's serveren zonder ze na elke herstart opnieuw te moeten aanmaken, dan heb je persistente opslag nodig.

We laten eerst zien hoe je dit regelt vanuit de GUI. Open Images, start de nginx-image en ga naar Optional Settings. Verwijs Host path bij Volumes naar een lokale map waarin je onder meer index.html plaatst, bijvoorbeeld d:\docker\nginx. Stel het Container path voor deze nginx-image in op /usr/share/nginx/html. Meer is er eigenlijk niet nodig.

Ook het YAML-bestand van WordPress/MariaDB kun je aanpassen voor persistente opslag. Voeg onderin db:, net boven wordpress:, het volgende toe:

volumes:

  - d:/docker/wp-test/db:/var/lib/mysql

En helemaal onderaan, in het onderdeel wordpress: voeg je toe:

volumes:

  - d:/docker/wp-test/wp:/var/www/html

Zoals bij nginx kun je deze mapkoppelingen (bind mounts) ook via Optional Settings in de interface instellen. Maak in Windows wel vooraf de opgegeven submappen (d:\docker\wp-test\db en d:\docker\wp-test\wp) aan voordat je de containers start.

Docker verwijdert interne opslag (in zogeheten 'named volumes') met het commando:

docker compose down -v

Dit kan ook via de rubriek Volumes in de interface van Docker Desktop. Zelf gekoppelde mappen, zoals in ons voorbeeld, moet je naderhand handmatig verwijderen, bijvoorbeeld via de Verkenner.

Je kunt Docker Desktop ook gebruiken om tijdelijk software te draaien die je liever niet rechtstreeks installeert, zoals oudere versies, netwerktools of analysetools. Wil je bestanden analyseren waarvan je de werking niet vertrouwt, bijvoorbeeld scripts of onbekende tools, dan kan Docker als relatief veilige analyseomgeving dienen.

Plaats de bestanden in een map zoals d:\analyse en koppel die via de GUI of met:

docker run --rm -it -v d:\analyse:/data ubuntu bash

Met -it start je een interactieve bash-shell en met -v leg je de mapkoppeling vast, waarbij d:\analyse de hostmap is en /data de map in de container. Met ubuntu verwijs je naar de image en bash is het commando dat in de container wordt uitgevoerd.

Ga in de shell met het commando cd /data naar de map data en open, voer of analyseer daar bestanden met tools als cat, less, file of strings.

Voer om deze tools te gebruiken eerst de volgende twee commando's uit:

apt update

apt install less file binutils

Het Linux-commando curl is eveneens veelzijdig, bijvoorbeeld om http-headers te controleren:

docker run --rm curlimages/curl -I -L https://<www.site.nl>

Of om bestanden te downloaden:

docker run --rm -v d:\downloads:/data curlimages/curl -L -o /data/<bestandsnaam> https://<www.site.nl>/<bestandsnaam>

Hier  vind je een overzicht van vrijwel alle curl-parameters.

Je kunt ook de netshoot-image gebruiken, die tientallen netwerktools bevat:

docker run --rm -it nicolaka/netshoot bash

Zo krijg je toegang tot onder meer traceroute, dig, tcpdump en iperf, en kun je eenvoudig experimenteren met commando's als:

dig google.com

traceroute 8.8.4.4.

Een voordeel van Docker-containers is ook dat je ze relatief eenvoudig naar een andere pc migreert. Dat kan meestal ook met een virtuele machine in bijvoorbeeld VirtualBox, maar een containermigratie is doorgaans minder omvangrijk.

Gebruikt je container geen persistente opslag, dan hoef je in feite alleen de configuratie opnieuw uit te voeren op de nieuwe pc. Werk je met compose.yml, kopieer dan de volledige projectmap met het YAML-bestand naar de nieuwe pc en voer het volgende commando uit:

docker compose up -d

Startte je een container met docker run, dan kun je op de nieuwe pc hetzelfde docker run-commando opnieuw uitvoeren, al werkt het meestal robuuster als je de instellingen eerst omzet naar overeenkomstige velden in een compose.yml-bestand, zeker bij meerdere containers.

Een voorbeeld, inclusief een bind mount, verduidelijkt dit. Stel dat je je container startte met het reeds hierboven gegeven commando:

docker run --rm -v d:\downloads:/data curlimages/curl -L -o /data/<bestandsnaam> https://<www.site.nl>/<bestandsnaam>

De relevante onderdelen hieruit vertalen zich als volgt in een compose.yml-bestand:

services:

  mijncurljob:

    container_name: mijn_curljob
    image: curlimages/curl

    volumes:

      - d:\downloads:/data

    command: -L -o /data/<bestandsnaam> https://<www.site.nl>/<bestandsnaam>

Nadat je eventueel bestaande gegevens uit de lokale map d:\downloads naar hetzelfde pad op de nieuwe pc hebt gekopieerd, voer je de migratie uit met het commando:

docker compose run --rm mijncurljob

Dit verdient de voorkeur boven:

docker compose up

Dat komt omdat het hier om een korte, eenmalige taak gaat waarvoor de container niet hoeft te blijven draaien.

Veel thuisgebruikers installeren allerlei software en services, testen van alles, laten het staan en weten na verloop van tijd niet meer wat waar draait of hoeveel schijfruimte het inneemt. Klinkt dit bekend, dan is Docker de uitgelezen tool.

Containers zijn immers geïsoleerde eenheden: stop en verwijder je ze, dan blijft Windows zelf schoon. Enkele extra commando's helpen je daarbij.

Zo zie je met de volgende twee commando's in één oogopslag welke containers er momenteel draaien en welke gestopte containers je hebt:

docker ps

docker ps -a

Met docker image ls bekijk je je lokale images. Wil je (onder andere) ongebruikte containers, netwerken en caches opruimen, dan gebruik je:

docker system prune

Met het volgende commando verwijder je ook alle images die niet door een container worden gebruikt:

docker system prune -a

Let wel op: die moet je later eventueel opnieuw downloaden als je ze weer wilt gebruiken. Eventuele volumes blijven hiermee wel buiten schot. Zijn er toch persistente data, ga dan na welke named volumes er bestaan met:

docker volume ls

Je kunt een specifiek volume verwijderen op voorwaarde dat geen container het nog gebruikt, of alle ongebruikte volumes verwijderen met de commando's:

docker volume rm <volumenaam>

docker volume prune

Wil je achterhalen of een container een named volume of een bind mount gebruikt? Voer dan het volgende commando uit:

docker inspect <containernaam>

Je ziet vervolgens in de rubriek Mounts of een container een named volume (Type: volume) of een bind mount (Type: bind) gebruikt. In dat laatste geval lees je bij Source de hostmap af, die je desgewenst handmatig kunt verwijderen nadat je de container hebt gestopt en verwijderd.

Met Docker-containers kun je kortom snel experimenteren zonder je Windows-omgeving te vervuilen.