Docker voor beginners: een praktische gids voor containers

Basisconcepten van Docker

Nu je Docker hebt geïnstalleerd, sta je misschien te popelen om direct containers te draaien. Voordat we dat doen, is het belangrijk om een paar kernconcepten te begrijpen die de basis vormen van hoe Docker werkt. Deze concepten helpen je Docker effectiever te gebruiken en veelvoorkomende beginnersfouten te vermijden.

In het hart van Docker staan images, die als blauwdrukken dienen voor containers; containers, de draaiende instanties van deze images; en Docker Hub, een centrale repository om images te delen en te beheren.

Laten we elk van deze concepten in meer detail bekijken.

Docker-images

Docker-images zijn de fundamentele bouwstenen van containers. Het zijn onveranderlijke, alleen-lezen templates met alles wat nodig is om een applicatie te draaien, inclusief het besturingssysteem, applicatiecode, runtime en afhankelijkheden.

Images worden gebouwd met een Dockerfile, die de instructies definieert om een image laag voor laag te creëren.

Images kunnen worden opgeslagen in en opgehaald uit containerregistries zoals Docker Hub.

Enkele voorbeeldcommando's om met images te werken:

• docker pull nginx: Haal de nieuwste Nginx-image op van Docker Hub.
• docker images: Toon alle beschikbare images op de lokale machine.
• docker rmi nginx: Verwijder een image van de lokale machine.

Docker-containers

Een Docker-container is een draaiende instantie van een Docker-image. Containers bieden een geïsoleerde runtime-omgeving waarin applicaties kunnen draaien zonder elkaar of het host-systeem te verstoren. Elke container heeft zijn eigen filesystem, networking en process-ruimte, maar deelt de host-kernel.

Containers volgen een eenvoudige levenscyclus van aanmaken, starten, stoppen en verwijderen. Hier zijn veelgebruikte beheercommando's:

1. Container aanmaken: docker create of docker run
2. Container starten: docker start
3. Container stoppen: docker stop
4. Container herstarten: docker restart
5. Container verwijderen: docker rm

Laten we een praktisch voorbeeld bekijken. Het volgende commando draait een Nginx-container in detached-modus (op de achtergrond), waarbij poort 80 in de container wordt gemapt naar poort 8080 op de hostmachine:

docker run -d -p 8080:80 nginx

Na het uitvoeren van dit commando zal Docker de Nginx-image ophalen (als die nog niet beschikbaar is), een container aanmaken en starten.

Om alle draaiende en gestopte containers te bekijken:

docker ps -a

Dit toont een lijst met alle containers en details zoals status en toegewezen poorten.

Docker Hub

Docker Hub is een cloudgebaseerde registry-service voor het vinden, opslaan en distribueren van containerimages. Gebruikers kunnen aangepaste images naar Docker Hub pushen en ze publiek of privé delen.

Enkele commando's om met Docker Hub te werken:

• docker login: Authenticateer bij Docker Hub.
• docker push my-image: Upload een zelfgebouwde image naar Docker Hub.
• docker search ubuntu: Zoek naar officiële en community-images.
• docker pull ubuntu: Download een Ubuntu-image van Docker Hub.

Nieuw met containerization? Leg een stevige basis met de cursus Containerization and Virtualization Concepts.

Je eerste Docker-container draaien

Nu we de kernconcepten van Docker hebben behandeld, is het tijd voor actie! Laten we beginnen met het draaien van onze eerste container om te controleren of Docker correct is geïnstalleerd en werkt zoals verwacht.

Open PowerShell (Windows) of Terminal (Mac en Linux) en voer uit:

docker run hello-world

Dit haalt de hello-world-image van DockerHub op en draait deze in een container.

Voorbeeld van Docker hello-world-image

Laten we nu een stap verder gaan en een echte applicatie draaien—een Nginx-webserver. Voer het volgende commando uit:

docker run -d -p 8080:80 nginx

Bovenstaand commando doet het volgende:

