🍽️ धडा 04 — Containers चालवणे: जेवणाची वेळ

📍 तुम्ही इथे आहात: 12 पैकी धडा 04 · मागे: lesson-03-dockerfile · पुढे: lesson-05-volumes-networks

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

धडे 01–03, आणि त्याशिवाय: रोजची क्रियापदे — run, ps, logs, exec, stop, rm — आणि तुम्ही कायम टाइप कराल असे दोन flags: -p आणि -e.

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

जेवणाची वेळ! 🍽️ डबे उघडण्याचे काही नियम आहेत:

वाढायची खिडकी 🪟 (-p 3000:3000): डबा स्वतःच्या टेबलवर जेवतो (त्याचे खाजगी network). तुम्हाला त्याच्यापर्यंत पोहोचता यावे म्हणून कॅन्टीन एक खिडकी उघडते: "laptop वरची खिडकी 3000 डब्यातल्या जागा 3000 कडे जाते". डावा आकडा = तुमचा laptop; उजवा = डब्याच्या आत. -p 8080:3000 ही चालते — बाहेरची खिडकी 8080, आतली जागा तीच.
झाकणावरच्या शेवटच्या क्षणाच्या चिठ्ठ्या ✏️ (-e APP_VERSION=v2): डबा पुन्हा पॅक न करता उघडताना settings बदला.
डोकावणे 👀: docker logs = डब्याची रोजनिशी वाचा; docker exec -it … sh = चालू डब्याच्या आत शिरून आजूबाजूला पाहा.
आवराआवर 🧹: docker stop = नम्रपणे "जेवण संपले" सांगणे (SIGTERM — आपले ॲप "bye 👋" म्हणते); docker rm = डबा फेकून देणे; --rm = स्वतःच स्वतःला फेकून देणारा डबा. डबे फेकून देण्यासारखे असतात — कधीच मौल्यवान नाहीत.

🗺️ आकृती

flowchart LR
    img["🧊 image<br/>hello-school:v1"]
    c["🏃 container<br/>node server.js as PID 1<br/>own filesystem + network"]
    win["🪟 -p 3000:3000<br/>laptop:3000 → box:3000"]
    tools["👀 daily verbs<br/>logs · exec · stop · rm"]
    img -->|"1 docker run<br/>-e APP_VERSION=v2"| c
    win -->|"2 the only way in"| c
    tools -.->|"3 watch, enter, end"| c

❓ काय

docker run IMAGE = container बनवा + सुरू करा. उपयोगी flags: --rm (स्वतः साफ होतो), -d (background), --name (शोधता येतो), -p, -e.
Container त्याच्या मुख्य process (PID 1) इतकाच जगतो. Process संपली → container संपतो. "container चालू आहे पण ॲप बंद आहे" असे काही नसते — हाच तर मुद्दा आहे.
docker ps (चालू), ps -a (संपलेलेही), logs -f (रोजनिशी सतत पाहा), exec -it NAME sh (आत shell), stop (SIGTERM, 10s सवलत, मग KILL).

🧠 Container चे जीवनचक्र

docker create  →  created
docker start   →  running
docker stop    →  stopped   (process gone, filesystem kept)
docker rm      →  removed   (container gone)

नवशिके गोंधळतात अशी तीन क्रियापदे:

docker stop  = stop the process        (container still exists)
docker rm    = remove the container    (its writable layer is gone)
docker rmi   = remove the IMAGE        (the template, from your machine)

docker run = एकाच फटक्यात create + start. docker ps -a तुम्ही विसरलेले थांबलेले containers दाखवते; docker system df या सगळ्याला disk वर किती जागा लागते ते दाखवते.

🤔 का

ही क्रियापदे म्हणजेच पुढच्या सगळ्यासाठी तुमचा debugging toolkit: Kubernetes मधला crash होणारा pod याच कल्पनांनी तपासला जातो (kubectl logs, kubectl exec हे अक्षरशः चुलतभाऊ आहेत). आणि PID-1/SIGTERM च्या गोष्टीमुळेच आपला server.js SIGTERM हाताळतो — हाच handler k8s कोर्समध्ये zero-downtime rollouts सुरळीत करतो.

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

app/server.js प्रत्येक request log करतो (docker logs साठी), आपले version छापतो (-e साठी), आणि SIGTERM हाताळतो (docker stop साठी). तो अगदी याच धड्यासाठीचे खेळाचे मैदान आहे.

🧪 करून पाहा

docker build -t hello-school:v1 app/

# background + named + windowed + note-on-the-lid:
docker run -d --name lunch -p 3000:3000 -e APP_VERSION=lunch-time hello-school:v1
curl localhost:3000                       # version: lunch-time
curl localhost:3000                       # visits: 2 — state lives IN the box

docker logs -f lunch                      # the diary (Ctrl+C to stop following)
docker exec -it lunch sh                  # climb in: ls, ps, cat server.js, exit

