Terraform depends_on: Modules & Best Practices

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

In Terraform, managing dependencies between resources is crucial for building reliable infrastructure. While Terraform automatically infers most dependencies, there are situations where you need to explicitly define them using the depends_on meta-argument. This guide will explore the use of depends_on, its implications for module dependencies, and alternative approaches to managing dependencies between modules.

Terraform typically manages dependencies between resources automatically. However, there are cases where you need to explicitly define dependencies that Terraform can't infer. This is where the depends_on meta-argument comes in.

Let's say you have a resource, Resource A, that needs to be created only after another resource, Resource B, is fully created. You would use depends_on within the configuration of Resource A, listing Resource B as a dependency.

It's important to note that depends_on should be used sparingly. Overusing it can make your Terraform code harder to understand and maintain. It's best to let Terraform handle dependencies implicitly whenever possible.

Now, when it comes to modules, things get a bit trickier. You cannot directly make one module depend on another using depends_on. This is because Terraform treats each module as a self-contained unit.

If you find yourself needing to enforce dependencies between modules, it often signals a design issue. Ideally, modules should be designed to be as independent as possible.

However, if you absolutely must create a dependency between modules, there are a couple of workarounds:

1. Output and Input Variables: One approach is to use output variables from one module as input variables for another. This creates an implicit dependency, as the second module relies on values provided by the first.

2. Null Resources: Another option is to use a null_resource within one module and make other resources depend on it. This resource doesn't actually do anything, but it acts as a synchronization point.

Remember, these workarounds should be used cautiously. Overusing them can lead to complex and fragile infrastructure code. Strive for modularity and clear separation of concerns in your Terraform projects.

The code demonstrates how to manage resource dependencies in Terraform using the depends_on meta-argument. It shows a basic example of making one resource creation dependent on another. Additionally, it provides workarounds for module dependencies, which are generally discouraged, using output/input variables and null resources. The description emphasizes that while these techniques exist, they should be used judiciously, prioritizing modular design and minimizing unnecessary dependencies for cleaner and more maintainable Terraform code.

1. Basic Resource Dependency:

# Resource B - This resource will be created first
resource "google_compute_network" "main" {
  name = "main-network"
}

# Resource A - This resource depends on Resource B
resource "google_compute_subnetwork" "subnet" {
  name          = "main-subnet"
  ip_cidr_range = "10.0.0.0/24"
  network       = google_compute_network.main.id

  # Explicitly define dependency on Resource B
  depends_on = [google_compute_network.main]
}

2. Module Dependency Workarounds:

a) Output and Input Variables:

# module "network" - Defines the network
resource "google_compute_network" "main" {
  name = "main-network"
}

output "network_id" {
  value = google_compute_network.main.id
}

# module "subnet" - Depends on the network module
resource "google_compute_subnetwork" "subnet" {
  name          = "main-subnet"
  ip_cidr_range = "10.0.0.0/24"
  network       = module.network.network_id # Using output from network module
}

b) Null Resources:

# module "network" - Defines the network and a null resource
resource "google_compute_network" "main" {
  name = "main-network"
}

resource "null_resource" "network_ready" {
  # This resource does nothing but acts as a dependency point
}

# module "subnet" - Depends on the null resource in the network module
resource "google_compute_subnetwork" "subnet" {
  name          = "main-subnet"
  ip_cidr_range = "10.0.0.0/24"
  network       = google_compute_network.main.id

  depends_on = [module.network.null_resource.network_ready]
}

Important Notes:

• These examples use Google Cloud resources, but the concepts apply to any provider.
• The depends_on meta-argument should be used sparingly.
• Module dependencies often indicate design issues and should be avoided if possible.
• Workarounds like output/input variables and null resources should be used cautiously.
• Always strive for modularity and clear separation of concerns in your Terraform code.

• Use Cases for depends_on: While implicit dependencies should be the default, depends_on is valuable when:
  • Resource relationships are not captured in attributes: For example, a script within a resource provisioner might require another resource to be fully ready.
  • External dependencies exist: You might need a resource to be created only after an external process completes.
