【保存版】Terraformのfor_eachを完全解説！7つの実践的ユースケースとベストプラクティス

SHARE

目次

目次へ

Terraformのfor_eachとは？初心者にもわかりやすく解説

for_eachの基本概念と動作原理

Terraformのfor_eachは、同じリソースを複数作成する際に使用する強力な機能です。マップ（キーと値のペア）またはセット（ユニークな値の集合）を元に、リソースやモジュールを動的に作成することができます。

for_eachの基本的な構文は以下のようになります：

resource "aws_instance" "server" {
  for_each = toset(["web", "app", "db"])

  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "server-${each.value}"
  }
}

このコードでは：

  • for_each = toset(["web", "app", "db"]): 3つの異なるサーバーを作成
  • each.value: 現在の要素の値を参照（この場合は”web”、”app”、”db”）
  • each.key: セットの場合、valueと同じ値。マップの場合はキーの値を参照

for_eachの特徴：

  1. 型安全性: 実行前に要素の存在が保証される
  2. 識別子の明確さ: 各リソースが一意の識別子を持つ
  3. 柔軟な更新: 個別のリソースの追加・削除が容易
  4. 依存関係の管理: リソース間の依存関係が明確

countとの違いと使い分けポイント

for_eachとcountは、どちらも複数のリソースを作成できますが、重要な違いがあります：

機能for_eachcount
識別子キーベース（明確）インデックスベース（位置依存）
要素の追加・削除他の要素に影響なしインデックスがずれる可能性あり
適している用途個別の設定が必要なリソース同一設定の繰り返し
値の参照方法each.key, each.valuecount.index

具体的な使い分け例：

# for_eachが適している例（異なる設定のEC2インスタンス）
resource "aws_instance" "servers" {
  for_each = {
    web = {
      type = "t2.micro"
      zone = "ap-northeast-1a"
    }
    app = {
      type = "t2.small"
      zone = "ap-northeast-1b"
    }
  }

  ami               = "ami-0c55b159cbfafe1f0"
  instance_type     = each.value.type
  availability_zone = each.value.zone

  tags = {
    Name = "server-${each.key}"
  }
}

# countが適している例（同一設定の複数インスタンス）
resource "aws_instance" "workers" {
  count = 3

  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "worker-${count.index + 1}"
  }
}

for_eachを使うべき状況：

  • リソースごとに異なる設定が必要な場合
  • リソースの追加・削除が頻繁に発生する可能性がある場合
  • リソース間の依存関係が複雑な場合
  • 設定値をキーと値のペアで管理したい場合

countを使うべき状況：

  • 完全に同一の設定で複数のリソースを作成する場合
  • 単純な連番での識別で十分な場合
  • リソースの数が固定的で、変更が少ない場合

この基本的な違いを理解することで、プロジェクトの要件に応じて適切な方法を選択できます。

for_eachを使う前に押さえておきたい前提知識

マップとセットの基本的な扱い方

for_eachを効果的に使用するためには、Terraformにおけるマップ（map）とセット（set）の概念を理解することが重要です。

マップ（Map）の基本

マップは、キーと値のペアを持つデータ構造です。

# マップの基本的な定義
variable "instance_configs" {
  type = map(object({
    instance_type = string
    subnet_id     = string
    environment   = string
  }))

  default = {
    "web" = {
      instance_type = "t2.micro"
      subnet_id     = "subnet-123"
      environment   = "prod"
    }
    "app" = {
      instance_type = "t2.small"
      subnet_id     = "subnet-456"
      environment   = "prod"
    }
  }
}

# マップの値へのアクセス方法
locals {
  web_instance_type = var.instance_configs["web"].instance_type
}

セット（Set）の基本

セットは、重複のない値のコレクションです。

# セットの定義
variable "availability_zones" {
  type    = set(string)
  default = ["ap-northeast-1a", "ap-northeast-1c", "ap-northeast-1d"]
}

# リストからセットへの変換
locals {
  instance_types = toset(["t2.micro", "t2.small", "t2.medium"])
}

変数定義とローカル値の活用方法

for_eachを効率的に使用するために、変数とローカル値を適切に組み合わせることが重要です。

変数の定義とバリデーション

