Why IaC over manual provisioning in Terraform - Why It Works

Introduction

Manually setting up servers and networks takes a lot of time and can lead to mistakes. Infrastructure as Code (IaC) lets you write down your setup in files, so you can create the same setup again and again without errors.

When you want to create the same server setup multiple times without forgetting steps

When you need to fix or update your infrastructure quickly and safely

When you want to share your infrastructure setup with your team easily

When you want to keep a history of changes to your infrastructure

When you want to avoid human errors in setting up cloud resources

Commands

This command sets up Terraform in your folder so it can talk to your cloud provider and prepare to create resources.

Terminal

terraform init

Expected Output

Initializing the backend...



Initializing provider plugins...

- Finding latest version of hashicorp/aws...

- Installing hashicorp/aws v4.0.0...

- Installed hashicorp/aws v4.0.0 (signed by HashiCorp)



Terraform has been successfully initialized!

This command shows what Terraform will do before it makes any changes. It helps you check your setup for mistakes.

Terminal

terraform plan

Expected Output

An execution plan has been generated and is shown below.

Resource actions are indicated with the following symbols:

  + create



Terraform will perform the following actions:



  # aws_instance.example will be created

  + resource "aws_instance" "example" {

      + ami           = "ami-0c55b159cbfafe1f0"

      + instance_type = "t2.micro"

    }



Plan: 1 to add, 0 to change, 0 to destroy.

This command tells Terraform to create the resources you described in your files without asking for confirmation.

Terminal

terraform apply -auto-approve

Expected Output

aws_instance.example: Creating...

aws_instance.example: Still creating... [10s elapsed]

aws_instance.example: Creation complete after 20s [id=i-0abcd1234efgh5678]



Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

→

-auto-approve - Skip manual approval to apply changes immediately

This command removes all the resources Terraform created, cleaning up your cloud environment.

Terminal

terraform destroy -auto-approve

Expected Output

aws_instance.example: Destroying...

aws_instance.example: Destruction complete after 10s



Destroy complete! Resources: 1 destroyed.

→

-auto-approve - Skip manual approval to destroy resources immediately

Key Concept

If you remember nothing else, remember: IaC lets you create, change, and delete infrastructure safely and repeatedly using code instead of manual steps.

Common Mistakes

Running terraform apply without checking terraform plan first

You might create or change resources you did not intend, causing errors or extra costs.

Always run terraform plan first to review what changes will happen.

Manually changing cloud resources after Terraform created them

Terraform will not know about manual changes and can overwrite or lose them on next apply.

Make all changes through Terraform files and commands to keep state consistent.

Not running terraform destroy to clean up resources after testing

Unused resources keep running and cost money.

Run terraform destroy when you no longer need the resources.

Summary

terraform init prepares your folder to work with Terraform and cloud providers.

terraform plan shows what changes Terraform will make before applying them.

terraform apply creates or updates your cloud resources based on your code.

terraform destroy removes the resources Terraform created to avoid extra costs.

Practice

1. Why is Infrastructure as Code (IaC) preferred over manual cloud provisioning?

easy

A. Manual provisioning tracks changes automatically.

B. Manual provisioning is faster for large-scale deployments.

C. IaC requires no knowledge of cloud services.

D. IaC automates setup, saving time and reducing human errors.

Solution

1. Step 1: Understand automation benefits of IaC

   IaC automates cloud setup, which reduces manual work and human mistakes.

2. Step 2: Compare manual provisioning drawbacks

   Manual provisioning is slower and prone to errors, especially at scale.

3. Final Answer:

   IaC automates setup, saving time and reducing human errors. -> Option D

4. Quick Check:

   Automation = IaC advantage [OK]

Hint: IaC automates and reduces errors, unlike manual steps [OK]

Common Mistakes:

• Thinking manual is faster for big setups
• Believing IaC needs no cloud knowledge
• Assuming manual tracks changes automatically

2. Which Terraform command applies your infrastructure code to create resources?

easy

A. terraform apply

B. terraform plan

C. terraform init

D. terraform destroy

Solution

1. Step 1: Identify command to create resources

   terraform apply runs the code and creates or updates infrastructure.

2. Step 2: Differentiate from other commands

   terraform plan shows changes, init sets up, destroy deletes resources.

3. Final Answer:

   terraform apply -> Option A

4. Quick Check:

   Apply = create/update resources [OK]

Hint: Apply means execute changes to infrastructure [OK]

Common Mistakes:

• Confusing plan with apply
• Using init to create resources
• Destroying instead of applying

3. Given this Terraform snippet, what is the main benefit of using it instead of manual setup?

resource "aws_instance" "web" {
  ami           = "ami-123456"
  instance_type = "t2.micro"
}

medium

A. It automatically tracks and applies changes to the instance.

B. It requires manual steps to launch the instance.

C. It disables version control for infrastructure.

D. It prevents reuse of the configuration.

Solution

1. Step 1: Understand Terraform resource block

   This block defines an AWS instance that Terraform can create and manage automatically.

2. Step 2: Compare with manual setup

   Manual setup requires clicking or scripting outside Terraform, no automatic tracking or updates.

3. Final Answer:

   It automatically tracks and applies changes to the instance. -> Option A

4. Quick Check:

   Automatic tracking = IaC benefit [OK]

Hint: Terraform tracks changes; manual does not [OK]

Common Mistakes:

• Thinking manual steps are needed with Terraform
• Believing Terraform disables version control
• Assuming config cannot be reused

4. You wrote Terraform code but it fails to update your cloud resources. What is a common reason for this?

medium

A. Manual provisioning is required after every change.

B. You forgot to run terraform apply after changes.

C. Terraform does not support updating resources.

D. Terraform automatically updates without commands.

Solution

1. Step 1: Identify Terraform workflow

   After editing code, you must run terraform apply to update resources.

2. Step 2: Eliminate incorrect options

   Terraform supports updates but needs apply; manual provisioning is not needed after changes; updates are not automatic without commands.

3. Final Answer:

   You forgot to run terraform apply after changes. -> Option B

4. Quick Check:

   Apply runs updates [OK]

Hint: Always run terraform apply to update resources [OK]

Common Mistakes:

• Assuming Terraform updates automatically
• Thinking manual steps are needed after code changes
• Believing Terraform cannot update resources

5. How does using Terraform as IaC help teams fix problems faster compared to manual provisioning?

hard

A. Manual provisioning is faster to fix because it uses GUIs.

B. Manual provisioning automatically logs all changes for easy fixes.

C. Terraform code is reusable and tracks changes, making troubleshooting easier.

D. Terraform requires no collaboration, so fewer errors occur.

Solution

1. Step 1: Understand Terraform's tracking and reusability

   Terraform stores infrastructure as code, enabling version control and easy sharing.

2. Step 2: Compare with manual provisioning challenges

   Manual provisioning lacks automatic tracking and is harder to reproduce or fix consistently.

3. Final Answer:

   Terraform code is reusable and tracks changes, making troubleshooting easier. -> Option C

4. Quick Check:

   Tracking + reuse = faster fixes [OK]

Hint: Code tracks changes and is reusable for quick fixes [OK]

Common Mistakes:

• Believing manual provisioning logs changes automatically
• Thinking Terraform needs no teamwork
• Assuming GUIs are always faster to fix problems