Wat is het verschil tussen ENTRYPOINT en CMD?

Question

Accepted Answer

**ENTRYPOINT** en **CMD** bepalen beide wat wordt uitgevoerd wanneer een container start, maar ze vervullen verschillende rollen en werken op specifieke manieren samen. Het begrijpen van het verschil (en de twee vormen — exec vs shell) is belangrijk voor het schrijven van Dockerfiles die correct werken.

## CMD — de standaardcommando (overschrijfbaar)

```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` biedt de **standaardcommando**, die **volledig wordt overschreven** door een commando dat op `docker run` wordt gegeven.

## ENTRYPOINT — het vaste uitvoerbare bestand

```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` stelt een **vast uitvoerbaar bestand** in dat altijd wordt uitgevoerd; runtime-argumenten worden **toegevoegd** als argumenten ervan in plaats van het te vervangen.

## Ze samen gebruiken (het standaardpatroon)

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

## Exec-vorm versus shell-vorm

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

## Waarom het belangrijk is

Het begrijpen van het verschil tussen ENTRYPOINT en CMD is belangrijk voor het **schrijven van Dockerfiles die correct werken**, dus het is waardevolle praktische kennis en een veelgehoord onderwerp dat tot verwarring leidt.

Het onderscheid in gedrag is van belang: **CMD** biedt een standaardcommando dat **volledig wordt overschreven** door een commando dat aan `docker run` wordt doorgegeven, terwijl **ENTRYPOINT** een vast uitvoerbaar bestand instelt dat altijd wordt uitgevoerd met runtime-argumenten **eraan toegevoegd** — verschillende gedragingen die beïnvloeden hoe de container reageert op runtime-argumenten.

Het begrijpen van het **standaardpatroon om ze samen te gebruiken** (`ENTRYPOINT` als het commando en `CMD` als overschrijfbare standaardargumenten) is een schone, idomatische aanpak die containers laat gedragen als configureerbare uitvoerbare bestanden — een veel gebruikte techniek die de moeite waard is om te kennen.

Kritisch is het begrijpen van de **exec-vorm versus shell-vorm** belangrijk voor juistheid: de **exec-vorm** (JSON-array, bijv. `CMD [