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

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

🧯 धडा 21 — DaemonSets: प्रत्येक मजल्यावर एक

📍 तुम्ही इथे आहात: धडा 21 / 26 · मागील: lesson-20-taints-affinity · पुढील: lesson-22-statefulsets

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

आधीचे सगळे, आणि workload चा तिसरा आकार: DaemonSets — प्रत्येक node वर नेमका एक pod.

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

आग-सुरक्षेचे नियम 🧯: "प्रत्येक मजल्यावर एक अग्निशामक." "इमारतीत कुठेतरी दोन अग्निशामक" नाही — प्रत्येक मजल्यावर, नेमका एक, अपवाद नाही. नवा मजला बांधला? त्यासोबत अग्निशामक येतो. मजला पाडला? त्याचा अग्निशामकही जातो.

हाच DaemonSet — आता तुम्हाला माहीत असलेल्या तीन आकारांची तुलना करा:

Deployment (L03): "N copies, कुठे ते मला फरक पडत नाही" — apps.
StatefulSet (पुढचा धडा): "नावे आणि स्वतःचे drawers असलेल्या N copies."
DaemonSet: "प्रत्येक बाकावर एक copy, बाकांच्या संख्येशी कायम जुळणारी."

प्रत्येक मजल्यावर कोण हवे? इमारतीचा स्वतःचा कर्मचारी वर्ग: कॉरिडॉरमधल्या फोनची wiring (kube-proxy — धडा 04 च्या Services प्रत्यक्ष route कसे करतात!), intercom बसवणारा (CNI plugin), log collectors (त्या बाकावरच्या प्रत्येक pod ची दैनंदिनी वाचून बाहेर पाठवतात — धडा 26 हे वापरतो), monitoring agents (node-exporter), आणि security sensors. तुम्ही धडा 01 पासून नकळत DaemonSets चालवत आहात. 🤯

त्यांच्याकडे सहसा मूठभर tolerations असतात (धडा 20!) — अग्निशामक tainted मजल्यांवरही जातो, अगदी शिक्षिकांच्या विश्रांती-खोलीतसुद्धा.

🗺️ आकृती

flowchart TB
    ds["🧯 DaemonSet: log-collector<br/>'one per desk, always'"]
    subgraph n1["🖥️ desk 1"]
        a1["🪑 app pods…"]
        d1["🧯 collector"]
    end
    subgraph n2["🖥️ desk 2"]
        a2["🪑 app pods…"]
        d2["🧯 collector"]
    end
    subgraph n3["🖥️ NEW desk 3<br/>added by autoscaler"]
        d3["🧯 collector<br/>appears automatically"]
    end
    ds --> d1
    ds --> d2
    ds -.->|"new desk → new copy,<br/>no human involved"| d3

❓ काय

DaemonSet ला pod template असतो (Deployment सारखा) पण replica count नसतो — nodes ची यादी हीच संख्या. Nodes वाढले (धडा 15 चा autoscaler!) की daemons आपोआप वाढतात.
nodeSelector/affinity ने काही मजल्यांपुरते मर्यादित करा ("फक्त Linux बाक", "फक्त GPU pool") — निवडलेल्यांमध्ये प्रत्येक node वर एक.
Rolling updates Deployments सारखेच चालतात (updateStrategy), पण जास्त विचार करा: बिघडलेला log agent सगळीकडे एकदम update केला तर सगळीकडे एकदम त्रास होतो — maxUnavailable: 1 तुमचा मित्र आहे.
Daemons ना सहसा node-पातळीवरचा access लागतो: /var/log/containers वाचायला hostPath volumes, कधीकधी host networking — म्हणूनच इथे RBAC (L17) आणि संयम महत्त्वाचा; DaemonSet प्रत्येक बाकावर असतो.

🤔 का

प्रत्येक node च्या गरजा Deployments वर टाकता येत नाहीत — "कुठेही N copies" मुळे ज्या node चे logs तुम्हाला हवे होते त्याच node वर शून्य collectors येऊ शकतात. DaemonSets node-पातळीवरची infrastructure declarative आणि स्वतः सांभाळणारी बनवतात: platform team चे tools fleet वाढताना, कमी होताना आणि बरा होताना आपोआप तिच्यामागे जातात.

🧪 करून पाहा

# you already run DaemonSets — meet them:
kubectl -n kube-system get daemonsets
# kube-proxy (lesson 04's routing!) + your CNI — DESIRED == number of nodes

# a toy extinguisher on every floor:
kubectl -n school apply -f - <<'EOF'
apiVersion: apps/v1
kind: DaemonSet
metadata: { name: floor-watch }
spec:
  selector: { matchLabels: { app: floor-watch } }
  template:
    metadata: { labels: { app: floor-watch } }
    spec:
      containers:
        - name: watch
          image: busybox
          command: ["sh","-c","echo watching floor $(hostname); sleep infinity"]
          resources: { requests: { cpu: 10m, memory: 16Mi } }
EOF
kubectl -n school get ds,pods -o wide | grep floor
# multi-node cluster? one pod PER node. minikube: one node, one pod —
#   `minikube node add` and watch a second appear by itself 🎉
kubectl -n school delete ds floor-watch

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

kubectl get ds -A · kubectl rollout status ds/…

🔗 यावर आधारित: 🪪 AWS L18 (प्रत्येक बाकावरचा CloudWatch agent)

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

