🏷️ धडा 08 — इमेजची स्वच्छता: डब्यांवर लेबल लावा, किल्ल्या पॅक करू नका

📍 तुम्ही इथे आहात: 12 पैकी धडा 08 — भाग 1 चा शेवट! · मागे: lesson-07-multi-stage · पुढे: lesson-09-registries

🔗 AWS शी संबंध: IAM आणि least privilege — container ही सुद्धा एक ओळख (identity) आहे, जिच्याकडे कमीत कमी अधिकार असायला हवेत (AWS शाळा, धडे 03 आणि 05).

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

धडे 01–07, आणि त्याशिवाय: image ला production-grade बनवणाऱ्या चार सवयी. खऱ्या files:

app/.dockerignore — build-context च्या दारावरचा रखवालदार
app/Dockerfile — USER node आणि pin केलेला base, आधीच जागेवर

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

डब्यांसाठी शाळेचे चार नियम:

डब्यांवर नीट लेबल लावा 🏷️ — फक्त "सर्वात नवा" नाही, तर "ऐश्वर्या, मंगळवार, वरण-भात" असे लिहा. कारण "सर्वात नवा" चा अर्थ रोज बदलतो! Docker मध्ये: hello-school:v1 किंवा :abc123 (एक git commit), production मध्ये कधीही :latest वर अवलंबून राहू नका — "latest" कडे rollback करता येत नाही, आणि काल ते काय होते ते तुम्हाला कधीच कळत नाही. (k8s आणि ArgoCD दोन्ही कोर्स या नियमावर अवलंबून आहेत.)
घराच्या किल्ल्या पॅक करू नका 🙈 — डब्यात काय जाते ते आई तपासते. .dockerignore .git, .env, secrets आणि कचरा COPY च्या आवाक्याबाहेर ठेवते. धडा 02 आठवा: थरात जे जाते ते केकमध्ये कायमचे राहते — "delete केलेल्या" files सुद्धा आधीच्या थरांत जिवंत राहतात.
डबा मुलीचा आहे, मुख्याध्यापिकांचा नाही 👤 — USER node. एखादा गुंड root container मध्ये घुसला, तर तो त्या डब्याचा (आणि कदाचित शाळेचाही) मुख्याध्यापक बनतो. node-user डब्यात घुसला? तो फक्त… बाकावर बसलेले एक मूल असतो.
फक्त छोटे डबे 🪶 — पूर्ण node:20 ऐवजी node:20-alpine / -slim वापरा. लहान base image म्हणजे कमी pull, कमी patch, आणि शक्यतो हल्ल्याची जागा कमी (खरे आकार docker images ने तपासा — ते releases नुसार बदलतात). Versions pin करा: FROM node:20-alpine, कधीही फक्त FROM node नाही.

🗺️ आकृती

flowchart TB
    subgraph rules["🏷️ the hygiene checklist"]
        r1["1 real tags: v1, git-sha<br/>never :latest in prod"]
        r2["2 .dockerignore:<br/>.git, .env, node_modules<br/>COPY can't leak what it can't see"]
        r3["3 USER node<br/>root container = root problems"]
        r4["4 small, pinned bases<br/>alpine/slim, versioned"]
    end
    good["✅ boring, predictable,<br/>production-grade image"]
    r1 --> good
    r2 --> good
    r3 --> good
    r4 --> good

❓ काय

Tags हे mutable pointers आहेत — :latest म्हणजे कोणीतरी शेवटी हलवलेला फक्त एक tag. Deploys ने नेमक्या version चा संदर्भ द्यायला हवा (ECR तर tag overwrites मनाई ही करू शकते — IMMUTABLE, धडा 10).
Build context = COPY ला जे दिसू शकते ते सगळे. .dockerignore ते लहान करते: जलद builds, चुकून secrets नाहीत, कचऱ्याच्या files मुळे cache तुटत नाही.
Secrets कधीही थरांत जात नाहीत — COPY मध्ये नाही, ENV मध्ये नाही, "नंतर delete केले" असेही नाही. Runtime env vars (-e, k8s Secrets) नेमके याचसाठी आहेत.
Default ने non-root: node images सोबत तयार node user येतो; अनेक images मध्ये असेच काहीतरी असते, नाहीतर adduser ने स्वतःचा जोडा.

