【保守性抜群】Terraformダイナミックブロック完全ガイド！実践的な7つの活用例と実践のコツ

SHARE

目次

目次へ

Terraform 動的ブロックとは？ 基礎から徹底解説

Terraformの動的ブロック（dynamic block）は、似たような構造を持つ複数のブロックを効率的に生成するための機能です。特に大規模なインフラ環境では、同じような設定を何度も記述する必要があり、それがコードの肥大化や保守性の低下を招きます。動的ブロックを使用することで、このような課題を効果的に解決できます。

動的ブロックが解決する3つの課題

  1. コードの重複削減
  • 従来の方法では、似たような設定ブロックを何度も記述する必要がありました
  • 動的ブロックを使用することで、設定をデータとして管理し、繰り返し生成できます
  • これにより、コードの行数が大幅に削減され、可読性が向上します
  1. 保守性の向上
  • 設定変更時に複数箇所を修正する必要がなくなります
  • データ駆動の設定管理により、変更のリスクが低減します
  • バージョン管理がしやすくなります
  1. 柔軟な設定管理
  • 環境変数や外部データに基づいて設定を動的に生成できます
  • 条件分岐との組み合わせが容易です
  • モジュール化との相性が良く、再利用性が高まります

基本的な文法と動作の仕組み

動的ブロックの基本的な構文は以下の通りです：

dynamic "ブロック名" {
  for_each = 繰り返し対象のデータ
  content {
    # 各要素に対する設定
    設定項目 = each.value.項目名
  }
}

具体的な例として、複数のインバウンドルールを持つセキュリティグループの定義を見てみましょう：

# 設定データの定義
variable "sg_rules" {
  default = [
    {
      port        = 80
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    },
    {
      port        = 443
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    }
  ]
}

# セキュリティグループの定義
resource "aws_security_group" "example" {
  name = "example-sg"

  # 動的ブロックを使用したルール定義
  dynamic "ingress" {
    for_each = var.sg_rules
    content {
      from_port   = ingress.value.port
      to_port     = ingress.value.port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidr_blocks
    }
  }
}

従来の記述方法との比較

従来の静的な記述方法と動的ブロックを使用した方法を比較してみましょう：

従来の方法：

resource "aws_security_group" "example" {
  name = "example-sg"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # 新しいルールを追加する場合、
  # ここに同じような構造のブロックを追加
}

動的ブロックを使用した方法のメリット：

  1. 設定の一元管理
  • ルールの追加・変更・削除が変数の修正だけで完結
  • データとロジックの分離により、管理が容易に
  1. コードの簡潔さ
  • 重複するコードが大幅に削減
  • 変更箇所が集中するため、ミスのリスクが低下
  1. 拡張性の向上
  • 新しいルールの追加が容易
  • 環境ごとの設定変更が変数定義の変更だけで可能

動的ブロックは、特に以下のような場合に効果を発揮します：

  • 同じ構造の設定を複数回記述する必要がある場合
  • 環境やコンテキストに応じて設定内容が変化する場合
  • チーム間で設定を共有・再利用する必要がある場合

これらの特徴を活かすことで、より保守性の高いTerraformコードを実現できます。

実践で使えるダイナミックブロックの活用例7選

実際のAWS環境構築でよく遭遇する場面での、動的ブロックの効果的な活用例を紹介します。

セキュリティグループのルール定義をスマートに管理

セキュリティグループの設定は、複数のポートやプロトコルを管理する必要があり、動的ブロックの活用が特に効果的です。

locals {
  sg_rules = {
    http = {
      port     = 80
      protocol = "tcp"
      cidrs    = ["0.0.0.0/0"]
    },
    https = {
      port     = 443
      protocol = "tcp"
      cidrs    = ["0.0.0.0/0"]
    },
    monitoring = {
      port     = 9090
      protocol = "tcp"
      cidrs    = ["10.0.0.0/8"]
    }
  }
}

resource "aws_security_group" "web" {
  name        = "web-sg"
  description = "Security group for web servers"
  vpc_id      = aws_vpc.main.id

  dynamic "ingress" {
    for_each = local.sg_rules
    content {
      description = each.key
      from_port   = each.value.port
      to_port     = each.value.port
      protocol    = each.value.protocol
      cidr_blocks = each.value.cidrs
    }
  }
}

