Claude Code के साथ AWS CloudFormation और CDK: सुरक्षित IaC review गाइड

AWS Console में क्लिक करके infrastructure बदलना शुरू में तेज लगता है। लेकिन कुछ हफ्तों बाद जब कोई पूछता है कि production और staging में फर्क क्यों है, तब समस्या शुरू होती है। CloudFormation और AWS CDK infrastructure को code में रखते हैं, लेकिन IaC अपने आप सुरक्षित नहीं हो जाता। बहुत खुली IAM policy, गलती से resource replacement, या भूला हुआ NAT Gateway सुरक्षा और cost दोनों में नुकसान कर सकता है।

Claude Code यहां उपयोगी है, पर उसे automatic deploy operator की तरह नहीं चलाना चाहिए। बेहतर तरीका है: Claude Code से पहला CloudFormation/CDK draft बनवाएं, cdk diff समझवाएं, IAM privilege expansion पकड़वाएं, और CloudFormation events से rollback checklist बनवाएं। अंतिम approval इंसान के पास रहना चाहिए।

शुरुआती लोगों के लिए: CloudFormation AWS का service है जो templates से resources बनाता और update करता है। CDK TypeScript जैसी language में infrastructure लिखने का toolkit है, जो अंत में CloudFormation template बनाता है। Stack deploy होने वाली resource group है। Drift का मतलब है कि वास्तविक AWS resource अब code से match नहीं करता।

यह लेख 3 जून 2026 को देखी गई AWS official documentation पर आधारित है:

• AWS CDK Developer Guide
• AWS CDK CLI deploy command
• AWS CDK CLI diff command
• CloudFormation change sets
• CloudFormation drift detection
• CloudFormation stack failure options
• IAM security best practices
• AWS CDK security best practices

पहले जिम्मेदारी तय करें

काम	Claude Code से कराएं	इंसान क्या approve करे
Requirements	resources, environments, dependencies	resource सच में चाहिए या नहीं
Template draft	CloudFormation/CDK code	नाम, deletion policy, cost
IAM	possible Action/Resource/Condition	least privilege
Diff review	cdk diff या change set summary	delete, replacement, privilege expansion
Failure handling	events पढ़ना, fix ideas	rollback plan

flowchart LR
  A["Requirements लिखें"] --> B["Claude Code से IaC draft"]
  B --> C["cost और naming की human review"]
  C --> D["cdk diff या change set"]
  D --> E["Claude Code से risk review"]
  E --> F["approve और deploy"]
  F --> G["drift और rollback checks लिखें"]

Use case 1: छोटे AWS हिस्से को CloudFormation में लाना

पूरे production account को एक साथ migrate न करें। छोटे और कम जोखिम वाले हिस्से से शुरू करें। यह template private S3 bucket और Lambda के लिए ऐसा IAM role बनाता है जो केवल उसी bucket को read कर सकता है। Named IAM role बनने के कारण CAPABILITY_NAMED_IAM चाहिए।

mkdir cfn-iac-review-demo
cd cfn-iac-review-demo
# नीचे वाला YAML cfn-safe-iac-demo.yaml में save करें

AWSTemplateFormatVersion: "2010-09-09"
Description: "ClaudeCodeLab safe IaC review demo: private S3 bucket and least-privilege Lambda role"

Parameters:
  Environment:
    Type: String
    Default: dev
    AllowedValues:
      - dev
      - staging
      - prod
  ProjectName:
    Type: String
    Default: cclab-iac-demo
    AllowedPattern: "^[a-z0-9][a-z0-9-]{2,24}$"

Resources:
  DemoBucket:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
    UpdateReplacePolicy: Retain
    Properties:
      BucketName: !Sub "${ProjectName}-${Environment}-${AWS::AccountId}-${AWS::Region}"
      VersioningConfiguration:
        Status: Enabled
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: AES256
      Tags:
        - Key: Project
          Value: !Ref ProjectName
        - Key: Environment
          Value: !Ref Environment

  DemoReaderRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ProjectName}-${Environment}-reader-${AWS::Region}"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: ReadOnlyDemoBucket
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Sid: ListOnlyThisBucket
                Effect: Allow
                Action:
                  - s3:ListBucket
                Resource: !GetAtt DemoBucket.Arn
              - Sid: ReadObjectsOnly
                Effect: Allow
                Action:
                  - s3:GetObject
                Resource: !Sub "${DemoBucket.Arn}/*"

