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

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

🏢 धडा 13 — पडद्यामागे: शाळेचे कार्यालय

📍 तुम्ही इथे आहात: 13 पैकी धडा 13 · मागचा: lesson-12-storage · बोनस पुढचा: lesson-14-deploy-gitops

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

सर्व 13 धडे — ही branch म्हणजे पूर्ण course. शेवटचा भाग: control plane — आधीचा प्रत्येक धडा प्रत्यक्षात घडवून आणणारी यंत्रणा. 4K आकृत्यांसह बोनस सखोल अभ्यास: docs/under-the-hood.md.

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

इतका वेळ तुम्ही "शाळेशी" बोलत होता — पण ती खरोखर चालवते कोण? शाळेच्या कार्यालयात 🏢 जा आणि कर्मचाऱ्यांना भेटा:

मुख्याध्यापिका 🧑‍💼 (API server) — कोणीही फक्त त्यांच्याशीच बोलू शकते. पालक (kubectl), शिक्षिका, इतर कर्मचारीसुद्धा — सगळे मुख्याध्यापिकांच्या टेबलावरूनच जाते. "मला 2 pods हवे" हे मुख्याध्यापिकांना दिलेले पत्र आहे.
मोठी नोंदवही 📖 (etcd) — मुख्याध्यापिका सगळे काही एकाच पवित्र वहीत लिहितात: प्रत्येक वर्ग, मूल, नियम, इच्छा. नोंदवही हरवली = शाळेची स्मृती हरवली. खरे तर नोंदवही म्हणजेच शाळा.
वेळापत्रक बनवणारी 🗓️ (scheduler) — नोंदवहीत "नवे मूल, बाक दिलेला नाही" पाहते आणि सर्वात योग्य वर्गखोली निवडते (धडा 08 मधली ताटांची मोजणी!). ठरलेली जागा पुन्हा नोंदवहीत लिहिते. स्वतः बाक ठेवत नाही!
तपासनीस 🔍 (controller manager) — नोंदवहीतल्या इच्छांची वास्तवाशी कायम तुलना करणारे कारकून: "नोंदवहीत 2 पाणी घालणारे लिहिले आहेत, मी 1 मोजतो → आणखी एकासाठी आदेश लिहा." धडा 03 मधला वर्ग-प्रमुख इथेच राहतो!
वर्गशिक्षिका 🧑‍🏫 (kubelet, प्रत्येक machine वर एक) — वर्गखोल्यांमध्ये. प्रत्येक जण मुख्याध्यापिकांना सतत विचारत असते "माझ्या खोलीसाठी काही आहे का?" आणि मग प्रत्यक्ष containers सुरू करते, धडा 07 चे probes चालवते, परत अहवाल देते.

संपूर्ण course मध्ये तुम्हाला जाणवलेली जादू — self-healing, autoscaling, rollouts — म्हणजे फक्त हे पाच जण, एकच नोंदवही सतत वाचत आणि लिहित. कोणतीही जादू नाही. 🪄❌

🗺️ आकृती — `kubectl apply` खरोखर काय करते

sequenceDiagram
    participant You as 🧑 kubectl apply
    participant API as 🧑‍💼 API server
    participant E as 📖 etcd
    participant CM as 🔍 controllers
    participant S as 🗓️ scheduler
    participant KL as 🧑‍🏫 kubelet on node
    You->>API: "I wish: Deployment, 2 replicas"
    API->>E: write the wish
    CM->>API: sees Deployment → creates ReplicaSet → creates 2 Pods, unassigned
    S->>API: sees unassigned pods → picks best node for each
    KL->>API: "anything for my node?" → yes!
    KL->>KL: pull image 🍱, start container, run probes 🙋
    KL->>API: "running & ready" → written to etcd
    Note over You,KL: kubectl get pods now shows 2/2 Running 🎉

❓ काय

Control plane (कार्यालय): API server, etcd, scheduler, controller manager. EKS वर हे सगळे AWS तुमच्यासाठी चालवते — ~$73/month त्याचसाठी मोजले जातात (terraform/eks.tf पाहा).
Worker nodes (वर्गखोल्या): kubelet + container runtime + kube-proxy (धडा 04 मधले Service IPs प्रत्यक्ष route करणाऱ्या व्हरांड्यातल्या पाट्या).
सर्वत्र लागू होणारी पद्धत: प्रत्येक गोष्ट etcd मध्ये लिहिलेली एक इच्छा आहे, आणि controllers वास्तवाला तिच्याकडे कायम जुळवत नेतात. Deployment, HPA, Ingress, PVC — प्रत्येक धडा म्हणजे वेगवेगळे पोशाख घातलेली हीच एक पद्धत होती.

🤔 का

कार्यालयातल्या कर्मचाऱ्यांची काळजी तुम्ही का करावी? कारण आता तुम्ही पाहिलेल्या प्रत्येक वर्तनाचे यांत्रिक स्पष्टीकरण आहे — आणि debugging अंदाज न राहता तर्क बनते:

