Mi az a Dockerfile és hogyan írunk egyet?

Question

Accepted Answer

A **Dockerfile** egy szövegfájl, amely utasításokat tartalmaz egy **Docker image felépítéséhez** — leírja az alapképet, a függőségeket, a másolandó fájlokat és az alkalmazás futtatásának módját. Reprodukálható és verziókezelésre alkalmas image buildeket biztosít.

## Egy alapszintű 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"]
```

## Kulcsfontosságú utasítások

```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 (gyakran összekeverik)

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

## Miért fontos

A Dockerfile megértése lényeges, mivel így épülnek fel a Docker imagek, ezért egy írása alapvető, napi Docker-feladat.

A Dockerfile **reprodukálható, verziókezelésre alkalmas image buildeket** biztosít — kódban pontosan leírja, hogyan kell összeépíteni egy image-t (az alapkép, függőségek, fájlok, konfiguráció és futtatási parancs), így bárki konzisztensen felépítheti ugyanazt az image-t, amely központi szerepet játszik a Docker reprodukálhatóságának értékében.

A **kulcsfontosságú utasítások** megértése — `FROM` (az alapkép), `WORKDIR`, `COPY` (fájlok bevezetése), `RUN` (build-time parancsok végrehajtása, például függőségek telepítése), `ENV`, `EXPOSE` és `CMD`/`ENTRYPOINT` (definiálja, mi fut a konténer indításakor) — szükséges ahhoz, hogy hatékony Dockerfile-okat írjunk valós alkalmazásokhoz.

Különösen fontos és gyakran összekeverik a **`RUN` vs `CMD` vs `ENTRYPOINT`** megkülönböztetést: a `RUN` **build-time-ban** hajtódik végre (az image felépítése, pl. csomagok telepítése), míg a `CMD`/`ENTRYPOINT` definiálja, mi fut **konténer indításkor** (az alkalmazás parancs) — ennek megértése megelőzi a gyakori hibákat.

A gyakorlati minták ismerete (például a függőségi fájlok másolása a kód előtt a jobb layer-cache-eléshez) azt tükrözi, hogy hatékony Dockerfile-okat írunk.

Mivel az image-ek felépítése alapvető a Docker használatához (minden Docker munkafolyamat image-eket tartalmaz, és a Dockerfile az az eszköz, amellyel egyedi image-eket hozunk létre), és mivel az utasítások és a build-time-vs-runtime megkülönböztetés megértése szükséges a helyes, hatékony image-ek létrehozásához, a Dockerfile megértése lényeges, gyakran alkalmazott Docker-tudás — alapvető készség bárki számára, aki Dockert használ, az a mechanizmus, amely a Docker reprodukálhatósági ígéretét gyakorlattá alakítja, és szinte általános követelmény alkalmazások containerizálásához.