30days of Terraform

Building Reusable Infrastructure with Terraform Modules

Dwayne Chima's photo
Dwayne Chima
·

3 min read

As you progress with Terraform, one of the most important topics to learn is how to make your infrastructure code scalable, modular, and reusable. This is where Terraform Modules come into play. Today, we'll look at the basics of Terraform modules, how to organize them, and how to utilize them to speed infrastructure deployments. By the conclusion of this tutorial, you will understand how to design and deploy reusable Terraform modules for various infrastructure components.

What Are Terraform Modules?

A Terraform module contains various resources that are utilized together. It enables you to encapsulate your code in a reusable and self-contained format. Modules allow you to install the same infrastructure components across several environments or accounts, saving time and maintaining consistency.

There are two sorts of modules you may use:

  1. Root Module: This is the default module, which is used when you create Terraform configuration files directly. It can call other modules; however, the root is not considered a module.

  2. Child Modules: These are reusable groups of resources specified in their own directories that may be accessed from the root module or other modules.

Key Concepts

Before you dive into writing your own modules, it’s essential to understand the key concepts:

  • Inputs: Modules can receive variables (inputs) to tailor their behavior to various use cases. For example, a VPC module may receive inputs such as
    vpc_cidr_block or region.

  • Outputs: After creating resources, the module can return essential data such as IP addresses, security group IDs, and other resource information. These can be returned to the root module or utilized in subsequent modules.

Advantages of Using Terraform Modules

  1. Reusability: Modules enable you to build infrastructure code once and then reuse it in numerous projects or settings. This lowers redundancy and saves time, particularly when installing comparable components across regions or accounts.

  2. Consistency: Using modules guarantees that your infrastructure is delivered consistently across several settings. This lowers the possibility of configuration drift and guarantees that your infrastructure is always built with the same settings.

  3. Simplified Maintenance: When you need to update your infrastructure, you can modify a module's code once. These changes will automatically propagate wherever the module is used, making updates easier to manage and apply consistently across your environments.

  4. Scalability: As your infrastructure increases, modules make it possible to properly scale your deployments. You may easily develop new environments by reusing existing modules, which helps to keep the codebase clean and structured.

  5. Easier Debugging: When problems develop, it is easier to troubleshoot and solve them in a module than in complicated, monolithic settings. This improves the speed and efficiency with which faults may be identified and resolved.

Building a Basic Module

Let’s walk through building a simple EC2 instance module.

mkdir modules
mkdir modules/instance

Define the module: Inside modules/instance, create a main.tf that defines an EC2 instance.

resource "aws_instance" "web" {
  ami           = var.ami
  instance_type = var.instance_type
}

Define inputs (variables): Create a variables.tf file to define the inputs for your module.

variable "ami" {
  description = "AMI ID"
  type        = string
}

variable "instance_type" {
  description = "Instance type"
  type        = string
}

Define Outputs: Create an outputs.tf file to output useful values, such as the EC2 instance ID.

output "instance_id" {
  value = aws_instance.web.id
}

Use the Module in Your Main Configuration

module "instance" {
  source        = "./modules/instance"
  ami           = "ami-id"
  instance_type = "t2.micro"
}

output "instance_id" {
  value = module.instance.instance_id
}

Best Practices for Using Modules

  • Version Control: Always use version control when using modules, whether they're custom or from the Terraform Registry.

  • Avoid Hardcoding Values: Instead, use input variables to keep your modules flexible.

  • Modularize Your Code: Break large infrastructure components into smaller, reusable modules.

TerraformAWS