複数のIAMポリシーを効率的に設定

IAMポリシーの管理は、特に複数のサービスやリソースへのアクセス権限を設定する際に複雑になりがちです。

locals {
  s3_permissions = {
    read = {
      actions   = ["s3:GetObject", "s3:ListBucket"]
      resources = ["arn:aws:s3:::my-bucket/*"]
    },
    write = {
      actions   = ["s3:PutObject", "s3:DeleteObject"]
      resources = ["arn:aws:s3:::my-bucket/*"]
    }
  }
}

resource "aws_iam_policy" "s3_access" {
  name = "s3-access-policy"

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      dynamic "statement" {
        for_each = local.s3_permissions
        content {
          Sid      = each.key
          Effect   = "Allow"
          Action   = each.value.actions
          Resource = each.value.resources
        }
      }
    ]
  })
}

S3バケットのライフサイクルルールを動的に制御

複数のライフサイクルルールを持つS3バケットの設定を効率的に管理できます。

locals {
  lifecycle_rules = [
    {
      prefix  = "logs/"
      enabled = true
      transitions = [
        {
          days          = 30
          storage_class = "STANDARD_IA"
        },
        {
          days          = 90
          storage_class = "GLACIER"
        }
      ]
      expiration = 365
    },
    {
      prefix  = "tmp/"
      enabled = true
      transitions = [
        {
          days          = 7
          storage_class = "GLACIER"
        }
      ]
      expiration = 30
    }
  ]
}

resource "aws_s3_bucket" "example" {
  bucket = "my-bucket"

  dynamic "lifecycle_rule" {
    for_each = local.lifecycle_rules
    content {
      prefix  = lifecycle_rule.value.prefix
      enabled = lifecycle_rule.value.enabled

      dynamic "transition" {
        for_each = lifecycle_rule.value.transitions
        content {
          days          = transition.value.days
          storage_class = transition.value.storage_class
        }
      }

      expiration {
        days = lifecycle_rule.value.expiration
      }
    }
  }
}

タグ付けを一元管理

複数のリソースに対する一貫したタグ付けを実現します。

locals {
  common_tags = {
    Environment = "Production"
    Department  = "DevOps"
    Project     = "Infrastructure"
    ManagedBy   = "Terraform"
  }
}

resource "aws_instance" "web" {
  ami           = "ami-12345678"
  instance_type = "t3.micro"

  dynamic "tags" {
    for_each = local.common_tags
    content {
      key   = tags.key
      value = tags.value
    }
  }
}

VPCのサブネット設定を柔軟に管理

複数のアベイラビリティーゾーンにまたがるサブネット設定を効率的に管理できます。

locals {
  azs = ["ap-northeast-1a", "ap-northeast-1c", "ap-northeast-1d"]
  subnets = {
    public = {
      cidr_offset = 0
      tags = {
        Type = "Public"
      }
    }
    private = {
      cidr_offset = 3
      tags = {
        Type = "Private"
      }
    }
  }
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"

  dynamic "subnet" {
    for_each = {
      for pair in setproduct(keys(local.subnets), local.azs) :
      "${pair[0]}-${pair[1]}" => {
        name   = pair[0]
        az     = pair[1]
        config = local.subnets[pair[0]]
      }
    }

    content {
      cidr_block = cidrsubnet(
        aws_vpc.main.cidr_block,
        8,
        subnet.value.config.cidr_offset + index(local.azs, subnet.value.az)
      )
      availability_zone = subnet.value.az
      tags             = merge(
        subnet.value.config.tags,
        {
          Name = "${subnet.key}-subnet"
        }
      )
    }
  }
}

ECSタスク定義でコンテナ設定を動的に生成

複数のコンテナを含むECSタスク定義を効率的に管理します。

locals {
  containers = {
    app = {
      image     = "app:latest"
      cpu       = 256
      memory    = 512
      essential = true
      portMappings = [
        {
          containerPort = 80
          hostPort     = 80
        }
      ]
    },
    sidecar = {
      image     = "sidecar:latest"
      cpu       = 128
      memory    = 256
      essential = false
    }
  }
}

