Terraform Resource Dependencies and Implicit Ordering

In Terraform, managing the order in which resources are created, updated, or destroyed is crucial for building stable and predictable infrastructure. Terraform automatically determines these relationships through resource dependencies, but understanding how it works is key to avoiding errors and optimizing your workflows.

What are Resource Dependencies?

A resource dependency exists when one resource relies on another resource for its configuration or existence. For example, a virtual machine might depend on a network interface, which in turn depends on a virtual network. Terraform analyzes these relationships to build an execution plan.

Terraform builds a dependency graph to determine the correct order of operations.

Terraform analyzes your configuration files to understand how resources relate to each other. If resource A needs information from resource B (like an IP address or a subnet ID), Terraform knows that resource B must be created before resource A.

Terraform constructs a directed acyclic graph (DAG) of your infrastructure. Each node in the graph represents a resource, and an edge between two nodes signifies a dependency. Terraform then traverses this graph to determine the optimal order for provisioning. This graph is the foundation for Terraform's ability to manage complex infrastructure deployments.

Implicit Dependencies

Most dependencies in Terraform are implicit, meaning Terraform infers them automatically based on how you reference attributes from one resource in the configuration of another. This is the most common and recommended way to manage dependencies.

What is an implicit dependency in Terraform?

An implicit dependency occurs when Terraform automatically infers that one resource depends on another because an attribute from the second resource is used in the configuration of the first.

For instance, if you create a virtual machine and need to assign it an IP address from a newly created public IP resource, you would reference the IP address attribute of the public IP resource in your virtual machine's configuration. Terraform sees this reference and understands that the public IP resource must be created first.

Consider a simple scenario: creating a virtual machine (VM) that needs a public IP address.

Resource aws_eip (Elastic IP) provides the IP address.
Resource aws_instance (EC2 Instance) needs to use this IP address.

When you configure aws_instance and reference an attribute from aws_eip (e.g., public_ip), Terraform automatically understands that aws_eip must be created before aws_instance. This creates an implicit dependency. The diagram illustrates this flow: the IP address resource must exist before the instance can be configured with it.

📚

Text-based content

Library pages focus on text content

Explicit Dependencies

While implicit dependencies are preferred, there are situations where you might need to explicitly define a dependency. This is done using the

code

depends_on

meta-argument. You would use this when Terraform cannot infer a dependency, such as when a resource depends on a provider configuration or when a resource's creation is a prerequisite for another, but no attributes are directly referenced.

Use depends_on sparingly. Relying on implicit dependencies makes your configuration more readable and less prone to errors.

Example of explicit dependency:

hcl

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  # This instance depends on the creation of the 'aws_security_group' resource
  # even if no specific attribute from it is directly used in this block.
  depends_on = [
    aws_security_group.example_sg
  ]
}
resource "aws_security_group" "example_sg" {
  name        = "example-security-group"
  description = "Allow SSH inbound traffic"
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  tags = {
    Name = "example-sg"
  }
}

How Terraform Orders Operations

Terraform's execution plan is generated by analyzing the dependency graph. Resources with no dependencies are candidates for creation first. Then, resources that depend on already created resources are scheduled. This process continues until all resources are accounted for. For destruction, the order is reversed: resources with no downstream dependencies are destroyed first.

Dependency Type	How it's Defined	When to Use
Implicit	Referencing attributes of one resource in another's configuration.	Most common and preferred. Use whenever possible.
Explicit	Using the `depends_on` meta-argument.	When Terraform cannot infer a dependency, e.g., resource creation is a prerequisite but no attributes are directly referenced, or dependency on provider setup.

Common Pitfalls and Best Practices

Over-reliance on

code

depends_on

can obscure the actual relationships between resources and make your code harder to maintain. Always strive to use implicit dependencies by structuring your configurations to naturally reference the outputs of resources that must be created first. This leads to more robust and self-documenting infrastructure code.

A well-structured Terraform configuration will minimize the need for explicit depends_on clauses.

Learning Resources

Terraform Documentation: Resource Dependencies(documentation)

The official HashiCorp documentation explaining the `depends_on` meta-argument and how Terraform handles dependencies.

Terraform Docs: Execution Order(documentation)

An in-depth explanation of how Terraform determines the order of operations for creating, updating, and destroying resources.

Understanding Terraform's Dependency Graph(blog)

A blog post from HashiCorp that provides insights into the internal workings of Terraform's dependency graph.

Terraform Tutorial: Managing Dependencies(blog)

A practical guide and tutorial on how to effectively manage resource dependencies in Terraform.

Terraform Best Practices: Dependencies(tutorial)

A tutorial focusing on best practices for managing dependencies to ensure predictable infrastructure deployments.

Terraform: Implicit vs. Explicit Dependencies(blog)

A Medium article that clearly distinguishes between implicit and explicit dependencies and when to use each.

Terraform `depends_on` Explained(video)

A video tutorial that visually explains the concept of `depends_on` and its practical application in Terraform.

Terraform Execution Plan(documentation)

Learn how to use `terraform plan` to visualize the execution order and identify potential dependency issues before applying changes.

Terraform State File(documentation)

Understanding Terraform state is crucial for managing dependencies, as it tracks the current infrastructure and its relationships.

Infrastructure as Code with Terraform(tutorial)

A comprehensive course that covers Terraform fundamentals, including resource management and dependency handling.