Czym jest Dockerfile i jak się go pisze?

Question

Accepted Answer

**Dockerfile** to plik tekstowy z instrukcjami do **budowania obrazu Docker** — opisuje obraz bazowy, zależności, pliki do skopiowania i sposób uruchomienia aplikacji. Sprawia, że budowanie obrazów jest powtarzalne i kontrolowane wersjami.

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

## Kluczowe instrukcje

```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 (często mylone)

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

## Dlaczego to ważne

Zrozumienie Dockerfile jest niezbędne, ponieważ w ten sposób budowane są obrazy Docker, a pisanie go jest fundamentalną, codzienną umiejętnością pracy z Dockerem.

Dockerfile zapewnia **powtarzalne, kontrolowane wersjami budowanie obrazów** — opisując w kodzie dokładnie, jak skonstruować obraz (obraz bazowy, zależności, pliki, konfigurację i polecenie uruchomienia), dzięki czemu każdy może konsekwentnie budować ten sam obraz, co jest kluczowe dla wartości, jaką Docker przynosi poprzez powtarzalność.

Zrozumienie **kluczowych instrukcji** — `FROM` (obraz bazowy), `WORKDIR`, `COPY` (przenoszenie plików), `RUN` (wykonywanie poleceń w czasie budowania, takich jak instalacja zależności), `ENV`, `EXPOSE` i `CMD`/`ENTRYPOINT` (definiowanie tego, co uruchamia się po starcie kontenera) — jest konieczne do pisania efektywnych Dockerfile'i dla rzeczywistych aplikacji.

Szczególnie ważne i często mylone rozróżnienie to **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` wykonuje się w **czasie budowania** (konstruowanie obrazu, np. instalacja pakietów), podczas gdy `CMD`/`ENTRYPOINT` definiują to, co uruchamia się przy **starcie kontenera** (polecenie aplikacji) — zrozumienie tego zapobiega powszechnym błędom.

Znajomość praktycznych wzorów (takich jak kopiowanie plików zależności przed kodem dla lepszego cachowania warstw) odzwierciedla pisanie efektywnych Dockerfile'i.

Ponieważ budowanie obrazów jest fundamentalne dla używania Dockera (każdy przepływ pracy z Dockerem obejmuje obrazy, a Dockerfile to sposób, w jaki budowane są obrazy niestandardowe), i ponieważ zrozumienie instrukcji oraz rozróżnienia między czasem budowania a czasem uruchomienia jest konieczne do tworzenia poprawnych i efektywnych obrazów, zrozumienie Dockerfile jest niezbędną, często stosowaną wiedzą o Dockerze — umiejętnością podstawową dla każdego używającego Docker, mechanizmem zamieniającym obietnicę powtarzalności Dockera w praktykę i uniwersalnym wymogiem dla konteneryzacji aplikacji.