Outputs:
  BucketName:
    Value: !Ref DemoBucket
  ReaderRoleArn:
    Value: !GetAtt DemoReaderRole.Arn

Deploy से पहले Claude Code से review करवाएं:

claude -p "
cfn-safe-iac-demo.yaml को CloudFormation template की तरह review करो।
सिर्फ इन points पर table बनाओ:
1. accidental public access
2. IAM Resource scope
3. delete या replacement risk
4. possible monthly cost
5. production change set में क्या देखना है
"

फिर change set बनाकर देखें:

aws cloudformation create-change-set \
  --stack-name cclab-iac-demo-dev \
  --change-set-name review-20260603-001 \
  --template-body file://cfn-safe-iac-demo.yaml \
  --capabilities CAPABILITY_NAMED_IAM \
  --parameters ParameterKey=Environment,ParameterValue=dev ParameterKey=ProjectName,ParameterValue=cclab-iac-demo

aws cloudformation describe-change-set \
  --stack-name cclab-iac-demo-dev \
  --change-set-name review-20260603-001

Add, Modify, Remove, और Replacement देखें। S3, RDS, DynamoDB, KMS या network resources में Replacement दिखे तो approval रोककर impact समझना जरूरी है।

Use case 2: CDK TypeScript से छोटा safe stack

नए project में CDK TypeScript पढ़ना और review करना आसान होता है। यह example DynamoDB, S3 और Lambda बनाता है, API Gateway नहीं, ताकि demo छोटा और cost कम रहे।

mkdir cdk-iac-review-demo
cd cdk-iac-review-demo
npm init -y
npm install aws-cdk-lib constructs
npm install --save-dev aws-cdk typescript ts-node @types/node
mkdir bin lib

{
  "app": "npx ts-node --prefer-ts-exts bin/app.ts"
}

// bin/app.ts
import * as cdk from "aws-cdk-lib";
import { IacReviewDemoStack } from "../lib/iac-review-demo-stack";

const app = new cdk.App();

new IacReviewDemoStack(app, "IacReviewDemoStack", {
  env: {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION ?? "ap-south-1",
  },
});

// lib/iac-review-demo-stack.ts
import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";
import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
import * as iam from "aws-cdk-lib/aws-iam";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as logs from "aws-cdk-lib/aws-logs";
import * as s3 from "aws-cdk-lib/aws-s3";

export class IacReviewDemoStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const stage = this.node.tryGetContext("stage") ?? "dev";
    const isProd = stage === "prod";

    const table = new dynamodb.Table(this, "AppTable", {
      partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      pointInTimeRecovery: isProd,
      deletionProtection: isProd,
      removalPolicy: isProd ? cdk.RemovalPolicy.RETAIN : cdk.RemovalPolicy.DESTROY,
    });

    const bucket = new s3.Bucket(this, "PrivateAssetsBucket", {
      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
      enforceSSL: true,
      encryption: s3.BucketEncryption.S3_MANAGED,
      versioned: true,
      removalPolicy: isProd ? cdk.RemovalPolicy.RETAIN : cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: !isProd,
    });

    const fn = new lambda.Function(this, "ApiHandler", {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: "index.handler",
      code: lambda.Code.fromInline(`
exports.handler = async () => ({
  statusCode: 200,
  body: JSON.stringify({
    tableName: process.env.TABLE_NAME,
    bucketName: process.env.BUCKET_NAME
  })
});
`),
      environment: {
        TABLE_NAME: table.tableName,
        BUCKET_NAME: bucket.bucketName,
        STAGE: stage,
      },
      timeout: cdk.Duration.seconds(10),
      memorySize: 256,
      logRetention: logs.RetentionDays.ONE_WEEK,
    });

    table.grantReadWriteData(fn);
    bucket.grantPut(fn);

    fn.addToRolePolicy(
      new iam.PolicyStatement({
        sid: "DenyInsecureS3Transport",
        effect: iam.Effect.DENY,
        actions: ["s3:*"],
        resources: [bucket.bucketArn, bucket.arnForObjects("*")],
        conditions: { Bool: { "aws:SecureTransport": "false" } },
      }),
    );

    cdk.Tags.of(this).add("Project", "ClaudeCodeLab");
    cdk.Tags.of(this).add("Stage", stage);

    new cdk.CfnOutput(this, "FunctionName", { value: fn.functionName });
    new cdk.CfnOutput(this, "BucketName", { value: bucket.bucketName });
    new cdk.CfnOutput(this, "TableName", { value: table.tableName });
  }
}

