Vad är skillnaden mellan ENTRYPOINT och CMD?

Question

Accepted Answer

**ENTRYPOINT** och **CMD** definierar båda vad som körs när en behållare startar, men de har olika roller och interagerar på specifika sätt. Det är viktigt att förstå skillnaden (och de två formerna — exec vs shell) för att skriva Dockerfiler som beter sig korrekt.

## CMD — standardkommandot (som kan åsidosättas)

```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` tillhandahåller **standardkommandot**, vilket **helt åsidosätts** av alla kommandon som anges på `docker run`.

## ENTRYPOINT — den fasta körbara filen

```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` anger en **fast körbar fil** som alltid körs; körtidsargument **läggas till** som dess argument istället för att ersätta det.

## Att använda dem tillsammans (det vanliga mönstret)

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

## Varför det är viktigt

Att förstå skillnaden mellan ENTRYPOINT och CMD är viktigt för **att skriva Dockerfiler som beter sig korrekt**, så det är värdefull praktisk kunskap och ett vanligt missförstådd ämne.

Skillnaden i beteende är betydelsefull: **CMD** tillhandahåller ett standardkommando som **helt åsidosätts** av alla kommandon som skickas till `docker run`, medan **ENTRYPOINT** anger en fast körbar fil som alltid körs med körtidsargument **tillagda** till den — olika beteenden som påverkar hur behållaren reagerar på körtidsargument.

Att förstå **det vanliga mönstret för att använda dem tillsammans** (`ENTRYPOINT` som kommandot och `CMD` som åsidosättbara standardargument) är en ren, idiomatisk approach som får behållare att bete sig som konfigurerbara körbara filer — en ofta använd teknik som är värd att känna till.

Viktigt är att förstå **exec-form vs shell-form** för korrekthet: **exec-formen** (JSON-array, t.ex. `CMD ["node", "server.js"]`) är att föredra eftersom den kör den körbara filen **direkt som PID 1**, så den **mottar signaler som SIGTERM** korrekt, vilket möjliggör **graciös avstängning** — medan **shell-formen** (`CMD node server.js`) körs via ett skal som blir PID 1, ofta causing applicationen till **inte mottar avstängningssignaler korrekt** (leading to ungraceful termination, lost in-flight work, eller slow stops).

Detta signalhantering/graciös-avstängnings-problem är ett verkligt, subtilt problem som exec-formen undviker.

Since definiering vad som körs när en behållare startar är grundläggande för varje Dockerfile, och since ENTRYPOINT/CMD-skillnaden (och exec-vs-shell-form signalhantering-oron) direkt påverkar behållarens beteende och korrekthet (argumenthantering, graciös avstängning), är förståelse för ENTRYPOINT vs CMD — deras roller, hur de kombineras, och den viktiga exec-form-for-signals-praktiken — värdefull, praktiskt relevant Docker-kunskap, ett vanligt missförstått ämne där förståelse för skillnaderna förhindrar verkliga beteende- och avstängningsfel.