Resource dependencies (implicit) in Terraform - Deep Dive

Overview - Resource dependencies (implicit)

What is it?

Resource dependencies in Terraform are the relationships that tell Terraform which resources must be created or updated before others. Implicit dependencies happen automatically when one resource uses the output or attribute of another resource. This helps Terraform know the correct order to build or change infrastructure without extra instructions.

Why it matters

Without resource dependencies, Terraform wouldn't know the right order to create or update resources. This could cause errors, like trying to use a network before it exists. Implicit dependencies make infrastructure automation safer and smoother, saving time and avoiding costly mistakes.

Where it fits

Before learning implicit dependencies, you should understand basic Terraform resources and how to write configurations. After this, you can learn explicit dependencies and advanced dependency management to control complex infrastructure builds.

Mental Model

Core Idea

Terraform automatically figures out which resources depend on others by seeing when one resource uses another's data or attributes.

Think of it like...

It's like baking a cake where you automatically know you must mix the batter before putting it in the oven because the recipe calls for the batter first.

┌─────────────┐       ┌─────────────┐
│ Resource A  │──────▶│ Resource B  │
│ (network)   │       │ (server)    │
└─────────────┘       └─────────────┘

Terraform sees Resource B uses Resource A's info, so it builds A first.

Build-Up - 7 Steps

1

Foundation

What are Terraform resources

Concept: Terraform resources are the building blocks of infrastructure, representing things like servers or networks.

In Terraform, you write blocks called resources to tell it what to create. For example, a resource can be a virtual machine or a storage bucket. Each resource has a type and a name, and you set its properties.

Result

You can define infrastructure pieces in code that Terraform understands.

Knowing what resources are is essential because dependencies connect these pieces to build working infrastructure.

2

Foundation

How Terraform plans changes

Concept: Terraform creates a plan by comparing current infrastructure with desired state and figuring out what to add, change, or remove.

When you run 'terraform plan', Terraform checks what exists and what you want. It then decides the order to create or update resources based on dependencies it knows.

Result

Terraform shows a safe plan to change infrastructure without breaking things.

Understanding planning helps see why dependencies matter to avoid errors during changes.

3

Intermediate

Implicit dependencies explained

🤔Before reading on: do you think Terraform needs you to always tell it which resources depend on others? Commit to your answer.

Concept: Terraform automatically detects dependencies when one resource uses another's attributes or outputs.

If a resource uses a value from another resource, like a server needing a network ID, Terraform knows the server depends on the network. This is implicit dependency because you didn't tell Terraform explicitly; it figured it out from your code.

Result

Terraform builds resources in the correct order without extra instructions.

Understanding implicit dependencies shows how Terraform reduces manual work and errors by reading your resource connections.

4

Intermediate

Examples of implicit dependencies

🤔Before reading on: do you think referencing a resource's attribute always creates a dependency? Commit to your answer.

Concept: Using attributes from one resource inside another creates an implicit dependency.

Example: a virtual machine resource uses the subnet ID from a network resource. Terraform sees this and knows to create the network first. Even if you don't write 'depends_on', Terraform orders them correctly.

Result

Resources build in the right sequence automatically.

Knowing how references create dependencies helps you write clearer, safer Terraform code.

5

Intermediate

When implicit dependencies are not enough

🤔Before reading on: do you think all dependencies can be detected automatically by Terraform? Commit to your answer.

Concept: Some dependencies are not visible through resource attributes and need explicit declaration.

If a resource depends on another without using its outputs, Terraform won't know. For example, a script that must run after a server is ready but doesn't use its attributes. Here, you must use 'depends_on' to tell Terraform the order.

Result

You learn when to add explicit dependencies to avoid errors.

Recognizing implicit dependency limits prevents subtle bugs in complex infrastructure.

6

Advanced

How Terraform builds the dependency graph

🤔Before reading on: do you think Terraform builds a map of all resource connections before applying changes? Commit to your answer.

Concept: Terraform creates a graph of resources and their dependencies to plan the correct order of operations.

Terraform scans your configuration and builds a graph where nodes are resources and edges are dependencies. It then uses this graph to decide which resources to create, update, or delete first, ensuring no resource is used before it exists.

Result

Terraform applies changes safely and efficiently.

Understanding the dependency graph explains why Terraform can handle complex infrastructure reliably.

7

Expert

Surprises in implicit dependency detection

🤔Before reading on: do you think Terraform always detects dependencies inside all expressions and functions? Commit to your answer.

Concept: Terraform detects dependencies only when resource attributes are directly referenced; some indirect uses may not create dependencies.

If you use resource data inside complex expressions, or pass resource IDs through variables or locals without direct reference, Terraform might miss the dependency. This can cause resources to build in the wrong order. Experts carefully check references and sometimes add explicit dependencies to fix this.

Result

You avoid subtle bugs caused by hidden or indirect dependencies.

Knowing Terraform's detection limits helps prevent hard-to-debug infrastructure errors.

Under the Hood

Terraform parses all resource blocks and expressions to find references to other resources' attributes. It builds a directed graph where each node is a resource and edges represent dependencies. This graph guides the order of creation, update, or deletion. During apply, Terraform walks this graph to ensure no resource is used before it exists.

Why designed this way?

