Using Built In Functions to Standardize Code

In this lesson you’ll learn how Terraform’s built-in functions help standardize infrastructure code. By applying these small but powerful helpers—for strings, numbers, collections, and network math—you can eliminate repetitive configuration, enforce consistent naming and sizing patterns across environments, and reduce human error. Whether you need to concatenate resource names, compute subnet ranges, or convert between collection types for reliable iteration, mastering a core set of functions makes Terraform configurations more maintainable, readable, and portable.

Function categories and syntax

Terraform functions follow a consistent, predictable syntax: function_name(argument1, argument2, …) They accept one or more arguments and return a computed value. In practice you will usually pass variables, locals, or data source attributes into functions instead of hard-coded literals. Examples:

# string -> uppercase string
upper("hello")           # => "HELLO"

# numeric -> minimum of the provided values
min(4, 7, 2, 9, 5)       # => 2

# join: concatenates strings with a separator
join("-", ["hello", "terraform"])  # => "hello-terraform"

Common function categories:

Category	Purpose	Typical use
Numeric functions	Compute or compare numbers	Select CPU/memory sizes with `max()`/`min()`
String functions	Build consistent resource names, encode user data	`join()`, `replace()`, `base64encode()`
Network (CIDR) helpers	Subnet math and host IP selection	`cidrsubnet()` and `cidrhost()`
Type conversion & collection helpers	Ensure types for iteration and lookups	`tolist()`, `toset()`, `tomap()`, `distinct()`

Numeric functions

Numeric helpers are useful for resource sizing, capacity planning, and simple arithmetic without hard-coding values. Common functions:

max(…) — returns the largest numeric argument
min(…) — returns the smallest numeric argument
floor(…) — round down to nearest integer
ceil(…) — round up to nearest integer

Examples:

# Max: Returns the highest value in a list of numbers
max(10, 4, 7)         # => 10

# Min: Returns the lowest value in a list of numbers
min(10, 4, 7)         # => 4

# Using a variable inside a function:
variable "number" {
  type    = number
  default = 15
}

# max will compare 10, 4, and var.number (15) and return 15
max(10, 4, var.number)  # => 15

Use these when selecting instance sizes, setting thresholds, or applying simple dynamic scaling logic across environments.

String functions

String manipulation is essential for building resource names, templating startup scripts, or encoding user data consistently. Common string functions:

join(separator, list) — concatenates a list of strings
split(separator, string) — splits a string into a list
upper(string) / lower(string) — change case
replace(string, search, replace) — substitute substrings
base64encode(string) — encode a string to Base64 (useful for user data)

Examples:

# Join: Concatenates a list of strings into a single string.
join("-", ["prod", "web", "us-west-1"])         # => "prod-web-us-west-1"

# upper / lower: Converts a string to uppercase/lowercase
upper("example")                                # => "EXAMPLE"
lower("HELLO")                                  # => "hello"

# replace: Substitutes part of a string with another value
replace("123-abc", "abc", "xyz")                # => "123-xyz"

# base64encode: Encodes a string to Base64 (useful for user data)
base64encode("my-secret-data")                  # => "bXktc2VjcmV0LWRhdGE="

Using string functions enforces naming conventions, prevents accidental tag mismatches, and centralizes transformation logic.

Network functions (CIDR helpers)

Terraform includes CIDR helpers so you can programmatically calculate subnets and host IPs instead of performing error-prone manual math. Key functions:

cidrsubnet(prefix, newbits, netnum) — extend prefix length by newbits, then select netnum-th subnet
cidrhost(prefix, hostnum) — return a single host IP within the given CIDR

Example: carve multiple /19 subnets from a VPC /16

# Create a VPC with a /16 CIDR
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

# Create a public subnet in the first available range (/19)
resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  availability_zone = "us-east-1a"
  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 3, 0)
}

# Create a private subnet in the second available range (/19)
resource "aws_subnet" "private" {
  vpc_id            = aws_vpc.main.id
  availability_zone = "us-east-1b"
  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 3, 1)
}

Adding 3 bits to a /16 produces /19 subnets; the final argument (0, 1, …) selects each /19. Use cidrhost() similarly to derive a specific host address inside a CIDR block.

Type conversion and collection helpers

Conversion functions ensure data structures are in the correct format for iteration, lookups, and uniqueness rules. Common conversions:

tolist(…) — convert to list
toset(…) — convert to set (enforces uniqueness)
tomap(…) — convert to map
tostring(…) — convert to string
distinct(list) — remove duplicates while preserving first-seen order
tonumber(string) — convert string to number

A practical pattern: convert an availability zone list into a map keyed by index so you can iterate with both a stable index and the AZ value:

variable "availability_zones" {
  type    = list(string)
  default = ["us-east-1a", "us-east-1a", "us-east-1b"]
}

# Remove duplicates while preserving the original order, then create a map with string keys
locals {
  unique_list = distinct(var.availability_zones)
  indexed_azs = { for idx, az in local.unique_list : tostring(idx) => az }
}

resource "aws_subnet" "example" {
  for_each = local.indexed_azs

  vpc_id            = aws_vpc.main.id
  availability_zone = each.value
  # each.key is a string like "0", "1" — convert to number when passing to cidrsubnet
  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 2, tonumber(each.key))
}

This pattern:

ensures uniqueness via distinct()
preserves predictable ordering
exposes an index (converted back to a number with tonumber(each.key)) for use with cidrsubnet

Tip: Prefer distinct() when you need to remove duplicate values but keep the original ordering. Use toset() when order doesn’t matter and you only care about uniqueness.

Watch out for type mismatches (e.g., passing a list where a map is expected). Use tolist(), tomap(), or tostring() explicitly to avoid errors in expressions and for_each.

Summary

Built-in Terraform functions let you:

Reduce repetition and enforce consistent naming, tagging, and sizing
Convert safely between collection types (lists, sets, maps) for predictable iteration
Avoid manual network math with CIDR helpers like cidrsubnet() and cidrhost()
Encode and transform strings (e.g., base64encode()) for user data and configuration

Mastering a core subset—numeric, string, CIDR, and conversion functions—makes your Terraform code cleaner, safer, and easier to reuse. For the full catalog and advanced use cases, see the official documentation: https://developer.hashicorp.com/terraform/language/functions So that’s it for this lesson.

Course Introduction

Preparing Your Environment

Terraform Foundations

The Core Terraform Workflow

Terraform CLI

Terraform File Structure and Organization

Terraform Configuration - Fundamentals

Understading and Managing Terraform State

Marking Code Reusable

Refactoring Terraform State

Terraform Modules

Managing Resource Behavior and Dependencies

Securing Terraform Configurations

Terraform Troubleshooting

HCP Terraform

Using Built In Functions to Standardize Code

Function categories and syntax

Numeric functions

String functions

Network functions (CIDR helpers)

Type conversion and collection helpers

Summary

Watch Video

Practice Lab

​Function categories and syntax

​Numeric functions

​String functions

​Network functions (CIDR helpers)

​Type conversion and collection helpers

​Summary

Watch Video

Practice Lab

Function categories and syntax

Numeric functions

String functions

Network functions (CIDR helpers)

Type conversion and collection helpers

Summary