• De -d-vlag draait de container in detached-modus, dus op de achtergrond.
• De -p 8080:80-vlag mappt poort 80 in de container naar poort 8080 op je lokale machine, zodat je de webserver kunt bereiken.

Als het commando is geslaagd, open je een browser en ga je naar: http://localhost:8080

Webserver benaderen op localhost:8080

Je zou de standaard welkomstpagina van Nginx moeten zien—een bevestiging dat je webserver in een container draait!

Je ziet ook een draaiende container in je Docker Desktop:

Nginx-container draait op poort 8080

Je eerste Docker-image bouwen

Tot nu toe hebben we vooraf gebouwde images van Docker Hub gedraaid. Maar wat als je een aangepaste omgeving nodig hebt voor jouw applicatie? Dan bouw je je eigen Docker-image.

Een Docker-image maken doe je met een Dockerfile—een script dat het bouwen van de image automatiseert. Dit zorgt voor consistentie en portabiliteit tussen omgevingen. Zodra een image is gebouwd, kun je die als container draaien om applicaties geïsoleerd uit te voeren. 

In deze sectie leer je de basis van een Dockerfile schrijven, een custom image bouwen en deze als container draaien.

Dockerfile-basis

Een Dockerfile is een script met een reeks instructies die bepalen hoe een Docker-image wordt gebouwd. Het automatiseert het aanmaken van de image en zorgt voor consistentie tussen omgevingen. Elke instructie in een Dockerfile creëert een nieuwe laag in de image. Hier is een voorbeeld-Dockerfile voor een eenvoudige Python Flask-app:

# Base image containing Python runtime
FROM python:3.9

# Set the working directory inside the container
WORKDIR /app

# Copy the application files from the host to the container
COPY . /app

# Install the dependencies listed in requirements.txt
RUN pip install -r requirements.txt

# Define the command to run the Flask app when the container starts
CMD ["python", "app.py"]

In het bovenstaande commando:

• -v my-volume:/app/data mount de opslag my-volume op de map /app/data in de container.
• Alle data die in /app/data wordt opgeslagen, blijft behouden, zelfs als de container stopt of wordt verwijderd.

Uiteengezet wat de Dockerfile hierboven doet:

• FROM python:3.9: Specificeert de basisimage met Python 3.9 vooraf geïnstalleerd.
• WORKDIR /app: Stelt /app in als de werkmap binnen de container.
• COPY . /app: Kopieert alle bestanden uit de huidige map van de host naar /app in de container.
• RUN pip install -r requirements.txt: Installeert alle vereiste dependencies in de container.
• CMD ["python", "app.py"]: Definieert het commando dat wordt uitgevoerd wanneer de container start.

De image bouwen en draaien

Zodra de Dockerfile gedefinieerd is, kun je de image bouwen en draaien met de volgende commando's:

Stap 1: Bouw de image

docker build -t my-flask-app .

Bovenstaand commando:

• Gebruikt de huidige map (.) als buildcontext.
• Leest de Dockerfile en voert de instructies uit.
• Voorziet de resulterende image van een tag (-t) als my-flask-app.

Stap 2: Draai de image als container

docker run -d -p 5000:5000 my-flask-app

Bovenstaand commando:

• Draait de container in detached-modus (-d).
• Mapt poort 5000 in de container naar poort 5000 op de host (-p 5000:5000).

Zodra de container draait, kun je de Flask-app bereiken via http://localhost:5000 in je browser.

Docker-volumes en persistentie

Standaard zijn data in een Docker-container tijdelijk—zodra de container stopt of wordt verwijderd, verdwijnen de data. Om data te behouden over containerherstarts en te delen tussen meerdere containers, biedt Docker volumes: een ingebouwd mechanisme voor efficiënt beheer van persistente opslag.

In tegenstelling tot data opslaan in het filesystem van de container, worden volumes apart door Docker beheerd. Ze zijn efficiënter, flexibeler en eenvoudiger te back-uppen.

