The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Creating Modules

Next ►
►

In this section, we will delve into the process of creating reusable Terraform modules. Modules are a powerful way to organize and reuse code, making your Terraform configurations more manageable and scalable.

What is a Terraform Module?

A Terraform module is a container for multiple resources that are used together. Modules can be used to create reusable components, which can be shared and utilized across different projects.

Key Concepts:

  • Root Module: The main working directory where Terraform commands are run.
  • Child Module: A module that is called by another module, including the root module.
  • Module Registry: A repository where modules can be published and shared.

Steps to Create a Terraform Module

  1. Define the Module Structure

A typical module structure includes:

  • main.tf: Contains the primary resources.
  • variables.tf: Defines the input variables.
  • outputs.tf: Defines the output values.

Example Structure:

my-module/
  ├── main.tf
  ├── variables.tf
  ├── outputs.tf

  1. Write the Module Code

main.tf

This file contains the resources that the module will manage.

resource "aws_instance" "example" {
  ami           = var.ami_id
  instance_type = var.instance_type

  tags = {
    Name = var.instance_name
  }
}

variables.tf

This file defines the input variables for the module.

variable "ami_id" {
  description = "The AMI ID to use for the instance"
  type        = string
}

variable "instance_type" {
  description = "The type of instance to create"
  type        = string
  default     = "t2.micro"
}

variable "instance_name" {
  description = "The name of the instance"
  type        = string
}

outputs.tf

This file defines the output values that the module will return.

output "instance_id" {
  description = "The ID of the created instance"
  value       = aws_instance.example.id
}

output "public_ip" {
  description = "The public IP of the created instance"
  value       = aws_instance.example.public_ip
}

  1. Use the Module in a Configuration

To use the module, you need to call it from another Terraform configuration.

Example Usage:

module "my_instance" {
  source        = "./my-module"
  ami_id        = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  instance_name = "MyInstance"
}

output "instance_id" {
  value = module.my_instance.instance_id
}

output "public_ip" {
  value = module.my_instance.public_ip
}

  1. Initialize and Apply

Run the following commands to initialize and apply the configuration:

terraform init
terraform apply

Practical Exercise

Task:

Create a module that provisions an S3 bucket with versioning enabled.

Steps:

  1. Create a directory named s3-module.
  2. Inside s3-module, create main.tf, variables.tf, and outputs.tf.
  3. Define the S3 bucket resource in main.tf.
  4. Define input variables for the bucket name and versioning status in variables.tf.
  5. Define output values for the bucket name and ARN in outputs.tf.
  6. Use the module in a root configuration to create an S3 bucket.

Solution:

s3-module/main.tf

resource "aws_s3_bucket" "example" {
  bucket = var.bucket_name

  versioning {
    enabled = var.versioning
  }

  tags = {
    Name = var.bucket_name
  }
}

s3-module/variables.tf

variable "bucket_name" {
  description = "The name of the S3 bucket"
  type        = string
}

variable "versioning" {
  description = "Enable versioning for the S3 bucket"
  type        = bool
  default     = true
}

s3-module/outputs.tf

output "bucket_name" {
  description = "The name of the S3 bucket"
  value       = aws_s3_bucket.example.bucket
}

output "bucket_arn" {
  description = "The ARN of the S3 bucket"
  value       = aws_s3_bucket.example.arn
}

Root Configuration:

module "s3_bucket" {
  source      = "./s3-module"
  bucket_name = "my-unique-bucket-name"
  versioning  = true
}

output "bucket_name" {
  value = module.s3_bucket.bucket_name
}

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

Common Mistakes:

  • Incorrect Variable Types: Ensure the variable types in variables.tf match the expected input.
  • Missing Outputs: Define all necessary outputs in outputs.tf to make the module more useful.
  • Source Path: Ensure the source path in the root configuration correctly points to the module directory.

Conclusion

Creating modules in Terraform allows you to encapsulate and reuse configurations, making your infrastructure code more modular and maintainable. By following the steps outlined in this section, you can create your own modules and use them across different projects, enhancing your Terraform skills and efficiency.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved