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

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

🔑 धडा 12 — GitOps मधले Secrets + शेवटचे गुणपत्रक

📍 तुम्ही इथे आहात: 12 पैकी धडा 12 — शेवटचा धडा! · मागील: lesson-11-helm-kustomize-envs

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

सगळे 12 धडे — संपूर्ण course. शेवटचा ड्रॅगन: secrets (एकमेव गोष्ट जी वहीत कधीच उघडपणे बसू नये), आणि मग शेवटचे ArgoCD-सह-विरुद्ध-ArgoCD-शिवाय गुणपत्रक.

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

वही 📖 अद्भुत आहे कारण ती सगळे वाचू शकतात. आणि नेमक्या त्याच कारणामुळे तुम्ही लॉकरची चावी तिच्या आत कधीच चिकटवू नये. 🔑❌ git मध्ये paste केलेला password म्हणजे प्रसिद्ध केलेला password — कायमचा (git कधीच विसरत नाही, तुम्ही तो "delete" केल्यानंतरही).

वहीच्या जगात चाव्या हाताळण्याचे दोन प्रामाणिक मार्ग:

वहीत चिकटवलेली कुलूपबंद पेटी 🔐 (Sealed Secrets): तुम्ही चावी अशा पेटीत बंद करता जी फक्त तुमच्या शाळेचा केअरटेकर उघडू शकतो, आणि ती पेटी वहीत चिकटवता. पेटी आहे हे सगळ्यांना दिसते; ती फक्त cluster च्या आतला robot उघडू शकतो. प्रसिद्ध करायला सुरक्षित, आणि तरीही पूर्णपणे GitOps.
चावी कुठे ठेवली आहे हे सांगणारी चिठ्ठी 🗝️ (External Secrets Operator): वहीत फक्त "बँकेच्या तिजोरीतील चावी #42" (AWS Secrets Manager, Vault…) इतकेच लिहिलेले असते. शाळेच्या आतला एक मदतनीस ती आणून योग्य खोलीकडे देतो. वही स्वच्छ राहते; तिजोरी तिजोरीची कामे करते (rotation!).

k8s course च्या धडा 06 मधलाच नियम — सूचना फलक विरुद्ध लॉकरची चावी — आता थेट वहीलाच लागू.

🗺️ आकृती

flowchart LR
    bad["❌ plaintext password in git<br/>= published forever"]
    sealed["🔐 Sealed Secrets<br/>encrypted box IN the book<br/>only the cluster can open"]
    eso["🗝️ External Secrets<br/>book holds a POINTER<br/>to a vault / AWS SM"]
    cluster["🏫 cluster<br/>real Secret exists only here"]
    bad -.->|"1 never do this"| bad
    sealed -->|"2 decrypt inside"| cluster
    eso -->|"3 fetch inside"| cluster

❓ काय

आपल्या demo app ने मुद्दाम ड्रॅगन टाळला (DB नाही) — पण k8s course ची secret.example.yaml युक्ती (खरी file git-ignored) GitOps मध्ये चालत नाही: जे वहीत नाही, ते robot सांभाळत नाही.
Sealed Secrets: private key असलेला एक controller; तुम्ही kubeseal ने encrypt करता; SealedSecret git मध्ये जाते; ते फक्त cluster च्या आतच खरे Secret बनते. सोपे, स्वयंपूर्ण.
External Secrets Operator (ESO): git मधले ExternalSecret खऱ्या secret store मधल्या एका path चा संदर्भ देते; ESO ते Secret मध्ये sync करतो. Cloud stores + rotation सोबत सर्वोत्तम. (SOPS + age हा तिसरा मार्ग, त्याच धाटणीचा.)

🔧 कसे (एक किमान Sealed Secret, सुरुवातीपासून शेवटपर्यंत)

🔑 ढोबळ नियम: plaintext Secret कधीच commit करू नका — "फक्त dev साठी" म्हणूनही नाही, base64 म्हणूनही नाही (ते encoding आहे, encryption नाही). एकतर ते encrypt करून वहीत ठेवा (Sealed Secrets, SOPS) किंवा वहीत फक्त एक निर्देश ठेवा (External Secrets Operator).

# 1) install the controller once per cluster (it generates the cluster's key pair):
kubectl apply -f https://github.com/bitnami-labs/sealed-secrets/releases/latest/download/controller.yaml
brew install kubeseal            # the CLI that encrypts with the cluster's PUBLIC key

# 2) write the plain Secret locally — NEVER commit this file:
kubectl -n gitops-school create secret generic db-pass \
  --from-literal=password='SuperSecret123' --dry-run=client -o yaml > /tmp/db-pass.yaml

# 3) seal it — the output is safe to commit:
kubeseal --format yaml < /tmp/db-pass.yaml > k8s/db-pass.sealed.yaml
rm /tmp/db-pass.yaml
git add k8s/db-pass.sealed.yaml && git commit -m "add db password (sealed)"