In de volgende sectie bekijken we hoe je Docker-volumes aanmaakt en gebruikt om data persistent te maken in je containers.

Docker-volumes maken en gebruiken

Stap 1: Maak een volume

Voordat we een volume gebruiken, maken we er eerst één aan. Voer het volgende commando uit:

docker volume create my-volume

Dit maakt een named volume genaamd my-volume, dat Docker los van specifieke containers beheert.Stap 2: Gebruik het volume in een container

Start nu een container en mount het volume erin:

docker run -d -v my-volume:/app/data my-app

In bovenstaand commando:

• -v my-volume:/app/data mount de opslag my-volume op de map /app/data in de container.
• Alle data in /app/data blijft behouden, zelfs als de container stopt of wordt verwijderd.

Docker Compose voor multi-containerapplicaties

Tot nu toe hebben we met single-containerapplicaties gewerkt, maar veel real-world apps hebben meerdere containers nodig die samenwerken. Een webapplicatie kan bijvoorbeeld een backendserver, een database en een cachinglaag nodig hebben—elk in een eigen container. Dit handmatig beheren met losse docker run-commando's wordt al snel omslachtig.

Daar komt Docker Compose om de hoek kijken.

Wat is Docker Compose?

Docker Compose is een tool die het beheer van multi-containerapplicaties vereenvoudigt. In plaats van meerdere docker run-commando's te gebruiken, definieer je een volledige applicatiestack in een docker-compose.yml-bestand en deploy je alles met één commando.

Een Docker Compose-bestand schrijven

Laten we een realistisch voorbeeld maken—een eenvoudige Node.js-applicatie die verbinding maakt met een MongoDB-database. In plaats van de twee containers apart te beheren, definiëren we ze in een docker-compose.yml-bestand.

Zo definiëren we onze multi-container setup in Docker Compose:

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database
  database:
    image: mongo
    volumes:
      - db-data:/data/db
volumes:
  db-data:

Toelichting op het bestand hierboven:

• version: '3': Specificeert de Docker Compose-versie.
• services:: Definieert individuele services (containers).
• web:: Definieert de Node.js-webapplicatie.
• database:: Definieert de MongoDB-databasecontainer.
• volumes:: Maakt een named volume (db-data) voor de persistentie van MongoDB-data.

Multi-containerapplicaties draaien

Zodra het docker-compose.yml-bestand klaar is, starten we de hele stack met één commando:

docker-compose up -d

Het vorige commando start zowel de web- als databasecontainers in detached-modus (-d).

Om alle services te stoppen, gebruik je:

docker-compose down

Dit stopt en verwijdert alle containers, terwijl volumes en netwerkinstellingen behouden blijven.

Basis van Docker-networking

Tot nu toe hebben we ons gericht op het draaien van containers en het beheren van opslag, maar wat gebeurt er als containers met elkaar moeten communiceren? In de meeste real-world applicaties werken containers niet geïsoleerd—ze wisselen data uit, of het nu een webserver is die met een database praat, of microservices die onderling communiceren.

Docker biedt verschillende netwerkopties voor uiteenlopende use-cases, van geïsoleerde interne netwerken tot extern toegankelijke configuraties.

Klaar om je Docker-skills te upgraden? Schrijf je in voor Intermediate Docker en ontdek multi-stage builds, geavanceerde networking en meer!

Wat is Docker-networking?

Docker-networking is een ingebouwde functie waarmee containers met elkaar kunnen communiceren—op dezelfde host of over meerdere hosts in een gedistribueerde omgeving. Het biedt netwerkisolatie, segmentatie en verbindingsopties voor verschillende deploymentscenario's.

Docker ondersteunt meerdere netwerktype, elk met een eigen use-case:

• Bridge (standaard): Containers op dezelfde host communiceren via een intern virtueel netwerk. Elke container krijgt een privé-IP binnen het bridgenetwerk en kan andere containers bereiken via containernamen.
• Voorbeeld: docker network create my-bridge-network
• Ideaal om meerdere containers op één host veilig met elkaar te laten praten zonder services extern bloot te stellen.
• Host: Containers delen de netwerkstack van de host en gebruiken direct het IP-adres en de poorten van de host.
• Voorbeeld: docker run --network host nginx
• Handig wanneer je hoge performance nodig hebt en geen netwerkisolatie vereist, zoals bij monitoringagents of applicaties met lage latency.
• Overlay: Maakt communicatie tussen containers op verschillende hosts mogelijk via een gedistribueerd netwerk.
• Voorbeeld: docker network create --driver overlay my-overlay-network
• Ontworpen voor georchestreerde deployments zoals Docker Swarm, waarbij services meerdere nodes beslaan.
• Macvlan: Wijst elke container een uniek MAC-adres toe, waardoor deze lijkt op een fysiek apparaat in het netwerk.
• Voorbeeld: docker network create -d macvlan --subnet=192.168.1.0/24 my-macvlan
• Gebruikt wanneer containers directe netwerktoegang nodig hebben, bijvoorbeeld bij integratie met legacy-systemen of fysieke netwerken.

Containers draaien op aangepaste netwerken

Laten we doornemen hoe je een aangepast bridgenetwerk opzet voor communicatie tussen containers.

Stap 1: Maak een aangepast netwerk

Voordat we containers draaien, maken we eerst een dedicated netwerk aan:

docker network create my-custom-network

Dit commando maakt een geïsoleerd netwerk dat containers kunnen joinen voor onderlinge communicatie.

Stap 2: Draai containers op het netwerk

Start nu twee containers en verbind ze met ons nieuw aangemaakte netwerk:

docker run -d --network my-custom-network --name app1 my-app
docker run -d --network my-custom-network --name app2 my-app

• De vlag --network my-custom-network koppelt de container aan het opgegeven netwerk.
• De vlag --name geeft een unieke containernaam, wat het verwijzen vergemakkelijkt.

Zowel app1 als app2 kunnen nu communiceren via hun containernamen. Je kunt de connectiviteit testen met het ping-commando binnen een van de containers:

docker exec -it app1 ping app2

Als alles goed is ingesteld, zie je een response die bevestigt dat de containers kunnen communiceren.

Docker-netwerken inspecteren

Om netwerkconfiguraties en gekoppelde containers te verifiëren, gebruik je:

docker network inspect my-custom-network

Dit commando geeft details over het netwerk, inclusief IP-bereiken, gekoppelde containers en configuraties.

Poorten exposen en publiceren

Wanneer je containers extern toegankelijk moeten zijn, kun je specifieke poorten exposen.

Om bijvoorbeeld een Nginx-webserver te draaien en die beschikbaar te maken op poort 8080 van je lokale machine, gebruik je:

docker run -d -p 8080:80 nginx

Dit mappt poort 80 in de container naar poort 8080 op de host, waardoor de service bereikbaar is via http://localhost:8080.

Best practices voor Docker-networking

• Gebruik aangepaste netwerken: Vermijd het standaard bridgenetwerk voor productie om ongewenste toegang tussen containers te beperken.
• Maak gebruik van DNS-gebaseerde discovery: In plaats van IP-adressen hard te coderen, gebruik je containernamen voor dynamische servicediscovery.
• Beperk externe blootstelling: Gebruik firewalls of netwerkpolicies om toegang tot services te beheersen.
• Monitor verkeer: Gebruik tools zoals docker network inspect, Wireshark of Prometheus om netwerkverkeer te analyseren en anomalieën te detecteren.
• Optimaliseer overlay-netwerken: Stem overlay-netwerken af voor lagere latency in gedistribueerde setups door host-lokale routing te benutten.

Docker-best practices en vervolgstappen

Nu je de basis van Docker beheerst, is het tijd om je skills op te schalen en best practices toe te passen om veilige, efficiënte en onderhoudbare gecontaineriseerde applicaties te bouwen.

