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

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

🍱 धडा 01 — कंटेनर का: "माझ्या मशीनवर चालते" चा शेवट

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

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

सगळ्याचा पाया: कंटेनर म्हणजे काय आणि तो का आहे. खऱ्या files:

app/server.js — संपूर्ण कोर्ससाठीचे demo ॲप (शून्य dependencies, स्वतःचा hostname दाखवते)
app/Dockerfile — त्याची recipe (धडा 03 ती ओळ-ओळ वाचतो)

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

तुमचे ॲप तुमच्या laptop वर मस्त चालते. तुम्ही ते मैत्रिणीला पाठवता… 💥 crash. तिच्या laptop वर Node 14 आहे, तुमच्याकडे Node 20. तिच्याकडे एक library नाही. तिचे paths वेगळे आहेत. ओळखीचे वाटते ना? 😤

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

कंटेनर म्हणजे तुमच्या program साठीचा डबा: ॲप + Node 20 + libraries

settings, सगळे आत बंद केलेले. तुमचा laptop, मैत्रिणीचा laptop, एखादा मोठा AWS server — तोच डबा, तेच जेवण, प्रत्येक वेळी.

अजून एक गुपित: हा संगणकाच्या आतला छोटा संगणक नाही (तो असतो virtual machine — ट्रकमधून पाठवलेले संपूर्ण घर 🚚). कंटेनर तुमच्या मशीनचा Linux kernel वाटून घेतो आणि फक्त ॲपला वेगळे ठेवतो — म्हणूनच तो milliseconds मध्ये सुरू होतो आणि त्याचे वजन gigabytes नव्हे तर megabytes असते.

🗺️ आकृती

flowchart LR
    loose["😤 unpacked app<br/>works here, crashes there"]
    box["🍱 container<br/>app + runtime + libs + config<br/>ALL inside the box"]
    a["💻 laptop A ✅"]
    b["💻 laptop B ✅"]
    c["☁️ AWS server ✅"]
    loose -->|"1 pack everything"| box
    box -->|"2 identical"| a
    box -->|"2 identical"| b
    box -->|"2 identical"| c

❓ काय

Container = स्वतःची filesystem, network view आणि dependencies असलेली, host चा kernel वाटून घेणारी वेगळी ठेवलेली process.
VM विरुद्ध container: VM संपूर्ण OS boot करते (मिनिटे, GBs); container एक process सुरू करतो (milliseconds, MBs). वेगवेगळ्या कामांसाठी वेगवेगळी साधने.
Docker = containers build, run आणि ship करणारा साधनांचा संच. एकमेव नाही, पण प्रत्येकजण सर्वात आधी हाच शिकतो.

🧠 Container ≠ virtual machine

VM          App → libraries → GUEST OS → hypervisor → host
Container   App → libraries → container runtime → HOST kernel

कंटेनर application आणि त्याच्या user-space dependencies (libraries, runtime, config) पॅक करतो — तो साधारणपणे host चा kernel वाटून घेतो. डब्याच्या आत कोणतीही "छोटी operating system" नसते; म्हणूनच तो milliseconds मध्ये सुरू होतो आणि megabytes इतकाच असतो. नेमके सांगायचे तर: तीच image प्रत्येक मशीनवर सुसंगत application environment देते — खालचा kernel, CPU architecture आणि Docker version मात्र तरीही वेगळे असू शकतात.

🤔 का

या trilogy मधले प्रत्येक tool यावरच उभे आहे: Kubernetes containers schedule करते, ECR container images साठवते, ArgoCD असे manifests deploy करते जे containers चालवतात. डब्याची कल्पना पक्की झाली, की पुढचे सगळे फक्त वाहतुकीचे काम आहे. 🚚

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

app/server.js मुद्दाम dependency-free ठेवले आहे — एक file, साधा Node. ते आपल्या hostname ने उत्तर देते, म्हणजे पुढे तुम्ही 3 प्रती चालवाल तेव्हा कोणत्या डब्याने उत्तर दिले ते प्रत्यक्ष दिसेल. ही छोटी युक्ती तिन्ही कोर्समध्ये पुढे चालत राहते.

🧪 करून पाहा

# 0) install Docker Desktop, then prove the pain is real:
node app/server.js          # works IF you happen to have Node 20... maybe you don't!
                            # ^ that's exactly the problem containers solve

# 1) now the lunchbox way — no Node needed on your machine at all:
docker run --rm -p 3000:3000 -v "$PWD/app":/app -w /app node:20-alpine node server.js
curl localhost:3000         # 🍱 hello from <container-id>

# 2) peek behind the curtain:
docker ps                   # your running box
docker version              # client + engine

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

