Add generated/complex/gpt-4o/

generated/complex/gpt-4o/complex-aws-tf-001/main.tf

@@ -0,0 +1,172 @@
+provider "aws" {
+  alias  = "us_east_1"
+  region = "us-east-1"
+}
+
+provider "aws" {
+  alias  = "eu_west_1"
+  region = "eu-west-1"
+}
+
+provider "aws" {
+  alias  = "ap_southeast_1"
+  region = "ap-southeast-1"
+}
+
+provider "aws" {
+  alias  = "security_account"
+  region = "us-east-1"
+}
+
+resource "aws_s3_bucket" "flow_logs" {
+  provider = aws.security_account
+  bucket   = "centralized-security-flow-logs"
+
+  lifecycle_rule {
+    enabled = true
+
+    expiration {
+      days = 90
+    }
+  }
+
+  server_side_encryption_configuration {
+    rule {
+      apply_server_side_encryption_by_default {
+        sse_algorithm     = "aws:kms"
+        kms_master_key_id = aws_kms_key.flow_logs.arn
+      }
+    }
+  }
+}
+
+resource "aws_kms_key" "flow_logs" {
+  provider = aws.security_account
+  description = "KMS CMK for encrypting VPC Flow Logs"
+}
+
+resource "aws_ec2_transit_gateway" "main" {
+  provider = aws.us_east_1
+}
+
+resource "aws_ec2_transit_gateway_route_table" "main" {
+  provider = aws.us_east_1
+  transit_gateway_id = aws_ec2_transit_gateway.main.id
+}
+
+resource "aws_ec2_transit_gateway_route" "blackhole" {
+  provider = aws.us_east_1
+  transit_gateway_route_table_id = aws_ec2_transit_gateway_route_table.main.id
+  destination_cidr_block = "10.0.0.0/8"
+  blackhole = true
+}
+
+resource "aws_vpc" "spoke" {
+  provider = aws.us_east_1
+  cidr_block = "10.1.0.0/16"
+}
+
+resource "aws_subnet" "private" {
+  provider = aws.us_east_1
+  vpc_id = aws_vpc.spoke.id
+  cidr_block = "10.1.1.0/24"
+}
+
+resource "aws_security_group" "allowlist" {
+  provider = aws.us_east_1
+  vpc_id = aws_vpc.spoke.id
+
+  ingress {
+    from_port   = 0
+    to_port     = 65535
+    protocol    = "tcp"
+    cidr_blocks = ["203.0.113.0/24"] # Example allowlist
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 65535
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+}
+
+resource "aws_network_acl" "strict" {
+  provider = aws.us_east_1
+  vpc_id = aws_vpc.spoke.id
+
+  egress {
+    rule_no    = 100
+    protocol   = "-1"
+    action     = "allow"
+    cidr_block = "203.0.113.0/24"
+    from_port  = 0
+    to_port    = 0
+  }
+
+  ingress {
+    rule_no    = 100
+    protocol   = "-1"
+    action     = "allow"
+    cidr_block = "203.0.113.0/24"
+    from_port  = 0
+    to_port    = 0
+  }
+}
+
+resource "aws_vpc_flow_log" "spoke" {
+  provider = aws.us_east_1
+  vpc_id = aws_vpc.spoke.id
+  log_destination = aws_s3_bucket.flow_logs.arn
+  log_destination_type = "s3"
+  traffic_type = "ALL"
+  log_format = "${aws_kms_key.flow_logs.arn}"
+}
+
+resource "aws_rds_cluster" "aurora" {
+  provider = aws.us_east_1
+  cluster_identifier = "aurora-cluster"
+  engine = "aurora-mysql"
+  master_username = "admin"
+  master_password = "password"
+  vpc_security_group_ids = [aws_security_group.allowlist.id]
+  db_subnet_group_name = aws_db_subnet_group.aurora.name
+}
+
+resource "aws_db_subnet_group" "aurora" {
+  provider = aws.us_east_1
+  name = "aurora-subnet-group"
+  subnet_ids = [aws_subnet.private.id]
+}
+
+resource "aws_nat_gateway" "egress" {
+  provider = aws.us_east_1
+  allocation_id = aws_eip.nat.id
+  subnet_id = aws_subnet.private.id
+}
+
+resource "aws_eip" "nat" {
+  provider = aws.us_east_1
+  vpc = true
+}
+
+resource "aws_networkfirewall_firewall" "main" {
+  provider = aws.us_east_1
+  firewall_name = "centralized-firewall"
+  vpc_id = aws_vpc.spoke.id
+  subnet_mappings {
+    subnet_id = aws_subnet.private.id
+  }
+}
+
+resource "aws_networkfirewall_rule_group" "suricata" {
+  provider = aws.us_east_1
+  capacity = 1000
+  rule_group_name = "suricata-compatible-rules"
+  type = "STATEFUL"
+  rule_group {
+    rules_source {
+      rules_string = "alert tcp any any -> any any (msg:\"Example rule\"; sid:1;)"
+    }
+  }
+}

generated/complex/gpt-4o/complex-aws-tf-002/main.tf

@@ -0,0 +1,338 @@
+provider "aws" {
+  region = "us-west-2"
+}
+
+resource "aws_eks_cluster" "example" {
+  name     = "zero-trust-platform"
+  role_arn = aws_iam_role.eks_cluster_role.arn
+
+  vpc_config {
+    subnet_ids = aws_subnet.eks_subnets[*].id
+  }
+
+  depends_on = [aws_iam_role_policy_attachment.eks_cluster_policy]
+}
+
+resource "aws_iam_role" "eks_cluster_role" {
+  name = "eks-cluster-role"
+
+  assume_role_policy = data.aws_iam_policy_document.eks_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "eks_assume_role_policy" {
+  statement {
+    actions = ["sts:AssumeRole"]
+
+    principals {
+      type        = "Service"
+      identifiers = ["eks.amazonaws.com"]
+    }
+  }
+}
+
+resource "aws_iam_role_policy_attachment" "eks_cluster_policy" {
+  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
+  role       = aws_iam_role.eks_cluster_role.name
+}
+
+resource "aws_eks_node_group" "spot_nodes" {
+  cluster_name    = aws_eks_cluster.example.name
+  node_group_name = "spot-nodes"
+  node_role_arn   = aws_iam_role.eks_node_role.arn
+  subnets         = aws_subnet.eks_subnets[*].id
+
+  scaling_config {
+    desired_size = 2
+    max_size     = 5
+    min_size     = 1
+  }
+
+  capacity_type = "SPOT"
+}
+
+resource "aws_eks_node_group" "on_demand_nodes" {
+  cluster_name    = aws_eks_cluster.example.name
+  node_group_name = "on-demand-nodes"
+  node_role_arn   = aws_iam_role.eks_node_role.arn
+  subnets         = aws_subnet.eks_subnets[*].id
+
+  scaling_config {
+    desired_size = 2
+    max_size     = 5
+    min_size     = 1
+  }
+
+  capacity_type = "ON_DEMAND"
+}
+
+resource "aws_iam_role" "eks_node_role" {
+  name = "eks-node-role"
+
+  assume_role_policy = data.aws_iam_policy_document.eks_node_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "eks_node_assume_role_policy" {
+  statement {
+    actions = ["sts:AssumeRole"]
+
+    principals {
+      type        = "Service"
+      identifiers = ["ec2.amazonaws.com"]
+    }
+  }
+}
+
+resource "aws_iam_role_policy_attachment" "eks_worker_node_policy" {
+  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
+  role       = aws_iam_role.eks_node_role.name
+}
+
+resource "aws_iam_role_policy_attachment" "eks_cni_policy" {
+  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSCNIPolicy"
+  role       = aws_iam_role.eks_node_role.name
+}
+
+resource "aws_iam_role_policy_attachment" "ec2_container_registry_read_only" {
+  policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
+  role       = aws_iam_role.eks_node_role.name
+}
+
+resource "aws_iam_role" "external_dns_role" {
+  name = "external-dns-role"
+
+  assume_role_policy = data.aws_iam_policy_document.external_dns_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "external_dns_assume_role_policy" {
+  statement {
+    actions = ["sts:AssumeRole"]
+
+    principals {
+      type        = "Service"
+      identifiers = ["eks.amazonaws.com"]
+    }
+  }
+}
+
+resource "aws_iam_policy" "external_dns_policy" {
+  name = "ExternalDNSPolicy"
+
+  policy = data.aws_iam_policy_document.external_dns_policy.json
+}
+
+data "aws_iam_policy_document" "external_dns_policy" {
+  statement {
+    actions = [
+      "route53:ChangeResourceRecordSets",
+      "route53:ListHostedZones",
+      "route53:ListResourceRecordSets"
+    ]
+
+    resources = ["*"]
+  }
+}
+
+resource "aws_iam_role_policy_attachment" "external_dns_policy_attachment" {
+  policy_arn = aws_iam_policy.external_dns_policy.arn
+  role       = aws_iam_role.external_dns_role.name
+}
+
+resource "aws_iam_role" "fluent_bit_role" {
+  name = "fluent-bit-role"
+
+  assume_role_policy = data.aws_iam_policy_document.fluent_bit_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "fluent_bit_assume_role_policy" {
+  statement {
+    actions = ["sts:AssumeRole"]
+
+    principals {
+      type        = "Service"
+      identifiers = ["eks.amazonaws.com"]
+    }
+  }
+}
+
+resource "aws_iam_policy" "fluent_bit_policy" {
+  name = "FluentBitPolicy"
+
+  policy = data.aws_iam_policy_document.fluent_bit_policy.json
+}
+
+data "aws_iam_policy_document" "fluent_bit_policy" {
+  statement {
+    actions = [
+      "logs:PutLogEvents",
+      "logs:DescribeLogStreams",
+      "logs:DescribeLogGroups",
+      "logs:CreateLogStream",
+      "logs:CreateLogGroup"
+    ]
+
+    resources = ["*"]
+  }
+}
+
+resource "aws_iam_role_policy_attachment" "fluent_bit_policy_attachment" {
+  policy_arn = aws_iam_policy.fluent_bit_policy.arn
+  role       = aws_iam_role.fluent_bit_role.name
+}
+
+resource "kubernetes_namespace" "tenant_a" {
+  metadata {
+    name = "tenant-a"
+  }
+}
+
+resource "kubernetes_namespace" "tenant_b" {
+  metadata {
+    name = "tenant-b"
+  }
+}
+
+resource "kubernetes_resource_quota" "tenant_a_quota" {
+  metadata {
+    name      = "tenant-a-quota"
+    namespace = kubernetes_namespace.tenant_a.metadata[0].name
+  }
+
+  spec {
+    hard = {
+      "requests.cpu"    = "1",
+      "requests.memory" = "1Gi",
+      "limits.cpu"      = "2",
+      "limits.memory"   = "2Gi"
+    }
+  }
+}
+
+resource "kubernetes_limit_range" "tenant_a_limits" {
+  metadata {
+    name      = "tenant-a-limits"
+    namespace = kubernetes_namespace.tenant_a.metadata[0].name
+  }
+
+  spec {
+    limit {
+      type           = "Container"
+      default        = { "cpu" = "500m", "memory" = "512Mi" }
+      default_request = { "cpu" = "250m", "memory" = "256Mi" }
+    }
+  }
+}
+
+resource "kubernetes_network_policy" "tenant_a_policy" {
+  metadata {
+    name      = "tenant-a-policy"
+    namespace = kubernetes_namespace.tenant_a.metadata[0].name
+  }
+
+  spec {
+    pod_selector {}
+
+    ingress {
+      from {
+        pod_selector {}
+      }
+    }
+  }
+}
+
+resource "kubernetes_network_policy" "tenant_b_policy" {
+  metadata {
+    name      = "tenant-b-policy"
+    namespace = kubernetes_namespace.tenant_b.metadata[0].name
+  }
+
+  spec {
+    pod_selector {}
+
+    ingress {
+      from {
+        pod_selector {}
+      }
+    }
+  }
+}
+
+resource "kubernetes_service_account" "external_dns" {
+  metadata {
+    name      = "external-dns"
+    namespace = "kube-system"
+    annotations = {
+      "eks.amazonaws.com/role-arn" = aws_iam_role.external_dns_role.arn
+    }
+  }
+}
+
+resource "kubernetes_service_account" "fluent_bit" {
+  metadata {
+    name      = "fluent-bit"
+    namespace = "kube-system"
+    annotations = {
+      "eks.amazonaws.com/role-arn" = aws_iam_role.fluent_bit_role.arn
+    }
+  }
+}
+
+resource "kubernetes_daemonset" "fluent_bit" {
+  metadata {
+    name      = "fluent-bit"
+    namespace = "kube-system"
+  }
+
+  spec {
+    selector {
+      match_labels = {
+        "app" = "fluent-bit"
+      }
+    }
+
+    template {
+      metadata {
+        labels = {
+          "app" = "fluent-bit"
+        }
+      }
+
+      spec {
+        service_account_name = kubernetes_service_account.fluent_bit.metadata[0].name
+
+        container {
+          name  = "fluent-bit"
+          image = "fluent/fluent-bit:latest"
+
+          resources {
+            limits {
+              cpu    = "100m"
+              memory = "200Mi"
+            }
+            requests {
+              cpu    = "50m"
+              memory = "100Mi"
+            }
+          }
+
+          volume_mount {
+            name      = "varlog"
+            mount_path = "/var/log"
+          }
+
+          env {
+            name  = "AWS_REGION"
+            value = "us-west-2"
+          }
+        }
+
+        volume {
+          name = "varlog"
+
+          host_path {
+            path = "/var/log"
+          }
+        }
+      }
+    }
+  }
+}

generated/complex/gpt-4o/complex-aws-tf-003/main.tf

@@ -0,0 +1,255 @@
+provider "aws" {
+  region = "us-east-1"
+}
+
+resource "aws_kms_key" "dynamodb" {
+  description             = "KMS key for DynamoDB encryption"
+  deletion_window_in_days = 30
+}
+
+resource "aws_dynamodb_table" "data_table" {
+  name           = "data-table"
+  billing_mode   = "PAY_PER_REQUEST"
+  hash_key       = "id"
+  attribute {
+    name = "id"
+    type = "S"
+  }
+  server_side_encryption {
+    enabled     = true
+    kms_key_arn = aws_kms_key.dynamodb.arn
+  }
+  point_in_time_recovery {
+    enabled = true
+  }
+}
+
+resource "aws_s3_bucket" "data_bucket" {
+  bucket = "data-bucket"
+  versioning {
+    enabled = true
+  }
+  server_side_encryption_configuration {
+    rule {
+      apply_server_side_encryption_by_default {
+        sse_algorithm     = "aws:kms"
+        kms_master_key_id = aws_kms_key.dynamodb.arn
+      }
+    }
+  }
+  object_lock_configuration {
+    object_lock_enabled = "Enabled"
+    rule {
+      default_retention {
+        mode  = "COMPLIANCE"
+        days  = 365
+      }
+    }
+  }
+  logging {
+    target_bucket = aws_s3_bucket.logging_bucket.id
+    target_prefix = "data-bucket-logs/"
+  }
+  policy = <<POLICY
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "DenyUnencryptedObjectUploads",
+      "Effect": "Deny",
+      "Principal": "*",
+      "Action": "s3:PutObject",
+      "Resource": "arn:aws:s3:::data-bucket/*",
+      "Condition": {
+        "StringNotEquals": {
+          "s3:x-amz-server-side-encryption": "aws:kms"
+        }
+      }
+    },
+    {
+      "Sid": "AllowSSLRequestsOnly",
+      "Effect": "Deny",
+      "Principal": "*",
+      "Action": "s3:*",
+      "Resource": "arn:aws:s3:::data-bucket/*",
+      "Condition": {
+        "Bool": {
+          "aws:SecureTransport": "false"
+        }
+      }
+    }
+  ]
+}
+POLICY
+}
+
+resource "aws_s3_bucket" "logging_bucket" {
+  bucket = "logging-bucket"
+}
+
+resource "aws_sqs_queue" "fifo_queue" {
+  name                        = "fifo-queue.fifo"
+  fifo_queue                  = true
+  content_based_deduplication = true
+  kms_master_key_id           = aws_kms_key.dynamodb.arn
+}
+
+resource "aws_sqs_queue" "dead_letter_queue" {
+  name              = "dead-letter-queue.fifo"
+  fifo_queue        = true
+  kms_master_key_id = aws_kms_key.dynamodb.arn
+}
+
+resource "aws_lambda_function" "data_processor" {
+  filename         = "function.zip"
+  function_name    = "data_processor"
+  role             = aws_iam_role.lambda_exec.arn
+  handler          = "index.handler"
+  runtime          = "nodejs14.x"
+  vpc_config {
+    subnet_ids         = ["subnet-abc123", "subnet-def456"]
+    security_group_ids = ["sg-123456"]
+  }
+  provisioned_concurrent_executions = 5
+}
+
+resource "aws_api_gateway_rest_api" "api" {
+  name = "data-api"
+}
+
+resource "aws_api_gateway_stage" "stage" {
+  stage_name    = "prod"
+  rest_api_id   = aws_api_gateway_rest_api.api.id
+  deployment_id = aws_api_gateway_deployment.deployment.id
+}
+
+resource "aws_api_gateway_deployment" "deployment" {
+  rest_api_id = aws_api_gateway_rest_api.api.id
+  triggers = {
+    redeployment = sha1(file("swagger.yaml"))
+  }
+}
+
+resource "aws_wafv2_web_acl" "web_acl" {
+  name        = "web-acl"
+  scope       = "REGIONAL"
+  description = "WAF for API Gateway"
+  default_action {
+    allow {}
+  }
+  rule {
+    name     = "RateLimit"
+    priority = 1
+    statement {
+      rate_based_statement {
+        limit = 1000
+        aggregate_key_type = "IP"
+      }
+    }
+    action {
+      block {}
+    }
+    visibility_config {
+      sampled_requests_enabled = true
+      cloudwatch_metrics_enabled = true
+      metric_name = "RateLimit"
+    }
+  }
+  rule {
+    name     = "GeoBlock"
+    priority = 2
+    statement {
+      geo_match_statement {
+        country_codes = ["US", "CA"]
+      }
+    }
+    action {
+      block {}
+    }
+    visibility_config {
+      sampled_requests_enabled = true
+      cloudwatch_metrics_enabled = true
+      metric_name = "GeoBlock"
+    }
+  }
+}
+
+resource "aws_cloudtrail" "organization_trail" {
+  name                          = "organization-trail"
+  is_organization_trail         = true
+  include_global_service_events = true
+  is_multi_region_trail         = true
+  enable_log_file_validation    = true
+  s3_bucket_name                = aws_s3_bucket.logging_bucket.id
+  event_selector {
+    read_write_type           = "All"
+    include_management_events = true
+    data_resource {
+      type   = "AWS::S3::Object"
+      values = ["arn:aws:s3:::data-bucket/"]
+    }
+    data_resource {
+      type   = "AWS::Lambda::Function"
+      values = ["arn:aws:lambda:us-east-1:123456789012:function:data_processor"]
+    }
+  }
+}
+
+resource "aws_sfn_state_machine" "state_machine" {
+  name     = "data-processing-state-machine"
+  role_arn = aws_iam_role.sfn_role.arn
+  definition = <<DEFINITION
+{
+  "Comment": "A simple AWS Step Functions state machine",
+  "StartAt": "LambdaInvoke",
+  "States": {
+    "LambdaInvoke": {
+      "Type": "Task",
+      "Resource": "${aws_lambda_function.data_processor.arn}",
+      "End": true
+    }
+  }
+}
+DEFINITION
+  tracing_configuration {
+    enabled = true
+  }
+}
+
+resource "aws_iam_role" "lambda_exec" {
+  name = "lambda_exec_role"
+  assume_role_policy = <<POLICY
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Action": "sts:AssumeRole",
+      "Principal": {
+        "Service": "lambda.amazonaws.com"
+      },
+      "Effect": "Allow",
+      "Sid": ""
+    }
+  ]
+}
+POLICY
+}
+
+resource "aws_iam_role" "sfn_role" {
+  name = "sfn_role"
+  assume_role_policy = <<POLICY
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Action": "sts:AssumeRole",
+      "Principal": {
+        "Service": "states.amazonaws.com"
+      },
+      "Effect": "Allow",
+      "Sid": ""
+    }
+  ]
+}
+POLICY
+}

generated/complex/gpt-4o/complex-aws-tf-004/main.yaml

@@ -0,0 +1,266 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Description: AWS CloudFormation StackSet for Security Baseline
+
+Resources:
+  SecurityBaselineStackSet:
+    Type: AWS::CloudFormation::StackSet
+    Properties:
+      StackSetName: SecurityBaseline
+      PermissionModel: SERVICE_MANAGED
+      AutoDeployment:
+        Enabled: true
+        RetainStacksOnAccountRemoval: false
+      Capabilities:
+        - CAPABILITY_NAMED_IAM
+      Parameters:
+        - ParameterKey: SecurityOperationsEmail
+          ParameterValue: security-ops@example.com
+      TemplateBody: |
+        AWSTemplateFormatVersion: '2010-09-09'
+        Description: Security Baseline Template
+
+        Resources:
+          ConfigRecorder:
+            Type: AWS::Config::ConfigurationRecorder
+            Properties:
+              Name: default
+              RoleARN: !Sub arn:aws:iam::${AWS::AccountId}:role/aws-service-role/config.amazonaws.com/AWSServiceRoleForConfig
+              RecordingGroup:
+                AllSupported: true
+                IncludeGlobalResourceTypes: true
+
+          ConfigDeliveryChannel:
+            Type: AWS::Config::DeliveryChannel
+            Properties:
+              S3BucketName: !Sub aws-config-bucket-${AWS::AccountId}
+              ConfigSnapshotDeliveryProperties:
+                DeliveryFrequency: One_Hour
+
+          ConfigRuleEncryptedVolumes:
+            Type: AWS::Config::ConfigRule
+            Properties:
+              ConfigRuleName: encrypted-volumes
+              Source:
+                Owner: AWS
+                SourceIdentifier: ENCRYPTED_VOLUMES
+
+          ConfigRuleRootMfa:
+            Type: AWS::Config::ConfigRule
+            Properties:
+              ConfigRuleName: root-account-mfa-enabled
+              Source:
+                Owner: AWS
+                SourceIdentifier: ROOT_ACCOUNT_MFA_ENABLED
+
+          ConfigRuleVpcFlowLogs:
+            Type: AWS::Config::ConfigRule
+            Properties:
+              ConfigRuleName: vpc-flow-logs-enabled
+              Source:
+                Owner: AWS
+                SourceIdentifier: VPC_FLOW_LOGS_ENABLED
+
+          GuardDutyDetector:
+            Type: AWS::GuardDuty::Detector
+            Properties:
+              Enable: true
+              FindingPublishingFrequency: FIFTEEN_MINUTES
+
+          GuardDutyS3Protection:
+            Type: AWS::GuardDuty::Detector
+            Properties:
+              DataSources:
+                S3Logs:
+                  Enable: true
+
+          GuardDutyEksAuditLogs:
+            Type: AWS::GuardDuty::Detector
+            Properties:
+              DataSources:
+                Kubernetes:
+                  AuditLogs:
+                    Enable: true
+
+          SecurityHub:
+            Type: AWS::SecurityHub::Hub
+            Properties: {}
+
+          SecurityHubCIS:
+            Type: AWS::SecurityHub::StandardsSubscription
+            Properties:
+              StandardsArn: !Sub arn:aws:securityhub:${AWS::Region}::standards/cis-aws-foundations-benchmark/v/1.2.0
+
+          SecurityHubPCI:
+            Type: AWS::SecurityHub::StandardsSubscription
+            Properties:
+              StandardsArn: !Sub arn:aws:securityhub:${AWS::Region}::standards/pci-dss/v/3.2.1
+
+          AccessAnalyzer:
+            Type: AWS::AccessAnalyzer::Analyzer
+            Properties:
+              AnalyzerName: OrganizationAccessAnalyzer
+              Type: ORGANIZATION
+
+          CloudTrail:
+            Type: AWS::CloudTrail::Trail
+            Properties:
+              IsOrganizationTrail: true
+              S3BucketName: !Sub aws-cloudtrail-bucket-${AWS::AccountId}
+              IncludeGlobalServiceEvents: true
+              IsMultiRegionTrail: true
+              CloudWatchLogsLogGroupArn: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:CloudTrailLogs
+              CloudWatchLogsRoleArn: !Sub arn:aws:iam::${AWS::AccountId}:role/CloudTrail_CloudWatchLogs_Role
+
+          UnauthorizedApiCallsMetricFilter:
+            Type: AWS::Logs::MetricFilter
+            Properties:
+              LogGroupName: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:CloudTrailLogs
+              FilterPattern: '{ ($.errorCode = "*UnauthorizedOperation") || ($.errorCode = "AccessDenied*") }'
+              MetricTransformations:
+                - MetricValue: "1"
+                  MetricNamespace: CloudTrailMetrics
+                  MetricName: UnauthorizedApiCalls
+
+          ConsoleSigninWithoutMfaMetricFilter:
+            Type: AWS::Logs::MetricFilter
+            Properties:
+              LogGroupName: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:CloudTrailLogs
+              FilterPattern: '{ ($.eventName = "ConsoleLogin") && ($.additionalEventData.MFAUsed != "Yes") }'
+              MetricTransformations:
+                - MetricValue: "1"
+                  MetricNamespace: CloudTrailMetrics
+                  MetricName: ConsoleSigninWithoutMfa
+
+          RootAccountUsageMetricFilter:
+            Type: AWS::Logs::MetricFilter
+            Properties:
+              LogGroupName: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:CloudTrailLogs
+              FilterPattern: '{ $.userIdentity.type = "Root" && $.userIdentity.invokedBy NOT EXISTS && $.eventType != "AwsServiceEvent" }'
+              MetricTransformations:
+                - MetricValue: "1"
+                  MetricNamespace: CloudTrailMetrics
+                  MetricName: RootAccountUsage
+
+          SnsTopic:
+            Type: AWS::SNS::Topic
+            Properties:
+              Subscription:
+                - Endpoint: !Ref SecurityOperationsEmail
+                  Protocol: email
+
+          UnauthorizedApiCallsAlarm:
+            Type: AWS::CloudWatch::Alarm
+            Properties:
+              AlarmName: UnauthorizedApiCalls
+              MetricName: UnauthorizedApiCalls
+              Namespace: CloudTrailMetrics
+              Statistic: Sum
+              Period: 300
+              EvaluationPeriods: 1
+              Threshold: 1
+              ComparisonOperator: GreaterThanOrEqualToThreshold
+              AlarmActions:
+                - !Ref SnsTopic
+
+          ConsoleSigninWithoutMfaAlarm:
+            Type: AWS::CloudWatch::Alarm
+            Properties:
+              AlarmName: ConsoleSigninWithoutMfa
+              MetricName: ConsoleSigninWithoutMfa
+              Namespace: CloudTrailMetrics
+              Statistic: Sum
+              Period: 300
+              EvaluationPeriods: 1
+              Threshold: 1
+              ComparisonOperator: GreaterThanOrEqualToThreshold
+              AlarmActions:
+                - !Ref SnsTopic
+
+          RootAccountUsageAlarm:
+            Type: AWS::CloudWatch::Alarm
+            Properties:
+              AlarmName: RootAccountUsage
+              MetricName: RootAccountUsage
+              Namespace: CloudTrailMetrics
+              Statistic: Sum
+              Period: 300
+              EvaluationPeriods: 1
+              Threshold: 1
+              ComparisonOperator: GreaterThanOrEqualToThreshold
+              AlarmActions:
+                - !Ref SnsTopic
+
+          LambdaEbsEncryption:
+            Type: AWS::Lambda::Function
+            Properties:
+              Handler: index.handler
+              Role: !GetAtt LambdaExecutionRole.Arn
+              Code:
+                ZipFile: |
+                  import boto3
+                  def handler(event, context):
+                      ec2 = boto3.client('ec2')
+                      ec2.modify_ebs_default_kms_key_id(KmsKeyId='alias/aws/ebs')
+                      ec2.enable_ebs_encryption_by_default()
+              Runtime: python3.8
+
+          LambdaS3PublicAccessBlock:
+            Type: AWS::Lambda::Function
+            Properties:
+              Handler: index.handler
+              Role: !GetAtt LambdaExecutionRole.Arn
+              Code:
+                ZipFile: |
+                  import boto3
+                  def handler(event, context):
+                      s3 = boto3.client('s3control')
+                      account_id = boto3.client('sts').get_caller_identity().get('Account')
+                      s3.put_public_access_block(
+                          AccountId=account_id,
+                          PublicAccessBlockConfiguration={
+                              'BlockPublicAcls': True,
+                              'IgnorePublicAcls': True,
+                              'BlockPublicPolicy': True,
+                              'RestrictPublicBuckets': True
+                          }
+                      )
+              Runtime: python3.8
+
+          LambdaExecutionRole:
+            Type: AWS::IAM::Role
+            Properties:
+              AssumeRolePolicyDocument:
+                Version: '2012-10-17'
+                Statement:
+                  - Effect: Allow
+                    Principal:
+                      Service: lambda.amazonaws.com
+                    Action: sts:AssumeRole
+              Policies:
+                - PolicyName: LambdaEbsEncryptionPolicy
+                  PolicyDocument:
+                    Version: '2012-10-17'
+                    Statement:
+                      - Effect: Allow
+                        Action:
+                          - ec2:ModifyEbsDefaultKmsKeyId
+                          - ec2:EnableEbsEncryptionByDefault
+                        Resource: '*'
+                - PolicyName: LambdaS3PublicAccessBlockPolicy
+                  PolicyDocument:
+                    Version: '2012-10-17'
+                    Statement:
+                      - Effect: Allow
+                        Action:
+                          - s3:PutAccountPublicAccessBlock
+                        Resource: '*'
+
+      DeploymentTargets:
+        OrganizationalUnitIds:
+          - ou-1234
+          - ou-5678
+          - ou-91011
+
+      Regions:
+        - us-east-1
+        - us-west-2

generated/complex/gpt-4o/complex-aws-tf-005/main.yaml