resource "aws_ecs_task_definition" "service" {
  family                   = "service"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = 512
  memory                   = 1024

  dynamic "container_definitions" {
    for_each = local.containers
    content {
      name       = container_definitions.key
      image      = container_definitions.value.image
      cpu        = container_definitions.value.cpu
      memory     = container_definitions.value.memory
      essential  = container_definitions.value.essential

      dynamic "portMappings" {
        for_each = try(container_definitions.value.portMappings, [])
        content {
          containerPort = portMappings.value.containerPort
          hostPort     = portMappings.value.hostPort
        }
      }
    }
  }
}

CloudWatchアラームの閾値設定を一括管理

複数のメトリクスに対するアラーム設定を効率的に管理します。

locals {
  alarms = {
    cpu_high = {
      metric_name = "CPUUtilization"
      threshold   = 80
      period     = 300
      statistic  = "Average"
    },
    memory_high = {
      metric_name = "MemoryUtilization"
      threshold   = 75
      period     = 300
      statistic  = "Average"
    }
  }
}

resource "aws_cloudwatch_metric_alarm" "monitoring" {
  dynamic "metric_alarm" {
    for_each = local.alarms
    content {
      alarm_name          = "${metric_alarm.key}-alarm"
      comparison_operator = "GreaterThanThreshold"
      evaluation_periods  = "2"
      metric_name        = metric_alarm.value.metric_name
      namespace          = "AWS/ECS"
      period            = metric_alarm.value.period
      statistic         = metric_alarm.value.statistic
      threshold         = metric_alarm.value.threshold
      alarm_description = "Alarm when ${metric_alarm.key} exceeds threshold"
    }
  }
}

各例で示したように、動的ブロックは設定の繰り返しが必要な場面で特に威力を発揮します。これらのパターンを基に、自身の環境に合わせてカスタマイズすることで、より効率的なインフラ管理が可能になります。

dynamicblock 活用のベストプラクティス

効果的な動的ブロックの活用には、適切な設計とベストプラクティスの遵守が不可欠です。ここでは、実践的な観点から重要なポイントを解説します。

変数定義のための最適な構造化データの設計方法

効率的な動的ブロック運用の鍵は、適切なデータ構造の設計にあります。

  1. 階層構造の適切な設計
# 良い例：意味のある階層構造
locals {
  security_rules = {
    web = {
      description = "Web traffic"
      rules = {
        http  = { port = 80, protocol = "tcp", cidr = ["0.0.0.0/0"] }
        https = { port = 443, protocol = "tcp", cidr = ["0.0.0.0/0"] }
      }
    }
    monitoring = {
      description = "Monitoring traffic"
      rules = {
        prometheus = { port = 9090, protocol = "tcp", cidr = ["10.0.0.0/8"] }
        grafana    = { port = 3000, protocol = "tcp", cidr = ["10.0.0.0/8"] }
      }
    }
  }
}

# 悪い例：フラットすぎる構造
locals {
  security_rules_flat = {
    http_port       = 80
    http_protocol   = "tcp"
    http_cidr       = ["0.0.0.0/0"]
    https_port      = 443
    https_protocol  = "tcp"
    https_cidr      = ["0.0.0.0/0"]
  }
}
  1. データ型の一貫性維持
# 良い例：一貫したデータ構造
locals {
  lifecycle_rules = [
    {
      prefix = "logs/"
      transitions = [
        { days = 30, storage_class = "STANDARD_IA" },
        { days = 90, storage_class = "GLACIER" }
      ]
    }
  ]
}

# 悪い例：不整合なデータ構造
locals {
  lifecycle_rules_bad = [
    {
      prefix = "logs/"
      transition_days = [30, 90]  # 一部の情報が欠落
      storage_class = ["STANDARD_IA", "GLACIER"]
    }
  ]
}

コードの可読性を維持するためのヒント

  1. 適切なコメントとドキュメンテーション
locals {
  # 各環境のVPCとサブネット設定
  # format: {環境名 = {VPCのCIDR, サブネット数, タグ設定}}
  vpc_configs = {
    staging = {
      cidr = "10.0.0.0/16"
      subnets = {
        public  = { count = 2, offset = 0 }
        private = { count = 2, offset = 2 }
      }
      tags = {
        Environment = "Staging"
        ManagedBy  = "Terraform"
      }
    }
  }
}

