Modules for reusability in GCP - Commands & Configuration

Introduction

When you build cloud infrastructure, you often repeat the same setup steps. Modules let you package these steps once and reuse them easily. This saves time and keeps your setup consistent.

When you need to create multiple similar virtual machines with the same settings.

When you want to deploy the same network setup in different projects or environments.

When you want to share a common storage bucket configuration across several apps.

When you want to organize your infrastructure code into smaller, manageable parts.

When you want to avoid copying and pasting the same code and risk mistakes.

Config File - main.tf

main.tf

terraform {
  required_version = ">= 1.0"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.0"
    }
  }
}

provider "google" {
  project = "example-project"
  region  = "us-central1"
}

module "vm_instance" {
  source       = "./modules/vm"
  instance_name = "my-vm"
  machine_type  = "e2-medium"
  zone          = "us-central1-a"
}

This is the main Terraform file that uses a module called vm_instance.

The terraform block sets the required Terraform and provider versions.

The provider block configures the Google Cloud project and region.

The module block calls the reusable module from the ./modules/vm folder and passes parameters like instance name, machine type, and zone.

Commands

This command initializes Terraform, downloads the Google provider, and prepares the module for use.

Terminal

terraform init

Expected Output

Initializing the backend...



Initializing provider plugins...

- Finding hashicorp/google versions matching ">= 4.0"...

- Installing hashicorp/google v4.0.0...

- Installed hashicorp/google v4.0.0 (signed by HashiCorp)



Terraform has been successfully initialized!



You may now begin working with Terraform. Try running "terraform plan" to see

any changes that are required for your infrastructure. All Terraform commands

should now work.

This command shows what Terraform will create or change based on the module and parameters.

Terminal

terraform plan

Expected Output

Refreshing Terraform state in-memory prior to plan...



An execution plan has been generated and is shown below.

Resource actions are indicated with the following symbols:

  + create



Terraform will perform the following actions:



  # module.vm_instance.google_compute_instance.default will be created

  + resource "google_compute_instance" "default" {

      + name         = "my-vm"

      + machine_type = "e2-medium"

      + zone         = "us-central1-a"

      ...

    }



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

This command applies the plan and creates the resources defined by the module without asking for confirmation.

Terminal

terraform apply -auto-approve

Expected Output

google_compute_instance.default: Creating...

google_compute_instance.default: Still creating... [10s elapsed]

google_compute_instance.default: Creation complete after 15s [id=projects/example-project/zones/us-central1-a/instances/my-vm]



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

→

-auto-approve - Skips manual approval to apply changes immediately

This command removes all resources created by Terraform, cleaning up the environment.

Terminal

terraform destroy -auto-approve

Expected Output

google_compute_instance.default: Destroying... [id=projects/example-project/zones/us-central1-a/instances/my-vm]

google_compute_instance.default: Destruction complete after 10s



Destroy complete! Resources: 1 destroyed.

→

-auto-approve - Skips manual approval to destroy resources immediately

Key Concept

If you remember nothing else from this pattern, remember: modules let you write infrastructure code once and reuse it many times to save effort and avoid mistakes.

Common Mistakes

Copying module code instead of calling it as a module

This causes duplicated code that is hard to maintain and update.

Create a module folder and call it using the module block with parameters.

Not running 'terraform init' after adding a module

Terraform won't download the module or provider plugins, causing errors.

Always run 'terraform init' after adding or changing modules.

Hardcoding values inside the module instead of using variables

This makes the module less reusable and flexible.

Use input variables in the module and pass values from the main configuration.

Summary

Use modules to package reusable infrastructure code for Google Cloud.

Initialize Terraform with 'terraform init' to prepare modules and providers.

Use 'terraform plan' to preview changes and 'terraform apply' to create resources.

Clean up resources with 'terraform destroy' when no longer needed.

Practice

1. What is the main benefit of using modules in GCP infrastructure setup?

easy

A. They let you reuse code to create cloud resources easily.

B. They automatically fix errors in your cloud setup.

C. They increase the cost of cloud resources.

D. They replace the need for any configuration files.

Solution

