Variable Types and Validation

Terraform has a real type system — primitives (string, number, bool), collections (list, set, map), and structural types (object, tuple) — plus validation blocks that reject bad input before any apply runs. Strong types and validation turn a module into a contract: callers get an immediate, clear error instead of a confusing failure 40 resources deep into an apply.

The payoff is moving failures left. A string typed as a string accepts anything; an object with validation accepts exactly the shape you meant. The difference between those two is whether a caller's mistake surfaces at plan time with a sentence telling them what's wrong, or at apply time as a cryptic provider error after half the stack already changed.

Primitive and Collection Types

The primitives are string, number, and bool. The collections wrap a single element type: list(string) is ordered and allows duplicates, set(string) is unordered and deduplicated, and map(string) is key-value with named access. The choice is not cosmetic — it changes how the value behaves in a plan and how you access it.

variable "desired_count" {
  type = number
}

variable "availability_zones" {
  type = list(string)
}

variable "resource_tags" {
  type = map(string)
}

Structural Types

An object({...}) describes a value with named attributes of mixed types, and optional() marks an attribute the caller may omit, supplying a default when they do. This is how a module accepts one richly-shaped input instead of a dozen loose variables. The block below takes a single app_config object where instance_type defaults to t3.micro if the caller leaves it out.

variable "app_config" {
  type = object({
    name          = string
    instance_type = optional(string, "t3.micro")
    min_size      = number
    public        = optional(bool, false)
  })
}

Validation Blocks

A validation block runs a condition against the input and, if it fails, halts the plan with your error_message. Use it for ranges, allowed values, and formats — anything where a wrong value is knowable before apply. The validation below rejects an environment that isn't one of three allowed strings, and the message tells the caller exactly what's valid.

variable "environment" {
  type = string
  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "environment must be one of: dev, staging, prod."
  }
}

Type Conversion and Nullability

Terraform converts between compatible types automatically — a number flows into a string context, a list converts to a set — and the surprises come when an implicit conversion isn't the one you expected, like a number-as-string comparison that never matches. By default a variable may be null; setting nullable = false forbids it, and optional() with a default sidesteps the null question entirely for object attributes.