Arguments and expressions in Terraform - Deep Dive

Overview - Arguments and expressions

What is it?

Arguments and expressions in Terraform are ways to provide values and compute results within your infrastructure code. Arguments are like settings you give to resources or modules, while expressions are formulas or references that calculate values dynamically. Together, they let you customize and automate your cloud setup without hardcoding everything.

Why it matters

Without arguments and expressions, you would have to write fixed values everywhere, making your infrastructure rigid and hard to change. They solve the problem of flexibility and reuse, allowing you to adapt your cloud resources easily as needs evolve. This saves time, reduces errors, and helps manage complex environments efficiently.

Where it fits

Before learning arguments and expressions, you should understand basic Terraform concepts like resources and providers. After mastering them, you can explore advanced topics like modules, functions, and conditionals to build more powerful and reusable infrastructure code.

Mental Model

Core Idea

Arguments provide input values, and expressions compute or reference values dynamically to configure infrastructure flexibly.

Think of it like...

Arguments and expressions are like ingredients and recipes in cooking: arguments are the ingredients you choose, and expressions are the recipes that mix and adjust those ingredients to create different dishes.

Terraform Configuration
┌───────────────────────────────┐
│ Resource or Module Block       │
│ ┌───────────────┐             │
│ │ Arguments     │ ← Input values│
│ └───────────────┘             │
│ ┌───────────────┐             │
│ │ Expressions   │ ← Compute or │
│ │               │   reference  │
│ └───────────────┘             │
└───────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Terraform Arguments

Concept: Arguments are key-value pairs that configure resources or modules in Terraform.

In Terraform, when you define a resource like a virtual machine or a storage bucket, you provide arguments to specify details such as its name, size, or region. For example: resource "aws_instance" "example" { ami = "ami-123456" instance_type = "t2.micro" } Here, 'ami' and 'instance_type' are arguments with fixed values.

Result

Terraform knows what settings to apply to the resource based on the arguments you provide.

Understanding arguments is essential because they are the basic way to tell Terraform what you want to create or configure.

2

Foundation

What Are Expressions in Terraform

Concept: Expressions allow you to compute or reference values dynamically instead of using fixed values.

Instead of hardcoding values, expressions let you use variables, functions, or references. For example: variable "region" { default = "us-west-2" } resource "aws_instance" "example" { ami = "ami-123456" instance_type = "t2.micro" availability_zone = "${var.region}a" } Here, '${var.region}a' is an expression that combines the variable 'region' with the letter 'a'.

Result

Terraform calculates the final value for 'availability_zone' by combining parts dynamically.

Expressions make your infrastructure flexible and adaptable to changes without rewriting code.

3

Intermediate

Using Variables as Arguments

🤔Before reading on: do you think variables can only hold fixed values or can they also be computed dynamically? Commit to your answer.

Concept: Variables can be used as arguments to make configurations reusable and customizable.

Variables let you define placeholders for values that can change. You declare variables and then use them as arguments: variable "instance_type" { default = "t2.micro" } resource "aws_instance" "example" { ami = "ami-123456" instance_type = var.instance_type } You can override variables when running Terraform to create different setups without changing code.

Result

Terraform uses the variable value as the argument, allowing easy customization.

Knowing how to use variables as arguments unlocks the power of reusable and flexible infrastructure code.

4

Intermediate

Combining Expressions with Functions

🤔Before reading on: do you think Terraform functions can only transform strings or can they also handle lists and maps? Commit to your answer.

Concept: Terraform provides built-in functions to manipulate data within expressions for more complex logic.

Functions like 'join', 'length', and 'lookup' help process values: variable "subnets" { default = ["subnet-1", "subnet-2"] } output "subnet_count" { value = length(var.subnets) } output "subnet_list" { value = join(",", var.subnets) } Here, 'length' counts items, and 'join' creates a string from a list.

Result

Terraform outputs the number of subnets and a comma-separated list dynamically.

Understanding functions in expressions allows you to write smarter, data-driven infrastructure code.

5

Intermediate

Referencing Other Resources Dynamically

🤔Before reading on: do you think you can only use fixed values as arguments or can you reference other resources' attributes? Commit to your answer.

