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

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

📏 धडा 08 — Sync policies: robot वही किती काटेकोरपणे पाळतो

📍 तुम्ही इथे आहात: 12 पैकी धडा 08 · मागील: lesson-07-first-application · पुढील: lesson-09-self-heal-drift

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

धडे 01–07, आणि त्यासोबत robot च्या आज्ञापालनाच्या settings: manual विरुद्ध automated sync, आणि काटेकोरपणाचे दोन dials — prune आणि selfHeal.

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

प्रत्येक केअरटेकर robot ला घराचे नियम 📏 लागतात. तुमच्या robot कडे एक मोठे बटण आणि दोन dials आहेत:

मोठे बटण — वही बदलली की robot…

…आधी विचारतो? ✋ ("manual sync") — खोली आता नव्या पानाशी जुळत नाही हे त्याच्या लक्षात येते, तो पिवळा "OutOfSync" फलक लावतो, आणि तुम्ही होकार देईपर्यंत थांबतो (Sync click करा). तुमच्या click शिवाय काहीच बदलत नाही.
…सरळ करून टाकतो? ⚡ ("automated sync") — वही बदलताक्षणी तो खोली दुरुस्त करतो. होकाराची गरज नाही.

Dial 1 — prune 🗑️: वहीतून एक पोस्टर काढून टाकले. robot भिंतीवरचे खरे पोस्टर काढू शकतो का? बंद = तो फक्त नवे लावतो/बदलतो, कधीच काढत नाही (सुरक्षित, पण अनाथ वस्तू मागे राहतात). चालू = वहीचेच पूर्ण राज्य — वहीतून गेले, खोलीतूनही गेले.

Dial 2 — selfHeal ↩️: एका मुलाने (वहीने नव्हे!) खुर्च्या हलवल्या. robot त्या परत लावू शकतो का? बंद = तो फक्त पिवळा फलक लावतो. चालू = खुर्च्या काही मिनिटांत परत जागेवर, प्रत्येक वेळी.

शिकताना सगळे सौम्य ठेवून सुरुवात करा. Production मध्ये आधी automated, मग selfHeal, मग prune चालू करा — जाणीवपूर्वक, एका वेळी एक dial, सुरक्षा-उपायांसह (reviewed PRs, CI validation, तपासून पाहिलेला backup). विशेषतः prune खरे resources delete करू शकतो, म्हणून त्याचा क्रम सर्वात शेवटी येतो.

🗺️ आकृती

flowchart LR
    change["📖 change lands in git<br/>app goes OutOfSync 🟡"]
    manual["✋ manual sync<br/>robot ASKS - you click Sync"]
    auto["⚡ automated sync<br/>robot ACTS on its own"]
    prune["🗑️ prune: true<br/>deleted in git → deleted live"]
    heal["↩️ selfHeal: true<br/>hand-edits get reverted"]
    change -->|"1"| manual
    change -->|"2"| auto
    auto -.->|"3 dial"| prune
    auto -.->|"4 dial"| heal

❓ काय

syncPolicy:
  automated:          # omit this whole block = manual sync
    prune: true       # default false: never delete unless told
    selfHeal: true    # default false: report drift, don't revert it

OutOfSync हा तुलनेचा निकाल आहे, error नाही — "वही ≠ खोली".
prune शिवाय, git मधून काढलेले resources कायमचे तसेच पडून राहतात (आणि नंतर सगळ्यांना गोंधळात टाकतात). selfHeal शिवाय, drift दिसतो पण दुरुस्त होत नाही — तरीही भाग 1 पेक्षा हे चांगलेच, जिथे तो अदृश्य होता!
खास प्रसंगांसाठी सुटकेचे मार्ग आहेत: sync क्रमासाठी annotations (waves/hooks) आणि ठराविक diffs दुर्लक्षित करण्यासाठी (उदा. HPA च्या ताब्यातील replica count — ते field तुम्ही ignore कराल). ते अस्तित्वात आहेत हे माहीत ठेवा; सुरुवात तिथून करू नका.
अजून automate कधी करू नये: repo मध्ये review किंवा CI validation नाही; app कडे असे state आहे जे तुम्ही पुन्हा तयार करू शकत नाही (prune चे क्षेत्र — git मधून काढलेला PVC म्हणजे data गेला); एखादा HPA किंवा operator असे fields लिहितो जे ArgoCD ला ignore करायला तुम्ही सांगितलेले नाही (selfHeal त्याच्याशी भांडेल); किंवा OutOfSync कसा दिसतो हे तुम्ही अजून शिकत आहात. Manual sync हे वैशिष्ट्य आहे, अपयश नाही.