kubectl get ds मध्ये DESIRED = nodes ची संख्या दिसते; एक node जोडा → नवा pod आपोआप दिसतो.

🧹 साफसफाई

local cluster: kubectl delete -f k8s/ (किंवा तुम्ही apply केलेली file) — EKS वर चालू राहिलेल्या कशाचेही तासाप्रमाणे बिल येते

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

load नुसार वाढायला हवे अशा app साठी DaemonSet — ते Deployment चे काम आहे
tolerations विसरणे — tainted nodes वर पोहोचायला DaemonSets ना त्या लागतात

⏭️ पुढे

नावे आणि स्वतःचे drawers असलेले pods — cluster च्या आत database, नीटपणे चालवणे: StatefulSets.

git checkout lesson-22-statefulsets

🧯 Lesson 21 — DaemonSets: one on every floor

📍 You are here: Lesson 21 of 26 · Previous: lesson-20-taints-affinity · Next: lesson-22-statefulsets

📦 What's in this branch

Everything before, plus the third workload shape: DaemonSets — exactly one pod on EVERY node.

🧒 Explain like I'm 5

Fire safety rules 🧯: "one fire extinguisher on EVERY floor." Not "two extinguishers somewhere in the building" — every floor, exactly one, no exceptions. New floor built? Extinguisher appears with it. Floor demolished? Its extinguisher goes too.

That's a DaemonSet — compare the three shapes you now know:

Deployment (L03): "N copies, I don't care where" — apps.
StatefulSet (next lesson): "N copies with names and own drawers."
DaemonSet: "one copy per DESK, matching desk count forever."

Who needs to be on every floor? The building's own staff: the hall-phone wiring (kube-proxy — how lesson 04's Services actually route!), the intercom installer (the CNI plugin), log collectors (read every pod's diary on that desk and ship it out — lesson 26 uses this), monitoring agents (node-exporter), and security sensors. You've been running DaemonSets since lesson 01 without knowing it. 🤯

They usually carry a fistful of tolerations (lesson 20!) — the fire extinguisher goes on tainted floors too, even the teacher's lounge.

🗺️ Diagram

flowchart TB
    ds["🧯 DaemonSet: log-collector<br/>'one per desk, always'"]
    subgraph n1["🖥️ desk 1"]
        a1["🪑 app pods…"]
        d1["🧯 collector"]
    end
    subgraph n2["🖥️ desk 2"]
        a2["🪑 app pods…"]
        d2["🧯 collector"]
    end
    subgraph n3["🖥️ NEW desk 3<br/>added by autoscaler"]
        d3["🧯 collector<br/>appears automatically"]
    end
    ds --> d1
    ds --> d2
    ds -.->|"new desk → new copy,<br/>no human involved"| d3

❓ What

A DaemonSet has a pod template (like a Deployment) but no replica count — the node list IS the count. Scale-out of nodes (lesson 15's autoscaler!) auto-scales the daemons.
Limit to some floors with a nodeSelector/affinity ("only Linux desks", "only GPU pool") — one-per-node within the selection.
Rolling updates work like Deployments (updateStrategy), but think harder: updating a broken log agent everywhere at once hurts everywhere at once — maxUnavailable: 1 is your friend.
Daemons typically need node-level access: hostPath volumes to read /var/log/containers, sometimes host networking — which is exactly why RBAC (L17) and restraint matter here; a DaemonSet is on EVERY desk.

🤔 Why

Per-node concerns can't ride on Deployments — "N copies anywhere" might put zero collectors on the one node whose logs you needed. DaemonSets make node-level infrastructure declarative and self-maintaining: the platform team's tools follow the fleet automatically as it grows, shrinks and heals.

🧪 Try it

# you already run DaemonSets — meet them:
kubectl -n kube-system get daemonsets
# kube-proxy (lesson 04's routing!) + your CNI — DESIRED == number of nodes

# a toy extinguisher on every floor:
kubectl -n school apply -f - <<'EOF'
apiVersion: apps/v1
kind: DaemonSet
metadata: { name: floor-watch }
spec:
  selector: { matchLabels: { app: floor-watch } }
  template:
    metadata: { labels: { app: floor-watch } }
    spec:
      containers:
        - name: watch
          image: busybox
          command: ["sh","-c","echo watching floor $(hostname); sleep infinity"]
          resources: { requests: { cpu: 10m, memory: 16Mi } }
EOF
kubectl -n school get ds,pods -o wide | grep floor
# multi-node cluster? one pod PER node. minikube: one node, one pod —
#   `minikube node add` and watch a second appear by itself 🎉
kubectl -n school delete ds floor-watch

🔧 kubectl for this lesson

kubectl get ds -A · kubectl rollout status ds/…

🔗 Builds on: 🪪 AWS L18 (the CloudWatch agent on every desk)

✅ Verify — what you should see

kubectl get ds shows DESIRED = number of nodes; add a node → a new pod appears by itself.

🧹 Clean up

local cluster: kubectl delete -f k8s/ (or the file you applied) — on EKS, anything left running bills by the hour

⚠️ Common mistakes

a DaemonSet for an app that should scale by load — that's a Deployment
forgetting tolerations — DaemonSets need them to land on tainted nodes

⏭️ Next

Pods with NAMES and their own drawers — running a database inside the cluster, properly: StatefulSets.

git checkout lesson-22-statefulsets

← Previoustaints affinity Next →statefulsets

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