Terraform Coalesce vs Try: Error Handling with Practical Examples

Estimated reading time: 6 minutes

Last updated on October 25th, 2024 at 02:59 pm

Terraform is an open-source infrastructure as a code (IaC) to define and provision the infrastructure using the simple configuration file.

You can write the whole infrastructure as code and run the terraform plan and terraform apply to provision it. Let’s explore the Terraform Coalesce vs Try function with a practical example.

Understanding Terraform Functions

Terraform provides the built-in function to operate on various data types. They help to dynamically manipulate and transform the data to manage the configuration easily.

Commonly Used Terraform Functions

Commonly used function in Terraform:

Coalesce Function

What is the coalesce Function?

The coalesce function used to return the first non-null argument from the provided list of arguments. It is useful when you define the value for the multiple optional variables or handle the missing value in the data source.

Syntax and Usage

Syntax:

coalesce(val1, val2, ...)

Example:

# Define the primary region variable, allowing user input or leaving it null
variable "primary_region" {
  description = "The primary AWS region to use"
  type        = string
  default     = null
}

# Define the default region
variable "default_region" {
  description = "The default AWS region to use if primary region is not set"
  type        = string
  default     = "us-east-1"
}

# Determine the AWS region using the coalesce function
locals {
  aws_region = coalesce(var.primary_region, var.default_region)
}

# Output the selected AWS region
output "selected_region" {
  value = local.aws_region
}

Output:

selected_region = "us-east-1"

In this example, if the user doesn’t define the var.primary_region value, terraform will use the var.default_region and value will be us-east-1.

Use Cases for coalesce:

• Setting default values for optional variables.
• Handle the missing attribute in the data source.
• Simplify the conditional logic with a fallback default value.

Limitation of coalesce:

• It only works with the string and can’t handle complex data types.
• If all arguments are null or empty, Terraform will throw an error.
• Error handling is not implemented.

Try Function

The try function evaluates the given expression in order and returns the result of the first expression that does not produce the error.

In Terraform Coalesce vs Try, coalesce function can’t handle the error if all the values are empty. But with the try function it attempts to evaluate the expression and falls back to the default if the expression fails.

Syntax and Usage

Syntax:

try(expr1, expr2, ...)

Example:

# Define the primary region variable, allowing user input or leaving it null
variable "primary_region" {
  description = "The primary AWS region to use"
  type        = string
  default     = null
}

# Define the default region
variable "default_region" {
  description = "The default AWS region to use if primary region is not set"
  type        = string
  default     = "us-east-1"
}

# Determine the AWS region using the try function
locals {
  aws_region = try(var.primary_region, var.default_region)
}

# Output the selected AWS region
output "selected_region" {
  value = local.aws_region
}

Output:

selected_region = "us-east-1"

Use Cases for try:

• Handle errors gracefully when encountering unexpected issues.
• Exception handles and catches errors during data manipulation.

Limitation of try:

• The try the function can only catch and handle dynamic errors.
• Can’t handle the error related to the expression such as invalid input or wrong resource reference.

Terraform Coalesce vs Try: Choose the Right Tool

Similarities: Terraform Coalesce vs Try

Both Terraform function coalesce and try allow for fallback to the default value and manage the optional or undefined variable efficiently.

Key Differences: Terraform Coalesce vs Try

• Use coalesce for setting the default values and handling missing data.
• Use try for error handling and fallback gracefully.

Terraform Coalesce vs Try: Practical Example

Example 1: Default VPC for an EC2 Instance

If you launch an EC2 instance, the VPC might be a variable or module output. Use coalesce to make the valid VPC always available.

variable "vpc_id" {
  type     = string
  default  = "us-east-1"
}

module "vpc" {
  # Output the VPC ID from the VPC module
  outputs {
    vpc_id  = data.aws_vpc.main.id
  }
}

resource "aws_instance" "web_server" {
  # Use coalesce to ensure a VPC ID is always provided
  vpc_id   = coalesce(var.vpc_id, module.vpc.outputs.vpc_id)
}

In this example:

• var.vpc_id is default and allows the user to override.
• coalesce checks the var.vpc_id first and if empty, it used the value from the vpc module.
• Using coalesce make sure that the EC2 instance has a valid VPC.

Example 2: Handle Missing Tags in Data Sources

Another use case is if you have an AWS S3 bucket with missing tags, you can write below Terraform to handle the missing tags:

data "aws_s3_bucket" "bucket" {
  bucket = "bucket-name"
}

output "bucket_versioning_enabled" {
  value = coalesce(data.aws_s3_bucket.bucket.versioning.enabled, "false")
}

Using the coalesce ensure that it will keep the bucket version as it is but if the value is missing use the default value false

Example 3: Use Try to manage Error Gracefully

variable "optional" {
  default = null
}

output "try_example" {
  value = try(var.optional["nonexistent_key"], "fallback-value")
}

Terraform Coalesce vs Try: Best Practices

• Use coalesce with a combination of null checks for error handling.
• Ensure that expression in coalesce will return a non-null value first.
• Use try to handle complex logic and take action based on success or failure.
• try handle the errors but using it in critical applications can be hard to understand and maintain. Don’t overuse it.

Conclusion

We’ve discussed the common Terraform built-in functions such as merge, lookup, and concate the detailed usage and comparison of Terraform Coalesce vs Try.

Remember use coalesce as your default for handling optional values, and try to handle runtime values where you can face unexpected cases.