🤔 नेहमी सर्वात काटेकोर का नाही?

कारण काटेकोरपणा माणसांकडची सत्ता वहीकडे सोपवतो — आणि ते तेव्हाच चांगले जेव्हा वही विश्वासार्ह असते (reviewed PRs, CI validation). Teams सहसा ही शिडी चढतात: manual → automated → +prune → +selfHeal, प्रत्येक पायरीवर आत्मविश्वास मिळवत. Demo app ची application.yaml पूर्ण काटेकोर स्वरूपात येते कारण ते खेळाचे मैदान आहे — गोष्टी बंद करून फरक अनुभवा.

🧪 करून पाहा

# A) feel MANUAL mode — turn automation off:
kubectl -n argocd patch application hello-school --type merge \
  -p '{"spec":{"syncPolicy":null}}'
kubectl -n gitops-school scale deployment hello-school --replicas=3
kubectl -n argocd get application hello-school    # OutOfSync 🟡 — but nothing happens
# in the UI: yellow app, a diff view, and a Sync button waiting for your nod

# B) nod (sync it) via CLI or the UI button:
argocd app sync hello-school 2>/dev/null || echo "or click Sync in the UI"

# C) restore full strictness for the next lessons:
kubectl -n argocd patch application hello-school --type merge \
  -p '{"spec":{"syncPolicy":{"automated":{"prune":true,"selfHeal":true},"syncOptions":["CreateNamespace=true"]}}}'

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

Step A: syncPolicy काढून 3 पर्यंत scale केल्यावर, kubectl -n argocd get application hello-school OutOfSync दाखवते आणि तसेच राहते; UI मध्ये पिवळी tile, replicas: 2 → 3 असलेला Diff view, आणि एक Sync बटण दिसते. Step B: sync केल्यावर, Synced आणि 2 pods. Step C: पुन्हा पूर्ण automated — आणखी एकदा scale करा आणि ते परत उलटताना पाहा.

🧹 स्वच्छता

Step C चालला आहे (automated + prune + selfHeal परत आले) याची खात्री करा, नाहीतर धडे 09–10 वेगळे वागतील. बाकी काहीही काढायचे नाही.

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

आधी prune चालू करणे — जो resource तुम्ही ठेवण्यासाठी मुद्दाम git मधून काढला होता तो गायब होतो
selfHeal एखाद्या HPA शी किंवा replicas किंवा status fields लिहिणाऱ्या operator शी भांडतो — ignoreDifferences जोडा (धडा 09)
OutOfSync ला error समजून kubectl ने "दुरुस्त" करणे — खरा उपाय म्हणजे sync किंवा commit
वहीवर कोणाचाच विश्वास नाही म्हणून production app कायम manual sync वर ठेवणे — review process सुधारा, मग बटण फिरवा

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: बहुतेक teams automated + selfHeal चालवतात, आणि एखाद्या app चे सगळे resources git मध्ये आल्यावर त्या app साठी prune जोडतात; sync waves आणि hooks sync चा क्रम ठरवतात (CRDs आणि namespaces आधी, migrations Deployments च्या आधी). शिकताना manual ने सुरुवात करा; प्रत्येक dial जाणीवपूर्वक, सुरक्षा-उपायांसह चालू करा.

⏭️ पुढे

selfHeal चालू असताना, robot शी खरीखुरी लढाई करूया — आणि हरूया, काही सेकंदांत, live.

git checkout lesson-09-self-heal-drift

📏 Lesson 08 — Sync policies: how strictly the robot follows the book

📍 You are here: Lesson 08 of 12 · Previous: lesson-07-first-application · Next: lesson-09-self-heal-drift

📦 What's in this branch

Lessons 01–07, plus the robot's obedience settings: manual vs automated sync, and the two strictness dials — prune and selfHeal.

🧒 Explain like I'm 5

Every caretaker robot needs house rules 📏. Yours has one big switch and two dials:

The big switch — when the book changes, does the robot…

…ASK first? ✋ ("manual sync") — it notices the room no longer matches the new page, hangs a yellow "OutOfSync" sign, and waits for you to nod (click Sync). Nothing changes without your click.
…just DO it? ⚡ ("automated sync") — it fixes the room the moment the book changes. No nodding needed.

