Terraform Beginner Installation Tutorial Infrastructure as Code

How to Install Terraform and Create Your First Resource (Step-by-Step)

Published on: November 3, 2023 | Author: DevOps Engineering Team

Terraform Beginner's Guide

Welcome to the world of Infrastructure as Code! This comprehensive guide will walk you through installing Terraform and creating your first infrastructure resource. Perfect for absolute beginners with no prior Terraform experience.

What You'll Learn

• What is Terraform?
• Installing Terraform
• Setting Up Your Environment
• Your First Terraform Configuration
• Essential Terraform Commands
• Creating Your First Resource
• Cleaning Up Resources
• Next Steps

What is Terraform?

Terraform is an Infrastructure as Code (IaC) tool that lets you define and provision infrastructure using a declarative configuration language. Instead of manually creating resources through a web console, you write code that describes your desired infrastructure state.

Key Benefits

• Automation: Automate infrastructure provisioning
• Version Control: Track changes with Git
• Reusability: Share and reuse configurations
• Consistency: Eliminate manual configuration errors
• Collaboration: Team-friendly infrastructure management

How Terraform Works

• Write configuration files (.tf)
• Run terraform init to initialize
• Run terraform plan to preview changes
• Run terraform apply to create resources
• Terraform manages state to track resources

Infrastructure as Code (IaC)

IaC is the process of managing and provisioning computer data centers through machine-readable definition files, rather than physical hardware configuration or interactive configuration tools.

Installing Terraform

Terraform is a single binary that's easy to install on any platform. Choose your operating system below:

🪟

Windows

Using Chocolatey or manual download

🍎

macOS

Using Homebrew or manual download

🐧

Linux

Using package manager or manual download

Windows Installation

Option 1: Using Chocolatey (Recommended)

# Open PowerShell as Administrator
PS> choco install terraform

Option 2: Manual Installation

1. Download Terraform from official website
2. Unzip the downloaded file
3. Move terraform.exe to C:\Windows\System32\ or add to PATH

macOS Installation

Option 1: Using Homebrew (Recommended)

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

Option 2: Manual Installation

1. Download Terraform from official website
2. Unzip the downloaded file
3. Move to /usr/local/bin/

$ sudo mv terraform /usr/local/bin/

Linux Installation

Option 1: Using Package Manager

Ubuntu/Debian:

$ sudo apt-get update && sudo apt-get install -y gnupg software-properties-common
$ wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
$ echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
$ sudo apt update
$ sudo apt install terraform

Option 2: Manual Installation

$ wget https://releases.hashicorp.com/terraform/1.5.7/terraform_1.5.7_linux_amd64.zip
$ unzip terraform_1.5.7_linux_amd64.zip
$ sudo mv terraform /usr/local/bin/

Verifying Your Installation

After installation, verify that Terraform is working correctly:

$ terraform -version
Terraform v1.5.7
on linux_amd64

If you see version information like above, your installation was successful!

Setting Up Your Environment

Before creating infrastructure, you need to set up your environment. We'll use AWS for this tutorial, but the concepts apply to any cloud provider.

AWS CLI Setup

1. Install AWS CLI
2. Configure credentials
3. Set default region

$ aws configure
AWS Access Key ID: [your-access-key]
AWS Secret Access Key: [your-secret-key]
Default region name: us-east-1
Default output format: json

Project Structure

my-first-terraform/

main.tf

variables.tf

outputs.tf

.terraform/

Create this directory structure for your project.

Important Security Note

Never commit AWS credentials to version control! Use environment variables or AWS credentials file. For production, use IAM roles or secret management systems.

Your First Terraform Configuration

Let's create a simple Terraform configuration that sets up a basic AWS S3 bucket.

1

Create Project Directory

$ mkdir my-first-terraform
$ cd my-first-terraform

2

Create main.tf

Create a file named main.tf with the following content:

# Configure the AWS Provider
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

# Configure AWS Provider
provider "aws" {
  region = "us-east-1"
}

# Create a S3 bucket
resource "aws_s3_bucket" "my_first_bucket" {
  bucket = "my-unique-bucket-name-123456" # Must be globally unique

  tags = {
    Name        = "My First Bucket"
    Environment = "Dev"
  }
}

Understanding the Configuration

• terraform block: Specifies required providers and versions
• provider block: Configures the AWS provider with region
• resource block: Defines the S3 bucket to create
• tags: Metadata for your resources

Essential Terraform Commands

Terraform has several key commands you'll use regularly. Here's what they do:

Command	Purpose	When to Use
terraform init	Initialize Terraform configuration	First time in a project, after adding providers
terraform plan	Preview changes before applying	Before applying any changes
terraform apply	Create or update infrastructure	When you're ready to deploy changes
terraform destroy	Destroy managed infrastructure	When you want to clean up resources
terraform validate	Validate configuration syntax	After writing or modifying configuration
terraform fmt	Format configuration files	To maintain consistent code style

