DEVOCEAN

// lib/stacks/network-stack.ts
export class NetworkStack extends cdk.Stack {
  public readonly vpc: ec2.Vpc;
  
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    this.vpc = new ec2.Vpc(this, 'VisionAIVpc', {
      maxAzs: 2,
      natGateways: 1,
    });
  }
}

// lib/stacks/storage-stack.ts
export class StorageStack extends cdk.Stack {
  public readonly imageBucket: s3.Bucket;
  public readonly modelBucket: s3.Bucket;
  
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    this.imageBucket = new s3.Bucket(this, 'ImageBucket', {
      versioned: true,
      lifecycleRules: [{
        id: 'delete-old-versions',
        noncurrentVersionExpiration: cdk.Duration.days(30),
      }],
    });
    
    this.modelBucket = new s3.Bucket(this, 'ModelBucket', {
      encryption: s3.BucketEncryption.S3_MANAGED,
    });
  }
}

// lib/stacks/api-stack.ts
export class ApiStack extends cdk.Stack {
  constructor(
    scope: Construct, 
    id: string, 
    props: ApiStackProps
  ) {
    super(scope, id, props);
    
    // API Gateway와 Lambda 함수들 정의
  }
}

// config/env-config.ts
export interface EnvConfig {
  account: string;
  region: string;
  vpcCidr: string;
  lambdaMemory: number;
  apiThrottling: {
    rateLimit: number;
    burstLimit: number;
  };
}

export const envConfigs: Record<string, EnvConfig> = {
  dev: {
    account: '123456789012',
    region: 'ap-northeast-2',
    vpcCidr: '10.0.0.0/16',
    lambdaMemory: 1024,
    apiThrottling: {
      rateLimit: 100,
      burstLimit: 200,
    },
  },
  prod: {
    account: '987654321098',
    region: 'ap-northeast-2',
    vpcCidr: '10.1.0.0/16',
    lambdaMemory: 3008,
    apiThrottling: {
      rateLimit: 1000,
      burstLimit: 2000,
    },
  },
};

const aiModelLayer = new lambda.LayerVersion(this, 'AIModelLayer', {
  code: lambda.Code.fromAsset('layers/ai-model'),
  compatibleRuntimes: [lambda.Runtime.PYTHON_3_9],
  description: 'Vision AI model dependencies',
});

const imageProcessor = new lambda.Function(this, 'ImageProcessor', {
  runtime: lambda.Runtime.PYTHON_3_9,
  code: lambda.Code.fromAsset('src/lambdas/image-processor'),
  handler: 'index.handler',
  layers: [aiModelLayer],
  memorySize: props.config.lambdaMemory,
  timeout: cdk.Duration.minutes(5),
  environment: {
    MODEL_BUCKET: props.modelBucket.bucketName,
  },
});

const scalableTarget = imageProcessor.addAlias('live').addAutoScaling({
  minCapacity: 1,
  maxCapacity: 100,
});

scalableTarget.scaleOnUtilization({
  utilizationTarget: 0.75,
});

imageBucket.addLifecycleRule({
  id: 'move-to-ia',
  transitions: [{
    storageClass: s3.StorageClass.INFREQUENT_ACCESS,
    transitionAfter: cdk.Duration.days(30),
  }],
});

const dashboard = new cloudwatch.Dashboard(this, 'VisionAIDashboard', {
  dashboardName: `vision-ai-${props.envName}`,
});

const apiErrors = new cloudwatch.Alarm(this, 'APIErrors', {
  metric: api.metricServerError(),
  threshold: 10,
  evaluationPeriods: 1,
});

// SNS 토픽으로 알람 전송
apiErrors.addAlarmAction(
  new cloudwatchActions.SnsAction(alarmTopic)
);

name: Deploy CDK

on:
  push:
    branches: [main, develop]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          
      - name: Install dependencies
        run: npm ci
        
      - name: Run tests
        run: npm test
        
      - name: Deploy to AWS
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        run: |
          ENV_NAME=${{ github.ref == 'refs/heads/main' && 'prod' || 'dev' }}
          npx cdk deploy --all --require-approval never -c env=$ENV_NAME

// Provisioned Concurrency 설정
const provisionedConcurrency = imageProcessor.currentVersion.addAlias('provisioned', {
  provisionedConcurrentExecutions: 5,
});

// 워밍업 Lambda 추가
const warmer = new lambda.Function(this, 'Warmer', {
  runtime: lambda.Runtime.NODEJS_18_X,
  code: lambda.Code.fromInline(`
    exports.handler = async () => {
      // API 호출하여 Lambda 워밍업
    };
  `),
  handler: 'index.handler',
});

// EventBridge로 5분마다 실행
new events.Rule(this, 'WarmerRule', {
  schedule: events.Schedule.rate(cdk.Duration.minutes(5)),
  targets: [new targets.LambdaFunction(warmer)],
});

// 잘못된 예
// storage-stack.ts
this.bucket.grantRead(props.apiLambda); // apiLambda는 다른 스택에서 생성

// 올바른 예
// api-stack.ts에서 처리
props.storageBucket.grantRead(this.apiLambda);

// package.json
{
  "devDependencies": {
    "aws-cdk": "2.100.0",
    "aws-cdk-lib": "2.100.0",
    "constructs": "^10.0.0"
  },
  "overrides": {
    "aws-cdk-lib": "2.100.0"
  }
}