# 複雑な変数の定義例
variable "vpc_config" {
  type = map(object({
    cidr_block = string
    subnets = map(object({
      cidr_block = string
      public     = bool
    }))
  }))

  # バリデーションルールの追加
  validation {
    condition     = can([for vpc in var.vpc_config : cidrhost(vpc.cidr_block, 0)])
    error_message = "All VPC CIDR blocks must be valid IPv4 CIDR notations."
  }
}

# 使用例
vpc_config = {
  "main" = {
    cidr_block = "10.0.0.0/16"
    subnets = {
      "public-1" = {
        cidr_block = "10.0.1.0/24"
        public     = true
      }
      "private-1" = {
        cidr_block = "10.0.2.0/24"
        public     = false
      }
    }
  }
}

ローカル値の効果的な使用

ローカル値は、複雑な計算や変換を行う際に特に有用です：

locals {
  # マップの変換
  subnet_configs = flatten([
    for vpc_key, vpc in var.vpc_config : [
      for subnet_key, subnet in vpc.subnets : {
        vpc_key     = vpc_key
        subnet_key  = subnet_key
        vpc_cidr    = vpc.cidr_block
        subnet_cidr = subnet.cidr_block
        public      = subnet.public
      }
    ]
  ])

  # タグの共通化
  common_tags = {
    Environment = terraform.workspace
    ManagedBy   = "terraform"
    Project     = "infrastructure"
  }

  # 条件付きマップの作成
  public_subnets = {
    for k, v in local.subnet_configs : "${v.vpc_key}-${v.subnet_key}" => v
    if v.public
  }
}

実践的なTips：

  1. 型定義の明確化
  • 変数には常に明示的な型定義を行う
  • 複雑なオブジェクト構造も適切に定義する
  1. バリデーションの活用
  • 入力値の検証を変数定義に含める
  • エラーメッセージを明確に記述する
  1. ローカル値の使い方
  • 複雑な変換はlocalsブロックで行う
  • 共通の値や計算結果を再利用する
  • データの正規化や変換に活用する
  1. 命名規則の統一
  • キー名は一貫性のある命名規則に従う
  • 分かりやすい識別子を使用する

これらの基本を押さえることで、for_eachを使用した効率的なリソース管理が可能になります。

実践で使えるfor_eachの7つのユースケース

複数のIAMユーザーを一括作成する

開発チームのIAMユーザーを効率的に管理する例を見ていきましょう。

# 開発者の定義
variable "developers" {
  type = map(object({
    groups       = list(string)
    permissions = list(string)
  }))
  default = {
    "john.doe" = {
      groups       = ["developers", "ops"]
      permissions = ["s3:List*", "s3:Get*"]
    }
    "jane.smith" = {
      groups       = ["developers"]
      permissions = ["s3:List*"]
    }
  }
}

# IAMユーザーの作成
resource "aws_iam_user" "developers" {
  for_each = var.developers
  name     = each.key

  tags = {
    Department = "Engineering"
    Role       = join(",", each.value.groups)
  }
}

# ユーザーポリシーの作成
resource "aws_iam_user_policy" "developer_permissions" {
  for_each = var.developers
  name     = "${each.key}-permissions"
  user     = aws_iam_user.developers[each.key].name

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect   = "Allow"
        Action   = each.value.permissions
        Resource = "*"
      }
    ]
  })
}

環境ごとに異なるEC2インスタンスを管理する

開発、ステージング、本番環境で異なる設定のEC2インスタンスを管理する例です。

locals {
  environments = {
    dev = {
      instance_type = "t2.micro"
      volume_size   = 20
      count         = 1
    }
    staging = {
      instance_type = "t2.small"
      volume_size   = 30
      count         = 2
    }
    prod = {
      instance_type = "t2.medium"
      volume_size   = 50
      count         = 3
    }
  }

  # 環境ごとのインスタンス設定を展開
  instance_configs = merge([
    for env_name, env in local.environments : {
      for idx in range(env.count) : "${env_name}-${idx + 1}" => {
        instance_type = env.instance_type
        volume_size   = env.volume_size
        environment   = env_name
      }
    }
  ]...)
}

resource "aws_instance" "app_servers" {
  for_each = local.instance_configs

  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = each.value.instance_type

  root_block_device {
    volume_size = each.value.volume_size
  }

  tags = {
    Name        = "app-${each.key}"
    Environment = each.value.environment
  }
}

