TerraWeek Day -5 : Modules in Terraform

Task -1 What are the modules in Terraform and its Benefit.

In Terraform, Modules are fundamental concepts that allow you to organize and reuse your infrastructure code. Modules help you to encapsulate and package sets of Terraform resources and configurations into reusable and shareable components.

Here are the key benefits of Terraform modules:

Modularity: Terraform modules allow you to break down your infrastructure configuration into smaller, self-contained components. This modularity makes it easier to manage and reason about your infrastructure because each module handles a specific piece of functionality, such as an EC2 instance, a database, or a network configuration.
Reusability: With modules, you can create reusable templates for common infrastructure components. Instead of rewriting similar configurations for multiple projects, you can reuse modules across different Terraform projects. This reduces duplication and promotes consistency in your infrastructure.
Simplified Collaboration: Modules make it easier for teams to collaborate on infrastructure projects. Different team members can work on separate modules independently, and then these modules can be combined to build complex infrastructure deployments. This division of labor can streamline development and reduce conflicts in the codebase.
Versioning and Maintenance: Modules can have their own versioning, making it easier to manage updates and changes. When you update a module, you can increment its version, and other projects using that module can choose when to adopt the new version, helping to prevent unexpected changes in existing deployments.
Abstraction: Modules can abstract away the complexity of underlying resources. For example, an EC2 instance module can hide the details of security groups, subnets, and other configurations, allowing users to focus on high-level parameters like instance type and image ID.
Testing and Validation: Modules can be individually tested and validated, ensuring that they work correctly before being used in multiple projects. This reduces the risk of errors propagating across your infrastructure.
Documentation: Modules promote self-documentation. When you define variables, outputs, and resource dependencies within a module, it becomes clear how the module should be used, making it easier for others (or your future self) to understand and work with.
Scalability: As your infrastructure grows, modules provide a scalable approach to managing complexity. You can continue to create new modules for different components of your architecture, maintaining a clean and organized codebase.
Security and Compliance: Modules can encapsulate security and compliance best practices. For instance, you can create a module for launching EC2 instances with predefined security groups, IAM roles, and other security-related configurations, ensuring consistency and compliance across your deployments.

Task- 2 Create/Define a module in Terraform to encapsulate reusable infrastructure configuration in a modular and scalable manner.

In root main.tf we will be adding our module according to the requirement you can modify the values like instance_type and ami_id or other things. Our provider will be AWS, so add the following main.tf, outputs.tf, variables.tf to other folder like in my case modules/ec2-instance. In variables.tf we have declared variables and got them from root main.tf file.

Root main.tf file:

In modules/ec2-instance following fles are stored : main.tf, outputs.tf, variables.t

After setting up all the files you can run the following commands.
Run the terraform init command to initialize Terraform.

Then Run terraform validate command to ensure there are no syntax errors.

Then Run terraform plan command to see what resources will be created. Here

Then Run the terraform apply command to apply the Terraform configuration and create the EC2 instance.
Now the instance is running and you can see the public ip of EC2 instance:
Now Run the terraform destroy command to destroy the Terraform configuration and delete the EC2 instance.
Task -3 Dig into modular composition and module versioning.

Modular Composition:
Modular composition in terraform means you can combine smaller and reusable modules together to create more complex infrastructure setups. This nesting capability allows you to build sophisticated deployments by integrating different modules. It promotes the reuse of code, enhances modularity, and makes your infrastructure configurations easier to manage and maintain.

To better understand modular composition, let's take a look at an example.
```
  Explain# main.tf

  provider "aws" {
    region = "ap-south-1"
  }

  module "vpc" {
    source     = "./vpc"
    vpc_cidr   = "10.0.0.0/16"
    subnet_cidr = "10.0.1.0/24"
  }

  module "ec2" {
    source        = "./ec2_instance"
    ami_id        = "ami-abcd1234"
    instance_type = "t2.micro"
    subnet_id     = module.vpc.example_subnet_id
  }

  output "instance_ip" {
    description = "Public IP address of the EC2 instance"
    value       = module.ec2.instance_ip
  }
```
In this example, we are using subnet_id in the ec2 module.
Module versioning:

Module versioning in Terraform allows you to control and manage the specific versions of modules used in your infrastructure code. It ensures that the same module version is consistently used across different deployments and team collaboration, promoting stability and predictability.

Terraform module versions can be specified using version constraints or exact versions. It helps ensure that changes to modules don't introduce unexpected issues in your infrastructure and allows you to control when and how you adopt new features or bug fixes from modules.

To better understand modular composition, let's take a look at an example.

  Explain# main.tf

  provider "aws" {
    region = "ap-south-1"
  }
  module "example" {
    source  = "./example_module"
    version = "1.2.0"

    ami_id        = "ami-abcd1234"
    instance_type = "t2.micro"
  }

  output "instance_ip" {
    description = "Public IP address of the EC2 instance"
    value       = module.example.instance_ip
  }

In this example, we specify the module "example" with a specific version 1.2.0. We also provide values for the required input variables ami_id and instance_type within the module block.

Task-4 What are the ways to lock Terraform module versions? Explain with code snippets.

Locking Terraform module versions is important to ensure that your infrastructure code remains stable and doesn't break unexpectedly due to changes in external modules.

There are multiple ways to lock Terraform module versions. Let's explore two common approaches:

Using a Version Constraint in the Module Block: You can specify a version constraint directly in the module block of your Terraform configuration. This approach allows you to define the allowed range of versions for the module.
```
 Explain module "example" {
    source  = "example/infrastructure/aws"
    version = "~> 1.0"  # Specifies a version constraint of 1.0 or higher, but below 2.0
  }
```
In this code snippet, the module block references the module "example" and sets a version constraint of "~> 1.0". This constraint ensures that any version of the module equal to or higher than 1.0 but below 2.0 can be used.
Using a Terraform Lock File: Terraform can generate a lock file, typically named terraform.lock.hcl, which records the exact versions of modules used in your configuration. The lock file can be manually created or automatically generated using the terraform init command.
```
 Explain terraform {
    required_version = ">= 1.0.0"

    required_providers {
      aws = {
        source  = "hashicorp/aws"
        version = "3.57.0"
      }
    }

    modules {
      example = {
        source  = "example/infrastructure/aws"
        version = "1.2.0"
      }
    }
  }
```
The lock file specifies the exact version of the module "example" and its source. The lock file ensures that Terraform always uses the recorded version, regardless of any changes in the module's source or configuration.

Remember to commit the lock file to version control to maintain consistent module versions across deployments and team collaboration.

TerraWeek Day -5 : Modules in Terraform

Table of contents

Task -1 What are the modules in Terraform and its Benefit.

Task- 2 Create/Define a module in Terraform to encapsulate reusable infrastructure configuration in a modular and scalable manner.

Task -3 Dig into modular composition and module versioning.

Task-4 What are the ways to lock Terraform module versions? Explain with code snippets.

Thank You.