📝 धडा 03 — Dockerfile: recipe card वाचणे

📍 तुम्ही इथे आहात: 12 पैकी धडा 03 · मागे: lesson-02-images-layers · पुढे: lesson-04-run-containers

📦 या ब्रँचमध्ये काय आहे

धडे 01–02, आणि त्याशिवाय: Dockerfile, ओळ-ओळ. सात instructions तुम्ही कधीही वाचाल अशा बहुतेक Dockerfiles व्यापतात. खरी file:

app/Dockerfile — भरपूर comments असलेली, या धड्याचे पाठ्यपुस्तक

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

तुमचा डबा भरण्यासाठी आईचे recipe card 📝:

"दुकानातल्या साध्या डब्यापासून सुरुवात कर" — FROM node:20-alpine. कच्च्या plastic पासून कधीच डबा बनवू नका; चांगल्या तयार डब्यापासून सुरुवात करा.
"स्वयंपाकघराच्या ओट्यावर काम कर" — WORKDIR /app. पुढच्या सगळ्या पायऱ्या तिथेच होतात.
"अन्न आत ठेव" — COPY server.js . — तुमचे सामान डब्यात जाते.
"default settings झाकणावर चिकटव" — ENV PORT=3000. पुन्हा पॅक न करता जेवणाच्या वेळी बदलता येतात.
"लेबलवर 'खिडकी 3000 वर उघडतो' असे लिही" — EXPOSE 3000. हे फक्त माणसांसाठीचे लेबल आहे — ते स्वतःहून काहीच उघडत नाही!
"हा डबा मुलीचा आहे, मुख्याध्यापिकांचा नाही" — USER node. डब्याला गरज नसलेल्या महाशक्ती देऊ नका.
"डबा उघडल्यावर असे खा" — CMD ["node","server.js"]. एक डबा, एक पदार्थ: container foreground मध्ये एक मुख्य process चालवतो. ती process संपली की जेवण संपले.

🗺️ आकृती

flowchart TB
    subgraph df["📝 app/Dockerfile"]
        f["FROM node:20-alpine"]
        w["WORKDIR /app"]
        c["COPY server.js ."]
        e["ENV PORT=3000 · EXPOSE 3000"]
        u["USER node"]
        cmd["CMD node server.js"]
        f --> w --> c --> e --> u --> cmd
    end
    f -.->|"1 pre-baked base"| f
    c -.->|"2 your code enters"| c
    e -.->|"3 defaults + label"| e
    cmd -.->|"4 what runs on open"| cmd

❓ काय

FROM — base image (नेहमी version pin करा: node:20-alpine, कधीही फक्त node नाही).
WORKDIR — पुढच्या सगळ्या पायऱ्यांसाठी cd (directory ही बनवते).
COPY — build context मधून → image मध्ये files. .dockerignore context गाळते.
RUN — BUILD वेळी command चालवते (deps install, compile). आपल्याला त्याची गरज नाही — शून्य dependencies! मोठी ॲप्स: RUN npm ci.
ENV — default env vars, run वेळी बदलता येतात (-e).
EXPOSE — ऐकणाऱ्या port ची नोंद (खरे उघडणे -p ने होते, धडा 04).
USER — process कोणता user चालवतो (धडा 08: कधीही root नाही).
CMD — सुरू होताना चालणारी default command. ENTRYPOINT हा त्याचा जास्त कडक चुलतभाऊ — गरज पडेल तेव्हा त्याची ओळख करून घ्या, आधी नाही.
Build time विरुद्ध run time हीच मुख्य मानसिक विभागणी: RUN build वेळी एकदाच घडते; CMD/ENV प्रत्येक वेळी container सुरू होताना महत्त्वाचे असतात.

🧠 Instructions चा तक्ता (लगेच भेटणाऱ्या आठ)

Instruction	उद्देश	कधी चालते
`FROM`	base image	build
`WORKDIR`	पुढच्या पायऱ्यांसाठी working directory	build
`COPY`	build context मधून files copy करणे	build
`RUN`	command चालवणे (install, compile)	build
`ENV`	environment defaults	build → run वेळी दिसतात
`EXPOSE`	container port ची नोंद करते	(फक्त metadata)
`USER`	process कोणत्या user म्हणून चालते	run
`CMD`	default command	run (container start)

EXPOSE port publish करत नाही. फक्त -p host:container (धडा 04) दार उघडते. EXPOSE हे डब्यावरचे लेबल आहे.

🤔 का

Dockerfile म्हणजे चालवता येणारे documentation: त्यावरून कोणीही तुमचे नेमके environment पुन्हा बांधू शकते. प्रत्येक CI pipeline (k8s कोर्स!), प्रत्येक review, प्रत्येक debugging session याच file पासून सुरू होते. ती सहज वाचता येणे ही स्वस्तात मिळणारी महाशक्ती आहे.

🔧 कसे (या repo मध्ये)

app/Dockerfile उघडा — प्रत्येक ओळीवर या धड्याचे comment रूप आहे. काय नाही तेही लक्षात घ्या: RUN npm install नाही (deps नाहीत), secrets नाहीत (secrets कधीही थरांत bake करू नका — ते केकमध्ये कायमचे राहतात, धडा 08!).

🧪 करून पाहा

docker build -t hello-school:v1 app/          # bake from the recipe
docker run --rm -p 3000:3000 hello-school:v1  # open the box
curl localhost:3000                           # 🍱 hello from <hostname>

