ENTRYPOINT மற்றும் CMD இடையே உள்ள வேறுபாடு என்ன?

Question

Accepted Answer

**ENTRYPOINT** மற்றும் **CMD** இரண்டும் கொள்கலன் தொடங்கும் போது என்ன இயங்க வேண்டும் என்பதை வரையறுக்கின்றன, ஆனால் அவை வெவ்வேறு பாத்திரங்களை வகிக்கின்றன மற்றும் குறிப்பிட்ட வழிகளில் தொடர்பு கொள்கின்றன. வேறுபாட்டையும் (exec vs shell என்ற இரண்டு வடிவங்கள்) புரிந்துகொள்வது சரியாக செயல்படும் Dockerfile கள் எழுத பதவிக்கப்படும் வெளிப்பாட்டை உருவாக்க முக்கியமாகும்.

## CMD — முன்னிருப்பு கட்டளை (மேலெழுதக்கூடிய)

```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` இல் கொடுக்கப்பட்ட எந்த கட்டளையாலும் **முழுவதுமாக மேலெழுதப்படும்**.

## ENTRYPOINT — நிலையான செயல்பாடு

```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` **நிலையான செயல்பாடு** அமைக்கிறது அது எப்போதும் இயங்குகிறது; இயக்க-நேர வாதங்கள் அதன் வாதங்களாக **சேர்க்கப்படுகின்றன** அதை மாற்றுவதற்குப் பதிலாக.

## அவற்றை ஒன்றாகப் பயன்படுத்துதல் (பொதுவான முறை)

```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 வடிவம் vs 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
```

## ஏன் இது முக்கியமாக உள்ளது

ENTRYPOINT மற்றும் CMD இடையே உள்ள வேறுபாட்டைப் புரிந்துகொள்வது **சரியாக செயல்படும் Dockerfile களை எழுதுவதற்கு** முக்கியமாகும், எனவே இது மূல்யமான நடைமுறை அறிவு மற்றும் பொதுவாக குழப்பமான பொருள் ஆகும்.

আচরணத்தின் வேறுபாடு முக்கியமாகும்: **CMD** **முற்றிலும் மேலெழுதப்படும்** முன்னிருப்பு கட்டளை வழங்குகிறது `docker run` க்கு கடந்து செல்லப்பட்ட எந்த கட்டளையாலும், அதே சமயம் **ENTRYPOINT** நிலையான செயல்பாட்டை அமைக்கிறது அது எப்போதும் இயக்க-நேர வாதங்கள் **சேர்க்கப்படுகின்றன** அதற்கு — வெவ்வேறு வழிமுறைகள் கொள்கலன் இயக்க-நேர வாதங்களுக்கு எப்படி பதிலளிக்கிறது என்பதை பாதிக்கிறது.

அவற்றை ஒன்றாகப் பயன்படுத்துதலின் **பொதுவான முறை** (`ENTRYPOINT` கட்டளையாகவும் `CMD` மேலெழுதக்கூடிய முன்னிருப்பு வாதங்களாகவும்) புரிந்துகொள்வது சுத்தமான, உச்சரிப்பு முறைமைக் கொள்கலன்களை வடிவமைக்கக்கூடிய செயல்பாடுகள் போல் நடந்துகொள்ள செய்கிறது — பரவலாக பயன்படுத்தப்படும் நுணுக்கம் மதிப்புள்ளது.

முக்கியமாக, **exec வடிவம் vs shell வடிவம்** புரிந்துகொள்வது சரிசெய்தலுக்கு முக்கியமாகும்: **exec வடிவம்** (JSON array, e.g. `CMD ["node", "server.js"]`) விருப்பமாக இருக்கிறது ஏனெனில் அது செயல்பாட்டை **நேரடியாக PID 1 ஆக இயங்குகிறது**, எனவே அது **SIGTERM போன்ற சமிக்ஞைகளை சரியாக பெறுகிறது** செயல்பாட்டைக் கொண்ட **graceful shutdown** ஆதரவு அளிக்கிறது — அதே சமயம் **shell வடிவம்** (`CMD node server.js`) shell மூலம் இயங்குகிறது அது PID 1 ஆ, பொதுவாக **shutdown சமிக்ஞைகளை சரியாக பெற மாட்டார்** (ungraceful termination க்கு வழிவகுக்கிறது, in-flight வேலை இழந்து, அல்லது மெதுவாக நிறுத்துகிறது).

இந்த சமிக்ஞை-கையாளுதல்/graceful-shutdown சிக்கல் உண்மையான, நுட்பமான சிக்கல் exec வடிவம் தவிர்க்கிறது.

கொள்கலன் தொடங்கும் போது என்ன இயங்க வேண்டும் என்பதை வரையறுப்பது ஒவ்வொரு Dockerfile க்கும் அடிப்படை, மற்றும் ENTRYPOINT/CMD வேறுபாடு (மற்றும் exec-vs-shell-வடிவ-சமிக்ஞை-கையாளுதல் கவலை) கொள்கலன் நடத்தை மற்றும் சரிசெய்தலை நேரடியாக பாதிக்கிறது (வாதம் கையாளுதல், graceful shutdown), புரிந்துகொள்வது ENTRYPOINT vs CMD — அவற்றின் பாத்திரங்கள், அவை எப்படி ஒன்றாகிறது, மற்றும் முக்கியமான exec-வடிவ-சமிக்ஞைகளுக்கான நடைமுறை — மூல்யமான, நடைமுறை சம்பந்தமான Docker அறிவு, பொதுவாக தவறாக புரிந்துகொள்ளப்படும் பொருள் அங்கு புரிந்துகொள்வது வேறுபாடுகளை நিவர்த்தி செய்கிறது உண்மையான நடத்தை மற்றும் shutdown பிழைகளை.