De volgende best practices helpen je Docker-workflows te stroomlijnen en veelvoorkomende valkuilen te vermijden.

• Gebruik officiële basisimages: Geef de voorkeur aan officiële en goed onderhouden basisimages voor veiligheid en stabiliteit. Officiële images zijn geoptimaliseerd, regelmatig geüpdatet en minder kwetsbaar.
• Houd images klein: Verklein de imagegrootte door minimale basisimages te kiezen (bijv. python:3.9-slim i.p.v. python:3.9). Verwijder onnodige dependencies en bestanden om opslag en pull-tijden te optimaliseren.
• Gebruik multi-stage builds: Optimaliseer Dockerfiles door build- en runtime-afhankelijkheden te scheiden. Multi-stage builds zorgen dat alleen noodzakelijke artifacts in de uiteindelijke image komen, wat grootte en attack surface verkleint.
• Tag images correct: Gebruik altijd versie-tags (bijv. my-app:v1.0.0) in plaats van latest om onverwachte updates bij het pullen te voorkomen.
• Scan images op kwetsbaarheden: Gebruik securityscanners zoals docker scan, Trivy of Clair om kwetsbaarheden te identificeren en te verhelpen vóór deployment.
• Beheer omgevingsvariabelen veilig: Sla geen gevoelige credentials op in images. Gebruik Docker secrets, environment variables of externe secret managers zoals AWS Secrets Manager of HashiCorp Vault.
• Gebruik .dockerignore-bestanden: Sluit onnodige bestanden uit (bijv. .git, node_modules, venv) om de buildcontext te verkleinen en te voorkomen dat gevoelige bestanden per ongeluk in images belanden.
• Schakel logging en monitoring in: Gebruik tools zoals Prometheus, Grafana en Fluentd voor containerlogs en monitoring. Inspecteer logs met docker logs en gebruik gestructureerde logging voor betere observability.

Als je de basis van Docker beheerst, zijn er tal van geavanceerde onderwerpen om te verkennen. Enkele interessante volgende stappen:

• Docker Swarm & Kubernetes: Verken Docker Swarm (ingebouwde clustering) en Kubernetes (enterprise-grade orchestration met autoscaling en servicediscovery) voor orkestratie op productieniveau.
• Best practices voor containerbeveiliging: Volg de CIS Docker Benchmark-richtlijnen en implementeer RBAC (Role-Based Access Control) om gecontaineriseerde applicaties te beveiligen.
• CI/CD-pijplijnen met Docker: Automatiseer image-builds, securityscans en deployments met GitHub Actions, GitLab CI of Jenkins.
• Cloud-native development: Gebruik Docker met cloudplatforms zoals AWS ECS, Azure Container Instances en Google Cloud Run voor schaalbare, beheerde deployments.
• Strategieën voor datapersistentie: Begrijp de verschillen tussen Docker-volumes, bind mounts en tmpfs voor optimaal opslagbeheer.

Conclusie

Docker heeft de manier waarop developers applicaties bouwen, verzenden en draaien veranderd en is daarmee een essentieel hulpmiddel voor moderne softwareontwikkeling.

In deze tutorial hebben we behandeld:

• Wat Docker is en waarom het belangrijk is
• Hoe je je eerste container installeert en draait
• Kernconcepten zoals images, containers en networking
• Persistente opslag met Docker-volumes
• Multi-containerapplicaties met Docker Compose
• Best practices voor security, performance en schaalbaarheid

Maar dit is nog maar het begin! Wil je je Docker-expertise verdiepen, volg dan een beginnerscursus Introduction to Docker. Voor meer diepgang kun je de Intermediate Docker-cursus volgen over multi-stage builds, Docker-networkingtools en Docker Compose. Je kunt ook een Docker-certificering behalen; bekijk The Complete Docker Certification (DCA) Guide for 2025 als je geïnteresseerd bent!