Introduction
In this part, we’ll explore some advanced features of Terraform. You’ll learn about variable types, constructs like for_each, and how to use dynamic blocks to make your Terraform code cleaner and less verbose.
Introduction to Variables
Just like other programming languages, Terraform’s HCL (HashiCorp Configuration Language) supports variables and data types.
Modules and resource blocks often accept arbitrary user inputs. The best practice is to define variables in a terraform.tfvars file, which supplies values to Terraform during runtime.
Let’s start with a simple example.
Example Usage
We’ll create a Terraform project that provisions an S3 bucket. This project will include the following files:
.
├── backend.tf
├── main.tf
├── terraform.tfvars
└── variables.tf
main.tf
This file defines the S3 bucket and uses variables via the syntax var.variable_name.
provider "aws" {
profile = var.profile
region = var.region
}
resource "aws_s3_bucket" "testbucket" {
bucket = var.bucket_name
}
variables.tf
Here we declare the variables used in the project:
variable "region" {
type = string
default = "us-east-1"
}
variable "profile" {
type = string
default = "profile-name-to-use"
}
variable "bucket_name" {
type = string
description = "Name of S3 bucket to create"
}
You can also mark variables as sensitive or add validation rules for stricter control.
This file assigns values to the declared variables:
bucket_name = "test_bucket"
Here’s a typical Terraform workflow:
terraform init # Initialize backend and providers
terraform fmt # Format code
terraform validate # Validate for syntax errors
terraform plan # Preview changes
terraform apply # Apply changes
terraform destroy # Destroy resources
Types of Variables
Terraform supports two broad categories of variables:
1. Primitives:string, boolean, number
2. Complex:set, map, object, tuple, list, any
Here’s an example of a complex variable definition:
variable "igress_params" {
type = map(object({
port = number
proto = string
cidr = list(string)
}))
default = {
"rule1" = {
port = 22
proto = "tcp"
cidr = ["0.0.0.0/0"]
},
"rule2" = {
port = 80
proto = "tcp"
cidr = ["1.2.3.4/32"]
}
}
}
This map(object) variable defines ingress rules that you can later reference while creating security groups or VPCs.
Introduction to for_each
The for_each construct is useful when you want to create multiple resources of the same type with varying values. For example, creating three S3 buckets for dev, uat, and prod.
provider "aws" {
profile = "aws-profile-to-use"
region = "us-east-1"
}
variable "s3_buckets" {
type = set(string)
description = "Name of S3 buckets to create"
default = ["test-dev", "test-uat", "test-prod"]
}
resource "aws_s3_bucket" "testbucket" {
for_each = var.s3_buckets
bucket = each.value
}
Terraform will iterate through s3_buckets and create three separate S3 buckets.
The dynamic Keyword
When defining resources like security groups, you might need multiple ingress or egress rules. Manually declaring them can get verbose and hard to maintain.
Without Dynamic Blocks
resource "aws_security_group" "my-sg" {
vpc_id = aws_vpc.my-vpc.id
ingress {
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
ingress {
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
}
This approach quickly becomes messy for many rules.
With Dynamic Blocks
We can make this clean and reusable using the dynamic keyword.
variable "igress_params" {
type = map(object({
port = number
proto = string
cidr = list(string)
}))
default = {
"rule1" = {
port = 22
proto = "tcp"
cidr = ["0.0.0.0/0"]
},
"rule2" = {
port = 80
proto = "tcp"
cidr = ["1.2.3.4/32"]
}
}
}
resource "aws_vpc" "my-vpc" {
cidr_block = "10.0.0.0/16"
}
resource "aws_security_group" "my-sg" {
vpc_id = aws_vpc.my-vpc.id
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
dynamic "ingress" {
for_each = var.igress_params
content {
from_port = ingress.value["port"]
to_port = ingress.value["port"]
protocol = ingress.value["proto"]
cidr_blocks = ingress.value["cidr"]
}
}
}
Terraform will iterate through each map entry in igress_params and dynamically create multiple ingress blocks — one for each rule.
Key benefit: Your Terraform files stay concise, and you can easily scale your configuration by just editing variable definitions.
In Summary
Dynamic blocks and constructs like for_each bring programmability and flexibility into Terraform — reducing code repetition while improving readability and scalability.
