In Terraform, a module block is used to incorporate the configuration of one module into another, promoting reusability and organization in your infrastructure as code. The module block supports several parameters, allowing you to customize its behavior and the resources it provisions. Here's a breakdown of the key parameters you can define within a module block:

1. source (Required):

   • Description: Specifies the location of the module's source code.
   • Usage: This can be a local file path, a URL to a version control system (like Git), or a reference to a module in the Terraform Registry.
   • Example:

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

     or

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

2. version (Optional):

   • Description: Specifies the version of the module to use.
   • Usage: Particularly useful when sourcing modules from the Terraform Registry to ensure compatibility and stability.
   • Example:

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

3. Input Variables:

   • Description: These are user-defined parameters that allow customization of the module's behavior.
   • Usage: Each input variable must be defined within the module's variables.tf file. When calling the module, you provide values for these variables.
   • Example:

     module "network" {
       source = "./modules/network"
       cidr   = "10.0.0.0/16"
       region = "us-west-1"
     }

     Here, cidr and region are input variables defined within the network module.

4. providers (Optional):

   • Description: Overrides the default provider configurations for the module.
   • Usage: Useful when you need to specify different provider settings for a particular module.
   • Example:

     provider "aws" {
       region = "us-west-1"
     }
     
     module "network" {
       source    = "./modules/network"
       providers = {
         aws = aws.us_east
       }
     }
     
     provider "aws" {
       alias  = "us_east"
       region = "us-east-1"
     }

5. count (Optional):

   • Description: Creates multiple instances of the module.
   • Usage: Allows you to scale resources by specifying the number of instances.
   • Example:

     module "network" {
       source = "./modules/network"
       count  = 3
     }

     This will instantiate the network module three times.

6. for_each (Optional):

   • Description: Creates multiple instances of the module based on a map or set of strings.
   • Usage: Provides more control compared to count, especially when each instance requires unique configurations.
   • Example:

     module "network" {
       source  = "./modules/network"
       for_each = {
         net1 = "10.0.0.0/16"
         net2 = "10.1.0.0/16"
       }
       cidr = each.value
     }

     This will create two instances of the network module with different CIDR blocks.

7. depends_on (Optional):

   • Description: Specifies dependencies on other resources or modules.
   • Usage: Ensures that the module is provisioned only after certain resources or modules have been created.
   • Example:

     module "network" {
       source     = "./modules/network"
       depends_on = [aws_vpc.main]
     }

     Here, the network module will be created only after the aws_vpc.main resource is provisioned.

By utilizing these parameters, you can effectively manage and customize the behavior of your Terraform modules, leading to more modular and maintainable infrastructure configurations.

In Terraform, the source argument within a module block specifies the location of the module's source code. Terraform supports various methods to define this source, allowing flexibility in module sourcing. Here are the different ways to specify the source parameter, along with examples:

1. Local Paths

You can reference modules stored locally on your filesystem using relative paths.

module "network" {
  source = "./modules/network"
  # Additional module arguments
}

In this example, Terraform will load the module from the modules/network directory relative to your current working directory.

2. Terraform Registry

Modules can be sourced directly from the Terraform Registry, which hosts a vast collection of publicly available modules.

module "consul" {
  source  = "hashicorp/consul/aws"
  version = "0.0.5"
  # Additional module arguments
}

Here, the Consul module for AWS is sourced from the Terraform Registry. Specifying the version ensures that Terraform uses the desired module version. citeturn0search6

3. GitHub

Modules can be sourced from GitHub repositories using the github.com prefix.

module "vpc" {
  source = "github.com/terraform-aws-modules/terraform-aws-vpc"
  # Additional module arguments
}

This example fetches the VPC module from the specified GitHub repository. citeturn0search0

4. Generic Git Repositories

Terraform supports sourcing modules from any Git repository by specifying the repository URL.

module "vpc" {
  source = "git::https://example.com/terraform-modules.git//vpc?ref=tags/v0.1.0"
  # Additional module arguments
}

In this case, Terraform retrieves the vpc module from the specified Git repository at the v0.1.0 tag. citeturn0search0

5. Bitbucket