# 4) ArgoCD syncs the SealedSecret; the controller turns it into a real Secret in-cluster:
kubectl -n gitops-school get sealedsecret,secret db-pass

commit केलेली file कशी दिसते ते argocd/examples/sealed-secret.example.yaml दाखवते, आणि argocd/examples/external-secret.example.yaml हे त्याचे ESO रूप आहे: AWS Secrets Manager मधल्या एका key चे नाव देणारे आणि operator ला cluster च्या आत Secret तयार करू देणारे एक ExternalSecret.

🚪 Push चे चार खड्डे — बुजले

खड्डा (धडा 04)	कशाने बुजला	धडा
1 — दोन deploys दरम्यानचा drift अदृश्य असतो	~3-मिनिटांच्या reconcile loop वर selfHeal	09
2 — deployment credentials बाहेरून यावे लागतात	robot आतून pull करतो; CI कडे cluster मध्ये शिरण्याचा कोणताही मार्ग राहत नाही	07
3 — प्रत्येक जास्तीचा cluster keys आणि pipelines वाढवतो	एक वही, प्रत्येक cluster ला एक robot, app-of-apps bootstrap	11
4 — delivery log म्हणजे live सत्य नव्हे	Synced = खोली पानाशी जुळते; sync history सांगते केव्हा	10

🏁 शेवटचे गुणपत्रक

	🎒 हाताने	📮 CI/CD push	🤖 GitOps pull (ArgoCD)
पुन्हा करता येणारे deploys	❌ तुमची आठवण	✅ pipeline	✅ reconcile loop
दोन deploys दरम्यानचा drift	😱 अदृश्य	❌ अदृश्य	✅ काही मिनिटांत ओळखला + उलटवला
Deployment credentials	🔑 प्रत्येक laptop वर	⚠️ CI बाहेरून मिळवते (OIDC सह अल्पायुषी)	✅ cluster कधीच सोडत नाहीत
"आत्ता काय चालू आहे?"	🤷	⚠️ CI ने जे पाठवले ते	✅ वही — नेहमी खरी
Rollback	आठवणीतून पुन्हा रंगवा	⚠️ जुनी pipeline पुन्हा चालवा	✅ `git revert`, 10 सेकंद
History	shell history	⚠️ CI logs	✅ git (desired) + ArgoCD sync history (actual)
10 clusters	❌ 10× वेदना	❌ CI मध्ये 10 keys	✅ 10 agents, एकच वही

प्रगल्भ setup म्हणजे दोन्ही robots: courier 📮 अजूनही प्रत्येक image test आणि build करतो (CI कधीच जात नाही!) — पण त्याची शेवटची पायरी kubectl apply ऐवजी नवा image tag वहीत commit करणे अशी बदलते. केअरटेकर 🤖 सगळे प्रत्यक्ष deploying करतो. Courier build करतो, केअरटेकर deploy करतो — प्रत्येक जण त्याला जे सर्वात चांगले जमते तेच करतो.

🧪 करून पाहा (git कधीच का विसरत नाही ते पाहा)

# prove to yourself that "deleting" a committed secret doesn't work:
echo "password=SuperSecret123" > oops.txt
git add oops.txt && git commit -m "oops" -q
git rm oops.txt -q && git commit -m "remove secret" -q
git show HEAD~1:oops.txt        # 😱 still right there, forever
git reset --hard HEAD~2 -q      # (cleanup — we never pushed, so we got lucky)

# then, for real practice: run the Sealed Secret steps from the How section above.

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

Sealed Secret मार्ग: kubectl -n gitops-school get sealedsecret,secret db-pass दोन्ही objects दाखवते, आणि kubectl -n gitops-school get secret db-pass -o jsonpath='{.data.password}' | base64 -d value छापते — तर git show HEAD:k8s/db-pass.sealed.yaml फक्त ciphertext दाखवते. "git कधीच विसरत नाही" demo: "delete" केल्यानंतरही git show HEAD~1:oops.txt password छापतेच.

🧹 स्वच्छता

Course संपला — सगळे काढून टाका: kubectl -n argocd delete application hello-school, kubectl delete namespace gitops-school, ArgoCD uninstall करा (धडा 06 ची स्वच्छता), आणि install केला असल्यास kubectl delete -f https://github.com/bitnami-labs/sealed-secrets/releases/latest/download/controller.yaml. Cloud cluster आहे? तो नष्ट करा — तोपर्यंत nodes आणि load balancers चे bill लागत राहते.

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

