Optional attributes in objects in Terraform - Commands & Configuration

Introduction

Sometimes you want to create a group of settings where some are needed and others are not. Optional attributes let you skip some settings without breaking your configuration.

When you want to define a resource or module input that can have extra settings but doesn't always need them.

When you want to make your Terraform code flexible for different environments with different needs.

When you want to avoid errors caused by missing values that are not always required.

When you want to provide default values but allow users to override them if needed.

When you want to simplify your configuration by not forcing all attributes to be set every time.

Config File - main.tf

main.tf

variable "server_config" {
  type = object({
    cpu    = number
    memory = number
    disk   = optional(number)
  })
  default = {
    cpu    = 2
    memory = 4096
  }
}

resource "null_resource" "example" {
  triggers = {
    cpu    = var.server_config.cpu
    memory = var.server_config.memory
    disk   = try(var.server_config.disk, 100)
  }
}

This file defines a variable named server_config as an object with three attributes: cpu and memory are required, while disk is optional.

The default value sets cpu and memory, but leaves out disk.

The resource uses these values, and for disk, it uses try() to provide a fallback value of 100 if disk is not set.

Commands

This command sets up Terraform in the current folder by downloading necessary plugins and preparing the environment.

Terminal

terraform init

Expected Output

Initializing the backend...



Initializing provider plugins...

- Finding latest version of hashicorp/null...

- Installing hashicorp/null v3.2.1...

- Installed hashicorp/null v3.2.1 (signed by HashiCorp)



Terraform has been successfully initialized!

This command checks if the Terraform files are correct and ready to be applied.

Terminal

terraform validate

Expected Output

Success! The configuration is valid.

This command creates or updates the infrastructure based on the configuration without asking for confirmation.

Terminal

terraform apply -auto-approve

Expected Output

null_resource.example: Creating...

null_resource.example: Creation complete after 0s [id=1234567890]



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

→

-auto-approve - Skip manual approval to apply changes immediately

This command shows the outputs of the applied infrastructure, if any are defined.

Terminal

terraform output

Expected Output

No output (command runs silently)

Key Concept

If you remember nothing else from this pattern, remember: optional attributes let you leave out some settings safely while keeping others required.

Common Mistakes

Not marking an attribute as optional but then not providing it in the input.

Terraform will give an error because it expects that attribute to always be present.

Use the 'optional' keyword in the object type to allow skipping that attribute.

Forgetting to handle missing optional attributes when using them in resources.

Using an optional attribute directly without a fallback can cause errors if it is missing.

Use functions like 'try()' or 'lookup()' to provide default values when optional attributes are missing.

Summary

Define object variables with 'optional' attributes to allow flexible inputs.

Use 'try()' or similar functions to safely use optional attributes in resources.

Run 'terraform init' to prepare, 'terraform validate' to check, and 'terraform apply' to create resources.

Practice

1. What does the optional(type, default) function do in a Terraform object type?

easy

A. It allows an attribute to be skipped and provides a default value if missing.

B. It makes an attribute required and enforces a value.

C. It deletes the attribute from the object.

D. It converts the attribute to a list type.

Solution

1. Step 1: Understand optional attribute purpose

   Optional attributes let you omit some fields safely without errors.

2. Step 2: Role of default value

   The default value is used when the attribute is not provided, ensuring smooth operation.

3. Final Answer:

   It allows an attribute to be skipped and provides a default value if missing. -> Option A

4. Quick Check:

   optional(type, default) = skip with default [OK]

Hint: Optional means skip allowed with default value [OK]

Common Mistakes:

• Thinking optional means required
• Assuming it deletes attributes
• Confusing optional with type conversion

2. Which of the following is the correct syntax to define an optional string attribute named region with default "us-west-1" in a Terraform object type?

easy

A. object({ optional(region, string, "us-west-1") })

B. object({ region = optional(string, "us-west-1") })

C. object({ region = string.optional("us-west-1") })

D. object({ region: optional(string, "us-west-1") })

Solution

1. Step 1: Recall correct optional attribute syntax

   The correct syntax is attribute = optional(type, default) inside object.

2. Step 2: Match syntax with options

   object({ region = optional(string, "us-west-1") }) matches this pattern exactly with attribute name and default value.

3. Final Answer:

   object({ region = optional(string, "us-west-1") }) -> Option B

4. Quick Check:

   Correct optional attribute syntax = object({ region = optional(string, "us-west-1") }) [OK]

Hint: Use attribute = optional(type, default) inside object [OK]

Common Mistakes:

• Placing optional outside attribute name
• Using colon instead of equals
• Wrong order of parameters

3. Given this Terraform variable type declaration:

variable "config" {
  type = object({
    name = string
    description = optional(string, "No description")
  })
}

What will be the value of var.config.description if the input is { name = "App" }?

medium

A. "No description"

B. null

C. Error: missing required attribute

D. "App"

Solution

1. Step 1: Identify optional attribute with default

   The description attribute is optional with default "No description".

2. Step 2: Check input for description

   The input does not provide description, so default applies.

3. Final Answer:

   "No description" -> Option A

4. Quick Check:

   Missing optional attribute uses default [OK]

Hint: Missing optional attribute uses default value [OK]

Common Mistakes:

• Expecting null instead of default
• Thinking missing optional causes error
• Confusing attribute values

4. You wrote this object type in Terraform:

object({
  id = string
  tags = optional(map(string))
})

But when you apply, Terraform shows an error about tags. What is the likely cause?

medium

A. Optional attributes cannot be maps

B. Missing default value for optional attribute tags

C. Syntax error: missing comma after id

D. The attribute id should be optional

Solution

1. Step 1: Check object type syntax

   In Terraform object types, attributes must be separated by commas.

2. Step 2: Identify missing comma

   After id = string there is no comma before tags, causing a syntax error often reported at tags.

3. Final Answer:

   Syntax error: missing comma after id -> Option C

4. Quick Check:

   Missing comma in object type causes syntax error [OK]

Hint: Object attributes need commas between them [OK]

Common Mistakes:

• Forgetting commas between attributes
• Thinking optional(map) requires explicit default
• Assuming maps can't be optional

5. You want to define a Terraform object type for a server configuration with these rules:
- hostname is required string
- port is optional number, default 80
- tags is optional map of strings, default empty map

Which of these is the correct type declaration?

hard

A. object({ hostname = string, port = optional(number), tags = map(string) })

B. object({ hostname = optional(string), port = number, tags = optional(map(string)) })

C. object({ hostname = string, port = number, tags = optional(map(string), null) })

D. object({ hostname = string, port = optional(number, 80), tags = optional(map(string), {}) })

Solution

1. Step 1: Identify required and optional attributes

   hostname is required string, port optional number with default 80, tags optional map with default empty map.

2. Step 2: Match syntax with rules

   object({ hostname = string, port = optional(number, 80), tags = optional(map(string), {}) }) correctly uses optional(type, default) for port and tags, and required string for hostname.

3. Final Answer:

   object({ hostname = string, port = optional(number, 80), tags = optional(map(string), {}) }) -> Option D

4. Quick Check:

   Required and optional with defaults correctly declared [OK]

Hint: Use optional(type, default) for optional with defaults [OK]

Common Mistakes:

• Missing default for optional attributes
• Marking required attributes as optional
• Using null instead of empty map as default