32b - AI辅助IaC生成

你需要 AI 辅助 IaC 生成？
│
├── 你是否熟悉 IaC？
│   ├── 不熟悉 → Spacelift Intent（自然语言，无需学习 HCL）
│   └── 熟悉 → 继续 ↓
│
├── 你偏好哪种 IaC 工具？
│   ├── Terraform (HCL) → GitHub Copilot + Claude Code + Spacelift
│   ├── Pulumi (TypeScript/Python/Go) → Pulumi AI + GitHub Copilot
│   ├── AWS CDK (TypeScript/Python) → Amazon Q Developer + GitHub Copilot
│   └── CloudFormation (YAML/JSON) → Amazon Q Developer
│
├── 你需要什么级别的 AI 辅助？
│   ├── 代码补全 → GitHub Copilot / Cursor
│   ├── 完整模块生成 → Claude Code / Kiro / Pulumi AI
│   └── 自然语言→基础设施 → Spacelift Intent
│
└── 你需要额外能力？
    ├── 成本估算 → + Infracost
    ├── 安全扫描 → + Checkov / tfsec / Snyk IaC
    └── 漂移检测 → + Spacelift / env0

┌─────────────────────────────────────────────────────────────────┐
│              Terraform AI 辅助生成工作流                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ① 需求描述          ② AI 生成           ③ 安全审查              │
│  ┌──────────┐       ┌──────────┐       ┌──────────┐            │
│  │ 自然语言  │ ──→  │ HCL 代码  │ ──→  │ Checkov   │            │
│  │ 需求描述  │       │ 模块生成  │       │ tfsec     │            │
│  │ + Steering│       │ + 变量   │       │ Snyk IaC  │            │
│  │   规则    │       │ + 输出   │       │ 人工审查   │            │
│  └──────────┘       └──────────┘       └──────────┘            │
│                                              │                  │
│  ⑥ 监控漂移          ⑤ 部署执行           ④ 成本估算              │
│  ┌──────────┐       ┌──────────┐       ┌──────────┐            │
│  │ Spacelift │ ←──  │ terraform │ ←──  │ Infracost │            │
│  │ 漂移检测  │       │ plan     │       │ 成本预估  │            │
│  │ AI 修复   │       │ apply    │       │ PR 评审   │            │
│  └──────────┘       └──────────┘       └──────────┘            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

---
inclusion: auto
globs: ["**/*.tf", "**/*.tfvars", "**/terraform/**"]
---
 
# Terraform Steering 规则
 
## 通用规则
- 使用 Terraform >= 1.9 语法
- 所有资源必须包含 `tags` 块，至少包含 environment、team、cost-center、managed-by 标签
- 使用 `terraform-aws-modules` 官方模块优先于自定义资源
- 变量必须包含 `description` 和 `type`，敏感变量标记 `sensitive = true`
- 输出必须包含 `description`
 
## 安全规则
- 安全组禁止 `0.0.0.0/0` 入站规则（ALB/NLB 的 80/443 端口除外）
- 所有 S3 存储桶必须启用 `server_side_encryption_configuration` 和 `versioning`
- 所有 S3 存储桶必须阻止公共访问（`block_public_acls = true` 等）
- RDS 实例必须启用 `storage_encrypted = true` 和 `backup_retention_period >= 7`
- IAM 策略必须遵循最小权限原则，禁止使用 `"Action": "*"` 或 `"Resource": "*"`
- 使用 `aws_kms_key` 管理加密密钥，禁止使用默认密钥
 
## 架构规则
- 生产环境必须使用多 AZ 部署
- 使用远程状态存储（S3 + DynamoDB 锁）
- 模块化结构：networking、compute、database、monitoring 分离
- 每个模块包含 `variables.tf`、`outputs.tf`、`main.tf`、`versions.tf`
 
## 命名规则
- 资源命名格式：`{project}-{environment}-{resource-type}-{identifier}`
- 变量命名使用 snake_case
- 模块命名使用 kebab-case

## Terraform 生成规则
 
当生成 Terraform 代码时：
1. 始终使用模块化结构（networking/compute/database/monitoring 分离）
2. 所有资源添加标准标签（environment, team, cost-center, managed-by）
3. 安全组遵循最小权限，禁止 0.0.0.0/0 入站（ALB 80/443 除外）
4. 数据库启用加密存储和自动备份（≥7 天）
5. S3 启用版本控制、加密和公共访问阻止
6. 使用远程状态存储（S3 + DynamoDB）
7. 变量和输出必须包含 description
8. 敏感变量标记 sensitive = true
9. 优先使用 terraform-aws-modules 官方模块
10. 包含 README.md 说明模块用途和使用方法

请为以下需求生成模块化的 Terraform 配置：

## 需求
一个高可用的 Web 应用基础设施，包含：
- VPC（3 个 AZ，公有/私有子网，NAT Gateway）
- Application Load Balancer（HTTPS，ACM 证书）
- ECS Fargate 服务（自动扩缩容 2-10 实例）
- RDS PostgreSQL 16（Multi-AZ，加密存储，自动备份 14 天）
- ElastiCache Redis 7（集群模式，加密传输）
- S3 存储桶（静态资源 + 日志存储，版本控制）
- CloudWatch 日志组和告警

## 约束
- 云提供商：AWS
- 区域：ap-northeast-1
- 环境：production
- 月度预算：$2000 以内

## 模块结构
modules/
├── networking/    # VPC, 子网, NAT, 安全组
├── compute/       # ECS, ALB, 自动扩缩容
├── database/      # RDS, ElastiCache
├── storage/       # S3
└── monitoring/    # CloudWatch, SNS

## 输出要求
1. 每个模块包含 main.tf, variables.tf, outputs.tf, versions.tf
2. 根目录包含 main.tf（调用模块）, variables.tf, outputs.tf, terraform.tfvars.example
3. 遵循 .kiro/steering/terraform.md 中的所有规则
4. 包含 README.md 说明架构和使用方法

# 安装 Pulumi AI CLI 插件
pulumi ai web
 
# 在浏览器中打开 Pulumi AI 对话界面
# 输入自然语言描述：
# "Create a highly available web application infrastructure on AWS with
#  VPC, ALB, ECS Fargate, RDS PostgreSQL, and ElastiCache Redis.
#  Use TypeScript. Include auto-scaling and encryption."

