Dockerfile என்றால் என்ன மற்றும் நீங்கள் எவ்வாறு ஒன்றை எழுதுகிறீர்கள்?

Question

Accepted Answer

**Dockerfile** என்பது **Docker image-ஐ உருவாக்குவதற்கான** வழிமுறைகளைக் கொண்ட ஒரு text file ஆகும் — இது base image, dependencies, நகலெடுக்க வேண்டிய files மற்றும் application-ஐ எவ்வாறு இயக்குவது என்பதை விவரிக்கிறது. இது image builds-ஐ reproducible மற்றும் version-controllable ஆக்குகிறது.

## ஒரு basic Dockerfile

```dockerfile
# FROM — the base image to build on
FROM node:20-alpine

# WORKDIR — set the working directory inside the image
WORKDIR /app

# COPY dependency files first (for better layer caching)
COPY package*.json ./
# RUN — execute a command during the BUILD (install dependencies)
RUN npm install

# COPY the rest of the application code
COPY . .

# EXPOSE — document the port the app listens on
EXPOSE 3000

# CMD — the command to run when a CONTAINER starts
CMD ["node", "server.js"]
```

## முக்கிய வழிமுறைகள்

```text
FROM     → the base image (starting point) — REQUIRED, usually first
WORKDIR  → set the working directory for subsequent instructions
COPY/ADD → copy files from the host into the image
RUN      → execute a command at BUILD time (install packages, compile) → creates a layer
ENV      → set environment variables
EXPOSE   → document which port(s) the container listens on
CMD      → the default command to run when the container STARTS (one per Dockerfile)
ENTRYPOINT → the executable that runs (CMD provides default args to it)
ARG      → build-time variables
```

## RUN vs CMD vs ENTRYPOINT (பொதுவாக குழப்பமடையும்)

```text
RUN        → runs at BUILD time (builds the image — e.g. install dependencies)
CMD        → runs at CONTAINER START (the default command; overridable at run)
ENTRYPOINT → the main executable at start (CMD becomes its default arguments)
→ RUN builds the image; CMD/ENTRYPOINT define what runs when it starts.
```

## நீ முக்கியமாக இது ஏன்?

Docker images எவ்வாறு உருவாக்கப்படுகின்றன என்பதுதான் Dockerfile ஆகும் என்பதால், Dockerfile-ஐ புரிந்துகொள்வது அத்യাவசியம், எனவே ஒன்றை எழுதுவது ஒரு அடிப்படை, அன்றாட Docker skill ஆகும்.

Dockerfile **reproducible, version-controllable image builds** என்பதை வழங்குகிறது — image-ஐ எவ்வாறு உருவாக்குவது என்பதை code-ல் சரியாக விவரிக்கிறது (base image, dependencies, files, configuration, மற்றும் run command), எனவே யாரும் ஒரே image-ஐ consistently உருவாக்கலாம், இது Docker-ன் reproducibility value-ஓட் மையப்பகுதி.

**முக்கிய வழிமுறைகள்** — `FROM` (base image), `WORKDIR`, `COPY` (files-ஐ உள்ளே கொண்டுவர), `RUN` (build-time commands-ஐ execute செய்தல், dependencies install செய்வது போன்ற), `ENV`, `EXPOSE`, மற்றும் `CMD`/`ENTRYPOINT` (container தொடங்கும்போது என்ன run செய்வது என்பதை வரையறை செய்தல்) — புரிந்துகொள்வது real applications-க்கான effective Dockerfiles-ஐ எழுத வேண்டியதாக உள்ளது.

ப்ரத்யேকமாக முக்கியமான மற்றும் பொதுவாக-குழப்பமடையும் வேறுபாடு என்பது **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` என்பது **build time**-ல் execute செய்யப்படுகிறது (image-ஐ உருவாக்குதல், எ.கா. packages install செய்தல்), `CMD`/`ENTRYPOINT` என்பது **container start**-ல் என்ன run செய்வது என்பதை வரையறை செய்கிறது (application command) — இதை புரிந்துகொள்வது பொதுவான பிழைகளைத் தவிர்க்கும்.

பிரായोगिक patterns-ஐ அறிந்துகொள்வது (dependency files-ஐ code-க்கு முன்னால் copy செய்வது better layer caching-க்கு போன்ற) efficient Dockerfiles-ஐ எழுதுவதை பிரதிபலிக்கிறது.

Image-ஐ உருவாக்குவது Docker-ஐ பயன்படுத்துவதுக்கு அடிப்படையாக உள்ளது (ஒவ்வொரு Docker workflow-ம் images-ஐ உள்ளடக்கியுள்ளது, மற்றும் Dockerfile என்பது custom images-ஐ எவ்வாறு உருவாக்குவது என்பதாக உள்ளது), மற்றும் vanguards மற்றும் build-time-vs-runtime வேறுபாட்டை புரிந்துகொள்வது சரியான, efficient images-ஐ உருவாக்க வேண்டியதாக உள்ளது, Docker-ஓட் reproducibility promise-ஐ practice-ல் மாற்றும் mechanism ஆக உள்ளது மற்றும் applications-ஐ containerize செய்வதுக்கான near-universal requirement ஆக உள்ளது, Docker-ஐ பயன்படுத்தும் யாரும் அவசியமுள்ள அறிவு — Docker-ஓட் core skill.