1. Step 1: Understand what modules do

   Modules are reusable pieces of configuration that help you avoid repeating code.

2. Step 2: Identify the benefit in context

   Using modules makes your cloud setup easier and faster by reusing code.

3. Final Answer:

   They let you reuse code to create cloud resources easily. -> Option A

4. Quick Check:

   Modules = Reuse code [OK]

Hint: Modules help reuse code to save time and effort [OK]

Common Mistakes:

• Thinking modules fix errors automatically
• Believing modules increase costs
• Assuming modules remove all config files

2. Which of the following is the correct way to call a module in a Terraform configuration for GCP?

easy

A. module "storage" { source = "./modules/storage" }

B. call module storage from "./modules/storage"

C. use module storage located at ./modules/storage

D. import module storage from "./modules/storage"

Solution

1. Step 1: Recall Terraform module syntax

   Terraform uses the keyword module followed by a name and a block with source to specify the module path.

2. Step 2: Match the correct syntax

   module "storage" { source = "./modules/storage" } matches the correct syntax: module "name" { source = "path" }.

3. Final Answer:

   module "storage" { source = "./modules/storage" } -> Option A

4. Quick Check:

   Terraform module call = module "name" with source [OK]

Hint: Use 'module "name" { source = "path" }' to call modules [OK]

Common Mistakes:

• Using keywords like call or import which are invalid
• Missing quotes around module name
• Not using a block structure for module

3. Given this Terraform module call:

module "network" {
  source = "./modules/network"
  region = "us-central1"
}

What will happen if the module network does not accept a region variable?

medium

A. Terraform will deploy but with a default region.

B. Terraform will ignore the extra variable and deploy successfully.

C. Terraform will throw an error about an unknown variable.

D. Terraform will deploy but skip the network module.

Solution

1. Step 1: Understand variable passing in modules

   Terraform requires that variables passed to modules must be declared in the module's variables file.

2. Step 2: Identify behavior when unknown variable is passed

   If a variable is passed but not declared, Terraform throws an error about unknown input variable.

3. Final Answer:

   Terraform will throw an error about an unknown variable. -> Option C

4. Quick Check:

   Unknown module variable = error [OK]

Hint: Modules must declare variables before use [OK]

Common Mistakes:

• Assuming Terraform ignores unknown variables
• Thinking Terraform uses defaults without declaration
• Believing module is skipped silently

4. You have a module defined in ./modules/storage but when you run Terraform apply, it fails with:
Error: Module not found
What is the most likely cause?

medium

A. Terraform does not support modules in local folders.

B. The module code has syntax errors inside it.

C. You forgot to initialize the Terraform backend.

D. The source path in the module call is incorrect or misspelled.

Solution

1. Step 1: Understand the error meaning

   The error 'Module not found' means Terraform cannot locate the module source path.

2. Step 2: Check common causes

   The most common cause is a wrong or misspelled source path in the module call.

3. Final Answer:

   The source path in the module call is incorrect or misspelled. -> Option D

4. Quick Check:

   Module not found = wrong source path [OK]

Hint: Check module source path spelling if module not found error [OK]

Common Mistakes:

• Assuming syntax errors cause 'Module not found'
• Thinking Terraform disallows local modules
• Confusing backend init with module loading

5. You want to create multiple GCP VM instances with similar settings using a module. Which approach best uses modules for reusability and scalability?

hard

A. Use a module only once and duplicate its code for other VMs.

B. Create a module for one VM and call it multiple times with different instance names.

C. Create separate modules for each VM with hardcoded settings.

D. Write all VM configurations directly in the main file without modules.

Solution

1. Step 1: Understand module reusability

   Modules let you reuse the same configuration by calling them multiple times with different inputs.

2. Step 2: Identify scalable approach

   Calling one VM module multiple times with different names is scalable and clean.

3. Final Answer:

   Create a module for one VM and call it multiple times with different instance names. -> Option B

4. Quick Check:

   Reuse module calls for multiple resources [OK]

Hint: Call one module multiple times with different inputs [OK]

Common Mistakes:

• Duplicating module code instead of reusing
• Hardcoding settings in separate modules
• Avoiding modules and repeating code