複数のS3バケットにポリシーを適用する

異なる用途のS3バケットに適切なポリシーを一括で適用する例です。

locals {
  bucket_policies = {
    logs = {
      name = "app-logs"
      statements = [
        {
          effect    = "Allow"
          actions   = ["s3:PutObject"]
          principals = ["arn:aws:iam::${data.aws_caller_identity.current.account_id}:root"]
        }
      ]
    }
    backup = {
      name = "app-backup"
      statements = [
        {
          effect    = "Deny"
          actions   = ["s3:DeleteObject"]
          principals = ["*"]
        }
      ]
    }
  }
}

resource "aws_s3_bucket" "buckets" {
  for_each = local.bucket_policies
  bucket   = each.value.name
}

resource "aws_s3_bucket_policy" "policies" {
  for_each = local.bucket_policies
  bucket   = aws_s3_bucket.buckets[each.key].id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = each.value.statements
  })
}

セキュリティグループのルールをまとめて設定する

複数のセキュリティグループルールを効率的に管理する例です。

locals {
  security_rules = {
    http = {
      description = "HTTP access"
      from_port   = 80
      to_port     = 80
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    }
    https = {
      description = "HTTPS access"
      from_port   = 443
      to_port     = 443
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    }
    ssh = {
      description = "SSH access"
      from_port   = 22
      to_port     = 22
      protocol    = "tcp"
      cidr_blocks = ["10.0.0.0/8"]
    }
  }
}

resource "aws_security_group" "web" {
  name_prefix = "web-"
  vpc_id      = var.vpc_id

  dynamic "ingress" {
    for_each = local.security_rules
    content {
      description = ingress.value.description
      from_port   = ingress.value.from_port
      to_port     = ingress.value.to_port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidr_blocks
    }
  }
}

タグ付けを効率的に行う

リソースへの一貫したタグ付けを実現する例です。

locals {
  common_tags = {
    Project     = "MyApp"
    Environment = terraform.workspace
    ManagedBy   = "Terraform"
  }

  resource_tags = {
    ec2 = merge(local.common_tags, {
      Type = "Compute"
    })
    rds = merge(local.common_tags, {
      Type = "Database"
    })
    s3 = merge(local.common_tags, {
      Type = "Storage"
    })
  }
}

resource "aws_instance" "servers" {
  for_each = toset(["web", "app"])

  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = merge(
    local.resource_tags["ec2"],
    {
      Name = "server-${each.key}"
    }
  )
}

複数のサブネットを異なるAZに展開する

VPC内に複数のサブネットを効率的に作成する例です。

data "aws_availability_zones" "available" {
  state = "available"
}

locals {
  vpc_cidr = "10.0.0.0/16"

  subnet_configs = {
    for idx, az in data.aws_availability_zones.available.names : "subnet-${idx + 1}" => {
      az         = az
      cidr_block = cidrsubnet(local.vpc_cidr, 8, idx)
      public     = idx < 3  # 最初の3つを公開サブネットに
    }
  }
}

resource "aws_subnet" "subnets" {
  for_each = local.subnet_configs

  vpc_id            = aws_vpc.main.id
  cidr_block        = each.value.cidr_block
  availability_zone = each.value.az

  map_public_ip_on_launch = each.value.public

  tags = {
    Name   = each.key
    Type   = each.value.public ? "Public" : "Private"
    AZ     = each.value.az
  }
}

CloudWatchアラームを一括設定する

複数のメトリクスに対してアラームを設定する例です。

locals {
  alarm_configs = {
    cpu_high = {
      metric_name = "CPUUtilization"
      namespace   = "AWS/EC2"
      period      = 300
      threshold   = 80
      comparison_operator = "GreaterThanThreshold"
      evaluation_periods = 2
    }
    memory_high = {
      metric_name = "MemoryUtilization"
      namespace   = "System/Linux"
      period      = 300
      threshold   = 75
      comparison_operator = "GreaterThanThreshold"
      evaluation_periods = 2
    }
    disk_low = {
      metric_name = "DiskSpaceUtilization"
      namespace   = "System/Linux"
      period      = 300
      threshold   = 20
      comparison_operator = "LessThanThreshold"
      evaluation_periods = 1
    }
  }
}

