Co je Dockerfile a jak se píše?

Question

Accepted Answer

**Dockerfile** je textový soubor s instrukcemi pro **vytváření Docker image** — popisuje základní image, závislosti, soubory ke kopírování a jak spustit aplikaci. Umožňuje reproducibilní a verzovatelné vytváření image.

## Základní 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"]
```

## Klíčové instrukce

```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 (často zaměňované)

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

## Proč na to záleží

Rozmění si Dockerfile je nezbytné, protože je to způsob, jak se Docker image vytváří, takže napsání jednoho je základní, každodenní Docker skill.

Dockerfile poskytuje **reproducibilní, verzovatelné vytváření image** — popisuje v kódu přesně, jak konstruovat image (základní image, závislosti, soubory, konfiguraci a spouštěcí příkaz), aby kdokoli mohl konzistentně sestavit stejný image, což je ústřední část Docker hodnoty reproducibility.

Rozmění si **klíčové instrukce** — `FROM` (základní image), `WORKDIR`, `COPY` (přinesení souborů), `RUN` (spouštění příkazů v čase buildu, jako instalace závislostí), `ENV`, `EXPOSE` a `CMD`/`ENTRYPOINT` (definování co se spustí při startu kontejneru) — je nutné pro psaní efektivních Dockerfilů pro reálné aplikace.

Partikulárně důležité a často zaměňované rozlišení je **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` se spouští v čase **buildu** (konstruování image, např. instalace balíčků), zatímco `CMD`/`ENTRYPOINT` definují co se spustí při **startu kontejneru** (aplikační příkaz) — pochopení tohoto zabraňuje běžným chybám.

Znalost praktických vzorů (jako kopírování souborů závislostí před kódem pro lepší layer caching) odráží psaní efektivních Dockerfilů.

Jelikož vytváření image je fundamentální pro používání Dockeru (každý Docker workflow zahrnuje image a Dockerfile je způsob jak se vlastní image vytváří), a jelikož pochopení instrukcí a rozlišení mezi build-time a runtime je nutné pro vytváření správných, efektivních image, je porozumění Dockerfile nezbytná, často používaná Docker znalost — základní skill pro každého, kdo Docker používá, mechanismus, který Docker reproducibility promise mění v praxi a prakticky univerzální požadavek pro kontejnerizaci aplikací.