Why modules enable reusability in Terraform - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How do Terraform modules improve code reusability?

Which statement best explains why Terraform modules enable reusability?

A Modules automatically update cloud resources without any input changes.

B Modules are only used for storing variables and do not affect resource creation.

C Modules package configuration into reusable units that can be called multiple times with different inputs.

D Modules prevent any changes to infrastructure once deployed.

💡 Hint

Think about how grouping code helps avoid repeating the same instructions.

Terraform modules group related configuration so you can reuse the same setup multiple times by changing inputs, avoiding duplication.

❓ Architecture

intermediate

Using modules to deploy multiple similar resources

You want to deploy three virtual machines with similar settings but different names and IPs. How can Terraform modules help?

A Modules cannot be used for multiple similar resources; use loops instead.

B Write three separate resource blocks without modules to keep it simple.

C Use a module only once and manually copy its output to create other VMs.

D Create one module defining a VM and call it three times with different input variables for name and IP.

💡 Hint

Think about how calling the same code with different inputs saves effort.

Modules let you define a VM once and reuse it multiple times by passing different variables, making your code cleaner and easier to maintain.

❓ Configuration

advanced

What output does this Terraform module call produce?

Given the module call below, what is the value of module.webserver.instance_count after applying?

Terraform

module "webserver" {
  source = "./modules/server"
  instance_count = 3
  server_name = "web-prod"
}

output "instance_count" {
  value = module.webserver.instance_count
}

A 0

B 3

C null

D Error: output not found

💡 Hint

Check how the input variable instance_count is passed and output is defined.

The module receives instance_count=3 and outputs it, so the value is 3.

❓ security

advanced

How do modules help improve security in Terraform projects?

Which option best describes how using modules can enhance security in Terraform infrastructure code?

A Modules allow centralizing sensitive configurations, reducing exposure and mistakes across multiple resources.

B Modules automatically encrypt all variables and outputs without extra configuration.

C Modules prevent unauthorized users from running Terraform commands.

D Modules disable logging to avoid exposing sensitive data.

💡 Hint

Think about how reusing code can reduce errors and improve control.

By centralizing sensitive settings in modules, you reduce duplication and risk of exposing secrets or misconfigurations.

❓ service_behavior

expert

What happens when a module is updated and re-applied?

You have a Terraform module used in multiple places. You update the module code to change a resource property. What is the expected behavior when you run terraform apply in a project using this module?

A Terraform detects the change and updates the affected resources accordingly during apply.

B Terraform ignores module changes unless you delete and re-add the module block.

C Terraform throws an error and refuses to apply changes from updated modules.

D Terraform automatically creates new resources but does not modify existing ones.

💡 Hint

Consider how Terraform tracks resource state and module code.

Terraform compares the current state with the updated module code and applies necessary changes to keep infrastructure in sync.

Practice

1. What is the main benefit of using modules in Terraform?

easy

A. They let you reuse code to save time and reduce errors

B. They increase the cost of cloud resources

C. They make Terraform run slower

D. They prevent you from customizing infrastructure

Solution

1. Step 1: Understand what modules do

   Modules are reusable pieces of Terraform code that you can use multiple times.

2. Step 2: Identify the main benefit

   Using modules saves time and reduces errors by avoiding repeated code.

3. Final Answer:

   They let you reuse code to save time and reduce errors -> Option A

4. Quick Check:

   Modules = Reusability and error reduction [OK]

Hint: Modules = reusable code blocks to save time [OK]

Common Mistakes:

• Thinking modules increase costs
• Believing modules slow down Terraform
• Assuming modules prevent customization

2. Which syntax correctly calls a module named network in Terraform?

easy

A. resource "module" "network" { source = "./network" }

B. module "network" { source = "./network" }

C. module network { source = ./network }

D. resource "network" { source = "./network" }

Solution

1. Step 1: Recall module block syntax

   Modules are called using the module "name" { ... } block syntax.

2. Step 2: Check the correct usage

   module "network" { source = "./network" } uses the correct syntax with quotes around the module name and source path.

3. Final Answer:

   module "network" { source = "./network" } -> Option B

4. Quick Check:

   Module call syntax = module "name" [OK]

Hint: Module calls use module "name" { source = ... } [OK]

Common Mistakes:

• Using resource instead of module
• Omitting quotes around source path
• Mixing resource and module keywords

3. Given this module call:

module "web" {
  source = "./webserver"
  instance_count = 3
}

What happens when you change instance_count in the module input?

medium

A. Terraform deletes the module entirely

B. Terraform ignores the change and keeps the old count

C. Terraform creates or destroys instances to match the new count

D. Terraform throws a syntax error

Solution

1. Step 1: Understand module inputs

   Module inputs customize resources inside the module, like instance count.

2. Step 2: Effect of changing input

   Changing instance_count causes Terraform to update resources to match the new number.

3. Final Answer:

   Terraform creates or destroys instances to match the new count -> Option C

4. Quick Check:

   Module inputs control resource changes [OK]

Hint: Changing inputs updates resources accordingly [OK]

Common Mistakes:

• Thinking Terraform ignores input changes
• Assuming module is deleted on input change
• Expecting syntax errors from input changes

4. You wrote this module call:

module "db" {
  source = "./database"
  size = 10
  size = 20
}

What error will Terraform show?

medium

A. Duplicate argument 'size' declared

B. Missing required argument 'size'

C. Invalid source path error

D. No error, uses last 'size' value

Solution

1. Step 1: Check for duplicate arguments

   The module call has two size arguments, which is not allowed.

2. Step 2: Terraform error on duplicates

   Terraform throws an error about duplicate argument names in the same block.

3. Final Answer:

   Duplicate argument 'size' declared -> Option A

4. Quick Check:

   Duplicate args cause errors [OK]

Hint: No duplicate keys allowed in module blocks [OK]

Common Mistakes:

• Assuming last value overrides silently
• Ignoring duplicate argument errors
• Confusing missing argument with duplicates

5. You want to reuse a module for different environments (dev, prod) with different settings. What is the best way to achieve this?

hard

A. Copy the module code into separate folders for each environment

B. Create a new Terraform project for each environment without modules

C. Use one module call and manually edit the code each time

D. Call the module multiple times with different input variables for each environment

Solution

1. Step 1: Understand module reusability

   Modules are designed to be called multiple times with different inputs to customize behavior.

2. Step 2: Best practice for environments

   Calling the same module with different variables for dev and prod avoids code duplication and errors.

3. Final Answer:

   Call the module multiple times with different input variables for each environment -> Option D

4. Quick Check:

   Reuse modules with inputs for different environments [OK]

Hint: Use inputs to customize module calls per environment [OK]

Common Mistakes:

• Copying module code instead of reusing
• Editing module code manually each time
• Avoiding modules for environment separation