Dial 1 — prune 🗑️: a poster was removed from the book. May the robot take the real poster off the wall? Off = it only adds/updates, never removes (safe but leaves orphans). On = the book fully rules — gone from the book, gone from the room.

Dial 2 — selfHeal ↩️: a kid (not the book!) moved the chairs. May the robot move them back? Off = it just hangs the yellow sign. On = chairs go back within minutes, every time.

Start with everything gentle while learning. In production, turn on automated, then selfHeal, then prune — deliberately, one dial at a time, with safeguards (reviewed PRs, CI validation, a backup you have tested). Prune in particular can delete real resources, so it earns its place last.

🗺️ Diagram

flowchart LR
    change["📖 change lands in git<br/>app goes OutOfSync 🟡"]
    manual["✋ manual sync<br/>robot ASKS - you click Sync"]
    auto["⚡ automated sync<br/>robot ACTS on its own"]
    prune["🗑️ prune: true<br/>deleted in git → deleted live"]
    heal["↩️ selfHeal: true<br/>hand-edits get reverted"]
    change -->|"1"| manual
    change -->|"2"| auto
    auto -.->|"3 dial"| prune
    auto -.->|"4 dial"| heal

❓ What

syncPolicy:
  automated:          # omit this whole block = manual sync
    prune: true       # default false: never delete unless told
    selfHeal: true    # default false: report drift, don't revert it

OutOfSync is a comparison result, not an error — "book ≠ room".
Without prune, resources removed from git linger forever (and confuse everyone later). Without selfHeal, drift is visible but not fixed — already better than Part 1, where it was invisible!
Escape hatches exist for special cases: annotations for sync order (waves/hooks) and for ignoring specific diffs (e.g. a replica count that an HPA owns — you'd ignore that field). Know they exist; don't start there.
When NOT to automate yet: the repo has no review or CI validation; the app owns state you cannot recreate (prune territory — a PVC removed from git is data gone); an HPA or operator writes fields you have not told ArgoCD to ignore (selfHeal would fight it); or you are still learning what OutOfSync looks like. Manual sync is a feature, not a failure.

🤔 Why not always strictest?

Because strictness transfers power from humans to the book — which is only good once the book is trustworthy (reviewed PRs, CI validation). Teams usually walk the ladder: manual → automated → +prune → +selfHeal, gaining confidence at each rung. The demo app's application.yaml ships fully strict because it's a playground — flip things off and feel the difference.

🧪 Try it

# A) feel MANUAL mode — turn automation off:
kubectl -n argocd patch application hello-school --type merge \
  -p '{"spec":{"syncPolicy":null}}'
kubectl -n gitops-school scale deployment hello-school --replicas=3
kubectl -n argocd get application hello-school    # OutOfSync 🟡 — but nothing happens
# in the UI: yellow app, a diff view, and a Sync button waiting for your nod

# B) nod (sync it) via CLI or the UI button:
argocd app sync hello-school 2>/dev/null || echo "or click Sync in the UI"

# C) restore full strictness for the next lessons:
kubectl -n argocd patch application hello-school --type merge \
  -p '{"spec":{"syncPolicy":{"automated":{"prune":true,"selfHeal":true},"syncOptions":["CreateNamespace=true"]}}}'

✅ Verify — what you should see

Step A: after removing syncPolicy and scaling to 3, kubectl -n argocd get application hello-school shows OutOfSync and stays that way; the UI shows a yellow tile, a Diff view with replicas: 2 → 3, and a Sync button. Step B: after syncing, Synced and 2 pods. Step C: fully automated again — scale once more and watch it revert.

🧹 Clean up

Make sure step C ran (automated + prune + selfHeal restored) or lessons 09–10 behave differently. Nothing else to remove.

⚠️ Common mistakes

turning on prune first — a resource you removed from git on purpose to keep it disappears
selfHeal fighting an HPA or an operator that writes replicas or status fields — add ignoreDifferences (lesson 09)
reading OutOfSync as an error and "fixing" it with kubectl — the fix is a sync or a commit
leaving a production app on manual sync forever because nobody trusts the book — fix the review process, then flip the switch

🏭 Why this matters in production: most teams run automated + selfHeal, and add prune per app once all of its resources are in git; sync waves and hooks order the sync (CRDs and namespaces first, migrations before Deployments). Start manual while learning; turn each dial on deliberately, with safeguards.

⏭️ Next

With selfHeal on, let's have a proper fight with the robot — and lose, in seconds, live.

git checkout lesson-09-self-heal-drift

← Previousfirst application Next →self heal drift

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