Create_before_destroy lifecycle rule in Terraform - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the create_before_destroy lifecycle rule do in Terraform?

It tells Terraform to create the new resource before destroying the old one, helping to avoid downtime during updates.

beginner

Why is create_before_destroy useful for resources like load balancers or instances?

Because it ensures the new resource is ready before the old one is removed, preventing service interruptions.

beginner

How do you enable create_before_destroy in a Terraform resource block?

By adding a lifecycle block with create_before_destroy = true inside the resource definition.

intermediate

What happens if create_before_destroy is not set and a resource needs replacement?

Terraform destroys the old resource first, which can cause downtime or service disruption.

intermediate

Can create_before_destroy be used with all Terraform resources?

No, some resources do not support it due to provider or resource limitations.

What is the main benefit of using create_before_destroy in Terraform?

A It creates the new resource before destroying the old one to avoid downtime.

B It destroys the resource immediately without creating a new one.

C It delays resource creation until after destruction.

D It disables resource replacement.

The create_before_destroy rule ensures the new resource is created first, preventing downtime.

Where do you place the create_before_destroy setting in Terraform?

A Inside the <code>output</code> block.

B Inside the <code>provider</code> block.

C Inside the <code>variable</code> block.

D Inside the <code>resource</code> block's <code>lifecycle</code> block.

It must be set inside the lifecycle block within a resource.

What might happen if you don't use create_before_destroy for a critical resource update?

A The old resource is destroyed before the new one is ready, causing downtime.

B Terraform will automatically enable <code>create_before_destroy</code>.

C Terraform will skip the update.

D Terraform will create two resources.

Without create_before_destroy, the old resource is removed first, which can cause downtime.

Is create_before_destroy always supported by all Terraform providers?

A Yes, all providers support it.

B Only for AWS resources.

C No, some providers or resources do not support it.

D Only for Google Cloud resources.

Support depends on the provider and resource capabilities.

Which of these is a correct example of enabling create_before_destroy?

A resource "aws_instance" "example" { create_before_destroy = true }

B resource "aws_instance" "example" { lifecycle { create_before_destroy = true } }

C provider "aws" { create_before_destroy = true }

D variable "create_before_destroy" { default = true }

The create_before_destroy setting must be inside the lifecycle block within the resource.

Explain how the create_before_destroy lifecycle rule helps prevent downtime during resource updates in Terraform.

Think about what happens when replacing a resource without this rule.

Describe where and how to configure the create_before_destroy rule in a Terraform resource.

Look for the lifecycle settings inside the resource.

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