resource "aws_vpc" "main" {
  # VPC設定のdynamicブロック
  dynamic "vpc_config" {
    for_each = local.vpc_configs
    content {
      cidr_block = vpc_config.value.cidr

      # サブネット設定の動的生成
      dynamic "subnet" {
        for_each = vpc_config.value.subnets
        content {
          # ...サブネット設定の詳細...
        }
      }

      # 共通タグの適用
      tags = vpc_config.value.tags
    }
  }
}
  1. モジュール化による整理
# モジュール: security_group/main.tf
variable "rules" {
  description = "Security group rules configuration"
  type = map(object({
    description = string
    port        = number
    protocol    = string
    cidr_blocks = list(string)
  }))
}

resource "aws_security_group" "this" {
  dynamic "ingress" {
    for_each = var.rules
    content {
      description = ingress.value.description
      from_port   = ingress.value.port
      to_port     = ingress.value.port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidr_blocks
    }
  }
}

デバッグとトラブルシューティングのアプローチ

  1. 計画フェーズでの検証
# デバッグ用のoutput定義
output "generated_config" {
  value = [
    for rule in aws_security_group.example.ingress : {
      port        = rule.from_port
      protocol    = rule.protocol
      cidr_blocks = rule.cidr_blocks
    }
  ]
}

# 変数の値を確認するためのlocal値
locals {
  debug_view = {
    input_rules = var.security_rules
    processed_rules = [
      for name, rule in var.security_rules : {
        name     = name
        port     = rule.port
        protocol = rule.protocol
      }
    ]
  }
}
  1. エラー処理とバリデーション
locals {
  # 入力値の検証
  validate_ports = [
    for name, rule in var.security_rules :
    rule.port >= 0 && rule.port <= 65535 ?
    null : "Invalid port ${rule.port} for rule ${name}"
  ]

  # エラーがある場合は実行を停止
  validate_check = length(compact(local.validate_ports)) == 0 ?
    null : file("ERROR: Invalid security rules configuration")
}

これらのベストプラクティスを適用することで、動的ブロックを使用したTerraformコードの保守性と信頼性を大幅に向上させることができます。特に大規模なインフラストラクチャを管理する場合、これらの原則に従うことで長期的なメンテナンス性を確保できます。

実現時の注意点と回避すべき反アンチパターン

動的ブロックは強力な機能ですが、適切に使用しないとかえって保守性を低下させる可能性があります。ここでは、実装時の注意点とアンチパターンを解説します。

過度な動的生成を考慮するためのガイドライン

  1. 過度な入れ子構造の回避
# アンチパターン：深すぎる入れ子構造
resource "aws_security_group" "complex" {
  dynamic "ingress" {
    for_each = var.security_rules
    content {
      from_port = ingress.value.port
      to_port   = ingress.value.port

      dynamic "cidr_blocks" {  # 不必要な動的ブロック
        for_each = ingress.value.cidrs
        content {
          cidr_block = cidr_blocks.value
        }
      }

      dynamic "description" {  # 単純な値に対する不要な動的ブロック
        for_each = [ingress.value.description]
        content {
          value = description.value
        }
      }
    }
  }
}

# 推奨パターン：適切な構造化
resource "aws_security_group" "simple" {
  dynamic "ingress" {
    for_each = var.security_rules
    content {
      from_port   = ingress.value.port
      to_port     = ingress.value.port
      cidr_blocks = ingress.value.cidrs  # 直接リストを指定
      description = ingress.value.description  # 直接値を指定
    }
  }
}
  1. 複雑な条件分岐の制限
# アンチパターン：過度に複雑な条件分岐
locals {
  complex_rules = {
    for env, config in var.environments : env => {
      for service, rules in config.services : service => {
        for port in rules.ports : port => {
          enabled = try(rules.enabled, true) && 
                   try(var.global_config.services[service].enabled, true) &&
                   contains(var.allowed_ports, port)
        }
      }
    }
  }
}

# 推奨パターン：シンプルな構造化
locals {
  simplified_rules = {
    for service, config in var.services : service => {
      enabled = try(config.enabled, true)
      ports   = config.ports
    }
  }
}

テスト時の重要事項

  1. 計画フェーズでの検証
