Creating and Using a Module in Terraform Effectively

Creating and using a module in Terraform is one of the most powerful ways to simplify, scale, and manage cloud infrastructure. By building reusable code blocks, teams can deploy consistent resources across multiple environments and regions without redundancy or complexity.

In this comprehensive guide, you’ll explore how to create a custom Terraform module, use it to deploy multiple infrastructure environments, and understand its long-term benefits for any size project.

What Is a Terraform Module?

At its core, a module in Terraform is a container for multiple resources used together. Any directory that holds Terraform configuration files is a module. The directory where Terraform is executed is known as the root module, and any module called from within it is referred to as a child module.

Modules help to:

• Organize complex configurations
• Promote code reuse across environments
• Enforce consistency in deployments

Why Creating and Using a Module in Terraform Matters

When managing real-world infrastructure like virtual machines, S3 buckets, and databases, your Terraform files can grow out of control. Writing hundreds or thousands of lines of resource definitions becomes a maintenance nightmare.

Instead, you can isolate repeated blocks of code into a module, which can then be invoked multiple times in different contexts (e.g., staging, dev, production), using different inputs.

Designing a Reusable Terraform Module

Let’s consider a fictional company, Flex IT Consulting, that wants to deploy its payroll application in multiple countries using the same architecture. The app consists of:

• An EC2 instance (for the application)
• A DynamoDB table (to store payroll data)
• An S3 bucket (for storing pay stubs and tax documents)

To keep things simple and reusable, the infrastructure for each region is created using a module. The module lives in a directory like this:

/root/terraform-projects/modules/payroll-app/

Within this directory, configuration files define:

• An EC2 instance with a custom AMI (user-specified)
• A DynamoDB table with fixed name and key
• An S3 bucket with a region-prefixed name for uniqueness

Some values, such as instance type or database key, are hardcoded to maintain standardization. Others like AMI ID and region are exposed as input variables for flexibility.

Example: Defining Input Variables for Flexibility

Here’s how the module defines its variables:

variable "app_region" {
  type = string
}

variable "ami" {
  type = string
}

variable "bucket" {
  type    = string
  default = "flexit-payroll-alpha-22001c"
}

These are used throughout the module for configuring resource properties, ensuring a region-specific yet standardized deployment.

Using the Module in a Root Configuration

To deploy the application in the US East (N. Virginia) region, create a root module:

/root/terraform-projects/us-payroll-app/

Inside this directory, add a main.tf file:

module "us_payroll" {
  source        = "../modules/payroll-app"
  app_region    = "us-east-1"
  ami           = "ami-1234567890abcdef0"
}

You can optionally override the default bucket value if needed, but the rest of the configuration (like instance type, DynamoDB table name, etc.) remains fixed for consistency.

Deploying to Multiple Regions

To deploy the same application in another region like the UK (eu-west-2), simply replicate the directory and adjust values accordingly:

/root/terraform-projects/uk-payroll-app/

And the configuration:

module "uk_payroll" {
  source        = "../modules/payroll-app"
  app_region    = "eu-west-2"
  ami           = "ami-0987654321fedcba0"
}

Running terraform init, terraform plan, and terraform apply will provision the same architecture in the new region using the shared module.

Module Resource Addressing in Terraform

When Terraform provisions resources through a module, the full address includes:

module.<module_name>.<resource_type>.<resource_name>

For instance, to refer to the DynamoDB table in the US app deployment:

module.us_payroll.aws_dynamodb_table.payroll_db

This notation allows for precise targeting when referencing or debugging resources managed within modules.

Benefits of Creating and Using a Module in Terraform

1. Simplifies Configuration

Instead of repeating EC2 and database definitions across files, use a single, tested module.

2. Enhances Reusability

A module can be called in any region or project without rewriting code.

3. Improves Consistency

By hardcoding fixed values and exposing only required parameters, modules enforce best practices and reduce human error.

4. Reduces Maintenance

Centralized changes to the module reflect across all environments using it.

Conclusion

Creating and using a module in Terraform is a smart strategy for managing scalable, consistent, and reusable infrastructure. Whether you’re deploying in a single region or across multiple, modules allow you to maintain clean configurations and apply changes confidently.

By following this modular approach, your Terraform code becomes easier to read, debug, test, and scale—paving the way for robust DevOps practices and smoother cloud operations.

Frequently Asked Questions (FAQs)