Using Modules in Terraform: A Simple Guide to Better Infrastructure Code

If you’ve been using Terraform to manage your infrastructure, you’ve probably noticed that your configurations can quickly become repetitive and difficult to maintain. Writing the same code repeatedly

If you’ve been using Terraform to manage your infrastructure, you’ve probably noticed that your configurations can quickly become repetitive and difficult to maintain. Writing the same code repeatedly for similar resources is tedious and increases the risk of errors.

This is where Terraform modules come in. Modules are like building blocks for your infrastructure code – they allow you to write reusable, modular, and maintainable configurations. In this article, I will explain what modules are, why they’re useful, and how to use them in your Terraform projects.

---

What is a Terraform Module?

A Terraform module is a collection of Terraform configuration files (e.g., main.tf, variables.tf, outputs.tf) that work together to create a set of resources. Think of it as a reusable piece of code that you can call multiple times in your configurations.

For example, if you’re creating multiple EC2 instances in AWS, instead of writing the same code repeatedly, you can create a module for an EC2 instance and reuse it wherever needed.

---

Why Use Modules?

Here are some key benefits of using Terraform modules:

1. Reusability: Write once, use everywhere.

2. Modularity: Break down complex infrastructure into smaller, manageable pieces.

3. Consistency: Ensure resources are created the same way every time.

4. Collaboration: Share modules with your team or the community.

5. Maintainability: Update a module once, and the changes apply everywhere it’s used.

---

How to Use a Terraform Module

Using a Terraform module is simple. Let’s walk through an example of creating and using a module to provision an AWS EC2 instance.

Step 1: Create the Module

First, create a directory structure for your module. For example:

modules/
  ec2-instance/
    main.tf
    variables.tf
    outputs.tf

modules/ec2-instance/main.tf

This file defines the resources for the module. Here’s an example:

resource "aws_instance" "example" {
  ami           = var.ami_id
  instance_type = var.instance_type
  tags = {
    Name = var.instance_name
  }
}

modules/ec2-instance/variables.tf

This file defines the input variables for the module:

variable "ami_id" {
  description = "The AMI ID for the EC2 instance"
  type        = string
}

variable "instance_type" {
  description = "The instance type for the EC2 instance"
  type        = string
  default     = "t2.micro"
}

variable "instance_name" {
  description = "The name tag for the EC2 instance"
  type        = string
}

modules/ec2-instance/outputs.tf

This file defines the outputs for the module:

output "instance_id" {
  description = "The ID of the EC2 instance"
  value       = aws_instance.example.id
}

Step 2: Use the Module

Now that the module is created, you can use it in your main Terraform configuration.

main.tf

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

module "web_server" {
  source        = "./modules/ec2-instance"
  ami_id        = "ami-1234567890" # Replace with your AMI ID
  instance_type = "t2.micro"
  instance_name = "web-server"
}

output "web_server_instance_id" {
  value = module.web_server.instance_id
}

Step 3: Initialize and Apply

Run the following commands to initialize and apply your Terraform configuration:

terraform init
terraform apply

Terraform will provision the EC2 instance using the module.

---

Real-World Example: Reusing Modules

Let’s say you need to create multiple EC2 instances for different environments (e.g., dev, staging, production). Instead of writing the same code multiple times, you can reuse the module:

main.tf

module "dev_server" {
  source        = "./modules/ec2-instance"
  ami_id        = "ami-1234567890"
  instance_type = "t2.micro"
  instance_name = "dev-server"
}

module "stg_server" {
  source        = "./modules/ec2-instance"
  ami_id        = "ami-1234567890"
  instance_type = "t2.micro"
  instance_name = "stg-server"
}

module "prd_server" {
  source        = "./modules/ec2-instance"
  ami_id        = "ami-1234567890"
  instance_type = "t2.micro"
  instance_name = "prd-server"
}

This approach saves time, reduces errors, and makes your code easier to maintain.

---

Best Practices for Using Modules

1. Keep Modules Small and Focused: Each module should have a single responsibility.

2. Use Descriptive Names: Choose meaningful names for modules, variables, and outputs.

3. Document Your Modules: Provide clear documentation for how to use the module.

4. Version Your Modules: Use versioning to avoid breaking changes.

5. Test Your Modules: Use tools like Terratest to test your modules.

---

Conclusion

Terraform modules are a powerful way to make your infrastructure code reusable, modular, and maintainable. By encapsulating resources into modules, you can simplify your configurations, reduce duplication, and ensure consistency across environments.

Whether you’re managing a small project or a large-scale infrastructure, Terraform modules are a must-have tool in your IaC toolkit.

---

👉 Follow me for more insights on DevOps, Terraform, and cloud-native technologies:

• Twitter: https://x.com/arun7pulse

• YouTube: https://www.youtube.com/arun7pulse

• LinkedIn: https://www.linkedin.com/in/arun7pulse/

• Medium: https://medium.com/@arun7pulse

• Newsletter: https://pulsetechops.substack.com/subscribe

#TechOps #DevOps #SRE #Platform #InfrastructureAsCode #Terraform

---