Demo Using Modules from the Terraform Registry

Welcome — this hands-on guide shows how to consume modules from the Terraform Registry to provision a VPC and a security group, and how to pass outputs from one module into another. No slides — just the minimal files and commands you’ll need. Create these files in an empty directory (open in VS Code or your editor of choice):

main.tf
variables.tf
providers.tf (or include provider config in main.tf)
outputs.tf (create when prompted below)

What you’ll do:

Find and inspect a VPC module on the Registry.
Add variables and call the VPC module.
Initialize, plan, and apply to create the VPC.
Export the VPC ID via an output.
Consume that output in another module (security group).
Export the security group ID.

Browsing modules on the Terraform Registry

Head to the Terraform Registry and search for modules for your provider. Reusing community or vendor modules speeds up provisioning and reduces boilerplate.

A browser screenshot of the Terraform Registry showing a list of modules (e.g., terraform-aws-modules/iam, cloudposse/label, terraform-aws-modules/vpc) with provider filters in a left sidebar. The page has a purple header with search and navigation controls.

Choose the AWS VPC module terraform-aws-modules/vpc/aws. The Registry README includes usage examples; a minimal module block looks like:

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "5.19.0"
}

Read the module README to learn available inputs and outputs. The VPC module exposes many optional inputs (for example cidr and name) and useful outputs like vpc_id.

See the module source code

If you want to inspect implementation details, the Registry usually links to the module’s source repository (commonly GitHub). Look for main.tf, variables.tf, and outputs.tf to understand the variables and outputs the module exposes.

A screenshot of a GitHub repository page for the terraform-aws-modules/terraform-aws-vpc project, showing a file list with variables.tf highlighted. The lower part shows the README header "AWS VPC Terraform module" and some repository metadata on the right.

Define variables and call the VPC module

Create variables.tf to hold configurable values for the VPC name and CIDR. Note the corrected CIDR default below:

variable "cidr_block" {
  type        = string
  description = "The IPv4 CIDR block for the VPC"
  default     = "192.168.0.0/16"
}

variable "vpc_name" {
  type        = string
  description = "The name of our VPC"
  default     = "my-terraform-vpc"
}

Add a provider and module block to main.tf. This example pins the aws provider and passes the variables into the VPC module:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "5.89.0"
    }
  }
}

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

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "5.19.0"

  name = var.vpc_name
  cidr = var.cidr_block
}

Initialize, plan, and apply

Set your AWS credentials via environment variables or your preferred method, then run:

terraform init

Terraform will download the module and providers. Example (abridged):

Initializing modules...
- vpc in .terraform/modules/vpc
Initializing provider plugins...
- Finding hashicorp/aws versions matching ">= 5.79.0, 5.89.0"
- Installing hashicorp/aws v5.89.0...
Terraform has created a lock file .terraform.lock.hcl

Plan and apply:

terraform plan
terraform apply

Confirm the apply by typing yes when prompted. Example outputs:

Plan: 4 to add, 0 to change, 0 to destroy.

Then:

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.

Quick reference — common Terraform commands

Command	Purpose
`terraform init`	Download providers and modules referenced by the configuration.
`terraform plan`	Show proposed changes; good for review before apply.
`terraform apply`	Execute the planned changes (creates/modifies resources).
`terraform state list`	List resources tracked in state.

Verify state and the created VPC

List resources managed by Terraform:

terraform state list

Example output:

module.vpc.aws_default_network_acl.this[0]
module.vpc.aws_default_route_table.default[0]
module.vpc.aws_default_security_group.this[0]
module.vpc.aws_vpc.this[0]

In the AWS console (here us-east-1) you should see the VPC with the CIDR you supplied (192.168.0.0/16).

Add an output to expose the VPC ID

Create or update outputs.tf to export the VPC ID from your root module:

output "vpc_id" {
  value = module.vpc.vpc_id
}

Run terraform apply again — this typically reports no resource changes and adds the output:

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