resource "aws_cloudwatch_metric_alarm" "alarms" {
  for_each = local.alarm_configs

  alarm_name          = "alarm-${each.key}"
  metric_name         = each.value.metric_name
  namespace           = each.value.namespace
  period              = each.value.period
  threshold           = each.value.threshold
  comparison_operator = each.value.comparison_operator
  evaluation_periods  = each.value.evaluation_periods
  statistic          = "Average"

  alarm_description = "Alert when ${each.key} condition is met"
  alarm_actions     = [aws_sns_topic.alerts.arn]

  dimensions = {
    InstanceId = aws_instance.main.id
  }
}

各ユースケースのポイント：

  1. IAMユーザー管理
  • ユーザーごとの権限を柔軟に設定
  • グループ所属も含めた一括管理が可能
  1. 環境別EC2管理
  • 環境ごとの要件に応じた設定
  • スケーリングが容易
  1. S3バケットポリシー
  • 用途に応じた細かい権限設定
  • ポリシーの一元管理
  1. セキュリティグループ
  • ルールの視認性が高い
  • メンテナンスが容易
  1. タグ付け
  • 一貫性のある命名
  • 管理のしやすさ
  1. サブネット管理
  • AZの自動検出
  • CIDRの自動計算
  1. CloudWatchアラーム
  • 監視設定の一括管理
  • アラート条件の標準化

これらのユースケースは、実際のプロジェクトですぐに活用できる実践的な例となっています。

for_each使用時のよくあるエラーと対処法

型の不一致によるエラーの解決方法

for_eachを使用する際によく遭遇する型関連のエラーとその解決方法を見ていきましょう。

1. “The given key does not identify an element in the collection”

このエラーは、存在しないキーを参照しようとした時に発生します。

# エラーが発生するコード
resource "aws_instance" "servers" {
  for_each = toset(["web", "app"])
  # ...
}

resource "aws_route53_record" "dns" {
  for_each = aws_instance.servers
  # Error: aws_instance.serversはマップ型として扱われる
  name    = "${each.key}.example.com"
  records = [each.value.public_ip]
  # ...
}

# 修正後のコード
resource "aws_route53_record" "dns" {
  for_each = {
    for k, v in aws_instance.servers : k => v
  }
  name    = "${each.key}.example.com"
  records = [each.value.public_ip]
  # ...
}

2. “The “for_each” value depends on resource attributes”

このエラーは、for_eachで使用する値が他のリソースの属性に依存している場合に発生します。

# エラーが発生するコード
resource "aws_instance" "servers" {
  count = 2
  # ...
}

resource "aws_eip" "ips" {
  for_each = toset([
    for instance in aws_instance.servers : instance.id
  ])
  # Error: countで作成したリソースは配列として扱われる
  instance = each.value
}

# 修正後のコード
resource "aws_instance" "servers" {
  for_each = toset(["server-1", "server-2"])
  # ...
}

resource "aws_eip" "ips" {
  for_each = aws_instance.servers
  instance = each.value.id
}

依存関係エラーへの対処方法

for_eachを使用する際の依存関係に関連するエラーとその解決方法を解説します。

1. 循環参照の回避

# エラーが発生するコード
locals {
  instance_ips = {
    for k, v in aws_instance.servers : k => aws_eip.ips[k].public_ip
  }
}

resource "aws_instance" "servers" {
  for_each = toset(["web", "app"])
  # ...
  tags = {
    PublicIP = local.instance_ips[each.key] # 循環参照エラー
  }
}

resource "aws_eip" "ips" {
  for_each = aws_instance.servers
  instance = each.value.id
}

# 修正後のコード
# 依存関係を明確に分離
resource "aws_instance" "servers" {
  for_each = toset(["web", "app"])
  # ...
}

resource "aws_eip" "ips" {
  for_each = aws_instance.servers
  instance = each.value.id
}

# 別のリソースでタグを更新
resource "aws_ec2_tag" "instance_ip_tags" {
  for_each = aws_eip.ips

  resource_id = aws_instance.servers[each.key].id
  key         = "PublicIP"
  value       = each.value.public_ip
}

2. 条件付きリソース作成時の注意点

# エラーが発生するコード
locals {
  create_instances = true
  instances = local.create_instances ? {
    for k, v in var.instance_configs : k => v
  } : {}
}

