Preconditions and postconditions in Terraform - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add a precondition that checks if the variable 'instance_count' is greater than zero.

Terraform

variable "instance_count" {
  type = number
  [1] = [
    {
      condition     = var.instance_count > 0
      error_message = "Instance count must be greater than zero."
    }
  ]
}

Drag options to blanks, or click blank then click option'

Aprecondition

Bpostcondition

Cvalidation

Dconstraint

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'precondition' or 'postcondition' inside variable blocks instead of 'validation'.

Placing the condition outside the variable block.

The validation block is used in Terraform variables to define preconditions that must be met before applying the configuration.

2fill in blank

medium

Complete the resource block to add a precondition that ensures the 'ami' attribute is not empty.

Terraform

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = "t2.micro"

  [1] {
    condition     = length(self.ami) > 0
    error_message = "AMI must not be empty."
  }
}

Drag options to blanks, or click blank then click option'

Apostcondition

Bvalidation

Cconstraint

Dprecondition

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'validation' inside resource blocks (only valid in variables).

Using 'postcondition' instead of 'precondition' for input checks.

The precondition block inside a resource checks conditions before creating or updating the resource.

3fill in blank

hard

Fix the error in the postcondition block that checks if the instance state is 'running'.

Terraform

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = "t2.micro"

  lifecycle {
    [1] {
      condition     = self.instance_state.name == "running"
      error_message = "Instance must be running after creation."
    }
  }
}

Drag options to blanks, or click blank then click option'

Aprecondition

Bpostcondition

Cvalidation

Dconstraint

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'precondition' inside lifecycle blocks.

Using 'validation' inside lifecycle blocks.

The postcondition block inside the lifecycle block checks conditions after resource creation or update.

4fill in blank

hard

Fill both blanks to add a precondition and a postcondition to a resource that checks 'instance_type' before creation and 'state' after creation.

Terraform

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = var.instance_type

  [1] {
    condition     = self.instance_type == "t2.micro"
    error_message = "Instance type must be t2.micro."
  }

  lifecycle {
    [2] {
      condition     = self.instance_state.name == "running"
      error_message = "Instance must be running after creation."
    }
  }
}

Drag options to blanks, or click blank then click option'

Aprecondition

Bvalidation

Cpostcondition

Dconstraint

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping precondition and postcondition blocks.

Using 'validation' inside resource blocks.

The precondition block checks conditions before resource creation, and the postcondition block inside lifecycle checks after creation.

5fill in blank

hard

Fill all three blanks to add a variable with validation, a resource with precondition, and a lifecycle postcondition.

Terraform

variable "region" {
  type = string
  [1] = [
    {
      condition     = var.region != ""
      error_message = "Region cannot be empty."
    }
  ]
}

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = "t2.micro"

  [2] {
    condition     = self.instance_type == "t2.micro"
    error_message = "Instance type must be t2.micro."
  }

  lifecycle {
    [3] {
      condition     = self.instance_state.name == "running"
      error_message = "Instance must be running after creation."
    }
  }
}

Drag options to blanks, or click blank then click option'

Avalidation

Bprecondition

Cpostcondition

Dconstraint

Attempts:

3 left

💡 Hint

Common Mistakes

Using precondition inside variable blocks.

Using validation inside resource blocks.

Placing postcondition outside lifecycle.

Variables use validation blocks for input checks. Resources use precondition blocks before creation and postcondition blocks inside lifecycle after creation.

Practice

1. What is the main purpose of precondition blocks in Terraform?

easy

A. To check conditions before applying changes

B. To verify outputs after deployment

C. To define resource dependencies

D. To configure provider settings

Solution

1. Step 1: Understand preconditions role

   Preconditions are rules that Terraform checks before making any changes to infrastructure.

2. Step 2: Differentiate from postconditions

   Postconditions check after changes, but preconditions ensure safety before changes.

3. Final Answer:

   To check conditions before applying changes -> Option A

4. Quick Check:

   Preconditions = Before changes check [OK]

Hint: Preconditions run before changes to avoid errors [OK]

Common Mistakes:

• Confusing preconditions with postconditions
• Thinking preconditions run after deployment
• Assuming preconditions configure providers

2. Which of the following is the correct syntax to define a postcondition in a Terraform resource?

easy

A. postcondition {
condition = var.enabled
error_message = "Must be enabled"
}

B. postconditions {
condition = var.enabled == true
error_message = "Must be enabled"
}

C. postcondition {
condition = var.enabled == true
error_message = "Must be enabled"
}

