🍽️🍽️ धडा 06 — Docker Compose: एका command ने संपूर्ण टेबल मांडा

📍 तुम्ही इथे आहात: 12 पैकी धडा 06 · मागे: lesson-05-volumes-networks · पुढे: lesson-07-multi-stage

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

धडे 01–05, आणि त्याशिवाय: Compose — धडा 05 मधले सगळे, flags म्हणून टाइप करण्याऐवजी एका file मध्ये जाहीर केलेले. खऱ्या files:

compose.yml — टेबलचा आराखडा: web + proxy
proxy/nginx.conf — proxy नावाने http://web:3000 कडे पुढे पाठवतो

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

काल तुम्ही जेवणाचे टेबल हाताने मांडले: network बनवा, डबा 1 हे flags देऊन चालवा, डबा 2 ते flags देऊन चालवा, fridge जोडा… 15 मिनिटे flags टाइप करणे, आणि तुमची सहकारी ते थोडे वेगळे करते आणि काहीच चालत नाही. 😩

Compose म्हणजे laminate केलेला टेबलचा आराखडा 🍽️: एक कागद जो सांगतो "या टेबलवर एक web डबा आणि एक proxy डबा आहे, ते intercom वाटून घेतात, फक्त proxy ला वाढायची खिडकी आहे, हा fridge आहे." मग:

docker compose up — संपूर्ण टेबल, काढलेल्या आराखड्याप्रमाणे अगदी तसेच, हजर होते. ✨
docker compose down — संपूर्ण टेबल नाहीसे होते.
तुमची सहकारी तीच file चालवते → अगदी तसेच टेबल. Laptops मध्ये कोणताही फरक पडत नाही. (विषय ओळखला? जाहीर केलेली state > टाइप केलेल्या commands — ArgoCD कोर्समध्ये GitOps हीच कल्पना संपूर्ण clusters ला लागू करते.)

आपले टेबल: proxy हा एकमेव खिडकी असलेला डबा आहे (8080:80); तो सगळ्यांना नावाने web कडे पाठवतो. web ला स्वतःला कोणतीही खिडकी नाही — तो फक्त proxy मार्फतच पोहोचता येतो, जसे काउंटरमागचे स्वयंपाकघर.

🗺️ आकृती

flowchart LR
    yml["📄 compose.yml<br/>the table plan"]
    subgraph table["🍽️ one shared network, auto-created"]
        proxy["📦 proxy - nginx<br/>🪟 the ONLY window :8080"]
        web["📦 web - our app<br/>no window, name-only"]
        proxy -->|"http://web:3000<br/>by service NAME"| web
    end
    you["🧑‍💻 you"]
    yml -->|"1 docker compose up --build"| table
    you -->|"2 localhost:8080"| proxy

❓ काय

services: — प्रत्येक नोंद एक container बनते; service चे नाव हेच आपोआप बनलेल्या network वरचे त्याचे DNS नाव.
build: ./app विरुद्ध image: nginx:alpine — आपले स्वतः बनवा, त्यांचे विकत घ्या.
ports: फक्त जिथे बाहेरचे जग आत येते तिथेच; आतल्या services खिडकीविना राहतात (हल्ल्याची जागा कमी — hygiene, धडा 08!).
volumes: — आपला proxy आपली config read-only (:ro) bind-mount करतो.
depends_on: — सुरू होण्याचा क्रम (proxy आधी web). Start ≠ ready — खरी तयारी k8s probes नीट सोडवतात (k8s कोर्स, धडा 07).
रोजची क्रियापदे: up --build, down, ps, logs -f web, exec web sh.

🧠 Compose हवी असलेली application रचना वर्णन करते

compose.yml
web
 ├── depends_on → api
 │                 └── db
 └── network: app-net (everyone by name)

तुम्ही रोज टाइप कराल अशा पाच commands:

docker compose up -d      # create + start the whole table, detached
docker compose ps         # who's up
docker compose logs -f    # everyone's output, tailed
docker compose exec web sh   # a shell inside one service
docker compose down       # stop + remove (add -v to drop volumes)

depends_on फक्त सुरू होण्याचा क्रम ठरवते. त्याचा अर्थ dependency traffic स्वीकारायला तयार आहे असा नाही — db "सुरू" झालेला असून अजून initialize होत असू शकतो. तयारीसाठी healthcheck + condition: service_healthy वापरा, किंवा ॲपला retry करायला लावा. (Kubernetes हाच प्रश्न readiness probes ने सोडवते.)

🤔 का

Compose मध्ये "माझा dev setup" git मधली एक file बनतो — review करता येणारी, शेअर करता येणारी, versioned. Kubernetes कडे जाणारा हा सर्वोत्तम मानसिक पूलही आहे: Compose service ≈ Deployment + Service, सामायिक network ≈ cluster DNS. लहान शाळा शिका, म्हणजे मोठी शाळा ओळखीची वाटेल.

🧪 करून पाहा

docker compose up --build          # the whole table, one command
# open http://localhost:8080       # → proxy → web, by name 🎉

