Working with Terraform Modules

Terraform modules are building blocks that enhance reusability, simplify configuration, and ensure consistency in infrastructure as code (IaC). Whether creating custom modules or leveraging existing ones, understanding how to work effectively with Terraform modules is crucial for efficient infrastructure management. This article explores key aspects of Terraform modules, including module creation, usage, versioning, composition, and the differences between public and private modules, with detailed examples.

Module Creation

Modules encapsulate reusable Terraform configurations, enabling you to define, manage, and share infrastructure components consistently.

Steps to Create a Module:

1. Define Resources: Create a main.tf file containing the resources.
2. Parameterize with Variables: Use variables.tf to make the module flexible.
3. Output Results: Include outputs.tf for returning values from the module.

Scenario:

Creating a module to deploy an AWS S3 bucket:

Module Structure:

modules/
  ├── s3_bucket/
      ├── main.tf
      ├── variables.tf
      └── outputs.tf

main.tf:

resource "aws_s3_bucket" "bucket" {
  bucket = var.bucket_name
  acl    = var.acl
}

variables.tf:

variable "bucket_name" {}
variable "acl" {
  default = "private"
}

outputs.tf:

output "bucket_arn" {
  value = aws_s3_bucket.bucket.arn
}

Module Usage

Modules are referenced in Terraform configurations to provision infrastructure.

Usage Steps:

1. Source Declaration: Specify the module path in the configuration.
2. Pass Inputs: Assign values to module variables.
3. Retrieve Outputs: Use module outputs in the main configuration.

Scenario:

Using the S3 bucket module in a project:

Main Configuration:

module "s3" {
  source      = "./modules/s3_bucket"
  bucket_name = "example-bucket"
  acl         = "public-read"
}

output "bucket_arn" {
  value = module.s3.bucket_arn
}

Module Versioning

Versioning ensures consistency and avoids breaking changes when modules are updated. Modules stored in versioned repositories like Terraform Registry or Git can specify versions.

Scenario:

Referencing a specific version of a module from Terraform Registry:

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "3.14.0"

  cidr = "10.0.0.0/16"
  azs  = ["us-east-1a", "us-east-1b"]
}

When upgrading versions, use the terraform plan command to preview changes.

Module Composition

Modules can be composed by combining multiple modules to build complex infrastructure setups. This approach promotes modularity and reduces duplication.

Scenario:

Composing modules for a web application:

Structure:

modules/
  ├── network/
  ├── compute/
  └── storage/

Main Configuration:

module "network" {
  source = "./modules/network"
}

module "compute" {
  source = "./modules/compute"
  vpc_id = module.network.vpc_id
}

module "storage" {
  source      = "./modules/storage"
  bucket_name = "app-data"
}

This structure allows the application’s components to be managed independently while being interconnected.

Public vs Private Modules

Public Modules:

• Hosted on Terraform Registry: Accessible to everyone.
• Use Cases: Common infrastructure patterns like VPCs, EC2, or S3.
• Example:

  module "vpc" {
    source  = "terraform-aws-modules/vpc/aws"
    version = "3.14.0"
  }

Private Modules:

• Stored in Private Repositories: Used within an organization.
• Use Cases: Organization-specific configurations or sensitive infrastructure setups.
• Example:

  module "internal_network" {
    source = "git::ssh://git@github.com/org/private-modules.git//network"
  }

Public modules offer ready-to-use solutions, while private modules provide tailored functionality and enhanced security.

Conclusion

Terraform modules simplify infrastructure management by promoting reuse, consistency, and scalability. Whether creating custom modules, managing versions, or composing them for complex setups, understanding these practices is vital. Balancing public and private modules ensures a secure and efficient infrastructure tailored to your needs.