Was ist der Unterschied zwischen ENTRYPOINT und CMD?

Question

Accepted Answer

**ENTRYPOINT** und **CMD** definieren beide, was beim Start eines Containers ausgeführt wird, erfüllen aber unterschiedliche Rollen und interagieren auf spezifische Weise. Das Verständnis des Unterschieds (und der beiden Formen — exec vs shell) ist wichtig, um Dockerfiles zu schreiben, die sich korrekt verhalten.

## CMD — der Standardbefehl (überschreibbar)

```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` stellt den **Standardbefehl** bereit, der durch jeden Befehl, der mit `docker run` angegeben wird, **vollständig überschrieben** wird.

## ENTRYPOINT — die feste ausführbare Datei

```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` setzt eine **feste ausführbare Datei**, die immer ausgeführt wird; Argumente zur Laufzeit werden **als ihre Argumente angehängt**, anstatt sie zu ersetzen.

## Gemeinsame Verwendung (das häufige Muster)

```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-Form vs Shell-Form

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

## Warum es wichtig ist

Das Verständnis des Unterschieds zwischen ENTRYPOINT und CMD ist wichtig für das **Schreiben von Dockerfiles, die sich korrekt verhalten**, daher ist es wertvolleres praktisches Wissen und ein häufig missverstandenes Thema.

Der Unterschied im Verhalten ist wichtig: **CMD** stellt einen Standardbefehl bereit, der durch jeden an `docker run` übergebenen Befehl **vollständig überschrieben** wird, während **ENTRYPOINT** eine feste ausführbare Datei setzt, die immer mit an sie **angehängten** Laufzeit-Argumenten läuft — unterschiedliche Verhaltensweisen, die beeinflussen, wie der Container auf Laufzeit-Argumente reagiert.

Das Verständnis des **häufigen Musters, sie zusammen zu verwenden** (`ENTRYPOINT` als Befehl und `CMD` als überschreibbare Standardargumente) ist ein sauberer, idiomatischer Ansatz, der Container wie konfigurierbare ausführbare Dateien verhält — eine weit verbreitete Technik, die es wert ist, bekannt zu sein.

Wesentlich ist das Verständnis der **exec-Form vs Shell-Form** für die Korrektheit wichtig: Die **exec-Form** (JSON-Array, z. B. `CMD ["node", "server.js"]`) ist vorzuziehen, da sie die ausführbare Datei **direkt als PID 1** ausführt, sodass sie **Signale wie SIGTERM korrekt empfängt**, was **ordnungsgemäßes Herunterfahren** ermöglicht — während die **Shell-Form** (`CMD node server.js`) über eine Shell läuft, die PID 1 wird, oft dazu führt, dass die Anwendung **Shutdown-Signale nicht korrekt empfängt** (was zu ungraceful termination, verlorener laufender Arbeit oder langsamen Stopps führt).

Dieses Signal-Handling-/Graceful-Shutdown-Problem ist ein reales, subtiles Problem, das die exec-Form vermeidet.

Da die Definition dessen, was beim Start eines Containers läuft, grundlegend für jede Dockerfile ist, und da der ENTRYPOINT/CMD-Unterschied (und das exec-vs-shell-form-Signal-Handling-Problem) direkt das Container-Verhalten und die Korrektheit beeinflussen (Argument-Handling, ordnungsgemäßes Herunterfahren), ist das Verständnis von ENTRYPOINT vs CMD — ihre Rollen, wie sie zusammenpassen, und die wichtige exec-form-for-signals-Praxis — wertvolleres, praktisch relevantes Docker-Wissen, ein häufig missverstandenes Thema, bei dem das Verständnis der Unterschiede reale Verhaltens- und Shutdown-Bugs verhindert.