Terraform: Replace Null Values with Defaults

• Introduction
• Step-by-Step Guide
• Code Example
• Additional Notes
• Summary
• Conclusion
• References

Working with null values and defaults in Terraform is crucial for writing robust and predictable infrastructure code. This guide provides a practical overview of how to effectively manage null values and establish default settings in your Terraform configurations. We'll cover the behavior of null values, setting defaults for variables, using conditional logic for dynamic defaults, handling nulls within modules, working with objects and default values, and understanding how to access default values. By mastering these techniques, you can create more resilient and adaptable Terraform code.

Here's a breakdown of how to manage null values and set defaults in Terraform:

1. Understanding Null Behavior:

• In Terraform, setting an argument to null is equivalent to omitting it entirely.
• Terraform won't replace null with a default value automatically.

2. Setting Default Values for Variables:

variable "instance_type" {
  type = string
  default = "t3.micro"
}

• This ensures that if instance_type isn't provided, it defaults to "t3.micro".

3. Conditional Logic for Dynamic Defaults:

• Use the ternary operator to apply defaults based on conditions:

resource "aws_instance" "example" {
  # ... other arguments
  key_name = var.key_name != "" ? var.key_name : "default_key" 
}

• This sets key_name to var.key_name unless it's an empty string, in which case it uses "default_key".

4. Handling Null Values Within Modules:

• Pass values explicitly to module inputs, even if they have defaults defined within the module.
• This prevents unexpected behavior if a null value is passed.

5. Working with Objects and Default Values:

• When using objects, ensure that the entire object is provided if any of its attributes are set.
• Partially defined objects can lead to unexpected results.

6. Accessing Default Values:

• You can't directly access the default value of a variable within your Terraform code.
• The default value is only applied if the variable isn't explicitly set.

Key Points:

• Be mindful of the difference between null, empty strings (""), and undefined values.
• Use clear and concise logic when handling defaults to avoid confusion.
• Test your code thoroughly to ensure that default values are applied as expected.

The code provides Terraform examples for handling null values and defaults. It covers setting default values for variables, using conditional logic for dynamic defaults, handling null values within modules, working with objects and default values, and demonstrating inaccessible default values. The examples demonstrate how to use variables, conditional statements, module inputs, and object merging to manage default values effectively in Terraform configurations.

This code accompanies the article "Handling Null Values and Defaults in Terraform" and provides practical examples.

1. Setting Default Values for Variables:

# variables.tf
variable "instance_type" {
  type    = string
  default = "t3.micro"
}

variable "enable_monitoring" {
  type    = bool
  default = false
}

# main.tf
resource "aws_instance" "example" {
  # ... other arguments
  instance_type = var.instance_type
  monitoring    = var.enable_monitoring
}

2. Conditional Logic for Dynamic Defaults:

# variables.tf
variable "environment" {
  type = string
}

variable "key_name" {
  type = string
}

# main.tf
resource "aws_instance" "example" {
  # ... other arguments
  key_name = var.key_name != "" ? var.key_name : "default-${var.environment}-key"
  tags = {
    Environment = var.environment != "" ? var.environment : "development"
  }
}

3. Handling Null Values Within Modules:

# modules/vpc/variables.tf
variable "cidr_block" {
  type    = string
  default = "10.0.0.0/16"
}

# modules/vpc/main.tf
resource "aws_vpc" "main" {
  cidr_block = var.cidr_block
}

# main.tf
module "vpc" {
  source = "./modules/vpc"
  # Explicitly pass cidr_block, even if using the default
  cidr_block = "172.16.0.0/16" 
}

4. Working with Objects and Default Values:

# variables.tf
variable "database_config" {
  type = object({
    engine        = string
    instance_class = string
    username       = string
    password       = string
  })
  default = {
    engine        = "postgres"
    instance_class = "db.t3.micro"
    username       = "admin"
  }
}

# main.tf
resource "aws_rds_instance" "example" {
  # ... other arguments
  # Provide the entire object, even if only modifying 'password'
  database_config = merge(var.database_config, { password = "securepassword" })
}

