Hva er en Dockerfile og hvordan skriver du en?

Question

Accepted Answer

En **Dockerfile** er en tekstfil med instruksjoner for **å bygge et Docker-image** — den beskriver base-imaget, avhengigheter, filer som skal kopieres, og hvordan applikasjonen skal kjøres. Det gjør image-bygg reproduserbare og versjonsstyrbare.

## Et grunnleggende 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"]
```

## Viktige instruksjoner

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

Å forstå Dockerfile er essensielt fordi det er hvordan Docker-images bygges, så å skrive en er en fundamental, daglig Docker-ferdighet.

En Dockerfile gir **reproduserbare, versjonsstyrbare image-bygg** — beskriver i kode nøyaktig hvordan man konstruerer et image (base-imaget, avhengigheter, filer, konfigurasjon og kjøringskommando), slik at hvem som helst kan bygge samme image konsekvent, noe som er sentralt for Dockers verdi når det gjelder reproduserbarhet.

Å forstå **de viktige instruksjonene** — `FROM` (base-imaget), `WORKDIR`, `COPY` (bringer filer inn), `RUN` (kjører build-tid-kommandoer som å installere avhengigheter), `ENV`, `EXPOSE`, og `CMD`/`ENTRYPOINT` (definerer hva som kjører når kontaineren starter) — er nødvendig for å skrive effektive Dockerfiles for virkelige applikasjoner.

En særlig viktig og ofte forvekslet distinksjon er **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` kjører på **build-tid** (konstruerer imaget, f.eks. installerer pakker), mens `CMD`/`ENTRYPOINT` definerer hva som kjører på **container start** (applikasjonskommandoen) — å forstå dette forhindrer vanlige feil.

Å kjenne praktiske mønster (som å kopiere avhengighetsfiler før kode for bedre layer-caching) gjenspeiler skriving av effektive Dockerfiles.

Ettersom å bygge images er fundamentalt for å bruke Docker (hver Docker-arbeidsflyt involverer images, og Dockerfile er hvordan egendefinerte images bygges), og ettersom å forstå instruksjonene og distinsksjonen build-tid-vs-kjøretid er nødvendig for å lage riktige, effektive images, er å forstå Dockerfile essensielt, hyppig brukt Docker-kunnskap — en kjerneferdighet for alle som bruker Docker, mekanismen som gjør Dockers reproduserbarhetløfte til praksis og et nesten universelt krav for containerisering av applikasjoner.