Deploy से पहले:

npx cdk synth -c stage=dev
npx cdk diff -c stage=dev
claude -p "
इस cdk diff को review करो।
सिर्फ deletes, replacements, IAM privilege expansion, S3 exposure, DynamoDB cost, Lambda environment leak बताओ।
$(npx cdk diff -c stage=dev 2>&1)
"

autoDeleteObjects: !isProd development में ठीक है, production में खतरनाक। ऐसे environment guardrails को Claude Code से जरूर पकड़वाएं।

Use case 3: production diff को approval language में बदलना

claude -p "
इस cdk diff को ऐसे summarize करो कि non-AWS product owner भी समझ सके।
Columns:
- change type
- target resource
- user impact
- security impact
- cost impact
- question before approval

$(npx cdk diff -c stage=prod 2>&1)
"

High-risk items में IAM Action/Resource, 0.0.0.0/0 security group, missing deletion protection, public S3, CloudFront/NAT Gateway addition और stateful resource replacement आते हैं।

Use case 4: rollback और drift checks

aws cloudformation describe-stacks --stack-name cclab-iac-demo-dev
aws cloudformation detect-stack-drift --stack-name cclab-iac-demo-dev
aws cloudformation describe-stack-drift-detection-status --stack-drift-detection-id YOUR_DETECTION_ID

claude -p "
यह stack UPDATE_ROLLBACK_FAILED में है।
events पढ़कर likely causes, safe-to-touch resources, do-not-touch resources, और AWS official docs से verify करने वाले steps अलग-अलग बताओ।
$(aws cloudformation describe-stack-events --stack-name cclab-iac-demo-dev 2>&1)
"

सामान्य गलतियां

IAM बहुत खुला रखना। Action: "*" या Resource: "*" सिर्फ इसलिए accept न करें कि code चल गया। Action, ARN और Condition को use case तक सीमित रखें।

diff पढ़े बिना deploy। Production में synth, diff, और change set जरूरी हैं। Replacement दिखे तो deploy रोकें।

fixed cost भूलना। ALB, NAT Gateway, RDS, OpenSearch और हमेशा चलने वाला ECS low traffic में भी cost बनाते हैं।

Console fix को permanent मानना। Incident में manual fix हो सकता है, पर बाद में उसे CloudFormation/CDK में वापस लिखें।

Secrets code में लिखना। Password और API key template या Git history में न रखें। Secrets Manager या SSM Parameter Store use करें।

Review prompt

You are a strict AWS CloudFormation/CDK reviewer.
Review this IaC diff before production.

Check:
- least-privilege IAM Action/Resource/Condition
- accidental exposure through security groups or S3
- delete or replacement of stateful resources
- new fixed monthly cost such as ALB, NAT Gateway, RDS, or OpenSearch
- likely CloudFormation drift
- resources requiring manual rollback

Output:
1. issues to fix now
2. questions for approver
3. commands before deploy
4. commands after deploy

आगे पढ़ें

IAM को विस्तार से समझने के लिए Claude Code और AWS IAM पढ़ें। Compute और data layer के लिए AWS Lambda, AWS API Gateway और AWS DynamoDB भी उपयोगी हैं।

ClaudeCodeLab के practical products और team training इन prompts को Pull Request template और release checklist में बदलने में मदद करते हैं।

निष्कर्ष

CloudFormation/CDK के साथ Claude Code सबसे अच्छा तब काम करता है जब वह strict second reviewer हो। उससे draft बनवाएं, लेकिन deploy से पहले IAM, cost, replacement, rollback और drift की explanation मांगें। Practical result साफ है: cdk diff और change set को Claude Code से review करवाने पर production risk सिर्फ template generate करवाने से ज्यादा जल्दी पकड़ में आता है।