Een Dockerfile is een tekstbestand met instructies voor het bouwen van een Docker-image — het beschrijft de basisimage, afhankelijkheden, bestanden om te kopiëren en hoe de applicatie uit te voeren. Het maakt image-builds reproduceerbaar en versiecontroleerbaar.
Een basis Dockerfile
# FROM — the base image to build on
FROM node:20-alpine
# WORKDIR — set the working directory inside the image
WORKDIR /app
# COPY dependency files first (for better layer caching)
COPY package*.json ./
# RUN — execute a command during the BUILD (install dependencies)
RUN npm install
# COPY the rest of the application code
COPY . .
# EXPOSE — document the port the app listens on
EXPOSE 3000
# CMD — the command to run when a CONTAINER starts
CMD ["node", "server.js"]
Belangrijkste instructies
FROM → the base image (starting point) — REQUIRED, usually first
WORKDIR → set the working directory for subsequent instructions
COPY/ADD → copy files from the host into the image
RUN → execute a command at BUILD time (install packages, compile) → creates a layer
ENV → set environment variables
EXPOSE → document which port(s) the container listens on
CMD → the default command to run when the container STARTS (one per Dockerfile)
ENTRYPOINT → the executable that runs (CMD provides default args to it)
ARG → build-time variables
RUN vs CMD vs ENTRYPOINT (vaak verward)
RUN → runs at BUILD time (builds the image — e.g. install dependencies)
CMD → runs at CONTAINER START (the default command; overridable at run)
ENTRYPOINT → the main executable at start (CMD becomes its default arguments)
→ RUN builds the image; CMD/ENTRYPOINT define what runs when it starts.
Waarom het belangrijk is
Het begrijpen van de Dockerfile is essentieel omdat dit de manier is waarop Docker-images worden gebouwd, dus het schrijven van een Dockerfile is een fundamentele, dagelijkse Docker-vaardigheid.
Een Dockerfile biedt reproduceerbare, versiecontroleerbare image-builds — beschrijft in code precies hoe een image moet worden geconstrueerd (de basisimage, afhankelijkheden, bestanden, configuratie en uitvoeropdracht), zodat iedereen consistent dezelfde image kan bouwen, wat centraal staat in Docker's waarde van reproduceerbaarheid.
Het begrijpen van de belangrijkste instructies — FROM (de basisimage), WORKDIR, COPY (bestanden binnenhaalen), RUN (build-time-commando's uitvoeren zoals afhankelijkheden installeren), ENV, EXPOSE en CMD/ENTRYPOINT (definiëren wat wordt uitgevoerd wanneer de container start) — is nodig om effectieve Dockerfiles voor echte applicaties te schrijven.
Een bijzonder belangrijk en veelgehoord onderscheid is RUN vs CMD vs ENTRYPOINT: RUN wordt uitgevoerd op build-tijd (het construeren van de image, bijv. het installeren van pakketten), terwijl CMD/ENTRYPOINT definiëren wat wordt uitgevoerd op container-start (de applicatieopdracht) — het begrijpen hiervan voorkomt veel voorkomende fouten.
Het kennen van praktische patronen (zoals het kopiëren van afhankelijkheidsbestanden vóór code voor beter layer-caching) weerspiegelt het schrijven van efficiënte Dockerfiles.
Omdat het bouwen van images fundamenteel is voor het gebruik van Docker (elke Docker-workflow omvat images, en de Dockerfile is de manier waarop aangepaste images worden gebouwd), en omdat het begrijpen van de instructies en het onderscheid tussen build-tijd en runtime nodig is om correcte, efficiënte images te maken, is het begrijpen van de Dockerfile essentiële, veelvuldig toegepaste Docker-kennis — een kernvaardigheid voor iedereen die Docker gebruikt, het mechanisme dat Docker's reproduceerbaarheidsbelofte in praktijk omzet en een bijna universale vereiste voor het containeriseren van applicaties.