resource "aws_instance" "servers" {
  for_each = local.instances
  # ...
}

resource "aws_eip" "ips" {
  for_each = aws_instance.servers # エラー：条件評価が必要
  instance = each.value.id
}

# 修正後のコード
locals {
  create_instances = true
  instances = local.create_instances ? {
    for k, v in var.instance_configs : k => v
  } : {}
}

resource "aws_instance" "servers" {
  for_each = local.instances
  # ...
}

resource "aws_eip" "ips" {
  for_each = local.create_instances ? aws_instance.servers : {}
  instance = each.value.id
}

エラー解決のためのベストプラクティス：

  1. 型チェックの徹底
  • 変数定義時に明示的な型指定を行う
  • terraform consoleを使用して型を確認する
variable "instance_configs" {
  type = map(object({
    instance_type = string
    volume_size   = number
  }))

  validation {
    condition     = length(var.instance_configs) > 0
    error_message = "instance_configs must not be empty"
  }
}
  1. デバッグ用の出力
  • locals ブロックで中間値を確認
  • output で値を表示
locals {
  debug_instance_ids = {
    for k, v in aws_instance.servers : k => v.id
  }
}

output "debug_info" {
  value = {
    instance_ids = local.debug_instance_ids
    eip_configs  = aws_eip.ips
  }
}
  1. 依存関係の明示的な定義
  • depends_onを使用して依存関係を明確にする
  • リソースの参照を適切に設計する
resource "aws_route53_record" "dns" {
  for_each = aws_instance.servers

  depends_on = [aws_eip.ips]

  name    = "${each.key}.example.com"
  records = [aws_eip.ips[each.key].public_ip]
  # ...
}
  1. 段階的なリファクタリング
  • 大きな変更は小さな単位に分割
  • terraform planで各段階の変更を確認

これらのエラー対処法を理解することで、for_eachを使用した効率的なインフラ管理が可能になります。

for_eachを使用する際のベストプラクティス

コードの可読性を高めるための命名規則

効率的なfor_eachの使用には、適切な命名規則が不可欠です。

1. 変数とローカル値の命名

# 推奨される命名パターン
locals {
  # 複数形で配列やマップであることを示す
  instance_configs = {
    web = {
      type = "t2.micro"
      tags = local.web_tags
    }
  }

  # 用途を明確に示す接尾辞
  instance_config_map   = { ... }  # マップ型
  instance_config_set   = [ ... ]  # セット型
  instance_config_list  = [ ... ]  # リスト型

  # 変換や加工を示す動詞を含める
  normalized_configs = {
    for k, v in var.instance_configs :
    lower(k) => merge(v, local.default_config)
  }
}

2. リソースブロック内の参照

# 意図が明確な変数名を使用
resource "aws_instance" "servers" {
  for_each = local.instance_configs

  # キーの用途を明確に
  name = "server-${each.key}"

  # 値の参照は明示的に
  instance_type = each.value.type

  # ネストされた値は一時変数に格納
  dynamic "ebs_block_device" {
    for_each = each.value.volumes
    iterator = volume  # 意味のある反復子名
    content {
      device_name = volume.value.name
      volume_size = volume.value.size
    }
  }
}

メンテナンス性を考慮した構造化

1. モジュール化とデータの分離

# 設定データを別ファイルで管理
# terraform.tfvars
environment_configs = {
  dev = {
    instance_type = "t2.micro"
    volume_size   = 20
  }
  prod = {
    instance_type = "t2.large"
    volume_size   = 100
  }
}

# variables.tf
variable "environment_configs" {
  type = map(object({
    instance_type = string
    volume_size   = number
  }))
  description = "Environment-specific configurations"
}

# main.tf
module "environment" {
  for_each = var.environment_configs
  source   = "./modules/environment"

  instance_type = each.value.instance_type
  volume_size   = each.value.volume_size
  environment   = each.key
}

2. デフォルト値と上書きの管理

locals {
  # ベース設定
  default_config = {
    instance_type = "t2.micro"
    volume_size   = 20
    tags = {
      ManagedBy = "terraform"
    }
  }

  # 環境固有の設定
  environment_specific = {
    dev = {
      instance_type = "t2.small"
    }
    prod = {
      instance_type = "t2.large"
      volume_size   = 100
    }
  }

  # 設定のマージ
  final_configs = {
    for env, config in local.environment_specific :
    env => merge(local.default_config, config)
  }
}