docker stop lunch                         # watch the diary say "bye 👋" (SIGTERM!)
docker rm lunch                           # throw the box away
docker run --rm -p 3000:3000 hello-school:v1   # visits: 1 again — new box, fresh memory

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

docker stop ≠ docker rm ≠ docker rmi — process, container, image
-p विसरणे आणि localhost:3000 गप्प का आहे याचा विचार करत बसणे
-d ने चालवणे आणि कधीच docker logs न वाचणे — container ने "काहीच केले नाही" कारण तो crash झाला होता

⏭️ पुढे

"नवा डबा, ताजी स्मृती" ॲप्ससाठी छान, पण data साठी भयंकर. आणि दोन डबे एकमेकांशी कसे बोलतात? Volumes आणि networks.

git checkout lesson-05-volumes-networks

🍽️ Lesson 04 — Running containers: lunch time

📍 You are here: Lesson 04 of 12 · Previous: lesson-03-dockerfile · Next: lesson-05-volumes-networks

📦 What's in this branch

Lessons 01–03, plus: the daily verbs — run, ps, logs, exec, stop, rm — and the two flags you'll type forever: -p and -e.

🧒 Explain like I'm 5

Lunch time! 🍽️ Opening boxes has rules:

The serving window 🪟 (-p 3000:3000): the box eats at its own table (its private network). For YOU to reach it, the cafeteria opens a window: "window 3000 on the laptop leads to seat 3000 in the box". Left number = your laptop; right = inside the box. -p 8080:3000 works too — outside window 8080, same seat inside.
Last-minute notes on the lid ✏️ (-e APP_VERSION=v2): change settings at open time without re-packing the box.
Peeking 👀: docker logs = read the box's diary; docker exec -it … sh = climb inside a running box and look around.
Cleaning up 🧹: docker stop = politely say "lunch is over" (SIGTERM — our app says "bye 👋"); docker rm = throw away the box; --rm = a box that throws itself away. Boxes are disposable — never precious.

🗺️ Diagram

flowchart LR
    img["🧊 image<br/>hello-school:v1"]
    c["🏃 container<br/>node server.js as PID 1<br/>own filesystem + network"]
    win["🪟 -p 3000:3000<br/>laptop:3000 → box:3000"]
    tools["👀 daily verbs<br/>logs · exec · stop · rm"]
    img -->|"1 docker run<br/>-e APP_VERSION=v2"| c
    win -->|"2 the only way in"| c
    tools -.->|"3 watch, enter, end"| c

❓ What

docker run IMAGE = create + start a container. Useful flags: --rm (self-clean), -d (background), --name (findable), -p, -e.
A container lives exactly as long as its main process (PID 1). Process exits → container exits. There is no "the container is up but the app is down" — that's the whole point.
docker ps (running), ps -a (also exited), logs -f (follow the diary), exec -it NAME sh (shell inside), stop (SIGTERM, 10s grace, then KILL).

🧠 The container lifecycle

docker create  →  created
docker start   →  running
docker stop    →  stopped   (process gone, filesystem kept)
docker rm      →  removed   (container gone)

Three verbs beginners mix up:

docker stop  = stop the process        (container still exists)
docker rm    = remove the container    (its writable layer is gone)
docker rmi   = remove the IMAGE        (the template, from your machine)

docker run = create + start in one go. docker ps -a shows the stopped ones you forgot; docker system df shows what all of it costs on disk.

🤔 Why

These verbs ARE your debugging toolkit for everything later: a crashing pod in Kubernetes is investigated with the same ideas (kubectl logs, kubectl exec are literal cousins). And the PID-1/SIGTERM story is why our server.js handles SIGTERM — the same handler that makes zero-downtime rollouts graceful in the k8s course.

🔧 How (in this repo)

app/server.js logs every request (for docker logs), prints its version (for -e), and handles SIGTERM (for docker stop). It's a playground for exactly this lesson.

🧪 Try it

docker build -t hello-school:v1 app/

# background + named + windowed + note-on-the-lid:
docker run -d --name lunch -p 3000:3000 -e APP_VERSION=lunch-time hello-school:v1
curl localhost:3000                       # version: lunch-time
curl localhost:3000                       # visits: 2 — state lives IN the box

docker logs -f lunch                      # the diary (Ctrl+C to stop following)
docker exec -it lunch sh                  # climb in: ls, ps, cat server.js, exit

docker stop lunch                         # watch the diary say "bye 👋" (SIGTERM!)
docker rm lunch                           # throw the box away
docker run --rm -p 3000:3000 hello-school:v1   # visits: 1 again — new box, fresh memory

⚠️ Common mistakes

docker stop ≠ docker rm ≠ docker rmi — process, container, image
forgetting -p and wondering why localhost:3000 is silent
running with -d and never reading docker logs — the container "did nothing" because it crashed

⏭️ Next

"New box, fresh memory" is great for apps, terrible for data. And how do TWO boxes talk to each other? Volumes & networks.

git checkout lesson-05-volumes-networks

← Previousdockerfile Next →volumes networks

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