# prove ENV defaults are overridable without rebuilding:
docker run --rm -p 3000:3000 -e APP_VERSION=recipe-test hello-school:v1
curl localhost:3000                           # version: recipe-test

# inspect the metadata your Dockerfile wrote:
docker inspect hello-school:v1 --format '{{.Config.User}} {{.Config.Env}} {{.Config.Cmd}}'

⚠️ नेहमीच्या चुका

EXPOSE port publish करत नाही — -p करतो
RUN build वेळी घडते; CMD container सुरू होताना घडते
pin न केलेले FROM node — उद्या वेगळा base, उद्या वेगळा bug
.dockerignore अस्तित्वात येण्याआधी COPY . . (धडा 08)

⏭️ पुढे

डबा तयार झाला. आता तो उघडण्याकडे गांभीर्याने वळूया: ports, env vars, logs, exec, stop — रोजची क्रियापदे.

git checkout lesson-04-run-containers

📝 Lesson 03 — The Dockerfile: reading the recipe card

📍 You are here: Lesson 03 of 12 · Previous: lesson-02-images-layers · Next: lesson-04-run-containers

📦 What's in this branch

Lessons 01–02, plus: the Dockerfile, line by line. Seven instructions cover most Dockerfiles you'll ever read. Real file:

app/Dockerfile — heavily commented, this lesson's textbook

🧒 Explain like I'm 5

Mom's recipe card 📝 for packing your lunchbox:

"Start with the plain box from the shop" — FROM node:20-alpine. Never build a box from raw plastic; start from a good pre-made one.
"Work at the kitchen counter" — WORKDIR /app. All later steps happen there.
"Put the food in" — COPY server.js . — YOUR stuff enters the box.
"Tape the default settings to the lid" — ENV PORT=3000. Can be changed at lunch time without re-packing.
"Write 'opens at window 3000' on the label" — EXPOSE 3000. Just a label for humans — it doesn't open anything by itself!
"This box belongs to the kid, not the principal" — USER node. Don't give the box superpowers it doesn't need.
"When the box is opened, eat like THIS" — CMD ["node","server.js"]. One box, one dish: a container runs one main process, in the foreground. When that process ends, lunch is over.

🗺️ Diagram

flowchart TB
    subgraph df["📝 app/Dockerfile"]
        f["FROM node:20-alpine"]
        w["WORKDIR /app"]
        c["COPY server.js ."]
        e["ENV PORT=3000 · EXPOSE 3000"]
        u["USER node"]
        cmd["CMD node server.js"]
        f --> w --> c --> e --> u --> cmd
    end
    f -.->|"1 pre-baked base"| f
    c -.->|"2 your code enters"| c
    e -.->|"3 defaults + label"| e
    cmd -.->|"4 what runs on open"| cmd

❓ What

FROM — the base image (always pin a version: node:20-alpine, never bare node).
WORKDIR — cd for all following steps (creates the dir too).
COPY — files from build context → image. .dockerignore filters the context.
RUN — execute a command AT BUILD TIME (install deps, compile). We don't need one — zero dependencies! Bigger apps: RUN npm ci.
ENV — default env vars, overridable at run time (-e).
EXPOSE — documentation of the listening port (the real opening is -p, lesson 04).
USER — which user runs the process (lesson 08: never root).
CMD — the default command on start. ENTRYPOINT is its stricter cousin — meet it when you need it, not before.
Build time vs run time is THE mental split: RUN happens once at build; CMD/ENV matter every time a container starts.

🧠 The instruction table (eight you will meet immediately)

Instruction	Purpose	When it runs
`FROM`	base image	build
`WORKDIR`	working directory for later steps	build
`COPY`	copy files from the build context	build
`RUN`	execute a command (install, compile)	build
`ENV`	environment defaults	build → visible at run
`EXPOSE`	documents the container port	(metadata only)
`USER`	user the process runs as	run
`CMD`	default command	run (container start)

EXPOSE does not publish a port. Only -p host:container (lesson 04) opens a door. EXPOSE is a label on the box.

🤔 Why

The Dockerfile is executable documentation: anyone can rebuild your exact environment from it. It's also the file every CI pipeline (k8s course!), every review, every debugging session starts from. Reading one fluently is a superpower cheaply bought.

🔧 How (in this repo)

Open app/Dockerfile — every line carries a comment version of this lesson. Note what's missing too: no RUN npm install (no deps), no secrets (never bake secrets into layers — they're in the cake forever, lesson 08!).

🧪 Try it

docker build -t hello-school:v1 app/          # bake from the recipe
docker run --rm -p 3000:3000 hello-school:v1  # open the box
curl localhost:3000                           # 🍱 hello from <hostname>

# prove ENV defaults are overridable without rebuilding:
docker run --rm -p 3000:3000 -e APP_VERSION=recipe-test hello-school:v1
curl localhost:3000                           # version: recipe-test

# inspect the metadata your Dockerfile wrote:
docker inspect hello-school:v1 --format '{{.Config.User}} {{.Config.Env}} {{.Config.Cmd}}'

⚠️ Common mistakes

EXPOSE does not publish a port — -p does
RUN happens at build time; CMD happens when the container starts
unpinned FROM node — a different base tomorrow, a different bug tomorrow
COPY . . before .dockerignore exists (lesson 08)

⏭️ Next

The box is baked. Now we get serious about opening it: ports, env vars, logs, exec, stop — the daily verbs.

git checkout lesson-04-run-containers

← Previousimages layers Next →run containers

This page is the lesson's README from the lesson-03-dockerfile branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.