curl localhost:8080                # 🍱 hello from <web's container id>
curl localhost:3000 || echo "web has NO window — exactly as planned 🙅"

docker compose ps                  # the table's seating chart
docker compose logs -f web         # one box's diary (Ctrl+C)
docker compose down                # table vanishes, nothing left behind

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

depends_on = सुरू होण्याचा क्रम, तयारी नाही — ॲपने retry करायला हवे किंवा healthchecks वापरायला हवेत
प्रत्येक service चा port host ला उघडा करणे — फक्त पुढच्या दाराला ports: लागतात
चुकीच्या directory मध्ये docker compose down -v — तो त्या project चे volumes delete करतो

⏭️ पुढे

आपली image लहान आहे कारण ॲपला शून्य dependencies आहेत. खऱ्या ॲप्समध्ये build पायऱ्या आणि जड tools असतात — आणि तरीही images छोट्या ठेवण्याची एक युक्ती आहे: multi-stage builds.

git checkout lesson-07-multi-stage

🍽️🍽️ Lesson 06 — Docker Compose: set the whole table with one command

📍 You are here: Lesson 06 of 12 · Previous: lesson-05-volumes-networks · Next: lesson-07-multi-stage

📦 What's in this branch

Lessons 01–05, plus: Compose — everything from lesson 05, declared in one file instead of typed as flags. Real files:

compose.yml — the table plan: web + proxy
proxy/nginx.conf — proxy forwards to http://web:3000 by name

🧒 Explain like I'm 5

Yesterday you set the lunch table by hand: make a network, run box 1 with these flags, run box 2 with those flags, connect the fridge… 15 minutes of flag-typing, and your teammate does it slightly differently and nothing works. 😩

Compose is the laminated table plan 🍽️: one sheet that says "this table has a web box and a proxy box, they share the intercom, only the proxy has a serving window, here's the fridge." Then:

docker compose up — the whole table appears, exactly as drawn. ✨
docker compose down — the whole table vanishes.
Your teammate runs the same file → the identical table. No drift between laptops. (Recognize the theme? Declared state > typed commands — the same idea GitOps applies to whole clusters in the ArgoCD course.)

Our table: the proxy is the only box with a window (8080:80); it forwards everyone to web by name. web itself has NO window — reachable only through the proxy, like a kitchen behind the counter.

🗺️ Diagram

flowchart LR
    yml["📄 compose.yml<br/>the table plan"]
    subgraph table["🍽️ one shared network, auto-created"]
        proxy["📦 proxy - nginx<br/>🪟 the ONLY window :8080"]
        web["📦 web - our app<br/>no window, name-only"]
        proxy -->|"http://web:3000<br/>by service NAME"| web
    end
    you["🧑‍💻 you"]
    yml -->|"1 docker compose up --build"| table
    you -->|"2 localhost:8080"| proxy

❓ What

services: — each entry becomes a container; the service name is its DNS name on the auto-created network.
build: ./app vs image: nginx:alpine — bake ours, buy theirs.
ports: only where the outside world enters; internal services stay windowless (smaller attack surface — hygiene, lesson 08!).
volumes: — our proxy bind-mounts its config read-only (:ro).
depends_on: — start order (web before proxy). Start ≠ ready — real readiness is what k8s probes solve properly (k8s course, lesson 07).
Daily verbs: up --build, down, ps, logs -f web, exec web sh.

🧠 Compose describes a desired application topology

compose.yml
web
 ├── depends_on → api
 │                 └── db
 └── network: app-net (everyone by name)

The five commands you'll type daily:

docker compose up -d      # create + start the whole table, detached
docker compose ps         # who's up
docker compose logs -f    # everyone's output, tailed
docker compose exec web sh   # a shell inside one service
docker compose down       # stop + remove (add -v to drop volumes)

depends_on controls start order only. It does not mean the dependency is ready to accept traffic — db may be "started" and still initializing. For readiness use a healthcheck + condition: service_healthy, or make the app retry. (Kubernetes solves the same problem with readiness probes.)

🤔 Why

Compose is where "my dev setup" becomes a file in git — reviewable, shareable, versioned. It's also the best mental bridge to Kubernetes: a Compose service ≈ Deployment + Service, the shared network ≈ cluster DNS. Learn the small school, and the big school feels familiar.

🧪 Try it

docker compose up --build          # the whole table, one command
# open http://localhost:8080       # → proxy → web, by name 🎉

curl localhost:8080                # 🍱 hello from <web's container id>
curl localhost:3000 || echo "web has NO window — exactly as planned 🙅"

docker compose ps                  # the table's seating chart
docker compose logs -f web         # one box's diary (Ctrl+C)
docker compose down                # table vanishes, nothing left behind

⚠️ Common mistakes

depends_on = start order, not readiness — the app must retry or use healthchecks
exposing every service's port to the host — only the front door needs ports:
docker compose down -v in the wrong directory — it deletes that project's volumes

⏭️ Next

Our image is small because the app has zero dependencies. Real apps have build steps and heavy tools — and there's a trick to keep images tiny anyway: multi-stage builds.

git checkout lesson-07-multi-stage

← Previousvolumes networks Next →multi stage

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