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

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

🤖 धडा 25 — CRDs आणि operators: office ला नवे शब्द शिकवणे

📍 तुम्ही इथे आहात: धडा 25 / 26 · मागील: lesson-24-cluster-upgrades · पुढील: lesson-26-observability

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

आधीचे सगळे, आणि अर्ध्या cloud-native जगामागची विस्तार-यंत्रणा: CustomResourceDefinitions आणि operator pattern.

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

शाळेचे office (L13) एक ठरलेला शब्दकोश बोलते: Pod, Deployment, Service… पण Kubernetes ची सर्वात खोल युक्ती ही — तुम्ही त्याला नवे शब्द शिकवू शकता 📖✨:

शब्द शब्दकोशात जोडा (एक CRD): "आता BackupPlan नावाची गोष्ट आहे, आणि तिच्या fields चा अर्थ हा आहे." लगेच kubectl get backupplans चालते, इच्छा नोंदवहीत (etcd) साठवल्या जातात, RBAC त्यांच्यावर फाटक लावू शकते (L17)… आणि बाकी काहीच घडत नाही. कोणालाच न कळणारा शब्द म्हणजे फक्त फाईलमध्ये ठेवलेले कागद.
त्या शब्दावर काम करणारा robot नेमा (एक controller): तो नोंदवहीत BackupPlan इच्छांवर लक्ष ठेवतो आणि वास्तव सतत त्यांच्याशी जुळवत राहतो — धडा 03 च्या वर्ग-monitor सारखाच reconcile loop, फक्त तुम्ही शोधलेल्या शब्दासाठी.

CRD + controller + आत बसवलेले कौशल्य = operator — एक robot कर्मचारी जो software एखादा मानवी तज्ज्ञ चालवेल तसे चालवतो:

तुम्ही एक आधीच वापरला आहे: ArgoCD! Application हा CRD आहे; त्याचा controller म्हणजे काळजीवाहू robot. तो "आणखी एक Application file" workflow? हीच यंत्रणा.
cert-manager: Certificate ची इच्छा करा → robot TLS मिळवतो आणि कायम renew करतो.
CloudNativePG: Cluster ची इच्छा करा (Postgres, 3 replicas) → robot replication, failover, backups करतो — L22 ने दाखवलेले "ग्रंथपाल शाळेच्या आतच नेमा" हे उत्तर.

लक्षात ठेवायचा pattern: Kubernetes मध्ये, सगळे काही — अंगभूत असो वा शोधलेले — नोंदवहीतला एक शब्द आणि तो खरा करणारा एक robot असते.

🗺️ आकृती

flowchart LR
    crd["📖 CRD<br/>new word: BackupPlan<br/>+ its grammar (fields)"]
    api["🏢 office / etcd<br/>stores BackupPlan wishes<br/>kubectl & RBAC just work"]
    cr["📄 your wish<br/>kind: BackupPlan<br/>nightly: true"]
    ctrl["🤖 controller<br/>watches the word,<br/>reconciles forever (= L03 loop)"]
    real["✅ reality<br/>CronJobs created,<br/>buckets configured…"]
    crd -->|"1 teach"| api
    cr -->|"2 file a wish"| api
    ctrl -->|"3 reads wishes"| api
    ctrl -->|"4 makes true"| real

❓ काय

CRD group/version/kind + एक OpenAPI schema ठरवतो (validation मोफत). Instances ("custom resources") कोणत्याही object सारखे वागतात: YAML, GitOps-योग्य (ArgoCD कोर्स CRs आनंदाने deploy करतो), RBAC-योग्य.
Controllers म्हणजे फक्त programs (सहसा cluster मधले Deployments), जे watch API वापरतात; तयार असाल तेव्हा kubebuilder/operator-sdk ने स्वतःचा लिहा — किंवा कधीच नाही, बहुतेक teams फक्त operators वापरतात.
Operators stateful/तज्ज्ञ software साठी चमकतात (databases, queues, certs, service meshes). Install करण्याआधी पारखा: हे जवळजवळ cluster-admin असलेले software आहे जे तुम्हाला upgrade (L24) आणि monitor (L26) करावे लागते — trade-offs पान लागू होते!
प्रत्यक्ष जगात ओळखा: काहीतरी रोचक install केल्यावर kubectl get crds — एकटा ArgoCD office ला अनेक नवे शब्द शिकवतो.

🤔 का

"सगळे Kubernetes च्या शेजारी न बांधता त्याच्या वर का बांधतात" याचे हे उत्तर आहे: एक नोंदवही, एक reconcile pattern, एक CLI, एक RBAC — कोणीही कधीही शोधलेल्या प्रत्येक संकल्पनेसाठी. CRDs समजल्यामुळे ArgoCD, cert-manager आणि CloudNativePG सारखी tools जादू न राहता "एक शब्द आणि एक robot" बनतात — आणि हे मानसिक मॉडेल हीच खरी पदवी.

🧪 करून पाहा — robot शिवाय एक शब्द शिकवा, आणि शांतता अनुभवा

kubectl apply -f - <<'EOF'
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata: { name: backupplans.school.example.com }
spec:
  group: school.example.com
  scope: Namespaced
  names: { kind: BackupPlan, plural: backupplans, singular: backupplan }
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                nightly: { type: boolean }
EOF

kubectl apply -f - <<'EOF'
apiVersion: school.example.com/v1
kind: BackupPlan
metadata: { name: my-wish, namespace: school }
spec: { nightly: true }
EOF

kubectl -n school get backupplans          # your word, first-class citizen!
# ...and nothing else happens, ever — no robot knows the word. THAT gap
# (wish stored ≠ wish fulfilled) is exactly what a controller fills. 🤖

kubectl -n school delete backupplan my-wish
kubectl delete crd backupplans.school.example.com

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

