Qu'est-ce qu'un Dockerfile et comment en écrire un ?

Question

Accepted Answer

Un **Dockerfile** est un fichier texte contenant des instructions pour **construire une image Docker** — il décrit l'image de base, les dépendances, les fichiers à copier et comment lancer l'application. Il rend les constructions d'images reproductibles et contrôlables en version.

## Un Dockerfile basique

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

## Instructions clés

```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 (souvent confondus)

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

## Pourquoi c'est important

Comprendre le Dockerfile est essentiel car c'est comme cela que les images Docker sont construites, donc en écrire un est une compétence Docker fondamentale et quotidienne.

Un Dockerfile fournit des **constructions d'images reproductibles et contrôlables en version** — décrivant en code exactement comment construire une image (l'image de base, les dépendances, les fichiers, la configuration et la commande de lancement), afin que n'importe qui puisse construire la même image de manière cohérente, ce qui est central à la valeur de reproductibilité de Docker.

Comprendre les **instructions clés** — `FROM` (l'image de base), `WORKDIR`, `COPY` (importer des fichiers), `RUN` (exécuter des commandes au moment de la construction comme l'installation de dépendances), `ENV`, `EXPOSE` et `CMD`/`ENTRYPOINT` (définir ce qui s'exécute au démarrage du conteneur) — est nécessaire pour écrire des Dockerfiles efficaces pour de vraies applications.

Une distinction particulièrement importante et souvent confondue est **`RUN` vs `CMD` vs `ENTRYPOINT`** : `RUN` s'exécute au **moment de la construction** (construction de l'image, par exemple installation de paquets), tandis que `CMD`/`ENTRYPOINT` définissent ce qui s'exécute au **démarrage du conteneur** (la commande de l'application) — comprendre cela prévient les erreurs courantes.

Connaître les patterns pratiques (comme copier les fichiers de dépendances avant le code pour un meilleur cache des couches) reflète l'écriture de Dockerfiles efficaces.

Puisque construire des images est fondamental pour utiliser Docker (chaque workflow Docker implique des images, et le Dockerfile est comment les images personnalisées sont construites), et puisque comprendre les instructions et la distinction temps de construction versus temps d'exécution est nécessaire pour créer des images correctes et efficaces, comprendre le Dockerfile est une connaissance Docker essentielle et fréquemment appliquée — une compétence fondamentale pour quiconque utilise Docker, le mécanisme qui transforme la promesse de reproductibilité de Docker en pratique et une exigence quasi-universelle pour containeriser des applications.