@@ -0,0 +1,425 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Resources:
+  ECRRepository:
+    Type: AWS::ECR::Repository
+    Properties:
+      RepositoryName: my-app-repo
+      ImageScanningConfiguration:
+        ScanOnPush: true
+      LifecyclePolicy:
+        LifecyclePolicyText: |
+          {
+            "rules": [
+              {
+                "rulePriority": 1,
+                "description": "Retain only last 10 images",
+                "selection": {
+                  "tagStatus": "any",
+                  "countType": "imageCountMoreThan",
+                  "countNumber": 10
+                },
+                "action": {
+                  "type": "expire"
+                }
+              }
+            ]
+          }
+
+  ECSCluster:
+    Type: AWS::ECS::Cluster
+    Properties:
+      ClusterName: my-ecs-cluster
+      ClusterSettings:
+        - Name: containerInsights
+          Value: enabled
+
+  ALB:
+    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
+    Properties:
+      Name: my-alb
+      Scheme: internet-facing
+      Subnets: 
+        - subnet-12345678
+        - subnet-87654321
+      SecurityGroups: 
+        - !Ref ALBSecurityGroup
+
+  ALBSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupDescription: Allow HTTP and HTTPS traffic
+      VpcId: vpc-12345678
+      SecurityGroupIngress:
+        - IpProtocol: tcp
+          FromPort: 80
+          ToPort: 80
+          CidrIp: 0.0.0.0/0
+        - IpProtocol: tcp
+          FromPort: 443
+          ToPort: 443
+          CidrIp: 0.0.0.0/0
+
+  ECSServiceSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupDescription: Allow traffic from ALB only
+      VpcId: vpc-12345678
+      SecurityGroupIngress:
+        - IpProtocol: tcp
+          FromPort: 80
+          ToPort: 80
+          SourceSecurityGroupId: !Ref ALBSecurityGroup
+
+  TargetGroupBlue:
+    Type: AWS::ElasticLoadBalancingV2::TargetGroup
+    Properties:
+      Name: my-blue-target-group
+      Port: 80
+      Protocol: HTTP
+      VpcId: vpc-12345678
+      TargetType: ip
+
+  TargetGroupGreen:
+    Type: AWS::ElasticLoadBalancingV2::TargetGroup
+    Properties:
+      Name: my-green-target-group
+      Port: 80
+      Protocol: HTTP
+      VpcId: vpc-12345678
+      TargetType: ip
+
+  Listener:
+    Type: AWS::ElasticLoadBalancingV2::Listener
+    Properties:
+      LoadBalancerArn: !Ref ALB
+      Port: 80
+      Protocol: HTTP
+      DefaultActions:
+        - Type: forward
+          TargetGroupArn: !Ref TargetGroupBlue
+
+  ECSServiceBlue:
+    Type: AWS::ECS::Service
+    Properties:
+      Cluster: !Ref ECSCluster
+      DesiredCount: 1
+      LaunchType: FARGATE
+      NetworkConfiguration:
+        AwsvpcConfiguration:
+          AssignPublicIp: ENABLED
+          SecurityGroups:
+            - !Ref ECSServiceSecurityGroup
+          Subnets:
+            - subnet-12345678
+            - subnet-87654321
+      TaskDefinition: !Ref TaskDefinition
+      LoadBalancers:
+        - TargetGroupArn: !Ref TargetGroupBlue
+          ContainerName: my-container
+          ContainerPort: 80
+
+  ECSServiceGreen:
+    Type: AWS::ECS::Service
+    Properties:
+      Cluster: !Ref ECSCluster
+      DesiredCount: 1
+      LaunchType: FARGATE
+      NetworkConfiguration:
+        AwsvpcConfiguration:
+          AssignPublicIp: ENABLED
+          SecurityGroups:
+            - !Ref ECSServiceSecurityGroup
+          Subnets:
+            - subnet-12345678
+            - subnet-87654321
+      TaskDefinition: !Ref TaskDefinition
+      LoadBalancers:
+        - TargetGroupArn: !Ref TargetGroupGreen
+          ContainerName: my-container
+          ContainerPort: 80
+
+  TaskDefinition:
+    Type: AWS::ECS::TaskDefinition
+    Properties:
+      Family: my-task-family
+      NetworkMode: awsvpc
+      RequiresCompatibilities:
+        - FARGATE
+      Cpu: '256'
+      Memory: '512'
+      ContainerDefinitions:
+        - Name: my-container
+          Image: !Sub "${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/my-app-repo:latest"
+          Essential: true
+          PortMappings:
+            - ContainerPort: 80
+          Secrets:
+            - Name: MY_SECRET
+              ValueFrom: !Sub "arn:aws:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:my-secret"
+          Environment:
+            - Name: CONFIG_PARAM
+              Value: !Sub "{{resolve:ssm:/my/config/param}}"
+
+  CodePipeline:
+    Type: AWS::CodePipeline::Pipeline
+    Properties:
+      RoleArn: !GetAtt CodePipelineRole.Arn
+      Stages:
+        - Name: Source
+          Actions:
+            - Name: Source
+              ActionTypeId:
+                Category: Source
+                Owner: AWS
+                Provider: CodeCommit
+                Version: 1
+              OutputArtifacts:
+                - Name: SourceOutput
+              Configuration:
+                RepositoryName: my-repo
+                BranchName: main
+        - Name: Build
+          Actions:
+            - Name: Build
+              ActionTypeId:
+                Category: Build
+                Owner: AWS
+                Provider: CodeBuild
+                Version: 1
+              InputArtifacts:
+                - Name: SourceOutput
+              OutputArtifacts:
+                - Name: BuildOutput
+              Configuration:
+                ProjectName: !Ref CodeBuildProject
+        - Name: Approval
+          Actions:
+            - Name: ManualApproval
+              ActionTypeId:
+                Category: Approval
+                Owner: AWS
+                Provider: Manual
+                Version: 1
+              Configuration:
+                CustomData: "Please approve the deployment"
+                NotificationArn: !Ref ApprovalSNS
+        - Name: Deploy
+          Actions:
+            - Name: Deploy
+              ActionTypeId:
+                Category: Deploy
+                Owner: AWS
+                Provider: CodeDeploy
+                Version: 1
+              InputArtifacts:
+                - Name: BuildOutput
+              Configuration:
+                ApplicationName: !Ref CodeDeployApplication
+                DeploymentGroupName: !Ref CodeDeployDeploymentGroup
+
+  CodeBuildProject:
+    Type: AWS::CodeBuild::Project
+    Properties:
+      Name: my-build-project
+      Source:
+        Type: CODEPIPELINE
+      Environment:
+        ComputeType: BUILD_GENERAL1_SMALL
+        Image: aws/codebuild/standard:5.0
+        Type: LINUX_CONTAINER
+        VpcConfig:
+          SecurityGroupIds:
+            - !Ref BuildSecurityGroup
+          Subnets:
+            - subnet-12345678
+            - subnet-87654321
+      ServiceRole: !GetAtt CodeBuildRole.Arn
+
+  BuildSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupDescription: Allow build access
+      VpcId: vpc-12345678
+
+  ApprovalSNS:
+    Type: AWS::SNS::Topic
+    Properties:
+      Subscription:
+        - Endpoint: my-email@example.com
+          Protocol: email
+
+  CodeDeployApplication:
+    Type: AWS::CodeDeploy::Application
+    Properties:
+      ComputePlatform: ECS
+
+  CodeDeployDeploymentGroup:
+    Type: AWS::CodeDeploy::DeploymentGroup
+    Properties:
+      ApplicationName: !Ref CodeDeployApplication
+      DeploymentConfigName: CodeDeployDefault.ECSCanary10Percent5Minutes
+      ServiceRoleArn: !GetAtt CodeDeployRole.Arn
+      DeploymentStyle:
+        DeploymentType: BLUE_GREEN
+        DeploymentOption: WITH_TRAFFIC_CONTROL
+      BlueGreenDeploymentConfiguration:
+        TerminateBlueInstancesOnDeploymentSuccess:
+          Action: TERMINATE
+          TerminationWaitTimeInMinutes: 5
+        DeploymentReadyOption:
+          ActionOnTimeout: CONTINUE_DEPLOYMENT
+          WaitTimeInMinutes: 0
+        GreenFleetProvisioningOption:
+          Action: DISCOVER_EXISTING
+      LoadBalancerInfo:
+        TargetGroupPairInfoList:
+          - TargetGroups:
+              - Name: !Ref TargetGroupBlue
+              - Name: !Ref TargetGroupGreen
+            ProdTrafficRoute:
+              ListenerArns:
+                - !Ref Listener
+      AlarmConfiguration:
+        Alarms:
+          - Name: !Ref Alarm5xxErrorRate
+          - Name: !Ref AlarmP99Latency
+        Enabled: true
+        IgnorePollAlarmFailure: false
+
+  Alarm5xxErrorRate:
+    Type: AWS::CloudWatch::Alarm
+    Properties:
+      AlarmName: 5xxErrorRate
+      MetricName: HTTPCode_Target_5XX_Count
+      Namespace: AWS/ApplicationELB
+      Statistic: Sum
+      Period: 60
+      EvaluationPeriods: 1
+      Threshold: 1
+      ComparisonOperator: GreaterThanThreshold
+      Dimensions:
+        - Name: LoadBalancer
+          Value: !GetAtt ALB.LoadBalancerFullName
+
+  AlarmP99Latency:
+    Type: AWS::CloudWatch::Alarm
+    Properties:
+      AlarmName: P99Latency
+      MetricName: TargetResponseTime
+      Namespace: AWS/ApplicationELB
+      Statistic: p99
+      Period: 60
+      EvaluationPeriods: 1
+      Threshold: 1
+      ComparisonOperator: GreaterThanThreshold
+      Dimensions:
+        - Name: LoadBalancer
+          Value: !GetAtt ALB.LoadBalancerFullName
+
+  CodePipelineRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: codepipeline.amazonaws.com
+            Action: sts:AssumeRole
+      Policies:
+        - PolicyName: CodePipelinePolicy
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: Allow
+                Action:
+                  - codecommit:GetBranch
+                  - codecommit:GetCommit
+                  - codecommit:UploadArchive
+                  - codecommit:GetUploadArchiveStatus
+                  - codecommit:CancelUploadArchive
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - codebuild:BatchGetBuilds
+                  - codebuild:StartBuild
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - codedeploy:CreateDeployment
+                  - codedeploy:GetApplication
+                  - codedeploy:GetApplicationRevision
+                  - codedeploy:GetDeployment
+                  - codedeploy:GetDeploymentConfig
+                  - codedeploy:RegisterApplicationRevision
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - sns:Publish
+                Resource: !Ref ApprovalSNS
+
+  CodeBuildRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: codebuild.amazonaws.com
+            Action: sts:AssumeRole
+      Policies:
+        - PolicyName: CodeBuildPolicy
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: Allow
+                Action:
+                  - ecr:GetDownloadUrlForLayer
+                  - ecr:BatchGetImage
+                  - ecr:BatchCheckLayerAvailability
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - logs:CreateLogGroup
+                  - logs:CreateLogStream
+                  - logs:PutLogEvents
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - ssm:GetParameters
+                Resource: "*"
+
+  CodeDeployRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: codedeploy.amazonaws.com
+            Action: sts:AssumeRole
+      Policies:
+        - PolicyName: CodeDeployPolicy
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: Allow
+                Action:
+                  - ecs:DescribeServices
+                  - ecs:UpdateService
+                  - ecs:DescribeTaskDefinition
+                  - ecs:DescribeTasks
+                  - ecs:ListTasks
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - elasticloadbalancing:DescribeTargetGroups
+                  - elasticloadbalancing:DescribeTargetHealth
+                  - elasticloadbalancing:ModifyTargetGroup
+                Resource: "*"
+              - Effect: Allow
+                Action:
+                  - sns:Publish
+                Resource: !Ref ApprovalSNS

generated/complex/gpt-4o/complex-aws-tf-006/main.tf

@@ -0,0 +1,269 @@
+provider "aws" {
+  region = "us-east-1"
+}
+
+resource "aws_route53_zone" "primary" {
+  name = "example.com"
+}
+
+resource "aws_acm_certificate" "cert" {
+  domain_name       = "example.com"
+  validation_method = "DNS"
+
+  subject_alternative_names = [
+    "*.example.com",
+  ]
+
+  lifecycle {
+    create_before_destroy = true
+  }
+
+  provider = aws.us-east-1
+}
+
+resource "aws_acm_certificate_validation" "cert_validation" {
+  certificate_arn         = aws_acm_certificate.cert.arn
+  validation_record_fqdns = [aws_route53_record.cert_validation.fqdn]
+}
+
+resource "aws_route53_record" "cert_validation" {
+  zone_id = aws_route53_zone.primary.zone_id
+  name    = aws_acm_certificate.cert.domain_validation_options[0].resource_record_name
+  type    = aws_acm_certificate.cert.domain_validation_options[0].resource_record_type
+  records = [aws_acm_certificate.cert.domain_validation_options[0].resource_record_value]
+  ttl     = 60
+}
+
+resource "aws_cloudfront_distribution" "cdn" {
+  origin {
+    domain_name = aws_lb.application.dns_name
+    origin_id   = "alb-origin"
+
+    custom_origin_config {
+      http_port              = 80
+      https_port             = 443
+      origin_protocol_policy = "https-only"
+    }
+  }
+
+  enabled             = true
+  is_ipv6_enabled     = true
+  comment             = "CloudFront distribution for example.com"
+  default_root_object = "index.html"
+
+  aliases = ["example.com", "www.example.com"]
+
+  viewer_certificate {
+    acm_certificate_arn = aws_acm_certificate.cert.arn
+    ssl_support_method  = "sni-only"
+  }
+
+  default_cache_behavior {
+    allowed_methods  = ["GET", "HEAD", "OPTIONS"]
+    cached_methods   = ["GET", "HEAD"]
+    target_origin_id = "alb-origin"
+
+    forwarded_values {
+      query_string = false
+      cookies {
+        forward = "none"
+      }
+    }
+
+    viewer_protocol_policy = "redirect-to-https"
+    min_ttl                = 0
+    default_ttl            = 3600
+    max_ttl                = 86400
+  }
+
+  restrictions {
+    geo_restriction {
+      restriction_type = "none"
+    }
+  }
+
+  web_acl_id = aws_wafv2_web_acl.waf.arn
+}
+
+resource "aws_wafv2_web_acl" "waf" {
+  name        = "example-waf"
+  scope       = "CLOUDFRONT"
+  description = "WAF for CloudFront and ALB"
+
+  default_action {
+    allow {}
+  }
+
+  rule {
+    name     = "AWSManagedRulesCommonRuleSet"
+    priority = 1
+
+    override_action {
+      none {}
+    }
+
+    statement {
+      managed_rule_group_statement {
+        name        = "AWSManagedRulesCommonRuleSet"
+        vendor_name = "AWS"
+      }
+    }
+
+    visibility_config {
+      cloudwatch_metrics_enabled = true
+      metric_name                = "AWSManagedRulesCommonRuleSet"
+      sampled_requests_enabled   = true
+    }
+  }
+
+  rule {
+    name     = "AWSManagedRulesSQLiRuleSet"
+    priority = 2
+
+    override_action {
+      none {}
+    }
+
+    statement {
+      managed_rule_group_statement {
+        name        = "AWSManagedRulesSQLiRuleSet"
+        vendor_name = "AWS"
+      }
+    }
+
+    visibility_config {
+      cloudwatch_metrics_enabled = true
+      metric_name                = "AWSManagedRulesSQLiRuleSet"
+      sampled_requests_enabled   = true
+    }
+  }
+
+  rule {
+    name     = "AWSManagedRulesBotControlRuleSet"
+    priority = 3
+
+    override_action {
+      none {}
+    }
+
+    statement {
+      managed_rule_group_statement {
+        name        = "AWSManagedRulesBotControlRuleSet"
+        vendor_name = "AWS"
+      }
+    }
+
+    visibility_config {
+      cloudwatch_metrics_enabled = true
+      metric_name                = "AWSManagedRulesBotControlRuleSet"
+      sampled_requests_enabled   = true
+    }
+  }
+
+  visibility_config {
+    cloudwatch_metrics_enabled = true
+    metric_name                = "example-waf"
+    sampled_requests_enabled   = true
+  }
+}
+
+resource "aws_shield_protection" "cloudfront" {
+  name         = "example-cloudfront-protection"
+  resource_arn = aws_cloudfront_distribution.cdn.arn
+}
+
+resource "aws_shield_protection" "alb" {
+  name         = "example-alb-protection"
+  resource_arn = aws_lb.application.arn
+}
+
+resource "aws_autoscaling_group" "asg" {
+  launch_template {
+    id      = aws_launch_template.lt.id
+    version = "$Latest"
+  }
+
+  mixed_instances_policy {
+    launch_template {
+      launch_template_specification {
+        launch_template_id = aws_launch_template.lt.id
+        version            = "$Latest"
+      }
+
+      overrides {
+        instance_type = "t3.micro"
+      }
+
+      overrides {
+        instance_type = "t3a.micro"
+      }
+    }
+
+    instances_distribution {
+      on_demand_base_capacity                  = 1
+      on_demand_percentage_above_base_capacity = 50
+      spot_allocation_strategy                 = "capacity-optimized"
+    }
+  }
+
+  min_size         = 1
+  max_size         = 10
+  desired_capacity = 2
+
+  vpc_zone_identifier = ["subnet-12345678", "subnet-87654321"]
+
+  health_check_type         = "ELB"
+  health_check_grace_period = 300
+}
+
+resource "aws_launch_template" "lt" {
+  name = "example-launch-template"
+
+  block_device_mappings {
+    device_name = "/dev/xvda"
+
+    ebs {
+      delete_on_termination = true
+      volume_size           = 8
+      volume_type           = "gp2"
+      encrypted             = true
+    }
+  }
+
+  instance_type = "t3.micro"
+
+  metadata_options {
+    http_tokens = "required"
+  }
+
+  iam_instance_profile {
+    name = "example-instance-profile"
+  }
+
+  user_data = base64encode("#!/bin/bash\nyum install -y amazon-ssm-agent\n")
+
+  lifecycle {
+    create_before_destroy = true
+  }
+}
+
+resource "aws_rds_cluster" "aurora" {
+  cluster_identifier      = "aurora-cluster"
+  engine                  = "aurora-mysql"
+  engine_version          = "5.7.mysql_aurora.2.07.1"
+  master_username         = "admin"
+  master_password         = "password"
+  backup_retention_period = 5
+  preferred_backup_window = "07:00-09:00"
+  availability_zones      = ["us-east-1a", "us-east-1b", "us-east-1c"]
+
+  global_cluster_identifier = "aurora-global-cluster"
+  source_region             = "us-east-1"
+  enable_global_write_forwarding = true
+}
+
+resource "aws_ssm_parameter" "session_manager" {
+  name  = "/example/ssm/session-manager"
+  type  = "String"
+  value = "enabled"
+}

generated/complex/gpt-4o/complex-aws-tf-007/main.tf

@@ -0,0 +1,189 @@
+provider "aws" {
+  region = "us-east-1"
+}
+
+resource "aws_kms_key" "raw_tier" {
+  description = "KMS key for raw data tier"
+}
+
+resource "aws_kms_key" "curated_tier" {
+  description = "KMS key for curated data tier"
+}
+
+resource "aws_s3_bucket" "raw_data" {
+  bucket = "my-raw-data-bucket"
+  server_side_encryption_configuration {
+    rule {
+      apply_server_side_encryption_by_default {
+        sse_algorithm     = "aws:kms"
+        kms_master_key_id = aws_kms_key.raw_tier.arn
+      }
+    }
+  }
+  bucket_key_enabled = true
+}
+
+resource "aws_s3_bucket" "curated_data" {
+  bucket = "my-curated-data-bucket"
+  server_side_encryption_configuration {
+    rule {
+      apply_server_side_encryption_by_default {
+        sse_algorithm     = "aws:kms"
+        kms_master_key_id = aws_kms_key.curated_tier.arn
+      }
+    }
+  }
+  bucket_key_enabled = true
+  lifecycle_rule {
+    id      = "IntelligentTiering"
+    enabled = true
+    transitions {
+      days          = 30
+      storage_class = "INTELLIGENT_TIERING"
+    }
+  }
+}
+
+resource "aws_lakeformation_data_lake_settings" "default" {
+  admins = ["arn:aws:iam::123456789012:user/Admin"]
+}
+
+resource "aws_glue_crawler" "raw_crawler" {
+  name         = "raw-data-crawler"
+  role         = "arn:aws:iam::123456789012:role/AWSGlueServiceRole"
+  database_name = "raw_data_db"
+  s3_target {
+    path = aws_s3_bucket.raw_data.arn
+  }
+}
+
+resource "aws_glue_job" "etl_job" {
+  name     = "raw-to-curated-etl"
+  role_arn = "arn:aws:iam::123456789012:role/AWSGlueServiceRole"
+  command {
+    name            = "glueetl"
+    script_location = "s3://my-script-bucket/scripts/etl_script.py"
+  }
+  default_arguments = {
+    "--job-bookmark-option" = "job-bookmark-enable"
+  }
+}
+
+resource "aws_athena_workgroup" "primary" {
+  name = "primary"
+  configuration {
+    result_configuration {
+      output_location = "s3://my-athena-results/"
+      encryption_configuration {
+        encryption_option = "SSE_KMS"
+        kms_key_arn       = aws_kms_key.curated_tier.arn
+      }
+    }
+    enforce_workgroup_configuration = true
+    publish_cloudwatch_metrics_enabled = true
+    bytes_scanned_cutoff_per_query = 1000000000
+  }
+}
+
+resource "aws_redshiftserverless_namespace" "default" {
+  namespace_name = "my_namespace"
+  admin_username = "admin"
+  admin_user_password = "YourPassword123"
+}
+
+resource "aws_kinesis_firehose_delivery_stream" "raw_delivery" {
+  name        = "raw-delivery-stream"
+  destination = "extended_s3"
+
+  extended_s3_configuration {
+    role_arn           = "arn:aws:iam::123456789012:role/FirehoseDeliveryRole"
+    bucket_arn         = aws_s3_bucket.raw_data.arn
+    buffering_hints {
+      size_in_mbs = 128
+      interval_in_seconds = 300
+    }
+    data_format_conversion_configuration {
+      enabled = true
+      input_format_configuration {
+        deserializer {
+          open_x_json_ser_de {}
+        }
+      }
+      output_format_configuration {
+        serializer {
+          parquet_ser_de {}
+        }
+      }
+    }
+    dynamic_partitioning_configuration {
+      enabled = true
+    }
+  }
+}
+
+resource "aws_sfn_state_machine" "glue_etl_pipeline" {
+  name     = "GlueETLPipeline"
+  role_arn = "arn:aws:iam::123456789012:role/StepFunctionsExecutionRole"
+  definition = <<EOF
+{
+  "Comment": "A simple AWS Step Functions state machine that orchestrates Glue ETL jobs.",
+  "StartAt": "StartETLJob",
+  "States": {
+    "StartETLJob": {
+      "Type": "Task",
+      "Resource": "arn:aws:states:::glue:startJobRun.sync",
+      "Parameters": {
+        "JobName": "${aws_glue_job.etl_job.name}"
+      },
+      "Next": "SuccessState",
+      "Catch": [
+        {
+          "ErrorEquals": ["States.ALL"],
+          "ResultPath": "$.error-info",
+          "Next": "FailureNotification"
+        }
+      ]
+    },
+    "SuccessState": {
+      "Type": "Succeed"
+    },
+    "FailureNotification": {
+      "Type": "Task",
+      "Resource": "arn:aws:states:::sns:publish",
+      "Parameters": {
+        "TopicArn": "arn:aws:sns:us-east-1:123456789012:ETLFailureTopic",
+        "Message": "ETL job failed: $.error-info"
+      },
+      "End": true
+    }
+  }
+}
+EOF
+}
+
+resource "aws_cloudwatch_dashboard" "data_freshness" {
+  dashboard_name = "DataFreshnessMetrics"
+  dashboard_body = <<EOF
+{
+  "widgets": [
+    {
+      "type": "metric",
+      "x": 0,
+      "y": 0,
+      "width": 24,
+      "height": 6,
+      "properties": {
+        "metrics": [
+          [ "AWS/Glue", "BytesProcessed", "JobName", "${aws_glue_job.etl_job.name}" ],
+          [ ".", "JobDuration", ".", "." ]
+        ],
+        "period": 300,
+        "stat": "Sum",
+        "region": "us-east-1",
+        "title": "Glue ETL Job Metrics"
+      }
+    }
+  ]
+}
+EOF
+}

generated/complex/gpt-4o/complex-aws-tf-008/main.tf

