Writing Your First Terraform Configuration File for DevOps and Cloud Engineers

Welcome to the practical phase of your Terraform and Infrastructure as Code journey. After understanding Infrastructure as Code concepts and setting up your Terraform environment, the next step is learning how to write real Terraform configuration files.

Terraform configuration files are the foundation of modern cloud automation. DevOps engineers, cloud engineers, SRE teams, platform engineers, and infrastructure architects in the USA, UK, India, Europe, and global technology companies use Terraform configuration files to provision AWS infrastructure, Azure resources, Google Cloud services, Kubernetes clusters, databases, networking components, monitoring systems, CI/CD infrastructure, and multi-cloud environments.

In this guide, you will learn HashiCorp Configuration Language (HCL), Terraform file structure, providers, resources, variables, execution lifecycle, and real-world Terraform workflows used in enterprise DevOps projects.

What Is a Terraform Configuration File?

Terraform configuration files define your desired infrastructure state using declarative syntax. Instead of manually creating infrastructure from cloud dashboards or CLI commands, you describe infrastructure using code.

Terraform then calculates:

• What infrastructure needs to be created.
• What infrastructure needs modification.
• What infrastructure should be deleted.
• How dependencies should be handled.

Terraform configuration files usually use the .tf extension.

Example:

main.tf
variables.tf
outputs.tf
providers.tf
terraform.tfvars

What Is HashiCorp Configuration Language (HCL)?

Terraform uses HashiCorp Configuration Language (HCL). HCL is designed to be:

• Human-readable.
• Easy to maintain.
• Machine-friendly.
• Declarative.

Unlike programming languages like Java or Python where you write step-by-step instructions, Terraform focuses on declaring the desired end state of infrastructure.

Imperative Approach
-------------------
Step 1
Step 2
Step 3
Step 4

Declarative Terraform Approach
------------------------------
"Create infrastructure like this"
Terraform calculates the steps automatically
        

Basic HCL Syntax Structure

Terraform configurations are made of blocks, arguments, and expressions.

block_type "label1" "label2" {
  argument_name = value
}

Explanation

Terraform File Organization

Real-world Terraform projects are usually divided into multiple files for better readability and maintainability.

terraform-project/
│
├── main.tf
├── providers.tf
├── variables.tf
├── outputs.tf
├── terraform.tfvars
└── README.md

Purpose of Each File

Writing Your First Terraform Configuration

To avoid cloud costs and simplify learning, we will first use the Local Provider. This provider interacts with your local machine instead of cloud platforms.

Step 1: Create Project Directory

mkdir my-first-terraform-project
cd my-first-terraform-project

Step 2: Create main.tf File

Create a file named main.tf.

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.0"
    }
  }
}

resource "local_file" "welcome_message" {
  filename = "${path.module}/welcome.txt"

  content = "Welcome to Terraform Infrastructure as Code!"
}

Understanding the Configuration

terraform Block

The terraform block configures Terraform itself.

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.0"
    }
  }
}

This tells Terraform:

• Use the local provider.
• Download it from HashiCorp Registry.
• Use a compatible version.

resource Block

resource "local_file" "welcome_message"

This defines:

• resource → Terraform resource block.
• local_file → Resource type.
• welcome_message → Local resource name.

Arguments

filename = "${path.module}/welcome.txt"
content  = "Welcome to Terraform Infrastructure as Code!"

These configure:

• File location.
• Content inside the file.

Terraform Workflow Lifecycle

Terraform follows a standard lifecycle workflow.

Write Terraform Code
        │
        ▼
terraform init
        │
        ▼
terraform validate
        │
        ▼
terraform plan
        │
        ▼
terraform apply
        │
        ▼
Infrastructure Created
        │
        ▼
terraform destroy
        │
        ▼
Infrastructure Removed
        

Step 1: terraform init

Initialize the project:

terraform init

Terraform will:

• Download required providers.
• Create .terraform directory.
• Initialize backend.
• Create lock file.

Read .tf Files
      │
      ▼
Detect Providers
      │
      ▼
Download Plugins
      │
      ▼
Prepare Working Directory
        

Step 2: terraform validate

Validate configuration syntax.

terraform validate

Terraform checks:

• Syntax correctness.
• Provider configuration.
• Resource structure.
• Variable validation.

Step 3: terraform plan

Generate execution plan:

terraform plan

Terraform compares:

• Terraform configuration.
• Terraform state.
• Real infrastructure.

Terraform then shows:

• Resources to create.
• Resources to modify.
• Resources to delete.

Terraform Code
      │
      ▼
Terraform State
      │
      ▼
Provider APIs
      │
      ▼
Execution Plan Generated
        

Step 4: terraform apply

Apply infrastructure changes:

terraform apply

Terraform will ask for confirmation:

Do you want to perform these actions?

Type:

yes

Terraform creates the resource and updates Terraform state.

Step 5: terraform destroy

Destroy infrastructure safely:

terraform destroy

Terraform reads state and removes managed infrastructure.

Understanding Terraform State

After running apply, Terraform creates:

terraform.tfstate

This file stores:

• Resource IDs.
• Metadata.
• Current infrastructure state.
• Dependency mappings.

Real-World DevOps Use Cases

AWS Infrastructure Provisioning

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

Kubernetes Namespace Creation

resource "kubernetes_namespace" "app" {
  metadata {
    name = "production-app"
  }
}

Azure Resource Group

resource "azurerm_resource_group" "main" {
  name     = "production-rg"
  location = "East US"
}

The same Terraform workflow works across AWS, Azure, Google Cloud, Kubernetes, and multi-cloud environments.

Variables in Terraform

Variables make Terraform reusable.

variable "environment" {
  type    = string
  default = "dev"
}

Use variable:

tags = {
  Environment = var.environment
}

Outputs in Terraform

Outputs expose important values after deployment.

output "bucket_name" {
  value = aws_s3_bucket.app.bucket
}

Common Beginner Mistakes

• Forgetting to run terraform init.
• Wrong file extensions like .txt instead of .tf.
• Hardcoding secrets in Terraform files.
• Skipping terraform plan.
• Deleting state files accidentally.
• Not using variables.
• Mixing development and production infrastructure.
• Not formatting code.

Useful Terraform Commands

Interview Preparation Questions

Who Should Learn Terraform Configuration Files?

Terraform configuration skills are essential for DevOps engineers, cloud engineers, AWS engineers, Azure engineers, SRE teams, Kubernetes engineers, platform engineers, infrastructure architects, and professionals preparing for DevOps jobs, Terraform jobs, cloud engineering roles, and infrastructure automation careers in the USA, UK, India, and global remote companies.

Summary

Writing Terraform configuration files is the foundation of Infrastructure as Code automation. Terraform uses HCL to define infrastructure declaratively, allowing engineers to provision cloud infrastructure safely and consistently.

By understanding Terraform blocks, providers, resources, variables, outputs, and workflow commands such as terraform init, terraform plan, and terraform apply, engineers can automate modern cloud infrastructure for AWS, Azure, Google Cloud, Kubernetes, and multi-cloud enterprise environments.