テスト方法とデバッグのコツ

1. 段階的なテスト方法

# テスト用の出力定義
output "debug_configs" {
  value = {
    raw_configs     = var.environment_configs
    merged_configs  = local.final_configs
    instance_ids    = { for k, v in aws_instance.servers : k => v.id }
  }
}

# 条件付きリソース作成でのテスト
locals {
  is_testing = terraform.workspace == "test"

  test_configs = local.is_testing ? {
    test = local.final_configs["dev"]
  } : local.final_configs
}

resource "aws_instance" "servers" {
  for_each = local.test_configs
  # ...
}

2. デバッグ用の一時変数

locals {
  # デバッグ用の中間データ
  debug = {
    normalized_keys = [for k in keys(var.configs) : lower(k)]
    value_types    = { for k, v in var.configs : k => type(v) }
    null_values    = { for k, v in var.configs : k => v if v == null }
  }
}

# terraform consoleでの確認用
output "debug_info" {
  value = local.debug
}

実装のベストプラクティス

  1. データの正規化
locals {
  # キーの正規化
  normalized_keys = {
    for k, v in var.configs :
    lower(trimspace(k)) => v
  }

  # 値の正規化
  normalized_values = {
    for k, v in local.normalized_keys :
    k => {
      name = coalesce(v.name, k)
      type = lower(v.type)
      size = coalesce(v.size, 0)
    }
  }
}
  1. バリデーションの実装
variable "instance_configs" {
  type = map(object({
    type = string
    size = number
  }))

  validation {
    condition = alltrue([
      for k, v in var.instance_configs : can(regex("^[a-z0-9-]+$", k))
    ])
    error_message = "Keys must contain only lowercase letters, numbers, and hyphens."
  }

  validation {
    condition = alltrue([
      for v in var.instance_configs : contains(["t2.micro", "t2.small", "t2.medium"], v.type)
    ])
    error_message = "Instance type must be one of: t2.micro, t2.small, t2.medium"
  }
}
  1. エラーハンドリング
locals {
  # 安全な値の取得
  safe_configs = {
    for k, v in var.configs :
    k => {
      name = try(v.name, k)
      type = try(v.type, "default")
      tags = try(v.tags, {})
    }
  }

  # 条件付きリソース作成
  valid_configs = {
    for k, v in local.safe_configs :
    k => v
    if can(regex("^[a-z0-9-]+$", k)) && 
       contains(["t2.micro", "t2.small", "t2.medium"], v.type)
  }
}

これらのベストプラクティスを適用することで、保守性が高く、安全なTerraformコードを実現できます。

発展的なfor_eachの活用方法

モジュール内でのfor_eachの使い方

モジュールでfor_eachを使用する際の高度なパターンを見ていきましょう。

1. 再利用可能なマルチリソースモジュール

# modules/application/variables.tf
variable "environments" {
  type = map(object({
    instance_type     = string
    min_size         = number
    max_size         = number
    subnet_ids       = list(string)
    security_groups  = list(string)
  }))
  description = "Environment configurations"
}

# modules/application/main.tf
resource "aws_launch_template" "app" {
  for_each = var.environments

  name_prefix   = "app-${each.key}"
  instance_type = each.value.instance_type

  network_interface {
    security_groups = each.value.security_groups
  }

  tags = {
    Environment = each.key
  }
}

resource "aws_autoscaling_group" "app" {
  for_each = var.environments

  name                = "asg-${each.key}"
  min_size            = each.value.min_size
  max_size            = each.value.max_size
  vpc_zone_identifier = each.value.subnet_ids

  launch_template {
    id      = aws_launch_template.app[each.key].id
    version = "$Latest"
  }
}

# モジュールの使用例
module "application" {
  source = "./modules/application"

  environments = {
    dev = {
      instance_type    = "t2.micro"
      min_size         = 1
      max_size         = 2
      subnet_ids       = module.vpc.private_subnets
      security_groups  = [aws_security_group.app.id]
    }
    prod = {
      instance_type    = "t2.medium"
      min_size         = 2
      max_size         = 4
      subnet_ids       = module.vpc.private_subnets
      security_groups  = [aws_security_group.app.id]
    }
  }
}

