Create_before_destroy lifecycle rule in Terraform - Step-by-Step Execution

Process Flow - Create_before_destroy lifecycle rule

Start Apply

↓

Check resource change

↓

Create new resource

↓

Wait for new resource ready

↓

Destroy old resource

↓

Apply complete

Terraform first creates the new resource before destroying the old one to avoid downtime.

Execution Sample

Terraform

resource "aws_instance" "example" {
  lifecycle {
    create_before_destroy = true
  }
  ami           = "ami-12345678"
  instance_type = "t2.micro"
}

This Terraform code creates an AWS instance with the create_before_destroy lifecycle rule to ensure new instance is created before old one is destroyed.

Process Table

Step	Action	Resource State Before	Resource State After	Notes
1	Start apply	Old instance exists	Old instance exists	Terraform plan starts
2	Create new instance	Old instance exists	Old instance + New instance	New instance is created first
3	Wait for new instance ready	Old instance + New instance	Old instance + New instance	Ensures new instance is healthy
4	Destroy old instance	Old instance + New instance	New instance only	Old instance is safely removed
5	Apply complete	New instance only	New instance only	Infrastructure updated without downtime

💡 Old instance destroyed only after new instance is ready, ensuring zero downtime.

Status Tracker

Variable	Start	After Step 2	After Step 4	Final
old_instance	exists	exists	destroyed	destroyed
new_instance	not exists	created	created	created

Key Moments - 2 Insights

Why does Terraform create a new resource before destroying the old one?

Because the create_before_destroy rule tells Terraform to avoid downtime by ensuring the new resource is ready before removing the old one, as shown in steps 2 and 4 of the execution_table.

What happens if the new resource fails to become ready?

Terraform will not destroy the old resource, preventing service interruption. This is implied in step 3 where Terraform waits for readiness before proceeding.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the new instance get created?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Refer to the 'Action' column in execution_table row for Step 2.

According to variable_tracker, what is the state of old_instance after Step 4?

A exists

B created

C destroyed

D not exists

💡 Hint

Check the 'old_instance' row under 'After Step 4' in variable_tracker.

If create_before_destroy was false, what would change in the execution_table?

A Old instance destroyed before new instance created

B New instance created before old instance destroyed

C Both instances created simultaneously

D No instances destroyed

💡 Hint

The lifecycle rule controls creation and destruction order shown in execution_table steps.

Concept Snapshot

Terraform lifecycle create_before_destroy rule:
- Ensures new resource is created before old is destroyed
- Prevents downtime during resource replacement
- Applies during terraform apply phase
- Useful for resources needing continuous availability
- Syntax: lifecycle { create_before_destroy = true }

Full Transcript

This visual execution trace shows how Terraform applies the create_before_destroy lifecycle rule. First, Terraform starts the apply process with the old resource existing. Then it creates the new resource while keeping the old one active. Terraform waits until the new resource is ready and healthy. Only after that does it destroy the old resource. This sequence prevents downtime by ensuring continuous availability. The variable tracker shows the old instance exists initially and is destroyed only after the new instance is created. Key moments clarify why the new resource must be ready before destroying the old one and what happens if readiness fails. The quiz tests understanding of the creation and destruction order and the effect of disabling this rule.

Practice

1. What is the main purpose of the create_before_destroy lifecycle rule in Terraform?

easy

A. To create a new resource before deleting the old one to avoid downtime

B. To destroy resources before creating new ones to save costs

C. To prevent any resource from being created or destroyed

D. To automatically backup resources before deletion

Solution

1. Step 1: Understand lifecycle behavior

   The create_before_destroy rule tells Terraform to create the replacement resource first.

2. Step 2: Avoid downtime during updates

   This ensures the old resource is only destroyed after the new one is ready, preventing service interruption.

3. Final Answer:

   To create a new resource before deleting the old one to avoid downtime -> Option A

4. Quick Check:

   create_before_destroy = avoid downtime [OK]

Hint: Remember: create new first, then delete old [OK]

Common Mistakes:

