Module structure and conventions in Terraform - Step-by-Step Execution

Process Flow - Module structure and conventions

Create module folder

↓

Add main.tf, variables.tf, outputs.tf

↓

Define resources in main.tf

↓

Declare input variables in variables.tf

↓

Declare outputs in outputs.tf

↓

Use module block in root configuration

↓

Pass variables to module

↓

Run terraform init and apply

This flow shows how to organize a Terraform module with standard files, define inputs and outputs, and use the module in a root configuration.

Execution Sample

Terraform

module "example" {
  source = "./modules/example"
  instance_count = 2
}

output "instance_ids" {
  value = module.example.instance_ids
}

This code uses a module named 'example' from a local folder, passing an input variable and exposing an output.

Process Table

Step	Action	File Affected	Details	Result
1	Create module folder	modules/example/	New folder created for module	Folder ready for module files
2	Add main.tf	modules/example/main.tf	Define resources like aws_instance	Resources defined
3	Add variables.tf	modules/example/variables.tf	Declare input variables like instance_count	Inputs declared
4	Add outputs.tf	modules/example/outputs.tf	Declare outputs like instance_ids	Outputs declared
5	Use module block	root configuration	Reference module with source and inputs	Module block ready
6	Run terraform init	root folder	Initialize modules and providers	Modules downloaded and initialized
7	Run terraform apply	root folder	Apply configuration and create resources	Resources created, outputs available
8	Access output	root folder	Use output value from module	Output instance_ids available
9	Exit	-	All steps completed successfully	Infrastructure deployed

💡 All module structure steps completed and infrastructure deployed successfully

Status Tracker

Variable	Start	After Step 5	After Step 7	Final
instance_count	undefined	2 (passed to module)	2 (used to create resources)	2
instance_ids	undefined	undefined	list of created instance IDs	list of created instance IDs

Key Moments - 3 Insights

Why do we separate variables.tf, main.tf, and outputs.tf in a module?

Separating these files helps organize inputs, resource definitions, and outputs clearly, as shown in steps 2-4 of the execution_table.

How does the root configuration pass values to the module?

The root configuration uses a module block with input variables assigned, like instance_count=2 in step 5, which the module uses to create resources.

How do outputs from the module become accessible in the root?

Outputs declared in outputs.tf (step 4) are exposed via module.<name>.<output> syntax in the root, as seen in step 8.

Visual Quiz - 3 Questions

Look at the execution_table, at which step are input variables declared inside the module?

A Step 3

B Step 2

C Step 5

D Step 7

💡 Hint

Check the 'File Affected' column for variables.tf in the execution_table.

According to variable_tracker, what is the value of instance_count after step 7?

A list of instance IDs

B 2

C undefined

D 0

💡 Hint

Look at the 'After Step 7' column for instance_count in variable_tracker.

If you forget to declare outputs in outputs.tf, what happens when you try to access module outputs in the root?

A Outputs are accessible but empty

B Terraform creates outputs automatically

C Terraform shows an error that output does not exist

D Terraform ignores the module

💡 Hint

Refer to key_moments about how outputs declared in outputs.tf become accessible.

Concept Snapshot

Terraform modules are organized in folders with main.tf for resources,
variables.tf for inputs, and outputs.tf for outputs.
Root configurations use module blocks to call modules,
passing variables and accessing outputs.
This structure keeps code clean and reusable.

Full Transcript

This visual execution shows how to structure a Terraform module with separate files for resources, inputs, and outputs. First, create a module folder and add main.tf, variables.tf, and outputs.tf files. Define resources in main.tf, declare input variables in variables.tf, and outputs in outputs.tf. Then, in the root configuration, use a module block to reference the module folder and pass input variables. Running terraform init downloads and initializes the module. Terraform apply creates the resources using the inputs. Outputs declared in the module become accessible in the root via module.<name>.<output>. Variables like instance_count start undefined, get assigned when passed to the module, and are used to create resources. Outputs like instance_ids become available after apply. This modular approach organizes code and enables reuse.