Kris Fernando

Posted on Jan 13

Terraform Session 2: Setup and Build First Project

#terraform #awscommunitybuilder #aws #devops

Infrastructure as Code with Terraform: Getting Started

Are you ready to dive into the world of Infrastructure as Code (IaC) with Terraform? In this beginner-friendly guide, we'll walk you through the essential steps to set up Terraform and deploy your first EC2 instance on AWS.

Setting Up Your Environment

Before we begin, you'll need to install two crucial tools:

Terraform: Available for Windows, Mac, and Linux. Visit the official HashiCorp website for installation instructions specific to your operating system[1].
AWS CLI: This tool allows you to interact with AWS services. After installation, configure it using your AWS access key and secret key[1].

Pro Tip: Never hard-code your AWS credentials in your Terraform files. Instead, use environment variables or AWS profiles for better security[1].

For coding, we recommend using Visual Studio Code with the HashiCorp Terraform plugin for a smooth experience[1].

Installing and Configuring AWS CLI

To get started with AWS CLI, follow these steps:

Installation

Download the AWS CLI installer:

For Windows (64-bit):

 https://s3.amazonaws.com/aws-cli/AWSCLI64PY3.msi

For macOS/Linux:

 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
 unzip awscliv2.zip
 sudo ./aws/install

Run the installer and follow the on-screen instructions[3].
Verify the installation by opening a new terminal and running:

   aws --version

Configuration

After installation, configure AWS CLI with your credentials:

Open a terminal and run:

   aws configure

You'll be prompted to enter:
- AWS Access Key ID
- AWS Secret Access Key
- Default region name (e.g., us-east-1)
- Default output format (e.g., json)
Verify the configuration:

   aws sts get-caller-identity

This command should return your AWS account details, confirming the setup.

Remember to keep your AWS credentials secure and never share them publicly. It's recommended to use IAM roles for EC2 instances or environment variables for increased security when working with AWS resources.

Infrastructure as Code with Terraform: Getting Started

Understanding Terraform Providers

Terraform uses providers to interact with various cloud platforms and services. For AWS, we'll use the official AWS provider. Here's a simple configuration:

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

Versioning Providers

When working with Terraform, it's crucial to manage provider versions to ensure consistency and compatibility. Here's how you can specify provider versions:

Why Version Your Providers?

Stability: Using specific versions helps maintain a stable environment.
Reproducibility: Ensures your code works the same way across different machines and times.
Controlled Updates: Allows you to update providers in a controlled manner.

How to Specify Provider Versions

You can specify provider versions in your Terraform configuration:

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

This block tells Terraform to use version 3.x of the AWS provider, but not version 4.0 or later.

Version Constraints

Terraform supports several version constraint operators:

=: Exact version
!=: Not equal to version
>, >=, <, <=: Comparison operators
~>: Allows only the rightmost version component to increment

For example, ~> 3.0 allows any version from 3.0 up to but not including 4.0.

Best Practices for Versioning

Always specify provider versions in your configurations.
Start with a specific version and loosen constraints as needed.
Regularly update your providers, but test thoroughly before applying to production.

By properly versioning your providers, you'll create more stable and maintainable Terraform configurations.

Let's deploy an EC2 instance using Terraform. Here's a basic resource block:

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

This code specifies the AMI ID and instance type, which are required parameters for creating an EC2 instance[2].

Terraform Workflow Review

The Terraform workflow consists of three main steps:

terraform init: Initializes your Terraform working directory.
terraform plan: Shows you what changes Terraform will make to your infrastructure.
terraform apply: Applies the changes and creates your resources[2].

Managing Terraform State

Terraform uses a state file (.tfstate) to keep track of the resources it manages. This file is crucial for maintaining consistency between your code and the actual infrastructure[5].

Caution: Manual changes to your infrastructure can create discrepancies between the Terraform state and your actual resources. Always use Terraform to manage your infrastructure to avoid these issues[5].

Best Practices and Cleanup

After experimenting, it's important to clean up your resources to avoid unnecessary costs. Use the terraform destroy command to remove all resources created by Terraform[1].

Conclusion

Congratulations! You've taken your first steps into the world of Infrastructure as Code with Terraform. Remember, practice makes perfect. Keep exploring, and soon you'll be managing complex infrastructures with ease.

Happy Terraforming!

Citations:
[1] https://spacelift.io/blog/terraform-infrastructure-as-code
[2] https://spacelift.io/blog/terraform-state
[3] https://www.geeksforgeeks.org/terraform-state-file/
[4] https://www.youtube.com/watch?v=5xyCr7kQxjI
[5] https://www.xenonstack.com/insights/terraform
[6] https://www.cloudthat.com/resources/blog/best-practices-for-terraform-state-file-management
[7] https://developer.hashicorp.com/terraform/language/state
[8] https://www.youtube.com/watch?v=bEXfPzoB4RE
[9] https://kodekloud.com/blog/manage-terraform-state/
[10] https://zeet.co/blog/terraform-state-management