• Thinking it deletes old resource before creating new
• Confusing with prevent_destroy lifecycle rule
• Assuming it backs up resources automatically

2. Which of the following is the correct syntax to enable create_before_destroy in a Terraform resource?

easy

A. lifecycle { create_before_destroy = true }

B. lifecycle { create_before_destroy: true }

C. lifecycle = { create_before_destroy = true }

D. lifecycle { create_before_destroy = "true" }

Solution

1. Step 1: Review Terraform lifecycle block syntax

   The lifecycle block uses curly braces with key-value pairs using = and booleans without quotes.

2. Step 2: Identify correct boolean assignment

   Boolean values are unquoted, so true is correct, not "true" as string.

3. Final Answer:

   lifecycle { create_before_destroy = true } -> Option A

4. Quick Check:

   Correct syntax uses = and unquoted booleans [OK]

Hint: Use = and true without quotes in lifecycle block [OK]

Common Mistakes:

• Using colon : instead of equals =
• Putting boolean true in quotes
• Assigning lifecycle block with = instead of braces

3. Given this Terraform resource snippet, what will happen during an update?

resource "aws_instance" "example" {
  ami           = "ami-123456"
  instance_type = "t2.micro"

  lifecycle {
    create_before_destroy = true
  }
}

medium

A. Terraform will destroy the old instance before creating the new one

B. Terraform will fail because create_before_destroy is not supported

C. Terraform will update the instance in place without replacement

D. Terraform will create the new instance before destroying the old one

Solution

1. Step 1: Check lifecycle rule effect

   The create_before_destroy = true means Terraform creates the new resource first.

2. Step 2: Understand resource replacement

   Since the instance requires replacement, Terraform creates new instance before destroying old one.

3. Final Answer:

   Terraform will create the new instance before destroying the old one -> Option D

4. Quick Check:

   create_before_destroy = new before old [OK]

Hint: If replacement needed, new resource comes first [OK]

Common Mistakes:

• Assuming old resource is destroyed first
• Thinking update happens in place always
• Believing create_before_destroy is unsupported

4. You added create_before_destroy = true to a resource but Terraform still destroys the old resource before creating the new one. What is the likely cause?

medium

A. You used quotes around true in lifecycle block

B. The resource does not support create_before_destroy lifecycle rule

C. You forgot to run terraform init

D. Terraform always destroys before creating regardless of lifecycle

Solution

1. Step 1: Understand resource support

   Not all Terraform resources support create_before_destroy. If unsupported, Terraform ignores it.

2. Step 2: Check lifecycle behavior fallback

   If unsupported, Terraform defaults to destroying old resource before creating new one.

3. Final Answer:

   The resource does not support create_before_destroy lifecycle rule -> Option B

4. Quick Check:

   Unsupported resource ignores create_before_destroy [OK]

Hint: Check resource docs for create_before_destroy support [OK]

Common Mistakes:

• Assuming terraform init fixes lifecycle issues
• Using quotes around boolean true
• Believing lifecycle rules always override resource behavior

5. You manage a critical database server resource that must never be unavailable during updates. How should you configure Terraform to ensure zero downtime using create_before_destroy?

hard

A. Remove lifecycle block and rely on default behavior

B. Use prevent_destroy = true to stop any deletion

C. Add lifecycle { create_before_destroy = true } and verify the resource supports it

D. Manually delete old resource before applying changes

Solution

1. Step 1: Use create_before_destroy for zero downtime

   Setting create_before_destroy = true ensures new resource is ready before old is removed.

2. Step 2: Confirm resource supports lifecycle rule

   Check documentation to ensure the database resource supports this lifecycle feature to avoid unexpected downtime.

3. Final Answer:

   Add lifecycle { create_before_destroy = true } and verify the resource supports it -> Option C

4. Quick Check:

   Use create_before_destroy with support check [OK]

Hint: Always verify resource supports create_before_destroy [OK]

Common Mistakes:

• Using prevent_destroy which blocks updates
• Relying on default lifecycle risking downtime
• Manually deleting resources causing downtime