Chapter 36: Terraform count for_each dynamic lifecycle and depends_on

36.1 count — N copies of the same thing

By Ravindra Bagale · Last updated: 25 October 2026

Story. An Instagram-style feature launch needed three identical worker instances for a load test, and later zero. count creates a number of copies of a resource, indexed 0, 1, 2. It is also the simple on and off switch: count = var.enabled ? 1 : 0. Its weakness is that removing an item from the middle of a list renumbers everything after it.

variable "worker_count" {
  type    = number
  default = 3
}

resource "aws_instance" "worker" {
  count         = var.worker_count
  ami           = data.aws_ami.al2023.id
  instance_type = "t3.micro"
  tags          = { Name = "badge-worker-${count.index}" }
}

resource "aws_eip" "bastion" {
  count = var.create_bastion ? 1 : 0
}

output "worker_ids" {
  value = aws_instance.worker[*].id
}

What each line does

• variable "worker_count" { — An input number of workers.
• count = var.worker_count — Creates that many copies of the instance.
• tags = { Name = "badge-worker-${count.index}" } — count.index is 0, 1, 2, so each copy gets a distinct name.
• count = var.create_bastion ? 1 : 0 — Creates the Elastic IP only when the flag is true.
• value = aws_instance.worker[*].id — The splat expression returns a list of every copy's id.

When it is green.

  # aws_instance.worker[0] will be created
  # aws_instance.worker[1] will be created
  # aws_instance.worker[2] will be created
Plan: 3 to add, 0 to change, 0 to destroy.

When it is red.

Error: Invalid count argument
  on main.tf line 7: count = length(aws_subnet.new[*].id)
The "count" value depends on resource attributes that cannot be determined until apply.

Fix. count must be known at plan time. Base it on a variable or a list you already know, not on ids that do not exist yet.

What: every term in plain English

• count — A meta-argument. It makes N copies of one resource block.
• count.index — The number of the current copy: 0, 1, 2 and so on.
• splat [*] — Collects one attribute from every copy into a list.
• 1 or 0 switch — count = var.flag ? 1 : 0. Makes the resource optional.
• index shift — Removing an item in the middle renumbers every copy after it.
• known at plan time — count must be a value Terraform knows before apply.

Example 1: Three copies with no cloud cost

A Zomato-style trainee wanted to see count without paying for EC2. The local_file resource writes files on your laptop.

1. Make a folder.
2. Paste the code.
3. Run init and apply.
4. List the files.

variable "workers" {
  type    = number
  default = 3
}

resource "local_file" "worker" {
  count    = var.workers
  filename = "${path.module}/out/worker-${count.index}.txt"
  content  = "I am worker ${count.index}"
}

output "files" {
  value = local_file.worker[*].filename
}

terraform init
terraform apply -auto-approve
ls out/
cat out/worker-1.txt

Output

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

Outputs:

files = [
  "./out/worker-0.txt",
  "./out/worker-1.txt",
  "./out/worker-2.txt",
]
worker-0.txt  worker-1.txt  worker-2.txt
I am worker 1

What it shows: Change workers to 5 and plan: only worker-3 and worker-4 are added.

Example 2: Scale down to zero for the night

A load-test team at Swiggy turns test workers off at night. With count, zero means none.

terraform apply -auto-approve -var workers=0
ls out/ 2>/dev/null | wc -l
terraform apply -auto-approve -var workers=2

Output

Plan: 0 to add, 0 to change, 3 to destroy.
Apply complete! Resources: 0 added, 0 changed, 3 destroyed.
0
Plan: 2 to add, 0 to change, 0 to destroy.
Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

What it shows: The same code serves day and night. Only the input changes.

Example 3: Optional bastion with a 1 or 0 switch

Prod at an HDFC-style bank has no bastion; dev does. One flag decides.

variable "create_bastion" {
  type    = bool
  default = false
}

resource "aws_eip" "bastion" {
  count  = var.create_bastion ? 1 : 0
  domain = "vpc"
}

output "bastion_ip" {
  value = one(aws_eip.bastion[*].public_ip)
}

terraform plan -var create_bastion=false | tail -1
terraform plan -var create_bastion=true  | tail -1

Output

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

What it shows: one() returns null when the list is empty, so the output never fails.

Example 4: See the index shift problem

This is why count is risky for named things. Remove the middle name and watch the replace.

variable "names" {
  default = ["auth", "feed", "search"]
}

resource "local_file" "svc" {
  count    = length(var.names)
  filename = "${path.module}/out/${var.names[count.index]}.txt"
  content  = var.names[count.index]
}

terraform apply -auto-approve
terraform plan -var 'names=["auth","search"]' | grep -E "must be replaced|destroyed|Plan:"

Output

  # local_file.svc[1] must be replaced
  # local_file.svc[2] will be destroyed
Plan: 1 to add, 0 to change, 2 to destroy.

What it shows: search moved from index 2 to index 1, so Terraform rebuilt it. With for_each this does not happen.

Example 5: Real AWS: N worker instances with names

The same count pattern on EC2. A Myntra-style sale test needs 3 workers for one afternoon, then zero. Each worker gets a numbered Name tag so the team can find it in the console.

1. Set worker_count to 3 and apply.
2. Check the names in the console or CLI.
3. Set worker_count to 0 after the test and apply again.

resource "aws_instance" "worker" {
  count         = var.worker_count
  ami           = data.aws_ami.al2023.id
  instance_type = "t3.micro"
  tags = {
    Name = "sale-worker-${count.index + 1}"
  }
}

terraform apply -auto-approve -var worker_count=3
aws ec2 describe-instances --filters Name=tag:Name,Values=sale-worker-* \
  --query 'Reservations[].Instances[].Tags[?Key==`Name`].Value[]' --output text

Output

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.
sale-worker-1   sale-worker-2   sale-worker-3

What it shows: count.index + 1 gives human-friendly names starting at 1. Always scale back to 0 after a test to stop the cost.

Command cheat sheet

Verify: did it work?

1. Three copies

   terraform state list | grep -c local_file.worker
   

   Output

   3
   

2. Index names

   terraform state list
   

   Output

   local_file.worker[0]
   local_file.worker[1]
   local_file.worker[2]
   

When it is red 1

Error: Invalid count argument
The "count" value depends on resource attributes that cannot be determined until apply

Cause. count uses something only known after apply.

Fix, step by step

1. Base count on a variable or a known list.
2. Or apply the first resource with -target, then the rest.

When it is red 2

Error: Missing resource instance key
Because aws_eip.bastion has "count" set, its attributes must be accessed on specific instances.

Cause. You wrote aws_eip.bastion.public_ip without an index.

Fix, step by step

1. Use aws_eip.bastion[0].public_ip.
2. Or one(aws_eip.bastion[*].public_ip) for optional ones.

When it is red 3

Error: Invalid index
The given key does not identify an element in this collection value: the collection has no elements.

Cause. You asked for [0] when count is 0.

Fix, step by step

1. Use one() or a conditional.
2. Check the flag value.

Cleanup

terraform destroy -auto-approve
rm -rf out

Practice tasks

Homework: try at home

Recap

• count makes N indexed copies.
• count.index numbers each copy from 0.
• A 1 or 0 count makes a resource optional.
• Removing a middle item shifts indexes and rebuilds.
• count must be known at plan time.

FAQ

Can I use count and for_each together?

No. One resource block uses one of them.

Is count bad?

No. It is right for identical copies and switches.

Can count be negative?

No. It must be zero or more.

How do I move from count to for_each safely?

Add moved blocks from res[0] to res["name"] for each copy.

Does count work on modules?

Yes, since Terraform 0.13.

Interview questions

1. When do you use count?

   For N identical copies or to turn a resource on or off.

2. What is the risk with count?

   Removing a middle item shifts indexes and rebuilds resources.

3. How do you reference all copies?

   The splat expression res[*].attr.

4. Why must count be known at plan?

   Terraform needs the number of resources to build the plan.

5. How do you safely output an optional resource?

   one(res[*].attr) returns null when there is none.

Samajla ka?

Ravi Sir's Cards for this lesson

Revision cardInterview card

मराठी cards