Data source dependencies in Terraform - Commands & Configuration

Introduction

Sometimes in Terraform, you need to use information from existing resources before creating new ones. Data source dependencies help you get this information safely and in the right order.

When you want to get details about an existing cloud resource before creating a new resource that depends on it.

When you need to read configuration or state from outside Terraform to use in your setup.

When you want to avoid hardcoding values by fetching them dynamically from your cloud provider.

When you want to ensure Terraform creates resources in the correct order based on existing data.

When you want to share information between different parts of your Terraform code safely.

Config File - main.tf

main.tf

provider "aws" {
  region = "us-east-1"
}

data "aws_ami" "ubuntu" {
  most_recent = true
  owners      = ["099720109477"]
  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
  }
}

resource "aws_instance" "example" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "t2.micro"
  tags = {
    Name = "example-instance"
  }
}

The provider block sets the AWS region.

The data "aws_ami" "ubuntu" block fetches the latest Ubuntu AMI ID dynamically.

The resource "aws_instance" "example" block creates an EC2 instance using the AMI ID from the data source, ensuring the instance uses the latest Ubuntu image.

Commands

This command initializes the Terraform working directory, downloads the AWS provider plugin, and prepares Terraform to run.

Terminal

terraform init

Expected Output

Initializing the backend...



Initializing provider plugins...

- Finding latest version of hashicorp/aws...

- Installing hashicorp/aws v4.0.0...

- Installed hashicorp/aws v4.0.0 (signed by HashiCorp)



Terraform has been successfully initialized!



You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure.

This command shows what Terraform will do. It reads the data source to get the latest AMI ID and plans to create an EC2 instance using that AMI.

Terminal

terraform plan

Expected Output

Refreshing Terraform state in-memory prior to plan...



An execution plan has been generated and is shown below.

Resource actions are indicated with the following symbols:

  + create



Terraform will perform the following actions:



  # aws_instance.example will be created

  + resource "aws_instance" "example" {

      + ami                          = "ami-0abcdef1234567890"

      + arn                          = (known after apply)

      + instance_type                = "t2.micro"

      + tags                         = {

          + "Name" = "example-instance"

        }

    }



Plan: 1 to add, 0 to change, 0 to destroy.



─────────────────────────────────────────────────────────────────────────────



Note: You didn't specify an "-out" parameter to save this plan, so Terraform

can't guarantee to take exactly these actions if you run "terraform apply" now.

This command applies the planned changes, creating the EC2 instance using the AMI ID fetched from the data source.

Terminal

terraform apply -auto-approve

Expected Output

aws_instance.example: Creating...

aws_instance.example: Still creating... [10s elapsed]

aws_instance.example: Creation complete after 15s [id=i-0123456789abcdef0]



Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

→

-auto-approve - Automatically approves the apply without asking for confirmation.

This command shows the current state of the infrastructure Terraform manages, including the EC2 instance created with the AMI from the data source.

Terminal

terraform show

Expected Output

aws_instance.example:

  id = i-0123456789abcdef0

  ami = ami-0abcdef1234567890

  instance_type = t2.micro

  tags = {

    Name = example-instance

  }

Key Concept

If you remember nothing else from this pattern, remember: data sources let Terraform safely get information from existing resources so it can create new resources in the right order.

Common Mistakes

Using a data source without referencing its attributes in resources.

Terraform will fetch the data but not use it, so your resources won't get the needed information.

Always reference the data source attributes (like data.aws_ami.ubuntu.id) in your resource definitions.

Hardcoding values instead of using data sources.

Hardcoded values can become outdated and cause errors or security issues.

Use data sources to fetch dynamic or current values automatically.

Not running 'terraform init' before 'terraform plan' or 'apply'.

Terraform won't have the necessary provider plugins and will fail.

Always run 'terraform init' first to set up the working directory.

Summary

Use data sources in Terraform to fetch information from existing resources before creating new ones.

Run 'terraform init' to prepare your environment, then 'terraform plan' to see changes, and 'terraform apply' to create resources.

Reference data source attributes in your resource blocks to ensure dependencies are handled correctly.

Practice

1. What is the main purpose of using data source dependencies in Terraform?

easy

A. To fetch existing resource information before creating new resources

B. To delete resources automatically after creation

C. To speed up Terraform plan execution by skipping resources

D. To create duplicate resources with the same configuration

Solution

1. Step 1: Understand data source role

   Data sources in Terraform are used to read information about existing resources outside Terraform or created by other means.

2. Step 2: Identify dependency purpose

   Dependencies ensure Terraform fetches this existing info before creating or modifying other resources that rely on it.

3. Final Answer:

   To fetch existing resource information before creating new resources -> Option A

4. Quick Check:

   Data source dependencies = fetch info first [OK]