Creating Your First Resource

Now let's walk through the complete process of creating your first S3 bucket.

1

Initialize Terraform

$ terraform init

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/aws versions matching "~> 5.0"...
- Installing hashicorp/aws v5.0.0...
- Installed hashicorp/aws v5.0.0 (signed by HashiCorp)

Terraform has been successfully initialized!

This command downloads the AWS provider and sets up the backend.

2

Validate Configuration

$ terraform validate
Success! The configuration is valid.

$ terraform fmt
main.tf

3

Plan the Deployment

$ terraform plan

Terraform will perform the following actions:

  # aws_s3_bucket.my_first_bucket will be created
  + resource "aws_s3_bucket" "my_first_bucket" {
      + bucket = "my-unique-bucket-name-123456"
      + id     = (known after apply)
      + tags   = {
          + "Environment" = "Dev"
          + "Name"        = "My First Bucket"
        }
    }

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

This shows exactly what Terraform will create without making any changes.

4

Apply the Configuration

$ terraform apply

# ... plan output shown ...

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

aws_s3_bucket.my_first_bucket: Creating...
aws_s3_bucket.my_first_bucket: Creation complete after 2s [id=my-unique-bucket-name-123456]

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

Congratulations! You've just created your first infrastructure resource with Terraform!

🎉 Success!

You've successfully created an S3 bucket using Terraform! Check your AWS console to see the bucket listed in the S3 service.

Understanding Terraform State

After running terraform apply, you'll notice a new file: terraform.tfstate. This file contains the current state of your infrastructure.

What is State?

• Maps Terraform config to real resources
• Tracks metadata about resources
• Enables Terraform to know what to update/delete
• Stored in terraform.tfstate by default

State Best Practices

• Never edit state file manually
• Store state remotely for teams
• Use state locking in collaborative environments
• Back up state files regularly

Important: State File Security

The state file may contain sensitive information. Never commit it to version control. Add *.tfstate and *.tfstate.* to your .gitignore file.

Cleaning Up Resources

When you're done experimenting, it's important to clean up resources to avoid unnecessary costs.

1

Destroy Resources

$ terraform destroy

aws_s3_bucket.my_first_bucket: Refreshing state... [id=my-unique-bucket-name-123456]

Terraform will perform the following actions:

  # aws_s3_bucket.my_first_bucket will be destroyed
  - resource "aws_s3_bucket" "my_first_bucket" {
      - bucket = "my-unique-bucket-name-123456" -> null
      - tags   = {
          - "Environment" = "Dev"
          - "Name"        = "My First Bucket"
        } -> null
    }

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

Do you really want to destroy all resources?
  Terraform will destroy all your managed infrastructure, as shown above.
  There is no undo. Only 'yes' will be accepted to confirm.

  Enter a value: yes

aws_s3_bucket.my_first_bucket: Destroying... [id=my-unique-bucket-name-123456]
aws_s3_bucket.my_first_bucket: Destruction complete after 1s

Destroy complete! Resources: 1 destroyed.

2

Verify Cleanup

Check your AWS S3 console to confirm the bucket has been deleted. You can also run:

$ terraform show

This should show no resources, confirming everything has been destroyed.

Next Steps and Best Practices

Now that you've created your first resource, here's what to learn next:

Immediate Next Steps

• Learn about Terraform variables
• Understand resource dependencies
• Explore different AWS resources
• Learn about outputs
• Study Terraform modules

Best Practices to Adopt

• Use version control for all configurations
• Implement remote state storage
• Use variables for configuration
• Create reusable modules
• Implement testing and validation

Example: Enhanced Configuration

Here's a more complete example with variables and outputs:

variables.tf

variable "bucket_name" {
  description = "Name of the S3 bucket"
  type        = string
  default     = "my-default-bucket-name"
}

variable "environment" {
  description = "Environment tag"
  type        = string
  default     = "Dev"
}

main.tf (Enhanced)

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "example" {
  bucket = var.bucket_name

  tags = {
    Environment = var.environment
    ManagedBy   = "Terraform"
  }
}

outputs.tf

output "bucket_name" {
  description = "Name of the created S3 bucket"
  value       = aws_s3_bucket.example.bucket
}

output "bucket_arn" {
  description = "ARN of the created S3 bucket"
  value       = aws_s3_bucket.example.arn
}

Congratulations on Completing This Tutorial! 🎉

You've successfully installed Terraform, learned the basic commands, and created your first infrastructure resource. This is just the beginning of your Infrastructure as Code journey!

---

This is Part 1 of The Ultimate Terraform Mastery Series.

Next: Mastering Terraform Variables and Outputs →