Modules can also be sourced from Bitbucket repositories.

module "vpc" {
  source = "bitbucket.org/organization/terraform-modules.git//vpc?ref=tags/v0.1.0"
  # Additional module arguments
}

This example fetches the vpc module from a Bitbucket repository at the specified tag. citeturn0search0

6. HTTP URLs

Modules can be downloaded from HTTP URLs pointing to a ZIP archive of the module.

module "network" {
  source = "https://example.com/terraform-modules/network.zip"
  # Additional module arguments
}

Terraform will download and extract the module from the specified URL. citeturn0search0

7. Amazon S3 Buckets

Modules stored in Amazon S3 buckets can be referenced directly.

module "network" {
  source = "s3::https://s3.amazonaws.com/mybucket/terraform-modules/network.zip"
  # Additional module arguments
}

Here, Terraform retrieves the module from the specified S3 bucket. citeturn0search0

8. Google Cloud Storage (GCS) Buckets

Similarly, modules can be sourced from GCS buckets.

module "network" {
  source = "gcs::https://storage.googleapis.com/mybucket/terraform-modules/network.zip"
  # Additional module arguments
}

Terraform will download the module from the specified GCS bucket. citeturn0search0

Note on Parameterizing the source Argument

As of Terraform v0.13, the source argument must be a literal string and cannot directly reference variables or expressions. This design ensures that module sources are known before evaluating the configuration. citeturn0search6

By utilizing these methods, you can flexibly source Terraform modules from various locations, tailoring your infrastructure as code to your project's needs.

In Terraform, you can specify a module's source using various Git options to control which version or part of the repository to use. Here are examples illustrating different scenarios:

1. Default Branch

By default, Terraform fetches the module from the repository's default branch (usually main or master):

module "network" {
  source = "git::https://github.com/username/repository.git"
  # Additional module arguments
}

2. Specific Branch

To use a specific branch, append the ref parameter with the branch name:

module "network" {
  source = "git::https://github.com/username/repository.git?ref=branch-name"
  # Additional module arguments
}

3. Specific Tag

To use a specific tag, set the ref parameter to the tag name:

module "network" {
  source = "git::https://github.com/username/repository.git?ref=v1.0.0"
  # Additional module arguments
}

4. Specific Commit ID

To use a specific commit, set the ref parameter to the commit hash:

module "network" {
  source = "git::https://github.com/username/repository.git?ref=commit-sha"
  # Additional module arguments
}

5. Subdirectory in a Specific Branch

If the module resides in a subdirectory of a specific branch, specify both the branch and the subdirectory:

module "network" {
  source = "git::https://github.com/username/repository.git//subdirectory?ref=branch-name"
  # Additional module arguments
}

6. SSH Protocol

To clone a private repository over SSH, use the SSH URL:

module "network" {
  source = "git::ssh://git@github.com/username/repository.git"
  # Additional module arguments
}

7. GitHub Shortcut

For public GitHub repositories, you can use a shorthand notation:

module "network" {
  source = "github.com/username/repository"
  # Additional module arguments
}

8. Git Over SSH with Subdirectory

To access a module in a subdirectory over SSH:

module "network" {
  source = "git::ssh://git@github.com/username/repository.git//subdirectory"
  # Additional module arguments
}

9. Git Over HTTPS with Authentication

For private repositories over HTTPS, include the username and token:

module "network" {
  source = "git::https://username:token@github.com/username/repository.git"
  # Additional module arguments
}

10. Bitbucket Repository

To source a module from a Bitbucket repository:

module "network" {
  source = "git::https://bitbucket.org/username/repository.git"
  # Additional module arguments
}

11. GitLab Repository

To source a module from a GitLab repository:

module "network" {
  source = "git::https://gitlab.com/username/repository.git"
  # Additional module arguments
}

12. Using a Depth Parameter for Shallow Clone

To perform a shallow clone and limit the history depth:

module "network" {
  source = "git::https://github.com/username/repository.git?ref=branch-name&depth=1"
  # Additional module arguments
}

By utilizing these Git options, you can precisely control which version or part of a repository Terraform uses for your modules.