2. カウント付きfor_eachの組み合わせ

# modules/multi_az_resources/variables.tf
variable "configurations" {
  type = map(object({
    instance_count = number
    instance_type = string
    zones         = list(string)
  }))
}

# modules/multi_az_resources/main.tf
locals {
  # インスタンス設定を展開
  instance_configs = merge([
    for env_name, env in var.configurations : {
      for idx in range(env.instance_count) : 
      "${env_name}-${idx}" => {
        instance_type = env.instance_type
        zone         = env.zones[idx % length(env.zones)]
        environment  = env_name
      }
    }
  ]...)
}

resource "aws_instance" "multi_az" {
  for_each = local.instance_configs

  ami               = data.aws_ami.amazon_linux.id
  instance_type     = each.value.instance_type
  availability_zone = each.value.zone

  tags = {
    Name        = "instance-${each.key}"
    Environment = each.value.environment
  }
}

動的ブロックでの活用方法

1. 複雑な設定の動的生成

locals {
  lb_configs = {
    public = {
      listeners = {
        http = {
          port     = 80
          protocol = "HTTP"
          rules = {
            main = {
              path_pattern = ["/*"]
              priority    = 100
            }
            api = {
              path_pattern = ["/api/*"]
              priority    = 200
            }
          }
        }
        https = {
          port     = 443
          protocol = "HTTPS"
          rules = {
            main = {
              path_pattern = ["/*"]
              priority    = 100
            }
          }
        }
      }
    }
  }
}

resource "aws_lb" "this" {
  for_each = local.lb_configs
  name     = "${each.key}-lb"
  internal = each.key == "private"
}

resource "aws_lb_listener" "this" {
  for_each = merge([
    for lb_key, lb in local.lb_configs : {
      for listener_key, listener in lb.listeners :
      "${lb_key}-${listener_key}" => merge(listener, {
        lb_key = lb_key
      })
    }
  ]...)

  load_balancer_arn = aws_lb.this[each.value.lb_key].arn
  port              = each.value.port
  protocol          = each.value.protocol

  dynamic "default_action" {
    for_each = each.value.protocol == "HTTP" ? [1] : []
    content {
      type = "redirect"
      redirect {
        port        = "443"
        protocol    = "HTTPS"
        status_code = "HTTP_301"
      }
    }
  }

  dynamic "default_action" {
    for_each = each.value.protocol == "HTTPS" ? [1] : []
    content {
      type             = "forward"
      target_group_arn = aws_lb_target_group.default[each.key].arn
    }
  }
}

2. 条件付きブロックの生成

locals {
  instance_configs = {
    web = {
      type = "t2.micro"
      ebs_volumes = {
        data = {
          size = 50
          type = "gp2"
        }
        logs = {
          size = 20
          type = "gp2"
        }
      }
      enable_monitoring = true
    }
    db = {
      type = "t2.medium"
      ebs_volumes = {
        data = {
          size = 100
          type = "io1"
          iops = 1000
        }
      }
      enable_monitoring = true
    }
  }
}

resource "aws_instance" "servers" {
  for_each = local.instance_configs

  ami           = data.aws_ami.amazon_linux.id
  instance_type = each.value.type

  dynamic "ebs_block_device" {
    for_each = each.value.ebs_volumes
    content {
      device_name = "/dev/sd${ebs_block_device.key}"
      volume_size = ebs_block_device.value.size
      volume_type = ebs_block_device.value.type

      dynamic "iops" {
        for_each = try([ebs_block_device.value.iops], [])
        content {
          iops = iops.value
        }
      }
    }
  }

  dynamic "monitoring" {
    for_each = each.value.enable_monitoring ? [true] : []
    content {
      enabled = true
    }
  }
}

3. 複数のプロバイダーでの活用

locals {
  region_configs = {
    us-east-1 = {
      cidr_block = "10.1.0.0/16"
      azs        = ["us-east-1a", "us-east-1b"]
    }
    us-west-2 = {
      cidr_block = "10.2.0.0/16"
      azs        = ["us-west-2a", "us-west-2b"]
    }
  }
}

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

provider "aws" {
  alias  = "us_west_2"
  region = "us-west-2"
}

module "vpc" {
  for_each = local.region_configs
  source   = "terraform-aws-modules/vpc/aws"