"फक्त dev साठी" म्हणून plaintext Secret commit करणे — git कधीच विसरत नाही, आणि dev repos सगळीकडे clone होतात
base64 ला "encryption" समजणे — ते encoding आहे; ज्याच्याकडे file आहे त्याच्याकडे value आहे
एका cluster च्या key ने seal करून ते दुसऱ्या cluster वर चालेल अशी अपेक्षा करणे — प्रत्येक cluster ची स्वतःची key pair असते; प्रत्येक cluster साठी पुन्हा seal करा, किंवा controller च्या key चा backup घ्या
External Secrets store ला दीर्घकाळ टिकणारी AWS key देणे — त्याच्या service account साठी IAM role वापरा

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: प्रत्येक platform साठी एक pattern निवडा आणि review मध्ये तो काटेकोरपणे पाळा: कमी secrets असलेल्या छोट्या teams साठी Sealed Secrets किंवा SOPS, rotation आणि केंद्रीय audit महत्त्वाचे असतील तेव्हा managed store सह External Secrets. कोणताही मार्ग घ्या, खरे Secret फक्त cluster च्या आतच असते.

🎓 तुम्ही करून दाखवले — संपूर्ण प्रवास

हाताने पोहोचवणे 🎒 → drift 🪑 → courier robot 📮 → त्याच्या मर्यादा 🚪 → वही 📖 → केअरटेकर 🤖 → घराचे नियम 📏 → self-heal शी लढाई हरणे ↩️ → 10-सेकंदांचे rollbacks ⏪ → अनेक खोल्यांसाठी recipes 📚 → कुलूपबंद पेट्या 🔐.

आता तुमच्याकडे deployment ची संपूर्ण कथा आहे — आणि Kubernetes course सोबत, runtime ची संपूर्ण कथाही. जा, काहीतरी बनवा, आणि गृहपाठ robots ना वाहू द्या. 🤖🎒

git checkout main

🔑 Lesson 12 — Secrets in GitOps + the final scorecard

📍 You are here: Lesson 12 of 12 — the final lesson! · Previous: lesson-11-helm-kustomize-envs

📦 What's in this branch

All 12 lessons — the complete course. The last dragon: secrets (the one thing that must never sit plainly in the book), then the final with-vs-without-ArgoCD scorecard.

🧒 Explain like I'm 5

The book 📖 is wonderful because everyone can read it. Which is exactly why you must never glue the locker key inside it. 🔑❌ A password pasted into git is a password published — forever (git never forgets, even after you "delete" it).

Two honest ways to handle keys in a book-world:

A locked box glued into the book 🔐 (Sealed Secrets): you lock the key in a box that only your school's caretaker can open, and glue the BOX into the book. Everyone can see there's a box; only the robot inside the cluster can open it. Safe to publish, still fully GitOps.
A note saying where the key is kept 🗝️ (External Secrets Operator): the book only says "key #42 from the bank vault" (AWS Secrets Manager, Vault…). A helper inside the school fetches it and hands it to the right room. The book stays clean; the vault does vault things (rotation!).

Same rule as the k8s course, lesson 06 — notice board vs locker key — now applied to the book itself.

🗺️ Diagram

flowchart LR
    bad["❌ plaintext password in git<br/>= published forever"]
    sealed["🔐 Sealed Secrets<br/>encrypted box IN the book<br/>only the cluster can open"]
    eso["🗝️ External Secrets<br/>book holds a POINTER<br/>to a vault / AWS SM"]
    cluster["🏫 cluster<br/>real Secret exists only here"]
    bad -.->|"1 never do this"| bad
    sealed -->|"2 decrypt inside"| cluster
    eso -->|"3 fetch inside"| cluster

❓ What

Our demo app dodged the dragon on purpose (no DB) — but the k8s course's secret.example.yaml trick (real file git-ignored) does NOT work in GitOps: if it's not in the book, the robot doesn't manage it.
Sealed Secrets: a controller with a private key; you encrypt with kubeseal; the SealedSecret goes in git; it becomes a real Secret only in-cluster. Simple, self-contained.
External Secrets Operator (ESO): ExternalSecret in git references a path in a real secret store; ESO syncs it into a Secret. Best with cloud stores + rotation. (SOPS + age is a third path, same spirit.)

🔧 How (a minimal Sealed Secret, end to end)

🔑 Rule of thumb: never commit a plaintext Secret — not "just for dev", not base64 (that is encoding, not encryption). Either encrypt it into the book (Sealed Secrets, SOPS) or keep only a pointer in the book (External Secrets Operator).

# 1) install the controller once per cluster (it generates the cluster's key pair):
kubectl apply -f https://github.com/bitnami-labs/sealed-secrets/releases/latest/download/controller.yaml
brew install kubeseal            # the CLI that encrypts with the cluster's PUBLIC key

# 2) write the plain Secret locally — NEVER commit this file:
kubectl -n gitops-school create secret generic db-pass \
  --from-literal=password='SuperSecret123' --dry-run=client -o yaml > /tmp/db-pass.yaml