@@ -0,0 +1,200 @@
+provider "aws" {
+  region = "us-east-1"
+}
+
+resource "aws_organizations_organizational_unit" "aft_ou" {
+  name      = "AFT-Accounts"
+  parent_id = "r-examplerootid"
+}
+
+resource "aws_organizations_policy" "deny_regions" {
+  name        = "DenyRegionsOutsideUSEast1EUWest1"
+  description = "Deny access to regions outside us-east-1 and eu-west-1"
+  content     = jsonencode({
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Effect": "Deny",
+        "Action": "*",
+        "Resource": "*",
+        "Condition": {
+          "StringNotEquals": {
+            "aws:RequestedRegion": ["us-east-1", "eu-west-1"]
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_organizations_policy" "deny_iam_users_console_access" {
+  name        = "DenyIAMUsersConsoleAccess"
+  description = "Deny creation of IAM users with console access"
+  content     = jsonencode({
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Effect": "Deny",
+        "Action": "iam:CreateUser",
+        "Resource": "*",
+        "Condition": {
+          "Bool": {
+            "aws:RequestTag/ConsoleAccess": "true"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_organizations_policy" "require_imdsv2" {
+  name        = "RequireIMDSv2"
+  description = "Require IMDSv2 on all EC2 instances"
+  content     = jsonencode({
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Effect": "Deny",
+        "Action": "ec2:RunInstances",
+        "Resource": "arn:aws:ec2:*:*:instance/*",
+        "Condition": {
+          "StringNotEquals": {
+            "ec2:MetadataHttpTokens": "required"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_s3_bucket" "terraform_state" {
+  bucket = "aft-terraform-state-bucket"
+  versioning {
+    enabled = true
+  }
+}
+
+resource "aws_dynamodb_table" "terraform_lock" {
+  name         = "AFTTerraformLock"
+  billing_mode = "PAY_PER_REQUEST"
+  hash_key     = "LockID"
+
+  attribute {
+    name = "LockID"
+    type = "S"
+  }
+}
+
+resource "aws_iam_role" "cross_account_role" {
+  name = "AFTCrossAccountRole"
+
+  assume_role_policy = jsonencode({
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Effect": "Allow",
+        "Principal": {
+          "AWS": "arn:aws:iam::<management_account_id>:role/CI-CD-Pipeline-Role"
+        },
+        "Action": "sts:AssumeRole",
+        "Condition": {
+          "StringEquals": {
+            "sts:ExternalId": "external-id-condition"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_vpc" "main" {
+  cidr_block = "10.0.0.0/16"
+}
+
+resource "aws_subnet" "public" {
+  count             = 3
+  vpc_id            = aws_vpc.main.id
+  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 8, count.index)
+  availability_zone = element(data.aws_availability_zones.available.names, count.index)
+  map_public_ip_on_launch = true
+}
+
+resource "aws_subnet" "private" {
+  count             = 3
+  vpc_id            = aws_vpc.main.id
+  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 8, count.index + 3)
+  availability_zone = element(data.aws_availability_zones.available.names, count.index)
+}
+
+resource "aws_subnet" "isolated" {
+  count             = 3
+  vpc_id            = aws_vpc.main.id
+  cidr_block        = cidrsubnet(aws_vpc.main.cidr_block, 8, count.index + 6)
+  availability_zone = element(data.aws_availability_zones.available.names, count.index)
+}
+
+resource "aws_vpc_endpoint" "s3" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.s3"
+  vpc_endpoint_type = "Gateway"
+}
+
+resource "aws_vpc_endpoint" "dynamodb" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.dynamodb"
+  vpc_endpoint_type = "Gateway"
+}
+
+resource "aws_vpc_endpoint" "ssm" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.ssm"
+  vpc_endpoint_type = "Interface"
+  private_dns_enabled = true
+}
+
+resource "aws_vpc_endpoint" "ecr" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.ecr.api"
+  vpc_endpoint_type = "Interface"
+  private_dns_enabled = true
+}
+
+resource "aws_vpc_endpoint" "cloudwatch_logs" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.logs"
+  vpc_endpoint_type = "Interface"
+  private_dns_enabled = true
+}
+
+resource "aws_vpc_endpoint" "kms" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.kms"
+  vpc_endpoint_type = "Interface"
+  private_dns_enabled = true
+}
+
+resource "aws_vpc_endpoint" "sts" {
+  vpc_id       = aws_vpc.main.id
+  service_name = "com.amazonaws.us-east-1.sts"
+  vpc_endpoint_type = "Interface"
+  private_dns_enabled = true
+}
+
+resource "aws_ssoadmin_permission_set" "example" {
+  instance_arn = data.aws_ssoadmin_instances.main.arn
+  name         = "ExamplePermissionSet"
+  description  = "Example permission set for Azure AD group"
+}
+
+resource "aws_ssoadmin_account_assignment" "example" {
+  instance_arn       = data.aws_ssoadmin_instances.main.arn
+  permission_set_arn = aws_ssoadmin_permission_set.example.arn
+  principal_id       = "AzureADGroupID"
+  principal_type     = "GROUP"
+  target_id          = "AWSAccountID"
+  target_type        = "AWS_ACCOUNT"
+}
+
+data "aws_availability_zones" "available" {}
+
+data "aws_ssoadmin_instances" "main" {}

generated/complex/gpt-4o/complex-aws-tf-009/main.yaml

@@ -0,0 +1,279 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Resources:
+  KinesisDataStream:
+    Type: AWS::Kinesis::Stream
+    Properties:
+      ShardCount: 1
+      StreamEncryption:
+        EncryptionType: KMS
+        KeyId: !Ref KinesisKMSKey
+
+  KinesisKMSKey:
+    Type: AWS::KMS::Key
+    Properties:
+      Description: KMS key for Kinesis Data Stream encryption
+      KeyPolicy:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              AWS: !Sub arn:aws:iam::${AWS::AccountId}:root
+            Action: kms:*
+            Resource: '*'
+
+  KinesisDataAnalyticsApplication:
+    Type: AWS::KinesisAnalyticsV2::Application
+    Properties:
+      ApplicationName: FraudDetectionApp
+      RuntimeEnvironment: FLINK-1_11
+      ServiceExecutionRole: !GetAtt KinesisAnalyticsRole.Arn
+      ApplicationConfiguration:
+        ApplicationCodeConfiguration:
+          CodeContent:
+            S3ContentLocation:
+              BucketARN: !Sub arn:aws:s3:::${ModelS3Bucket}
+              FileKey: flink-app-code.jar
+              ObjectVersion: !Ref ModelS3ObjectVersion
+          CodeContentType: ZIPFILE
+        FlinkApplicationConfiguration:
+          CheckpointConfiguration:
+            ConfigurationType: CUSTOM
+            CheckpointInterval: 60000
+            CheckpointingEnabled: true
+          MonitoringConfiguration:
+            ConfigurationType: CUSTOM
+            LogLevel: INFO
+          ParallelismConfiguration:
+            ConfigurationType: CUSTOM
+            Parallelism: 2
+            ParallelismPerKPU: 1
+            AutoScalingEnabled: true
+        ApplicationSnapshotConfiguration:
+          SnapshotsEnabled: true
+
+  ModelS3Bucket:
+    Type: AWS::S3::Bucket
+    Properties:
+      VersioningConfiguration:
+        Status: Enabled
+
+  ModelS3ObjectVersion:
+    Type: AWS::S3::BucketVersioning
+    Properties:
+      Bucket: !Ref ModelS3Bucket
+      Status: Enabled
+
+  VPCGatewayEndpoint:
+    Type: AWS::EC2::VPCEndpoint
+    Properties:
+      ServiceName: com.amazonaws.us-east-1.s3
+      VpcId: !Ref VPCId
+      RouteTableIds:
+        - !Ref RouteTableId
+
+  LambdaFunction:
+    Type: AWS::Lambda::Function
+    Properties:
+      Handler: index.handler
+      Role: !GetAtt LambdaExecutionRole.Arn
+      Code:
+        S3Bucket: !Ref LambdaCodeBucket
+        S3Key: lambda-code.zip
+      Runtime: python3.8
+      Environment:
+        Variables:
+          DYNAMODB_TABLE_NAME: !Ref DynamoDBTable
+
+  LambdaExecutionRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: lambda.amazonaws.com
+            Action: sts:AssumeRole
+      Policies:
+        - PolicyName: LambdaDynamoDBPolicy
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: Allow
+                Action:
+                  - dynamodb:PutItem
+                Resource: !GetAtt DynamoDBTable.Arn
+
+  DynamoDBTable:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+        - AttributeName: ID
+          AttributeType: S
+      KeySchema:
+        - AttributeName: ID
+          KeyType: HASH
+      TimeToLiveSpecification:
+        AttributeName: TTL
+        Enabled: true
+
+  DynamoDBKMSKey:
+    Type: AWS::KMS::Key
+    Properties:
+      Description: KMS key for DynamoDB encryption
+      KeyPolicy:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              AWS: !Sub arn:aws:iam::${AWS::AccountId}:root
+            Action: kms:*
+            Resource: '*'
+
+  SNSTopic:
+    Type: AWS::SNS::Topic
+    Properties:
+      TopicName: FraudAlerts
+      Subscription:
+        - Protocol: https
+          Endpoint: https://events.pagerduty.com/integration/your_integration_key/enqueue
+          FilterPolicy:
+            severity: ["high"]
+        - Protocol: sqs
+          Endpoint: !GetAtt SQSQueue.Arn
+          FilterPolicy:
+            severity: ["medium"]
+
+  SQSQueue:
+    Type: AWS::SQS::Queue
+
+  CloudWatchDashboard:
+    Type: AWS::CloudWatch::Dashboard
+    Properties:
+      DashboardName: FraudDetectionDashboard
+      DashboardBody: !Sub |
+        {
+          "widgets": [
+            {
+              "type": "metric",
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "properties": {
+                "metrics": [
+                  [ "AWS/Kinesis", "IncomingRecords", "StreamName", "${KinesisDataStream}" ],
+                  [ ".", "IncomingBytes", ".", "." ]
+                ],
+                "period": 60,
+                "stat": "Sum",
+                "region": "${AWS::Region}",
+                "title": "Events Processed Per Second"
+              }
+            },
+            {
+              "type": "metric",
+              "x": 6,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "properties": {
+                "metrics": [
+                  [ "AWS/Lambda", "Duration", "FunctionName", "${LambdaFunction}" ]
+                ],
+                "period": 60,
+                "stat": "Average",
+                "region": "${AWS::Region}",
+                "title": "Anomaly Detection Latency"
+              }
+            },
+            {
+              "type": "metric",
+              "x": 12,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "properties": {
+                "metrics": [
+                  [ "AWS/Kinesis", "GetRecords.IteratorAgeMilliseconds", "StreamName", "${KinesisDataStream}" ]
+                ],
+                "period": 60,
+                "stat": "Maximum",
+                "region": "${AWS::Region}",
+                "title": "Iterator Age"
+              }
+            }
+          ]
+        }
+
+  CloudWatchCompositeAlarm:
+    Type: AWS::CloudWatch::CompositeAlarm
+    Properties:
+      AlarmName: KinesisScalingAlarm
+      AlarmRule: !Sub |
+        ALARM("${KinesisIncomingRecordsAlarm}") OR ALARM("${KinesisIteratorAgeAlarm}")
+      ActionsEnabled: true
+      AlarmActions:
+        - !Ref AutoScalingPolicy
+
+  KinesisIncomingRecordsAlarm:
+    Type: AWS::CloudWatch::Alarm
+    Properties:
+      AlarmName: KinesisIncomingRecordsAlarm
+      MetricName: IncomingRecords
+      Namespace: AWS/Kinesis
+      Statistic: Sum
+      Period: 60
+      EvaluationPeriods: 1
+      Threshold: 1000
+      ComparisonOperator: GreaterThanThreshold
+      Dimensions:
+        - Name: StreamName
+          Value: !Ref KinesisDataStream
+
+  KinesisIteratorAgeAlarm:
+    Type: AWS::CloudWatch::Alarm
+    Properties:
+      AlarmName: KinesisIteratorAgeAlarm
+      MetricName: GetRecords.IteratorAgeMilliseconds
+      Namespace: AWS/Kinesis
+      Statistic: Maximum
+      Period: 60
+      EvaluationPeriods: 1
+      Threshold: 30000
+      ComparisonOperator: GreaterThanThreshold
+      Dimensions:
+        - Name: StreamName
+          Value: !Ref KinesisDataStream
+
+  AutoScalingPolicy:
+    Type: AWS::ApplicationAutoScaling::ScalingPolicy
+    Properties:
+      PolicyName: KinesisScalingPolicy
+      PolicyType: TargetTrackingScaling
+      ResourceId: !Sub stream/${KinesisDataStream}
+      ScalableDimension: kinesis:stream:WriteCapacityUnits
+      ServiceNamespace: kinesis
+      TargetTrackingScalingPolicyConfiguration:
+        TargetValue: 70.0
+        PredefinedMetricSpecification:
+          PredefinedMetricType: KinesisWriteCapacityUtilization
+        ScaleInCooldown: 60
+        ScaleOutCooldown: 60
+
+  LambdaCodeBucket:
+    Type: AWS::S3::Bucket
+    Properties:
+      VersioningConfiguration:
+        Status: Enabled
+
+  VPCId:
+    Type: AWS::EC2::VPC
+    Properties:
+      CidrBlock: 10.0.0.0/16
+
+  RouteTableId:
+    Type: AWS::EC2::RouteTable
+    Properties:
+      VpcId: !Ref VPCId

generated/complex/gpt-4o/complex-aws-tf-010/main.tf

@@ -0,0 +1,234 @@
+provider "aws" {
+  region = "us-east-1"
+}
+
+provider "aws" {
+  alias  = "dr"
+  region = "us-west-2"
+}
+
+resource "aws_eks_cluster" "primary" {
+  name     = "primary-eks-cluster"
+  role_arn = aws_iam_role.eks_role.arn
+
+  vpc_config {
+    subnet_ids = aws_subnet.eks_subnets[*].id
+  }
+}
+
+resource "aws_eks_node_group" "primary" {
+  cluster_name    = aws_eks_cluster.primary.name
+  node_group_name = "primary-node-group"
+  node_role_arn   = aws_iam_role.node_role.arn
+  subnet_ids      = aws_subnet.eks_subnets[*].id
+
+  scaling_config {
+    desired_size = 3
+    max_size     = 5
+    min_size     = 1
+  }
+}
+
+resource "aws_eks_cluster" "dr" {
+  provider = aws.dr
+
+  name     = "dr-eks-cluster"
+  role_arn = aws_iam_role.eks_role.arn
+
+  vpc_config {
+    subnet_ids = aws_subnet.dr_eks_subnets[*].id
+  }
+}
+
+resource "aws_eks_node_group" "dr" {
+  provider = aws.dr
+
+  cluster_name    = aws_eks_cluster.dr.name
+  node_group_name = "dr-node-group"
+  node_role_arn   = aws_iam_role.node_role.arn
+  subnet_ids      = aws_subnet.dr_eks_subnets[*].id
+
+  scaling_config {
+    desired_size = 0
+    max_size     = 5
+    min_size     = 0
+  }
+}
+
+resource "aws_rds_cluster" "primary" {
+  cluster_identifier = "primary-rds-cluster"
+  engine             = "aurora-postgresql"
+  master_username    = "admin"
+  master_password    = "password"
+  availability_zones = ["us-east-1a", "us-east-1b"]
+}
+
+resource "aws_rds_cluster_instance" "primary_instance" {
+  cluster_identifier = aws_rds_cluster.primary.id
+  instance_class     = "db.r5.large"
+}
+
+resource "aws_rds_cluster" "dr" {
+  provider           = aws.dr
+  cluster_identifier = "dr-rds-cluster"
+  engine             = "aurora-postgresql"
+  master_username    = "admin"
+  master_password    = "password"
+  availability_zones = ["us-west-2a", "us-west-2b"]
+}
+
+resource "aws_rds_cluster_instance" "dr_instance" {
+  provider           = aws.dr
+  cluster_identifier = aws_rds_cluster.dr.id
+  instance_class     = "db.r5.large"
+}
+
+resource "aws_s3_bucket" "primary" {
+  bucket = "primary-bucket"
+  acl    = "private"
+
+  versioning {
+    enabled = true
+  }
+
+  replication_configuration {
+    role = aws_iam_role.replication_role.arn
+
+    rules {
+      id     = "replication-rule"
+      status = "Enabled"
+
+      destination {
+        bucket        = aws_s3_bucket.dr.arn
+        storage_class = "STANDARD"
+      }
+    }
+  }
+}
+
+resource "aws_s3_bucket" "dr" {
+  provider = aws.dr
+  bucket   = "dr-bucket"
+  acl      = "private"
+}
+
+resource "aws_elasticache_replication_group" "primary" {
+  replication_group_id          = "primary-redis"
+  replication_group_description = "Primary Redis replication group"
+  node_type                     = "cache.t3.micro"
+  number_cache_clusters         = 2
+  automatic_failover_enabled    = true
+}
+
+resource "aws_elasticache_global_replication_group" "global" {
+  global_replication_group_id_suffix = "global-redis"
+  primary_replication_group_id       = aws_elasticache_replication_group.primary.id
+}
+
+resource "aws_elb" "dr_alb" {
+  provider = aws.dr
+
+  name               = "dr-alb"
+  availability_zones = ["us-west-2a", "us-west-2b"]
+  security_groups    = [aws_security_group.alb_sg.id]
+  subnets            = aws_subnet.dr_eks_subnets[*].id
+}
+
+resource "aws_route53_health_check" "primary" {
+  fqdn              = "primary.example.com"
+  type              = "HTTP"
+  resource_path     = "/health"
+  failure_threshold = 3
+}
+
+resource "aws_route53_record" "failover" {
+  zone_id = aws_route53_zone.main.zone_id
+  name    = "example.com"
+  type    = "A"
+
+  alias {
+    name                   = aws_elb.dr_alb.dns_name
+    zone_id                = aws_elb.dr_alb.zone_id
+    evaluate_target_health = true
+  }
+
+  set_identifier = "dr"
+  failover_routing_policy {
+    type = "SECONDARY"
+  }
+}
+
+resource "aws_cloudwatch_metric_alarm" "rds_failover" {
+  alarm_name          = "RDSFailoverAlarm"
+  comparison_operator = "GreaterThanThreshold"
+  evaluation_periods  = 1
+  metric_name         = "DatabaseConnections"
+  namespace           = "AWS/RDS"
+  period              = 60
+  statistic           = "Average"
+  threshold           = 100
+  alarm_actions       = [aws_lambda_function.failover.arn]
+}
+
+resource "aws_lambda_function" "failover" {
+  filename         = "failover.zip"
+  function_name    = "FailoverFunction"
+  role             = aws_iam_role.lambda_exec.arn
+  handler          = "index.handler"
+  runtime          = "nodejs14.x"
+  source_code_hash = filebase64sha256("failover.zip")
+
+  environment {
+    variables = {
+      RDS_CLUSTER_ID = aws_rds_cluster.dr.id
+    }
+  }
+}
+
+resource "aws_ssm_document" "dr_runbook" {
+  name          = "DRRunbook"
+  document_type = "Automation"
+
+  content = jsonencode({
+    schemaVersion = "0.3"
+    description   = "Disaster Recovery Runbook"
+    mainSteps = [
+      {
+        name = "ValidatePrimary"
+        action = "aws:executeScript"
+        inputs = {
+          Runtime = "python3.8"
+          Handler = "handler"
+          Script  = "def handler(event, context): return 'Primary validated'"
+        }
+      },
+      {
+        name = "Failover"
+        action = "aws:executeAutomation"
+        inputs = {
+          DocumentName = "FailoverFunction"
+        }
+      },
+      {
+        name = "ValidateDR"
+        action = "aws:executeScript"
+        inputs = {
+          Runtime = "python3.8"
+          Handler = "handler"
+          Script  = "def handler(event, context): return 'DR validated'"
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_cloudwatch_event_rule" "dr_test_schedule" {
+  name        = "DRTestSchedule"
+  description = "Schedule for quarterly DR testing"
+  schedule_expression = "cron(0 0 1 */3 ? *)"
+}
+
+resource "aws_cloudwatch_event_target" "dr_test_target" {
+  rule = aws_cloudwatch_event_rule.dr_test_schedule.name
+  arn  = aws_ssm_document.dr_runbook.arn
+}

generated/complex/gpt-4o/complex-azure-tf-001/main.tf

@@ -0,0 +1,221 @@
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "rg" {
+  name     = "enterprise-landing-zone"
+  location = "East US"
+}
+
+resource "azurerm_virtual_wan" "wan" {
+  name                = "enterprise-vwan"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+}
+
+resource "azurerm_virtual_hub" "hub" {
+  name                = "enterprise-hub"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+  virtual_wan_id      = azurerm_virtual_wan.wan.id
+}
+
+resource "azurerm_firewall_policy" "firewall_policy" {
+  name                = "enterprise-firewall-policy"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+
+  threat_intelligence_mode = "AlertAndDeny"
+
+  intrusion_detection {
+    mode = "AlertAndDeny"
+  }
+
+  tls_inspection {
+    certificate {
+      key_vault_secret_id = "<key-vault-secret-id>"
+    }
+  }
+
+  dns_settings {
+    enable_proxy = true
+  }
+}
+
+resource "azurerm_firewall" "firewall" {
+  name                = "enterprise-firewall"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+  virtual_hub_id      = azurerm_virtual_hub.hub.id
+  firewall_policy_id  = azurerm_firewall_policy.firewall_policy.id
+}
+
+resource "azurerm_virtual_network" "spoke" {
+  count               = 3
+  name                = "spoke-vnet-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = ["East US", "West Europe", "Southeast Asia"][count.index]
+  address_space       = ["10.0.${count.index}.0/24"]
+
+  subnet {
+    name           = "web"
+    address_prefix = "10.0.${count.index}.0/26"
+  }
+
+  subnet {
+    name           = "app"
+    address_prefix = "10.0.${count.index}.64/26"
+  }
+
+  subnet {
+    name           = "data"
+    address_prefix = "10.0.${count.index}.128/26"
+  }
+}
+
+resource "azurerm_network_security_group" "nsg" {
+  count               = 3
+  name                = "spoke-nsg-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = ["East US", "West Europe", "Southeast Asia"][count.index]
+
+  security_rule {
+    name                       = "AllowWebToApp"
+    priority                   = 100
+    direction                  = "Inbound"
+    access                     = "Allow"
+    protocol                   = "Tcp"
+    source_port_range          = "*"
+    destination_port_range     = "80"
+    source_address_prefix      = "10.0.${count.index}.0/26"
+    destination_address_prefix = "10.0.${count.index}.64/26"
+  }
+
+  security_rule {
+    name                       = "AllowAppToData"
+    priority                   = 200
+    direction                  = "Inbound"
+    access                     = "Allow"
+    protocol                   = "Tcp"
+    source_port_range          = "*"
+    destination_port_range     = "1433"
+    source_address_prefix      = "10.0.${count.index}.64/26"
+    destination_address_prefix = "10.0.${count.index}.128/26"
+  }
+}
+
+resource "azurerm_route_table" "udr" {
+  count               = 3
+  name                = "spoke-udr-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = ["East US", "West Europe", "Southeast Asia"][count.index]
+
+  route {
+    name                   = "DefaultRoute"
+    address_prefix         = "0.0.0.0/0"
+    next_hop_type          = "VirtualAppliance"
+    next_hop_in_ip_address = azurerm_firewall.firewall.private_ip_address
+  }
+}
+
+resource "azurerm_private_endpoint" "sql" {
+  count               = 3
+  name                = "sql-private-endpoint-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = ["East US", "West Europe", "Southeast Asia"][count.index]
+  subnet_id           = azurerm_virtual_network.spoke[count.index].subnet[2].id
+
+  private_service_connection {
+    name                           = "sqlConnection"
+    private_connection_resource_id = "<sql-server-id>"
+    is_manual_connection           = false
+    subresource_names              = ["sqlServer"]
+  }
+}
+
+resource "azurerm_private_dns_zone" "sql" {
+  count               = 3
+  name                = "privatelink.database.windows.net"
+  resource_group_name = azurerm_resource_group.rg.name
+}
+
+resource "azurerm_private_dns_zone_virtual_network_link" "sql" {
+  count               = 3
+  name                = "sql-dns-link-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  private_dns_zone_id = azurerm_private_dns_zone.sql[count.index].id
+  virtual_network_id  = azurerm_virtual_network.spoke[count.index].id
+}
+
+resource "azurerm_policy_assignment" "allowed_locations" {
+  name                 = "allowed-locations"
+  policy_definition_id = "/providers/Microsoft.Authorization/policyDefinitions/<allowed-locations-policy-id>"
+  scope                = azurerm_resource_group.rg.id
+}
+
+resource "azurerm_policy_assignment" "required_tags" {
+  name                 = "required-tags"
+  policy_definition_id = "/providers/Microsoft.Authorization/policyDefinitions/<required-tags-policy-id>"
+  scope                = azurerm_resource_group.rg.id
+}
+
+resource "azurerm_policy_assignment" "deny_public_ip" {
+  name                 = "deny-public-ip"
+  policy_definition_id = "/providers/Microsoft.Authorization/policyDefinitions/<deny-public-ip-policy-id>"
+  scope                = azurerm_resource_group.rg.id
+}
+
+resource "azurerm_policy_assignment" "disk_encryption" {
+  name                 = "disk-encryption"
+  policy_definition_id = "/providers/Microsoft.Authorization/policyDefinitions/<disk-encryption-policy-id>"
+  scope                = azurerm_resource_group.rg.id
+}
+
+resource "azurerm_log_analytics_workspace" "workspace" {
+  count               = 3
+  name                = "log-analytics-${count.index}"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = ["East US", "West Europe", "Southeast Asia"][count.index]
+  sku                 = "PerGB2018"
+}
+
+resource "azurerm_sentinel_alert_rule_scheduled" "brute_force" {
+  count               = 3
+  name                = "BruteForceDetection"
+  log_analytics_workspace_id = azurerm_log_analytics_workspace.workspace[count.index].id
+  query               = "SecurityEvent | where EventID == 4625 | summarize Count = count() by TargetAccount, bin(TimeGenerated, 5m)"
+  query_frequency     = "PT5M"
+  query_period        = "PT5M"
+  severity            = "High"
+  trigger_operator    = "GreaterThan"
+  trigger_threshold   = 5
+}
+
+resource "azurerm_sentinel_alert_rule_scheduled" "impossible_travel" {
+  count               = 3
+  name                = "ImpossibleTravelDetection"
+  log_analytics_workspace_id = azurerm_log_analytics_workspace.workspace[count.index].id
+  query               = "SigninLogs | extend PreviousIP = lag(IPAddress, 1) | where IPAddress != PreviousIP | summarize Count = count() by UserPrincipalName, bin(TimeGenerated, 5m)"
+  query_frequency     = "PT5M"
+  query_period        = "PT5M"
+  severity            = "Medium"
+  trigger_operator    = "GreaterThan"
+  trigger_threshold   = 1
+}
+
+resource "azurerm_monitor_diagnostic_setting" "diagnostic" {
+  count               = 3
+  name                = "diagnostic-setting-${count.index}"
+  target_resource_id  = azurerm_virtual_network.spoke[count.index].id
+  log_analytics_workspace_id = azurerm_log_analytics_workspace.workspace[count.index].id
+
+  log {
+    category = "AllLogs"
+    enabled  = true
+  }
+
+  metric {
+    category = "AllMetrics"
+    enabled  = true
+  }
+}

generated/complex/gpt-4o/complex-azure-tf-002/main.tf

@@ -0,0 +1,185 @@
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "rg" {
+  name     = "rg-aks-saas"
+  location = "East US"
+}
+
+resource "azurerm_kubernetes_cluster" "aks" {
+  name                = "aks-saas-cluster"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  dns_prefix          = "aks-saas"
+
+  default_node_pool {
+    name                = "default"
+    node_count          = 3
+    vm_size             = "Standard_DS2_v2"
+    os_disk_type        = "Ephemeral"
+    os_disk_size_gb     = 30
+    enable_fips         = true
+  }
+
+  identity {
+    type = "SystemAssigned"
+  }
+
+  network_profile {
+    network_plugin    = "azure"
+    network_policy    = "calico"
+    load_balancer_sku = "standard"
+    outbound_type     = "userDefinedRouting"
+    ip_families       = ["IPv4", "IPv6"]
+  }
+
+  api_server_authorized_ip_ranges = ["<YOUR_IP_RANGE>"]
+  private_cluster_enabled         = true
+
+  addon_profile {
+    azure_policy {
+      enabled = true
+    }
+    kube_dashboard {
+      enabled = false
+    }
+  }
+
+  tags = {
+    environment = "production"
+  }
+}
+
+resource "azurerm_kubernetes_cluster_node_pool" "system" {
+  name                = "system"
+  kubernetes_cluster_id = azurerm_kubernetes_cluster.aks.id
+  vm_size             = "Standard_DS2_v2"
+  node_count          = 3
+  os_disk_type        = "Ephemeral"
+  enable_fips         = true
+}
+
+resource "azurerm_container_registry" "acr" {
+  name                = "acrsaasplatform"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+  sku                 = "Premium"
+
+  georeplication_locations = ["East US", "West US"]
+
+  trust_policy {
+    type = "Notary"
+  }
+
+  quarantine_policy_enabled = true
+}
+
+resource "helm_release" "dapr" {
+  name       = "dapr"
+  repository = "https://dapr.github.io/helm-charts"
+  chart      = "dapr"
+  version    = "1.8.0"
+
+  set {
+    name  = "global.mtls.enabled"
+    value = "true"
+  }
+}
+
+resource "helm_release" "keda" {
+  name       = "keda"
+  repository = "https://kedacore.github.io/charts"
+  chart      = "keda"
+  version    = "2.5.0"
+}
+
+resource "helm_release" "flux" {
+  name       = "flux"
+  repository = "https://fluxcd.io/flux"
+  chart      = "flux"
+  version    = "2.0.0"
+
+  set {
+    name  = "gitops.multiTenancy.enabled"
+    value = "true"
+  }
+}
+
+resource "kubernetes_namespace" "tenant" {
+  for_each = toset(["tenant1", "tenant2", "tenant3"])
+  metadata {
+    name = each.key
+  }
+}
+
+resource "kubernetes_network_policy" "cilium" {
+  for_each = toset(["tenant1", "tenant2", "tenant3"])
+  metadata {
+    name      = "cilium-policy"
+    namespace = each.key
+  }
+  spec {
+    pod_selector {}
+    ingress {
+      from {
+        namespace_selector {}
+      }
+      ports {
+        protocol = "TCP"
+        port     = 80
+      }
+    }
+  }
+}
+
+resource "kubernetes_manifest" "opa_gatekeeper" {
+  for_each = toset(["tenant1", "tenant2", "tenant3"])
+  manifest = {
+    "apiVersion" = "constraints.gatekeeper.sh/v1beta1"
+    "kind"       = "K8sRequiredLabels"
+    "metadata" = {
+      "name"      = "no-hostpath"
+      "namespace" = each.key
+    }
+    "spec" = {
+      "match" = {
+        "kinds" = [
+          {
+            "apiGroups" = [""]
+            "kinds"     = ["Pod"]
+          }
+        ]
+      }
+      "parameters" = {
+        "labels" = ["securityContext.runAsNonRoot"]
+      }
+    }
+  }
+}
+
+resource "kubernetes_secret" "azure_key_vault" {
+  for_each = toset(["tenant1", "tenant2", "tenant3"])
+  metadata {
+    name      = "azure-key-vault"
+    namespace = each.key
+  }
+  data = {
+    "vaultName" = "<YOUR_VAULT_NAME>"
+  }
+}
+
+resource "helm_release" "csi_secrets_store" {
+  name       = "csi-secrets-store"
+  repository = "https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts"
+  chart      = "secrets-store-csi-driver"
+  version    = "0.0.23"
+}
+
+resource "azurerm_kubernetes_cluster_defender" "defender" {
+  kubernetes_cluster_id = azurerm_kubernetes_cluster.aks.id
+  log_analytics_workspace_id = "<LOG_ANALYTICS_WORKSPACE_ID>"
+  plan {
+    name = "Defender"
+  }
+}

generated/complex/gpt-4o/complex-azure-tf-003/main.json

@@ -0,0 +1,409 @@
+{
+  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+  "contentVersion": "1.0.0.0",
+  "resources": [
+    {
+      "type": "Microsoft.Resources/deployments",
+      "apiVersion": "2021-04-01",
+      "name": "nestedDeployment",
+      "properties": {
+        "mode": "Incremental",
+        "template": {
+          "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+          "contentVersion": "1.0.0.0",
+          "resources": [
+            {
+              "type": "Microsoft.Network/applicationGateways",
+              "apiVersion": "2021-08-01",
+              "name": "appGateway",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "sku": {
+                  "name": "WAF_v2",
+                  "tier": "WAF_v2",
+                  "capacity": 2
+                },
+                "gatewayIPConfigurations": [
+                  {
+                    "name": "appGwIpConfig",
+                    "properties": {
+                      "subnet": {
+                        "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'vnet', 'appGwSubnet')]"
+                      }
+                    }
+                  }
+                ],
+                "frontendIPConfigurations": [
+                  {
+                    "name": "appGwFrontendIP",
+                    "properties": {
+                      "publicIPAddress": {
+                        "id": "[resourceId('Microsoft.Network/publicIPAddresses', 'appGwPublicIP')]"
+                      }
+                    }
+                  }
+                ],
+                "frontendPorts": [
+                  {
+                    "name": "appGwFrontendPort",
+                    "properties": {
+                      "port": 443
+                    }
+                  }
+                ],
+                "backendAddressPools": [
+                  {
+                    "name": "appGwBackendPool",
+                    "properties": {
+                      "backendAddresses": []
+                    }
+                  }
+                ],
+                "backendHttpSettingsCollection": [
+                  {
+                    "name": "appGwBackendHttpSettings",
+                    "properties": {
+                      "port": 80,
+                      "protocol": "Http",
+                      "cookieBasedAffinity": "Disabled",
+                      "pickHostNameFromBackendAddress": false,
+                      "probeEnabled": true,
+                      "requestTimeout": 20
+                    }
+                  }
+                ],
+                "httpListeners": [
+                  {
+                    "name": "appGwHttpListener",
+                    "properties": {
+                      "frontendIPConfiguration": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/frontendIPConfigurations', 'appGateway', 'appGwFrontendIP')]"
+                      },
+                      "frontendPort": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/frontendPorts', 'appGateway', 'appGwFrontendPort')]"
+                      },
+                      "protocol": "Https",
+                      "sslCertificate": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/sslCertificates', 'appGateway', 'appGwSslCert')]"
+                      }
+                    }
+                  }
+                ],
+                "requestRoutingRules": [
+                  {
+                    "name": "appGwRoutingRule",
+                    "properties": {
+                      "ruleType": "Basic",
+                      "httpListener": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/httpListeners', 'appGateway', 'appGwHttpListener')]"
+                      },
+                      "backendAddressPool": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/backendAddressPools', 'appGateway', 'appGwBackendPool')]"
+                      },
+                      "backendHttpSettings": {
+                        "id": "[resourceId('Microsoft.Network/applicationGateways/backendHttpSettingsCollection', 'appGateway', 'appGwBackendHttpSettings')]"
+                      }
+                    }
+                  }
+                ],
+                "webApplicationFirewallConfiguration": {
+                  "enabled": true,
+                  "firewallMode": "Prevention",
+                  "ruleSetType": "OWASP",
+                  "ruleSetVersion": "3.2",
+                  "customRules": [
+                    {
+                      "name": "BlockRequestsWithoutHeaders",
+                      "priority": 1,
+                      "ruleType": "MatchRule",
+                      "matchConditions": [
+                        {
+                          "matchVariables": [
+                            {
+                              "variableName": "RequestHeaders"
+                            }
+                          ],
+                          "operator": "Contains",
+                          "negationConditon": true,
+                          "matchValues": [
+                            "SpecificHeader"
+                          ]
+                        }
+                      ],
+                      "action": "Block"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "type": "Microsoft.Network/loadBalancers",
+              "apiVersion": "2021-08-01",
+              "name": "internalLoadBalancer",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "frontendIPConfigurations": [
+                  {
+                    "name": "loadBalancerFrontend",
+                    "properties": {
+                      "subnet": {
+                        "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'vnet', 'backendSubnet')]"
+                      }
+                    }
+                  }
+                ],
+                "backendAddressPools": [
+                  {
+                    "name": "loadBalancerBackendPool"
+                  }
+                ]
+              }
+            },
+            {
+              "type": "Microsoft.Compute/virtualMachineScaleSets",
+              "apiVersion": "2021-07-01",
+              "name": "vmss",
+              "location": "[resourceGroup().location]",
+              "sku": {
+                "name": "Standard_DS1_v2",
+                "tier": "Standard",
+                "capacity": 2
+              },
+              "properties": {
+                "overprovision": true,
+                "upgradePolicy": {
+                  "mode": "Automatic"
+                },
+                "virtualMachineProfile": {
+                  "storageProfile": {
+                    "osDisk": {
+                      "createOption": "FromImage",
+                      "managedDisk": {
+                        "storageAccountType": "Standard_LRS",
+                        "encryptionSettings": {
+                          "enabled": true,
+                          "diskEncryptionKey": {
+                            "sourceVault": {
+                              "id": "[resourceId('Microsoft.KeyVault/vaults', 'keyVault')]"
+                            },
+                            "secretUrl": "[concat('https://', 'keyVault', '.vault.azure.net/secrets/', 'diskEncryptionKey')]"
+                          },
+                          "keyEncryptionKey": {
+                            "sourceVault": {
+                              "id": "[resourceId('Microsoft.KeyVault/vaults', 'keyVault')]"
+                            },
+                            "keyUrl": "[concat('https://', 'keyVault', '.vault.azure.net/keys/', 'keyEncryptionKey')]"
+                          }
+                        }
+                      }
+                    }
+                  },
+                  "osProfile": {
+                    "computerNamePrefix": "vmss",
+                    "adminUsername": "adminUser",
+                    "adminPassword": "Password123!"
+                  },
+                  "networkProfile": {
+                    "networkInterfaceConfigurations": [
+                      {
+                        "name": "vmssNic",
+                        "properties": {
+                          "primary": true,
+                          "ipConfigurations": [
+                            {
+                              "name": "ipConfig",
+                              "properties": {
+                                "subnet": {
+                                  "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'vnet', 'backendSubnet')]"
+                                },
+                                "loadBalancerBackendAddressPools": [
+                                  {
+                                    "id": "[resourceId('Microsoft.Network/loadBalancers/backendAddressPools', 'internalLoadBalancer', 'loadBalancerBackendPool')]"
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              },
+              "zones": [
+                "1",
+                "2",
+                "3"
+              ]
+            },
+            {
+              "type": "Microsoft.Sql/servers",
+              "apiVersion": "2021-02-01-preview",
+              "name": "sqlServer",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "administratorLogin": "sqlAdmin",
+                "administratorLoginPassword": "Password123!"
+              }
+            },
+            {
+              "type": "Microsoft.Sql/servers/databases",
+              "apiVersion": "2021-02-01-preview",
+              "name": "[concat('sqlServer', '/', 'sqlDatabase')]",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "collation": "SQL_Latin1_General_CP1_CI_AS",
+                "maxSizeBytes": "1073741824",
+                "sampleName": "AdventureWorksLT",
+                "zoneRedundant": false
+              }
+            },
+            {
+              "type": "Microsoft.Network/virtualNetworks",
+              "apiVersion": "2021-08-01",
+              "name": "vnet",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "addressSpace": {
+                  "addressPrefixes": [
+                    "10.0.0.0/16"
+                  ]
+                },
+                "subnets": [
+                  {
+                    "name": "appGwSubnet",
+                    "properties": {
+                      "addressPrefix": "10.0.1.0/24"
+                    }
+                  },
+                  {
+                    "name": "backendSubnet",
+                    "properties": {
+                      "addressPrefix": "10.0.2.0/24"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "type": "Microsoft.Network/ddosProtectionPlans",
+              "apiVersion": "2021-08-01",
+              "name": "ddosProtectionPlan",
+              "location": "[resourceGroup().location]",
+              "properties": {}
+            },
+            {
+              "type": "Microsoft.Network/networkSecurityGroups",
+              "apiVersion": "2021-08-01",
+              "name": "nsg",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "securityRules": [
+                  {
+                    "name": "AllowAppGateway",
+                    "properties": {
+                      "priority": 100,
+                      "protocol": "*",
+                      "access": "Allow",
+                      "direction": "Inbound",
+                      "sourceAddressPrefix": "10.0.1.0/24",
+                      "sourcePortRange": "*",
+                      "destinationAddressPrefix": "*",
+                      "destinationPortRange": "80"
+                    }
+                  },
+                  {
+                    "name": "DenyAllInbound",
+                    "properties": {
+                      "priority": 4096,
+                      "protocol": "*",
+                      "access": "Deny",
+                      "direction": "Inbound",
+                      "sourceAddressPrefix": "*",
+                      "sourcePortRange": "*",
+                      "destinationAddressPrefix": "*",
+                      "destinationPortRange": "*"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "type": "Microsoft.Network/bastionHosts",
+              "apiVersion": "2021-08-01",
+              "name": "bastionHost",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "ipConfigurations": [
+                  {
+                    "name": "bastionIPConfig",
+                    "properties": {
+                      "subnet": {
+                        "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'vnet', 'AzureBastionSubnet')]"
+                      },
+                      "publicIPAddress": {
+                        "id": "[resourceId('Microsoft.Network/publicIPAddresses', 'bastionPublicIP')]"
+                      }
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "type": "Microsoft.OperationalInsights/workspaces",
+              "apiVersion": "2021-06-01",
+              "name": "logAnalyticsWorkspace",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "retentionInDays": 365
+              }
+            },
+            {
+              "type": "Microsoft.KeyVault/vaults",
+              "apiVersion": "2021-06-01-preview",
+              "name": "keyVault",
+              "location": "[resourceGroup().location]",
+              "properties": {
+                "sku": {
+                  "family": "A",
+                  "name": "standard"
+                },
+                "tenantId": "[subscription().tenantId]",
+                "accessPolicies": [
+                  {
+                    "tenantId": "[subscription().tenantId]",
+                    "objectId": "[parameters('adminObjectId')]",
+                    "permissions": {
+                      "keys": [
+                        "get",
+                        "create",
+                        "delete",
+                        "list",
+                        "update",
+                        "import",
+                        "backup",
+                        "restore",
+                        "recover",
+                        "purge"
+                      ],
+                      "secrets": [
+                        "get",
+                        "list",
+                        "set",
+                        "delete",
+                        "backup",
+                        "restore",
+                        "recover",
+                        "purge"
+                      ]
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    }
+  ]
+}

generated/complex/gpt-4o/complex-azure-tf-004/main.tf

@@ -0,0 +1,299 @@
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "main" {
+  name     = "rg-global-platform"
+  location = "East US"
+}
+
+resource "azurerm_eventgrid_topic" "custom_topic" {
+  name                = "custom-topic"
+  resource_group_name = azurerm_resource_group.main.name
+  location            = azurerm_resource_group.main.location
+}
+
+resource "azurerm_storage_account" "dead_letter" {
+  name                     = "deadletterstorage"
+  resource_group_name      = azurerm_resource_group.main.name
+  location                 = azurerm_resource_group.main.location
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+}
+
+resource "azurerm_eventgrid_event_subscription" "dead_letter" {
+  name  = "deadletter-subscription"
+  scope = azurerm_eventgrid_topic.custom_topic.id
+
+  webhook_endpoint {
+    url = "https://example.com/webhook"
+  }
+
+  dead_letter_identity {
+    type = "SystemAssigned"
+  }
+
+  dead_letter_destination {
+    storage_blob_container {
+      storage_account_id = azurerm_storage_account.dead_letter.id
+      container_name     = "deadletters"
+    }
+  }
+}
+
+resource "azurerm_function_app" "premium" {
+  name                       = "function-premium"
+  location                   = azurerm_resource_group.main.location
+  resource_group_name        = azurerm_resource_group.main.name
+  app_service_plan_id        = azurerm_app_service_plan.premium.id
+  storage_account_name       = azurerm_storage_account.function_storage.name
+  storage_account_access_key = azurerm_storage_account.function_storage.primary_access_key
+  os_type                    = "Linux"
+  version                    = "~3"
+
+  site_config {
+    vnet_route_all_enabled = true
+  }
+
+  identity {
+    type = "SystemAssigned"
+  }
+}
+
+resource "azurerm_app_service_plan" "premium" {
+  name                = "asp-premium"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  kind                = "FunctionApp"
+  reserved            = true
+
+  sku {
+    tier = "PremiumV2"
+    size = "P1v2"
+  }
+}
+
+resource "azurerm_private_endpoint" "function" {
+  name                = "function-private-endpoint"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  subnet_id           = azurerm_subnet.function_subnet.id
+
+  private_service_connection {
+    name                           = "function-privatelink"
+    private_connection_resource_id = azurerm_function_app.premium.id
+    is_manual_connection           = false
+  }
+}
+
+resource "azurerm_cosmosdb_account" "multi_region" {
+  name                = "cosmosdb-global"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  offer_type          = "Standard"
+  kind                = "GlobalDocumentDB"
+
+  consistency_policy {
+    consistency_level = "Strong"
+  }
+
+  geo_location {
+    location          = "East US"
+    failover_priority = 0
+  }
+
+  geo_location {
+    location          = "West US"
+    failover_priority = 1
+  }
+
+  geo_location {
+    location          = "North Europe"
+    failover_priority = 2
+  }
+
+  geo_location {
+    location          = "Southeast Asia"
+    failover_priority = 3
+  }
+
+  geo_location {
+    location          = "Australia East"
+    failover_priority = 4
+  }
+}
+
+resource "azurerm_cosmosdb_sql_container" "financial" {
+  name                = "financial-transactions"
+  cosmosdb_account_id = azurerm_cosmosdb_account.multi_region.id
+  database_name       = azurerm_cosmosdb_sql_database.main.name
+  partition_key_path  = "/partitionKey"
+
+  consistency_policy {
+    consistency_level = "Strong"
+  }
+}
+
+resource "azurerm_cosmosdb_sql_container" "analytics" {
+  name                = "analytics-data"
+  cosmosdb_account_id = azurerm_cosmosdb_account.multi_region.id
+  database_name       = azurerm_cosmosdb_sql_database.main.name
+  partition_key_path  = "/partitionKey"
+
+  consistency_policy {
+    consistency_level = "Eventual"
+  }
+}
+
+resource "azurerm_servicebus_namespace" "premium" {
+  name                = "servicebus-premium"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  sku                 = "Premium"
+  capacity            = 1
+
+  zone_redundant = true
+}
+
+resource "azurerm_servicebus_namespace_authorization_rule" "geo_dr" {
+  name                = "geo-dr-rule"
+  namespace_name      = azurerm_servicebus_namespace.premium.name
+  resource_group_name = azurerm_resource_group.main.name
+  listen              = true
+  send                = true
+  manage              = true
+}
+
+resource "azurerm_frontdoor" "premium" {
+  name                = "frontdoor-premium"
+  resource_group_name = azurerm_resource_group.main.name
+
+  routing_rule {
+    name               = "default-route"
+    accepted_protocols = ["Https"]
+    patterns_to_match  = ["/*"]
+    frontend_endpoints = [azurerm_frontdoor_frontend_endpoint.default.name]
+
+    forwarding_configuration {
+      forwarding_protocol = "HttpsOnly"
+      backend_pool_name   = azurerm_frontdoor_backend_pool.default.name
+    }
+  }
+
+  backend_pool {
+    name = "default-backend-pool"
+
+    backend {
+      host_header = "example.com"
+      address     = azurerm_private_endpoint.function.private_ip_address
+      http_port   = 80
+      https_port  = 443
+    }
+  }
+}
+
+resource "azurerm_frontdoor_firewall_policy" "waf" {
+  name                = "waf-policy"
+  resource_group_name = azurerm_resource_group.main.name
+
+  managed_rule {
+    type    = "Microsoft_BotManagerRuleSet"
+    version = "1.0"
+  }
+
+  custom_rule {
+    name      = "geo-filter"
+    priority  = 1
+    rule_type = "MatchRule"
+
+    match_condition {
+      match_variable = "RemoteAddr"
+      operator       = "GeoMatch"
+      negate_condition = false
+      match_values   = ["US", "CA"]
+    }
+
+    action = "Block"
+  }
+}
+
+resource "azurerm_key_vault" "secrets" {
+  name                = "kv-secrets"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  tenant_id           = data.azurerm_client_config.current.tenant_id
+  sku_name            = "standard"
+
+  soft_delete_enabled = true
+  purge_protection_enabled = true
+
+  access_policy {
+    tenant_id = data.azurerm_client_config.current.tenant_id
+    object_id = azurerm_function_app.premium.identity.principal_id
+
+    secret_permissions = [
+      "get",
+      "list"
+    ]
+  }
+}
+
+resource "azurerm_application_insights" "insights" {
+  name                = "app-insights"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  application_type    = "web"
+
+  retention_in_days = 90
+}
+
+resource "azurerm_monitor_action_group" "incident" {
+  name                = "incident-action-group"
+  resource_group_name = azurerm_resource_group.main.name
+  short_name          = "incident"
+
+  webhook_receiver {
+    name        = "logicapp-webhook"
+    service_uri = azurerm_logic_app_workflow.incident_trigger.endpoint
+  }
+}
+
+resource "azurerm_logic_app_workflow" "incident_trigger" {
+  name                = "incident-logicapp"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+
+  identity {
+    type = "SystemAssigned"
+  }
+}
+
+resource "azurerm_monitor_smart_detection_rule" "smart_alerts" {
+  name                = "smart-detection-alerts"
+  resource_group_name = azurerm_resource_group.main.name
+  application_insights_id = azurerm_application_insights.insights.id
+
+  action {
+    action_group_id = azurerm_monitor_action_group.incident.id
+  }
+}
+
+resource "azurerm_monitor_availability_test" "global_tests" {
+  name                = "availability-test"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  application_insights_id = azurerm_application_insights.insights.id
+
+  enabled = true
+
+  geo_locations = [
+    "us-fl-mia-edge",
+    "us-ca-sjc-edge",
+    "eu-fr-pra-edge",
+    "apac-sg-sin-edge",
+    "aus-syd-edge"
+  ]
+
+  frequency = 300
+  timeout   = 30
+}

generated/complex/gpt-4o/complex-azure-tf-005/main.json

@@ -0,0 +1,174 @@
+{
+  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+  "contentVersion": "1.0.0.0",
+  "resources": [
+    {
+      "type": "Microsoft.MachineLearningServices/workspaces",
+      "apiVersion": "2023-04-01",
+      "name": "[parameters('workspaceName')]",
+      "location": "[parameters('location')]",
+      "properties": {
+        "friendlyName": "[parameters('workspaceFriendlyName')]",
+        "encryption": {
+          "status": "Enabled",
+          "keyVaultProperties": {
+            "keyVaultArmId": "[parameters('keyVaultId')]",
+            "keyIdentifier": "[parameters('keyIdentifier')]"
+          }
+        },
+        "privateEndpointConnections": [
+          {
+            "name": "[concat(parameters('workspaceName'), '-pe')]",
+            "properties": {
+              "privateLinkServiceConnectionState": {
+                "status": "Approved",
+                "description": "Auto-Approved"
+              }
+            }
+          }
+        ],
+        "virtualNetworkProfile": {
+          "vnetId": "[parameters('vnetId')]",
+          "subnetId": "[parameters('subnetId')]",
+          "networkIsolation": {
+            "allowOnlyApprovedOutbound": true
+          }
+        }
+      }
+    },
+    {
+      "type": "Microsoft.MachineLearningServices/workspaces/computes",
+      "apiVersion": "2023-04-01",
+      "name": "[concat(parameters('workspaceName'), '/', parameters('computeClusterName'))]",
+      "properties": {
+        "computeType": "AmlCompute",
+        "properties": {
+          "vmSize": "[parameters('vmSize')]",
+          "scaleSettings": {
+            "minNodeCount": 0,
+            "maxNodeCount": "[parameters('maxNodeCount')]"
+          },
+          "enableNodePublicIp": false
+        }
+      }
+    },
+    {
+      "type": "Microsoft.Storage/storageAccounts",
+      "apiVersion": "2022-09-01",
+      "name": "[parameters('storageAccountName')]",
+      "location": "[parameters('location')]",
+      "sku": {
+        "name": "Standard_LRS"
+      },
+      "kind": "StorageV2",
+      "properties": {
+        "isHnsEnabled": true,
+        "networkAcls": {
+          "bypass": "AzureServices",
+          "virtualNetworkRules": [
+            {
+              "id": "[parameters('vnetId')]"
+            }
+          ],
+          "ipRules": [],
+          "defaultAction": "Deny"
+        }
+      }
+    },
+    {
+      "type": "Microsoft.Storage/storageAccounts/privateEndpointConnections",
+      "apiVersion": "2022-09-01",
+      "name": "[concat(parameters('storageAccountName'), '-pe')]",
+      "properties": {
+        "privateLinkServiceConnectionState": {
+          "status": "Approved",
+          "description": "Auto-Approved"
+        }
+      }
+    },
+    {
+      "type": "Microsoft.Storage/storageAccounts/lifecycleManagementPolicies",
+      "apiVersion": "2022-09-01",
+      "name": "[concat(parameters('storageAccountName'), '/default')]",
+      "properties": {
+        "rules": [
+          {
+            "enabled": true,
+            "name": "MoveToCoolAfter30Days",
+            "type": "Lifecycle",
+            "definition": {
+              "filters": {
+                "blobTypes": ["blockBlob"]
+              },
+              "actions": {
+                "baseBlob": {
+                  "tierToCool": {
+                    "daysAfterModificationGreaterThan": 30
+                  },
+                  "tierToArchive": {
+                    "daysAfterModificationGreaterThan": 90
+                  }
+                }
+              }
+            }
+          }
+        ]
+      }
+    },
+    {
+      "type": "Microsoft.Resources/deploymentScripts",
+      "apiVersion": "2020-10-01",
+      "name": "AzureDevOpsPipelineScript",
+      "location": "[parameters('location')]",
+      "properties": {
+        "forceUpdateTag": "[newGuid()]",
+        "azPowerShellVersion": "5.0",
+        "scriptContent": "[concat('# Azure DevOps Pipeline YAML\ntrigger:\n  branches:\n    include:\n      - main\n\npool:\n  vmImage: ''ubuntu-latest''\n\nsteps:\n- task: UsePythonVersion@0\n  inputs:\n    versionSpec: ''3.x''\n\n- script: |\n    az ml workspace show --name ', parameters('workspaceName'), ' --resource-group ', parameters('resourceGroupName'), '\n    az ml data create --name training-data --path ''', parameters('adlsGen2Path'), ''' --type uri_folder\n    az ml job create --file pipeline.yml\n    az ml model register --name my-model --path outputs/model.pkl\n    az ml model deploy --name my-deployment --model my-model:1 --endpoint-name my-endpoint --compute-type aks --aks-cluster-name ', parameters('aksClusterName'), ' --auth-mode aad --enable-ssl --traffic-split 80 20\n  displayName: ''Run AML Pipeline''\n')]"
+      }
+    }
+  ],
+  "parameters": {
+    "workspaceName": {
+      "type": "string"
+    },
+    "location": {
+      "type": "string"
+    },
+    "workspaceFriendlyName": {
+      "type": "string"
+    },
+    "keyVaultId": {
+      "type": "string"
+    },
+    "keyIdentifier": {
+      "type": "string"
+    },
+    "vnetId": {
+      "type": "string"
+    },
+    "subnetId": {
+      "type": "string"
+    },
+    "computeClusterName": {
+      "type": "string"
+    },
+    "vmSize": {
+      "type": "string"
+    },
+    "maxNodeCount": {
+      "type": "int"
+    },
+    "storageAccountName": {
+      "type": "string"
+    },
+    "resourceGroupName": {
+      "type": "string"
+    },
+    "adlsGen2Path": {
+      "type": "string"
+    },
+    "aksClusterName": {
+      "type": "string"
+    }
+  }
+}

generated/complex/gpt-4o/complex-azure-tf-006/main.tf

@@ -0,0 +1,191 @@
+provider "azurerm" {
+  features {}
+}
+
+provider "azuread" {}
+
+resource "azuread_conditional_access_policy" "admin_access" {
+  display_name = "Admin Access Policy"
+  state        = "enabled"
+
+  conditions {
+    users {
+      include_groups = ["<admin-group-id>"]
+    }
+    devices {
+      device_states {
+        exclude = ["compliant"]
+      }
+    }
+  }
+
+  grant_controls {
+    operator = "AND"
+    built_in_controls = ["mfa"]
+  }
+}
+
+resource "azurerm_virtual_network" "hub" {
+  name                = "hub-vnet"
+  address_space       = ["10.0.0.0/16"]
+  location            = "East US"
+  resource_group_name = "<resource-group-name>"
+}
+
+resource "azurerm_virtual_network_manager" "network_manager" {
+  name                = "vnet-manager"
+  location            = "East US"
+  resource_group_name = "<resource-group-name>"
+
+  connectivity_configuration {
+    name = "connectivity-config"
+    hub_and_spoke {
+      hub = azurerm_virtual_network.hub.id
+    }
+  }
+
+  security_admin_configuration {
+    name = "security-config"
+    base_policy {
+      nsg_rules {
+        name                   = "mandatory-nsg-rule"
+        priority               = 100
+        direction              = "Inbound"
+        access                 = "Allow"
+        protocol               = "Tcp"
+        source_port_range      = "*"
+        destination_port_range = "22"
+        source_address_prefix  = "*"
+        destination_address_prefix = "*"
+      }
+    }
+  }
+}
+
+resource "azurerm_firewall" "firewall" {
+  name                = "central-firewall"
+  location            = "East US"
+  resource_group_name = "<resource-group-name>"
+  sku_name            = "AZFW_VNet"
+  threat_intelligence_mode = "Alert"
+
+  application_rule_collection {
+    name     = "app-rule-collection"
+    priority = 100
+    action   = "Allow"
+
+    rule {
+      name = "url-filtering-rule"
+      source_addresses = ["*"]
+      destination_urls = ["*.microsoft.com"]
+      protocols {
+        protocol_type = "Http"
+        port          = 80
+      }
+    }
+  }
+
+  network_rule_collection {
+    name     = "network-rule-collection"
+    priority = 200
+    action   = "Allow"
+
+    rule {
+      name = "fqdn-rule"
+      source_addresses = ["*"]
+      destination_fqdns = ["*.azure.com"]
+      protocols {
+        protocol_type = "Tcp"
+        port          = 443
+      }
+    }
+  }
+
+  nat_rule_collection {
+    name     = "dnat-rule-collection"
+    priority = 300
+    action   = "Dnat"
+
+    rule {
+      name = "dnat-rule"
+      source_addresses = ["*"]
+      destination_addresses = ["<public-ip>"]
+      destination_ports = ["80"]
+      translated_address = "<private-ip>"
+      translated_port    = "8080"
+      protocols = ["Tcp"]
+    }
+  }
+}
+
+resource "azurerm_private_endpoint" "sql_private_link" {
+  name                = "sql-private-endpoint"
+  location            = "East US"
+  resource_group_name = "<resource-group-name>"
+  subnet_id           = "<subnet-id>"
+
+  private_service_connection {
+    name                           = "sql-connection"
+    private_connection_resource_id = "<sql-server-id>"
+    is_manual_connection           = false
+  }
+}
+
+resource "azurerm_security_center_contact" "security_contact" {
+  email = "security@example.com"
+  phone = "+123456789"
+  alert_notifications = true
+  alerts_to_admins    = true
+}
+
+resource "azurerm_security_center_subscription_pricing" "defender_pricing" {
+  tier = "Standard"
+}
+
+resource "azurerm_security_center_automation" "automation" {
+  name                = "auto-remediation"
+  location            = "East US"
+  resource_group_name = "<resource-group-name>"
+
+  action {
+    type = "LogicApp"
+    logic_app_id = "<logic-app-id>"
+  }
+
+  source {
+    event_source = "Assessments"
+    rule_set {
+      rules {
+        property_path = "properties.metadata.severity"
+        operator      = "Equals"
+        expected_value = "High"
+      }
+    }
+  }
+}
+
+resource "azurerm_monitor_log_profile" "log_profile" {
+  name = "default-log-profile"
+
+  retention_policy {
+    enabled = true
+    days    = 365
+  }
+
+  categories = [
+    "Action",
+    "Write",
+    "Delete"
+  ]
+
+  locations = ["global"]
+}
+
+resource "azurerm_policy_assignment" "compliance_policy" {
+  name                 = "compliance-policy"
+  scope                = "<scope>"
+  policy_definition_id = "<policy-definition-id>"
+  parameters = jsonencode({
+    policyName = "SOC 2, ISO 27001"
+  })
+}

generated/complex/gpt-4o/complex-azure-tf-007/main.tf

@@ -0,0 +1,255 @@
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "rg" {
+  name     = "rg-api-management"
+  location = "East US"
+}
+
+resource "azurerm_virtual_network" "vnet" {
+  name                = "vnet-apim"
+  address_space       = ["10.0.0.0/16"]
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+}
+
+resource "azurerm_subnet" "subnet" {
+  name                 = "subnet-apim"
+  resource_group_name  = azurerm_resource_group.rg.name
+  virtual_network_name = azurerm_virtual_network.vnet.name
+  address_prefixes     = ["10.0.1.0/24"]
+}
+
+resource "azurerm_api_management" "apim" {
+  name                = "apim-platform"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  publisher_name      = "My Company"
+  publisher_email     = "admin@mycompany.com"
+  sku_name            = "Premium_1"
+  virtual_network_type = "Internal"
+
+  identity {
+    type = "SystemAssigned"
+  }
+
+  virtual_network_configuration {
+    subnet_id = azurerm_subnet.subnet.id
+  }
+
+  hostname_configuration {
+    proxy {
+      host_name          = "api.mycompany.com"
+      key_vault_id       = azurerm_key_vault_certificate.cert.id
+    }
+  }
+
+  additional_location {
+    location            = "West Europe"
+    sku_name            = "Premium_1"
+    virtual_network_configuration {
+      subnet_id = azurerm_subnet.subnet.id
+    }
+  }
+
+  tags = {
+    environment = "production"
+  }
+}
+
+resource "azurerm_key_vault" "kv" {
+  name                = "kv-apim-certificates"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  tenant_id           = data.azurerm_client_config.current.tenant_id
+  sku_name            = "standard"
+}
+
+resource "azurerm_key_vault_certificate" "cert" {
+  name         = "apim-cert"
+  key_vault_id = azurerm_key_vault.kv.id
+
+  certificate {
+    contents = filebase64("path/to/certificate.pfx")
+    password = "cert-password"
+  }
+}
+
+resource "azurerm_frontdoor" "fd" {
+  name                = "fd-global-entry"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+
+  routing_rule {
+    name               = "route-to-apim"
+    accepted_protocols = ["Https"]
+    patterns_to_match  = ["/*"]
+    frontend_endpoints = ["frontend-endpoint"]
+
+    forwarding_configuration {
+      forwarding_protocol = "HttpsOnly"
+      backend_pool_name   = "apim-backend-pool"
+    }
+  }
+
+  backend_pool {
+    name = "apim-backend-pool"
+
+    backend {
+      host_header = "api.mycompany.com"
+      address     = azurerm_api_management.apim.gateway_url
+      http_port   = 80
+      https_port  = 443
+    }
+
+    load_balancing {
+      sample_size      = 4
+      successful_samples_required = 2
+    }
+
+    health_probe {
+      path     = "/status"
+      protocol = "Https"
+      interval_in_seconds = 30
+    }
+  }
+
+  frontend_endpoint {
+    name      = "frontend-endpoint"
+    host_name = "api.mycompany.com"
+  }
+}
+
+resource "azurerm_container_app_environment" "env" {
+  name                = "container-app-env"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+}
+
+resource "azurerm_container_app" "app" {
+  name                = "backend-api"
+  container_app_environment_id = azurerm_container_app_environment.env.id
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+
+  dapr {
+    app_id     = "backend-api"
+    dapr_port  = 3500
+    enable_api_logging = true
+  }
+
+  template {
+    container {
+      name   = "backend-api"
+      image  = "myregistry.azurecr.io/backend-api:latest"
+      cpu    = 0.5
+      memory = "1Gi"
+    }
+
+    scale {
+      min_replicas = 0
+      max_replicas = 5
+    }
+  }
+}
+
+resource "azurerm_private_endpoint" "pe" {
+  name                = "pe-apim-backend"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  subnet_id           = azurerm_subnet.subnet.id
+
+  private_service_connection {
+    name                           = "apim-connection"
+    private_connection_resource_id = azurerm_api_management.apim.id
+    is_manual_connection           = false
+  }
+}
+
+resource "azurerm_redis_enterprise" "redis" {
+  name                = "redis-cache"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  sku_name            = "Enterprise_E10"
+  capacity            = 2
+}
+
+resource "azurerm_application_insights" "ai" {
+  name                = "apim-insights"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  application_type    = "web"
+}
+
+resource "azurerm_monitor_metric_alert" "latency_alert" {
+  name                = "latency-alert"
+  resource_group_name = azurerm_resource_group.rg.name
+  scopes              = [azurerm_application_insights.ai.id]
+  description         = "Alert for degraded latency"
+  criteria {
+    metric_namespace = "Microsoft.ApiManagement/service"
+    metric_name      = "GatewayLatency"
+    aggregation      = "Average"
+    operator         = "GreaterThan"
+    threshold        = 200
+  }
+}
+
+resource "azurerm_api_management_api" "api" {
+  name                = "my-api"
+  resource_group_name = azurerm_resource_group.rg.name
+  api_management_name = azurerm_api_management.apim.name
+  revision            = "1"
+  display_name        = "My API"
+  path                = "myapi"
+  protocols           = ["https"]
+
+  import {
+    content_format = "swagger-link-json"
+    content_value  = "https://path/to/swagger.json"
+  }
+}
+
+resource "azurerm_api_management_api_policy" "api_policy" {
+  api_name            = azurerm_api_management_api.api.name
+  api_management_name = azurerm_api_management.apim.name
+  resource_group_name = azurerm_resource_group.rg.name
+
+  xml_content = <<XML
+<policies>
+  <inbound>
+    <base />
+    <validate-jwt header-name="Authorization" failed-validation-httpcode="401" failed-validation-error-message="Unauthorized" require-scheme="Bearer">
+      <openid-config url="https://myb2c.b2clogin.com/myb2c.onmicrosoft.com/v2.0/.well-known/openid-configuration?p=B2C_1A_signup_signin" />
+      <required-claims>
+        <claim name="iss">
+          <value>https://myb2c.b2clogin.com/myb2c.onmicrosoft.com/v2.0/</value>
+        </claim>
+        <claim name="aud">
+          <value>my-api-client-id</value>
+        </claim>
+      </required-claims>
+    </validate-jwt>
+    <rate-limit-by-key calls="100" renewal-period="60" increment-condition="@(context.Request.Headers.GetValueOrDefault("x-subscription-key", ""))" />
+    <quota-by-key calls="1000" renewal-period="86400" increment-condition="@(context.Request.Headers.GetValueOrDefault("x-subscription-key", ""))" />
+    <set-header name="X-Custom-Header" exists-action="override">
+      <value>CustomValue</value>
+    </set-header>
+    <cache-lookup vary-by-developer="false" vary-by-developer-groups="false" vary-by-header="false" vary-by-query-parameter="false" />
+  </inbound>
+  <backend>
+    <base />
+    <forward-request />
+  </backend>
+  <outbound>
+    <base />
+    <cache-store duration="300" />
+    <emit-metric name="customMetric" value="@(context.Response.StatusCode)" />
+  </outbound>
+  <on-error>
+    <base />
+  </on-error>
+</policies>
+XML
+}

generated/complex/gpt-4o/complex-azure-tf-008/main.tf

@@ -0,0 +1,154 @@
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "rg" {
+  name     = "rg-synapse-analytics"
+  location = "East US"
+}
+
+resource "azurerm_storage_account" "adls_gen2" {
+  name                     = "adlsgen2storage"
+  resource_group_name      = azurerm_resource_group.rg.name
+  location                 = azurerm_resource_group.rg.location
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+  enable_https_traffic_only = true
+  is_hns_enabled           = true
+  enable_infrastructure_encryption = true
+  allow_blob_public_access = false
+
+  blob_properties {
+    delete_retention_policy {
+      days = 7
+    }
+  }
+
+  immutable_storage_with_versioning {
+    enabled = true
+    time_based_retention_policy {
+      days = 30
+    }
+  }
+}
+
+resource "azurerm_synapse_workspace" "synapse" {
+  name                                 = "synapseworkspace"
+  resource_group_name                  = azurerm_resource_group.rg.name
+  location                             = azurerm_resource_group.rg.location
+  storage_data_lake_gen2_filesystem_id = azurerm_storage_account.adls_gen2.id
+  managed_virtual_network_enabled      = true
+  managed_private_endpoint_enabled     = true
+  data_exfiltration_protection_enabled = true
+  allowed_tenant_ids                   = ["<approved_tenant_id>"]
+
+  customer_managed_key {
+    key_vault_key_id = "<key_vault_key_id>"
+  }
+}
+
+resource "azurerm_synapse_sql_pool" "dedicated_sql_pool" {
+  name                = "dedicatedsqlpool"
+  synapse_workspace_id = azurerm_synapse_workspace.synapse.id
+  sku_name            = "DW100c"
+  collation           = "SQL_Latin1_General_CP1_CI_AS"
+
+  column_level_security_enabled = true
+  dynamic_data_masking_enabled  = true
+}
+
+resource "azurerm_synapse_spark_pool" "spark_pool" {
+  name                = "sparkpool"
+  synapse_workspace_id = azurerm_synapse_workspace.synapse.id
+  node_size           = "Small"
+  node_count          = 3
+  enable_auto_scale   = true
+  auto_scale_min_node_count = 3
+  auto_scale_max_node_count = 10
+  isolation_enabled   = true
+
+  customer_managed_key {
+    key_vault_key_id = "<key_vault_key_id>"
+  }
+}
+
+resource "azurerm_synapse_integration_runtime_self_hosted" "self_hosted_ir" {
+  name                = "selfhostedir"
+  synapse_workspace_id = azurerm_synapse_workspace.synapse.id
+}
+
+resource "azurerm_purview_account" "purview" {
+  name                = "purviewaccount"
+  resource_group_name = azurerm_resource_group.rg.name
+  location            = azurerm_resource_group.rg.location
+  sku_name            = "Standard"
+
+  scanning {
+    enabled = true
+    target_resources = [
+      azurerm_synapse_workspace.synapse.id,
+      azurerm_storage_account.adls_gen2.id,
+      "<azure_sql_database_id>"
+    ]
+  }
+
+  sensitivity_labels {
+    enabled = true
+  }
+
+  lineage_tracking {
+    enabled = true
+  }
+}
+
+resource "azurerm_synapse_pipeline" "data_ingestion_pipeline" {
+  name                = "dataingestionpipeline"
+  synapse_workspace_id = azurerm_synapse_workspace.synapse.id
+
+  activity {
+    name = "CopyDataFromOnPremSQL"
+
+    copy {
+      source {
+        type = "SqlSource"
+        sql_reader_query = "SELECT * FROM <table_name>"
+      }
+
+      sink {
+        type = "AzureDataLakeStoreSink"
+        storage_account_id = azurerm_storage_account.adls_gen2.id
+        folder_path        = "raw/<table_name>"
+      }
+
+      integration_runtime_name = azurerm_synapse_integration_runtime_self_hosted.self_hosted_ir.name
+    }
+  }
+
+  activity {
+    name = "TransformDataWithSpark"
+
+    spark {
+      spark_pool_name = azurerm_synapse_spark_pool.spark_pool.name
+      notebook_path   = "/notebooks/transform_data"
+      parameters = {
+        input_path  = "raw/<table_name>"
+        output_path = "curated/<table_name>"
+      }
+    }
+  }
+
+  activity {
+    name = "ServeDataWithServerlessSQL"
+
+    sql {
+      sql_pool_name = "serverless"
+      sql_script    = "CREATE VIEW <view_name> AS SELECT * FROM OPENROWSET(BULK 'curated/<table_name>', FORMAT='DELTA')"
+    }
+  }
+}
+
+resource "azurerm_role_assignment" "synapse_ad_auth" {
+  principal_id   = "<azure_ad_user_or_group_id>"
+  role_definition_name = "Synapse Administrator"
+  scope          = azurerm_synapse_workspace.synapse.id
+}

generated/complex/gpt-4o/complex-azure-tf-009/main.json

@@ -0,0 +1,299 @@
+{
+  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+  "contentVersion": "1.0.0.0",
+  "resources": [
+    {
+      "type": "Microsoft.HealthcareApis/services",
+      "apiVersion": "2021-11-01",
+      "name": "healthcareDataPlatform",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "kind": "fhir",
+        "authenticationConfiguration": {
+          "authority": "[parameters('aadAuthority')]",
+          "audience": "[parameters('aadAudience')]",
+          "smartProxyEnabled": true
+        },
+        "corsConfiguration": {
+          "origins": ["*"],
+          "headers": ["*"],
+          "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+          "maxAge": 3600,
+          "allowCredentials": false
+        },
+        "privateEndpointConnections": [
+          {
+            "name": "privateEndpointConnection",
+            "properties": {
+              "privateLinkServiceConnectionState": {
+                "status": "Approved",
+                "description": "Auto-approved"
+              }
+            }
+          }
+        ],
+        "encryption": {
+          "keyVaultProperties": {
+            "keyIdentifier": "[parameters('keyVaultKeyIdentifier')]"
+          }
+        }
+      }
+    },
+    {
+      "type": "Microsoft.HealthcareApis/services",
+      "apiVersion": "2021-11-01",
+      "name": "dicomService",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "kind": "dicom",
+        "privateEndpointConnections": [
+          {
+            "name": "privateEndpointConnection",
+            "properties": {
+              "privateLinkServiceConnectionState": {
+                "status": "Approved",
+                "description": "Auto-approved"
+              }
+            }
+          }
+        ],
+        "encryption": {
+          "keyVaultProperties": {
+            "keyIdentifier": "[parameters('keyVaultKeyIdentifier')]"
+          }
+        }
+      }
+    },
+    {
+      "type": "Microsoft.HealthcareApis/services",
+      "apiVersion": "2021-11-01",
+      "name": "medTechService",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "kind": "medtech",
+        "privateEndpointConnections": [
+          {
+            "name": "privateEndpointConnection",
+            "properties": {
+              "privateLinkServiceConnectionState": {
+                "status": "Approved",
+                "description": "Auto-approved"
+              }
+            }
+          }
+        ],
+        "encryption": {
+          "keyVaultProperties": {
+            "keyIdentifier": "[parameters('keyVaultKeyIdentifier')]"
+          }
+        }
+      }
+    },
+    {
+      "type": "Microsoft.Devices/IotHubs",
+      "apiVersion": "2021-03-03",
+      "name": "iotHub",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "enableFileUploadNotifications": false,
+        "eventHubEndpoints": {
+          "events": {
+            "retentionTimeInDays": 1,
+            "partitionCount": 2
+          }
+        },
+        "routing": {
+          "endpoints": {
+            "eventHubs": [
+              {
+                "name": "eventHubEndpoint",
+                "connectionString": "[parameters('eventHubConnectionString')]"
+              }
+            ]
+          },
+          "routes": [
+            {
+              "name": "telemetryRoute",
+              "source": "DeviceMessages",
+              "endpointNames": ["eventHubEndpoint"],
+              "isEnabled": true
+            }
+          ]
+        },
+        "storageEndpoints": {
+          "[$default]": {
+            "sasTtlAsIso8601": "PT1H",
+            "connectionString": "[parameters('storageAccountConnectionString')]",
+            "containerName": "telemetry"
+          }
+        },
+        "enableDataResidency": true
+      },
+      "sku": {
+        "name": "S1",
+        "capacity": 1
+      }
+    },
+    {
+      "type": "Microsoft.Devices/provisioningServices",
+      "apiVersion": "2021-03-03",
+      "name": "deviceProvisioningService",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "iotHubs": [
+          {
+            "connectionString": "[parameters('iotHubConnectionString')]"
+          }
+        ],
+        "provisioningState": "Succeeded",
+        "attestation": {
+          "type": "x509",
+          "x509": {
+            "rootCertificates": [
+              {
+                "certificate": "[parameters('rootCertificate')]",
+                "isVerified": true
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      "type": "Microsoft.EventHub/namespaces",
+      "apiVersion": "2021-06-01-preview",
+      "name": "eventHubNamespace",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "isAutoInflateEnabled": true,
+        "maximumThroughputUnits": 20
+      },
+      "sku": {
+        "name": "Standard",
+        "tier": "Standard",
+        "capacity": 1
+      }
+    },
+    {
+      "type": "Microsoft.Storage/storageAccounts",
+      "apiVersion": "2021-04-01",
+      "name": "adlsGen2",
+      "location": "[resourceGroup().location]",
+      "kind": "StorageV2",
+      "properties": {
+        "accessTier": "Hot",
+        "isHnsEnabled": true,
+        "encryption": {
+          "services": {
+            "file": {
+              "keyType": "Account",
+              "enabled": true
+            },
+            "blob": {
+              "keyType": "Account",
+              "enabled": true
+            }
+          },
+          "keySource": "Microsoft.Keyvault",
+          "keyVaultProperties": {
+            "keyName": "[parameters('keyVaultKeyName')]",
+            "keyVersion": "[parameters('keyVaultKeyVersion')]",
+            "keyVaultUri": "[parameters('keyVaultUri')]"
+          }
+        }
+      },
+      "sku": {
+        "name": "Standard_LRS"
+      }
+    },
+    {
+      "type": "Microsoft.ConfidentialLedger/ledgers",
+      "apiVersion": "2021-05-13-preview",
+      "name": "confidentialLedger",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "ledgerUri": "[parameters('ledgerUri')]"
+      }
+    },
+    {
+      "type": "Microsoft.Authorization/policyAssignments",
+      "apiVersion": "2021-06-01",
+      "name": "hitrustPolicyAssignment",
+      "properties": {
+        "displayName": "HITRUST CSF Compliance",
+        "policyDefinitionId": "[parameters('hitrustPolicyDefinitionId')]",
+        "scope": "[resourceGroup().id]"
+      }
+    },
+    {
+      "type": "Microsoft.Security/iotDefenderSettings",
+      "apiVersion": "2021-01-01-preview",
+      "name": "defenderForIoT",
+      "location": "[resourceGroup().location]",
+      "properties": {
+        "iotHubResourceIds": [
+          "[resourceId('Microsoft.Devices/IotHubs', 'iotHub')]"
+        ],
+        "isDefenderEnabled": true
+      }
+    },
+    {
+      "type": "Microsoft.PowerBIDedicated/capacities",
+      "apiVersion": "2021-01-01",
+      "name": "powerBIEmbedded",
+      "location": "[resourceGroup().location]",
+      "sku": {
+        "name": "A1",
+        "tier": "PBIE_Azure"
+      },
+      "properties": {
+        "administration": {
+          "members": [
+            "[parameters('powerBIAdmin')]"
+          ]
+        }
+      }
+    }
+  ],
+  "parameters": {
+    "aadAuthority": {
+      "type": "string"
+    },
+    "aadAudience": {
+      "type": "string"
+    },
+    "keyVaultKeyIdentifier": {
+      "type": "string"
+    },
+    "eventHubConnectionString": {
+      "type": "string"
+    },
+    "storageAccountConnectionString": {
+      "type": "string"
+    },
+    "iotHubConnectionString": {
+      "type": "string"
+    },
+    "rootCertificate": {
+      "type": "string"
+    },
+    "keyVaultKeyName": {
+      "type": "string"
+    },
+    "keyVaultKeyVersion": {
+      "type": "string"
+    },
+    "keyVaultUri": {
+      "type": "string"
+    },
+    "ledgerUri": {
+      "type": "string"
+    },
+    "hitrustPolicyDefinitionId": {
+      "type": "string"
+    },
+    "powerBIAdmin": {
+      "type": "string"
+    }
+  }
+}

generated/complex/gpt-4o/complex-azure-tf-010/main.tf

@@ -0,0 +1,223 @@
+# main.tf
+provider "azurerm" {
+  features {}
+  use_oidc = true
+}
+
+provider "azuread" {
+  version = "~> 2.0"
+  use_oidc = true
+}
+
+resource "azurerm_resource_group" "rg" {
+  name     = "rg-${var.environment}"
+  location = var.location
+  tags     = var.tags
+}
+
+resource "azurerm_storage_account" "sa" {
+  name                     = "st${random_string.storage_account_name.result}"
+  resource_group_name      = azurerm_resource_group.rg.name
+  location                 = azurerm_resource_group.rg.location
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+  enable_https_traffic_only = true
+  allow_blob_public_access = false
+  tags                     = var.tags
+
+  blob_properties {
+    versioning_enabled = true
+    delete_retention_policy {
+      days = 7
+    }
+  }
+
+  network_rules {
+    default_action             = "Deny"
+    bypass                     = ["AzureServices"]
+    virtual_network_subnet_ids = [azurerm_subnet.subnet.id]
+  }
+}
+
+resource "azurerm_storage_container" "tfstate" {
+  name                  = "tfstate"
+  storage_account_name  = azurerm_storage_account.sa.name
+  container_access_type = "private"
+}
+
+resource "azurerm_virtual_network" "vnet" {
+  name                = "vnet-${var.environment}"
+  address_space       = ["10.0.0.0/16"]
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  tags                = var.tags
+}
+
+resource "azurerm_subnet" "subnet" {
+  name                 = "subnet-${var.environment}"
+  resource_group_name  = azurerm_resource_group.rg.name
+  virtual_network_name = azurerm_virtual_network.vnet.name
+  address_prefixes     = ["10.0.1.0/24"]
+}
+
+resource "azurerm_network_security_group" "nsg" {
+  name                = "nsg-${var.environment}"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  tags                = var.tags
+
+  security_rule {
+    name                       = "AllowAzureDevOps"
+    priority                   = 100
+    direction                  = "Inbound"
+    access                     = "Allow"
+    protocol                   = "*"
+    source_port_range          = "*"
+    destination_port_range     = "*"
+    source_address_prefix      = "AzureDevOps"
+    destination_address_prefix = "*"
+  }
+}
+
+resource "azurerm_virtual_machine_scale_set" "agent_pool" {
+  name                = "agents-${var.environment}"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  sku                 = "Standard_DS2_v2"
+  instances           = 2
+  admin_username      = "azureuser"
+  admin_password      = "P@ssword1234!"
+  tags                = var.tags
+
+  network_profile {
+    name    = "agent-nic"
+    primary = true
+    ip_configuration {
+      name      = "agent-ip"
+      subnet_id = azurerm_subnet.subnet.id
+    }
+  }
+}
+
+resource "azurerm_private_endpoint" "storage" {
+  name                = "pe-storage-${var.environment}"
+  location            = azurerm_resource_group.rg.location
+  resource_group_name = azurerm_resource_group.rg.name
+  subnet_id           = azurerm_subnet.subnet.id
+
+  private_service_connection {
+    name                           = "storageConnection"
+    private_connection_resource_id = azurerm_storage_account.sa.id
+    is_manual_connection           = false
+  }
+}
+
+resource "azuread_application" "app" {
+  display_name = "app-${var.environment}"
+  tags         = var.tags
+}
+
+resource "azuread_service_principal" "sp" {
+  application_id = azuread_application.app.application_id
+}
+
+resource "azuread_application_certificate" "cert" {
+  application_object_id = azuread_application.app.id
+  type                  = "AsymmetricX509Cert"
+  end_date              = timeadd(timestamp(), "2160h") # 90 days
+}
+
+resource "azuread_service_principal_certificate" "sp_cert" {
+  service_principal_id = azuread_service_principal.sp.id
+  value                = azuread_application_certificate.cert.value
+  end_date             = azuread_application_certificate.cert.end_date
+}
+
+# terragrunt.hcl
+terraform {
+  source = "./modules/${path_relative_to_include()}"
+}
+
+inputs = {
+  environment = "dev"
+  location    = "East US"
+  tags        = {
+    Environment = "dev"
+    Owner       = "team"
+  }
+}
+
+# azure-pipelines.yml
+trigger:
+  branches:
+    include:
+      - main
+
+stages:
+  - stage: Plan
+    jobs:
+      - job: TerraformPlan
+        pool:
+          vmImage: 'ubuntu-latest'
+        steps:
+          - checkout: self
+          - task: TerraformInstaller@0
+            inputs:
+              terraformVersion: '1.3.0'
+          - task: TerraformTaskV2@2
+            inputs:
+              provider: 'azurerm'
+              command: 'plan'
+              workingDirectory: '$(System.DefaultWorkingDirectory)/terraform'
+              environmentServiceName: 'AzureServiceConnection'
+              backendServiceArm: 'AzureServiceConnection'
+              backendAzureRmResourceGroupName: '$(ResourceGroupName)'
+              backendAzureRmStorageAccountName: '$(StorageAccountName)'
+              backendAzureRmContainerName: 'tfstate'
+              backendAzureRmKey: '$(Environment).tfstate'
+          - task: Conftest@0
+            inputs:
+              command: 'test'
+              policyPath: 'policy'
+              fileType: 'hcl'
+          - task: Checkov@1
+            inputs:
+              directory: '$(System.DefaultWorkingDirectory)/terraform'
+          - task: TFSec@1
+            inputs:
+              directory: '$(System.DefaultWorkingDirectory)/terraform'
+          - publish: $(Pipeline.Workspace)/terraform
+            artifact: terraformPlan
+
+  - stage: Apply
+    dependsOn: Plan
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    jobs:
+      - deployment: Deploy
+        environment: 'Production'
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - checkout: self
+                - task: TerraformInstaller@0
+                  inputs:
+                    terraformVersion: '1.3.0'
+                - task: TerraformTaskV2@2
+                  inputs:
+                    provider: 'azurerm'
+                    command: 'apply'
+                    workingDirectory: '$(System.DefaultWorkingDirectory)/terraform'
+                    environmentServiceName: 'AzureServiceConnection'
+                    backendServiceArm: 'AzureServiceConnection'
+                    backendAzureRmResourceGroupName: '$(ResourceGroupName)'
+                    backendAzureRmStorageAccountName: '$(StorageAccountName)'
+                    backendAzureRmContainerName: 'tfstate'
+                    backendAzureRmKey: '$(Environment).tfstate'
+                    commandOptions: '-auto-approve'
+                - download: terraformPlan
+                  artifact: terraformPlan
+                - task: PublishPipelineArtifact@1
+                  inputs:
+                    targetPath: '$(Pipeline.Workspace)/terraformPlan'
+                    artifact: 'TerraformPlan'

generated/complex/gpt-4o/complex-gcp-tf-001/main.tf

@@ -0,0 +1,220 @@
+provider "google" {
+  version = "~> 4.0"
+}
+
+resource "google_organization_iam_custom_role" "iap_tcp_forwarding" {
+  org_id     = "YOUR_ORG_ID"
+  role_id    = "iap_tcp_forwarding"
+  title      = "IAP TCP Forwarding"
+  permissions = [
+    "iap.tunnelInstances.accessViaIAP"
+  ]
+}
+
+resource "google_project" "shared_vpc_host" {
+  name       = "shared-vpc-host"
+  project_id = "shared-vpc-host"
+  org_id     = "YOUR_ORG_ID"
+  billing_account = "YOUR_BILLING_ACCOUNT_ID"
+}
+
+resource "google_project" "dev" {
+  name       = "dev"
+  project_id = "dev"
+  org_id     = "YOUR_ORG_ID"
+  billing_account = "YOUR_BILLING_ACCOUNT_ID"
+}
+
+resource "google_project" "staging" {
+  name       = "staging"
+  project_id = "staging"
+  org_id     = "YOUR_ORG_ID"
+  billing_account = "YOUR_BILLING_ACCOUNT_ID"
+}
+
+resource "google_project" "prod" {
+  name       = "prod"
+  project_id = "prod"
+  org_id     = "YOUR_ORG_ID"
+  billing_account = "YOUR_BILLING_ACCOUNT_ID"
+}
+
+resource "google_project" "data" {
+  name       = "data"
+  project_id = "data"
+  org_id     = "YOUR_ORG_ID"
+  billing_account = "YOUR_BILLING_ACCOUNT_ID"
+}
+
+resource "google_compute_shared_vpc_host_project" "host" {
+  project = google_project.shared_vpc_host.project_id
+}
+
+resource "google_compute_shared_vpc_service_project" "dev" {
+  host_project    = google_project.shared_vpc_host.project_id
+  service_project = google_project.dev.project_id
+}
+
+resource "google_compute_shared_vpc_service_project" "staging" {
+  host_project    = google_project.shared_vpc_host.project_id
+  service_project = google_project.staging.project_id
+}
+
+resource "google_compute_shared_vpc_service_project" "prod" {
+  host_project    = google_project.shared_vpc_host.project_id
+  service_project = google_project.prod.project_id
+}
+
+resource "google_compute_shared_vpc_service_project" "data" {
+  host_project    = google_project.shared_vpc_host.project_id
+  service_project = google_project.data.project_id
+}
+
+resource "google_compute_network" "vpc" {
+  name                    = "custom-vpc"
+  auto_create_subnetworks = false
+  project                 = google_project.shared_vpc_host.project_id
+}
+
+resource "google_compute_subnetwork" "subnets" {
+  count   = 12
+  name    = "subnet-${element(["dev", "staging", "prod", "data"], count.index % 4)}-${element(["us-central1", "europe-west1", "asia-east1"], count.index / 4)}"
+  ip_cidr_range = "10.${count.index}.0.0/16"
+  region        = element(["us-central1", "europe-west1", "asia-east1"], count.index / 4)
+  network       = google_compute_network.vpc.id
+  private_ip_google_access = true
+  log_config {
+    aggregation_interval = "INTERVAL_5_SEC"
+    flow_sampling        = 1.0
+    metadata             = "INCLUDE_ALL_METADATA"
+  }
+}
+
+resource "google_compute_router" "nat_router" {
+  count  = 3
+  name   = "nat-router-${element(["us-central1", "europe-west1", "asia-east1"], count.index)}"
+  region = element(["us-central1", "europe-west1", "asia-east1"], count.index)
+  network = google_compute_network.vpc.id
+}
+
+resource "google_compute_router_nat" "nat" {
+  count   = 3
+  name    = "nat-${element(["us-central1", "europe-west1", "asia-east1"], count.index)}"
+  router  = google_compute_router.nat_router[count.index].name
+  region  = google_compute_router.nat_router[count.index].region
+  nat_ip_allocate_option = "AUTO_ONLY"
+  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"
+  min_ports_per_vm = 64
+  endpoint_independent_mapping = false
+}
+
+resource "google_organization_policy" "shielded_vm" {
+  constraint = "constraints/compute.requireShieldedVm"
+  org_id     = "YOUR_ORG_ID"
+  boolean_policy {
+    enforced = true
+  }
+}
+
+resource "google_organization_policy" "disable_sa_key_creation" {
+  constraint = "constraints/iam.disableServiceAccountKeyCreation"
+  org_id     = "YOUR_ORG_ID"
+  boolean_policy {
+    enforced = true
+  }
+}
+
+resource "google_organization_policy" "deny_external_ip" {
+  constraint = "constraints/compute.vmExternalIpAccess"
+  org_id     = "YOUR_ORG_ID"
+  list_policy {
+    deny {
+      all = true
+    }
+  }
+}
+
+resource "google_organization_policy" "restrict_sql_public_ip" {
+  constraint = "constraints/sql.restrictPublicIp"
+  org_id     = "YOUR_ORG_ID"
+  boolean_policy {
+    enforced = true
+  }
+}
+
+resource "google_logging_project_sink" "audit_logs" {
+  name        = "audit-logs-sink"
+  project     = google_project.shared_vpc_host.project_id
+  destination = "bigquery.googleapis.com/projects/YOUR_PROJECT_ID/datasets/audit_logs"
+  filter      = "logName:logs/cloudaudit.googleapis.com%2Fdata_access"
+  unique_writer_identity = true
+}
+
+resource "google_vpc_access_connector" "connector" {
+  name   = "vpc-access-connector"
+  region = "us-central1"
+  network = google_compute_network.vpc.id
+}
+
+resource "google_access_context_manager_access_policy" "access_policy" {
+  parent = "organizations/YOUR_ORG_ID"
+  title  = "Corporate Access Policy"
+}
+
+resource "google_access_context_manager_access_level" "corporate_access" {
+  parent = google_access_context_manager_access_policy.access_policy.name
+  title  = "CorporateAccess"
+  basic {
+    conditions {
+      ip_subnetworks = ["CORPORATE_CIDR"]
+      device_policy {
+        require_screen_lock = true
+      }
+    }
+  }
+}
+
+resource "google_access_context_manager_service_perimeter" "data_perimeter" {
+  parent = google_access_context_manager_access_policy.access_policy.name
+  perimeter_type = "PERIMETER_TYPE_REGULAR"
+  title          = "DataProjectPerimeter"
+  status {
+    resources = ["projects/${google_project.data.project_id}"]
+    restricted_services = [
+      "bigquery.googleapis.com",
+      "storage.googleapis.com",
+      "pubsub.googleapis.com"
+    ]
+    access_levels = [google_access_context_manager_access_level.corporate_access.name]
+  }
+}
+
+resource "google_compute_firewall_policy" "org_policy" {
+  parent = "organizations/YOUR_ORG_ID"
+  display_name = "Org Level Firewall Policy"
+}
+
+resource "google_compute_firewall_policy_rule" "deny_ingress" {
+  firewall_policy = google_compute_firewall_policy.org_policy.id
+  priority        = 1000
+  direction       = "INGRESS"
+  action          = "deny"
+  match {
+    layer4_configs {
+      ip_protocol = "all"
+    }
+  }
+}
+
+resource "google_compute_firewall_policy_rule" "allow_iap_tcp" {
+  firewall_policy = google_compute_firewall_policy.org_policy.id
+  priority        = 100
+  direction       = "INGRESS"
+  action          = "allow"
+  match {
+    layer4_configs {
+      ip_protocol = "tcp"
+    }
+    src_ip_ranges = ["35.235.240.0/20"]
+  }
+}

generated/complex/gpt-4o/complex-gcp-tf-002/main.tf

@@ -0,0 +1,1952 @@
+```hcl
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+
+resource "google_container_cluster" "gke_autopilot" {
+  name     = "autopilot-cluster"
+  location = var.region
+  autopilot {
+  }
+}
+
+resource "google_service_account" "microservice_sa" {
+  count        = length(var.microservices)
+  account_id   = "${var.microservices[count.index]}-sa"
+  display_name = "${var.microservices[count.index]} Service Account"
+}
+
+resource "google_project_iam_member" "microservice_iam" {
+  count   = length(var.microservices)
+  project = var.project_id
+  role    = var.microservice_roles[count.index]
+  member  = "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+}
+
+resource "google_container_node_pool" "node_pool" {
+  name       = "default-pool"
+  location   = var.region
+  cluster    = google_container_cluster.gke_autopilot.name
+  node_count = 1
+
+  node_config {
+    oauth_scopes = [
+      "https://www.googleapis.com/auth/cloud-platform",
+    ]
+  }
+}
+
+resource "google_project_service" "enable_services" {
+  count   = length(var.services)
+  service = var.services[count.index]
+}
+
+resource "google_cloud_run_service" "service" {
+  count     = length(var.microservices)
+  name      = var.microservices[count.index]
+  location  = var.region
+  template {
+    spec {
+      containers {
+        image = var.microservice_images[count.index]
+      }
+    }
+  }
+}
+
+resource "google_cloud_run_service_iam_binding" "binding" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_binary_authorization_attestor" "cloud_build_attestor" {
+  name = "cloud-build-attestor"
+  attestation_authority_note {
+    note_reference = "projects/${var.project_id}/notes/cloud-build-attestor"
+  }
+}
+
+resource "google_binary_authorization_attestor" "manual_qa_attestor" {
+  name = "manual-qa-attestor"
+  attestation_authority_note {
+    note_reference = "projects/${var.project_id}/notes/manual-qa-attestor"
+  }
+}
+
+resource "google_binary_authorization_policy" "policy" {
+  default_admission_rule {
+    evaluation_mode = "REQUIRE_ATTESTATION"
+    enforcement_mode = "ENFORCED_BLOCK_AND_AUDIT_LOG"
+    require_attestations_by = [
+      google_binary_authorization_attestor.cloud_build_attestor.name,
+      google_binary_authorization_attestor.manual_qa_attestor.name
+    ]
+  }
+}
+
+resource "google_logging_metric" "error_rate_metric" {
+  name   = "error_rate"
+  filter = "resource.type=\"k8s_container\" AND severity>=ERROR"
+}
+
+resource "google_monitoring_alert_policy" "error_rate_alert" {
+  display_name = "Error Rate Alert"
+  combiner     = "OR"
+  conditions {
+    display_name = "Error Rate Condition"
+    condition_threshold {
+      filter          = "metric.type=\"logging.googleapis.com/user/error_rate\""
+      comparison      = "COMPARISON_GT"
+      threshold_value = 1
+      duration        = "60s"
+      aggregations {
+        alignment_period     = "60s"
+        per_series_aligner   = "ALIGN_RATE"
+        cross_series_reducer = "REDUCE_SUM"
+      }
+    }
+  }
+  notification_channels = [
+    google_monitoring_notification_channel.pagerduty.id,
+    google_monitoring_notification_channel.slack.id
+  ]
+}
+
+resource "google_monitoring_notification_channel" "pagerduty" {
+  display_name = "PagerDuty"
+  type         = "pagerduty"
+  labels = {
+    "service_key" = var.pagerduty_service_key
+  }
+}
+
+resource "google_monitoring_notification_channel" "slack" {
+  display_name = "Slack"
+  type         = "slack"
+  labels = {
+    "channel_name" = var.slack_channel_name
+    "token"        = var.slack_token
+  }
+}
+
+resource "google_pubsub_topic" "slack_topic" {
+  name = "slack-notifications"
+}
+
+resource "google_pubsub_subscription" "slack_subscription" {
+  name  = "slack-subscription"
+  topic = google_pubsub_topic.slack_topic.name
+  push_config {
+    push_endpoint = "https://hooks.slack.com/services/${var.slack_webhook}"
+  }
+}
+
+resource "google_pubsub_topic" "pagerduty_topic" {
+  name = "pagerduty-notifications"
+}
+
+resource "google_pubsub_subscription" "pagerduty_subscription" {
+  name  = "pagerduty-subscription"
+  topic = google_pubsub_topic.pagerduty_topic.name
+  push_config {
+    push_endpoint = "https://events.pagerduty.com/integration/${var.pagerduty_integration_key}/enqueue"
+  }
+}
+
+resource "google_compute_security_policy" "cloud_armor_policy" {
+  name = "cloud-armor-policy"
+  rule {
+    action = "allow"
+    match {
+      versioned_expr = "SRC_IPS_V1"
+      config {
+        src_ip_ranges = ["0.0.0.0/0"]
+      }
+    }
+  }
+  rule {
+    action = "deny-403"
+    match {
+      versioned_expr = "SRC_IPS_V1"
+      config {
+        src_ip_ranges = ["10.0.0.0/8"]
+      }
+    }
+  }
+}
+
+resource "google_compute_backend_service" "backend" {
+  name                  = "backend-service"
+  load_balancing_scheme = "EXTERNAL"
+  backend {
+    group = google_compute_instance_group.default.self_link
+  }
+  cdn_policy {
+    cache_key_policy {
+      include_host = true
+      include_protocol = true
+      include_query_string = true
+    }
+  }
+}
+
+resource "google_compute_url_map" "url_map" {
+  name            = "url-map"
+  default_service = google_compute_backend_service.backend.self_link
+}
+
+resource "google_compute_global_forwarding_rule" "http_rule" {
+  name       = "http-rule"
+  target     = google_compute_target_http_proxy.http_proxy.self_link
+  port_range = "80"
+}
+
+resource "google_compute_target_http_proxy" "http_proxy" {
+  name    = "http-proxy"
+  url_map = google_compute_url_map.url_map.self_link
+}
+
+resource "google_compute_ssl_certificate" "ssl_cert" {
+  name        = "ssl-cert"
+  description = "SSL certificate for HTTPS"
+}
+
+resource "google_compute_target_https_proxy" "https_proxy" {
+  name        = "https-proxy"
+  url_map     = google_compute_url_map.url_map.self_link
+  ssl_certificates = [google_compute_ssl_certificate.ssl_cert.self_link]
+}
+
+resource "google_compute_global_forwarding_rule" "https_rule" {
+  name       = "https-rule"
+  target     = google_compute_target_https_proxy.https_proxy.self_link
+  port_range = "443"
+}
+
+resource "google_cloud_run_domain_mapping" "domain_mapping" {
+  location = var.region
+  name     = var.domain_name
+  spec {
+    route_name = google_cloud_run_service.service[0].name
+  }
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.developer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_invoker" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.invoker"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_admin" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.admin"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_viewer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name
+  location = google_cloud_run_service.service[count.index].location
+  role     = "roles/run.viewer"
+  members  = [
+    "serviceAccount:${google_service_account.microservice_sa[count.index].email}"
+  ]
+}
+
+resource "google_cloud_run_service_iam_binding" "cloud_run_developer" {
+  count    = length(var.microservices)
+  service  = google_cloud_run_service.service[count.index].name

generated/complex/gpt-4o/complex-gcp-tf-003/main.tf

@@ -0,0 +1,176 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "us-central1"
+}
+
+resource "google_pubsub_topic" "ordered_topic" {
+  name                     = "ordered-topic"
+  message_storage_policy {
+    allowed_persistence_regions = ["us-central1"]
+  }
+  kms_key_name = "projects/your-gcp-project-id/locations/global/keyRings/your-keyring/cryptoKeys/your-key"
+  enable_message_ordering = true
+}
+
+resource "google_pubsub_topic" "dead_letter_topic" {
+  name = "dead-letter-topic"
+}
+
+resource "google_pubsub_subscription" "ordered_subscription" {
+  name  = "ordered-subscription"
+  topic = google_pubsub_topic.ordered_topic.id
+
+  dead_letter_policy {
+    dead_letter_topic = google_pubsub_topic.dead_letter_topic.id
+    max_delivery_attempts = 5
+  }
+}
+
+resource "google_dataflow_job" "streaming_job" {
+  name           = "streaming-job"
+  template_gcs_path = "gs://dataflow-templates/latest/Stream_GCS_Text_to_BigQuery"
+  parameters = {
+    inputFilePattern = "gs://your-bucket/input/*"
+    outputTable      = "your-gcp-project-id:your_dataset.your_table"
+  }
+  max_workers = 10
+  on_delete   = "cancel"
+  enable_streaming_engine = true
+  dataflow_service_options = ["enable_prime"]
+}
+
+resource "google_bigquery_dataset" "streaming_dataset" {
+  dataset_id = "your_dataset"
+  location   = "US"
+}
+
+resource "google_bigquery_table" "streaming_table" {
+  dataset_id = google_bigquery_dataset.streaming_dataset.dataset_id
+  table_id   = "your_table"
+  time_partitioning {
+    type = "DAY"
+  }
+  clustering {
+    fields = ["column1", "column2"]
+  }
+  encryption_configuration {
+    kms_key_name = "projects/your-gcp-project-id/locations/global/keyRings/your-keyring/cryptoKeys/your-key"
+  }
+}
+
+resource "google_bigtable_instance" "analytics_instance" {
+  name         = "analytics-instance"
+  cluster {
+    cluster_id   = "cluster-1"
+    zone         = "us-central1-b"
+    num_nodes    = 3
+    storage_type = "SSD"
+  }
+  cluster {
+    cluster_id   = "cluster-2"
+    zone         = "us-central1-c"
+    num_nodes    = 3
+    storage_type = "SSD"
+  }
+  instance_type = "PRODUCTION"
+}
+
+resource "google_composer_environment" "composer_env" {
+  name   = "composer-env"
+  region = "us-central1"
+
+  config {
+    node_count = 3
+    software_config {
+      image_version = "composer-2.0.0-airflow-2.1.2"
+      python_version = "3"
+    }
+    private_environment_config {
+      enable_private_environment = true
+    }
+    encryption_config {
+      kms_key_name = "projects/your-gcp-project-id/locations/global/keyRings/your-keyring/cryptoKeys/your-key"
+    }
+    dag_gcs_prefix = "gs://your-composer-bucket/dags"
+  }
+}
+
+resource "google_storage_bucket" "composer_bucket" {
+  name     = "your-composer-bucket"
+  location = "US"
+  versioning {
+    enabled = true
+  }
+  encryption {
+    default_kms_key_name = "projects/your-gcp-project-id/locations/global/keyRings/your-keyring/cryptoKeys/your-key"
+  }
+}
+
+resource "google_vpc_access_connector" "vpc_connector" {
+  name   = "vpc-connector"
+  region = "us-central1"
+  network = "default"
+}
+
+resource "google_kms_key_ring" "keyring" {
+  name     = "your-keyring"
+  location = "global"
+}
+
+resource "google_kms_crypto_key" "crypto_key" {
+  name            = "your-key"
+  key_ring        = google_kms_key_ring.keyring.id
+  rotation_period = "7776000s" # 90 days
+}
+
+resource "google_data_catalog_policy_tag" "policy_tag" {
+  display_name = "Sensitive"
+  taxonomy     = "projects/your-gcp-project-id/locations/us-central1/taxonomies/your-taxonomy"
+}
+
+resource "google_data_loss_prevention_job_trigger" "dlp_job" {
+  display_name = "dlp-job"
+  inspect_job {
+    storage_config {
+      big_query_options {
+        table_reference {
+          project_id = "your-gcp-project-id"
+          dataset_id = google_bigquery_dataset.streaming_dataset.dataset_id
+          table_id   = google_bigquery_table.streaming_table.table_id
+        }
+      }
+    }
+    inspect_config {
+      info_types {
+        name = "PERSON_NAME"
+      }
+      info_types {
+        name = "EMAIL_ADDRESS"
+      }
+      limits {
+        max_findings_per_request = 0
+      }
+    }
+  }
+  triggers {
+    schedule {
+      recurrence_period_duration = "86400s" # Daily
+    }
+  }
+}
+
+resource "google_vpc_service_controls_service_perimeter" "service_perimeter" {
+  name   = "projects/your-gcp-project-id/servicePerimeters/your-perimeter"
+  title  = "Service Perimeter"
+  status {
+    resources = [
+      "projects/your-gcp-project-id"
+    ]
+    restricted_services = [
+      "bigquery.googleapis.com",
+      "pubsub.googleapis.com",
+      "bigtable.googleapis.com",
+      "storage.googleapis.com"
+    ]
+  }
+}

generated/complex/gpt-4o/complex-gcp-tf-004/main.tf

@@ -0,0 +1,221 @@
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+
+resource "google_project" "dev" {
+  name       = "dev-environment"
+  project_id = "dev-${var.project_id}"
+  org_id     = var.org_id
+}
+
+resource "google_project" "staging" {
+  name       = "staging-environment"
+  project_id = "staging-${var.project_id}"
+  org_id     = var.org_id
+}
+
+resource "google_project" "prod" {
+  name       = "prod-environment"
+  project_id = "prod-${var.project_id}"
+  org_id     = var.org_id
+}
+
+resource "google_service_account" "cloud_build" {
+  account_id   = "cloud-build-sa"
+  display_name = "Cloud Build Service Account"
+}
+
+resource "google_project_iam_member" "cloud_build_sa" {
+  project = google_project.dev.project_id
+  role    = "roles/editor"
+  member  = "serviceAccount:${google_service_account.cloud_build.email}"
+}
+
+resource "google_project_iam_member" "cloud_build_sa_staging" {
+  project = google_project.staging.project_id
+  role    = "roles/editor"
+  member  = "serviceAccount:${google_service_account.cloud_build.email}"
+}
+
+resource "google_project_iam_member" "cloud_build_sa_prod" {
+  project = google_project.prod.project_id
+  role    = "roles/editor"
+  member  = "serviceAccount:${google_service_account.cloud_build.email}"
+}
+
+resource "google_cloudbuild_trigger" "github_trigger" {
+  project = google_project.dev.project_id
+  trigger_template {
+    repo_name = "your-repo"
+    branch_name = "main"
+  }
+  github {
+    owner = "your-org"
+    name  = "your-repo"
+    push {
+      branch = "main"
+    }
+  }
+  build {
+    steps {
+      name = "gcr.io/cloud-builders/docker"
+      args = ["build", "-t", "gcr.io/${google_project.dev.project_id}/app", "."]
+    }
+    steps {
+      name = "gcr.io/cloud-builders/gcloud"
+      args = ["beta", "container", "images", "describe", "gcr.io/${google_project.dev.project_id}/app"]
+    }
+  }
+}
+
+resource "google_artifact_registry_repository" "repo" {
+  project  = google_project.dev.project_id
+  location = var.region
+  repository_id = "my-repo"
+  format = "DOCKER"
+}
+
+resource "google_cloudfunctions_function" "notify_chat" {
+  name        = "notify-chat"
+  runtime     = "nodejs14"
+  entry_point = "notifyChat"
+  source_archive_bucket = google_storage_bucket.source_archive_bucket.name
+  source_archive_object = google_storage_bucket_object.source_archive.name
+  trigger_http = true
+}
+
+resource "google_storage_bucket" "source_archive_bucket" {
+  name     = "${var.project_id}-source"
+  location = var.region
+}
+
+resource "google_storage_bucket_object" "source_archive" {
+  name   = "function-source.zip"
+  bucket = google_storage_bucket.source_archive_bucket.name
+  source = "function-source.zip"
+}
+
+resource "google_clouddeploy_delivery_pipeline" "pipeline" {
+  project = google_project.dev.project_id
+  name    = "my-pipeline"
+  serial_pipeline {
+    stages {
+      target_id = "dev"
+      profiles  = ["canary"]
+    }
+    stages {
+      target_id = "staging"
+      profiles  = ["canary"]
+    }
+    stages {
+      target_id = "prod"
+      profiles  = ["canary"]
+    }
+  }
+}
+
+resource "google_clouddeploy_target" "dev" {
+  project = google_project.dev.project_id
+  name    = "dev"
+  gke {
+    cluster = "projects/${google_project.dev.project_id}/locations/${var.region}/clusters/dev-cluster"
+  }
+}
+
+resource "google_clouddeploy_target" "staging" {
+  project = google_project.staging.project_id
+  name    = "staging"
+  gke {
+    cluster = "projects/${google_project.staging.project_id}/locations/${var.region}/clusters/staging-cluster"
+  }
+}
+
+resource "google_clouddeploy_target" "prod" {
+  project = google_project.prod.project_id
+  name    = "prod"
+  gke {
+    cluster = "projects/${google_project.prod.project_id}/locations/${var.region}/clusters/prod-cluster"
+  }
+}
+
+resource "google_monitoring_alert_policy" "slo_burn_rate" {
+  project = google_project.prod.project_id
+  display_name = "SLO Burn Rate Alert"
+  conditions {
+    display_name = "Burn Rate Condition"
+    condition_threshold {
+      filter = "metric.type=\"compute.googleapis.com/instance/cpu/utilization\""
+      comparison = "COMPARISON_GT"
+      threshold_value = 0.8
+      duration = "60s"
+    }
+  }
+  notification_channels = [google_cloudfunctions_function.notify_chat.https_trigger_url]
+}
+
+resource "google_iam_workload_identity_pool" "github_pool" {
+  provider = google-beta
+  workload_identity_pool_id = "github-pool"
+  display_name = "GitHub Workload Identity Pool"
+}
+
+resource "google_iam_workload_identity_pool_provider" "github_provider" {
+  provider = google-beta
+  workload_identity_pool_id = google_iam_workload_identity_pool.github_pool.workload_identity_pool_id
+  workload_identity_pool_provider_id = "github-provider"
+  display_name = "GitHub Provider"
+  oidc {
+    issuer_uri = "https://token.actions.githubusercontent.com"
+  }
+  attribute_mapping = {
+    "google.subject" = "assertion.sub"
+    "attribute.actor" = "assertion.actor"
+    "attribute.repository" = "assertion.repository"
+  }
+  attribute_condition = "attribute.repository == 'your-org/your-repo' && attribute.branch == 'main'"
+}
+
+resource "google_project_iam_binding" "workload_identity_user" {
+  project = google_project.dev.project_id
+  role    = "roles/iam.workloadIdentityUser"
+  members = ["principalSet://iam.googleapis.com/${google_iam_workload_identity_pool.github_pool.name}/attribute.repository/your-org/your-repo"]
+}
+
+resource "google_project_iam_binding" "workload_identity_user_staging" {
+  project = google_project.staging.project_id
+  role    = "roles/iam.workloadIdentityUser"
+  members = ["principalSet://iam.googleapis.com/${google_iam_workload_identity_pool.github_pool.name}/attribute.repository/your-org/your-repo"]
+}
+
+resource "google_project_iam_binding" "workload_identity_user_prod" {
+  project = google_project.prod.project_id
+  role    = "roles/iam.workloadIdentityUser"
+  members = ["principalSet://iam.googleapis.com/${google_iam_workload_identity_pool.github_pool.name}/attribute.repository/your-org/your-repo"]
+}
+
+resource "google_binary_authorization_policy" "binauthz_policy" {
+  project = google_project.prod.project_id
+  default_admission_rule {
+    evaluation_mode = "ALWAYS_ALLOW"
+    enforcement_mode = "ENFORCED_BLOCK_AND_AUDIT_LOG"
+  }
+}
+
+resource "google_cloudbuild_trigger" "terraform_trigger" {
+  project = google_project.dev.project_id
+  trigger_template {
+    repo_name = "your-infra-repo"
+    branch_name = "main"
+  }
+  build {
+    steps {
+      name = "hashicorp/terraform"
+      args = ["plan"]
+    }
+    steps {
+      name = "hashicorp/terraform"
+      args = ["apply", "-auto-approve"]
+    }
+  }
+}

generated/complex/gpt-4o/complex-gcp-tf-005/main.tf

@@ -0,0 +1,176 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "europe-west1"
+}
+
+resource "google_storage_bucket" "data_bucket" {
+  name     = "gdpr-compliant-bucket"
+  location = "eu"
+  force_destroy = true
+
+  lifecycle_rule {
+    action {
+      type = "Delete"
+    }
+    condition {
+      age = 365
+    }
+  }
+}
+
+resource "google_bigquery_dataset" "dataset" {
+  dataset_id                  = "gdpr_compliant_dataset"
+  location                    = "EU"
+  default_table_expiration_ms = 2592000000
+
+  encryption_configuration {
+    kms_key_name = "projects/your-gcp-project-id/locations/europe-west1/keyRings/your-keyring/cryptoKeys/your-key"
+  }
+}
+
+resource "google_kms_crypto_key" "crypto_key" {
+  name     = "your-key"
+  key_ring = "projects/your-gcp-project-id/locations/europe-west1/keyRings/your-keyring"
+
+  rotation_period = "2592000s"
+
+  lifecycle {
+    prevent_destroy = false
+  }
+}
+
+resource "google_sql_database_instance" "postgres_instance" {
+  name             = "gdpr-compliant-sql"
+  database_version = "POSTGRES_13"
+  region           = "europe-west1"
+
+  settings {
+    tier = "db-custom-1-3840"
+
+    backup_configuration {
+      enabled             = true
+      point_in_time_recovery_enabled = true
+      backup_retention_settings {
+        retained_backups = 30
+      }
+    }
+
+    ip_configuration {
+      ipv4_enabled = false
+      private_network = "projects/your-gcp-project-id/global/networks/your-vpc"
+    }
+  }
+}
+
+resource "google_sql_database_instance" "read_replica" {
+  name              = "gdpr-compliant-sql-replica"
+  database_version  = "POSTGRES_13"
+  region            = "europe-west2"
+  master_instance_name = google_sql_database_instance.postgres_instance.name
+
+  settings {
+    tier = "db-custom-1-3840"
+
+    ip_configuration {
+      ipv4_enabled = false
+      private_network = "projects/your-gcp-project-id/global/networks/your-vpc"
+    }
+  }
+}
+
+resource "google_data_catalog_entry_group" "entry_group" {
+  entry_group_id = "gdpr_entry_group"
+  location       = "europe-west1"
+}
+
+resource "google_data_catalog_tag_template" "pii_tag_template" {
+  display_name = "PII Tag Template"
+  location     = "europe-west1"
+  fields = {
+    "pii_type" = {
+      display_name = "PII Type"
+      type = {
+        primitive_type = "STRING"
+      }
+    }
+  }
+}
+
+resource "google_bigquery_table" "authorized_view" {
+  dataset_id = google_bigquery_dataset.dataset.dataset_id
+  table_id   = "authorized_view"
+
+  view {
+    query = "SELECT * FROM your_table WHERE user_id = SESSION_USER()"
+    use_legacy_sql = false
+  }
+}
+
+resource "google_cloud_scheduler_job" "data_deletion_job" {
+  name        = "data-deletion-job"
+  schedule    = "0 3 * * *"
+  time_zone   = "Europe/Brussels"
+
+  http_target {
+    uri = "https://your-cloud-function-url"
+    http_method = "POST"
+  }
+}
+
+resource "google_logging_project_sink" "access_transparency_sink" {
+  name        = "access-transparency-sink"
+  destination = "bigquery.googleapis.com/projects/your-siem-project/datasets/your_dataset"
+
+  filter = "logName:cloudaudit.googleapis.com%2Factivity"
+}
+
+resource "google_vpc_access_connector" "vpc_connector" {
+  name   = "vpc-connector"
+  region = "europe-west1"
+  network = "projects/your-gcp-project-id/global/networks/your-vpc"
+}
+
+resource "google_access_context_manager_access_policy" "access_policy" {
+  parent = "organizations/123456789"
+}
+
+resource "google_access_context_manager_access_level" "access_level" {
+  name        = "access-level"
+  parent      = google_access_context_manager_access_policy.access_policy.name
+  title       = "Corporate Devices Only"
+
+  basic {
+    conditions {
+      device_policy {
+        require_screen_lock = true
+        os_constraints {
+          os_type = "DESKTOP"
+        }
+      }
+    }
+  }
+}
+
+resource "google_vpc_service_controls_service_perimeter" "perimeter" {
+  name        = "service-perimeter"
+  perimeter_type = "PERIMETER_TYPE_REGULAR"
+  status {
+    resources = ["projects/your-gcp-project-id"]
+    restricted_services = ["bigquery.googleapis.com", "storage.googleapis.com"]
+
+    ingress_policies {
+      ingress_from {
+        identities = ["serviceAccount:your-service-account@your-gcp-project-id.iam.gserviceaccount.com"]
+        identity_type = "IDENTITY_TYPE_SERVICE_ACCOUNT"
+      }
+    }
+
+    egress_policies {
+      egress_to {
+        operations {
+          service_name = "bigquery.googleapis.com"
+        }
+      }
+    }
+  }
+}

generated/complex/gpt-4o/complex-gcp-tf-006/main.tf

@@ -0,0 +1,190 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "us-central1"
+}
+
+resource "google_compute_global_address" "global_ip" {
+  name = "global-ip"
+}
+
+resource "google_compute_global_forwarding_rule" "global_forwarding_rule" {
+  name       = "global-forwarding-rule"
+  ip_address = google_compute_global_address.global_ip.address
+  ip_protocol = "TCP"
+  port_range = "80-443"
+  target     = google_compute_target_http_proxy.http_proxy.self_link
+}
+
+resource "google_compute_target_http_proxy" "http_proxy" {
+  name        = "http-proxy"
+  url_map     = google_compute_url_map.url_map.self_link
+}
+
+resource "google_compute_url_map" "url_map" {
+  name            = "url-map"
+  default_service = google_compute_backend_service.backend_service.self_link
+}
+
+resource "google_compute_backend_service" "backend_service" {
+  name                  = "backend-service"
+  protocol              = "HTTP"
+  load_balancing_scheme = "EXTERNAL"
+  backends {
+    group = google_compute_region_network_endpoint_group.serverless_neg.self_link
+  }
+  cdn_policy {
+    cache_mode = "USE_ORIGIN_HEADERS"
+  }
+  security_policy = google_compute_security_policy.security_policy.id
+}
+
+resource "google_compute_security_policy" "security_policy" {
+  name = "security-policy"
+  rule {
+    action = "allow"
+    match {
+      versioned_expr = "SRC_IPS_V1"
+      config {
+        src_ip_ranges = ["0.0.0.0/0"]
+      }
+    }
+  }
+  rule {
+    action = "deny(403)"
+    match {
+      versioned_expr = "SRC_IPS_V1"
+      config {
+        src_ip_ranges = ["1.2.3.4/32"] # Example IP for geo-blocking
+      }
+    }
+  }
+}
+
+resource "google_compute_region_network_endpoint_group" "serverless_neg" {
+  name                  = "serverless-neg"
+  network_endpoint_type = "SERVERLESS"
+  cloud_run {
+    service = google_cloud_run_service.cloud_run_service.name
+  }
+  region = "us-central1"
+}
+
+resource "google_cloud_run_service" "cloud_run_service" {
+  name     = "cloud-run-service"
+  location = "us-central1"
+
+  template {
+    spec {
+      containers {
+        image = "gcr.io/your-gcp-project-id/your-image"
+        resources {
+          limits = {
+            cpu    = "1"
+            memory = "512Mi"
+          }
+        }
+        env {
+          name  = "SECRET_KEY"
+          value = data.google_secret_manager_secret_version.secret_version.secret_data
+        }
+      }
+      service_account_name = google_service_account.cloud_run_service_account.email
+    }
+  }
+
+  traffic {
+    percent         = 100
+    latest_revision = true
+  }
+}
+
+resource "google_service_account" "cloud_run_service_account" {
+  account_id   = "cloud-run-sa"
+  display_name = "Cloud Run Service Account"
+}
+
+resource "google_secret_manager_secret" "secret" {
+  secret_id = "my-secret"
+}
+
+data "google_secret_manager_secret_version" "secret_version" {
+  secret = google_secret_manager_secret.secret.secret_id
+}
+
+resource "google_vpc_access_connector" "vpc_connector" {
+  name   = "vpc-connector"
+  region = "us-central1"
+  network = "default"
+}
+
+resource "google_cloud_sql_instance" "cloud_sql_instance" {
+  name             = "cloud-sql-instance"
+  database_version = "POSTGRES_13"
+  region           = "us-central1"
+  settings {
+    tier = "db-f1-micro"
+  }
+}
+
+resource "google_redis_instance" "redis_instance" {
+  name           = "redis-instance"
+  tier           = "BASIC"
+  memory_size_gb = 1
+  region         = "us-central1"
+}
+
+resource "google_firebase_project" "firebase" {
+  project = "your-gcp-project-id"
+}
+
+resource "google_identity_platform_config" "identity_platform" {
+  project = "your-gcp-project-id"
+  mfa {
+    state = "ENABLED"
+  }
+}
+
+resource "google_cloud_tasks_queue" "tasks_queue" {
+  name = "tasks-queue"
+  location = "us-central1"
+  rate_limits {
+    max_dispatches_per_second = 5
+  }
+  retry_config {
+    max_attempts = 5
+  }
+}
+
+resource "google_monitoring_slo" "slo" {
+  display_name = "Availability SLO"
+  goal         = 0.99
+  rolling_period = "30d"
+  service {
+    service_id = "my-service"
+  }
+  request_based {
+    good_total_ratio {
+      good_service_filter = "metric.type=\"serviceruntime.googleapis.com/api/request_count\" AND metric.label.\"response_code\" < 400"
+      total_service_filter = "metric.type=\"serviceruntime.googleapis.com/api/request_count\""
+    }
+  }
+}
+
+resource "google_monitoring_alert_policy" "burn_rate_alert" {
+  display_name = "Burn Rate Alert"
+  conditions {
+    display_name = "Burn Rate Condition"
+    condition_threshold {
+      filter = "metric.type=\"serviceruntime.googleapis.com/api/request_count\" AND metric.label.\"response_code\" >= 400"
+      comparison = "COMPARISON_GT"
+      threshold_value = 0.05
+      duration = "300s"
+      aggregations {
+        alignment_period = "60s"
+        per_series_aligner = "ALIGN_RATE"
+      }
+    }
+  }
+  combiner = "OR"
+  notification_channels = ["projects/your-gcp-project-id/notificationChannels/your-channel-id"]
+}

generated/complex/gpt-4o/complex-gcp-tf-007/main.tf

@@ -0,0 +1,157 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "us-central1"
+}
+
+resource "google_compute_network" "shared_services_vpc" {
+  name = "shared-services-vpc"
+}
+
+resource "google_compute_router" "cloud_router" {
+  name    = "cloud-router"
+  network = google_compute_network.shared_services_vpc.name
+  bgp {
+    asn = 64512
+  }
+}
+
+resource "google_compute_interconnect_attachment" "primary_interconnect" {
+  name          = "primary-interconnect"
+  interconnect  = "your-primary-interconnect-id"
+  router        = google_compute_router.cloud_router.name
+  edge_availability_domain = "availability-domain-1"
+}
+
+resource "google_compute_interconnect_attachment" "secondary_interconnect" {
+  name          = "secondary-interconnect"
+  interconnect  = "your-secondary-interconnect-id"
+  router        = google_compute_router.cloud_router.name
+  edge_availability_domain = "availability-domain-2"
+}
+
+resource "google_compute_interconnect_attachment" "partner_interconnect" {
+  name          = "partner-interconnect"
+  interconnect  = "your-partner-interconnect-id"
+  router        = google_compute_router.cloud_router.name
+  type          = "PARTNER"
+}
+
+resource "google_network_connectivity_hub" "ncc_hub" {
+  name = "network-connectivity-hub"
+}
+
+resource "google_network_connectivity_spoke" "primary_spoke" {
+  name = "primary-spoke"
+  hub  = google_network_connectivity_hub.ncc_hub.id
+  linked_interconnect_attachments = [google_compute_interconnect_attachment.primary_interconnect.id]
+}
+
+resource "google_network_connectivity_spoke" "secondary_spoke" {
+  name = "secondary-spoke"
+  hub  = google_network_connectivity_hub.ncc_hub.id
+  linked_interconnect_attachments = [google_compute_interconnect_attachment.secondary_interconnect.id]
+}
+
+resource "google_network_connectivity_spoke" "partner_spoke" {
+  name = "partner-spoke"
+  hub  = google_network_connectivity_hub.ncc_hub.id
+  linked_interconnect_attachments = [google_compute_interconnect_attachment.partner_interconnect.id]
+}
+
+resource "google_dns_managed_zone" "forwarding_zone" {
+  name        = "on-prem-dns"
+  dns_name    = "onprem.example.com."
+  visibility  = "private"
+  forwarding_config {
+    target_name_servers {
+      ipv4_address = "on-prem-dns-server-ip"
+    }
+  }
+}
+
+resource "google_dns_managed_zone" "peering_zone" {
+  name        = "cross-project-dns"
+  dns_name    = "crossproject.example.com."
+  visibility  = "private"
+  peering_config {
+    target_network {
+      network_url = "projects/other-project/global/networks/other-vpc"
+    }
+  }
+}
+
+resource "google_private_service_connect_endpoint" "psc_google_apis" {
+  name    = "psc-google-apis"
+  network = google_compute_network.shared_services_vpc.name
+  target_service = "all-apis"
+}
+
+resource "google_compute_security_policy" "cloud_armor_policy" {
+  name = "cloud-armor-policy"
+  rule {
+    action = "allow"
+    match {
+      versioned_expr = "SRC_IPS_V1"
+      config {
+        src_ip_ranges = ["0.0.0.0/0"]
+      }
+    }
+  }
+}
+
+resource "google_pubsub_topic" "threat_detection_topic" {
+  name = "threat-detection-topic"
+}
+
+resource "google_pubsub_subscription" "chronicle_siem_subscription" {
+  name  = "chronicle-siem-subscription"
+  topic = google_pubsub_topic.threat_detection_topic.id
+}
+
+resource "google_cloud_ids_endpoint" "cloud_ids" {
+  name    = "cloud-ids-instance"
+  network = google_compute_network.shared_services_vpc.name
+  threat_detection {
+    pubsub_topic = google_pubsub_topic.threat_detection_topic.id
+  }
+}
+
+resource "google_network_management_connectivity_test" "connectivity_test" {
+  name = "connectivity-test"
+  source {
+    instance = "projects/your-gcp-project-id/zones/us-central1-a/instances/source-instance"
+  }
+  destination {
+    instance = "projects/your-gcp-project-id/zones/us-central1-a/instances/destination-instance"
+  }
+}
+
+resource "google_network_management_firewall_insights" "firewall_insights" {
+  name = "firewall-insights"
+}
+
+resource "google_network_management_performance_dashboard" "performance_dashboard" {
+  name = "performance-dashboard"
+  monitored_resources {
+    resource_type = "INTERCONNECT"
+    resource_id   = google_compute_interconnect_attachment.primary_interconnect.id
+  }
+}
+
+resource "google_compute_firewall_policy" "hierarchical_policy" {
+  name = "hierarchical-firewall-policy"
+}
+
+resource "google_compute_firewall_policy_rule" "allow_traffic" {
+  policy = google_compute_firewall_policy.hierarchical_policy.id
+  action = "allow"
+  match {
+    layer4_configs {
+      ip_protocol = "tcp"
+      ports       = ["0-65535"]
+    }
+  }
+  direction = "INGRESS"
+  priority  = 1000
+  target_service_accounts = ["serviceAccount:your-service-account@your-gcp-project-id.iam.gserviceaccount.com"]
+}

generated/complex/gpt-4o/complex-gcp-tf-008/main.tf

@@ -0,0 +1,176 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "us-central1"
+}
+
+resource "google_compute_network" "vpc_network" {
+  name = "mlops-vpc"
+}
+
+resource "google_compute_subnetwork" "private_subnet" {
+  name          = "mlops-private-subnet"
+  ip_cidr_range = "10.0.0.0/24"
+  region        = "us-central1"
+  network       = google_compute_network.vpc_network.id
+  private_ip_google_access = true
+}
+
+resource "google_kms_key_ring" "mlops_key_ring" {
+  name     = "mlops-key-ring"
+  location = "us-central1"
+}
+
+resource "google_kms_crypto_key" "mlops_crypto_key" {
+  name            = "mlops-crypto-key"
+  key_ring        = google_kms_key_ring.mlops_key_ring.id
+  rotation_period = "100000s"
+}
+
+resource "google_vertex_ai_workbench_instance" "vertex_ai_workbench" {
+  name        = "mlops-workbench"
+  machine_type = "n1-standard-4"
+  subnet       = google_compute_subnetwork.private_subnet.id
+  kms_key      = google_kms_crypto_key.mlops_crypto_key.id
+  enable_ip_forwarding = false
+}
+
+resource "google_vertex_ai_featurestore" "feature_store" {
+  name = "mlops-feature-store"
+  online_serving_config {
+    fixed_node_count = 1
+  }
+  bigquery_destination {
+    output_uri = "bq://your-gcp-project-id.dataset.table"
+  }
+  bigtable_destination {
+    instance_id = "bigtable-instance"
+    table_id    = "bigtable-table"
+  }
+}
+
+resource "google_vertex_ai_endpoint" "vertex_ai_endpoint" {
+  display_name = "mlops-endpoint"
+}
+
+resource "google_vertex_ai_model" "vertex_ai_model" {
+  display_name = "mlops-model"
+  container_spec {
+    image_uri = "gcr.io/your-gcp-project-id/custom-container"
+  }
+}
+
+resource "google_vertex_ai_pipeline" "vertex_ai_pipeline" {
+  display_name = "mlops-pipeline"
+  pipeline_spec = file("pipeline_spec.json")
+}
+
+resource "google_vertex_ai_tensorboard" "vertex_ai_tensorboard" {
+  display_name = "mlops-tensorboard"
+}
+
+resource "google_vertex_ai_custom_job" "vertex_ai_custom_job" {
+  display_name = "mlops-custom-job"
+  job_spec {
+    worker_pool_specs {
+      machine_spec {
+        machine_type = "a2-highgpu-1g"
+        accelerator_type = "NVIDIA_TESLA_A100"
+        accelerator_count = 1
+      }
+      container_spec {
+        image_uri = "gcr.io/your-gcp-project-id/custom-container"
+      }
+    }
+  }
+}
+
+resource "google_cloud_run_service" "cloud_deploy_service" {
+  name     = "mlops-cloud-deploy"
+  location = "us-central1"
+  template {
+    spec {
+      containers {
+        image = "gcr.io/your-gcp-project-id/deploy-container"
+      }
+    }
+  }
+}
+
+resource "google_iam_policy" "vertex_ai_iam_policy" {
+  binding {
+    role = "roles/aiplatform.user"
+    members = [
+      "serviceAccount:your-service-account@your-gcp-project-id.iam.gserviceaccount.com"
+    ]
+    condition {
+      title       = "DeploymentWindow"
+      description = "Allow deployments only during approved windows"
+      expression  = "request.time.getHours('America/Los_Angeles') >= 9 && request.time.getHours('America/Los_Angeles') <= 17"
+    }
+  }
+}
+
+resource "google_vertex_ai_model_deployment" "model_deployment" {
+  model = google_vertex_ai_model.vertex_ai_model.id
+  endpoint = google_vertex_ai_endpoint.vertex_ai_endpoint.id
+  traffic_split {
+    0 = 50
+    1 = 50
+  }
+}
+
+resource "google_vertex_ai_featurestore_entitytype" "featurestore_entitytype" {
+  featurestore = google_vertex_ai_featurestore.feature_store.id
+  entitytype_id = "entity-type-id"
+}
+
+resource "google_vertex_ai_featurestore_entitytype_feature" "featurestore_feature" {
+  featurestore_entitytype = google_vertex_ai_featurestore_entitytype.featurestore_entitytype.id
+  feature_id = "feature-id"
+  value_type = "STRING"
+}
+
+resource "google_dataflow_job" "dataflow_job" {
+  name = "mlops-dataflow-job"
+  template_gcs_path = "gs://your-bucket/templates/dataflow-template"
+  parameters = {
+    inputFile = "gs://your-bucket/input-file"
+    outputTable = "your-gcp-project-id:dataset.output_table"
+  }
+}
+
+resource "google_binary_authorization_attestor" "binary_authorization" {
+  name = "mlops-attestor"
+  attestation_authority_note {
+    note_reference = "projects/your-gcp-project-id/notes/note-id"
+  }
+}
+
+resource "google_workload_identity_pool" "workload_identity_pool" {
+  provider_id = "mlops-workload-identity"
+}
+
+resource "google_workload_identity_pool_provider" "workload_identity_provider" {
+  workload_identity_pool_id = google_workload_identity_pool.workload_identity_pool.id
+  provider_id = "mlops-provider"
+  oidc {
+    issuer_uri = "https://accounts.google.com"
+  }
+}
+
+resource "google_vertex_ai_model_monitoring_job" "model_monitoring" {
+  display_name = "mlops-model-monitoring"
+  model_deployment = google_vertex_ai_model_deployment.model_deployment.id
+  objective_config {
+    training_dataset {
+      bigquery_source {
+        input_uri = "bq://your-gcp-project-id.dataset.training_table"
+      }
+    }
+    prediction_dataset {
+      bigquery_source {
+        input_uri = "bq://your-gcp-project-id.dataset.prediction_table"
+      }
+    }
+  }
+}

generated/complex/gpt-4o/complex-gcp-tf-009/main.tf

@@ -0,0 +1,144 @@
+provider "google" {
+  project = "your-gcp-project-id"
+  region  = "us-central1"
+}
+
+resource "google_container_cluster" "gke_cluster" {
+  count             = 3
+  name              = "gke-cluster-${count.index}"
+  location          = ["us-central1", "europe-west1", "asia-east1"][count.index]
+  initial_node_count = 1
+
+  node_config {
+    machine_type = "custom-4-16384"
+    shielded_instance_config {
+      enable_secure_boot          = true
+      enable_integrity_monitoring = true
+    }
+    confidential_nodes {
+      enabled = true
+    }
+  }
+
+  datapath_provider = "ADVANCED_DATAPATH"
+  enable_autopilot  = false
+
+  network_policy {
+    enabled = true
+    provider = "CILIUM"
+  }
+
+  node_pool {
+    name = "auto-provisioned-pool"
+    management {
+      auto_upgrade = true
+    }
+    autoscaling {
+      min_node_count = 1
+      max_node_count = 5
+    }
+  }
+
+  logging_service   = "logging.googleapis.com/kubernetes"
+  monitoring_service = "monitoring.googleapis.com/kubernetes"
+}
+
+resource "google_gke_hub_membership" "gke_membership" {
+  count = 3
+  name  = "gke-cluster-${count.index}"
+  endpoint {
+    gke_cluster {
+      resource_link = google_container_cluster.gke_cluster[count.index].self_link
+    }
+  }
+}
+
+resource "google_gke_hub_membership" "bare_metal_membership" {
+  name = "bare-metal-cluster"
+  endpoint {
+    bare_metal {
+      admin_cluster {
+        membership_cr_manifest = file("path/to/bare-metal-membership.yaml")
+      }
+    }
+  }
+}
+
+resource "google_gke_hub_feature" "config_management" {
+  name = "config-management"
+  spec {
+    configmanagement {
+      policy_controller {
+        enabled = true
+        template_library_installed = true
+      }
+      config_sync {
+        git {
+          sync_repo = "https://github.com/your-org/your-repo"
+          sync_branch = "main"
+          policy_dir = "config-sync"
+          secret_type = "ssh"
+        }
+        prevent_drift = true
+      }
+    }
+  }
+}
+
+resource "google_gke_hub_feature" "service_mesh" {
+  name = "service-mesh"
+  spec {
+    servicemesh {
+      control_plane = "MANAGED"
+      mtls {
+        mode = "STRICT"
+      }
+    }
+  }
+}
+
+resource "google_gke_hub_feature" "multi_cluster_ingress" {
+  name = "multi-cluster-ingress"
+  spec {
+    multiclusteringress {
+      config_membership = google_gke_hub_membership.gke_membership[0].name
+    }
+  }
+}
+
+resource "google_logging_project_sink" "fleet_logging" {
+  name        = "fleet-logging"
+  destination = "logging.googleapis.com/projects/your-gcp-project-id/locations/global/buckets/_Default"
+  filter      = "resource.type=gke_cluster"
+}
+
+resource "google_monitoring_notification_channel" "fleet_monitoring" {
+  display_name = "Fleet Monitoring"
+  type         = "email"
+  labels = {
+    email_address = "your-email@example.com"
+  }
+}
+
+resource "google_iam_policy" "fleet_rbac" {
+  binding {
+    role = "roles/gkehub.admin"
+    members = [
+      "group:your-group@example.com"
+    ]
+  }
+}
+
+resource "google_iap_tunnel_instance_iam_member" "connect_gateway" {
+  project = "your-gcp-project-id"
+  zone    = "us-central1-a"
+  instance = google_container_cluster.gke_cluster[0].name
+  role     = "roles/iap.tunnelResourceAccessor"
+  member   = "user:your-email@example.com"
+}
+
+resource "google_logging_project_sink" "audit_logging" {
+  name        = "audit-logging"
+  destination = "logging.googleapis.com/projects/your-gcp-project-id/locations/global/buckets/_Default"
+  filter      = "protoPayload.methodName:\"google.container.v1.ClusterManager\""
+}

generated/complex/gpt-4o/complex-gcp-tf-010/main.tf

@@ -0,0 +1,165 @@
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+
+resource "google_project" "data_product" {
+  name       = var.data_product_name
+  project_id = var.data_product_id
+  org_id     = var.organization_id
+}
+
+resource "google_bigquery_dataset" "dataset" {
+  project = google_project.data_product.project_id
+  dataset_id = var.dataset_id
+  location = var.region
+}
+
+resource "google_dataplex_lake" "lake" {
+  project = google_project.data_product.project_id
+  location = var.region
+  lake_id  = var.lake_id
+}
+
+resource "google_dataplex_zone" "zone" {
+  project = google_project.data_product.project_id
+  location = var.region
+  lake    = google_dataplex_lake.lake.name
+  zone_id = var.zone_id
+  type    = "RAW"
+}
+
+resource "google_dataplex_task" "data_quality" {
+  project = google_project.data_product.project_id
+  location = var.region
+  lake    = google_dataplex_lake.lake.name
+  task_id = var.data_quality_task_id
+
+  execution_spec {
+    service_account = var.service_account_email
+  }
+
+  trigger_spec {
+    type = "ON_DEMAND"
+  }
+
+  notebook {
+    path = var.notebook_path
+  }
+}
+
+resource "google_analytics_hub_data_exchange" "data_exchange" {
+  project = google_project.data_product.project_id
+  location = var.region
+  data_exchange_id = var.data_exchange_id
+}
+
+resource "google_data_catalog_entry_group" "entry_group" {
+  project = google_project.data_product.project_id
+  location = var.region
+  entry_group_id = var.entry_group_id
+}
+
+resource "google_data_catalog_tag_template" "tag_template" {
+  project = google_project.data_product.project_id
+  location = var.region
+  tag_template_id = var.tag_template_id
+
+  field {
+    display_name = "Business Metadata"
+    type {
+      primitive_type = "STRING"
+    }
+  }
+}
+
+resource "google_composer_environment" "composer" {
+  project = google_project.data_product.project_id
+  region  = var.region
+  name    = var.composer_name
+
+  config {
+    node_count = 3
+    software_config {
+      image_version = "composer-2.0.0-airflow-2.1.0"
+    }
+  }
+}
+
+resource "google_pubsub_topic" "cdc_topic" {
+  project = google_project.data_product.project_id
+  name    = var.cdc_topic_name
+}
+
+resource "google_cloudfunctions_function" "api_function" {
+  project        = google_project.data_product.project_id
+  name           = var.api_function_name
+  runtime        = "nodejs14"
+  entry_point    = "main"
+  source_archive_bucket = var.source_bucket
+  source_archive_object = var.source_object
+
+  trigger_http = true
+}
+
+resource "google_api_gateway_api" "api_gateway" {
+  project = google_project.data_product.project_id
+  api_id  = var.api_id
+}
+
+resource "google_api_gateway_api_config" "api_config" {
+  project = google_project.data_product.project_id
+  api     = google_api_gateway_api.api_gateway.api_id
+  config_id = var.api_config_id
+
+  openapi_documents {
+    document {
+      path     = var.openapi_spec_path
+      contents = file(var.openapi_spec_file)
+    }
+  }
+}
+
+resource "google_api_gateway_gateway" "gateway" {
+  project = google_project.data_product.project_id
+  api     = google_api_gateway_api.api_gateway.api_id
+  gateway_id = var.gateway_id
+  api_config = google_api_gateway_api_config.api_config.id
+}
+
+resource "google_data_catalog_policy_tag" "org_policy" {
+  project = var.organization_project_id
+  location = var.region
+  taxonomy = var.taxonomy_id
+  display_name = "Organization Level Policy"
+}
+
+resource "google_data_loss_prevention_inspect_template" "dlp_template" {
+  project = var.organization_project_id
+  inspect_template_id = var.dlp_template_id
+
+  inspect_config {
+    info_types {
+      name = "EMAIL_ADDRESS"
+    }
+    min_likelihood = "POSSIBLE"
+  }
+}
+
+resource "google_security_center_notification_config" "scc_notification" {
+  project = var.organization_project_id
+  notification_config_id = var.scc_notification_id
+  pubsub_topic = google_pubsub_topic.cdc_topic.id
+}
+
+module "data_product_module" {
+  source  = "app.terraform.io/my-org/data-product-module"
+  version = "1.0.0"
+
+  project_id = google_project.data_product.project_id
+  region     = var.region
+  dataset_id = google_bigquery_dataset.dataset.dataset_id
+  lake_id    = google_dataplex_lake.lake.lake_id
+  zone_id    = google_dataplex_zone.zone.zone_id
+  api_id     = google_api_gateway_api.api_gateway.api_id
+}

generated/complex/gpt-4o/complex-k8s-tf-001/main.tf

@@ -0,0 +1,243 @@
+provider "kubernetes" {
+  config_path = "~/.kube/config"
+}
+
+provider "helm" {
+  kubernetes {
+    config_path = "~/.kube/config"
+  }
+}
+
+provider "aws" {
+  region = "us-west-2"
+}
+
+resource "kubernetes_namespace" "monitoring" {
+  metadata {
+    name = "monitoring"
+    labels = {
+      "pod-security.kubernetes.io/enforce" = "restricted"
+    }
+  }
+}
+
+resource "kubernetes_network_policy" "monitoring" {
+  metadata {
+    name      = "monitoring-network-policy"
+    namespace = kubernetes_namespace.monitoring.metadata[0].name
+  }
+  spec {
+    pod_selector {}
+    policy_types = ["Ingress"]
+    ingress {
+      from {
+        pod_selector {
+          match_labels = {
+            "app.kubernetes.io/name" = "prometheus"
+          }
+        }
+      }
+      ports {
+        port     = 9090
+        protocol = "TCP"
+      }
+    }
+  }
+}
+
+resource "helm_release" "cert_manager" {
+  name       = "cert-manager"
+  namespace  = "cert-manager"
+  repository = "https://charts.jetstack.io"
+  chart      = "cert-manager"
+  version    = "v1.8.0"
+
+  set {
+    name  = "installCRDs"
+    value = "true"
+  }
+}
+
+resource "kubernetes_manifest" "letsencrypt_cluster_issuers" {
+  manifest = {
+    "apiVersion" = "cert-manager.io/v1"
+    "kind"       = "ClusterIssuer"
+    "metadata" = {
+      "name" = "letsencrypt-staging"
+    }
+    "spec" = {
+      "acme" = {
+        "server" = "https://acme-staging-v02.api.letsencrypt.org/directory"
+        "email"  = "your-email@example.com"
+        "privateKeySecretRef" = {
+          "name" = "letsencrypt-staging"
+        }
+        "solvers" = [
+          {
+            "dns01" = {
+              "route53" = {
+                "region" = "us-west-2"
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}
+
+resource "helm_release" "nginx_ingress" {
+  name       = "nginx-ingress"
+  namespace  = "ingress-nginx"
+  repository = "https://kubernetes.github.io/ingress-nginx"
+  chart      = "ingress-nginx"
+  version    = "4.0.6"
+
+  set {
+    name  = "controller.config.enable-modsecurity"
+    value = "true"
+  }
+
+  set {
+    name  = "controller.config.modsecurity-snippet"
+    value = "Include /etc/nginx/owasp-modsecurity-crs/nginx-modsecurity.conf"
+  }
+}
+
+resource "helm_release" "external_dns" {
+  name       = "external-dns"
+  namespace  = "kube-system"
+  repository = "https://charts.bitnami.com/bitnami"
+  chart      = "external-dns"
+  version    = "5.4.0"
+
+  set {
+    name  = "provider"
+    value = "aws"
+  }
+
+  set {
+    name  = "txtOwnerId"
+    value = "external-dns"
+  }
+}
+
+resource "helm_release" "prometheus_stack" {
+  name       = "kube-prometheus-stack"
+  namespace  = kubernetes_namespace.monitoring.metadata[0].name
+  repository = "https://prometheus-community.github.io/helm-charts"
+  chart      = "kube-prometheus-stack"
+  version    = "19.0.0"
+
+  set {
+    name  = "prometheus.thanos.create"
+    value = "true"
+  }
+
+  set {
+    name  = "prometheus.thanos.objectStorageConfig"
+    value = <<EOF
+type: S3
+config:
+  bucket: "thanos-bucket"
+  endpoint: "s3.amazonaws.com"
+  access_key: "your-access-key"
+  secret_key: "your-secret-key"
+EOF
+  }
+}
+
+resource "helm_release" "grafana" {
+  name       = "grafana"
+  namespace  = kubernetes_namespace.monitoring.metadata[0].name
+  repository = "https://grafana.github.io/helm-charts"
+  chart      = "grafana"
+  version    = "6.17.0"
+
+  set {
+    name  = "grafana.ini.auth.generic_oauth"
+    value = <<EOF
+enabled = true
+name = OAuth
+allow_sign_up = true
+client_id = your-client-id
+client_secret = your-client-secret
+scopes = openid email profile
+auth_url = https://dex.example.com/auth
+token_url = https://dex.example.com/token
+api_url = https://dex.example.com/userinfo
+EOF
+  }
+}
+
+resource "helm_release" "loki" {
+  name       = "loki"
+  namespace  = kubernetes_namespace.monitoring.metadata[0].name
+  repository = "https://grafana.github.io/helm-charts"
+  chart      = "loki"
+  version    = "2.9.0"
+
+  set {
+    name  = "loki.config.storage_config.aws_s3"
+    value = <<EOF
+bucketnames: "loki-bucket"
+region: "us-west-2"
+EOF
+  }
+
+  set {
+    name  = "loki.config.auth_enabled"
+    value = "true"
+  }
+}
+
+resource "helm_release" "tempo" {
+  name       = "tempo"
+  namespace  = kubernetes_namespace.monitoring.metadata[0].name
+  repository = "https://grafana.github.io/helm-charts"
+  chart      = "tempo"
+  version    = "0.7.0"
+
+  set {
+    name  = "tempo.config.receivers.jaeger"
+    value = "true"
+  }
+}
+
+resource "helm_release" "velero" {
+  name       = "velero"
+  namespace  = "velero"
+  repository = "https://vmware-tanzu.github.io/helm-charts"
+  chart      = "velero"
+  version    = "2.23.0"
+
+  set {
+    name  = "configuration.provider"
+    value = "aws"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.bucket"
+    value = "velero-backups"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.region"
+    value = "us-west-2"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.s3ForcePathStyle"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.s3Url"
+    value = "https://s3.amazonaws.com"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.s3ForcePathStyle"
+    value = "true"
+  }
+}

generated/complex/gpt-4o/complex-k8s-tf-002/main.yaml

@@ -0,0 +1,241 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: tenant-root
+---
+apiVersion: hnc.x-k8s.io/v1alpha2
+kind: HierarchyConfiguration
+metadata:
+  name: hierarchy
+  namespace: tenant-root
+spec:
+  children:
+  - dev
+  - staging
+  - prod
+---
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: enforce-approved-registries
+spec:
+  rules:
+  - name: validate-image-registry
+    match:
+      resources:
+        kinds:
+        - Pod
+    validate:
+      message: "Images must be pulled from approved registries"
+      pattern:
+        spec:
+          containers:
+          - image: "approved-registry.com/*"
+---
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: enforce-image-signature
+spec:
+  rules:
+  - name: verify-image-signature
+    match:
+      resources:
+        kinds:
+        - Pod
+    verifyImages:
+    - image: "approved-registry.com/*"
+      key: "cosign.pub"
+---
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: inject-resource-quotas
+spec:
+  rules:
+  - name: add-resource-quotas
+    match:
+      resources:
+        kinds:
+        - Namespace
+    mutate:
+      patchStrategicMerge:
+        spec:
+          resourceQuota:
+            hard:
+              requests.cpu: "1"
+              requests.memory: "1Gi"
+              limits.cpu: "2"
+              limits.memory: "2Gi"
+---
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: inject-limit-ranges
+spec:
+  rules:
+  - name: add-limit-ranges
+    match:
+      resources:
+        kinds:
+        - Namespace
+    mutate:
+      patchStrategicMerge:
+        spec:
+          limitRange:
+            limits:
+            - default:
+                cpu: "500m"
+                memory: "256Mi"
+              defaultRequest:
+                cpu: "250m"
+                memory: "128Mi"
+---
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: enforce-security-context
+spec:
+  rules:
+  - name: add-security-context
+    match:
+      resources:
+        kinds:
+        - Pod
+    mutate:
+      patchStrategicMerge:
+        spec:
+          securityContext:
+            runAsNonRoot: true
+            readOnlyRootFilesystem: true
+            capabilities:
+              drop: ["ALL"]
+---
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: default-deny
+  namespace: tenant-root
+spec:
+  podSelector: {}
+  policyTypes:
+  - Ingress
+  - Egress
+  ingress:
+  - from:
+    - podSelector: {}
+  egress:
+  - to:
+    - podSelector: {}
+---
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: rds-instance
+spec:
+  compositeTypeRef:
+    apiVersion: database.example.org/v1alpha1
+    kind: RDSInstance
+  resources:
+  - name: instance
+    base:
+      apiVersion: database.aws.crossplane.io/v1beta1
+      kind: RDSInstance
+      spec:
+        forProvider:
+          region: us-west-2
+---
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: s3-bucket
+spec:
+  compositeTypeRef:
+    apiVersion: storage.example.org/v1alpha1
+    kind: S3Bucket
+  resources:
+  - name: bucket
+    base:
+      apiVersion: s3.aws.crossplane.io/v1beta1
+      kind: Bucket
+      spec:
+        forProvider:
+          region: us-west-2
+---
+apiVersion: templates.gatekeeper.sh/v1beta1
+kind: ConstraintTemplate
+metadata:
+  name: k8sdisallowpublic
+spec:
+  crd:
+    spec:
+      names:
+        kind: K8sDisallowPublic
+  targets:
+  - target: admission.k8s.gatekeeper.sh
+    rego: |
+      package k8sdisallowpublic
+      violation[{"msg": msg}] {
+        input.review.object.spec.forProvider.publicAccessBlockConfiguration.blockPublicAcls == false
+        msg := "Public access is not allowed"
+      }
+---
+apiVersion: bitnami.com/v1alpha1
+kind: SealedSecret
+metadata:
+  name: mysecret
+  namespace: tenant-root
+spec:
+  encryptedData:
+    foo: AgB+...
+  template:
+    metadata:
+      labels:
+        app: myapp
+---
+apiVersion: argoproj.io/v1alpha1
+kind: ApplicationSet
+metadata:
+  name: tenants
+spec:
+  generators:
+  - git:
+      repoURL: https://github.com/example/tenants
+      directory:
+        recurse: true
+  template:
+    metadata:
+      name: '{{path.basename}}'
+    spec:
+      project: '{{path.basename}}'
+      source:
+        repoURL: https://github.com/example/tenants
+        path: '{{path}}'
+        targetRevision: HEAD
+      destination:
+        server: https://kubernetes.default.svc
+        namespace: '{{path.basename}}'
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  namespace: tenant-root
+  name: tenant-admin
+rules:
+- apiGroups: [""]
+  resources: ["pods", "services", "deployments"]
+  verbs: ["get", "list", "watch", "create", "update", "delete"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: tenant-admin-binding
+  namespace: tenant-root
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: tenant-admin
+subjects:
+- kind: User
+  name: tenant-user
+  apiGroup: rbac.authorization.k8s.io

generated/complex/gpt-4o/complex-k8s-tf-003/main.yaml

@@ -0,0 +1,128 @@
+apiVersion: linkerd.io/v1alpha2
+kind: ServiceProfile
+metadata:
+  name: my-service.default.svc.cluster.local
+spec:
+  routes:
+    - name: "/api/v1"
+      condition:
+        method: GET
+      isRetryable: true
+      responseClasses:
+        - condition:
+            status:
+              min: 500
+              max: 599
+          isFailure: true
+---
+apiVersion: split.smi-spec.io/v1alpha2
+kind: TrafficSplit
+metadata:
+  name: my-service-split
+spec:
+  service: my-service
+  backends:
+    - service: my-service-primary
+      weight: 90
+    - service: my-service-canary
+      weight: 10
+---
+apiVersion: policy.linkerd.io/v1alpha1
+kind: AuthorizationPolicy
+metadata:
+  name: my-service-authz
+spec:
+  targetRef:
+    kind: ServiceAccount
+    name: my-service-account
+  rules:
+    - from:
+        - source:
+            kind: ServiceAccount
+            name: allowed-service-account
+---
+apiVersion: linkerd.io/v1alpha1
+kind: LinkerdViz
+metadata:
+  name: linkerd-viz
+spec:
+  prometheus:
+    enabled: true
+  grafana:
+    enabled: true
+---
+apiVersion: linkerd.io/v1alpha1
+kind: LinkerdJaeger
+metadata:
+  name: linkerd-jaeger
+spec:
+  tracing:
+    enabled: true
+---
+apiVersion: getambassador.io/v2
+kind: Host
+metadata:
+  name: my-host
+spec:
+  hostname: my-service.example.com
+  acmeProvider:
+    authority: https://acme-v02.api.letsencrypt.org/directory
+  tlsSecret:
+    name: my-tls-secret
+  requestPolicy:
+    insecure:
+      action: Redirect
+  cors:
+    origins:
+      - "*"
+    methods:
+      - GET
+      - POST
+    headers:
+      - Content-Type
+---
+apiVersion: getambassador.io/v2
+kind: RateLimitService
+metadata:
+  name: rate-limit
+spec:
+  service: redis-rate-limit.default:6379
+  timeout_ms: 1000
+---
+apiVersion: getambassador.io/v2
+kind: Mapping
+metadata:
+  name: my-service-mapping
+spec:
+  prefix: /api/
+  service: my-service.default.svc.cluster.local
+  host: my-service.example.com
+  cors:
+    origins:
+      - "*"
+    methods:
+      - GET
+      - POST
+    headers:
+      - Content-Type
+  rate_limits:
+    - descriptor_key: client_ip
+      rate: 1000
+      unit: minute
+  ext_auth:
+    enabled: true
+    auth_service: oauth2-proxy.default:4180
+---
+apiVersion: linkerd.io/v1alpha1
+kind: LinkerdMulticluster
+metadata:
+  name: linkerd-multicluster
+spec:
+  gateways:
+    - name: cluster1-gateway
+    - name: cluster2-gateway
+    - name: cluster3-gateway
+  serviceMirroring:
+    enabled: true
+  endpointVerification:
+    enabled: true

generated/complex/gpt-4o/complex-k8s-tf-004/main.tf

@@ -0,0 +1,398 @@
+provider "kubernetes" {
+  config_path = "~/.kube/config"
+}
+
+resource "kubernetes_namespace" "tekton" {
+  metadata {
+    name = "tekton"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-triggers" {
+  metadata {
+    name = "tekton-triggers"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-chains" {
+  metadata {
+    name = "tekton-chains"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-dashboard" {
+  metadata {
+    name = "tekton-dashboard"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-results" {
+  metadata {
+    name = "tekton-results"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-monitoring" {
+  metadata {
+    name = "tekton-monitoring"
+  }
+}
+
+resource "kubernetes_namespace" "tekton-pipelines" {
+  metadata {
+    name = "tekton-pipelines"
+  }
+}
+
+resource "kubernetes_namespace" "argo-cd" {
+  metadata {
+    name = "argo-cd"
+  }
+}
+
+resource "kubernetes_network_policy" "tekton_network_policy" {
+  metadata {
+    name      = "default-deny"
+    namespace = "tekton"
+  }
+
+  spec {
+    pod_selector {}
+
+    policy_types = ["Ingress", "Egress"]
+  }
+}
+
+resource "kubernetes_service_account" "tekton_pipelines" {
+  metadata {
+    name      = "tekton-pipelines"
+    namespace = "tekton-pipelines"
+  }
+}
+
+resource "kubernetes_role_binding" "tekton_pipelines" {
+  metadata {
+    name      = "tekton-pipelines"
+    namespace = "tekton-pipelines"
+  }
+
+  role_ref {
+    api_group = "rbac.authorization.k8s.io"
+    kind      = "ClusterRole"
+    name      = "tekton-pipelines-controller"
+  }
+
+  subjects {
+    kind      = "ServiceAccount"
+    name      = kubernetes_service_account.tekton_pipelines.metadata[0].name
+    namespace = kubernetes_service_account.tekton_pipelines.metadata[0].namespace
+  }
+}
+
+resource "kubernetes_deployment" "tekton_pipelines" {
+  metadata {
+    name      = "tekton-pipelines-controller"
+    namespace = "tekton-pipelines"
+  }
+
+  spec {
+    replicas = 1
+
+    selector {
+      match_labels = {
+        app = "tekton-pipelines-controller"
+      }
+    }
+
+    template {
+      metadata {
+        labels = {
+          app = "tekton-pipelines-controller"
+        }
+      }
+
+      spec {
+        service_account_name = kubernetes_service_account.tekton_pipelines.metadata[0].name
+
+        containers {
+          name  = "tekton-pipelines-controller"
+          image = "gcr.io/tekton-releases/github.com/tektoncd/pipeline/cmd/controller:v0.30.0"
+
+          security_context {
+            run_as_user = 1000
+            run_as_group = 3000
+            fs_group = 2000
+          }
+        }
+      }
+    }
+  }
+}
+
+resource "kubernetes_service" "tekton_dashboard" {
+  metadata {
+    name      = "tekton-dashboard"
+    namespace = "tekton-dashboard"
+  }
+
+  spec {
+    selector = {
+      app = "tekton-dashboard"
+    }
+
+    ports {
+      port        = 9097
+      target_port = 9097
+    }
+  }
+}
+
+resource "kubernetes_ingress" "tekton_dashboard" {
+  metadata {
+    name      = "tekton-dashboard"
+    namespace = "tekton-dashboard"
+    annotations = {
+      "nginx.ingress.kubernetes.io/whitelist-source-range" = "192.168.1.0/24"
+      "nginx.ingress.kubernetes.io/auth-url"               = "https://auth.example.com/oauth2/auth"
+      "nginx.ingress.kubernetes.io/auth-signin"            = "https://auth.example.com/oauth2/start?rd=$request_uri"
+    }
+  }
+
+  spec {
+    rules {
+      host = "tekton-dashboard.example.com"
+
+      http {
+        paths {
+          path = "/"
+
+          backend {
+            service_name = kubernetes_service.tekton_dashboard.metadata[0].name
+            service_port = 9097
+          }
+        }
+      }
+    }
+  }
+}
+
+resource "kubernetes_secret" "github_webhook_secret" {
+  metadata {
+    name      = "github-webhook-secret"
+    namespace = "tekton-triggers"
+  }
+
+  data = {
+    secret = base64encode("your-github-webhook-secret")
+  }
+}
+
+resource "kubernetes_config_map" "tekton_triggers_eventlistener" {
+  metadata {
+    name      = "tekton-triggers-eventlistener"
+    namespace = "tekton-triggers"
+  }
+
+  data = {
+    "eventlistener.yaml" = <<EOF
+apiVersion: triggers.tekton.dev/v1alpha1
+kind: EventListener
+metadata:
+  name: github-listener
+spec:
+  serviceAccountName: tekton-triggers
+  triggers:
+    - name: github-trigger
+      interceptors:
+        - ref:
+            name: "github"
+          params:
+            - name: secretRef
+              value:
+                secretKey: secret
+                secretName: github-webhook-secret
+      bindings:
+        - ref: pipeline-binding
+      template:
+        ref: pipeline-template
+EOF
+  }
+}
+
+resource "kubernetes_secret" "cosign_kms_key" {
+  metadata {
+    name      = "cosign-kms-key"
+    namespace = "tekton-pipelines"
+  }
+
+  data = {
+    key = base64encode("your-kms-key")
+  }
+}
+
+resource "kubernetes_config_map" "tekton_pipeline" {
+  metadata {
+    name      = "tekton-pipeline"
+    namespace = "tekton-pipelines"
+  }
+
+  data = {
+    "pipeline.yaml" = <<EOF
+apiVersion: tekton.dev/v1beta1
+kind: Pipeline
+metadata:
+  name: image-build-pipeline
+spec:
+  tasks:
+    - name: git-clone
+      taskRef:
+        name: git-clone
+    - name: build-image
+      taskRef:
+        name: buildah
+      params:
+        - name: IMAGE
+          value: "$(params.image-url)"
+    - name: scan-image
+      taskRef:
+        name: trivy
+      params:
+        - name: IMAGE
+          value: "$(tasks.build-image.results.image)"
+    - name: sign-image
+      taskRef:
+        name: cosign
+      params:
+        - name: IMAGE
+          value: "$(tasks.build-image.results.image)"
+        - name: KMS_KEY
+          valueFrom:
+            secretKeyRef:
+              name: cosign-kms-key
+              key: key
+    - name: validate-manifests
+      taskRef:
+        name: conftest
+      params:
+        - name: MANIFESTS
+          value: "$(tasks.build-image.results.manifests)"
+    - name: deploy
+      taskRef:
+        name: argocd-sync
+      params:
+        - name: APP
+          value: "$(params.app-name)"
+EOF
+  }
+}
+
+resource "kubernetes_config_map" "tekton_results_config" {
+  metadata {
+    name      = "tekton-results-config"
+    namespace = "tekton-results"
+  }
+
+  data = {
+    "config.yaml" = <<EOF
+database:
+  user: "results"
+  password: "results-password"
+  host: "postgresql"
+  port: 5432
+  dbname: "tekton_results"
+EOF
+  }
+}
+
+resource "kubernetes_cron_job" "pipeline_run_cleanup" {
+  metadata {
+    name      = "pipeline-run-cleanup"
+    namespace = "tekton-pipelines"
+  }
+
+  spec {
+    schedule = "0 0 * * *"
+
+    job_template {
+      spec {
+        template {
+          spec {
+            containers {
+              name  = "cleanup"
+              image = "gcr.io/tekton-releases/github.com/tektoncd/pipeline/cmd/pipelinerun-cleanup:v0.30.0"
+            }
+
+            restart_policy = "OnFailure"
+          }
+        }
+      }
+    }
+  }
+}
+
+resource "kubernetes_service_monitor" "tekton_pipelines" {
+  metadata {
+    name      = "tekton-pipelines"
+    namespace = "tekton-monitoring"
+  }
+
+  spec {
+    selector {
+      match_labels = {
+        app = "tekton-pipelines-controller"
+      }
+    }
+
+    endpoints {
+      port = "metrics"
+    }
+  }
+}
+
+resource "kubernetes_config_map" "grafana_dashboard" {
+  metadata {
+    name      = "tekton-dashboard"
+    namespace = "tekton-monitoring"
+  }
+
+  data = {
+    "dashboard.json" = <<EOF
+{
+  "dashboard": {
+    "panels": [
+      {
+        "title": "Build Success Rate",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "sum(rate(tekton_pipelines_builds_success[5m])) / sum(rate(tekton_pipelines_builds_total[5m]))",
+            "format": "time_series"
+          }
+        ]
+      },
+      {
+        "title": "Build Duration",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "histogram_quantile(0.95, sum(rate(tekton_pipelines_build_duration_seconds_bucket[5m])) by (le))",
+            "format": "time_series"
+          }
+        ]
+      },
+      {
+        "title": "Vulnerability Trends",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "sum(rate(trivy_vulnerabilities_total[5m])) by (severity)",
+            "format": "time_series"
+          }
+        ]
+      }
+    ]
+  }
+}
+EOF
+  }
+}

generated/complex/gpt-4o/complex-k8s-tf-005/main.yaml

@@ -0,0 +1,129 @@
+apiVersion: cockroachlabs.com/v1alpha1
+kind: CrdbCluster
+metadata:
+  name: cockroachdb
+spec:
+  nodes: 9
+  regions:
+    - name: region-a
+      nodes: 3
+    - name: region-b
+      nodes: 3
+    - name: region-c
+      nodes: 3
+  tls:
+    enabled: true
+    certManagerIssuer: "letsencrypt-prod"
+  locality:
+    partitioning: "gdpr"
+  backup:
+    schedule: "0 2 * * *"
+    storage:
+      type: "s3"
+      s3:
+        bucket: "cockroachdb-backups"
+        region: "us-west-1"
+  podAntiAffinity: true
+  topologySpreadConstraints:
+    - maxSkew: 1
+      topologyKey: "topology.kubernetes.io/zone"
+  podDisruptionBudget:
+    maxUnavailable: 1
+  storage:
+    className: "gp2-encrypted"
+    volumeExpansion: true
+
+---
+apiVersion: kafka.strimzi.io/v1beta2
+kind: Kafka
+metadata:
+  name: kafka-cluster
+spec:
+  kafka:
+    version: "3.0.0"
+    replicas: 3
+    listeners:
+      - name: tls
+        port: 9093
+        type: internal
+        tls: true
+        authentication:
+          type: scram-sha-512
+    authorization:
+      type: simple
+    storage:
+      type: jbod
+      volumes:
+        - id: 0
+          type: persistent-claim
+          size: 100Gi
+          class: "gp2-encrypted"
+          deleteClaim: false
+    config:
+      offsets.topic.replication.factor: 3
+      transaction.state.log.replication.factor: 3
+      transaction.state.log.min.isr: 2
+      log.message.format.version: "3.0"
+    podDisruptionBudget:
+      maxUnavailable: 1
+    podAntiAffinity: true
+    topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: "topology.kubernetes.io/zone"
+  zookeeper:
+    replicas: 3
+    storage:
+      type: persistent-claim
+      size: 100Gi
+      class: "gp2-encrypted"
+      deleteClaim: false
+  entityOperator:
+    topicOperator: {}
+    userOperator: {}
+  kafkaMirrorMaker2:
+    replicas: 3
+    connectCluster: "target-cluster"
+    consumer:
+      config:
+        group.id: "mirror-maker-consumer"
+    producer:
+      config:
+        acks: "all"
+  cruiseControl:
+    config:
+      num.partition.replicas: 3
+
+---
+apiVersion: redis.redis.opstreelabs.in/v1beta1
+kind: RedisSentinel
+metadata:
+  name: redis-sentinel
+spec:
+  size: 3
+  redis:
+    image: "redis:6.2"
+    storage:
+      type: persistent-claim
+      size: 10Gi
+      class: "gp2-encrypted"
+      volumeExpansion: true
+    tls:
+      enabled: true
+      certManagerIssuer: "letsencrypt-prod"
+    acl:
+      enabled: true
+  sentinel:
+    replicas: 3
+  podDisruptionBudget:
+    maxUnavailable: 1
+  podAntiAffinity: true
+  topologySpreadConstraints:
+    - maxSkew: 1
+      topologyKey: "topology.kubernetes.io/zone"
+  backup:
+    schedule: "0 3 * * *"
+    storage:
+      type: "s3"
+      s3:
+        bucket: "redis-backups"
+        region: "us-west-1"

generated/complex/gpt-4o/complex-k8s-tf-006/main.tf

@@ -0,0 +1,264 @@
+provider "helm" {
+  kubernetes {
+    config_path = "~/.kube/config"
+  }
+}
+
+provider "aws" {
+  region = "us-west-2"
+}
+
+resource "helm_release" "vault" {
+  name       = "vault"
+  namespace  = "vault"
+  chart      = "hashicorp/vault"
+  repository = "https://helm.releases.hashicorp.com"
+
+  values = [
+    <<EOF
+server:
+  ha:
+    enabled: true
+  dataStorage:
+    enabled: true
+    storageClass: "encrypted-storage-class"
+  auditStorage:
+    enabled: true
+    storageClass: "audit-storage-class"
+  extraEnvironmentVars:
+    VAULT_AUDIT_LOG_PATH: "/vault/logs/audit.log"
+    VAULT_AUDIT_LOG_FORWARDER: "loki"
+  extraVolumes:
+    - name: audit-log
+      persistentVolumeClaim:
+        claimName: audit-log-pvc
+  extraVolumeMounts:
+    - name: audit-log
+      mountPath: /vault/logs
+  extraArgs:
+    - "-auto-unseal"
+    - "-seal=awskms"
+    - "-seal-config=region=us-west-2"
+    - "-seal-config=kms_key_id=your-kms-key-id"
+    - "-seal-config=access_key=your-access-key"
+    - "-seal-config=secret_key=your-secret-key"
+injector:
+  enabled: true
+EOF
+  ]
+}
+
+resource "kubernetes_namespace" "vault" {
+  metadata {
+    name = "vault"
+  }
+}
+
+resource "kubernetes_persistent_volume_claim" "audit_log" {
+  metadata {
+    name      = "audit-log-pvc"
+    namespace = "vault"
+  }
+  spec {
+    access_modes = ["ReadWriteOnce"]
+    resources {
+      requests {
+        storage = "10Gi"
+      }
+    }
+    storage_class_name = "audit-storage-class"
+  }
+}
+
+resource "vault_mount" "pki" {
+  path        = "pki"
+  type        = "pki"
+  description = "PKI secrets engine"
+}
+
+resource "vault_pki_secret_backend_root_cert" "root_ca" {
+  backend = vault_mount.pki.path
+  common_name = "example.com"
+  ttl = "87600h"
+}
+
+resource "vault_pki_secret_backend_intermediate_cert_request" "intermediate_ca" {
+  backend = vault_mount.pki.path
+  common_name = "intermediate.example.com"
+  ttl = "43800h"
+}
+
+resource "vault_auth_backend" "kubernetes" {
+  type = "kubernetes"
+  description = "Kubernetes auth backend"
+}
+
+resource "vault_kubernetes_auth_backend_config" "config" {
+  backend = vault_auth_backend.kubernetes.path
+  kubernetes_host = "https://kubernetes.default.svc"
+  kubernetes_ca_cert = file("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt")
+  token_reviewer_jwt = file("/var/run/secrets/kubernetes.io/serviceaccount/token")
+}
+
+resource "vault_kubernetes_auth_backend_role" "example" {
+  backend = vault_auth_backend.kubernetes.path
+  role_name = "example-role"
+  bound_service_account_names = ["example-sa"]
+  bound_service_account_namespaces = ["default"]
+  policies = ["example-policy"]
+  ttl = "1h"
+}
+
+resource "vault_aws_secret_backend" "aws" {
+  path = "aws"
+}
+
+resource "vault_aws_secret_backend_role" "iam_role" {
+  backend = vault_aws_secret_backend.aws.path
+  role = "arn:aws:iam::123456789012:role/example-role"
+  credential_type = "iam_user"
+  policy_document = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": "ec2:*",
+      "Resource": "*"
+    }
+  ]
+}
+EOF
+}
+
+resource "vault_database_secret_backend_connection" "postgres" {
+  backend = "database"
+  name    = "postgres"
+  allowed_roles = ["readonly"]
+  connection_url = "postgresql://{{username}}:{{password}}@db.example.com:5432/postgres?sslmode=disable"
+}
+
+resource "vault_database_secret_backend_role" "readonly" {
+  backend = "database"
+  name    = "readonly"
+  db_name = vault_database_secret_backend_connection.postgres.name
+  creation_statements = ["CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' VALID UNTIL '{{expiration}}';"]
+  revocation_statements = ["ALTER ROLE \"{{name}}\" NOLOGIN;"]
+  default_ttl = "1h"
+  max_ttl = "24h"
+}
+
+resource "vault_transit_secret_backend" "transit" {
+  path = "transit"
+}
+
+resource "vault_policy" "example-policy" {
+  name = "example-policy"
+  policy = <<EOF
+path "secret/data/*" {
+  capabilities = ["create", "read", "update", "delete", "list"]
+}
+EOF
+}
+
+resource "vault_identity_entity" "example_entity" {
+  name = "example-entity"
+}
+
+resource "vault_identity_entity_alias" "example_alias" {
+  name = "example-alias"
+  canonical_id = vault_identity_entity.example_entity.id
+  mount_accessor = vault_auth_backend.kubernetes.accessor
+}
+
+resource "vault_mfa_duo" "example_mfa" {
+  name = "example-mfa"
+  type = "duo"
+  mount_accessor = vault_auth_backend.kubernetes.accessor
+  config = {
+    host = "api-XXXXXXXX.duosecurity.com"
+    integration_key = "DIXXXXXXXXXXXXXXXXXX"
+    secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+  }
+}
+
+resource "kubernetes_custom_resource_definition" "vault_secrets_operator" {
+  metadata {
+    name = "vaultsecretsoperator"
+  }
+  spec {
+    group = "vault.hashicorp.com"
+    names {
+      kind = "VaultSecret"
+      listKind = "VaultSecretList"
+      plural = "vaultsecrets"
+      singular = "vaultsecret"
+    }
+    scope = "Namespaced"
+    versions {
+      name = "v1"
+      served = true
+      storage = true
+    }
+  }
+}
+
+resource "kubernetes_custom_resource_definition" "vault_static_secret" {
+  metadata {
+    name = "vaultstaticsecret"
+  }
+  spec {
+    group = "vault.hashicorp.com"
+    names {
+      kind = "VaultStaticSecret"
+      listKind = "VaultStaticSecretList"
+      plural = "vaultstaticsecrets"
+      singular = "vaultstaticsecret"
+    }
+    scope = "Namespaced"
+    versions {
+      name = "v1"
+      served = true
+      storage = true
+    }
+  }
+}
+
+resource "kubernetes_custom_resource_definition" "vault_dynamic_secret" {
+  metadata {
+    name = "vaultdynamicsecret"
+  }
+  spec {
+    group = "vault.hashicorp.com"
+    names {
+      kind = "VaultDynamicSecret"
+      listKind = "VaultDynamicSecretList"
+      plural = "vaultdynamicsecrets"
+      singular = "vaultdynamicsecret"
+    }
+    scope = "Namespaced"
+    versions {
+      name = "v1"
+      served = true
+      storage = true
+    }
+  }
+}
+
+resource "cert_manager_cluster_issuer" "vault_issuer" {
+  metadata {
+    name = "vault-issuer"
+  }
+  spec {
+    vault {
+      server = "http://vault.vault.svc.cluster.local:8200"
+      path = "pki/sign/example-dot-com"
+      auth {
+        tokenSecretRef {
+          name = "vault-token"
+          key = "token"
+        }
+      }
+    }
+  }
+}

generated/complex/gpt-4o/complex-k8s-tf-007/main.yaml

@@ -0,0 +1,264 @@
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  name: falco
+  namespace: kube-system
+spec:
+  selector:
+    matchLabels:
+      app: falco
+  template:
+    metadata:
+      labels:
+        app: falco
+    spec:
+      containers:
+      - name: falco
+        image: falcosecurity/falco:latest
+        securityContext:
+          privileged: true
+        volumeMounts:
+        - mountPath: /host/var/run/docker.sock
+          name: docker-socket
+        - mountPath: /host/proc
+          name: proc
+          readOnly: true
+        - mountPath: /host/boot
+          name: boot
+          readOnly: true
+        - mountPath: /host/lib/modules
+          name: lib-modules
+          readOnly: true
+        - mountPath: /host/usr
+          name: usr
+          readOnly: true
+        env:
+        - name: FALCO_RULES_FILE
+          value: /etc/falco/falco_rules.yaml
+        - name: FALCO_SIDECAR_CONFIG
+          value: /etc/falco/falcosidekick.yaml
+      volumes:
+      - name: docker-socket
+        hostPath:
+          path: /var/run/docker.sock
+      - name: proc
+        hostPath:
+          path: /proc
+      - name: boot
+        hostPath:
+          path: /boot
+      - name: lib-modules
+        hostPath:
+          path: /lib/modules
+      - name: usr
+        hostPath:
+          path: /usr
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: falco-rules
+  namespace: kube-system
+data:
+  falco_rules.yaml: |
+    - rule: Detect Crypto Mining
+      desc: Detect crypto mining activity
+      condition: spawned_process and proc.name in (crypto-miners)
+      output: "Crypto mining detected (user=%user.name command=%proc.cmdline)"
+      priority: WARNING
+    - rule: Detect Reverse Shell
+      desc: Detect reverse shell attempts
+      condition: spawned_process and proc.name in (reverse-shells)
+      output: "Reverse shell detected (user=%user.name command=%proc.cmdline)"
+      priority: WARNING
+    - rule: Sensitive File Access
+      desc: Detect access to sensitive files
+      condition: open_read and fd.name in (sensitive-files)
+      output: "Sensitive file access detected (user=%user.name file=%fd.name)"
+      priority: WARNING
+    - rule: Privilege Escalation
+      desc: Detect privilege escalation attempts
+      condition: spawned_process and proc.name in (priv-escalation-tools)
+      output: "Privilege escalation detected (user=%user.name command=%proc.cmdline)"
+      priority: WARNING
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: falcosidekick-config
+  namespace: kube-system
+data:
+  falcosidekick.yaml: |
+    config:
+      slack:
+        webhookurl: "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
+      pagerduty:
+        routingkey: "your-pagerduty-routing-key"
+      loki:
+        hostport: "http://loki:3100"
+---
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  name: tetragon
+  namespace: kube-system
+spec:
+  selector:
+    matchLabels:
+      app: tetragon
+  template:
+    metadata:
+      labels:
+        app: tetragon
+    spec:
+      containers:
+      - name: tetragon
+        image: cilium/tetragon:latest
+        securityContext:
+          privileged: true
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: tetragon-policies
+  namespace: kube-system
+data:
+  tracing-policies.yaml: |
+    apiVersion: cilium.io/v1alpha1
+    kind: TracingPolicy
+    metadata:
+      name: block-unexpected-processes
+    spec:
+      selectors:
+        matchPIDs:
+          - namespace: default
+      action: block
+      matchActions:
+        - exec
+    ---
+    apiVersion: cilium.io/v1alpha1
+    kind: TracingPolicy
+    metadata:
+      name: block-unexpected-network
+    spec:
+      selectors:
+        matchPIDs:
+          - namespace: default
+      action: block
+      matchActions:
+        - connect
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: trivy-operator
+  namespace: kube-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: trivy-operator
+  template:
+    metadata:
+      labels:
+        app: trivy-operator
+    spec:
+      containers:
+      - name: trivy-operator
+        image: aquasec/trivy-operator:latest
+        env:
+        - name: TRIVY_OPERATOR_SLACK_WEBHOOK
+          value: "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: kubescape
+  namespace: kube-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: kubescape
+  template:
+    metadata:
+      labels:
+        app: kubescape
+    spec:
+      containers:
+      - name: kubescape
+        image: armosec/kubescape:latest
+        args:
+        - scan
+        - --compliance
+        - --schedule
+        - "0 0 * * *"
+        - --output
+        - prometheus
+---
+apiVersion: policy/v1
+kind: PodSecurityPolicy
+metadata:
+  name: restricted-psp
+spec:
+  privileged: false
+  allowPrivilegeEscalation: false
+  requiredDropCapabilities:
+    - ALL
+  volumes:
+    - 'configMap'
+    - 'emptyDir'
+    - 'projected'
+    - 'secret'
+    - 'downwardAPI'
+    - 'persistentVolumeClaim'
+  hostNetwork: false
+  hostIPC: false
+  hostPID: false
+  runAsUser:
+    rule: 'MustRunAsNonRoot'
+  seLinux:
+    rule: 'RunAsAny'
+  supplementalGroups:
+    rule: 'MustRunAs'
+    ranges:
+      - min: 1
+        max: 65535
+  fsGroup:
+    rule: 'MustRunAs'
+    ranges:
+      - min: 1
+        max: 65535
+---
+apiVersion: admissionregistration.k8s.io/v1
+kind: ValidatingAdmissionPolicy
+metadata:
+  name: restrict-host-access
+spec:
+  matchConstraints:
+    resourceRules:
+      - apiGroups: [""]
+        apiVersions: ["v1"]
+        resources: ["pods"]
+  validations:
+    - expression: "!object.spec.hostNetwork && !object.spec.hostPID && !object.spec.hostIPC"
+---
+apiVersion: admissionregistration.k8s.io/v1
+kind: MutatingWebhookConfiguration
+metadata:
+  name: seccomp-apparmor-webhook
+webhooks:
+  - name: seccomp-apparmor.k8s.io
+    clientConfig:
+      service:
+        name: seccomp-apparmor-webhook
+        namespace: kube-system
+        path: "/mutate"
+    rules:
+      - operations: ["CREATE"]
+        apiGroups: [""]
+        apiVersions: ["v1"]
+        resources: ["pods"]
+    admissionReviewVersions: ["v1"]
+    sideEffects: None
+    timeoutSeconds: 5

generated/complex/gpt-4o/complex-k8s-tf-008/main.tf

@@ -0,0 +1,139 @@
+provider "kubernetes" {
+  config_path = "~/.kube/config"
+}
+
+provider "helm" {
+  kubernetes {
+    config_path = "~/.kube/config"
+  }
+}
+
+resource "helm_release" "argocd" {
+  name       = "argocd"
+  repository = "https://argoproj.github.io/argo-helm"
+  chart      = "argo-cd"
+  namespace  = "argocd"
+
+  values = [
+    <<EOF
+server:
+  oidcConfig:
+    name: Keycloak
+    issuer: https://keycloak.example.com/auth/realms/myrealm
+    clientID: argocd
+    clientSecret: myclientsecret
+    requestedScopes: ["openid", "profile", "email", "groups"]
+
+rbac:
+  policy.csv: |
+    g, team1, role:admin
+    g, team2, role:readonly
+  policy.default: role:readonly
+
+  project:
+    - name: team1-project
+      sourceRepos:
+        - "https://github.com/org/repo1"
+      destinations:
+        - namespace: team1-ns
+          server: https://kubernetes.default.svc
+      clusterResourceWhitelist:
+        - group: '*'
+          kind: '*'
+      clusterResourceBlacklist:
+        - group: ''
+          kind: 'Secret'
+      syncWindows:
+        - kind: allow
+          schedule: "9-17 * * 1-5"
+          duration: 8h
+          applications:
+            - '*'
+
+notifications:
+  triggers:
+    - name: on-sync-succeeded
+      condition: app.status.operationState.phase == "Succeeded"
+      template: app-sync-succeeded
+  templates:
+    - name: app-sync-succeeded
+      title: Application {{.app.metadata.name}} sync succeeded
+      body: Application {{.app.metadata.name}} at {{.app.spec.source.repoURL}} sync succeeded.
+  services:
+    - name: slack
+      url: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
+    - name: github
+      url: https://api.github.com/repos/org/repo/statuses/{{.app.status.sync.revision}}
+
+imageUpdater:
+  enabled: true
+  writeBackMethod: git
+  semver:
+    constraints: ">=1.0.0 <2.0.0"
+
+rollouts:
+  analysisTemplates:
+    - name: canary-analysis
+      spec:
+        metrics:
+          - name: request-success-rate
+            interval: 1m
+            successCondition: result > 0.95
+            failureCondition: result < 0.90
+            provider:
+              prometheus:
+                address: http://prometheus-server
+                query: sum(rate(http_requests_total{status=~"2.."}[1m])) / sum(rate(http_requests_total[1m]))
+        webhooks:
+          - name: integration-tests
+            url: http://integration-tests-svc/run
+            timeoutSeconds: 300
+            failureThreshold: 1
+            successThreshold: 1
+
+events:
+  eventSources:
+    - name: webhook-source
+      webhook:
+        endpoint: /webhook
+        port: 12000
+    - name: s3-source
+      s3:
+        bucket: my-bucket
+        events:
+          - s3:ObjectCreated:*
+    - name: kafka-source
+      kafka:
+        url: kafka:9092
+        topic: my-topic
+  sensors:
+    - name: my-sensor
+      dependencies:
+        - name: webhook-dep
+          eventSourceName: webhook-source
+          eventName: example
+        - name: s3-dep
+          eventSourceName: s3-source
+          eventName: example
+        - name: kafka-dep
+          eventSourceName: kafka-source
+          eventName: example
+      triggers:
+        - template:
+            name: workflow-trigger
+            argoWorkflow:
+              source:
+                resource:
+                  apiVersion: argoproj.io/v1alpha1
+                  kind: Workflow
+                  metadata:
+                    generateName: triggered-workflow-
+                  spec:
+                    entrypoint: main
+                    templates:
+                      - name: main
+                        container:
+                          image: my-image
+EOF
+  ]
+}

generated/complex/gpt-4o/complex-k8s-tf-009/main.yaml

@@ -0,0 +1,327 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: kong
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: keycloak
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: backstage
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: kong
+  namespace: kong
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: kong
+  template:
+    metadata:
+      labels:
+        app: kong
+    spec:
+      containers:
+      - name: kong
+        image: kong/kong-gateway:latest
+        env:
+        - name: KONG_DATABASE
+          value: "off"
+        - name: KONG_PROXY_LISTEN
+          value: "0.0.0.0:8000, 0.0.0.0:8443 ssl"
+        - name: KONG_ADMIN_LISTEN
+          value: "0.0.0.0:8001, 0.0.0.0:8444 ssl"
+        ports:
+        - containerPort: 8000
+        - containerPort: 8443
+        - containerPort: 8001
+        - containerPort: 8444
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: keycloak
+  namespace: keycloak
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: keycloak
+  template:
+    metadata:
+      labels:
+        app: keycloak
+    spec:
+      containers:
+      - name: keycloak
+        image: quay.io/keycloak/keycloak:latest
+        env:
+        - name: DB_VENDOR
+          value: POSTGRES
+        - name: DB_ADDR
+          value: keycloak-db.keycloak.svc.cluster.local
+        - name: DB_DATABASE
+          value: keycloak
+        - name: DB_USER
+          value: keycloak
+        - name: DB_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: keycloak-db-secret
+              key: password
+        ports:
+        - containerPort: 8080
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: backstage
+  namespace: backstage
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: backstage
+  template:
+    metadata:
+      labels:
+        app: backstage
+    spec:
+      containers:
+      - name: backstage
+        image: backstage/backstage:latest
+        ports:
+        - containerPort: 7000
+---
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: kong-access
+  namespace: kong
+spec:
+  podSelector:
+    matchLabels:
+      app: kong
+  policyTypes:
+  - Ingress
+  - Egress
+  ingress:
+  - from:
+    - namespaceSelector:
+        matchLabels:
+          name: backstage
+    ports:
+    - protocol: TCP
+      port: 7000
+  egress:
+  - to:
+    - namespaceSelector:
+        matchLabels:
+          name: keycloak
+    ports:
+    - protocol: TCP
+      port: 8080
+---
+apiVersion: policy/v1
+kind: PodSecurityPolicy
+metadata:
+  name: restricted
+spec:
+  privileged: false
+  allowPrivilegeEscalation: false
+  requiredDropCapabilities:
+  - ALL
+  volumes:
+  - 'configMap'
+  - 'secret'
+  - 'emptyDir'
+  hostNetwork: false
+  hostIPC: false
+  hostPID: false
+  runAsUser:
+    rule: 'MustRunAsNonRoot'
+  seLinux:
+    rule: 'RunAsAny'
+  supplementalGroups:
+    rule: 'MustRunAs'
+    ranges:
+    - min: 1
+      max: 65535
+  fsGroup:
+    rule: 'MustRunAs'
+    ranges:
+    - min: 1
+      max: 65535
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: kong-proxy
+  namespace: kong
+spec:
+  type: LoadBalancer
+  ports:
+  - port: 80
+    targetPort: 8000
+  - port: 443
+    targetPort: 8443
+  selector:
+    app: kong
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: keycloak
+  namespace: keycloak
+spec:
+  ports:
+  - port: 8080
+    targetPort: 8080
+  selector:
+    app: keycloak
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: backstage
+  namespace: backstage
+spec:
+  ports:
+  - port: 7000
+    targetPort: 7000
+  selector:
+    app: backstage
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: rate-limiting
+  namespace: kong
+config:
+  minute: 20
+  policy: redis
+plugin: rate-limiting
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: oidc
+  namespace: kong
+config:
+  client_id: my-client-id
+  client_secret: my-client-secret
+  introspection_endpoint: http://keycloak.keycloak.svc.cluster.local:8080/auth/realms/myrealm/protocol/openid-connect/token/introspect
+plugin: openid-connect
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: request-transformer
+  namespace: kong
+config:
+  add:
+    headers:
+    - "X-Correlation-ID: $request_id"
+plugin: request-transformer
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: response-transformer
+  namespace: kong
+config:
+  remove:
+    headers:
+    - "Server"
+plugin: response-transformer
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: ip-restriction
+  namespace: kong
+config:
+  whitelist:
+  - "192.168.1.0/24"
+plugin: ip-restriction
+---
+apiVersion: configuration.konghq.com/v1
+kind: KongPlugin
+metadata:
+  name: bot-detection
+  namespace: kong
+plugin: bot-detection
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: keycloak-db
+  namespace: keycloak
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: keycloak-db
+  template:
+    metadata:
+      labels:
+        app: keycloak-db
+    spec:
+      containers:
+      - name: postgres
+        image: postgres:latest
+        env:
+        - name: POSTGRES_DB
+          value: keycloak
+        - name: POSTGRES_USER
+          value: keycloak
+        - name: POSTGRES_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: keycloak-db-secret
+              key: password
+        ports:
+        - containerPort: 5432
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: keycloak-db-secret
+  namespace: keycloak
+type: Opaque
+data:
+  password: cGFzc3dvcmQ= # base64 encoded password
+---
+apiVersion: networking.istio.io/v1beta1
+kind: PeerAuthentication
+metadata:
+  name: default
+  namespace: kong
+spec:
+  mtls:
+    mode: STRICT
+---
+apiVersion: networking.istio.io/v1beta1
+kind: PeerAuthentication
+metadata:
+  name: default
+  namespace: keycloak
+spec:
+  mtls:
+    mode: STRICT
+---
+apiVersion: networking.istio.io/v1beta1
+kind: PeerAuthentication
+metadata:
+  name: default
+  namespace: backstage
+spec:
+  mtls:
+    mode: STRICT

generated/complex/gpt-4o/complex-k8s-tf-010/main.tf

@@ -0,0 +1,225 @@
+provider "kubernetes" {
+  config_path = "~/.kube/config"
+}
+
+provider "helm" {
+  kubernetes {
+    config_path = "~/.kube/config"
+  }
+}
+
+resource "helm_release" "velero" {
+  name       = "velero"
+  repository = "https://vmware-tanzu.github.io/helm-charts"
+  chart      = "velero"
+  version    = "2.23.0"
+
+  set {
+    name  = "configuration.backupStorageLocation.name"
+    value = "aws"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.bucket"
+    value = "velero-backups"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.region"
+    value = "us-west-2"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.s3ForcePathStyle"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.serverSideEncryption"
+    value = "AES256"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.immutable"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.backupStorageLocation.config.retentionPolicy"
+    value = "30d"
+  }
+
+  set {
+    name  = "configuration.schedule"
+    value = "0 2 * * *"
+  }
+
+  set {
+    name  = "configuration.scheduleSelector"
+    value = "environment=production"
+  }
+
+  set {
+    name  = "configuration.includeNamespaces"
+    value = "default,production"
+  }
+
+  set {
+    name  = "configuration.excludeNamespaces"
+    value = "kube-system"
+  }
+
+  set {
+    name  = "configuration.preBackupHooks"
+    value = "snapshot.sh"
+  }
+
+  set {
+    name  = "configuration.postBackupHooks"
+    value = "cleanup.sh"
+  }
+}
+
+resource "helm_release" "submariner" {
+  name       = "submariner"
+  repository = "https://submariner.io/charts"
+  chart      = "submariner"
+  version    = "0.11.0"
+
+  set {
+    name  = "globalnet.enabled"
+    value = "true"
+  }
+
+  set {
+    name  = "broker.k8sSecret"
+    value = "submariner-broker"
+  }
+
+  set {
+    name  = "globalnet.cidrRange"
+    value = "169.254.0.0/16"
+  }
+
+  set {
+    name  = "serviceDiscovery.enabled"
+    value = "true"
+  }
+}
+
+resource "helm_release" "cloudcasa" {
+  name       = "cloudcasa"
+  repository = "https://cloudcasa.io/charts"
+  chart      = "cloudcasa"
+  version    = "1.0.0"
+
+  set {
+    name  = "configuration.applicationBackup"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.helmReleaseMetadata"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.pvcSnapshots"
+    value = "true"
+  }
+
+  set {
+    name  = "configuration.csiSnapshotClass"
+    value = "csi-snapshot-class"
+  }
+}
+
+resource "kubernetes_custom_resource_definition" "failover_operator" {
+  metadata {
+    name = "failover-operator"
+  }
+
+  spec {
+    group   = "failover.example.com"
+    version = "v1"
+    names {
+      kind     = "Failover"
+      listKind = "FailoverList"
+      plural   = "failovers"
+      singular = "failover"
+    }
+    scope = "Namespaced"
+  }
+}
+
+resource "kubernetes_cluster_role" "dr_operator" {
+  metadata {
+    name = "dr-operator"
+  }
+
+  rule {
+    api_groups = [""]
+    resources  = ["pods", "services", "endpoints", "persistentvolumeclaims"]
+    verbs      = ["get", "list", "watch", "create", "update", "patch", "delete"]
+  }
+
+  rule {
+    api_groups = ["apps"]
+    resources  = ["deployments", "statefulsets"]
+    verbs      = ["get", "list", "watch", "create", "update", "patch", "delete"]
+  }
+
+  rule {
+    api_groups = ["failover.example.com"]
+    resources  = ["failovers"]
+    verbs      = ["get", "list", "watch", "create", "update", "patch", "delete"]
+  }
+}
+
+resource "kubernetes_cron_job" "dr_drill" {
+  metadata {
+    name = "dr-drill"
+  }
+
+  spec {
+    schedule = "0 3 * * *"
+    job_template {
+      spec {
+        template {
+          spec {
+            container {
+              name  = "dr-drill"
+              image = "dr-drill-image:latest"
+              command = ["/bin/sh", "-c", "validate-backup.sh"]
+            }
+            restart_policy = "OnFailure"
+          }
+        }
+      }
+    }
+  }
+}
+
+resource "prometheus_alert_rule" "backup_freshness" {
+  alert = "BackupFreshness"
+  expr  = "time() - velero_backup_last_successful_timestamp_seconds > 86400"
+  labels = {
+    severity = "warning"
+  }
+  annotations = {
+    summary     = "Backup freshness alert"
+    description = "The last successful Velero backup is older than 24 hours."
+  }
+}
+
+resource "prometheus_alert_rule" "cross_cluster_connectivity" {
+  alert = "CrossClusterConnectivity"
+  expr  = "submariner_gateway_down > 0"
+  labels = {
+    severity = "critical"
+  }
+  annotations = {
+    summary     = "Cross-cluster connectivity alert"
+    description = "One or more Submariner gateways are down."
+  }
+}