5. Demonstrating Inaccessible Default Values:

# variables.tf
variable "instance_count" {
  type    = number
  default = 2
}

# main.tf
# This will throw an error because you cannot access the default value directly
resource "aws_instance" "example" {
  # ... other arguments
  count = var.instance_count == var.instance_count ? 1 : var.instance_count 
}

These examples illustrate various techniques for managing null values and defaults in Terraform. Remember to prioritize clarity and test your code thoroughly to ensure the desired behavior.

• Empty strings ("") are not null: Terraform treats empty strings as actual values. This is important for conditional logic, as an empty string won't trigger a default value meant for a truly null input.

• The null type: While less common, you can enforce a variable to be explicitly null using type = null. This can be useful for optional module inputs where you want to differentiate between "not set" and an empty string.

• Default objects need all keys: When defining default values for object variables, ensure all required keys are present in the default. Missing keys will lead to errors if the object is not fully defined elsewhere.

• Use try() for graceful error handling: The try() function is helpful for providing fallback values when an expression might error due to a null value. This can make your code more resilient.

• Consider using maps for dynamic blocks: When working with resources that support dynamic blocks (like aws_security_group_rule), using maps with conditional logic can be cleaner than relying heavily on null and default values within the block definition.

• Document your defaults: Clearly document the default values for variables, especially in shared modules. This helps users understand the expected behavior without needing to dig through the code.

• Test with and without inputs: When testing your Terraform code, always test scenarios where variables are both provided and omitted to ensure defaults are working as intended.

Mastering the nuances of null values and defaults is essential for writing clean, predictable, and adaptable Terraform code. By understanding the behavior of null, leveraging variable defaults, employing conditional logic, and carefully managing values passed to modules, you can create infrastructure code that behaves as expected. Remember to thoroughly test your configurations, considering scenarios with and without explicit input values, to ensure your defaults are applied correctly and your infrastructure is provisioned reliably.

• User Experience with Terraform Default Values ! | by Aamod Kadam ... | My Experience with default values
• Terraform modules are are not changing null values to the default ... | Terraform Version Terraform v1.2.7 on linux_amd64 Terraform Configuration Files mod1/main.tf variable optional_input { default = 5 } output foo { value = var.optional_input / 5 } main.tf module mod...
• Best practices for setting default values for objects : r/Terraform | Posted by u/greenlakejohnny - 15 votes and 26 comments
• How to set a default value for a variable in a Terraform template ... | For setting a default value in something like Jinja2 I would use something like Hey {{ first_name|default(“there”, true) }} How would I achieve this in a Terraform template file?
• In terraform how to handle null value with default value? | Jhooq | Jun 19, 2023 ... To overcome the challenges posed by null values, Terraform provides mechanisms to assign default values to variables, ensuring that if a null ...
• Variables: NULL, empty string and default values - Terraform ... | Hello, I would like to use a default value when a variable is set to an empty string. Somehow I’m missing something obvious. Appreciate your input. Code: module: data "aws_key_pair" "EC2_Key" { ... key_name = var.key_name ... } Variable file: variable "key_name" { description = "The new keyname" default = "ID_EC2_DS" } The calling module: module "vm" { source = "..//modules/AWS/comp/ec2" key_name = var.key_name == "" ? null : var.key_name ... } C...
• Input Variables - Configuration Language | Terraform | HashiCorp ... | nullable - Specify if the variable can be null within the module. Default values. The variable declaration can also include a default argument. If present, the ...
• Is it possible to access the default value of a variable? - Terraform ... | I am configuring an existing module. The module that is being configured declares a variable x with default value v. I do expose the same variable in my configuration but I would only like to declare it if the value changes from its default. Trying the code below causes errors when the variable is not defined. module "mod" { source = "git://...." x = var.config.x } I would like x to be assigned if and only if I do have it declared in my config. Otherwise assign its default value. I...
• Terraform — for_each vs count.. Count | by Jacek Kikiewicz | Medium | Count