# 安装 Spacelift Intent CLI
# Intent 直接调用云 API，无需编写 HCL
spacelift intent apply "Create a VPC with 3 availability zones, 
  public and private subnets, and a NAT gateway in ap-northeast-1"

# ============================================================
# Networking Module - VPC, Subnets, NAT Gateway, Security Groups
# ============================================================
 
module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"
 
  name = "${var.project}-${var.environment}-vpc"
  cidr = var.vpc_cidr
 
  azs             = var.availability_zones
  private_subnets = var.private_subnet_cidrs
  public_subnets  = var.public_subnet_cidrs
 
  enable_nat_gateway     = true
  single_nat_gateway     = var.environment != "production"
  one_nat_gateway_per_az = var.environment == "production"
 
  enable_dns_hostnames = true
  enable_dns_support   = true
 
  # 流日志
  enable_flow_log                      = true
  create_flow_log_cloudwatch_log_group = true
  create_flow_log_iam_role             = true
 
  tags = merge(var.common_tags, {
    Module = "networking"
  })
}
 
# ALB 安全组
resource "aws_security_group" "alb" {
  name_prefix = "${var.project}-${var.environment}-alb-"
  description = "Security group for Application Load Balancer"
  vpc_id      = module.vpc.vpc_id
 
  ingress {
    description = "HTTPS from internet"
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  ingress {
    description = "HTTP from internet (redirect to HTTPS)"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  egress {
    description = "All outbound traffic"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  tags = merge(var.common_tags, {
    Name   = "${var.project}-${var.environment}-alb-sg"
    Module = "networking"
  })
 
  lifecycle {
    create_before_destroy = true
  }
}
 
# ECS 任务安全组
resource "aws_security_group" "ecs_tasks" {
  name_prefix = "${var.project}-${var.environment}-ecs-"
  description = "Security group for ECS tasks"
  vpc_id      = module.vpc.vpc_id
 
  ingress {
    description     = "Traffic from ALB only"
    from_port       = var.app_port
    to_port         = var.app_port
    protocol        = "tcp"
    security_groups = [aws_security_group.alb.id]
  }
 
  egress {
    description = "All outbound traffic"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  tags = merge(var.common_tags, {
    Name   = "${var.project}-${var.environment}-ecs-sg"
    Module = "networking"
  })
 
  lifecycle {
    create_before_destroy = true
  }
}
 
# 数据库安全组
resource "aws_security_group" "database" {
  name_prefix = "${var.project}-${var.environment}-db-"
  description = "Security group for RDS database"
  vpc_id      = module.vpc.vpc_id
 
  ingress {
    description     = "PostgreSQL from ECS tasks only"
    from_port       = 5432
    to_port         = 5432
    protocol        = "tcp"
    security_groups = [aws_security_group.ecs_tasks.id]
  }
 
  # 注意：没有 egress 规则 = 没有出站流量（数据库不需要）
  # 如需出站，请明确指定目标
 
  tags = merge(var.common_tags, {
    Name   = "${var.project}-${var.environment}-db-sg"
    Module = "networking"
  })
 
  lifecycle {
    create_before_destroy = true
  }
}

variable "project" {
  description = "项目名称，用于资源命名前缀"
  type        = string
}
 
variable "environment" {
  description = "部署环境（dev/staging/production）"
  type        = string
  validation {
    condition     = contains(["dev", "staging", "production"], var.environment)
    error_message = "environment 必须是 dev、staging 或 production 之一"
  }
}
 
variable "vpc_cidr" {
  description = "VPC CIDR 块"
  type        = string
  default     = "10.0.0.0/16"
}
 
variable "availability_zones" {
  description = "可用区列表"
  type        = list(string)
  default     = ["ap-northeast-1a", "ap-northeast-1c", "ap-northeast-1d"]
}
 
variable "private_subnet_cidrs" {
  description = "私有子网 CIDR 列表"
  type        = list(string)
  default     = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
}
 
variable "public_subnet_cidrs" {
  description = "公有子网 CIDR 列表"
  type        = list(string)
  default     = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
}
 
variable "app_port" {
  description = "应用程序端口"
  type        = number
  default     = 3000
}
 
variable "common_tags" {
  description = "应用于所有资源的通用标签"
  type        = map(string)
  default     = {}
}

请生成 Terraform 远程状态存储的引导配置（bootstrap），包含：
1. S3 存储桶（加密、版本控制、阻止公共访问、生命周期策略）
2. DynamoDB 表（状态锁定）
3. IAM 策略（最小权限访问状态存储）
4. backend 配置示例

要求：
- 存储桶名称包含账户 ID 以确保全局唯一
- 启用 S3 存储桶日志记录
- DynamoDB 使用按需计费模式
- 包含防止意外删除的保护措施

# backend-bootstrap/main.tf
# 用于初始化 Terraform 远程状态存储的引导配置
 
terraform {
  required_version = ">= 1.9"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}
 
data "aws_caller_identity" "current" {}
data "aws_region" "current" {}
 
locals {
  bucket_name = "${var.project}-${data.aws_caller_identity.current.account_id}-tfstate"
  table_name  = "${var.project}-tfstate-lock"
}
 
# 状态存储桶
resource "aws_s3_bucket" "tfstate" {
  bucket = local.bucket_name
 
  # 防止意外删除
  lifecycle {
    prevent_destroy = true
  }
 
  tags = {
    Name        = local.bucket_name
    Purpose     = "terraform-state"
    Environment = "shared"
    ManagedBy   = "terraform-bootstrap"
  }
}
 
resource "aws_s3_bucket_versioning" "tfstate" {
  bucket = aws_s3_bucket.tfstate.id
  versioning_configuration {
    status = "Enabled"
  }
}
 
resource "aws_s3_bucket_server_side_encryption_configuration" "tfstate" {
  bucket = aws_s3_bucket.tfstate.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "aws:kms"
    }
    bucket_key_enabled = true
  }
}
 
resource "aws_s3_bucket_public_access_block" "tfstate" {
  bucket                  = aws_s3_bucket.tfstate.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}
 
# 状态锁定表
resource "aws_dynamodb_table" "tfstate_lock" {
  name         = local.table_name
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"
 
  attribute {
    name = "LockID"
    type = "S"
  }
 
  point_in_time_recovery {
    enabled = true
  }
 
  tags = {
    Name        = local.table_name
    Purpose     = "terraform-state-lock"
    Environment = "shared"
    ManagedBy   = "terraform-bootstrap"
  }
}

Terraform plan 检测到以下配置漂移：

[粘贴 terraform plan 输出]

请分析：
1. 漂移的根本原因是什么？（手动修改？自动扩缩容？AWS 服务更新？）
2. 是否需要修复？还是应该将当前状态导入 Terraform？
3. 如果需要修复，请提供修复方案
4. 如何防止此类漂移再次发生？

我有以下 Terraform 模块：
- modules/networking（VPC、子网、安全组）
- modules/compute（ECS Fargate）
- modules/database（RDS PostgreSQL）

请生成根模块（root module）的 main.tf，实现：
1. 模块间的依赖关系正确传递（networking → compute, networking → database）
2. 支持多环境部署（dev/staging/production）
3. 使用 terraform.tfvars 文件管理环境差异
4. 包含条件逻辑（如 dev 环境不需要 Multi-AZ）

# main.tf - 根模块，组合所有子模块
 
terraform {
  required_version = ">= 1.9"
 
  backend "s3" {
    bucket         = "myproject-123456789012-tfstate"
    key            = "infrastructure/terraform.tfstate"
    region         = "ap-northeast-1"
    dynamodb_table = "myproject-tfstate-lock"
    encrypt        = true
  }
 
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}
 
provider "aws" {
  region = var.aws_region
 
  default_tags {
    tags = {
      Project     = var.project
      Environment = var.environment
      ManagedBy   = "terraform"
      CostCenter  = var.cost_center
      Team        = var.team
    }
  }
}
 
# ============================================================
# Networking Module
# ============================================================
module "networking" {
  source = "./modules/networking"
 
  project              = var.project
  environment          = var.environment
  vpc_cidr             = var.vpc_cidr
  availability_zones   = var.availability_zones
  private_subnet_cidrs = var.private_subnet_cidrs
  public_subnet_cidrs  = var.public_subnet_cidrs
  app_port             = var.app_port
 
  common_tags = local.common_tags
}
 
# ============================================================
# Database Module
# ============================================================
module "database" {
  source = "./modules/database"
 
  project     = var.project
  environment = var.environment
 
  vpc_id              = module.networking.vpc_id
  private_subnet_ids  = module.networking.private_subnet_ids
  database_sg_id      = module.networking.database_sg_id
 
  # 环境差异化配置
  instance_class       = var.db_instance_class
  multi_az             = var.environment == "production"
  backup_retention     = var.environment == "production" ? 14 : 7
  deletion_protection  = var.environment == "production"
 
  common_tags = local.common_tags
}
 
# ============================================================
# Compute Module
# ============================================================
module "compute" {
  source = "./modules/compute"
 
  project     = var.project
  environment = var.environment
 
  vpc_id             = module.networking.vpc_id
  private_subnet_ids = module.networking.private_subnet_ids
  public_subnet_ids  = module.networking.public_subnet_ids
  alb_sg_id          = module.networking.alb_sg_id
  ecs_sg_id          = module.networking.ecs_sg_id
 
  # 应用配置
  app_port       = var.app_port
  app_image      = var.app_image
  desired_count  = var.ecs_desired_count
  min_capacity   = var.ecs_min_capacity
  max_capacity   = var.ecs_max_capacity
 
  # 数据库连接信息
  database_endpoint = module.database.endpoint
  database_name     = module.database.database_name
 
  common_tags = local.common_tags
}
 
# ============================================================
# Locals
# ============================================================
locals {
  common_tags = {
    Project     = var.project
    Environment = var.environment
    Team        = var.team
    CostCenter  = var.cost_center
  }
}

# Production 环境配置
project     = "myapp"
environment = "production"
aws_region  = "ap-northeast-1"
team        = "platform"
cost_center = "eng-001"
 
# Networking
vpc_cidr             = "10.0.0.0/16"
availability_zones   = ["ap-northeast-1a", "ap-northeast-1c", "ap-northeast-1d"]
private_subnet_cidrs = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
public_subnet_cidrs  = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
 
# Compute
app_port          = 3000
ecs_desired_count = 3
ecs_min_capacity  = 2
ecs_max_capacity  = 10
 
# Database
db_instance_class = "db.r6g.large"

Create a highly available web application on AWS using TypeScript:
- VPC with 3 AZs, public and private subnets
- Application Load Balancer with HTTPS
- ECS Fargate service with auto-scaling (2-10 tasks)
- RDS PostgreSQL with Multi-AZ and encryption
- S3 bucket for static assets
- CloudWatch alarms for CPU and memory

# 在项目中添加 Pulumi Agent Skills
# 参考 https://github.com/pulumi/pulumi-agent-skills

// index.ts - Pulumi AWS 基础设施
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as awsx from "@pulumi/awsx";
 
// ============================================================
// 配置
// ============================================================
const config = new pulumi.Config();
const project = config.require("project");
const environment = config.require("environment");
const dbPassword = config.requireSecret("dbPassword");
 
const commonTags = {
  Project: project,
  Environment: environment,
  ManagedBy: "pulumi",
};
 
// ============================================================
// VPC
// ============================================================
const vpc = new awsx.ec2.Vpc(`${project}-vpc`, {
  cidrBlock: "10.0.0.0/16",
  numberOfAvailabilityZones: 3,
  natGateways: {
    strategy: environment === "production"
      ? awsx.ec2.NatGatewayStrategy.OnePerAz
      : awsx.ec2.NatGatewayStrategy.Single,
  },
  enableDnsHostnames: true,
  enableDnsSupport: true,
  tags: { ...commonTags, Name: `${project}-${environment}-vpc` },
});
 
// ============================================================
// 安全组
// ============================================================
const albSg = new aws.ec2.SecurityGroup(`${project}-alb-sg`, {
  vpcId: vpc.vpcId,
  description: "Security group for ALB",
  ingress: [
    { protocol: "tcp", fromPort: 443, toPort: 443, cidrBlocks: ["0.0.0.0/0"], description: "HTTPS" },
    { protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"], description: "HTTP redirect" },
  ],
  egress: [
    { protocol: "-1", fromPort: 0, toPort: 0, cidrBlocks: ["0.0.0.0/0"], description: "All outbound" },
  ],
  tags: { ...commonTags, Name: `${project}-${environment}-alb-sg` },
});
 
const ecsSg = new aws.ec2.SecurityGroup(`${project}-ecs-sg`, {
  vpcId: vpc.vpcId,
  description: "Security group for ECS tasks",
  ingress: [
    {
      protocol: "tcp",
      fromPort: 3000,
      toPort: 3000,
      securityGroups: [albSg.id],
      description: "Traffic from ALB",
    },
  ],
  egress: [
    { protocol: "-1", fromPort: 0, toPort: 0, cidrBlocks: ["0.0.0.0/0"], description: "All outbound" },
  ],
  tags: { ...commonTags, Name: `${project}-${environment}-ecs-sg` },
});
 
const dbSg = new aws.ec2.SecurityGroup(`${project}-db-sg`, {
  vpcId: vpc.vpcId,
  description: "Security group for RDS",
  ingress: [
    {
      protocol: "tcp",
      fromPort: 5432,
      toPort: 5432,
      securityGroups: [ecsSg.id],
      description: "PostgreSQL from ECS",
    },
  ],
  tags: { ...commonTags, Name: `${project}-${environment}-db-sg` },
});
 
// ============================================================
// RDS PostgreSQL
// ============================================================
const dbSubnetGroup = new aws.rds.SubnetGroup(`${project}-db-subnet`, {
  subnetIds: vpc.privateSubnetIds,
  tags: commonTags,
});
 
const db = new aws.rds.Instance(`${project}-db`, {
  engine: "postgres",
  engineVersion: "16.4",
  instanceClass: environment === "production" ? "db.r6g.large" : "db.t4g.medium",
  allocatedStorage: 50,
  maxAllocatedStorage: 200,
  dbName: project.replace(/-/g, "_"),
  username: "app_admin",
  password: dbPassword,
  dbSubnetGroupName: dbSubnetGroup.name,
  vpcSecurityGroupIds: [dbSg.id],
  multiAz: environment === "production",
  storageEncrypted: true,
  backupRetentionPeriod: environment === "production" ? 14 : 7,
  deletionProtection: environment === "production",
  skipFinalSnapshot: environment !== "production",
  performanceInsightsEnabled: true,
  tags: { ...commonTags, Name: `${project}-${environment}-db` },
});
 
// ============================================================
// ECS Fargate + ALB
// ============================================================
const cluster = new aws.ecs.Cluster(`${project}-cluster`, {
  settings: [{ name: "containerInsights", value: "enabled" }],
  tags: commonTags,
});
 
const alb = new awsx.lb.ApplicationLoadBalancer(`${project}-alb`, {
  subnetIds: vpc.publicSubnetIds,
  securityGroups: [albSg.id],
  tags: commonTags,
});
 
const service = new awsx.ecs.FargateService(`${project}-service`, {
  cluster: cluster.arn,
  networkConfiguration: {
    subnets: vpc.privateSubnetIds,
    securityGroups: [ecsSg.id],
  },
  desiredCount: environment === "production" ? 3 : 1,
  taskDefinitionArgs: {
    container: {
      name: `${project}-app`,
      image: config.require("appImage"),
      cpu: 512,
      memory: 1024,
      essential: true,
      portMappings: [{ containerPort: 3000, targetGroup: alb.defaultTargetGroup }],
      environment: [
        { name: "NODE_ENV", value: environment },
        { name: "DATABASE_HOST", value: db.address },
        { name: "DATABASE_NAME", value: db.dbName },
      ],
      secrets: [
        { name: "DATABASE_PASSWORD", valueFrom: dbPassword.apply(p => p) },
      ],
      logConfiguration: {
        logDriver: "awslogs",
        options: {
          "awslogs-group": `/ecs/${project}-${environment}`,
          "awslogs-region": aws.config.region!,
          "awslogs-stream-prefix": "app",
        },
      },
      healthCheck: {
        command: ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
        interval: 30,
        timeout: 5,
        retries: 3,
        startPeriod: 60,
      },
    },
  },
  tags: commonTags,
});
 
// ============================================================
// Auto Scaling
// ============================================================
const scalingTarget = new aws.appautoscaling.Target(`${project}-scaling-target`, {
  maxCapacity: 10,
  minCapacity: environment === "production" ? 2 : 1,
  resourceId: pulumi.interpolate`service/${cluster.name}/${service.service.name}`,
  scalableDimension: "ecs:service:DesiredCount",
  serviceNamespace: "ecs",
});
 
new aws.appautoscaling.Policy(`${project}-cpu-scaling`, {
  policyType: "TargetTrackingScaling",
  resourceId: scalingTarget.resourceId,
  scalableDimension: scalingTarget.scalableDimension,
  serviceNamespace: scalingTarget.serviceNamespace,
  targetTrackingScalingPolicyConfiguration: {
    predefinedMetricSpecification: {
      predefinedMetricType: "ECSServiceAverageCPUUtilization",
    },
    targetValue: 70,
    scaleInCooldown: 300,
    scaleOutCooldown: 60,
  },
});
 
// ============================================================
// 输出
// ============================================================
export const vpcId = vpc.vpcId;
export const albDnsName = alb.loadBalancer.dnsName;
export const dbEndpoint = db.endpoint;
export const ecsClusterName = cluster.name;

请使用 AWS CDK v2 (TypeScript) 生成以下基础设施：

## 需求
高可用 Web 应用架构：
- VPC（3 AZ，公有/私有子网，NAT Gateway）
- Application Load Balancer（HTTPS，ACM 证书）
- ECS Fargate 服务（自动扩缩容）
- RDS PostgreSQL（Multi-AZ，加密）
- S3 存储桶（静态资源）

## 约束
- 使用 CDK L2/L3 构造（高级抽象）
- 遵循 AWS Well-Architected Framework
- 包含 CDK Nag 安全检查
- 使用 Stack 分离（NetworkStack, DatabaseStack, ComputeStack）

// lib/network-stack.ts
import * as cdk from "aws-cdk-lib";
import * as ec2 from "aws-cdk-lib/aws-ec2";
import { Construct } from "constructs";
 
export interface NetworkStackProps extends cdk.StackProps {
  project: string;
  environment: string;
}
 
export class NetworkStack extends cdk.Stack {
  public readonly vpc: ec2.Vpc;
  public readonly albSecurityGroup: ec2.SecurityGroup;
  public readonly ecsSecurityGroup: ec2.SecurityGroup;
  public readonly dbSecurityGroup: ec2.SecurityGroup;
 
  constructor(scope: Construct, id: string, props: NetworkStackProps) {
    super(scope, id, props);
 
    // VPC - 3 AZ，公有/私有子网
    this.vpc = new ec2.Vpc(this, "Vpc", {
      vpcName: `${props.project}-${props.environment}-vpc`,
      maxAzs: 3,
      natGateways: props.environment === "production" ? 3 : 1,
      subnetConfiguration: [
        {
          cidrMask: 24,
          name: "Public",
          subnetType: ec2.SubnetType.PUBLIC,
        },
        {
          cidrMask: 24,
          name: "Private",
          subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
        },
        {
          cidrMask: 24,
          name: "Isolated",
          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
        },
      ],
      flowLogs: {
        default: {
          destination: ec2.FlowLogDestination.toCloudWatchLogs(),
          trafficType: ec2.FlowLogTrafficType.REJECT,
        },
      },
    });
 
    // ALB 安全组
    this.albSecurityGroup = new ec2.SecurityGroup(this, "AlbSg", {
      vpc: this.vpc,
      description: "Security group for ALB",
      allowAllOutbound: true,
    });
    this.albSecurityGroup.addIngressRule(
      ec2.Peer.anyIpv4(),
      ec2.Port.tcp(443),
      "HTTPS from internet"
    );
    this.albSecurityGroup.addIngressRule(
      ec2.Peer.anyIpv4(),
      ec2.Port.tcp(80),
      "HTTP redirect"
    );
 
    // ECS 安全组 - 仅允许来自 ALB 的流量
    this.ecsSecurityGroup = new ec2.SecurityGroup(this, "EcsSg", {
      vpc: this.vpc,
      description: "Security group for ECS tasks",
      allowAllOutbound: true,
    });
    this.ecsSecurityGroup.addIngressRule(
      this.albSecurityGroup,
      ec2.Port.tcp(3000),
      "Traffic from ALB"
    );
 
    // 数据库安全组 - 仅允许来自 ECS 的流量
    this.dbSecurityGroup = new ec2.SecurityGroup(this, "DbSg", {
      vpc: this.vpc,
      description: "Security group for RDS",
      allowAllOutbound: false,
    });
    this.dbSecurityGroup.addIngressRule(
      this.ecsSecurityGroup,
      ec2.Port.tcp(5432),
      "PostgreSQL from ECS"
    );
  }
}

// lib/database-stack.ts
import * as cdk from "aws-cdk-lib";
import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as rds from "aws-cdk-lib/aws-rds";
import { Construct } from "constructs";
 
export interface DatabaseStackProps extends cdk.StackProps {
  project: string;
  environment: string;
  vpc: ec2.Vpc;
  securityGroup: ec2.SecurityGroup;
}
 
export class DatabaseStack extends cdk.Stack {
  public readonly instance: rds.DatabaseInstance;
 
  constructor(scope: Construct, id: string, props: DatabaseStackProps) {
    super(scope, id, props);
 
    this.instance = new rds.DatabaseInstance(this, "Database", {
      engine: rds.DatabaseInstanceEngine.postgres({
        version: rds.PostgresEngineVersion.VER_16_4,
      }),
      instanceType: props.environment === "production"
        ? ec2.InstanceType.of(ec2.InstanceClass.R6G, ec2.InstanceSize.LARGE)
        : ec2.InstanceType.of(ec2.InstanceClass.T4G, ec2.InstanceSize.MEDIUM),
      vpc: props.vpc,
      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
      securityGroups: [props.securityGroup],
      multiAz: props.environment === "production",
      storageEncrypted: true,
      backupRetention: cdk.Duration.days(
        props.environment === "production" ? 14 : 7
      ),
      deletionProtection: props.environment === "production",
      removalPolicy: props.environment === "production"
        ? cdk.RemovalPolicy.RETAIN
        : cdk.RemovalPolicy.DESTROY,
      enablePerformanceInsights: true,
      allocatedStorage: 50,
      maxAllocatedStorage: 200,
      databaseName: props.project.replace(/-/g, "_"),
      credentials: rds.Credentials.fromGeneratedSecret("app_admin", {
        secretName: `${props.project}/${props.environment}/db-credentials`,
      }),
    });
  }
}

// bin/app.ts - CDK 应用入口
import * as cdk from "aws-cdk-lib";
import { NetworkStack } from "../lib/network-stack";
import { DatabaseStack } from "../lib/database-stack";
// import { ComputeStack } from "../lib/compute-stack";
 
const app = new cdk.App();
 
const project = app.node.tryGetContext("project") || "myapp";
const environment = app.node.tryGetContext("environment") || "dev";
 
const env = {
  account: process.env.CDK_DEFAULT_ACCOUNT,
  region: process.env.CDK_DEFAULT_REGION || "ap-northeast-1",
};
 
const networkStack = new NetworkStack(app, `${project}-${environment}-network`, {
  project,
  environment,
  env,
});
 
const databaseStack = new DatabaseStack(app, `${project}-${environment}-database`, {
  project,
  environment,
  vpc: networkStack.vpc,
  securityGroup: networkStack.dbSecurityGroup,
  env,
});
 
// const computeStack = new ComputeStack(app, `${project}-${environment}-compute`, {
//   project,
//   environment,
//   vpc: networkStack.vpc,
//   albSecurityGroup: networkStack.albSecurityGroup,
//   ecsSecurityGroup: networkStack.ecsSecurityGroup,
//   database: databaseStack.instance,
//   env,
// });

// bin/app.ts 中添加 CDK Nag
import { Aspects } from "aws-cdk-lib";
import { AwsSolutionsChecks } from "cdk-nag";
 
// 在 app 级别添加安全检查
Aspects.of(app).add(new AwsSolutionsChecks({ verbose: true }));

CDK Nag 报告了以下安全警告：

[粘贴 CDK Nag 输出]

请分析每个警告并提供修复方案：
1. 哪些是必须修复的安全问题？
2. 哪些可以通过 NagSuppressions 安全地抑制？
3. 请提供修复代码

你是一位资深云架构师和 DevOps 工程师。请为以下需求设计并生成 [Terraform/Pulumi/CDK] 基础设施配置：

## 应用信息
- 应用类型：[Web 应用/API 服务/数据管线/ML 平台]
- 技术栈：[例如 Next.js + Node.js + PostgreSQL]
- 预期流量：[例如 1000 QPS 峰值]
- 数据量：[例如 100GB 初始，每月增长 10GB]

## 基础设施需求
[详细描述所需的基础设施组件]

## 非功能需求
- 可用性目标：[例如 99.9%]
- RPO/RTO：[例如 RPO 1小时, RTO 4小时]
- 合规要求：[例如 SOC 2, GDPR]
- 月度预算：[例如 $3000]

## 安全要求
- [列出具体安全要求]

## 输出要求
1. 模块化结构，每个模块职责单一
2. 支持多环境部署（dev/staging/production）
3. 包含安全最佳实践（加密、最小权限、网络隔离）
4. 包含监控和告警配置
5. 包含成本标签
6. 包含 README 文档

请审查以下 [Terraform/Pulumi/CDK] 代码的安全性：

[粘贴 IaC 代码]

请检查以下方面并提供修复建议：
1. 网络安全：安全组规则是否过于宽松？
2. 数据加密：存储和传输是否加密？
3. 访问控制：IAM 权限是否遵循最小权限？
4. 密钥管理：是否有硬编码的密钥或密码？
5. 日志审计：是否启用必要的日志记录？
6. 备份恢复：是否配置了备份和恢复策略？
7. 合规性：是否符合 [SOC 2/GDPR/HIPAA] 要求？

对每个发现的问题，请提供：
- 风险等级（高/中/低）
- 问题描述
- 修复代码

请分析以下 [Terraform/Pulumi/CDK] 配置并提供优化建议：

[粘贴 IaC 代码]

请从以下维度进行优化：
1. 成本优化：是否有过度配置的资源？推荐更经济的替代方案
2. 性能优化：是否有性能瓶颈？推荐优化措施
3. 可靠性：是否有单点故障？推荐高可用改进
4. 安全性：是否有安全漏洞？推荐加固措施
5. 可维护性：代码结构是否清晰？推荐重构方案
6. 可扩展性：是否支持未来扩展？推荐改进方案

对每个优化建议，请提供：
- 优先级（P0/P1/P2）
- 预期收益
- 实施难度
- 修改后的代码

请为以下基础设施生成多环境配置：

## 基础模块
[描述或粘贴基础 IaC 模块]

## 环境要求

### Development
- 最小化成本（单 AZ，最小实例）
- 可以使用 Spot 实例
- 无需高可用
- 数据可以不加密（非生产数据）

### Staging
- 模拟生产环境（但规模缩小）
- 多 AZ 部署
- 数据加密
- 自动关停（非工作时间）

### Production
- 完整高可用（多 AZ）
- 自动扩缩容
- 全面加密和安全加固
- 完整监控和告警
- 备份和灾备

请生成：
1. 共享的模块代码（参数化）
2. 每个环境的变量文件
3. 环境间的差异说明

Terraform apply 失败，错误信息如下：

[粘贴完整错误信息]

相关的 Terraform 配置：

[粘贴相关代码]

请分析：
1. 错误的根本原因是什么？
2. 是配置问题还是 AWS 服务限制？
3. 请提供具体的修复步骤
4. 如何防止此类错误再次发生？

请帮我将以下 [CloudFormation/手动配置/Terraform] 迁移到 [Pulumi TypeScript/CDK TypeScript/Terraform]：

## 源配置
[粘贴源配置或描述现有基础设施]

## 迁移要求
1. 保持功能等价（不改变基础设施行为）
2. 改进安全配置（如果源配置有安全问题）
3. 添加缺失的最佳实践（标签、加密、日志）
4. 模块化重构
5. 生成迁移计划（步骤和风险评估）

## 约束
- 零停机迁移
- 保留现有资源（import 而非重建）

请生成 [Terraform/Pulumi/CDK] 的 Serverless 架构配置：

## 架构
- API Gateway (REST/HTTP API)
- Lambda 函数（[语言]）
- DynamoDB 表
- S3 存储桶（文件上传）
- SQS 队列（异步处理）
- CloudWatch 日志和告警

## 要求
1. Lambda 使用 ARM64 架构（Graviton2，成本更低）
2. API Gateway 配置 WAF 和速率限制
3. DynamoDB 使用按需计费模式
4. 所有 Lambda 函数配置死信队列
5. 包含 X-Ray 追踪
6. 包含 CloudWatch 仪表板

请生成 [Terraform/Pulumi/CDK] 的数据库基础设施配置：

## 数据库需求
- 类型：[RDS PostgreSQL/Aurora/DynamoDB/ElastiCache Redis]
- 预期数据量：[大小]
- 读写比例：[例如 80% 读 20% 写]
- 延迟要求：[例如 P99 < 10ms]

## 高可用要求
- Multi-AZ：[是/否]
- 读副本：[数量]
- 自动故障转移：[是/否]

## 安全要求
- 加密存储：是
- 加密传输：是
- 密钥管理：[KMS/Secrets Manager]
- 网络隔离：私有子网 + 安全组

## 备份要求
- 自动备份保留期：[天数]
- 时间点恢复：[是/否]
- 跨区域备份：[是/否]

请生成 [Terraform/Pulumi/CDK] 的企业级网络架构配置：

## 网络需求
- VPC 数量：[例如 3 个：production, staging, shared-services]
- VPC Peering / Transit Gateway：[选择]
- VPN / Direct Connect：[是否需要]
- 公网访问：[哪些服务需要]

## 安全需求
- 网络 ACL 规则
- 安全组策略
- VPC 流日志
- DNS 解析（Route 53 私有托管区）

## 合规需求
- 数据不出境：[是/否]
- PCI DSS 网络分段：[是/否]

┌─────────────────────────────────────────────────────────────┐
│              AI 辅助 IaC 审查工作流                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  开发者提交 PR                                               │
│       │                                                     │
│       ▼                                                     │
│  ┌──────────────────────────────────────────────┐           │
│  │            自动化审查管线                      │           │
│  │                                              │           │
│  │  ① terraform fmt    → 格式检查               │           │
│  │  ② terraform validate → 语法验证             │           │
│  │  ③ Checkov/tfsec    → 安全扫描               │           │
│  │  ④ Infracost        → 成本估算               │           │
│  │  ⑤ AI 代码审查      → 最佳实践检查            │           │
│  │  ⑥ terraform plan   → 变更预览               │           │
│  └──────────────────────────────────────────────┘           │
│       │                                                     │
│       ▼                                                     │
│  PR 评论汇总（安全发现 + 成本影响 + AI 建议）                  │
│       │                                                     │
│       ▼                                                     │
│  人工审查 → 批准/请求修改                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

请审查以下 Terraform PR 变更：

## 变更摘要
[描述变更目的]

## 变更内容
```diff
[粘贴 git diff 输出]

---

## 7. IaC 安全扫描集成

### 7.1 安全扫描工具对比

| 工具 | 类型 | 支持的 IaC | 价格 | AI 增强 | 适用场景 |
|------|------|-----------|------|---------|---------|
| **Checkov** | 开源静态分析 | Terraform, CloudFormation, K8s, Pulumi, CDK | 开源免费；Prisma Cloud 集成需付费 | 否（规则驱动） | 全面的 IaC 安全扫描 |
| **tfsec** | 开源静态分析 | Terraform | 开源免费（已合并入 Trivy） | 否 | Terraform 专用安全扫描 |
| **Trivy** | 开源多功能扫描 | Terraform, CloudFormation, K8s, Docker | 开源免费 | 否 | 统一的安全扫描（IaC + 容器 + 依赖） |
| **Snyk IaC** | 商业安全平台 | Terraform, CloudFormation, K8s, ARM | 免费版可用；Team $25/月/开发者 | 是（AI 修复建议） | 开发者友好的安全扫描 |
| **Snyk MCP** | MCP 集成安全扫描 | 代码 + IaC + 依赖 | Snyk 订阅内含 | 是（AI 编码助手集成） | AI 编码助手内实时安全扫描 |
| **KICS** | 开源静态分析 | Terraform, CloudFormation, K8s, Ansible, Docker | 开源免费 | 否 | 多 IaC 框架支持 |
| **OPA/Conftest** | 策略即代码引擎 | 任意 JSON/YAML/HCL | 开源免费 | 否 | 自定义策略检查 |

### 7.2 操作步骤

#### 步骤 1：Checkov 集成

```bash
# 安装 Checkov
pip install checkov

# 扫描 Terraform 目录
checkov -d ./terraform/ --framework terraform

# 扫描并输出 SARIF 格式（用于 GitHub Security）
checkov -d ./terraform/ -o sarif > results.sarif

# 仅检查高严重性问题
checkov -d ./terraform/ --check HIGH --check CRITICAL

# 跳过特定检查（需要在代码中注释说明原因）
# 在 .tf 文件中添加：
# checkov:skip=CKV_AWS_18:S3 access logging not needed for this bucket

# .github/workflows/iac-security.yml
name: IaC Security Scan
 
on:
  pull_request:
    paths:
      - 'terraform/**'
      - 'infrastructure/**'
 
jobs:
  checkov:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Run Checkov
        uses: bridgecrewio/checkov-action@v12
        with:
          directory: terraform/
          framework: terraform
          output_format: sarif
          output_file_path: results.sarif
          soft_fail: false  # PR 失败如果发现高危问题
 
      - name: Upload SARIF
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: results.sarif

# 安装 Snyk CLI
npm install -g snyk
 
# 认证
snyk auth
 
# 扫描 Terraform 代码
snyk iac test ./terraform/
 
# 扫描并生成 JSON 报告
snyk iac test ./terraform/ --json > snyk-results.json
 
# 监控（持续扫描）
snyk iac monitor ./terraform/

{
  "mcpServers": {
    "snyk": {
      "command": "npx",
      "args": ["-y", "@snyk/mcp-server"]
    }
  }
}

# 安装 Trivy（包含原 tfsec 功能）
# macOS
brew install trivy
 
# 扫描 Terraform 配置
trivy config ./terraform/
 
# 仅显示高危和严重问题
trivy config ./terraform/ --severity HIGH,CRITICAL
 
# 输出 JSON 格式
trivy config ./terraform/ -f json -o trivy-results.json

安全扫描工具 [Checkov/Snyk/Trivy] 在我的 Terraform 代码中发现以下问题：

[粘贴扫描结果]

相关的 Terraform 代码：

[粘贴相关代码]

请为每个发现提供：
1. 风险说明（为什么这是安全问题）
2. 修复代码
3. 是否可以安全地抑制此检查（如果是，说明原因）
4. 预防措施（如何在 Steering 规则中避免此类问题）

# 安装 Infracost
# macOS
brew install infracost
 
# Linux
curl -fsSL https://raw.githubusercontent.com/infracost/infracost/master/scripts/install.sh | sh
 
# 注册并获取 API Key
infracost auth login
 
# 验证安装
infracost --version

# 生成 Terraform plan
cd terraform/
terraform init
terraform plan -out=tfplan.binary
terraform show -json tfplan.binary > tfplan.json
 
# 使用 Infracost 估算成本
infracost breakdown --path=tfplan.json
 
# 输出示例：
# Project: myapp-production
#
#  Name                                     Monthly Qty  Unit         Monthly Cost
#
#  aws_instance.web
#  ├─ Instance usage (Linux/UNIX, on-demand, m5.large)
#  │                                                730  hours              $70.08
#  ├─ root_block_device
#  │  └─ Storage (general purpose SSD, gp3)          50  GB                  $4.00
#  ...
#
#  OVERALL TOTAL                                                          $1,234.56

# .github/workflows/infracost.yml
name: Infracost
 
on:
  pull_request:
    paths:
      - 'terraform/**'
 
jobs:
  infracost:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
 
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Infracost
        uses: infracost/actions/setup@v3
        with:
          api-key: ${{ secrets.INFRACOST_API_KEY }}
 
      - name: Generate Infracost diff
        run: |
          infracost diff \
            --path=terraform/ \
            --format=json \
            --out-file=/tmp/infracost.json
 
      - name: Post PR comment
        uses: infracost/actions/comment@v1
        with:
          path: /tmp/infracost.json
          behavior: update

Infracost 估算我的基础设施月度成本为 $[金额]，超出预算 $[预算]。

成本明细：
[粘贴 Infracost breakdown 输出]

请提供成本优化建议：
1. 哪些资源可以降级而不影响性能？
2. 是否可以使用 Reserved Instances 或 Savings Plans？
3. 是否有可以使用 Spot 实例的工作负载？
4. 是否有闲置或过度配置的资源？
5. 是否可以通过架构调整降低成本？

对每个建议，请提供：
- 预估节省金额
- 实施风险
- 修改后的 Terraform 代码

---
inclusion: auto
globs: ["**/*.tf", "**/*.tfvars", "**/*.ts", "**/*.py", "**/cdk.json", "**/Pulumi.yaml"]
---
 
# IaC Steering 规则（完整版）
 
## 通用规则
- 所有 IaC 代码必须模块化，每个模块职责单一
- 所有资源必须包含标准标签：environment, team, cost-center, managed-by, project
- 变量必须包含 description 和 type，敏感变量标记为 sensitive
- 输出必须包含 description
- 使用远程状态存储，禁止本地状态文件
- Provider 和 module 版本必须锁定（使用 ~> 约束）
 
## 安全规则（最高优先级）
- 安全组入站规则禁止 0.0.0.0/0（ALB/NLB 的 80/443 除外）
- IAM 策略禁止 "Action": "*" 或 "Resource": "*"
- 所有存储（S3/EBS/RDS/DynamoDB）必须启用加密
- S3 存储桶必须阻止公共访问
- RDS 必须启用加密存储和自动备份（≥7 天）
- 密钥通过 Secrets Manager 或 SSM Parameter Store 管理，禁止硬编码
- 所有外部通信使用 TLS 1.2+
- 数据库部署在私有子网，禁止公网访问
- 启用 VPC 流日志和 CloudTrail
 
## 架构规则
- 生产环境必须多 AZ 部署
- 有状态服务（RDS/ElastiCache）必须配置自动故障转移
- 无状态服务必须配置自动扩缩容
- 使用 NAT Gateway 而非 NAT Instance
- 生产环境每个 AZ 一个 NAT Gateway
 
## 成本规则
- 所有资源必须包含 cost-center 标签
- 开发环境使用最小实例类型
- 开发环境配置自动关停（非工作时间）
- 优先使用按需计费模式（DynamoDB、Lambda）
- 生产环境评估 Reserved Instances / Savings Plans
 
## 命名规则
- 资源命名格式：{project}-{environment}-{resource-type}-{identifier}
- 变量使用 snake_case
- 模块使用 kebab-case
- 标签键使用 kebab-case
 
## Terraform 专用规则
- 使用 terraform-aws-modules 官方模块优先
- 使用 terraform fmt 格式化代码
- 使用 terraform validate 验证语法
- 使用 Checkov 或 tfsec 进行安全扫描
- 使用 Infracost 进行成本估算
 
## CDK 专用规则
- 使用 L2/L3 构造优先于 L1（CfnXxx）
- 集成 CDK Nag 进行安全检查
- 使用 Stack 分离不同关注点
- 使用 CDK Context 管理环境差异
 
## Pulumi 专用规则
- 使用 ComponentResource 封装可复用组件
- 使用 Pulumi Config 管理配置和密钥
- 使用 Pulumi ESC 管理多环境密钥
- 启用 Pulumi Policy Pack 进行合规检查

## IaC 生成规则
 
当生成基础设施代码时，必须遵循以下规则：
 
### 安全（不可协商）
1. 安全组禁止 0.0.0.0/0 入站（ALB 80/443 除外）
2. IAM 遵循最小权限，禁止 * 通配符
3. 所有存储加密（S3/EBS/RDS）
4. 密钥通过 Secrets Manager 管理，禁止硬编码
5. 数据库部署在私有子网
 
### 架构
1. 生产环境多 AZ 部署
2. 模块化结构（networking/compute/database/monitoring）
3. 支持多环境（dev/staging/production）
4. 配置自动扩缩容和健康检查
 
### 成本
1. 所有资源包含 cost-center 标签
2. 开发环境使用最小实例
3. 使用 Infracost 估算成本
 
### 质量
1. 变量和输出包含 description
2. 代码格式化（terraform fmt）
3. 安全扫描通过（Checkov/tfsec）
4. 包含 README 文档

请为以下多云项目生成 Terraform 项目结构：

## 项目结构要求
- 支持 AWS 和 GCP 双云
- 模块化设计（每个云的 networking/compute/database 分离）
- 共享模块（monitoring/alerting）
- 多环境支持（dev/staging/production）
- 远程状态存储（每个云独立状态文件）

## 输出
1. 目录结构
2. 每个模块的 README
3. Makefile（常用命令）
4. CI/CD 工作流（GitHub Actions）

infrastructure/
├── modules/
│   ├── aws/
│   │   ├── networking/     # VPC, 子网, 安全组
│   │   ├── compute/        # ECS Fargate, ALB
│   │   ├── database/       # RDS, ElastiCache
│   │   └── storage/        # S3
│   ├── gcp/
│   │   ├── networking/     # VPC, 子网, 防火墙
│   │   ├── compute/        # GKE
│   │   ├── database/       # Cloud SQL
│   │   └── ai/             # Vertex AI
│   └── shared/
│       ├── monitoring/     # CloudWatch + Cloud Monitoring
│       └── alerting/       # SNS + PagerDuty
├── environments/
│   ├── dev/
│   │   ├── aws/            # AWS dev 配置
│   │   └── gcp/            # GCP dev 配置
│   ├── staging/
│   └── production/
├── .github/workflows/
│   └── terraform.yml       # CI/CD 管线
├── .kiro/steering/
│   └── terraform.md        # IaC Steering 规则
├── Makefile
└── README.md

# 安全扫描
checkov -d ./infrastructure/ --framework terraform
 
# 成本估算
cd infrastructure/environments/production/aws/
terraform init && terraform plan -out=tfplan.binary
terraform show -json tfplan.binary > tfplan.json
infracost breakdown --path=tfplan.json