kubectl get crd · kubectl explain · kubectl api-resources | grep school

🔗 यावर आधारित: 🤖 ArgoCD शाळा L07 (Application म्हणजे नेमके हेच)

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

CRD नंतर kubectl get backupplans चालते; kubectl explain backupplan तुमचा schema छापते.

🧹 साफसफाई

kubectl delete crd backupplans.school.io तो शब्द आणि त्याचे प्रत्येक object काढून टाकतो

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

controller नसलेला CRD आणि काहीतरी घडेल अशी अपेक्षा
CronJob + Deployment आधीच जे करतात त्यासाठी operator लिहिणे

⏭️ पुढे

शेवटचा धडा: हे सगळे चालताना तुम्हाला खरोखर दिसते का? प्रगतिपुस्तके, दैनंदिनी आणि धोक्याच्या घंटा: observability.

git checkout lesson-26-observability

🤖 Lesson 25 — CRDs & operators: teaching the office new words

📍 You are here: Lesson 25 of 26 · Previous: lesson-24-cluster-upgrades · Next: lesson-26-observability

📦 What's in this branch

Everything before, plus the extension mechanism behind half the cloud-native world: CustomResourceDefinitions and the operator pattern.

🧒 Explain like I'm 5

The school office (L13) speaks a fixed dictionary: Pod, Deployment, Service… But here's Kubernetes' deepest trick — you can teach it new words 📖✨:

Add the word to the dictionary (a CRD): "there is now a thing called BackupPlan, and here's what its fields mean." Instantly, kubectl get backupplans works, wishes get stored in the register (etcd), RBAC can gate them (L17)… and absolutely nothing else happens. A word with no one who understands it is just filed paperwork.
Hire a robot who acts on the word (a controller): it watches the register for BackupPlan wishes and endlessly makes reality match — the SAME reconcile loop as lesson 03's class monitor, just for a word you invented.

CRD + controller + baked-in expertise = an operator — a robot employee that runs software the way a human expert would:

You've already USED one: ArgoCD! Application is a CRD; its controller is the caretaker robot. That "one more Application file" workflow? This mechanism.
cert-manager: wish for a Certificate → robot obtains and renews TLS forever.
CloudNativePG: wish for a Cluster (Postgres, 3 replicas) → robot does replication, failover, backups — the "hire the librarian INSIDE the school" answer L22 pointed at.

The pattern to remember: in Kubernetes, everything — built-in or invented — is a word in the register plus a robot who makes it true.

🗺️ Diagram

flowchart LR
    crd["📖 CRD<br/>new word: BackupPlan<br/>+ its grammar (fields)"]
    api["🏢 office / etcd<br/>stores BackupPlan wishes<br/>kubectl & RBAC just work"]
    cr["📄 your wish<br/>kind: BackupPlan<br/>nightly: true"]
    ctrl["🤖 controller<br/>watches the word,<br/>reconciles forever (= L03 loop)"]
    real["✅ reality<br/>CronJobs created,<br/>buckets configured…"]
    crd -->|"1 teach"| api
    cr -->|"2 file a wish"| api
    ctrl -->|"3 reads wishes"| api
    ctrl -->|"4 makes true"| real

❓ What

A CRD defines group/version/kind + an OpenAPI schema (validation for free). Instances ("custom resources") behave like any object: YAML, GitOps-able (the ArgoCD course deploys CRs happily), RBAC-able.
Controllers are just programs (usually in-cluster Deployments) using the watch API; write your own with kubebuilder/operator-sdk when you're ready — or never, most teams only consume operators.
Operators shine for stateful/expert software (databases, queues, certs, service meshes). Judge before installing: it's cluster-admin-ish software you must upgrade (L24) and monitor (L26) — the trade-offs page applies!
Spot them in the wild: kubectl get crds after installing anything interesting — ArgoCD alone teaches the office several new words.

🤔 Why

This is the answer to "why does everyone build ON Kubernetes instead of NEXT to it": one register, one reconcile pattern, one CLI, one RBAC — for every concept anyone ever invents. Understanding CRDs turns tools like ArgoCD, cert-manager and CloudNativePG from magic into "a word plus a robot" — and that mental model is the real graduation.

🧪 Try it — teach a word with NO robot, and feel the silence

kubectl apply -f - <<'EOF'
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata: { name: backupplans.school.example.com }
spec:
  group: school.example.com
  scope: Namespaced
  names: { kind: BackupPlan, plural: backupplans, singular: backupplan }
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                nightly: { type: boolean }
EOF

kubectl apply -f - <<'EOF'
apiVersion: school.example.com/v1
kind: BackupPlan
metadata: { name: my-wish, namespace: school }
spec: { nightly: true }
EOF

kubectl -n school get backupplans          # your word, first-class citizen!
# ...and nothing else happens, ever — no robot knows the word. THAT gap
# (wish stored ≠ wish fulfilled) is exactly what a controller fills. 🤖

kubectl -n school delete backupplan my-wish
kubectl delete crd backupplans.school.example.com

🔧 kubectl for this lesson

kubectl get crd · kubectl explain · kubectl api-resources | grep school

🔗 Builds on: 🤖 ArgoCD school L07 (Application is exactly this)

✅ Verify — what you should see

kubectl get backupplans works after the CRD; kubectl explain backupplan prints your schema.

🧹 Clean up

kubectl delete crd backupplans.school.io removes the word and every object of it

⚠️ Common mistakes

a CRD with no controller and expecting something to happen
writing an operator for what a CronJob + Deployment already do

⏭️ Next

The final lesson: can you actually SEE all of this running? Report cards, diaries and alarm bells: observability.

git checkout lesson-26-observability

← Previouscluster upgrades Next →observability

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