Terraform Output as Input: Sharing Data Between Modules

• Introduction
• Step-by-Step Guide
• Code Example
• Additional Notes
• Summary
• Conclusion
• References

In Terraform, modules promote code reusability and organization. Often, you'll need to pass data, such as resource identifiers, between these modules. This guide demonstrates how to use the output of one Terraform module as an input variable in another, enabling seamless data flow and resource dependencies within your infrastructure code.

To use the output of one Terraform module as an input variable in another, you'll leverage Terraform's terraform_remote_state resource.

1. Define Outputs in the Source Module:

In the Terraform module where the resource you want to reference is defined, declare an output variable. This makes the value available to other modules.

output "example_output" {
  value = aws_instance.example.id
}

2. Create a terraform_remote_state Data Source:

In the module where you want to use the output value, define a terraform_remote_state data source. This data source allows you to access the state of another Terraform deployment.

data "terraform_remote_state" "source_module" {
  backend = "local"
  config = {
    path = "../source-module/terraform.tfstate" 
  }
}

• Replace "../source-module/terraform.tfstate" with the relative path to the state file of your source module.

3. Access the Output Value:

You can now access the output value from the source module using the data.terraform_remote_state object.

resource "aws_instance" "example" {
  # ... other configurations ...
  subnet_id = data.terraform_remote_state.source_module.outputs.subnet_id
}

• Replace "source_module" with the name you gave your terraform_remote_state data source.
• Replace "subnet_id" with the name of the output variable you defined in the source module.

Important Considerations:

• State File Location: Ensure the path in the terraform_remote_state configuration correctly points to the source module's state file.
• Dependency: Terraform will automatically manage the dependency between the modules. The module containing the terraform_remote_state data source will always be applied after the source module.
• Remote Backends: If you're using remote backends (like AWS S3, Azure Storage, etc.), adjust the backend and config settings in the terraform_remote_state data source accordingly.

This code demonstrates Terraform module communication. The first module defines network infrastructure (VPC and subnet) and outputs the subnet ID. The second module, responsible for creating an EC2 instance, accesses the first module's state file to retrieve the subnet ID and uses it during instance creation, ensuring the instance is provisioned within the intended subnet. This showcases how modules can interact to build upon each other's resources.

Let's say you have two Terraform modules:

• networking: Defines a VPC and subnets.
• compute: Creates EC2 instances within the VPC.

1. networking/main.tf:

# Defines a VPC
resource "aws_vpc" "example" {
  cidr_block = "10.0.0.0/16"
}

# Defines a subnet
resource "aws_subnet" "example" {
  vpc_id     = aws_vpc.example.id
  cidr_block = "10.0.1.0/24"
}

# Makes the subnet ID available as an output
output "subnet_id" {
  value = aws_subnet.example.id
}

2. compute/main.tf:

# Accesses the state of the networking module
data "terraform_remote_state" "networking" {
  backend = "local"
  config = {
    path = "../networking/terraform.tfstate"
  }
}

# Creates an EC2 instance
resource "aws_instance" "example" {
  ami           = "ami-0c55b159c9e670260" # Replace with your desired AMI
  instance_type = "t2.micro"

  # Uses the subnet ID from the networking module
  subnet_id = data.terraform_remote_state.networking.outputs.subnet_id
}

Explanation:

• The networking module defines a VPC and subnet and outputs the subnet ID.
• The compute module uses a terraform_remote_state data source to access the state file of the networking module.
• The compute module then references the subnet_id output from the networking module when creating the EC2 instance.

This ensures that the EC2 instance is created in the correct subnet defined by the networking module.

Note: This example uses a local backend. For remote backends, you'll need to adjust the backend and config settings in the terraform_remote_state data source accordingly.

