Wat is een Dockerfile en hoe schrijf je er een?

Question

IT Interview Practice · Accepted Answer

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

```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

```text
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)

```text
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.

Een basis Dockerfile

Belangrijkste instructies

RUN vs CMD vs ENTRYPOINT (vaak verward)

Waarom het belangrijk is

Gerelateerde vragen