• Drawbacks of Overusing depends_on:
  • Reduced Parallelism: Terraform's ability to create resources in parallel is hindered, potentially slowing down deployments.
  • Hidden Dependencies: Overuse can obscure the true relationships between resources, making the code harder to debug.
• Alternatives to Module Dependencies:
  • Refactoring Modules: Often, the need for module dependencies suggests the modules can be restructured into smaller, more focused units.
  • Shared Modules: If common functionality is needed across modules, consider creating a shared module that both modules can utilize.
• Terraform Best Practices:
  • Documentation: Clearly document any use of depends_on to explain the reasoning behind the explicit dependency.
  • Testing: Thoroughly test your Terraform code, especially when using depends_on or workarounds for module dependencies, to ensure the desired behavior.
• Terraform Version Considerations: Always refer to the documentation for the specific Terraform version you are using, as behavior and best practices can evolve.
• Community Resources: The Terraform community is active and helpful. Online forums and discussion boards can provide valuable insights and solutions for managing dependencies effectively.

Key Takeaway: Prioritize modularity and clear separation of concerns in your Terraform projects. Minimize the use of explicit dependencies and workarounds to maintain code clarity and maintainability.

In conclusion, effectively managing dependencies in Terraform is key to predictable and reliable infrastructure deployments. While Terraform excels at automatically inferring relationships, the depends_on meta-argument provides a powerful tool for explicitly defining dependencies when necessary. However, it should be used judiciously, as overuse can hinder parallelism and obfuscate the codebase. When it comes to modules, strive for independence. While workarounds like output/input variables and null resources exist for inter-module dependencies, they often signal design issues and should be used cautiously. Prioritizing modularity, clear separation of concerns, and adhering to best practices will result in cleaner, more maintainable, and robust Terraform code.

• The depends_on Meta-Argument | Terraform | Use the depends_on meta-argument to handle hidden resource or module dependencies that Terraform cannot automatically infer. You only need to explicitly ...
• Module depends_on modifies the called module - Terraform ... | Hi All been working on terraform for only a short time, but something seemingly straightforward has be most confused in behavior. Could be something simple that I misunderstand, but hoping for some assistance. I have a couple of projects (both happen to be vsphere ones). I have stripped out provider references which seems self defeating in the re-usable code aspect as it makes them now either a module or a standalone project but I digress. So both work fine. One creates a win DC and one cr...
• Is it best practice to never use data resources within modules or use ... | Posted by u/mccarthycodes - 5 votes and 5 comments
• TIPS: Howto implement Module depends_on emulation - Terraform ... | Good morning. I tought I would share a workaround I put together to implement a missing “depends_on” support for modules. It is fairly simple and will be easy to swap out once Terraform implement built-in depends_on support. 1st, create a file called something like modult_depends_on.tf and throw the following into it: /* Add the following line to the resource in this module that depends on the completion of external module components: depends_on = ["null_resource.module_depends_on"] ...
• Beware of depends_on for Terraform modules. It might bite you! | by ... | When defining dependencies between Terraform modules, using depends_on can cause unwanted surprises. Find out why and how to…
• How to Use Terraform depends_on Meta-Argument | Understanding how Terraform uses implicit and explicit dependencies helps you to determine when and how to use the depends_on meta-argument.
• how to correctly use depends_on for a module? : r/Terraform | Posted by u/UmungoBungo - 3 votes and 3 comments
• terraform-guides/infrastructure-as-code/terraform-0.13-examples ... | Example usage of HashiCorp Terraform. Contribute to hashicorp/terraform-guides development by creating an account on GitHub.
• Best Practice: depends_on Meta-Argument – HashiCorp Help Center | Definitions

Terraform module: any directory containing one or more configuration files (e.g., somefile.tf). Terraform treats all modules equally, there is no hierarchy. 

Top-level configuration: ...