Count and for_each

mkdir terraform-lesson-22
cd terraform-lesson-22
touch versions.tf variables.tf main.tf outputs.tf .gitignore

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

variable "bucket_names" {
  description = "List of S3 bucket name suffixes to create"
  type        = list(string)
  default     = ["alpha", "beta", "gamma"]  # Three buckets — we'll remove beta to demo instability
}

variable "environment" {
  description = "Deployment environment"
  type        = string
  default     = "dev"
}

# Three buckets created using count — identified by index position
resource "aws_s3_bucket" "count_demo" {
  count = length(var.bucket_names)  # Creates one bucket per item in the list

  # element() retrieves the name at the current index
  bucket = "lesson22-count-${element(var.bucket_names, count.index)}-${var.environment}"

  tags = {
    Name      = "lesson22-count-${element(var.bucket_names, count.index)}"
    Index     = count.index    # Track which index owns this bucket
    ManagedBy = "Terraform"
  }
}

# Apply with all three buckets
terraform apply

# Updated variables.tf — map instead of list
variable "buckets" {
  description = "Map of bucket key to configuration object"
  type = map(object({
    suffix      = string  # Name suffix for the bucket
    environment = string  # Environment tag value
  }))
  default = {
    alpha = { suffix = "alpha", environment = "dev"  }
    beta  = { suffix = "beta",  environment = "dev"  }
    gamma = { suffix = "gamma", environment = "prod" }  # Gamma is prod, others are dev
  }
}

# main.tf — for_each with a map of objects
resource "aws_s3_bucket" "foreach_demo" {
  for_each = var.buckets  # Map drives for_each — each.key is "alpha", "beta", or "gamma"

  bucket = "lesson22-foreach-${each.value.suffix}-${each.value.environment}"

  tags = {
    Name        = "lesson22-foreach-${each.key}"    # Key used as stable identifier
    Environment = each.value.environment             # Value field from the object
    ManagedBy   = "Terraform"
  }
}

terraform apply

# Now remove beta — update variables.tf to remove the beta entry
# default = {
#   alpha = { suffix = "alpha", environment = "dev"  }
#   gamma = { suffix = "gamma", environment = "prod" }
# }

terraform plan

# moves.tf — safe conversion from count to for_each
# Step 1: add these moved blocks BEFORE changing the resource block

# Map each count index to its corresponding for_each key
moved {
  from = aws_s3_bucket.count_demo[0]      # Old count-indexed address
  to   = aws_s3_bucket.foreach_demo["alpha"]  # New for_each-keyed address
}

moved {
  from = aws_s3_bucket.count_demo[1]
  to   = aws_s3_bucket.foreach_demo["beta"]
}

moved {
  from = aws_s3_bucket.count_demo[2]
  to   = aws_s3_bucket.foreach_demo["gamma"]
}

# Step 2: update the resource block — remove count, add for_each
# Step 3: terraform plan — should show only moves, zero destroys
# Step 4: terraform apply
# Step 5: remove the moved blocks after successful apply

# locals.tf — for expressions demonstrated in locals (best practice for complex transforms)

locals {
  # Transform a simple list into a map for use with for_each
  # Input: ["alpha", "beta", "gamma"]
  # Output: { "alpha" = "alpha", "beta" = "beta", "gamma" = "gamma" }
  bucket_map = { for name in var.bucket_names : name => name }

  # Filter the map to only include prod-environment buckets
  # Input: { alpha = {...dev}, beta = {...dev}, gamma = {...prod} }
  # Output: { gamma = {...prod} }
  prod_buckets = {
    for key, config in var.buckets : key => config
    if config.environment == "prod"  # Only include entries where environment is prod
  }

  # Build a flat list of all bucket names from the foreach_demo resource
  # Converts the map result (keyed by "alpha", "beta", etc.) into a plain list of names
  all_bucket_names = [
    for key, bucket in aws_s3_bucket.foreach_demo : bucket.bucket
  ]

  # Transform a list of names to uppercase — demonstrates list for expression
  bucket_names_upper = [
    for name in var.bucket_names : upper(name)  # upper() converts string to uppercase
  ]

  # Merge environment-specific tags with common tags for each bucket
  # Creates a map of key => tags_map
  bucket_tags = {
    for key, config in var.buckets : key => merge(
      {
        Name      = "lesson22-${key}"
        ManagedBy = "Terraform"
      },
      { Environment = config.environment }  # Each bucket gets its own environment tag
    )
  }
}

# Explore the for expressions in terraform console
terraform console

variable "enable_monitoring" {
  description = "Enable enhanced CloudWatch monitoring — prod only, costs extra"
  type        = bool
  default     = false  # Off by default — enable explicitly in prod tfvars
}

variable "environment" {
  description = "Deployment environment"
  type        = string
  default     = "dev"
}

# S3 bucket that always exists
resource "aws_s3_bucket" "app_data" {
  bucket = "lesson22-app-data-${var.environment}"

  tags = {
    Environment = var.environment
    ManagedBy   = "Terraform"
  }
}

# Conditional resource — only exists when enable_monitoring is true
# count = 1 creates it, count = 0 does not
resource "aws_s3_bucket_intelligent_tiering_configuration" "app_data" {
  count = var.enable_monitoring ? 1 : 0  # Ternary — 1 if true, 0 if false

  bucket = aws_s3_bucket.app_data.bucket  # References the always-existing bucket
  name   = "EntireS3Bucket"

  tiering {
    access_tier = "DEEP_ARCHIVE_ACCESS"
    days        = 180  # Move objects to deep archive after 180 days
  }
}

# Conditional resource using for_each pattern — cleaner for complex conditionals
# Local computes an empty or populated map based on conditions
locals {
  # Only create monitoring config for prod environments with monitoring enabled
  monitoring_config = var.environment == "prod" && var.enable_monitoring ? {
    "primary" = { tier = "DEEP_ARCHIVE_ACCESS", days = 180 }
  } : {}  # Empty map = zero resources created
}

resource "aws_s3_bucket_intelligent_tiering_configuration" "conditional" {
  for_each = local.monitoring_config  # Empty map = no resources

  bucket = aws_s3_bucket.app_data.bucket
  name   = "Conditional-${each.key}"

  tiering {
    access_tier = each.value.tier
    days        = each.value.days
  }
}

# Output that safely handles count = 0 using one()
output "tiering_id" {
  description = "ID of the tiering config if it exists, null if monitoring is disabled"
  value       = one(aws_s3_bucket_intelligent_tiering_configuration.app_data[*].id)
  # [*] splat returns a list — one() extracts single item or returns null
}