कंटेनरमध्ये "OS असते" असे समजणे — त्यात user-space files असतात आणि तो host चा kernel वाटून घेतो
CPU architecture काहीही असले तरी कंटेनर कुठेही चालेल अशी अपेक्षा करणे (arm64 आणि amd64 images वेगळ्या असतात)
कंटेनरला VM सारखे वागवणे, त्यात login करून हाताने configure करणे — त्याऐवजी image पुन्हा build करा

⏭️ पुढे

आपण आत्ता वापरलेली ती node:20-alpine गोष्ट म्हणजे image — एकावर एक रचलेल्या थरांनी बनलेला गोठवलेला डबा. आता केकची ओळख करून घेऊया. 🎂

git checkout lesson-02-images-layers

🍱 Lesson 01 — Why containers: the end of "works on my machine"

📍 You are here: Lesson 01 of 12 · Next: lesson-02-images-layers

📦 What's in this branch

The foundation of everything: what a container is and why it exists. Real files:

app/server.js — the demo app for the whole course (zero dependencies, shows its hostname)
app/Dockerfile — its recipe (lesson 03 reads it line by line)

🧒 Explain like I'm 5

Your app runs great on YOUR laptop. You send it to a friend… 💥 crash. Their laptop has Node 14, yours has Node 20. They're missing a library. Their paths are different. Sound familiar? 😤

Now imagine your mom packs you a lunchbox 🍱 — rice, curry, spoon, napkin, everything you need, inside the box. It doesn't matter whose house you open it in: lunch is identical.

A container is a lunchbox for your program: the app + Node 20 + libraries

settings, all sealed inside. Your laptop, your friend's laptop, a giant AWS server — same box, same lunch, every time.

One more secret: it's NOT a mini-computer-in-a-computer (that's a virtual machine — an entire house shipped in a truck 🚚). A container shares your machine's Linux kernel and just isolates the app — which is why it starts in milliseconds and weighs megabytes, not gigabytes.

🗺️ Diagram

flowchart LR
    loose["😤 unpacked app<br/>works here, crashes there"]
    box["🍱 container<br/>app + runtime + libs + config<br/>ALL inside the box"]
    a["💻 laptop A ✅"]
    b["💻 laptop B ✅"]
    c["☁️ AWS server ✅"]
    loose -->|"1 pack everything"| box
    box -->|"2 identical"| a
    box -->|"2 identical"| b
    box -->|"2 identical"| c

❓ What

Container = an isolated process with its own filesystem, network view and dependencies, sharing the host's kernel.
VM vs container: a VM boots a whole OS (minutes, GBs); a container starts one process (milliseconds, MBs). Different tools for different jobs.
Docker = the toolbox that builds, runs and ships containers. Not the only one, but the one everyone learns first.

🧠 Container ≠ virtual machine

VM          App → libraries → GUEST OS → hypervisor → host
Container   App → libraries → container runtime → HOST kernel

A container packages the application and its user-space dependencies (libraries, runtime, config) — it normally shares the host's kernel. There is no "little operating system" inside the box; that's why it starts in milliseconds and weighs megabytes. Precisely: the same image produces a consistent application environment across machines — the kernel, CPU architecture and Docker version underneath can still differ.

🤔 Why

Every tool in the trilogy stands on this: Kubernetes schedules containers, ECR stores container images, ArgoCD deploys manifests that run containers. If the lunchbox idea is solid, everything later is just logistics. 🚚

🔧 How (in this repo)

app/server.js is deliberately dependency-free — one file, plain Node. It answers with its hostname, so when you later run 3 copies you can literally see which box replied. That little trick carries through all three courses.

🧪 Try it

# 0) install Docker Desktop, then prove the pain is real:
node app/server.js          # works IF you happen to have Node 20... maybe you don't!
                            # ^ that's exactly the problem containers solve

# 1) now the lunchbox way — no Node needed on your machine at all:
docker run --rm -p 3000:3000 -v "$PWD/app":/app -w /app node:20-alpine node server.js
curl localhost:3000         # 🍱 hello from <container-id>

# 2) peek behind the curtain:
docker ps                   # your running box
docker version              # client + engine

⚠️ Common mistakes

thinking a container "contains an OS" — it contains user-space files and shares the host kernel
expecting a container to run anywhere regardless of CPU architecture (arm64 vs amd64 images differ)
treating a container like a VM you log into and hand-configure — rebuild the image instead

⏭️ Next

That node:20-alpine thing we just used is an image — a frozen lunchbox made of stacked layers. Time to meet the cake. 🎂

git checkout lesson-02-images-layers

← Course homeall lessons Next →images layers

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