# テスト用のチェックポイント
locals {
  # 設定値の検証
  validation_checks = {
    port_ranges = [
      for rule in var.security_rules :
      rule.port >= 0 && rule.port <= 65535
    ]
    unique_ports = length(distinct([
      for rule in var.security_rules : rule.port
    ])) == length(var.security_rules)
  }

  # 検証エラーの集約
  validation_errors = concat(
    [
      for i, valid in local.validation_checks.port_ranges :
      valid ? null : "Invalid port range in rule ${i}"
    ],
    local.validation_checks.unique_ports ?
    [] : ["Duplicate ports detected"]
  )
}

# 検証結果の出力
output "validation_result" {
  value = length(compact(local.validation_errors)) == 0 ?
    "All validations passed" : local.validation_errors
}
  1. テスト用のワークスペース設定
# テスト環境用の設定
locals {
  test_configs = {
    minimal = {
      rules = {
        http = {
          port        = 80
          protocol    = "tcp"
          cidr_blocks = ["0.0.0.0/0"]
        }
      }
    }
    complete = {
      rules = {
        http = {
          port        = 80
          protocol    = "tcp"
          cidr_blocks = ["0.0.0.0/0"]
        }
        https = {
          port        = 443
          protocol    = "tcp"
          cidr_blocks = ["0.0.0.0/0"]
        }
      }
    }
  }
}

パフォーマンスへの影響と最適化方法

  1. リソース生成数の最適化
# アンチパターン：不必要なリソース生成
resource "aws_security_group_rule" "inefficient" {
  count = length(local.all_combinations)  # 大量のルールを個別に生成

  type        = "ingress"
  from_port   = local.all_combinations[count.index].port
  to_port     = local.all_combinations[count.index].port
  protocol    = local.all_combinations[count.index].protocol
  cidr_blocks = local.all_combinations[count.index].cidrs
}

# 推奨パターン：効率的なリソース生成
resource "aws_security_group" "efficient" {
  dynamic "ingress" {
    for_each = {
      for rule in local.security_rules :
      "${rule.port}-${rule.protocol}" => rule
    }

    content {
      from_port   = ingress.value.port
      to_port     = ingress.value.port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidrs
    }
  }
}
  1. データ構造の最適化
# アンチパターン：非効率なデータ処理
locals {
  processed_rules = flatten([
    for group in var.security_groups : [
      for rule in group.rules : {
        port     = rule.port
        protocol = rule.protocol
        cidrs    = rule.cidrs
      }
    ]
  ])
}

# 推奨パターン：効率的なデータ構造
locals {
  optimized_rules = merge([
    for group_name, group in var.security_groups : {
      for rule_name, rule in group.rules : 
      "${group_name}-${rule_name}" => {
        port     = rule.port
        protocol = rule.protocol
        cidrs    = rule.cidrs
      }
    }
  ]...)
}

これらの注意点とベストプラクティスを意識することで、より保守性が高く、効率的な動的ブロックの実装が可能になります。特に大規模な環境では、これらのガイドラインに従うことで、長期的なメンテナンス性と安定性を確保できます。

応用：より高度なダイナミックブロックの使い方

動的ブロックの基本を理解したら、より高度な使い方を習得することで、さらに柔軟で保守性の高いインフラストラクチャコードを実現できます。

ネスト化されたブロックの取り扱い

複雑な設定が必要な場合、ネスト化された動的ブロックを効果的に活用できます。

# ECSタスク定義での高度な設定例
locals {
  container_definitions = {
    app = {
      image = "app:latest"
      portMappings = [
        { containerPort = 80, protocol = "tcp" },
        { containerPort = 443, protocol = "tcp" }
      ]
      environment = {
        DATABASE_URL = "db://localhost:5432"
        API_KEY      = "secret"
      }
      mountPoints = [
        {
          sourceVolume  = "data"
          containerPath = "/data"
          readOnly     = false
        }
      ]
    }
    sidecar = {
      image = "sidecar:latest"
      portMappings = [
        { containerPort = 9090, protocol = "tcp" }
      ]
      environment = {
        METRICS_PATH = "/metrics"
      }
    }
  }
}

resource "aws_ecs_task_definition" "advanced" {
  family = "service"

  dynamic "container_definitions" {
    for_each = local.container_definitions
    content {
      name  = container_definitions.key
      image = container_definitions.value.image

      dynamic "portMappings" {
        for_each = container_definitions.value.portMappings
        content {
          containerPort = portMappings.value.containerPort
          protocol     = portMappings.value.protocol
        }
      }

      dynamic "environment" {
        for_each = container_definitions.value.environment
        content {
          name  = environment.key
          value = environment.value
        }
      }

      dynamic "mountPoints" {
        for_each = try(container_definitions.value.mountPoints, [])
        content {
          sourceVolume  = mountPoints.value.sourceVolume
          containerPath = mountPoints.value.containerPath
          readOnly     = mountPoints.value.readOnly
        }
      }
    }
  }
}

