🚀 Day 07 – Mastering Terraform Variable Type Constraints

Variables are central to making Terraform configurations flexible, reusable, and safe. On this day I learned about primitive types (string, number, bool), complex types (list, set, map, tuple, object), and how to use them — with validation — to build clean infrastructure code.

Below is what I learned, how types differ, and 10 conceptual tasks that illustrate how each type can be used in real-world AWS infrastructure definitions (with mini code examples).

🔹 Why Variable Type Constraints Matter

Terraform variables help avoid hard-coding values. Instead of embedding static values in configuration, you declare variables using variable blocks — which let you pass data at runtime or reuse the configuration across environments. HashiCorp Developer+2HashiCorp Developer+2

Specifying a type constraint ensures Terraform validates that the provided value matches expected structure. This reduces errors, enforces consistency, and makes modules safer and more maintainable. HashiCorp Developer+2Env0+2

When infrastructure grows (multiple environments, many resources), types + validation + organized variables make configuration manageable.

---

🧠 Terraform Variable Types Overview

Terraform supports different variable types:

✅ Primitive Types

• string: textual values (e.g. "${var.environment}-app")

• number: integers or floats (e.g. instance counts, sizes)

• bool: true/false flags (e.g. enable monitoring) Medium+1

✅ Collection & Structural Types

• list(type) — ordered collection of same-type elements

• set(type) — unordered no-duplicate collection (unique values)

• map(type) — key → value pairs with string keys

• tuple([type1, type2, ...]) — ordered, fixed-structure collection (types of elements defined)

• object({key1=type1, key2=type2, ...}) — structured object with named attributes of defined types HashiCorp Developer+2Medium+2

Collections & structural types let you represent more complex data — tags, lists of subnets, security group settings, configuration objects etc.

---

🎯 Day 07 – 10 Conceptual Tasks & Mini Code Examples

Here are 10 tasks (as in challenge) along with example Terraform snippets demonstrating each type’s usage.

Task 1 — String Constraint (environment, region)

Use string variables to set AWS provider region and naming conventions.

variable "environment" { type = string, default = "dev" }
variable "region"      { type = string, default = "us-east-1" }

provider "aws" {
  region = var.region
}

resource "aws_s3_bucket" "app_bucket" {
  bucket = "${var.environment}-terraform-bucket"
}

---

Task 2 — Number Constraint (instance_count)

Use number to create a variable number of EC2 instances.

variable "instance_count" { type = number, default = 2 }

resource "aws_instance" "web" {
  count         = var.instance_count
  ami           = "ami-xyz"
  instance_type = "t2.micro"
}

---

Task 3 — Boolean Constraint (monitoring_enabled, associate_public_ip)

Use bool to toggle resource parameters.

variable "monitoring_enabled"    { type = bool, default = true }
variable "associate_public_ip"   { type = bool, default = true }

resource "aws_instance" "server" {
  ami                         = "ami-xyz"
  instance_type               = "t2.micro"
  monitoring                  = var.monitoring_enabled
  associate_public_ip_address = var.associate_public_ip
}

---

Task 4 — List(string) Constraint (cidr_block list)

Use a list of strings for ordered configuration like VPC + subnets.

variable "cidr_block" {
  type    = list(string)
  default = ["10.0.0.0/8", "192.168.0.0/16", "172.16.0.0/12"]
}

resource "aws_vpc" "main" {
  cidr_block = var.cidr_block[0]
}

resource "aws_subnet" "subnet1" {
  cidr_block = var.cidr_block[1]
}

resource "aws_subnet" "subnet2" {
  cidr_block = var.cidr_block[2]
}

---

Task 5 — List(string) Constraint (allowed_vm_types validation)

Use list to validate allowed VM types.

variable "allowed_vm_types" {
  type    = list(string)
  default = ["t2.micro", "t2.small", "t3.micro", "t3.small"]
}

variable "instance_type" {
  type = string

  validation {
    condition     = contains(var.allowed_vm_types, var.instance_type)
    error_message = "Instance type is not allowed!"
  }
}

---

Task 6 — Set(string) Constraint (allowed_region validation)

Use set to define allowed regions (unordered, unique) and validate region variable.

variable "allowed_region" {
  type    = set(string)
  default = ["us-east-1", "us-west-2", "eu-west-1"]
}

variable "region" {
  type = string

  validation {
    condition     = contains(var.allowed_region, var.region)
    error_message = "Region is not supported!"
  }
}

---

Task 7 — Map(string) Constraint (tags)

Pass tags as a map to an AWS resource.

variable "tags" {
  type = map(string)
  default = {
    Environment = "dev"
    Name        = "dev-resource"
    created_by  = "terraform"
  }
}

resource "aws_vpc" "example" {
  cidr_block = "10.0.0.0/16"
  tags       = var.tags
}

output "resource_name" {
  value = var.tags["Name"]
}

---

Task 8 — Tuple Constraint (ingress_values)

Use tuple to define structured ingress rule parameters.

variable "ingress_values" {
  type    = tuple([number, string, number])
  default = [443, "tcp", 443]
}

resource "aws_security_group" "web_sg" {
  ingress {
    from_port   = var.ingress_values[0]
    protocol    = var.ingress_values[1]
    to_port     = var.ingress_values[2]
    cidr_blocks = ["0.0.0.0/0"]
  }
}

---

Task 9 — Object Constraint (config object)

Use object type to group multiple settings into one variable.

variable "config" {
  type = object({
    region         = string
    monitoring     = bool
    instance_count = number
  })
  default = {
    region         = "us-east-1"
    monitoring     = true
    instance_count = 1
  }
}

provider "aws" {
  region = var.config.region
}

resource "aws_instance" "app" {
  count   = var.config.instance_count
  ami     = "ami-xyz"
  monitoring = var.config.monitoring
  instance_type = "t2.micro"
}

---

Task 10 — Mixed Type Constraints & Deployment Summary Output

Combine different types into a deployment summary output.

output "deployment_summary" {
  value = {
    environment     = var.environment
    instance_count  = var.instance_count
    name_tag        = var.tags["Name"]
  }
}

---

🧠 My Day 07 Key Learnings

• Declaring types for input variables makes configurations safer and clearer. HashiCorp Developer+2HashiCorp Developer+2

• Collection & structural types (list, set, map, tuple, object) allow modeling complex data — helpful for tags, subnets, security rules, environment configs.

• Using validation blocks or contains() guards helps enforce business rules and prevent misconfigurations (e.g. invalid regions or wrong VM types).

• Good variable design + type constraints improves reusability and maintainability — essential for larger infrastructure. DevOpsCube+2Brainboard Blog+2

---

📺 Video (Day 07)

[Embedded YouTube Video]

https://youtu.be/gu2oCJ9DQiQ?si=uJ4SXbdx3uA2roBp

---

✅ Conclusion

Day 07 transformed my understanding: from simple hard-coded configs to flexible, validated, and scalable Terraform setups. Now I’m ready to build robust infrastructure with confidence.
Up for Day 08! 🚀

---