Quelle est la différence entre ENTRYPOINT et CMD ?

Question

Accepted Answer

**ENTRYPOINT** et **CMD** définissent tous les deux ce qui s'exécute au démarrage d'un conteneur, mais ils jouent des rôles différents et interagissent de façons spécifiques. Comprendre la différence (et les deux formes — exec vs shell) est important pour écrire des Dockerfile qui se comportent correctement.

## CMD — la commande par défaut (remplaçable)

```dockerfile
CMD ["node", "server.js"]
# → the DEFAULT command when the container starts
# → but it's REPLACED if you pass a command at run time:
#   docker run myapp echo hello   → runs "echo hello" INSTEAD of node server.js
```

`CMD` fournit la **commande par défaut**, qui est **entièrement remplacée** par toute commande passée à `docker run`.

## ENTRYPOINT — l'exécutable fixe

```dockerfile
ENTRYPOINT ["node", "server.js"]
# → ALWAYS runs; run-time arguments are APPENDED (not replacing it):
#   docker run myapp --port 8080   → runs "node server.js --port 8080"
# → makes the container behave like a specific executable
```

`ENTRYPOINT` définit un **exécutable fixe** qui s'exécute toujours ; les arguments au moment de l'exécution sont **ajoutés** comme ses arguments plutôt que de le remplacer.

## Les utiliser ensemble (le modèle courant)

```dockerfile
ENTRYPOINT ["node", "server.js"]   # the fixed command
CMD ["--port", "3000"]              # DEFAULT arguments (overridable)
# docker run myapp                  → node server.js --port 3000 (defaults)
# docker run myapp --port 8080      → node server.js --port 8080 (CMD overridden)
→ ENTRYPOINT = the command; CMD = default arguments you can override. A clean pattern.
```

## Forme exec vs forme shell

```text
EXEC form  → CMD ["node", "server.js"]  (JSON array) — PREFERRED:
  runs the executable DIRECTLY (PID 1) → receives signals (SIGTERM) → graceful shutdown
SHELL form → CMD node server.js  → runs via /bin/sh -c → the shell is PID 1,
  the app may NOT receive signals properly (shutdown issues) → avoid for the main process
```

## Pourquoi c'est important

Comprendre la différence entre ENTRYPOINT et CMD est important pour **écrire des Dockerfile qui se comportent correctement**, c'est donc une connaissance pratique précieuse et un sujet souvent source de confusion.

La distinction dans le comportement est importante : **CMD** fournit une commande par défaut qui est **entièrement remplacée** par toute commande passée à `docker run`, tandis que **ENTRYPOINT** définit un exécutable fixe qui s'exécute toujours avec les arguments au moment de l'exécution **ajoutés** à celui-ci — des comportements différents qui affectent la façon dont le conteneur répond aux arguments au moment de l'exécution.

Comprendre le **modèle courant de les utiliser ensemble** (`ENTRYPOINT` comme la commande et `CMD` comme arguments par défaut remplaçables) est une approche propre et idiomatique qui rend les conteneurs comportés comme des exécutables configurables — une technique largement utilisée qui vaut la peine d'être connue.

Critiquement, comprendre la **forme exec vs forme shell** est important pour la correction : la **forme exec** (tableau JSON, par exemple `CMD ["node", "server.js"]`) est préférable car elle exécute l'exécutable **directement en tant que PID 1**, donc elle **reçoit les signaux comme SIGTERM** correctement, permettant **l'arrêt gracieux** — tandis que la **forme shell** (`CMD node server.js`) s'exécute via un shell qui devient PID 1, ce qui fait souvent que l'application **ne reçoit pas correctement les signaux d'arrêt** (conduisant à une résiliation non gracieuse, au travail en vol perdu, ou à des arrêts lents).

Ce problème de gestion des signaux/arrêt gracieux est un problème réel et subtil que la forme exec évite.

Puisque définir ce qui s'exécute au démarrage d'un conteneur est fondamental pour tout Dockerfile, et puisque la distinction ENTRYPOINT/CMD (et la préoccupation de gestion des signaux forme exec vs shell) affecte directement le comportement et la correction du conteneur (gestion des arguments, arrêt gracieux), comprendre ENTRYPOINT vs CMD — leurs rôles, comment ils se combinent, et la pratique importante de la forme exec pour les signaux — est une connaissance Docker précieuse et pratiquement pertinente, un sujet couramment mal compris où la compréhension des différences prévient les vrais bugs de comportement et d'arrêt.