Cos'è un Dockerfile e come si scrive?

Question

Accepted Answer

Un **Dockerfile** è un file di testo con istruzioni per **costruire un'immagine Docker** — descrive l'immagine base, le dipendenze, i file da copiare e come eseguire l'applicazione. Rende i build delle immagini riproducibili e controllabili in versione.

## Un Dockerfile di base

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

## Istruzioni chiave

```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 (comunemente confusi)

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

## Perché è importante

Comprendere il Dockerfile è essenziale perché è il modo in cui le immagini Docker vengono costruite, quindi scriverne uno è un'abilità Docker fondamentale e quotidiana.

Un Dockerfile fornisce **build di immagini riproducibili e controllabili in versione** — descrivendo in codice esattamente come costruire un'immagine (l'immagine base, le dipendenze, i file, la configurazione e il comando di esecuzione), in modo che chiunque possa costruire la stessa immagine in modo coerente, il che è centrale al valore di riproducibilità di Docker.

Comprendere le **istruzioni chiave** — `FROM` (l'immagine base), `WORKDIR`, `COPY` (portare file dentro), `RUN` (eseguire comandi in fase di build come l'installazione di dipendenze), `ENV`, `EXPOSE` e `CMD`/`ENTRYPOINT` (definire cosa viene eseguito all'avvio del container) — è necessario per scrivere Dockerfile efficaci per applicazioni reali.

Una distinzione particolarmente importante e comunemente confusa è **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` viene eseguito al **momento del build** (costruendo l'immagine, ad esempio installando pacchetti), mentre `CMD`/`ENTRYPOINT` definiscono cosa viene eseguito all'**avvio del container** (il comando dell'applicazione) — comprendere questo previene errori comuni.

Conoscere i pattern pratici (come copiare i file delle dipendenze prima del codice per un migliore caching dei layer) riflette la scrittura di Dockerfile efficienti.

Poiché costruire immagini è fondamentale per usare Docker (ogni flusso di lavoro Docker coinvolge immagini, e il Dockerfile è il modo in cui vengono costruite le immagini personalizzate), e poiché comprendere le istruzioni e la distinzione tra tempo di build e tempo di esecuzione è necessario per creare immagini corrette ed efficienti, comprendere il Dockerfile è una conoscenza Docker essenziale e frequentemente applicata — un'abilità fondamentale per chiunque usi Docker, il meccanismo che trasforma la promessa di riproducibilità di Docker in pratica e un requisito quasi universale per containerizzare applicazioni.