Infrastructure as Code (IaC)

Introduction: Moving Beyond "Hello World

Providers: The Bridge to the Cloud

State Locking: Preventing Disaster

Modules: The Lego Blocks

Environment Separation: Workspaces vs. Directories

Loops: count vs. for_each

Data Sources: Querying Reality

Preconditions and Postconditions: Assertions in Code

Provisioners: The "Avoid" Feature

OpenTofu: The Open-Source Fork

Introduction: The Heart of Terraform

Remote Backends and Locking

State Fracturing (Layering)

Connecting Layers: Remote State Data Source

Drift Detection: Reality vs. Code

Importing Legacy Infrastructure

The `moved` Block: Declarative State Refactoring

Sensitive Data in State

Introduction: Pets vs. Cattle

Packer: The Image Builder

Writing a Packer Template

Golden Images and Hardening

AMI Management Strategy

Introduction: Why Ansible?

Inventory: Where Are We Going?

Playbooks: The To-Do List

Variables and Precedence

Templating with Jinja2: Filters and Loops

Handlers: Doing Things Only When Necessary

Roles: Organizing Your Code

Ansible Vault: Keeping Secrets Safe

Tags: Selective Execution

Introduction: Speed vs. Safety

Where Does It Fit in the Pipeline?

Static Analysis: Checkov and tfsec

OPA and Rego: The Universal Policy Engine

Learning Rego Syntax

HashiCorp Sentinel: Enterprise-Integrated Policy

Introduction: The Limits of Configuration

AWS CDK: Constructs and Levels

Pulumi: Multi-Cloud with Real Languages

Custom Constructs: Encoding Organizational Standards

Custom Providers: Extending IaC to Any API

Cross-Stack References

Introduction: Trust, But Verify

Static Analysis: The Spellchecker (`tflint`)

Plan Analysis: The Guardrail (OPA)

Integration Testing: The Real Deal (Terratest)

Structuring Tests in a Real CI Pipeline

Introduction: Terraform is a Plugin System

The Protocol: gRPC and go-plugin

SDKv2 vs. The Plugin Framework

Provider Project Structure

CRUD Operations

Acceptance Testing

Debugging Providers

Introduction: Escaping the Monolith

Strategy: The Stack Hierarchy

Resolving "State Hell": Circular Dependencies

State Migration During Re-Platforming

Introduction: Coding Patterns in Infrastructure

Composition vs. Inheritance

The Facade Pattern

Dependency Inversion in IaC

Putting It All Together: The Three-Pattern Stack

Introduction: The Entropy of Infrastructure

Remediation Workflows: Manual vs. Automated

The Import Path: Adopting Legitimate Changes

Event-Driven IaC: The Immune System

Choosing a Remediation Strategy: A Decision Framework

Introduction: The Copilot Era

Prompt Engineering for IaC

Scaffolding Modules and Policies

The Dark Side: Hallucinations and Drift

Building a Safe AI-Assisted IaC Workflow

Introduction: The Invisible Price Tag

Cloud Pricing Fundamentals: Why Estimation Is Hard

The Tool: Infracost

Workflow: The Pull Request Comment

Cost Policies: Automating Cost Governance

Introduction: The Dependency Nightmare

Terragrunt Dependencies

Mocking for the First Run

SaaS Orchestration: Spacelift and Terraform Cloud

Introduction: The Era of "Pets

The Master/Agent Architecture

SaltStack: The Hybrid Approach

Agentless vs. Agent-Based: The Ansible Disruption

Configuration Drift: The Core Problem These Tools Solve

Migration Strategy: The "Golden Image" Bridge

Introduction: Stop Applying from Laptops

Atlantis: Terraform in Pull Requests

Flux TF-Controller: The Kubernetes-Native Way

Branch Strategy and Environment Promotion in GitOps

Introduction: From CLI to Control Plane

Providers: Connecting Crossplane to the Cloud

Compositions: Building Your Own API

Crossplane vs. Terraform: Choosing the Right Tool

Introduction: The Wall of YAML

How CDK8s Works: A Client-Side Rendering Engine

Constructs: The Building Blocks of CDK8s

Introduction: The Noisy Neighbor Problem

Strategy 1: Module per Tenant (The Pool Approach)

Strategy 2: Workspace per Tenant (The Clone Approach)

Strategy 3: Cell-Based (Directory per Tenant)