Optional attributes in objects in Terraform - Mini Project: Build & Apply

Optional attributes in objects

📖 Scenario: You are setting up a Terraform configuration to manage cloud resources. Some resources have optional settings that you want to include only if needed.

🎯 Goal: Build a Terraform variable with an object type that includes optional attributes, then use it in a resource configuration.

📋 What You'll Learn

Create a Terraform variable named server_config with an object type that has required and optional attributes

Add a default value for server_config with only the required attributes set

Write a local value that sets a final configuration object using the variable, including optional attributes only if they are defined

Use the final configuration object in a resource block with the correct attribute references

💡 Why This Matters

🌍 Real World

Cloud infrastructure often requires flexible configurations where some settings are optional. This project shows how to handle optional attributes cleanly in Terraform.

💼 Career

Understanding optional attributes in Terraform objects is essential for cloud engineers and DevOps professionals to write adaptable and maintainable infrastructure code.

1

Define the server_config variable with required and optional attributes

Create a Terraform variable called server_config with an object type that has these attributes: name (string, required), cpu (number, required), and tags (map of strings, optional). Set the default value with name as "web-server" and cpu as 2.

Terraform

# Define the variable server_config with required and optional attributes
# Your code here

Hint

Use optional() to mark the tags attribute as optional in the object type.

2

Create a local value to build the final server configuration

Add a local value called final_config that starts with server_config and adds tags only if server_config.tags is defined.

Terraform

variable "server_config" {
  type = object({
    name = string
    cpu  = number
    tags = optional(map(string))
  })
  default = {
    name = "web-server"
    cpu  = 2
  }
}

# Define local final_config to include tags only if defined
# Your code here

Hint

Use merge() with a conditional expression to add tags only if it exists.

3

Use final_config in a resource block

Create a resource block named cloud_server of type example_server that uses local.final_config.name for the name attribute, local.final_config.cpu for the cpu attribute, and includes local.final_config.tags only if it exists.

Terraform

variable "server_config" {
  type = object({
    name = string
    cpu  = number
    tags = optional(map(string))
  })
  default = {
    name = "web-server"
    cpu  = 2
  }
}

locals {
  final_config = merge(
    {
      name = var.server_config.name
      cpu  = var.server_config.cpu
    },
    var.server_config.tags != null ? { tags = var.server_config.tags } : {}
  )
}

# Create resource example_server.cloud_server using local.final_config
# Your code here

Hint

Use a dynamic block to include tags only if they exist.

4

Add an example override with tags in server_config

Update the default value of the server_config variable to include tags with environment = "production" and owner = "team-a".

Terraform

variable "server_config" {
  type = object({
    name = string
    cpu  = number
    tags = optional(map(string))
  })
  default = {
    name = "web-server"
    cpu  = 2
    # Add tags here
  }
}

# Your code here

Hint

Add the tags map inside the default value with the specified keys and values.

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