Terraform was designed to automate infrastructure safely and efficiently. Implicit dependencies reduce manual work and errors by letting Terraform infer order from natural references. Explicit dependencies exist for cases where references are not visible. This balance keeps configurations simple yet powerful.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│ Resource A  │──────▶│ Resource B  │──────▶│ Resource C  │
│ (network)   │       │ (server)    │       │ (database)  │
└─────────────┘       └─────────────┘       └─────────────┘

Terraform builds this graph to know the order: A before B before C.

Myth Busters - 4 Common Misconceptions

Quick: Do you think Terraform always needs 'depends_on' to order resources? Commit yes or no.

Common Belief: Terraform requires explicit 'depends_on' for all resource dependencies.

Reality: Terraform automatically detects dependencies when one resource uses another's attributes, so 'depends_on' is often unnecessary.

Why it matters: Adding unnecessary 'depends_on' makes configurations verbose and harder to maintain.

Quick: Do you think referencing a resource inside a variable or local always creates a dependency? Commit yes or no.

Common Belief: Any use of a resource's output inside variables or locals creates implicit dependencies.

Reality: Terraform only detects dependencies if the resource attribute is directly referenced in resource arguments; indirect use in variables or locals may not create dependencies.

Why it matters: Missing dependencies can cause resources to build in the wrong order, leading to errors.

Quick: Do you think Terraform's dependency graph includes data sources the same way as resources? Commit yes or no.

Common Belief: Data sources always create dependencies like resources do.

Reality: Data sources are read-only and do not create dependencies that affect resource creation order unless explicitly referenced.

Why it matters: Misunderstanding this can cause confusion about why some resources build before data sources.

Quick: Do you think Terraform can detect dependencies inside all expressions and functions? Commit yes or no.

Common Belief: Terraform detects dependencies inside any expression or function that uses resource attributes.

Reality: Terraform only detects dependencies when resource attributes are directly referenced; complex expressions or functions may hide dependencies.

Why it matters: This can cause subtle bugs where resources build in the wrong order.

Expert Zone

1

Terraform's dependency graph is recalculated on every plan, so changes in references immediately affect resource order.

2

Implicit dependencies do not cover lifecycle hooks or provisioners, which may require explicit ordering.

3

Modules can hide dependencies inside, so understanding how outputs connect modules is key for complex setups.

When NOT to use

Implicit dependencies are not enough when resources depend on side effects, external scripts, or lifecycle events. In these cases, use explicit 'depends_on' or external orchestration tools.

Production Patterns

In production, teams rely on implicit dependencies for most resources to keep code clean, adding explicit dependencies only for edge cases like ordering scripts or manual steps. They also use modules to encapsulate dependencies and outputs clearly.

Connections

Directed Acyclic Graphs (DAGs)

Terraform's dependency graph is a DAG representing resource order.

Understanding DAGs from computer science helps grasp how Terraform ensures no cycles and correct build order.

Build systems (e.g., Makefiles)

Both use dependency graphs to decide build order automatically.

Knowing how build tools manage dependencies clarifies Terraform's approach to infrastructure orchestration.

Project management task dependencies

Like tasks that must finish before others start, Terraform resources depend on each other.

Seeing resource dependencies as task dependencies helps plan and avoid bottlenecks in infrastructure projects.

Common Pitfalls

#1 Assuming all dependencies are detected automatically.

Wrong approach:

resource "null_resource" "example" {
provisioner "local-exec" {
command = "echo done"
}
}

resource "null_resource" "dependent" {
provisioner "local-exec" {
command = "echo depends"
}
}

# No depends_on used

Correct approach:

resource "null_resource" "example" {
provisioner "local-exec" {
command = "echo done"
}
}

resource "null_resource" "dependent" {
depends_on = [null_resource.example]
provisioner "local-exec" {
command = "echo depends"
}
}

Root cause:

Implicit dependencies only detect references in resource arguments, not side effects or provisioners.

#2 Using variables or locals to pass resource IDs without direct reference.

Wrong approach:

variable "subnet_id" {}

resource "aws_instance" "web" {
subnet_id = var.subnet_id
}

# subnet_id variable set outside referencing resource

Correct approach:

resource "aws_subnet" "main" {
# subnet config
}

resource "aws_instance" "web" {
subnet_id = aws_subnet.main.id
}

Root cause:

Terraform cannot detect dependency if resource attributes are passed indirectly through variables.

#3 Expecting data sources to create build order dependencies.

Wrong approach:

data "aws_vpc" "main" {
filter { name = "tag:Name" value = "main-vpc" }
}

resource "aws_subnet" "subnet" {
vpc_id = data.aws_vpc.main.id
}

# Assuming data source delays subnet creation

Correct approach:

data "aws_vpc" "main" {
filter { name = "tag:Name" value = "main-vpc" }
}

resource "aws_subnet" "subnet" {
vpc_id = data.aws_vpc.main.id
}

# Data source reads existing VPC, no creation order needed

Root cause:

Data sources read existing infrastructure and do not create dependencies for resource creation order.

Key Takeaways

Terraform automatically detects resource dependencies when one resource uses another's attributes, creating implicit dependencies.

Implicit dependencies help Terraform build infrastructure in the correct order without extra instructions, reducing errors and manual work.

Not all dependencies are detected implicitly; some require explicit 'depends_on' declarations to ensure correct ordering.

Terraform builds a dependency graph internally to plan and apply changes safely and efficiently.

Understanding implicit dependencies and their limits is essential to write reliable and maintainable Terraform configurations.