Infrastructure as Code ও Terraform — Provisioning-এ Reconciliation Loop

# tf_plan_apply.py -- core of Terraform's plan/apply algorithm: a
# declarative resource graph (HCL, conceptually), a diff() against
# RECORDED state, and a topological sort for dependency-correct ordering.
DESIRED = {
    "vpc-main":     {"type": "aws_vpc",            "depends_on": [],
                      "attrs": {"cidr_block": "10.0.0.0/16"}},
    "subnet-a":     {"type": "aws_subnet",         "depends_on": ["vpc-main"],
                      "attrs": {"cidr_block": "10.0.1.0/24"}},
    "sg-web":       {"type": "aws_security_group", "depends_on": ["vpc-main"],
                      "attrs": {"ingress_port": 443}},
    "instance-web": {"type": "aws_instance",       "depends_on": ["subnet-a", "sg-web"],
                      "attrs": {"instance_type": "t3.micro"}},
}


def topo_order(graph):
    """Kahn's algorithm over depends_on edges. A subnet resource block
    that REFERENCES a VPC resource's id (e.g. vpc_id = aws_vpc.vpc-main.id
    in real HCL) creates exactly this kind of edge -- nobody writes the
    creation order by hand, Terraform derives it from the reference."""
    indeg = {name: 0 for name in graph}
    children = {name: [] for name in graph}
    for name, r in graph.items():
        for dep in r["depends_on"]:
            children[dep].append(name)
            indeg[name] += 1
    ready = sorted([n for n, d in indeg.items() if d == 0])
    order = []
    while ready:
        n = ready.pop(0)
        order.append(n)
        for child in sorted(children[n]):
            indeg[child] -= 1
            if indeg[child] == 0:
                ready.append(child)
        ready.sort()
    return order


def diff(desired, recorded):
    """`terraform plan`'s core: compare desired config against Terraform's
    RECORDED state -- NOT the live cloud provider -- and compute exactly
    which resources need CREATE / UPDATE / DELETE / no-op. Pure
    computation, no side effects: this is why plan is safe to run anytime."""
    order = topo_order(desired)
    plan = []
    for name in order:
        d = desired[name]
        if name not in recorded:
            plan.append(("CREATE", name, d["type"], d["attrs"]))
        elif recorded[name]["attrs"] != d["attrs"]:
            plan.append(("UPDATE", name, d["type"], (recorded[name]["attrs"], d["attrs"])))
        else:
            plan.append(("no-op", name, d["type"], None))
    for name in recorded:
        if name not in desired:
            plan.append(("DELETE", name, recorded[name]["type"], None))
    return plan


def print_plan(plan, title):
    print(f"--- {title} ---")
    for action, name, rtype, detail in plan:
        if action == "CREATE":
            print(f"  + CREATE  {name} ({rtype})  attrs={detail}")
        elif action == "UPDATE":
            before, after = detail
            print(f"  ~ UPDATE  {name} ({rtype})  {before} -> {after}")
        elif action == "DELETE":
            print(f"  - DELETE  {name} ({rtype})")
        else:
            print(f"  . no-op   {name} ({rtype})")
    print(f"  plan: {sum(1 for p in plan if p[0]=='CREATE')} to create, "
          f"{sum(1 for p in plan if p[0]=='UPDATE')} to update, "
          f"{sum(1 for p in plan if p[0]=='DELETE')} to delete, "
          f"{sum(1 for p in plan if p[0]=='no-op')} unchanged")
    print()


def apply_plan(plan, recorded):
    """`terraform apply`: execute the plan's actions, in the SAME
    topologically-sorted order plan computed, and update recorded state
    to match. Plan only computes the diff; apply performs it."""
    for action, name, rtype, detail in plan:
        if action == "CREATE":
            recorded[name] = {"type": rtype, "attrs": DESIRED[name]["attrs"]}
        elif action == "UPDATE":
            recorded[name]["attrs"] = DESIRED[name]["attrs"]
        elif action == "DELETE":
            del recorded[name]
    return recorded


print("=== resource graph -> topological creation order ===")
print(" ", " -> ".join(topo_order(DESIRED)))
print()

recorded_state = {}  # brand-new: Terraform has never seen this infra before
plan1 = diff(DESIRED, recorded_state)
print_plan(plan1, "terraform plan  (recorded state is empty)")

recorded_state = apply_plan(plan1, recorded_state)
print("terraform apply: 4 resources created, recorded state updated.\n")

plan2 = diff(DESIRED, recorded_state)
print_plan(plan2, "terraform plan  (run again immediately -- idempotency check)")

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

=== resource graph -> topological creation order ===
  vpc-main -> sg-web -> subnet-a -> instance-web

--- terraform plan  (recorded state is empty) ---
  + CREATE  vpc-main (aws_vpc)  attrs={'cidr_block': '10.0.0.0/16'}
  + CREATE  sg-web (aws_security_group)  attrs={'ingress_port': 443}
  + CREATE  subnet-a (aws_subnet)  attrs={'cidr_block': '10.0.1.0/24'}
  + CREATE  instance-web (aws_instance)  attrs={'instance_type': 't3.micro'}
  plan: 4 to create, 0 to update, 0 to delete, 0 unchanged

terraform apply: 4 resources created, recorded state updated.

--- terraform plan  (run again immediately -- idempotency check) ---
  . no-op   vpc-main (aws_vpc)
  . no-op   sg-web (aws_security_group)
  . no-op   subnet-a (aws_subnet)
  . no-op   instance-web (aws_instance)
  plan: 0 to create, 0 to update, 0 to delete, 4 unchanged

তিনটা জিনিস লক্ষ্য করুন। প্রথমত, topological order — vpc-main সবার আগে (কারো ওপর নির্ভর করে না), instance-web সবার শেষে (দুটোর ওপর নির্ভরশীল); sg-web আর subnet-a-এর মধ্যে কোনো নির্ভরতা নেই বলে তাদের আপেক্ষিক ক্রম অনির্ধারিত — এখানে alphabetical tie-break-এ sg-web আগে এসেছে, কিন্তু subnet-a আগে এলেও equally বৈধ হতো। দ্বিতীয়ত, প্রথম plan-এ সবকিছু CREATE, কারণ recorded state খালি। তৃতীয়ত — সবচেয়ে গুরুত্বপূর্ণ — apply-এর ঠিক পরেই আবার plan চালালে সবকিছু no-op: এটাই idempotency, কথায় না বলে বাস্তবে দেখানো।