Ce este un Dockerfile și cum se scrie unul?

Question

Accepted Answer

Un **Dockerfile** este un fișier text cu instrucțiuni pentru **construirea unei imagini Docker** — descrie imaginea de bază, dependențele, fișierele de copiat și cum se rulează aplicația. Face construcția imaginilor reproducibilă și controlabilă din punct de vedere al versiunilor.

## Un Dockerfile de bază

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

## Instrucțiuni cheie

```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 (frecvent confundate)

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

## De ce este important

Înțelegerea Dockerfile-ului este esențială deoarece acesta este modul în care sunt construite imaginile Docker, deci scrierea unuia este o abilitate fundamentală și cotidiană în Docker.

Un Dockerfile oferă **construcții de imagini reproducibile și controlabile din punct de vedere al versiunilor** — descriind în cod exact cum să se construiască o imagine (imaginea de bază, dependențe, fișiere, configurație și comanda de execuție), astfel încât oricine poate construi aceeași imagine în mod consistent, ceea ce este central pentru valoarea Docker a reproducibilității.

Înțelegerea **instrucțiunilor cheie** — `FROM` (imaginea de bază), `WORKDIR`, `COPY` (aducerea fișierelor), `RUN` (executarea comenzilor în timp de construcție, cum ar fi instalarea dependențelor), `ENV`, `EXPOSE` și `CMD`/`ENTRYPOINT` (definirea ceea ce se rulează când containerul pornește) — este necesară pentru a scrie Dockerfile-uri eficiente pentru aplicații reale.

O distincție deosebit de importantă și frecvent confuzată este **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` se execută în **timp de construcție** (construind imaginea, de exemplu instalând pachete), în timp ce `CMD`/`ENTRYPOINT` definesc ce se rulează la **pornirea containerului** (comanda aplicației) — înțelegerea acestui lucru previne greșeli frecvente.

Cunoașterea modelelor practice (cum ar fi copierea fișierelor de dependență înainte de cod pentru cache mai bun al straturilor) reflectă scrierea unor Dockerfile-uri eficiente.

Deoarece construirea imaginilor este fundamentală pentru utilizarea Docker (fiecare flux de lucru Docker implică imagini, iar Dockerfile-ul este modul în care sunt construite imaginile personalizate), și deoarece înțelegerea instrucțiunilor și a distincției dintre timp de construcție și timp de execuție este necesară pentru a crea imagini corecte și eficiente, înțelegerea Dockerfile-ului este cunoștințe Docker esențiale și frecvent aplicate — o abilitate de bază pentru oricine folosește Docker, mecanismul care transformă promisiunea reproducibilității Docker în practică și o cerință aproape universală pentru containerizarea aplicațiilor.