Demo Writing and Using Your Own Modules

In this lesson you’ll create local Terraform modules and consume them from a parent configuration to provision AWS resources. This demonstrates how to:

Organize local modules on disk
Pass inputs and outputs between modules
Call the same module multiple times from the parent
Keep modules small, focused, and reusable

While the examples use AWS resources (VPC, subnet, EC2), the patterns shown are provider-agnostic and apply to any Terraform-supported provider.

Design modules to be small, focused, and configurable. Expose required values via input variables and useful computed values via outputs so parent modules (or other teams) can compose them easily.

Project layout

Create a repository root (for example, terraform/) and a modules/ directory. For this lesson we build three local modules:

modules/vpc — creates a VPC
modules/subnet — creates a subnet and its public networking (IGW, route table, association)
modules/ec2 — creates a security group and an EC2 instance

Top-level files in the repo will call these modules from the parent configuration. Example directory structure:

terraform/
├── main.tf          # parent module — calls child modules
├── providers.tf
└── modules/
    ├── vpc/
    │   ├── main.tf
    │   ├── variables.tf
    │   └── outputs.tf
    ├── subnet/
    │   ├── main.tf
    │   ├── variables.tf
    │   └── outputs.tf
    └── ec2/
        ├── main.tf
        ├── variables.tf
        └── outputs.tf

Summary of modules and responsibilities:

Module	Purpose	Key outputs
`modules/vpc`	Create a VPC with configurable CIDR and name	`vpc_id`
`modules/subnet`	Create a subnet and basic public networking (IGW, route table)	`subnet_id`
`modules/ec2`	Create a security group and EC2 instance in the subnet	`instance_id`, `public_ip`

Below are suggested file contents for each module and the parent configuration. Adjust names, regions, and AMIs for your environment.

Module: vpc

This module creates a VPC and exports its ID. It demonstrates a common module file arrangement: main.tf, variables.tf, and outputs.tf. modules/vpc/main.tf

resource "aws_vpc" "vpc" {
  cidr_block = var.vpc_cidr

  tags = {
    Name = var.vpc_name
  }
}

modules/vpc/variables.tf

variable "vpc_name" {
  description = "Name of the VPC"
  type        = string
  default     = "my-cool-vpc-for-modules"
}

variable "vpc_cidr" {
  description = "CIDR block for the VPC"
  type        = string
  default     = "10.0.0.0/16"
}

modules/vpc/outputs.tf

output "vpc_id" {
  description = "The ID of the VPC"
  value       = aws_vpc.vpc.id
}

Module: subnet

The subnet module creates a subnet and a simple public network path by provisioning an Internet Gateway, a route table, and a route table association. modules/subnet/main.tf

resource "aws_subnet" "subnet" {
  vpc_id            = var.vpc_id
  cidr_block        = var.subnet_cidr
  availability_zone = var.availability_zone

  tags = {
    Name = var.subnet_name
  }
}

resource "aws_internet_gateway" "igw" {
  vpc_id = var.vpc_id

  tags = {
    Name = "${var.subnet_name}-igw"
  }
}

resource "aws_route_table" "rt" {
  vpc_id = var.vpc_id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.igw.id
  }

  tags = {
    Name = "${var.subnet_name}-rt"
  }
}

resource "aws_route_table_association" "rta" {
  subnet_id      = aws_subnet.subnet.id
  route_table_id = aws_route_table.rt.id
}

modules/subnet/variables.tf

variable "vpc_id" {
  description = "The VPC ID where the subnet will be created"
  type        = string
}

variable "subnet_cidr" {
  description = "CIDR block for the subnet"
  type        = string
  default     = "10.0.1.0/24"
}

variable "subnet_name" {
  description = "Name of the subnet"
  type        = string
  default     = "my-subnet"
}

variable "availability_zone" {
  description = "Availability zone for the subnet"
  type        = string
  default     = "us-east-1a"
}

modules/subnet/outputs.tf

output "subnet_id" {
  description = "The ID of the subnet"
  value       = aws_subnet.subnet.id
}

This module is an example of grouping related resources inside a module rather than limiting a module to a single resource.

This subnet module creates an Internet Gateway (IGW) and attaches it to the VPC. Because a VPC can have only one IGW, avoid calling this subnet module multiple times for the same VPC unless you protect or extract the IGW/route-table resources. For multi-subnet designs, consider creating the IGW and shared public route table in the VPC module or in a dedicated networking module.

Module: ec2

A concise EC2 module that creates a security group and an EC2 instance. The security group is kept inside the module for simplicity; for larger deployments you may choose to externalize security groups. modules/ec2/main.tf

