Kubernetes Architecture — Control Plane আর Worker Node-এর স্থাপত্য

লক্ষ্য: controller-manager-এর reconciliation loop প্যাটার্নটা শুধু বাক্যে না রেখে code-এ ঘটিয়ে দেখা — বিশেষভাবে, একটা node-failure-এর পর controller কীভাবে নিজে থেকেই, কোনো manual trigger ছাড়াই, ঠিক যা হারিয়েছে তা আবার তৈরি করে।

# reconcile.py -- toy simulation of the Kubernetes controller-manager's
# core pattern: a reconciliation loop that compares DESIRED state (what
# the user declared) against OBSERVED state (what's actually running) and
# computes the exact create/delete actions needed to converge. Modeled
# after the ReplicaSet/Deployment controller, stripped to its essence.
import itertools

pod_id_counter = itertools.count(1)

class ToyController:
    """Holds desired replica count + observed running toy-pods, and
    reconciles the gap -- exactly the pattern every Kubernetes controller
    (Deployment, ReplicaSet, Job, ...) repeats, each on its own resource."""
    def __init__(self, name, desired_replicas):
        self.name = name
        self.desired_replicas = desired_replicas
        self.observed_pods = []  # list of pod ids currently "running"

    def reconcile(self):
        """One pass of the reconciliation loop. Returns (create, delete)."""
        current = len(self.observed_pods)
        desired = self.desired_replicas
        actions_create, actions_delete = [], []

        if current < desired:
            need = desired - current
            for _ in range(need):
                new_id = f"pod-{next(pod_id_counter)}"
                self.observed_pods.append(new_id)
                actions_create.append(new_id)
        elif current > desired:
            excess = current - desired
            for _ in range(excess):
                removed = self.observed_pods.pop()
                actions_delete.append(removed)
        return actions_create, actions_delete

    def kill(self, pod_id):
        """Simulate a node failure taking a pod down -- OBSERVED state
        drifts away from DESIRED without anyone asking for it."""
        if pod_id in self.observed_pods:
            self.observed_pods.remove(pod_id)

    def status(self):
        return f"desired={self.desired_replicas} observed={sorted(self.observed_pods)}"


def report(step, ctrl, created, deleted):
    print(f"--- iteration {step}: {ctrl.name} ---")
    print(f"  before reconcile desired={ctrl.desired_replicas}")
    if created:
        print(f"  CREATE: {created}")
    if deleted:
        print(f"  DELETE: {deleted}")
    if not created and not deleted:
        print("  no action -- observed already matches desired")
    print(f"  after reconcile   -> {ctrl.status()}")
    print()


ctrl = ToyController("web-deployment", desired_replicas=3)

# iteration 1: nothing observed yet -- controller must create 3
c, d = ctrl.reconcile()
report(1, ctrl, c, d)

# iteration 2: steady state -- observed already matches desired, no-op
c, d = ctrl.reconcile()
report(2, ctrl, c, d)

# iteration 3: user edits the Deployment, scales desired 3 -> 5
ctrl.desired_replicas = 5
c, d = ctrl.reconcile()
report(3, ctrl, c, d)

# iteration 4: simulated node failure -- two running pods vanish without
# the controller being told in advance; OBSERVED silently drifts from DESIRED
print("*** simulated node failure: 2 pods lost ***")
victims = ctrl.observed_pods[:2]
for v in victims:
    ctrl.kill(v)
print(f"    lost: {victims}")
print(f"    observed now: {sorted(ctrl.observed_pods)} (desired still {ctrl.desired_replicas})")
print()

# iteration 5: reconcile notices the gap and recreates exactly what's missing
c, d = ctrl.reconcile()
report(5, ctrl, c, d)

# iteration 6: user scales down 5 -> 2
ctrl.desired_replicas = 2
c, d = ctrl.reconcile()
report(6, ctrl, c, d)

# iteration 7: steady state again
c, d = ctrl.reconcile()
report(7, ctrl, c, d)

প্রকৃত চালিয়ে পাওয়া output (deterministic — হুবহু এটাই আসবে):

--- iteration 1: web-deployment ---
  before reconcile desired=3
  CREATE: ['pod-1', 'pod-2', 'pod-3']
  after reconcile   -> desired=3 observed=['pod-1', 'pod-2', 'pod-3']

--- iteration 2: web-deployment ---
  before reconcile desired=3
  no action -- observed already matches desired
  after reconcile   -> desired=3 observed=['pod-1', 'pod-2', 'pod-3']

--- iteration 3: web-deployment ---
  before reconcile desired=5
  CREATE: ['pod-4', 'pod-5']
  after reconcile   -> desired=5 observed=['pod-1', 'pod-2', 'pod-3', 'pod-4', 'pod-5']

*** simulated node failure: 2 pods lost ***
    lost: ['pod-1', 'pod-2']
    observed now: ['pod-3', 'pod-4', 'pod-5'] (desired still 5)

--- iteration 5: web-deployment ---
  before reconcile desired=5
  CREATE: ['pod-6', 'pod-7']
  after reconcile   -> desired=5 observed=['pod-3', 'pod-4', 'pod-5', 'pod-6', 'pod-7']

--- iteration 6: web-deployment ---
  before reconcile desired=2
  DELETE: ['pod-7', 'pod-6', 'pod-5']
  after reconcile   -> desired=2 observed=['pod-3', 'pod-4']

--- iteration 7: web-deployment ---
  before reconcile desired=2
  no action -- observed already matches desired
  after reconcile   -> desired=2 observed=['pod-3', 'pod-4']

তিনটা মুহূর্ত মন দিয়ে পড়ুন: (১) iteration 2 আর 7-এ কোনো action নেই — reconciliation loop idempotent, একবার converge হয়ে গেলে বারবার চালালেও কিছু বদলায় না; (২) node-failure-এর পর controller-কে কেউ বলেনি “২টা pod হারিয়েছে, replace করো” — পরের reconcile pass নিজে থেকেই gap দেখে ঠিক ২টা নতুন pod (pod-6, pod-7) তৈরি করেছে, hardcoded কোনো “on-failure” handler ছাড়াই; (৩) scale-down-এ (iteration 6) ঠিক ততটুকুই delete হয়েছে যতটুকু দরকার, কোনো বাড়তি cleanup logic ছাড়াই — পুরো controller-এর behavior এই একটা reconcile() ফাংশনেই বন্দি।

নিজে বাড়ান:

1. একটা দ্বিতীয় ToyController (আলাদা name, আলাদা desired count) যোগ করে দেখান দুইটা controller স্বাধীনভাবে reconcile করে, একে অপরকে না ছুঁয়ে — ঠিক যেমন Kubernetes-এ প্রতিটা Deployment-এর নিজের ReplicaSet controller instance থাকে।
2. reconcile()-এ একটা max_actions_per_pass limit যোগ করুন (একবারে সর্বোচ্চ ২টা create/delete) — দেখুন বড় একটা gap বন্ধ হতে কয়টা pass লাগে, আর কেন বাস্তব controller-manager-এও rate-limiting থাকা যুক্তিসঙ্গত (একসাথে হাজার container চালু করার চাপ এড়াতে)।
3. kill()-কে randomize করুন (প্রতি iteration-এ random সংখ্যক pod হারানোর সম্ভাবনা) আর ১০০ iteration চালিয়ে verify করুন observed কখনো desired-এর চেয়ে বেশি iteration ধরে কম থাকে না — এটাই “self-healing” দাবির একটা পরিমাণগত প্রমাণ।