D. postcondtion {
condition = var.enabled == true
error_message = "Must be enabled"
}

Solution

1. Step 1: Recall correct block name and syntax

   The block is singular postcondition with a condition attribute.

2. Step 2: Check condition expression format

   Using var.enabled == true is explicit and correct for boolean check.

3. Final Answer:

   postcondition { condition = var.enabled == true error_message = "Must be enabled" } -> Option C

4. Quick Check:

   Correct syntax uses singular postcondition and explicit condition [OK]

Hint: Use singular 'postcondition' with condition attribute [OK]

Common Mistakes:

• Using plural 'postconditions' block
• Omitting '== true' for boolean checks
• Misspelling 'postcondition'

3. Given this Terraform snippet inside a resource:

precondition {
  condition     = var.size > 0
  error_message = "Size must be positive"
}
postcondition {
  condition     = length(self.id) > 0
  error_message = "Resource ID must be set"
}

What happens if var.size is 0 during apply?

medium

A. Terraform applies changes but shows a warning

B. Terraform stops and shows "Size must be positive" error

C. Terraform applies changes and postcondition fails silently

D. Terraform ignores precondition and applies changes

Solution

1. Step 1: Understand precondition behavior

   Preconditions run before applying changes and block apply if false.

2. Step 2: Evaluate condition with var.size = 0

   Condition var.size > 0 is false, so Terraform stops with error message.

3. Final Answer:

   Terraform stops and shows "Size must be positive" error -> Option B

4. Quick Check:

   Precondition false stops apply with error [OK]

Hint: Precondition false stops apply with error message [OK]

Common Mistakes:

• Thinking preconditions only warn, not stop
• Confusing precondition with postcondition timing
• Assuming apply continues despite precondition failure

4. You wrote this postcondition in a Terraform resource:

postcondition {
  condition     = self.name != ""
  error_message = "Name must not be empty"
}

But Terraform never shows the error even if name is empty. What is the likely problem?

medium

A. Postconditions run after apply, but self.name is not set yet

B. The condition should use length(self.name) > 0 instead of self.name != ""

C. The postcondition block is misspelled and ignored

D. Postconditions run before resource creation, so condition is not checked properly

Solution

1. Step 1: Understand postcondition timing

   Postconditions run after resource creation to verify results.

2. Step 2: Analyze condition evaluation

   If self.name is null (not set) rather than empty string after apply, self.name != "" is true because null != "", so no error is triggered.

3. Final Answer:

   Postconditions run after apply, but self.name is not set yet -> Option A

4. Quick Check:

   null != "" passes; check availability [OK]

Hint: Postconditions check after apply; ensure attribute is set [OK]

Common Mistakes:

• Assuming postconditions run before apply
• Using wrong condition syntax without checking attribute availability
• Misspelling postcondition block name

5. You want to ensure a Terraform resource only applies if var.region is either "us-east-1" or "us-west-2", and after apply, the resource's status attribute must be "active". Which is the correct way to write preconditions and postconditions?

hard

A. precondition {
condition = var.region == "us-east-1" && var.region == "us-west-2"
error_message = "Region must be us-east-1 and us-west-2"
}
postcondition {
condition = self.status != "active"
error_message = "Status must not be active"
}

B. precondition {
condition = var.region == "us-east-1" || var.region == "us-west-2"
error_message = "Region must be us-east-1 or us-west-2"
}
postcondition {
condition = self.status != "active"
error_message = "Status must not be active"
}

C. precondition {
condition = var.region != "us-east-1" && var.region != "us-west-2"
error_message = "Region must not be us-east-1 or us-west-2"
}
postcondition {
condition = self.status == "active"
error_message = "Status must be active"
}

D. precondition {
condition = var.region == "us-east-1" || var.region == "us-west-2"
error_message = "Region must be us-east-1 or us-west-2"
}
postcondition {
condition = self.status == "active"
error_message = "Status must be active"
}

Solution

1. Step 1: Write correct precondition for region

   Use logical OR (||) to allow either region, with proper error message.

2. Step 2: Write correct postcondition for status

   Check that self.status equals "active" after apply, with matching error message.

3. Final Answer:

   Precondition uses OR for region check; postcondition checks status equals "active" -> Option D

4. Quick Check:

   Precondition OR and postcondition equality check [OK]

Hint: Use OR for precondition, equality for postcondition [OK]

Common Mistakes:

• Using AND instead of OR in precondition
• Checking for inequality in postcondition wrongly
• Mixing error messages with wrong logic