Introduction

Terraform does not have an if statement that wraps an entire data block directly, but you can still make data-source lookup conditional. The usual pattern is to use count or for_each so the data source is instantiated only when the condition is true. After that, you reference it carefully because the data source may not exist in the false branch.

Use count for a simple boolean condition

A common pattern looks like this:

1variable "lookup_ami" {
2  type    = bool
3  default = true
4}
5
6data "aws_ami" "selected" {
7  count       = var.lookup_ami ? 1 : 0
8  most_recent = true
9  owners      = ["self"]
10
11  filter {
12    name   = "name"
13    values = ["my-image-*"]
14  }
15}

If lookup_ami is false, the data source count is zero and Terraform does not instantiate it.

Reference conditional data sources safely

Once count is involved, the data source becomes a list-like collection. So references must use an index:

locals {
  ami_id = var.lookup_ami ? data.aws_ami.selected[0].id : null
}

That conditional matters. If you try to access data.aws_ami.selected[0].id when count = 0, Terraform will fail.

A related defensive tool is try():

locals {
  ami_id = try(data.aws_ami.selected[0].id, null)
}

This is useful when the data source may or may not exist.

for_each is useful when the condition is collection-shaped

If the lookup should happen for each enabled item in a set or map, for_each is often cleaner than count:

1locals {
2  enabled_names = var.enabled ? toset(["primary"]) : toset([])
3}
4
5data "aws_ami" "selected" {
6  for_each    = local.enabled_names
7  most_recent = true
8  owners      = ["self"]
9
10  filter {
11    name   = "name"
12    values = ["${each.key}-image-*"]
13  }
14}

This pattern is handy when the condition is naturally keyed rather than just true or false.

Ask whether the lookup really belongs in the false branch

A good Terraform design question is whether the data source should be skipped entirely or whether the module should always receive the looked-up value and decide later how to use it.

Conditional data sources are useful, but they also add reference complexity. Sometimes a simpler design is:

• always read the data
• conditionally use the result later

That depends on API cost, provider behavior, and whether the lookup is valid in all environments.

Structure outputs with the conditional in mind

If the rest of the module consumes the looked-up value, think about what the "disabled" shape should be. Returning null, an empty list, or an empty map can make downstream expressions much easier to reason about. The conditional data-source pattern works best when the absence case is modeled explicitly instead of being left for later resources to discover accidentally.

Common Pitfalls

The most common mistake is writing a conditional count on the data source and then referencing it as though it were always a single object rather than a counted collection.

Another common issue is forgetting to guard the [0] access when count may be zero.

People also overuse conditional data sources when always performing the lookup would have made the module simpler and easier to read.

Finally, remember that the condition affects whether Terraform evaluates that block at all. If your provider or input assumptions differ across environments, that can be exactly what you want, but it should be intentional.

Summary

• Terraform does conditional data-source lookup through count or for_each, not a dedicated if block.
• Use count = condition ? 1 : 0 for simple boolean control.
• Reference counted data sources carefully because they become indexed collections.
• 'try() and guarded conditionals help avoid invalid references when the data source does not exist.'
• Sometimes the simpler design is to always read the data and conditionally use it later.