  providers = {
    aws = aws[replace(each.key, "-", "_")]
  }

  name            = "vpc-${each.key}"
  cidr            = each.value.cidr_block
  azs             = each.value.azs
  private_subnets = [for i, az in each.value.azs : cidrsubnet(each.value.cidr_block, 8, i)]
  public_subnets  = [for i, az in each.value.azs : cidrsubnet(each.value.cidr_block, 8, i + length(each.value.azs))]
}

これらの発展的な使用方法は、より複雑なインフラストラクチャの管理に役立ちます。

まとめ：for_eachで実現する効率的なインフラ管理

for_each活用のためのチェックリスト

Terraformのfor_eachを効果的に活用するための重要なポイントをチェックリストとしてまとめました。

設計時のチェックポイント

  1. データ構造の設計
  • [ ] マップまたはセットの選択は適切か
  • [ ] キーの命名規則は統一されているか
  • [ ] 値の型は明確に定義されているか
  • [ ] デフォルト値は適切に設定されているか
  1. コードの構造化
  • [ ] モジュール化の範囲は適切か
  • [ ] 変数とローカル値の分離ができているか
  • [ ] 依存関係は明確か
  • [ ] エラーハンドリングは考慮されているか
  1. 保守性の確保
  • [ ] コードの可読性は確保されているか
  • [ ] ドキュメントは十分か
  • [ ] テスト方法は確立されているか
  • [ ] バージョン管理との整合性は取れているか

実装時の確認事項

  1. 基本実装
# 実装前の確認事項
locals {
  # 1. データ構造の定義
  resource_configs = {
    # キーの命名規則は統一されているか
    # 値の構造は適切か
  }

  # 2. デフォルト値の設定
  defaults = {
    # 共通の設定は定義されているか
  }

  # 3. バリデーション
  validation = {
    # 入力値の検証は十分か
  }
}
  1. エラー防止のポイント
# 実装時のベストプラクティス
resource "aws_instance" "example" {
  # 1. for_eachの使用
  for_each = local.validated_configs  # バリデーション済みの設定を使用

  # 2. 安全な値の参照
  name = try(each.value.name, "default-${each.key}")

  # 3. 依存関係の明示
  depends_on = [
    aws_vpc.main,
    aws_subnet.primary
  ]
}

次のステップと学習リソース

1. スキルアップの方向性

  1. 基本から応用へ
  • for_eachの基本的な使い方の習得
  • 複雑なデータ構造の操作方法の理解
  • モジュール設計のベストプラクティスの学習
  • 大規模インフラ管理への適用
  1. 実践的な学習ステップ
  • 小規模なリソース管理から始める
  • 段階的に複雑な構成に移行
  • 実際のプロジェクトでの活用
  • チーム内でのベストプラクティス共有

2. 推奨される学習リソース

  1. 公式ドキュメント
  1. 実践的な演習環境
  • AWS無料枠を使用した検証環境
  • LocalstackやTerraform Cloudサンドボックス
  • GitLabやGitHubのCI/CD環境
  1. コミュニティリソース
  • Terraform Registryのモジュール例
  • GitHubの実装例
  • コミュニティフォーラムやブログ

3. 次の学習ステップ

  1. 応用的なトピック
  • カスタムプロバイダーの開発
  • 複雑なモジュール設計
  • 大規模インフラの自動化
  • セキュリティベストプラクティス
  1. 関連する技術
  • Configuration Management Tools
  • CI/CD Pipeline Integration
  • Infrastructure Testing
  • Policy as Code

for_eachは、Terraformを使用したインフラストラクチャ管理の効率を大きく向上させる機能です。この記事で解説した内容を基に、段階的に理解を深め、実践的なスキルを身につけていくことをお勧めします。最初は小規模な実装から始め、徐々に複雑な構成に挑戦することで、確実にスキルアップを図ることができます。

Terraformによるインフラ管理の自動化は、現代のDevOps実践において重要な要素となっています。for_eachの効果的な活用は、その中核となるスキルの一つと言えるでしょう。この機能を使いこなすことで、より保守性が高く、スケーラブルなインフラストラクチャの実現が可能となります。

前の記事

【保存版】terraform applyの使い方完全ガイド！実…

次の記事

【保存版】Terraformバージョン管理完全ガイド2024 …