Creating Your First Terraform Module

Traditionally, infrastructure management was a manual process, prone to errors and slow. Terraform offers an alternative: Infrastructure as Code (IaC). IaC defines your infrastructure in code, allowing for version control, reusability, and automation.

This blog post will guide you through creating your first Terraform module to provision an EC2 instance.

Understanding Infrastructure as Code (IaC)

IaC treats infrastructure like any other code, allowing for management with version control systems like Git. This enables collaboration, tracking changes, and rollbacks if necessary.

Terraform for IaC

Terraform is an open-source tool for managing infrastructure as code. It supports multiple cloud providers, including AWS, GCP, Azure, and OpenStack.

Here are some key benefits of using Terraform for IaC:

• Repeatability: Terraform modules allow you to reuse infrastructure configurations, saving time and reducing errors.
• Version Control: Track changes to your infrastructure and roll back to previous versions if needed.
• Collaboration: Share and collaborate on infrastructure definitions with your team.

Getting Started with Terraform

Here’s a quick rundown of what you’ll need to get started with Terraform:

1. Install Terraform: Download and install Terraform from the official website https://developer.hashicorp.com/terraform/install.
2. Configure AWS Credentials: Set up your AWS access key and secret access key to allow Terraform to interact with AWS services.

Writing Your First Terraform Code

Here’s a basic structure for a Terraform configuration:

• main.tf: This file defines the resources you want to create, such as EC2 instances or security groups.
• variables.tf: This file stores variables used throughout your Terraform code. These variables can be customized without modifying the main configuration.
• outputs.tf: This file defines outputs that Terraform will display after applying the configuration.

Creating an EC2 Instance with Terraform

Here’s an example of a Terraform configuration that creates a basic EC2 instance:

main.tf:

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

resource "aws_instance" "ec2-instance" {
ami = var.ami_id
instance_type = var.instance_type
vpc_security_group_ids = [aws_security_group.mysg.id]
}
resource "aws_security_group" "mysg" {
name = "allow-ssh"
description = "Allow SSH traffic"
vpc_id = var.vpc_id
ingress {
from_port = var.port
to_port = var.port
protocol = "tcp"
cidr_blocks = [var.cidr_block]
}
tags = {
name = "allow_ssh"
}
}

variables.tf:

variable "ami_id" {
default = "ami-0c2d06d50ce30b442"
}
variable "instance_type" {
default = "t2.micro"
}
variable "vpc_id" {
default = "vpc-bc102dc4"
}
variable "port" {
default = 22
}
variable "cidr_block" {
default = "0.0.0.0/0"
}

outputs.tf:

output "instance_id" {
value = aws_instance.ec2-instance.public_ip
}
output "security_group_id" {
value = aws_security_group.mysg.id
}

Explanation:

• This code defines an EC2 instance (aws_instance) with an AMI ID, instance type, and security group.
• The security group (aws_security_group) allows SSH access on port 22 from anywhere (0.0.0.0/0). This is for demonstration purposes only and should be restricted in a production environment.
• Variables are used to store configurable values like AMI ID and instance type.
• Outputs allow retrieving information about the created resources, such as the public IP address of the EC2 instance.

Using Terraform Modules

Terraform modules encapsulate reusable infrastructure components. They can be created from your local directory or referenced from a remote registry like the Terraform Registry.

Here are the benefits of using Terraform modules:

• Reusability: Package infrastructure components into modules for reuse across different projects.
• Maintainability: Isolate and manage complex configurations within modules, improving code organization.
• Collaboration: Share modules within your team or publish them to the Terraform Registry for wider use.

Converting Your Terraform Code into a Module

Here’s how to convert your EC2 instance code into a reusable Terraform module:

1. Create a directory for your module (e.g., ec2-instance).
2. Move your main.tf, variables.tf, and outputs.tf files into the ec2-instance directory.
3. In your main Terraform directory, create a new main.tf file to reference the module:

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

module "ec2_instance" {
source = "./ec2-instance"

# Pass values to the module's variables
ami_id = var.ami_id
instance_type = var.instance_type
vpc_id = var.vpc_id
port = var.port
cidr_block = var.cidr_block
}

Update your variables.tf file to remove default values (these will now be provided when using the module).

Version Control and Infrastructure Environments

Terraform modules can be version controlled using Git. This allows you to track changes, revert to previous versions, and create separate module versions for different environments (e.g., development, staging, production).

For example, you can tag your module with version numbers to differentiate between development and production configurations.

Terraform Registry

The Terraform Registry is a central repository for sharing and discovering Terraform modules. You can publish your own modules to the registry or use modules from other developers.

Conclusion

Creating Terraform modules is a straightforward way to improve code reusability, maintainability, and collaboration in your infrastructure deployments. By leveraging modules and IaC principles, you can manage your infrastructure in a more efficient and automated way.

Read the complete article here: https://www.squadcast.com/blog/creating-your-first-module-using-terraform

Squadcast is an Incident Management tool that’s purpose-built for SRE. Get rid of unwanted alerts, receive relevant notifications and integrate with popular ChatOps tools. Work in collaboration using virtual incident war rooms and use automation to eliminate toil.