• Modularity: Using outputs as inputs between modules is key to writing reusable and maintainable Terraform code. It enforces separation of concerns and allows for independent module development and testing.
• Refactoring: terraform_remote_state is particularly useful when refactoring existing code into modules. You can extract resources into a separate module and use terraform_remote_state to access their outputs without rewriting large portions of your codebase.
• Versioning: Be mindful of potential issues when changing output values in the source module. If the consuming module relies on a specific output format or value type, updates to the source module could lead to breaking changes.
• Alternatives to terraform_remote_state:
  • Terraform Registry Modules: For common infrastructure components, consider using modules from the Terraform Registry. These modules often have well-defined outputs that you can use as inputs in your own code.
  • Data Sources: If the value you need is not an output of another module but can be fetched using a Terraform data source, that's another option to avoid direct state file dependencies.
• Security: Be cautious about storing sensitive information in state files. If your state file is stored remotely, ensure appropriate access controls are in place. Consider using tools like terraform output to retrieve sensitive values directly after deployment rather than storing them in the state.
• Best Practices:
  • Use clear and descriptive names for output variables to improve code readability.
  • Document your module outputs to explain their purpose and expected values.
  • Use a consistent naming convention for terraform_remote_state data sources to easily identify their purpose.

By understanding these concepts and following best practices, you can effectively use Terraform modules to create well-structured, reusable, and maintainable infrastructure code.

This table summarizes how to use outputs from one Terraform module as input variables in another:

Key Points:

• State File Path: Ensure the terraform_remote_state configuration points to the correct state file.
• Automatic Dependency: Terraform manages the dependency between modules, applying the consuming module after the source module.
• Remote Backends: Adjust the backend and config settings for remote state file locations.

By leveraging terraform_remote_state, you can establish connections between your Terraform modules, enabling one module to utilize the outputs of another. This approach enhances code organization, promotes reusability, and ensures a logical flow of information within your infrastructure deployments. Remember to pay close attention to state file locations, especially when working with remote backends, and to follow security best practices when handling sensitive data. By mastering these techniques, you can build robust and maintainable infrastructure as code using Terraform modules.

• Terraform Output Values : Complete Guide & Examples | What are Terraform outputs? See the different options for their configuration and how Terraform handles and exports output values between modules.
• amazon iam - Terraform use output variable as an input in another ... | Nov 16, 2021 ... MalformedPolicyDocument: Resource data.terraform_remote_state.msk_vpc[0].outputs.cluster_arn must be in ARN format or "*". resource " ...
• Using a resource's output as an input value for a provider - possible ... | Posted by u/RepublicNo3042 - 4 votes and 12 comments
• Terraform output variables to be used as input variables - Stack ... | Mar 30, 2020 ... Of course you can. And there is nothing more you need to do. Just do it as usual. Here is an example: main.tf ├── rg │ ├── output.tf ...
• Use output variables inside the module that defines them · Issue ... | Terraform Version Terraform v0.11.2 Terraform Configuration Files variable "security-group-id" { description = "The security group id to which the rules should be added" } output "network-ipv4-cidr...
• Terraform in a cloud agnostic way - Terraform - HashiCorp Discuss | Can someone suggest an approach to write TF code in a cloud agnostic way. For example I want to provision VPC on AWS/GCP/Azure using some factored out Input/ Output variables and common TF code may be a VPC module which I can control to provision on which cloud .
• Cannot pass output string of one module as input list to another ... | Hi, I have two modules: module 1 loadbalancer: ... output "backendAddressPoolId" { value = "${azurerm_lb_backend_address_pool.backendAddressPool.id}" } module 2 virtual machine: ... variable "lbBac...
• Unable to pass a module's output as input to another module ... | Hello everybody, this is my first post in this community and also fairly new to Terrafrom. Please correct or disregard deviation from community guidelines. I currently have a directory structure as below and I am trying to output db_endpoint from cosmosdb module and use it in environments/dev/keyvault.tf to pass it as a secret ├── environments │ └── dev │ ├── cosmosdb.tf │ ├── keyvault.tf │ ├── variables.tf ├── modules │ ├── cosmosdb │ │ ├── main.tf │ │ ├─...
• Terraform Output Command : Examples, Tips and Best Practices ... | A practical in-depth guide on Terraform outputs with detailed examples, advanced use cases, and more.