Concept: Expressions can reference attributes of other resources to create dependencies and dynamic configurations.

You can use expressions like 'resource_type.resource_name.attribute' to get values: resource "aws_vpc" "main" { cidr_block = "10.0.0.0/16" } resource "aws_subnet" "subnet1" { vpc_id = aws_vpc.main.id cidr_block = "10.0.1.0/24" } Here, 'aws_vpc.main.id' is an expression referencing the VPC's ID for the subnet's argument.

Result

Terraform links resources together automatically based on references.

Knowing how to reference other resources creates dynamic, connected infrastructure that adapts as components change.

6

Advanced

Conditional Expressions for Flexible Arguments

🤔Before reading on: do you think Terraform supports if-else logic inside arguments? Commit to your answer.

Concept: Terraform supports conditional expressions to choose argument values based on conditions.

You can write expressions like: variable "environment" { default = "dev" } resource "aws_instance" "example" { instance_type = var.environment == "prod" ? "m5.large" : "t2.micro" } This means if the environment is 'prod', use a bigger instance; otherwise, use a smaller one.

Result

Terraform sets the instance type based on the environment variable dynamically.

Conditional expressions let you write adaptable infrastructure that changes behavior without code duplication.

7

Expert

Complex Expressions and Lazy Evaluation

🤔Before reading on: do you think all expressions in Terraform are evaluated immediately or only when needed? Commit to your answer.

Concept: Terraform evaluates expressions lazily, meaning it computes values only when necessary, enabling complex dependencies and avoiding errors.

Expressions can include nested references, functions, and conditionals. Terraform builds a dependency graph and evaluates expressions in order. For example, you can write: resource "aws_instance" "example" { count = var.create_instance ? 1 : 0 ami = lookup(var.amis, var.region, "ami-default") } Here, 'count' controls resource creation, and 'lookup' safely gets an AMI ID. Terraform only evaluates these when applying, avoiding unnecessary errors if 'create_instance' is false.

Result

Terraform creates resources conditionally and resolves values safely at runtime.

Understanding lazy evaluation helps prevent common bugs and enables writing efficient, error-resistant infrastructure code.

Under the Hood

Terraform parses configuration files and builds a graph of resources and their dependencies. Arguments are stored as key-value pairs, while expressions are parsed and evaluated at runtime using Terraform's expression engine. This engine supports variables, functions, references, and conditionals, resolving values in dependency order. Lazy evaluation means expressions are only computed when needed, allowing conditional resource creation and avoiding errors from missing values.

Why designed this way?

Terraform was designed to manage complex infrastructure declaratively and safely. Arguments provide clear, explicit configuration, while expressions add flexibility without sacrificing readability. Lazy evaluation and dependency graphs ensure resources are created in the right order and only when necessary, preventing errors and improving performance. Alternatives like immediate evaluation or imperative scripting would be less safe and harder to maintain.

Terraform Configuration
┌───────────────────────────────┐
│ Configuration Files (.tf)      │
└──────────────┬────────────────┘
               │ Parse
               ▼
┌───────────────────────────────┐
│ Internal Graph Model           │
│ ┌───────────────┐             │
│ │ Arguments    │             │
│ │ (key-value)  │             │
│ └───────────────┘             │
│ ┌───────────────┐             │
│ │ Expressions  │             │
│ │ (variables,  │             │
│ │ functions)   │             │
│ └───────────────┘             │
└──────────────┬────────────────┘
               │ Evaluate (lazy)
               ▼
┌───────────────────────────────┐
│ Dependency Graph & Execution   │
│ Plan & Apply Resources         │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think Terraform expressions are always evaluated immediately when parsing? Commit to yes or no.

Common Belief: Terraform evaluates all expressions immediately when reading the configuration files.

Reality: Terraform evaluates expressions lazily during the planning and applying phases, not immediately at parse time.

Why it matters: Believing immediate evaluation leads to confusion about errors and resource dependencies, causing incorrect assumptions about when values are available.

Quick: Can you use any programming language expression inside Terraform arguments? Commit to yes or no.

Common Belief: You can write any programming language expression inside Terraform arguments.

Reality: Terraform expressions use a specific syntax and set of functions unique to Terraform, not general programming languages.