Pod Pending मध्ये अडकला? → वेळापत्रक बनवणारीला खोली सापडत नाही (सहसा धडा 08 चे requests कोणत्याच node वर बसत नाहीत).
Pod CrashLoopBackOff? → वर्गशिक्षिका तो सुरू करते, तो मरतो, पुन्हा तेच (kubectl logs पाहा; अनेकदा धडा 06 मधला config चुकीचा असतो).
kubectl अडकते? → मुख्याध्यापिकांचे टेबल पोहोचण्याच्या पलीकडे आहे (kubeconfig, VPN, cluster बंद).
बदल दुर्लक्षित होतात? → कोणीतरी तपासनीस तुमच्या विरोधात जुळवणी करत आहे — धडा 09 मध्ये HPA तुमची replica संख्या edit करत होता, आठवते?

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

terraform/eks.tf — एकच Terraform resource AWS कडे पूर्ण managed कार्यालय + वर्गखोलीच्या machines चा एक node group मागतो.
.circleci/config.yml — CI म्हणजे "आणखी एक पालक": aws eks update-kubeconfig मुख्याध्यापिकांशी बोलण्यासाठी credentials मिळवते, मग kubectl apply तुम्ही 12 धड्यांमध्ये अभ्यासलेली पत्रे (manifests) सुपूर्द करते.
docs/under-the-hood.md — तीच गोष्ट तीन 4K आकृत्यांमध्ये: docker run, kubectl apply, आणि ALB → Service → pod असा एका HTTP request चा प्रवास.

🧪 करून पाहा

kubectl get nodes -o wide                      # the classroom machines
kubectl -n kube-system get pods                # office staff & helpers you can see
kubectl get --raw /healthz && echo             # ask the principal directly: "ok"

# Watch the office gossip live while you break something (lesson 03 chaos):
kubectl -n school get events -w
# in another terminal:  kubectl -n school delete pod -l app=school-api --wait=false
# → watch: killing → SuccessfulCreate → Scheduled → Pulled → Started. The whole office, on record.

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

kubectl get events · kubectl get componentstatuses · kubectl api-resources

🔗 यावर आधारित: 🪪 AWS L13 (ज्या परिसरात ही कार्यालये उभी आहेत)

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

kubectl get events --sort-by=.lastTimestamp -n school नव्या pod साठी Scheduled → Pulled → Created → Started याच क्रमाने दाखवते.

🧹 साफसफाई

काहीच नाही — तुम्ही फक्त वाचले

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

kubectl nodes शी बोलते असे समजणे — ते फक्त API server शीच बोलते
etcd म्हणजेच cluster हे विसरणे — त्याचा backup घ्या (L18)

🎓 तुम्ही करून दाखवले!

आता तुम्हाला माहीत आहे: containers → pods → deployments → services → namespaces → config आणि secrets → probes → resources → autoscaling → ingress → rollouts → storage → control plane. हे "नवशिक्यांचे Kubernetes" नाही — ही platform engineer ची कामाची शब्दसंपदा आहे.

पुढे कुठे जायचे, याच repo चा वापर करून:

सगळे local ला चालवा: docker compose up, मग minikube + manifests.
खऱ्या cloud वर जा: terraform/ → terraform apply → .circleci/config.yml द्वारे deploy करा (⚠️ खरे पैसे लागतात — त्याच दिवशी terraform destroy करा!).
Production design doc वाचा: docs/architecture.html — 100 शाळांसाठी multi-tenancy, तुम्ही आत्ता शिकलेल्या सगळ्यावर उभी.
बोनस धडा — हाताने deploy करणे थांबवा; प्रत्येक git push robots ना पाठवू द्या:

git checkout lesson-14-deploy-gitops   # CI/CD pipelines + GitOps with ArgoCD 🤖

🏢 Lesson 13 — Under the hood: the school office

📍 You are here: Lesson 13 of 13 · Previous: lesson-12-storage · Bonus next: lesson-14-deploy-gitops

📦 What's in this branch

All 13 lessons — this branch is the complete course. The finale: the control plane — the machinery that made every previous lesson actually happen. Bonus deep-dive with 4K diagrams: docs/under-the-hood.md.

🧒 Explain like I'm 5

All this time you've been talking to "the school" — but who actually RUNS it? Walk into the school office 🏢 and meet the staff:

The principal 🧑‍💼 (API server) — the ONLY person anyone may talk to. Parents (kubectl), teachers, even other staff — everything goes through the principal's desk. "I want 2 pods" is a letter handed to the principal.
The big register 📖 (etcd) — the principal writes EVERYTHING in one sacred book: every class, kid, rule, wish. Lose the register = lose the school's memory. It IS the school, really.
The timetable-maker 🗓️ (scheduler) — sees "new kid, no desk assigned" in the register and picks the best classroom (lesson 08's plate-counting!). Writes the assignment back in the register. Doesn't place desks personally!
The checkers 🔍 (controller manager) — clerks who forever compare the register's wishes with reality: "register says 2 plant-waterers, I count 1 → write an order for one more." Lesson 03's class monitor lives here!
The class teachers 🧑‍🏫 (kubelet, one per machine) — out in the classrooms. Each keeps asking the principal "anything for MY room?" and then actually starts the containers, runs lesson 07's probes, reports back.

The magic you've felt all course — self-healing, autoscaling, rollouts — is just these five, endlessly reading and writing one register. No magic. 🪄❌

🗺️ Diagram — what `kubectl apply` really does

sequenceDiagram
    participant You as 🧑 kubectl apply
    participant API as 🧑‍💼 API server
    participant E as 📖 etcd
    participant CM as 🔍 controllers
    participant S as 🗓️ scheduler
    participant KL as 🧑‍🏫 kubelet on node
    You->>API: "I wish: Deployment, 2 replicas"
    API->>E: write the wish
    CM->>API: sees Deployment → creates ReplicaSet → creates 2 Pods, unassigned
    S->>API: sees unassigned pods → picks best node for each
    KL->>API: "anything for my node?" → yes!
    KL->>KL: pull image 🍱, start container, run probes 🙋
    KL->>API: "running & ready" → written to etcd
    Note over You,KL: kubectl get pods now shows 2/2 Running 🎉

❓ What

Control plane (the office): API server, etcd, scheduler, controller manager. On EKS, AWS runs all of this for you — that's what the ~$73/month is buying (see terraform/eks.tf).
Worker nodes (the classrooms): kubelet + container runtime + kube-proxy (the hallway signs that make lesson 04's Service IPs actually route).
The universal pattern: everything is a wish written to etcd, and controllers reconcile reality toward it, forever. Deployment, HPA, Ingress, PVC — every lesson was this one pattern wearing different costumes.

🤔 Why

Why should you care about the office staff? Because now every behavior you've seen has a mechanical explanation — and debugging becomes deduction, not guessing:

Pod stuck Pending? → the timetable-maker can't find a room (usually lesson 08's requests don't fit any node).
Pod CrashLoopBackOff? → the class teacher starts it, it dies, repeat (check kubectl logs; often lesson 06's config is wrong).
kubectl hangs? → the principal's desk is unreachable (kubeconfig, VPN, cluster down).
Changes ignored? → some checker is reconciling against you — remember the HPA editing your replica count in lesson 09?

🔧 How (in this repo)

terraform/eks.tf — one Terraform resource asks AWS for a complete managed office + a node group of classroom machines.
.circleci/config.yml — CI is "just another parent": aws eks update-kubeconfig gets credentials to speak to the principal, then kubectl apply hands over the letters (manifests) you've studied for 12 lessons.
docs/under-the-hood.md — the same story in three 4K diagrams: docker run, kubectl apply, and the life of one HTTP request through ALB → Service → pod.

🧪 Try it

kubectl get nodes -o wide                      # the classroom machines
kubectl -n kube-system get pods                # office staff & helpers you can see
kubectl get --raw /healthz && echo             # ask the principal directly: "ok"

# Watch the office gossip live while you break something (lesson 03 chaos):
kubectl -n school get events -w
# in another terminal:  kubectl -n school delete pod -l app=school-api --wait=false
# → watch: killing → SuccessfulCreate → Scheduled → Pulled → Started. The whole office, on record.

🔧 kubectl for this lesson

kubectl get events · kubectl get componentstatuses · kubectl api-resources

🔗 Builds on: 🪪 AWS L13 (the campus these offices stand in)

✅ Verify — what you should see

kubectl get events --sort-by=.lastTimestamp -n school shows Scheduled → Pulled → Created → Started for a new pod, in that order.

🧹 Clean up

nothing — you only read

⚠️ Common mistakes

thinking kubectl talks to nodes — it only ever talks to the API server
forgetting etcd IS the cluster — back it up (L18)

🎓 You made it!

You now know: containers → pods → deployments → services → namespaces → config & secrets → probes → resources → autoscaling → ingress → rollouts → storage → the control plane. That's not "beginner Kubernetes" — that's the working vocabulary of a platform engineer.

Where to go next, using this very repo:

Run it all locally: docker compose up, then minikube + the manifests.
Go to the real cloud: terraform/ → terraform apply → deploy via .circleci/config.yml (⚠️ costs real money — terraform destroy the same day!).
Read the production design doc: docs/architecture.html — multi-tenancy for 100 schools, built on everything you just learned.
Bonus lesson — stop deploying by hand; let robots ship every git push:

git checkout lesson-14-deploy-gitops   # CI/CD pipelines + GitOps with ArgoCD 🤖

← Previousstorage Next →deploy gitops

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