vpc_id = "vpc-0123456789abcdef0"

Inspect module outputs on the Registry — the VPC module documents outputs like vpc_id that are intended for consumption by other modules or the root module.

Screenshot of a Terraform Registry page listing outputs for the terraform-aws-vpc module, showing output names like vpc_id, vpc_instance_tenancy, vpc_ipv6_cidr_block, vpc_main_route_table_id, and descriptions for each. The vpc_id entry is highlighted on the left.

Consume the VPC output in another module (security group)

Now consume module.vpc.vpc_id as input to a security group module. Add a module block (choose an identifier-safe name like security_group) to main.tf:

module "security_group" {
  source  = "terraform-aws-modules/security-group/aws"
  version = "5.3.0"

  vpc_id = module.vpc.vpc_id
  name   = "my-cool-security-group"
}

Important: when you add or change module sources, re-run terraform init so Terraform can download any new modules.

Any time you add or change module sources, rerun terraform init so Terraform can install the newly referenced modules locally.

If you run terraform plan before terraform init after adding a module, you’ll see:

Error: Module not installed
This module is not yet installed. Run "terraform init" to install all modules required by this configuration.

Run:

terraform init
terraform apply

Expected confirmation:

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

You can now verify in the AWS console that the security group my-cool-security-group exists and is associated with the VPC created earlier.

A screenshot of the AWS VPC Security Groups page showing a list of security groups, with "my-cool-security-group" selected. The lower pane shows details (ID, name, description and VPC association), and browser tabs referencing Terraform modules are visible at the top.

Also confirm your VPC details in the console:

A screenshot of the AWS VPC console showing a VPC named "my-terraform-vpc" (VPC ID vpc-0c11fbe634c8a9edf) in state "Available" with IPv4 CIDR 192.168.0.0/16. The details pane shows DNS resolution enabled, Block Public Access off, and links to the route table and DHCP option set.

Output the security group ID

To expose the security group ID from the root module, add this to outputs.tf:

output "sg_id" {
  value = module.security_group.security_group_id
}

Run terraform apply once more (no infra changes expected) to add the output. Example final outputs:

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

sg_id = "sg-0123456789abcdef0"
vpc_id = "vpc-0123456789abcdef0"

Summary and best practices

The Terraform Registry is a primary source for reusable modules — search by provider and use well-reviewed modules.
Always inspect a module’s README and source to learn variable names, defaults, and available outputs.
Pass values from the root module into child modules with variables; get values back through module outputs.
Re-run terraform init whenever you add or modify module sources so Terraform can download them.
Pin provider and module versions to achieve reproducible configurations.

Links and references

Terraform Registry — https://registry.terraform.io
Terraform Documentation — https://www.terraform.io/docs
terraform-aws-modules/vpc/aws — https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws
terraform-aws-modules/security-group/aws — https://registry.terraform.io/modules/terraform-aws-modules/security-group/aws

Go explore the Registry and compose modules together to accelerate infrastructure provisioning. Let module authors handle resource complexity while you focus on infrastructure design.

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 Using Modules from the Terraform Registry

Browsing modules on the Terraform Registry

See the module source code

Define variables and call the VPC module

Initialize, plan, and apply

Verify state and the created VPC

Add an output to expose the VPC ID

Consume the VPC output in another module (security group)

Output the security group ID

Summary and best practices

Watch Video

Practice Lab

​Browsing modules on the Terraform Registry

​See the module source code

​Define variables and call the VPC module

​Initialize, plan, and apply

​Verify state and the created VPC

​Add an output to expose the VPC ID

​Consume the VPC output in another module (security group)

​Output the security group ID

​Summary and best practices

Watch Video

Practice Lab

Browsing modules on the Terraform Registry

See the module source code

Define variables and call the VPC module

Initialize, plan, and apply

Verify state and the created VPC

Add an output to expose the VPC ID

Consume the VPC output in another module (security group)

Output the security group ID

Summary and best practices