What Is Terraform and How to Use It (2025 Guide)

Introduction

Provisioning cloud infrastructure manually is slow, error-prone, and difficult to maintain. As systems scale, engineers need reproducibility, version control, and automation. That’s where Terraform comes in.

Terraform is the industry-standard tool for Infrastructure as Code (IaC), the practice of managing infrastructure with code instead of clicking around in a cloud provider’s UI. Whether you’re launching EC2 instances, configuring DNS, or spinning up managed databases, Terraform gives you a single workflow to define and deploy your infrastructure across providers.

In this guide, we’ll break down what Terraform is, how it works, and walk through a real-world AWS example. You’ll also learn best practices, common pitfalls, and how to build reusable infrastructure using Terraform modules.

What Is Terraform?

Terraform is an open-source tool developed by HashiCorp for provisioning and managing infrastructure using declarative configuration files.

Instead of manually creating cloud resources, you write .tf files that describe what your infrastructure should look like. Then, Terraform makes it happen by interacting with your cloud provider’s API.

Key Features

• Declarative syntax: You describe what you want, not how to build it.
• Multi-cloud support: Works with AWS, Azure, GCP, Kubernetes, and more.
• State management: Keeps track of deployed infrastructure so it can detect drift and changes.
• Plan and Apply workflow: See changes before making them.

Why Use Terraform?

Terraform solves a core problem: manual infrastructure management doesn’t scale.

Benefits:

• Automation: Define infrastructure once and reuse it many times.
• Version Control: Your infra config lives in Git, rollback and track changes like any code.
• Repeatability: Developers can spin up identical environments for dev, staging, and prod.
• Team Collaboration: Share modules and enforce consistency across teams.

Real-World Scenarios

• Launching cloud environments for each pull request.
• Deploying infrastructure for SaaS products across regions.
• Creating disaster recovery and failover systems with no manual intervention.

Key Concepts in Terraform

Let’s cover the foundational building blocks.

Providers

A provider tells Terraform how to interact with external APIs. Example: aws, google, azurerm, kubernetes.

provider "aws" {
  region = "us-west-2"
}

Resources

Resources are the actual infrastructure components you want to create.

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

Variables & Outputs

Variables allow customization; outputs return useful info post-deployment.

variable "region" {
  default = "us-west-2"
}

output "instance_ip" {
  value = aws_instance.web.public_ip
}

State Files

Terraform stores your infrastructure state in a file (terraform.tfstate).

• Local state (default): saved on your machine
• Remote state (recommended): stored in S3, Terraform Cloud, etc.

Modules

Modules are reusable pieces of configuration, like functions in code.

Installing Terraform

Terraform runs as a single binary. To install:

macOS (Homebrew)

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

Windows (Chocolatey)

choco install terraform

Linux (Manual)

Download from developer.hashicorp.com/terraform/install and move it to your PATH.

Verify installation:

terraform -version

Your First Terraform Script (AWS EC2 Example)

Let’s create a simple EC2 instance using Terraform.

Step 1: Setup

Create a new project folder:

mkdir terraform-ec2 && cd terraform-ec2

Create main.tf:

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"  # Replace with a valid AMI ID
  instance_type = "t2.micro"
}

Step 2: Initialize Terraform

terraform init

This downloads the AWS provider plugin and sets up your working directory for Terraform. Behind the scenes, Terraform creates a hidden folder called .terraform/ which stores provider binaries, dependency locks, and the working state of your project.

Want to understand what really happens when you run init? Learn how Terraform builds a dependency graph (DAG), uses implicit modules, and manages internal files in our Terraform Under the Hood Guide.

Step 3: Plan

terraform plan

Terraform shows the resources it will create.

Step 4: Apply

terraform apply

Type yes when prompted. Terraform provisions your EC2 instance.

Step 5: Destroy

To clean up:

terraform destroy

Using Variables and Outputs

Let’s make the configuration reusable:

variables.tf

variable "region" {
  default = "us-west-2"
}

variable "instance_type" {
  default = "t2.micro"
}

main.tf

provider "aws" {
  region = var.region
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = var.instance_type
}

outputs.tf

output "public_ip" {
  value = aws_instance.web.public_ip
}

Now run terraform apply again, and Terraform will show your EC2’s public IP.

terraform-ec2/\n
├── main.tf\n
├── variables.tf\n
├── outputs.tf\n
├── terraform.tfvars (optional)\n
└── .terraform/ (generated)\n

This structure keeps your code modular and easier to manage as you scale beyond one EC2 instance.

Curious how Terraform actually interprets your folder as a root module, builds a DAG, and handles .tf file loading? Dive deeper in How Terraform Works Under the Hood.

Terraform Modules: Reuse at Scale

Modules allow you to write DRY code by grouping resources together.

Creating a Module

mkdir -p modules/ec2-instance

Inside modules/ec2-instance, create:

main.tf

resource "aws_instance" "this" {
  ami           = var.ami
  instance_type = var.instance_type
}

variables.tf

variable "ami" {}
variable "instance_type" {}

Use it in your root module:

module "web_server" {
  source        = "./modules/ec2-instance"
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Best Practices for Using Terraform

• Use remote state for collaboration (e.g. S3 + DynamoDB for AWS).
• Organize code into modules.
• Run terraform fmt and terraform validate in CI pipelines.
• Avoid hardcoding secrets; use environment variables or tools like Vault.
• Use terraform plan in PR checks to catch unintended changes.

Common Errors and How to Fix Them

Terraform vs CloudFormation vs Pulumi

Verdict: Terraform strikes the best balance between simplicity and power for most engineers.

Real-World Use Cases

• CI/CD Pipelines: Provision and tear down preview environments automatically.
• Multi-region apps: Deploy identical infra to different AWS regions.
• SaaS tenant isolation: Use workspaces to deploy isolated environments per customer.
• Compliance auditing: Use plan files and state diffs to track changes.

Conclusion

Terraform is one of the most important tools in a cloud engineer’s toolkit. It enables fast, predictable, and scalable infrastructure deployment using code.

In this guide, you:

• Learned what Terraform is and how it works
• Built your first AWS EC2 instance using Terraform
• Discovered how to use variables, outputs, and modules
• Explored real-world use cases and best practices

Ready to go further? Check out Terraform Cloud, explore Terraform Registry modules, or integrate Terraform with GitHub Actions for automated deployments.

Related Articles:

• Manual vs Terraform: What’s the Best AWS Workflow for Data Engineers?
• How Terraform Really Works Under the Hood (Modules, State, DAGs Explained)
• What Is Docker, Really? Why Developers Use It, and When You Should Too