🧠 हा भाग 1 चा security धडा आहे

Image ला incident बनण्यापासून रोखणारी यादी:

सगळे खाजगी .dockerignore मध्ये — build context म्हणजे COPY ला दिसणारे सगळे
.env, SSH keys, cloud credentials कधीही copy करू नका — थरातले secret image मध्ये कायमचे राहते, नंतरच्या थराने ते "delete" केले तरीही
AWS credentials images मध्ये bake करू नका — मशीनना roles मिळतात (AWS शाळा, धडा 05), keys कधीच नाही
ARG/ENV मध्ये secrets नाहीत — दोन्ही image metadata मध्ये जातात (docker history ते दाखवते)
non-root म्हणून चालवा (USER node) — आत root मध्ये घुसखोरी म्हणजे host च्या user namespace मध्ये घुसखोरी
base images विचारपूर्वक निवडा आणि pin करा — node:20-alpine, node नाही
images scan करा (ECR scan-on-push, धडा 11; docker scout) आणि गरज नसलेले packages काढा

❌  COPY . .                       → accidentally copies .env and .git
✅  .dockerignore:  .env  .git  node_modules  *.pem  → COPY can't leak what it can't see

🤔 का

इथला प्रत्येक नियम एखादी विशिष्ट खरी घटना टाळतो: rollback न करता येणारे deploys (:latest), leak झालेले credentials (image मध्ये context/git), container-escape चा blast radius (root), आणि CVEs साठवणाऱ्या gigabyte images. भाग 2 images अशा registry कडे पाठवतो ज्यावर इतर मशीन विश्वास ठेवतात — hygiene मुळेच तो विश्वास योग्य ठरतो.

🧪 करून पाहा

# 1) prove .dockerignore works — try to leak a "secret":
echo "SECRET_KEY=dont-pack-me" > app/.env
docker build -t hygiene-test app/
docker run --rm hygiene-test ls -a        # no .env in the box 🙅 (it's ignored)
rm app/.env

# 2) prove we're not root:
docker run --rm hello-school:v1 whoami     # node 👤

# 3) feel the tag rule:
docker tag hello-school:v1 hello-school:latest
docker tag hello-school:v1 hello-school:2026-09-09
docker image ls hello-school               # 3 labels, ONE image (same ID) —
                                           # tags are stickers, not copies

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

.env (किंवा संपूर्ण repo) image मध्ये copy करणे — ते थरात कायमचे राहते
ARG/ENV मध्ये secrets bake करणे — ते docker history ने वाचता येतात
कशालाही गरज नसताना production containers root म्हणून चालवणे
:latest deploy करणे — हलत्या tag कडे rollback करता येत नाही

⏭️ पुढे — भाग 2 सुरू ☁️

तुमची image लहान, स्वच्छ, लेबल लावलेली आहे… आणि तुमच्या laptop वर अडकलेली आहे. आता ती अशा ठिकाणी पाठवूया जिथून प्रत्येक मशीन pull करू शकेल: registries.

git checkout lesson-09-registries

🏷️ Lesson 08 — Image hygiene: label your boxes, don't pack your keys

📍 You are here: Lesson 08 of 12 — end of Part 1! · Previous: lesson-07-multi-stage · Next: lesson-09-registries

🔗 AWS connection: IAM & least privilege — a container is just another identity that should hold the minimum (AWS school, lessons 03 & 05).

📦 What's in this branch

Lessons 01–07, plus: the four habits that make an image production-grade. Real files:

app/.dockerignore — the bouncer at the build-context door
app/Dockerfile — USER node and a pinned base, already in place

🧒 Explain like I'm 5

Four school rules for lunchboxes:

Label boxes properly 🏷️ — write "Aishwarya, Tuesday, dal-rice", not just "newest". Because "newest" changes meaning every day! In Docker: hello-school:v1 or :abc123 (a git commit), never rely on :latest in production — you can't roll back to "latest", and you never know what it was yesterday. (The k8s and ArgoCD courses both depend on this rule.)
Don't pack your house keys 🙈 — mom checks what goes in the box. .dockerignore keeps .git, .env, secrets and junk out of COPY's reach. Remember lesson 02: whatever enters a layer is in the cake forever — even "deleted" files live on in earlier layers.
The box belongs to the kid, not the principal 👤 — USER node. If a bully breaks into a root container, they're the principal of that box (and maybe the school). Break into a node-user box? They're… a kid at a desk.
Small boxes only 🪶 — prefer node:20-alpine / -slim over the full node:20. A smaller base image means less to pull, less to patch, and potentially a smaller attack surface (check real sizes with docker images — they change between releases). Pin versions: FROM node:20-alpine, never bare FROM node.

🗺️ Diagram

flowchart TB
    subgraph rules["🏷️ the hygiene checklist"]
        r1["1 real tags: v1, git-sha<br/>never :latest in prod"]
        r2["2 .dockerignore:<br/>.git, .env, node_modules<br/>COPY can't leak what it can't see"]
        r3["3 USER node<br/>root container = root problems"]
        r4["4 small, pinned bases<br/>alpine/slim, versioned"]
    end
    good["✅ boring, predictable,<br/>production-grade image"]
    r1 --> good
    r2 --> good
    r3 --> good
    r4 --> good

❓ What

Tags are mutable pointers — :latest is just a tag someone moved last. Deploys must reference an exact version (ECR can even forbid tag overwrites — IMMUTABLE, lesson 10).
Build context = everything COPY could see. .dockerignore shrinks it: faster builds, no accidental secrets, no cache-busting from junk files.
Secrets never go in layers — not in COPY, not in ENV, not "deleted later". Runtime env vars (-e, k8s Secrets) exist for exactly this.
Non-root by default: the node images ship a ready node user; many images have equivalents, or add your own with adduser.

🧠 This is the security lesson of Part 1

The checklist that keeps an image from becoming an incident:

.dockerignore everything private — the build context is what COPY can see
never copy .env, SSH keys, cloud credentials — a secret in a layer is in the image forever, even if a later layer "deletes" it
don't bake AWS credentials into images — machines get roles (AWS school, lesson 05), never keys
no secrets in ARG/ENV — both end up in image metadata (docker history shows them)
run as non-root (USER node) — a break-in to root inside is a break-in to the host's user namespace
pin and choose base images deliberately — node:20-alpine, not node
scan images (ECR scan-on-push, lesson 11; docker scout) and remove unneeded packages

❌  COPY . .                       → accidentally copies .env and .git
✅  .dockerignore:  .env  .git  node_modules  *.pem  → COPY can't leak what it can't see

🤔 Why

Every rule here prevents a specific real incident: un-rollback-able deploys (:latest), leaked credentials (context/git in image), container-escape blast radius (root), and CVE-hoarding gigabyte images. Part 2 ships images to a registry other machines trust — hygiene is what makes that trust deserved.

🧪 Try it

# 1) prove .dockerignore works — try to leak a "secret":
echo "SECRET_KEY=dont-pack-me" > app/.env
docker build -t hygiene-test app/
docker run --rm hygiene-test ls -a        # no .env in the box 🙅 (it's ignored)
rm app/.env

# 2) prove we're not root:
docker run --rm hello-school:v1 whoami     # node 👤

# 3) feel the tag rule:
docker tag hello-school:v1 hello-school:latest
docker tag hello-school:v1 hello-school:2026-09-09
docker image ls hello-school               # 3 labels, ONE image (same ID) —
                                           # tags are stickers, not copies

⚠️ Common mistakes

copying .env (or the whole repo) into the image — it's in a layer forever
baking secrets into ARG/ENV — they're readable with docker history
running production containers as root when nothing requires it
deploying :latest — you can't roll back to a moving tag

⏭️ Next — Part 2 begins ☁️

Your image is small, clean, labeled… and trapped on your laptop. Time to ship it somewhere every machine can pull from: registries.

git checkout lesson-09-registries

← Previousmulti stage Next →registries

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