Hvad er en Dockerfile, og hvordan skriver man en?

Question

Accepted Answer

En **Dockerfile** er en tekstfil med instruktioner til at **bygge et Docker-image** — den beskriver base-imaget, afhængigheder, filer til at kopiere og hvordan man kører applikationen. Det gør image-bygninger reproducerbare og versionskontrollable.

## Et grundlæggende 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"]
```

## Vigtige instruktioner

```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 (ofte forvekslet)

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

## Hvorfor det betyder noget

At forstå Dockerfile er essentielt, fordi det er sådan Docker-images bygges, så at skrive en er en fundamental, daglig Docker-færdighed.

En Dockerfile giver **reproducerbare, versionskontrollable image-bygninger** — beskriver i kode præcis hvordan man konstruerer et image (base-imaget, afhængigheder, filer, konfiguration og kørselkommando), så hvem som helst kan bygge det samme image konsekvent, hvilket er centralt for Dockers værdi omkring reproducerbarhed.

At forstå de **vigtige instruktioner** — `FROM` (base-imaget), `WORKDIR`, `COPY` (henter filer ind), `RUN` (udfører build-tids-kommandoer som at installere afhængigheder), `ENV`, `EXPOSE` og `CMD`/`ENTRYPOINT` (definerer hvad der køres når containeren starter) — er nødvendigt for at skrive effektive Dockerfiles til rigtige applikationer.

En særligt vigtig og almindeligt forvekslet distinktion er **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` udfører ved **build-tid** (konstruerer imaget, f.eks. installation af pakker), mens `CMD`/`ENTRYPOINT` definerer hvad der køres ved **container-start** (applikationskommandoen) — at forstå dette forebygger almindelige fejl.

At kende praktiske mønstre (som at kopiere dependency-filer før kode for bedre layer caching) afspejler skrivningen af effektive Dockerfiles.

Fordi at bygge images er fundamentalt for at bruge Docker (hvert Docker-workflow involverer images, og Dockerfile er hvordan custom images bygges), og fordi at forstå instruktionerne og build-tid-versus-runtime-distinktionen er nødvendig for at skabe korrekte, effektive images, er forståelse af Dockerfile essentiel, hyppigt anvendt Docker-viden — en kernefærdighed for alle der bruger Docker, mekanismen der omdanner Dockers reproducerbarhed-løfte til praksis og en næsten universel kravformel for containerisering af applikationer.