Why it matters: Trying to use unsupported syntax causes errors and frustration; understanding Terraform's expression language avoids this.

Quick: Do you think arguments must always be static values? Commit to yes or no.

Common Belief: Arguments must be fixed values and cannot depend on other resources or variables.

Reality: Arguments can be dynamic expressions referencing variables, other resources, or computed values.

Why it matters: Assuming static arguments limits flexibility and leads to repetitive, hard-to-maintain code.

Quick: Do you think conditional expressions can only be used in outputs, not in resource arguments? Commit to yes or no.

Common Belief: Conditional expressions cannot be used inside resource arguments.

Reality: Conditional expressions are fully supported inside resource arguments to control configuration dynamically.

Why it matters: Not using conditionals in arguments misses a powerful way to write adaptable infrastructure.

Expert Zone

1

Terraform's lazy evaluation means expressions referencing resources that may not be created yet do not cause errors until apply time, enabling complex conditional resource creation.

2

Expressions can combine multiple functions and references in nested ways, but excessive complexity can reduce readability and maintainability.

3

Terraform's expression language is intentionally limited to keep configurations declarative and predictable, avoiding side effects common in general programming languages.

When NOT to use

Arguments and expressions are not suitable when you need imperative logic or loops beyond what Terraform supports. In such cases, use external tools or scripts to generate Terraform code or use Terraform's 'for_each' and 'count' features carefully. Avoid complex expressions that reduce clarity; instead, break configurations into modules.

Production Patterns

In production, arguments and expressions are used to create reusable modules with variable inputs, conditional resource creation for different environments, and dynamic references to outputs from other modules or data sources. Experts use expressions to manage secrets securely, handle multi-region deployments, and optimize resource counts based on environment size.

Connections

Functional Programming

Terraform expressions share concepts with functional programming like pure functions and immutability.

Understanding functional programming helps grasp why Terraform expressions avoid side effects and focus on declarative value computation.

Spreadsheet Formulas

Terraform expressions work like spreadsheet formulas that compute values based on cell references and functions.

Knowing how spreadsheets calculate values dynamically helps understand Terraform's expression evaluation and dependency graph.

Cooking Recipes

Arguments and expressions relate to choosing ingredients and following recipes to create dishes.

This connection helps appreciate how inputs and dynamic combinations produce varied outcomes in infrastructure.

Common Pitfalls

#1 Using incorrect syntax for expressions causing Terraform to fail parsing.

Wrong approach:

resource "aws_instance" "example" {
instance_type = "${var.instance_type" # Missing closing brace
}

Correct approach:

resource "aws_instance" "example" {
instance_type = "${var.instance_type}"
}

Root cause:

Misunderstanding the required syntax for interpolation expressions leads to syntax errors.

#2 Hardcoding values instead of using variables or expressions, reducing flexibility.

Wrong approach:

resource "aws_instance" "example" {
instance_type = "t2.micro"
}

Correct approach:

variable "instance_type" {
default = "t2.micro"
}
resource "aws_instance" "example" {
instance_type = var.instance_type
}

Root cause:

Not realizing the benefit of variables and expressions for reusable and adaptable configurations.

#3 Referencing a resource attribute before the resource is created, causing errors.

Wrong approach:

resource "aws_subnet" "subnet1" {
vpc_id = aws_vpc.main.id
cidr_block = "10.0.1.0/24"
}
resource "aws_vpc" "main" {
cidr_block = "10.0.0.0/16"
}

Correct approach:

resource "aws_vpc" "main" {
cidr_block = "10.0.0.0/16"
}
resource "aws_subnet" "subnet1" {
vpc_id = aws_vpc.main.id
cidr_block = "10.0.1.0/24"
}

Root cause:

Incorrect resource order causes Terraform to fail resolving dependencies.

Key Takeaways

Arguments are the input settings you provide to Terraform resources and modules to define their configuration.

Expressions let you compute or reference values dynamically, making your infrastructure flexible and reusable.

Terraform evaluates expressions lazily, resolving dependencies and values only when needed during planning and applying.

Using variables, functions, and references in expressions helps avoid hardcoding and supports adaptable infrastructure.

Understanding arguments and expressions is essential to writing clear, maintainable, and powerful Terraform configurations.