HCL Language - 10 - Terraform Modules

Terraform Modules in HCL

Terraform is a versatile infrastructure as code (IaC) tool that allows you to define and manage resources on various cloud platforms. In this guide, we’ll delve into Terraform modules in HashiCorp Configuration Language (HCL). Modules enable you to encapsulate and reuse configurations, making your IaC more organized and maintainable.

Understanding Terraform Modules

Terraform modules are self-contained packages of Terraform configurations that can be easily reused across different projects. They allow you to encapsulate infrastructure components, variables, and resources into a single unit, providing a higher level of abstraction.

Creating Terraform Modules

To create a Terraform module, you organize your configuration files into a dedicated directory, typically containing a .tf file with the module’s settings. This directory should also include any necessary variables, outputs, and resources that define the module’s behavior.


# Directory structure for a Terraform module
my_module/
  ├── main.tf
  ├── variables.tf
  ├── outputs.tf
  ├── README.md

In this example, a Terraform module named “my_module” includes the main configuration file main.tf, variable definitions in variables.tf, output definitions in outputs.tf, and optional documentation in README.md.

Using Terraform Modules

Once you’ve created a Terraform module, you can use it in your main configuration by referencing it in the Terraform configuration files. This allows you to utilize the module’s resources and configurations within your project.


module "my_module" {
  source = "./my_module"
  var1   = "value1"
  var2   = "value2"
}

In this code snippet, the module block references the “my_module” module located in the same directory. It also provides values for variables var1 and var2.

Module Variables and Outputs

Terraform modules can define input variables and output values to make them configurable and reusable. Input variables allow you to customize module behavior, while output values provide information that can be used in your main configuration.


# my_module/variables.tf
variable "var1" {
  description = "Variable 1 description"
}

variable "var2" {
  description = "Variable 2 description"
}

# my_module/outputs.tf
output "output1" {
  value = "This is an output value from my_module"
}

In this example, the “my_module” module defines two input variables (var1 and var2output1). These can be accessed and customized when using the module.

Module Versioning and Sharing

To encourage reusability, Terraform modules can be published and versioned, making them available for sharing with others. Modules can be hosted on version control systems, module registries, or private repositories, and you can specify the module source with version constraints.


module "my_module" {
  source  = "git::https://github.com/user/my-module.git?ref=v1.0.0"
  var1    = "value1"
  var2    = "value2"
}

In this example, the source attribute references a specific version (v1.0.0) of the “my-module” module hosted on GitHub. This ensures that your configuration uses a stable version of the module.

Best Practices for Terraform Modules

To make the best use of Terraform modules in your HCL configurations, consider the following best practices:

Modularity: Keep modules focused on specific tasks or resources to maintain simplicity and reusability.
Documentation: Include clear and concise documentation within modules to aid users in understanding their purpose and usage.
Version Control: Version your modules to ensure stability and maintain compatibility across projects.
Testing: Test modules independently to verify their functionality before using them in larger configurations.

Conclusion

Terraform modules in HCL are a powerful tool for organizing and reusing infrastructure configurations. By creating modular, versioned modules and following best practices, you can streamline your IaC development and promote consistency across projects.

HCL Language – 10 – Terraform Modules