ENTRYPOINT અને CMD વચ્ચે શું તફાવત છે?

Question

Accepted Answer

**ENTRYPOINT** અને **CMD** બંને કન્ટેનર શરૂ થાય છે ત્યારે શું ચલાવવું તે વ્યાખ્યાયિત કરે છે, પરંતુ તેઓ વિવિધ ભૂમિકાઓ ભજવે છે અને ચોક્કસ રીતે ક્રિયાપ્રતিક્રિયા કરે છે. તફાવત (અને બે ફોર્મ્સ — exec વિરુદ્ધ shell) સમજવું એ જરૂરી છે કે Dockerfiles લખતા સમયે તે યોગ્ય રીતે વર્તે.

## CMD — ડિફોલ્ટ કમાન્ડ (overridable)

```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` **ડિફોલ્ટ કમાન્ડ** પ્રદાન કરે છે, જે `docker run` પર આપવામાં આવેલ કોઈપણ કમાન્ડ દ્વારા **સંપૂર્ણપણે override** થાય છે.

## ENTRYPOINT — fixed executable

```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` **fixed executable** સેટ કરે છે જે હંમેશા ચલાય છે; run-time arguments તેના arguments તરીકે **appended** થાય છે તેને બદલે તેને બદલવાની જગ્યાએ.

## તેમને એક સાથે વાપરવું (સામાન્ય પેટર્ન)

```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 વિરુદ્ધ 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
```

## આ શા માટે મહત્વપૂર્ણ છે

ENTRYPOINT અને CMD વચ્ચેનો તફાવત સમજવો **યોગ્ય રીતે વર્તે તેવી Dockerfiles લખવા** માટે મહત્વપૂર્ણ છે, તેથી તે મૂલ્યવાન વ્યવહારિક જ્ઞાન અને સામાન્ય રીતે ગૂંચવણમાં પડતું વિષય છે.

વર્તનમાં તફાવત મહત્વપૂર્ણ છે: **CMD** ડિફોલ્ટ કમાન્ડ પ્રદાન કરે છે જે `docker run` પર પસાર કરવામાં આવેલ કોઈપણ કમાન્ડ દ્વારા **સંપૂર્ણપણે override** થાય છે, જ્યારે **ENTRYPOINT** fixed executable સેટ કરે છે જે હંમેશા ચલાય છે run-time arguments તેના પર **appended** સાથે — વિવિધ વર્તણૂક જે કન્ટેનર run-time arguments માટે કેવી રીતે પ્રતિક્રિયા આપે છે તેને અસર કરે છે.

તેમને **એક સાથે વાપરવાનો સામાન્ય પેટર્ન** સમજવું (`ENTRYPOINT` કમાન્ડ તરીકે અને `CMD` overridable ડિફોલ્ટ arguments તરીકે) એ સ્વચ્છ, idiomatic અભિગમ છે જે કન્ટેનરને configurable executables તરીકે વર્તે છે — વ્યાપક રીતે વાપરવામાં આવતી તકનીક જે જાણવી યોગ્ય છે.

odhani રીતે, **exec form વિરુદ્ધ shell form** સમજવું સુધારણા માટે મહત્વપૂર્ણ છે: **exec form** (JSON array, ઉદાહરણ તરીકે `CMD ["node", "server.js"]`) પસંદ છે કારણ કે તે executable **સીધા PID 1 તરીકે** ચલાવે છે, તેથી તે **SIGTERM જેવા signals** યોગ્ય રીતે **પ્રાપ્ત કરે છે**, **graceful shutdown** સક્ષમ કરે છે — જ્યારે **shell form** (`CMD node server.js`) shell દ્વારા ચલાવે છે જે PID 1 બને છે, ઘણીવાર application **shutdown signals યોગ્ય રીતે પ્રાપ્ત કરતું નથી** (ungraceful termination તરફ દોરી જાય છે, in-flight work ખોવાય છે, અથવા slow stops).

यह signal-handling/graceful-shutdown મુદ્દો એક વાસ્તવિક, સૂક્ષ્મ સમસ્યા છે જે exec form ટાળે છે.

કન્ટેનર શરૂ થાય ત્યારે શું ચલાવવું તે વ્યાખ્યાયિત કરવું પ્રત્યેક Dockerfile માટે મૂળભૂત છે, અને ENTRYPOINT/CMD તફાવત (અને exec-vs-shell-form signal-handling વ્યંજના) કન્ટેનર વર્તણૂક અને સુધારણાને સીધી અસર કરે છે (argument handling, graceful shutdown), ENTRYPOINT વિરુદ્ધ CMD સમજવું — તેમની ભૂમિકાઓ, તેઓ કેવી રીતે સંયોજિત થાય છે, અને મહત્વપૂર્ણ exec-form-for-signals અભ્યાસ — મૂલ્યવાન, વ્યવહારિક રીતે પ્રાસંગિક Docker જ્ઞાન છે, સામાન્ય રીતે ગૂંચવણમાં પડતું વિષય જ્યાં તફાવત સમજવું વર્તણૂક અને shutdown bugs ને રોકે છે.