Hint: Data sources get info before resource creation [OK]

Common Mistakes:

• Thinking data sources create or delete resources
• Confusing dependencies with resource lifecycle
• Assuming data sources speed up plans by skipping

2. Which syntax correctly adds an explicit dependency on a data source named aws_vpc.main in a resource block?

easy

A. depends_on = {aws_vpc.main}

B. depends_on = aws_vpc.main

C. depends_on = ["aws_vpc.main"]

D. depends_on = [aws_vpc.main]

Solution

1. Step 1: Recall depends_on syntax

   Terraform expects depends_on to be a list of resource or data source references without quotes.

2. Step 2: Analyze options

   depends_on = [aws_vpc.main] uses a list with the correct reference syntax. depends_on = aws_vpc.main misses list brackets. depends_on = ["aws_vpc.main"] uses quotes making it a string, not a reference. depends_on = {aws_vpc.main} uses braces which is invalid.

3. Final Answer:

   depends_on = [aws_vpc.main] -> Option D

4. Quick Check:

   depends_on requires list of references [OK]

Hint: Use square brackets and no quotes for depends_on [OK]

Common Mistakes:

• Using quotes around resource names
• Omitting square brackets for depends_on
• Using curly braces instead of square brackets

3. Given this Terraform snippet:

data "aws_ami" "example" {
  most_recent = true
  filter {
    name   = "name"
    values = ["amzn2-ami-hvm-*-x86_64-gp2"]
  }
}

resource "aws_instance" "web" {
  ami           = data.aws_ami.example.id
  instance_type = "t2.micro"
}

What happens if the data source aws_ami.example fails to find a matching AMI?

medium

A. Terraform will skip the instance creation silently

B. Terraform will create the instance with a default AMI

C. Terraform plan will fail with an error before creating the instance

D. Terraform will retry the data source until it finds an AMI

Solution

1. Step 1: Understand data source failure behavior

   If a data source cannot find the requested resource, Terraform plan fails with an error because it cannot resolve the value.

2. Step 2: Check resource dependency

   The resource depends on the data source's output for the AMI ID, so without it, resource creation cannot proceed.

3. Final Answer:

   Terraform plan will fail with an error before creating the instance -> Option C

4. Quick Check:

   Data source failure = plan error [OK]

Hint: Missing data source value causes plan failure [OK]

Common Mistakes:

• Assuming default values are used automatically
• Thinking Terraform retries data sources
• Believing resource creation skips silently

4. You have this Terraform configuration:

data "aws_subnet" "selected" {
  filter {
    name   = "tag:Name"
    values = ["my-subnet"]
  }
}

resource "aws_instance" "app" {
  ami           = "ami-123456"
  instance_type = "t2.micro"
  subnet_id     = data.aws_subnet.selected.id
  depends_on    = [aws_instance.app]
}

What is the problem with this configuration?

medium

A. The resource depends_on itself causing a circular dependency

B. The data source filter syntax is invalid

C. The subnet_id should not use data source references

D. The instance_type is not a valid type

Solution

1. Step 1: Analyze depends_on usage

   The resource aws_instance.app declares depends_on referencing itself, which creates a circular dependency.

2. Step 2: Understand circular dependency impact

   Circular dependencies cause Terraform to fail planning or applying because it cannot resolve resource order.

3. Final Answer:

   The resource depends_on itself causing a circular dependency -> Option A

4. Quick Check:

   depends_on self-reference = circular dependency error [OK]

Hint: Avoid depends_on referencing the same resource [OK]

Common Mistakes:

• Confusing data source filter syntax as error
• Thinking subnet_id cannot use data sources
• Assuming instance_type is invalid without checking

5. You want to create an AWS security group that allows inbound traffic only from instances in a specific subnet fetched via a data source. Which approach correctly ensures Terraform creates the security group only after the subnet data is fetched?

hard

A. Use depends_on = [data.aws_subnet.target] in the security group resource

B. No need for depends_on; Terraform infers dependency from data source usage

C. Create the security group first, then fetch the subnet data source

D. Use a null_resource to delay security group creation

Solution

1. Step 1: Understand implicit dependencies

   When a resource uses a data source attribute (like subnet ID), Terraform automatically creates a dependency to fetch data first.

2. Step 2: Evaluate explicit depends_on necessity

   Explicit depends_on is not needed unless the dependency is indirect or complex; here, implicit dependency suffices.

3. Final Answer:

   No need for depends_on; Terraform infers dependency from data source usage -> Option B

4. Quick Check:

   Data source usage creates implicit dependency [OK]

Hint: Data source references create implicit dependencies [OK]

Common Mistakes:

• Adding unnecessary depends_on for direct data source use
• Creating resources in wrong order ignoring implicit dependencies
• Using null_resource unnecessarily