Was ist eine Dockerfile und wie schreibt man eine?

Question

Accepted Answer

Eine **Dockerfile** ist eine Textdatei mit Anweisungen zum **Erstellen eines Docker-Images** — sie beschreibt das Basis-Image, Abhängigkeiten, zu kopierende Dateien und wie die Anwendung ausgeführt wird. Sie macht Image-Builds reproduzierbar und versionskontrollierbar.

## Ein einfaches 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"]
```

## Wichtigste Anweisungen

```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 (häufig verwechselt)

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

## Warum es wichtig ist

Das Verständnis einer Dockerfile ist unverzichtbar, da sie der Weg ist, wie Docker-Images erstellt werden, daher ist das Schreiben einer Dockerfile eine grundlegende, alltägliche Docker-Fähigkeit.

Eine Dockerfile ermöglicht **reproduzierbare, versionskontrollierbare Image-Builds** — indem sie im Code genau beschreibt, wie man ein Image konstruiert (das Basis-Image, Abhängigkeiten, Dateien, Konfiguration und Run-Befehl), sodass jeder dasselbe Image konsistent erstellen kann, was zentral für Dockers Wert der Reproduzierbarkeit ist.

Das Verständnis der **wichtigsten Anweisungen** — `FROM` (das Basis-Image), `WORKDIR`, `COPY` (Dateien einbringen), `RUN` (Build-Zeit-Befehle ausführen, wie das Installieren von Abhängigkeiten), `ENV`, `EXPOSE` und `CMD`/`ENTRYPOINT` (definiert, was beim Container-Start ausgeführt wird) — ist notwendig, um effektive Dockerfiles für echte Anwendungen zu schreiben.

Eine besonders wichtige und häufig verwechselte Unterscheidung ist **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` führt zur **Build-Zeit** aus (Image konstruieren, z.B. Pakete installieren), während `CMD`/`ENTRYPOINT` definiert, was beim **Container-Start** ausgeführt wird (der Anwendungsbefehl) — dieses Verständnis verhindert häufige Fehler.

Kenntnis praktischer Muster (wie das Kopieren von Abhängigkeitsdateien vor Code für besseres Layer-Caching) spiegelt das Schreiben effizienter Dockerfiles wider.

Da das Erstellen von Images grundlegend für die Verwendung von Docker ist (jeder Docker-Workflow beinhaltet Images, und die Dockerfile ist, wie benutzerdefinierte Images erstellt werden), und da das Verständnis der Anweisungen und der Build-Zeit-vs-Runtime-Unterscheidung notwendig ist, um korrekte, effiziente Images zu erstellen, ist das Verständnis der Dockerfile wesentlich, häufig angewendetes Docker-Wissen — eine Kernfähigkeit für jeden, der Docker verwendet, der Mechanismus, der Dockers Reproducibility-Versprechen in die Praxis umsetzt, und eine quasi universelle Anforderung für die Containerisierung von Anwendungen.