Vad är en Dockerfile och hur skriver man en?

Question

Accepted Answer

En **Dockerfile** är en textfil med instruktioner för **att bygga en Docker-image** — den beskriver basbilden, beroenden, filer som ska kopieras och hur programmet ska köras. Det gör bildbyggen reproducerbara och versionskontrollerbara.

## En grundläggande 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"]
```

## Viktiga 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 (ofta förvirrande)

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

## Varför det är viktigt

Att förstå Dockerfile är väsentligt eftersom det är så Docker-images byggas, så att skriva en är en grundläggande, daglig Docker-färdighet.

En Dockerfile ger **reproducerbara, versionskontrollerbara bildbyggen** — beskriver i kod exakt hur man konstruerar en image (basbilden, beroenden, filer, konfiguration och körkommando), så vem som helst kan bygga samma image konsekvent, vilket är centralt för Dockers värde av reproducerbarhet.

Att förstå **de viktiga instruktionerna** — `FROM` (basbilden), `WORKDIR`, `COPY` (för att få in filer), `RUN` (för att köra byggkommando som att installera beroenden), `ENV`, `EXPOSE` och `CMD`/`ENTRYPOINT` (för att definiera vad som körs när behållaren startar) — är nödvändigt för att skriva effektiva Dockerfiles för riktiga program.

En särskilt viktig och ofta förvirrande skillnad är **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` körs vid **byggtid** (för att konstruera imagen, t.ex. installera paket), medan `CMD`/`ENTRYPOINT` definierar vad som körs vid **behållarestart** (programkommandot) — att förstå detta förhindrar vanliga misstag.

Att känna till praktiska mönster (som att kopiera beroendefiler före kod för bättre lagercaching) återspeglar skrivandet av effektiva Dockerfiles.

Eftersom att bygga images är grundläggande för att använda Docker (varje Docker-arbetsflöde involverar images, och Dockerfile är hur anpassade images byggas), och eftersom att förstå instruktionerna och distinktionen mellan byggtid kontra runtime är nödvändigt för att skapa korrekta, effektiva images, är förståelsen av Dockerfile väsentlig, ofta tillämpad Docker-kunskap — en kärnfärdighet för alla som använder Docker, mekanismen som förvandlar Dockers löfte om reproducerbarhet till praktik och en nästan universell förutsättning för containerisering av program.