# 3) seal it — the output is safe to commit:
kubeseal --format yaml < /tmp/db-pass.yaml > k8s/db-pass.sealed.yaml
rm /tmp/db-pass.yaml
git add k8s/db-pass.sealed.yaml && git commit -m "add db password (sealed)"

# 4) ArgoCD syncs the SealedSecret; the controller turns it into a real Secret in-cluster:
kubectl -n gitops-school get sealedsecret,secret db-pass

argocd/examples/sealed-secret.example.yaml shows what the committed file looks like, and argocd/examples/external-secret.example.yaml is the ESO equivalent: an ExternalSecret that names a key in AWS Secrets Manager and lets the operator create the Secret inside the cluster.

🚪 The four gaps of push — closed

Gap (lesson 04)	Closed by	Lesson
1 — drift between deploys is invisible	selfHeal on a ~3-minute reconcile loop	09
2 — deployment credentials must come from outside	the robot pulls from inside; CI keeps no way into the cluster	07
3 — every extra cluster multiplies keys and pipelines	one book, one robot per cluster, app-of-apps bootstrap	11
4 — the delivery log is not the live truth	Synced = room matches page; sync history says when	10

🏁 The final scorecard

	🎒 by hand	📮 CI/CD push	🤖 GitOps pull (ArgoCD)
Repeatable deploys	❌ your memory	✅ pipeline	✅ reconcile loop
Drift between deploys	😱 invisible	❌ invisible	✅ detected + reverted in minutes
Deployment credentials	🔑 every laptop	⚠️ obtained from outside by CI (short-lived with OIDC)	✅ never leave the cluster
"What's running right now?"	🤷	⚠️ what CI sent	✅ the book — always true
Rollback	repaint from memory	⚠️ re-run old pipeline	✅ `git revert`, 10 seconds
History	shell history	⚠️ CI logs	✅ git (desired) + ArgoCD sync history (actual)
10 clusters	❌ 10× pain	❌ 10 keys in CI	✅ 10 agents, same book

The mature setup is BOTH robots: the courier 📮 still tests and builds every image (CI never goes away!) — but its last step changes from kubectl apply to committing the new image tag into the book. The caretaker 🤖 does all actual deploying. Courier builds, caretaker deploys — each doing what it's best at.

🧪 Try it (see why git never forgets)

# prove to yourself that "deleting" a committed secret doesn't work:
echo "password=SuperSecret123" > oops.txt
git add oops.txt && git commit -m "oops" -q
git rm oops.txt -q && git commit -m "remove secret" -q
git show HEAD~1:oops.txt        # 😱 still right there, forever
git reset --hard HEAD~2 -q      # (cleanup — we never pushed, so we got lucky)

# then, for real practice: run the Sealed Secret steps from the How section above.

✅ Verify — what you should see

Sealed Secret path: kubectl -n gitops-school get sealedsecret,secret db-pass shows both objects, and kubectl -n gitops-school get secret db-pass -o jsonpath='{.data.password}' | base64 -d prints the value — while git show HEAD:k8s/db-pass.sealed.yaml shows only ciphertext. The "git never forgets" demo: git show HEAD~1:oops.txt still prints the password after the "delete".

🧹 Clean up

Course over — remove everything: kubectl -n argocd delete application hello-school, kubectl delete namespace gitops-school, uninstall ArgoCD (lesson 06's clean-up), and kubectl delete -f https://github.com/bitnami-labs/sealed-secrets/releases/latest/download/controller.yaml if you installed it. Cloud cluster? Destroy it — nodes and load balancers bill until you do.

⚠️ Common mistakes

committing a plaintext Secret "just for dev" — git never forgets, and dev repos get cloned everywhere
base64 as "encryption" — it is encoding; anyone with the file has the value
sealing with one cluster's key and expecting it to work on another — each cluster has its own key pair; re-seal per cluster, or back up the controller's key
giving the External Secrets store a long-lived AWS key — use an IAM role for its service account

🏭 Why this matters in production: pick one pattern per platform and enforce it in review: Sealed Secrets or SOPS for small teams with few secrets, External Secrets with a managed store when rotation and central audit matter. Either way the real Secret exists only inside the cluster.

🎓 You made it — the whole journey

Hand-delivery 🎒 → drift 🪑 → courier robot 📮 → its limits 🚪 → the book 📖 → the caretaker 🤖 → house rules 📏 → losing a fight with self-heal ↩️ → 10-second rollbacks ⏪ → recipes for many rooms 📚 → locked boxes 🔐.

You now hold the complete deployment story — and with the Kubernetes course, the complete runtime story too. Go build something, and let the robots carry the homework. 🤖🎒

git checkout main

← Previoushelm kustomize envs Finished! Take the quiz →check what stuck

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