코드로 관리하는 인프라

Manually clicking through a cloud console to create servers and networks is slow, error-prone, and impossible to reproduce. Infrastructure as Code (IaC) defines your infrastructure in files you can version, review, and re-run.

IaC brings software engineering discipline to infrastructure:

• Version control and code review for changes
• Reproducible environments (dev, staging, prod identical)
• Automated, fast provisioning and teardown
• Self-documenting infrastructure

IaC tools are usually declarative: you describe the desired end state and the tool figures out how to get there. Imperative scripts instead list the exact steps. Declarative is easier to reason about and converge to.

Here is a declarative definition of a virtual machine. You state what should exist; the tool creates or updates it to match.

A core IaC property is idempotency: applying the same definition repeatedly yields the same result. If the resource already matches, nothing changes. This makes re-runs safe.

Many tools track a state of what they manage. When reality diverges — someone changes a resource by hand — that is drift. The tool detects drift and can reconcile infrastructure back to the declared definition.

Good IaC workflows preview changes before applying them. A plan step shows exactly what will be created, changed, or destroyed, so you catch a destructive change in review rather than in production.

Two related but distinct jobs:

• Provisioning creates infrastructure (Terraform, CloudFormation, Pulumi)
• Configuration management sets up software on existing machines (Ansible, Chef, Puppet)

Containers and immutable images blur this line.

Avoid copy-paste by packaging infrastructure into reusable modules with input variables. One well-tested module can stamp out identical, parameterized environments for many teams.

IaC fits naturally into pipelines: a commit triggers a plan, review approves it, and the pipeline applies it. Combined with containers and Kubernetes manifests, the entire stack — network, cluster, and apps — becomes reproducible from code.

Keep IaC healthy: store state remotely and locked, never hardcode secrets, review every plan, keep modules small, and treat infrastructure code exactly like application code — tested and reviewed.

Test your understanding of Infrastructure as Code.

You learned the foundations of Infrastructure as Code:

• Declarative definitions describe desired state idempotently
• State tracking detects and reconciles drift
• Plan before apply to preview changes safely
• Modules enable reuse; IaC integrates into CI/CD pipelines