🖼️ See the drawing + lab 🏠 Course home 🌿 Branch on GitHub ✏️ View source

🖼️ आकृती आणि labThe drawing + lab पूर्ण पानावर उघडा ↗Open full page ↗

🍱 धडा 01 — Containers आणि Images: भरलेला जेवणाचा डबा

📍 तुम्ही इथे आहात: 13 पैकी धडा 01 · पुढची branch: lesson-02-pods

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

ही branch अगदी पहिला धडा जोडते: container म्हणजे काय, आणि image म्हणजे काय — कारण Kubernetes चे संपूर्ण काम containers चालवणे हेच आहे, त्यामुळे हे समजल्याशिवाय पुढचे काहीच समजत नाही. या धड्यात वापरलेल्या खऱ्या files:

apps/school-api/Dockerfile — Node.js API image ची पाककृती
apps/school-analytics/Dockerfile — Python image ची पाककृती
docker-compose.yml — दोन्ही containers + Postgres स्थानिक पातळीवर चालवते

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

कल्पना करा, तुमची आई तुम्हाला जेवणाचा डबा 🍱 भरून देते. त्यात तुम्हाला लागणारे सगळे आहे: भात, भाजी, चमचा, रुमाल. तुम्ही तो कोणाच्याही घरी उघडा — तुमचे जेवण अगदी तसेच असते, कारण सगळे डब्याच्या आतच आले होते.

Container म्हणजे program साठीचा जेवणाचा डबा. त्यात app आणि त्याला लागणारे सगळे असते — Node.js, libraries, config. त्यामुळे ते तुमच्या laptop वर, मैत्रिणीच्या laptop वर आणि एखाद्या मोठ्या AWS server वर अगदी सारखेच चालते. आता "पण माझ्या machine वर तर चालते!" असे म्हणायची वेळ येत नाही 😤

Image = पाककृती + कपाटात ठेवलेला भरलेला डबा (गोठवलेला, तयार).
Container = उघडलेला आणि खाल्ला जात असलेला डबा (चालू).
Dockerfile = डबा भरताना आईने वापरलेले पाककृतीचे कार्ड.

एका पाककृतीतून तुम्ही 100 एकसारखे डबे बनवू शकता. म्हणूनच एक image 100 एकसारख्या containers म्हणून चालू शकते.

🗺️ आकृती

flowchart LR
    subgraph recipe["📝 Recipe - Dockerfile"]
        D["FROM node:20<br/>COPY src<br/>RUN npm install"]
    end
    subgraph shelf["🧊 Image - frozen lunchbox"]
        I["school-api:latest<br/>app + Node.js + libs"]
    end
    subgraph running["🏃 Containers - lunch time"]
        C1["container 1"]
        C2["container 2"]
        C3["container 3"]
    end
    D -- "docker build" --> I
    I -- "docker run" --> C1
    I -- "docker run" --> C2
    I -- "docker run" --> C3

❓ काय

Container म्हणजे स्वतःची filesystem, network ची दृष्टी आणि dependencies असलेली एक वेगळी ठेवलेली process — virtual machine पेक्षा खूप हलकी (ती स्वतःची OS boot करण्याऐवजी host चा Linux kernel वाटून घेते).
Image म्हणजे container ज्यापासून सुरू होतो तो read-only साचा, जो Dockerfile पासून थरांमध्ये (layers) बनवला जातो.
Registry (इथे AWS ECR सारखी) म्हणजे ते कपाट जिथे images ठेवल्या जातात आणि जिथून pull केल्या जातात.

🤔 का

Containers नसतील तर: "Node 20, Postgres 16 install करा, हे 12 env vars set करा…" आणि प्रत्येक machine हळूहळू वेगळी होत जाते. Containers असतील तर: एकदा build करा, कुठेही, अगदी सारखेच चालवा. Kubernetes अस्तित्वात आहे ते अनेक machines वर अनेक containers चालवण्यासाठी — म्हणून पुढे येणाऱ्या सगळ्याचे अणू म्हणजे containers.

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

apps/school-api/Dockerfile उघडा:

FROM node:20-alpine — ज्यात आधीच Node आहे अशा लहान मूळ डब्यापासून सुरुवात करा.
COPY + RUN npm ci — app आणि त्याच्या libraries आत ठेवा.
Multi-stage build — अंतिम image मध्ये फक्त चालवण्यासाठी लागणारेच राहते (लहान = पाठवायला जलद).
CMD — डबा उघडल्यावर काय करायचे ("server सुरू करा").

त्यानंतर docker-compose.yml तुमच्या laptop वर तीन containers एकत्र चालवते: school-api, school-analytics, आणि postgres.

🧪 करून पाहा

# Build the image (bake the lunchbox) — needs Docker Desktop running
docker build -t school-api:v1 apps/school-api

# Run one container from it (open the box)
docker run --rm -p 3000:3000 school-api:v1