resource "aws_security_group" "sg" {
  name        = "allow-ssh"
  description = "Allow SSH inbound traffic"
  vpc_id      = var.vpc_id

  ingress {
    description = "SSH from anywhere"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "allow-ssh"
  }
}

resource "aws_instance" "instance" {
  ami                         = var.ami_id
  instance_type               = var.instance_type
  subnet_id                   = var.subnet_id
  vpc_security_group_ids      = [aws_security_group.sg.id]
  associate_public_ip_address = true

  tags = {
    Name = var.instance_name
  }
}

modules/ec2/variables.tf

variable "vpc_id" {
  description = "VPC ID where instance will be launched"
  type        = string
}

variable "subnet_id" {
  description = "Subnet ID where the instance will be placed"
  type        = string
}

variable "ami_id" {
  description = "The AMI ID to use for the instance"
  type        = string
  default     = "ami-0c55b159cbfafe1f0" # Example: Amazon Linux 2 AMI in us-east-1 (update as needed)
}

variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t2.micro"
}

variable "instance_name" {
  description = "Name of the EC2 instance"
  type        = string
  default     = "my-instance"
}

modules/ec2/outputs.tf

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

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

Parent module (calls the local modules)

At the repository root create providers.tf and main.tf (or similar) to call the child modules. providers.tf

provider "aws" {
  region = "us-east-1"
}

main.tf (parent module — calling the local modules)

module "vpc" {
  source   = "./modules/vpc"
  vpc_cidr = "10.0.0.0/16"
  vpc_name = "demo-vpc"
}

module "subnet_module" {
  source            = "./modules/subnet"
  vpc_id            = module.vpc.vpc_id
  subnet_cidr       = "10.0.1.0/24"
  subnet_name       = "demo-subnet"
  availability_zone = "us-east-1a"
}

module "prod_workload" {
  source        = "./modules/ec2"
  vpc_id        = module.vpc.vpc_id
  subnet_id     = module.subnet_module.subnet_id
  ami_id        = "ami-0c55b159cbfafe1f0" # replace with a region-appropriate AMI
  instance_type = "t2.micro"
  instance_name = "bryans-web-server"
}

Notes:

module.vpc.vpc_id references the vpc_id output declared by the VPC module.
module.subnet_module.subnet_id references the subnet_id output declared by the Subnet module.
The same module can be invoked multiple times with different inputs (e.g., to create multiple subnets or instance flavors). Be mindful of any resources inside a module that must be unique per VPC (IGW, for example).

Initialize and run

From the parent module directory (where providers.tf and main.tf live) run:

terraform init

Example output header (your output may vary):

Terraform has been successfully initialized!

Then plan and apply:

terraform plan
terraform apply
# Confirm with "yes" when prompted (or use -auto-approve)

Terraform creates resources in dependency order because inputs/outputs express the graph (for example, the VPC is created before the subnet that needs its ID).

Reuse and iteration

Call the same module multiple times by adding more module blocks, or use for_each/count on a module block for dynamic creation.
Keep modules parameterized and export only the inputs/outputs needed by callers to reduce coupling.
Use sensible defaults in variables.tf and clear descriptions in both variables.tf and outputs.tf to make modules easier to reuse.

Include helpful description fields for variables and outputs. Consumers of your modules will thank you — clear descriptions and small well-documented modules reduce surprises and improve reusability across teams.

Links and references

Terraform documentation: https://www.terraform.io/docs
AWS provider for Terraform: https://registry.terraform.io/providers/hashicorp/aws
AWS VPC concepts: https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html

That covers a simple example of local modules (VPC, subnet, EC2) and composing them from a parent configuration. Use these patterns to encapsulate repeated infrastructure patterns, keep configurations DRY, and make your infra easier to maintain and share.

Course Introduction

Preparing Your Environment

Terraform Foundations

The Core Terraform Workflow

Terraform CLI

Terraform File Structure and Organization

Terraform Configuration - Fundamentals

Understading and Managing Terraform State

Marking Code Reusable

Refactoring Terraform State

Terraform Modules

Managing Resource Behavior and Dependencies

Securing Terraform Configurations

Terraform Troubleshooting

HCP Terraform

Demo Writing and Using Your Own Modules

Project layout

Module: vpc

Module: subnet

Module: ec2

Parent module (calls the local modules)

Initialize and run

Reuse and iteration

Links and references

Watch Video

Practice Lab

​Project layout

​Module: vpc

​Module: subnet

​Module: ec2

​Parent module (calls the local modules)

​Initialize and run

​Reuse and iteration

​Links and references

Watch Video

Practice Lab

Project layout

Module: vpc

Module: subnet

Module: ec2

Parent module (calls the local modules)

Initialize and run

Reuse and iteration

Links and references