条件付きリソース生成との組み合わせ

動的ブロックと条件付きリソース生成を組み合わせることで、より柔軟な設定が可能になります。

# 環境に応じた条件付きリソース生成
locals {
  environments = {
    dev = {
      enable_monitoring = false
      instance_count   = 1
      alarms = {}
    }
    staging = {
      enable_monitoring = true
      instance_count   = 2
      alarms = {
        cpu = {
          threshold = 80
          period    = 300
        }
        memory = {
          threshold = 75
          period    = 300
        }
      }
    }
    prod = {
      enable_monitoring = true
      instance_count   = 3
      alarms = {
        cpu = {
          threshold = 70
          period    = 180
        }
        memory = {
          threshold = 65
          period    = 180
        }
        disk = {
          threshold = 85
          period    = 300
        }
      }
    }
  }
}

resource "aws_cloudwatch_metric_alarm" "conditional" {
  for_each = local.environments[var.environment].enable_monitoring ? local.environments[var.environment].alarms : {}

  alarm_name = "${var.environment}-${each.key}-alarm"

  dynamic "metric_query" {
    for_each = each.value
    content {
      id          = "m1"
      metric {
        namespace  = "AWS/EC2"
        metric_name = upper(each.key)
        period     = each.value.period
        stat       = "Average"
        dimensions = {
          InstanceId = aws_instance.example[count.index].id
        }
      }
    }
  }

  threshold         = each.value.threshold
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = "2"
}

モジュール化における活用戦略

動的ブロックを効果的にモジュール化することで、再利用性と保守性を向上させることができます。

# modules/security_group/variables.tf
variable "rules" {
  description = "Map of security group rules"
  type = map(object({
    type        = string
    from_port   = number
    to_port     = number
    protocol    = string
    cidr_blocks = list(string)
    description = string
  }))
}

variable "tags" {
  description = "Resource tags"
  type        = map(string)
  default     = {}
}

# modules/security_group/main.tf
resource "aws_security_group" "this" {
  name_prefix = var.name_prefix
  vpc_id      = var.vpc_id

  dynamic "ingress" {
    for_each = {
      for k, v in var.rules : k => v
      if v.type == "ingress"
    }
    content {
      from_port   = ingress.value.from_port
      to_port     = ingress.value.to_port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidr_blocks
      description = ingress.value.description
    }
  }

  dynamic "egress" {
    for_each = {
      for k, v in var.rules : k => v
      if v.type == "egress"
    }
    content {
      from_port   = egress.value.from_port
      to_port     = egress.value.to_port
      protocol    = egress.value.protocol
      cidr_blocks = egress.value.cidr_blocks
      description = egress.value.description
    }
  }

  dynamic "tags" {
    for_each = var.tags
    content {
      key   = tags.key
      value = tags.value
    }
  }
}

# 使用例
module "web_security_group" {
  source = "./modules/security_group"

  name_prefix = "web"
  vpc_id      = aws_vpc.main.id

  rules = {
    http = {
      type        = "ingress"
      from_port   = 80
      to_port     = 80
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
      description = "HTTP access"
    }
    https = {
      type        = "ingress"
      from_port   = 443
      to_port     = 443
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
      description = "HTTPS access"
    }
    egress = {
      type        = "egress"
      from_port   = 0
      to_port     = 0
      protocol    = "-1"
      cidr_blocks = ["0.0.0.0/0"]
      description = "Allow all outbound traffic"
    }
  }

  tags = {
    Environment = "Production"
    ManagedBy   = "Terraform"
  }
}

これらの高度な使用方法を理解し適切に活用することで、より柔軟で保守性の高いインフラストラクチャコードを実現できます。特に大規模な環境や複雑な要件がある場合、これらのパターンを組み合わせることで効果的な解決策を提供できます。

前の記事

【保存版】TerraformでS3を構築する完全ガイド2024…

次の記事

【保存版】TerraformとAnsibleで実現 AWS環境…