In this section, we will explore how to use modules in Terraform. Modules are a powerful way to organize and reuse code, making your Terraform configurations more manageable and scalable.

1. Module Basics: Understand what a module is and how it is structured.
2. Calling a Module: Learn how to call a module from your Terraform configuration.
3. Module Inputs and Outputs: Understand how to pass variables to a module and retrieve outputs.
4. Module Versioning: Learn how to manage different versions of a module.
5. Best Practices: Explore best practices for using modules effectively.

A module in Terraform is a container for multiple resources that are used together. A module consists of the following files:

• main.tf: Contains the primary configuration for the module.
• variables.tf: Defines the input variables for the module.
• outputs.tf: Defines the outputs of the module.

To use a module, you need to call it from your root configuration. This is done using the module block.

Let's assume we have a module that creates an AWS S3 bucket. The module is located in a directory called s3-bucket.

s3-bucket/main.tf

s3-bucket/variables.tf

s3-bucket/outputs.tf

To call this module from your root configuration:

main.tf

Modules can accept input variables, which are defined in the variables.tf file. These variables can be passed when calling the module.

Modules can also produce outputs, which are defined in the outputs.tf file. These outputs can be accessed using the module.<MODULE_NAME>.<OUTPUT_NAME> syntax.

In the example above, the s3-bucket module accepts two input variables: bucket_name and acl. It produces one output: bucket_arn.

When using modules from a remote source, such as the Terraform Registry, it's important to manage versions to ensure stability and predictability.

To use a specific version of a module from the Terraform Registry:

1. Use Descriptive Names: Name your modules and variables descriptively to make your configurations easier to understand.
2. Version Control: Always specify a version when using remote modules to avoid unexpected changes.
3. Documentation: Document your modules, including inputs, outputs, and usage examples.
4. Reusability: Design modules to be reusable across different projects and environments.

1. Create a module that provisions an AWS EC2 instance.
2. The module should accept the following inputs:
   • instance_type: The type of the EC2 instance.
   • ami_id: The ID of the AMI to use.
3. The module should output the instance ID.

ec2-instance/main.tf

ec2-instance/variables.tf

ec2-instance/outputs.tf

main.tf

In this section, we learned how to use modules in Terraform to organize and reuse code. We covered the basics of module structure, how to call a module, manage inputs and outputs, and best practices for using modules effectively. By mastering modules, you can create more modular, maintainable, and scalable Terraform configurations.