# In another terminal — it's alive:
curl http://localhost:3000/healthz

# Or run the WHOLE lunch table (both APIs + Postgres):
docker compose up

🔧 या धड्यासाठी kubectl

docker build · docker run · docker logs

🔗 यावर आधारित: 🍱 Docker शाळा L01–L04 (images, run, ports)

✅ तपासा — तुम्हाला काय दिसायला हवे

docker run -p 3000:3000 school-api:v1 हे curl localhost:3000/health ला उत्तर देते.

🧹 साफसफाई

Container ला docker rm -f करा — images फक्त disk ची जागा घेतात

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

container ला VM समजणे — तो host चा kernel वाटून घेतो (Docker शाळा L01)
-p शिवाय image चालवणे आणि मग localhost गप्प का आहे असा प्रश्न पडणे

⏭️ पुढे

Kubernetes मध्ये container कधीच एकटा, उघड्यावर चालत नाही — तो नेहमी Pod च्या आत बसून चालतो.

git checkout lesson-02-pods

🍱 Lesson 01 — Containers & Images: the packed lunchbox

📍 You are here: Lesson 01 of 13 · Next branch: lesson-02-pods

📦 What's in this branch

This branch adds the very first lesson: what a container is, and what an image is — because Kubernetes' whole job is running containers, so nothing else makes sense until this does. Real files this lesson uses:

apps/school-api/Dockerfile — recipe for the Node.js API image
apps/school-analytics/Dockerfile — recipe for the Python image
docker-compose.yml — runs both containers + Postgres locally

🧒 Explain like I'm 5

Imagine your mom packs you a lunchbox 🍱. Inside is everything you need: rice, curry, a spoon, a napkin. It doesn't matter whose house you open it in — your lunch is exactly the same, because everything came inside the box.

A container is a lunchbox for a program. Inside is the app plus everything it needs — Node.js, libraries, config. So it runs exactly the same on your laptop, your friend's laptop, and a giant AWS server. No more "but it works on my machine!" 😤

The image = the recipe + packed box on the shelf (frozen, ready).
The container = the box opened and being eaten (running).
The Dockerfile = the recipe card mom followed to pack it.

You can make 100 identical lunchboxes from one recipe. That's why one image can run as 100 identical containers.

🗺️ Diagram

flowchart LR
    subgraph recipe["📝 Recipe - Dockerfile"]
        D["FROM node:20<br/>COPY src<br/>RUN npm install"]
    end
    subgraph shelf["🧊 Image - frozen lunchbox"]
        I["school-api:latest<br/>app + Node.js + libs"]
    end
    subgraph running["🏃 Containers - lunch time"]
        C1["container 1"]
        C2["container 2"]
        C3["container 3"]
    end
    D -- "docker build" --> I
    I -- "docker run" --> C1
    I -- "docker run" --> C2
    I -- "docker run" --> C3

❓ What

A container is an isolated process with its own filesystem, network view and dependencies — much lighter than a virtual machine (it shares the host's Linux kernel instead of booting its own OS).
An image is the read-only template a container starts from, built in layers from a Dockerfile.
A registry (like AWS ECR here) is the shelf where images are stored and pulled from.

🤔 Why

Without containers: "install Node 20, Postgres 16, set these 12 env vars…" and every machine drifts apart. With containers: build once, run anywhere, identically. Kubernetes exists to run lots of containers across lots of machines — so containers are the atoms of everything that follows.

🔧 How (in this repo)

Open apps/school-api/Dockerfile:

FROM node:20-alpine — start from a small base lunchbox that already has Node.
COPY + RUN npm ci — put the app and its libraries inside.
Multi-stage build — the final image keeps only what's needed to run (small = fast to ship).
CMD — what to do when the box is opened ("start the server").

docker-compose.yml then runs three containers together on your laptop: school-api, school-analytics, and postgres.

🧪 Try it

# Build the image (bake the lunchbox) — needs Docker Desktop running
docker build -t school-api:v1 apps/school-api

# Run one container from it (open the box)
docker run --rm -p 3000:3000 school-api:v1

# In another terminal — it's alive:
curl http://localhost:3000/healthz

# Or run the WHOLE lunch table (both APIs + Postgres):
docker compose up

🔧 kubectl for this lesson

docker build · docker run · docker logs

🔗 Builds on: 🍱 Docker school L01–L04 (images, run, ports)

✅ Verify — what you should see

docker run -p 3000:3000 school-api:v1 answers on curl localhost:3000/health.

🧹 Clean up

docker rm -f the container — images cost disk only

⚠️ Common mistakes

thinking the container is a VM — it shares the host kernel (Docker school L01)
running the image without -p and wondering why localhost is silent

⏭️ Next

A container never runs "naked" in Kubernetes — it always rides inside a Pod.

git checkout lesson-02-pods

← Course homeall lessons Next →pods

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