Claude Code × AWS CodePipeline: stage, artifact, approval और सुरक्षित deploy

“GitHub Actions तो काफी है, AWS CodePipeline की क्या जरूरत?”—यह सवाल मुझसे अक्सर पूछा जाता है।

जवाब है AWS संसाधनों के साथ गहरा एकीकरण। ECR पर पुश करना, ECS पर डिप्लॉय करना, CloudFormation स्टैक्स अपडेट करना—जब यह सब AWS के भीतर नेटिव रूप से काम करना हो, तो CodePipeline + CodeBuild सबसे सहज संयोजन है।

मैं काम में कई AWS सेवाओं को मिलाने वाले पाइपलाइन प्रबंधित करता हूं, और जब से Claude Code पाइपलाइन आवश्यकताओं का वर्णन करने पर buildspec.yml, CDK कोड और IAM नीतियां एक साथ जेनरेट करने लगा, नए पाइपलाइन बनाने का समय एक-चौथाई हो गया।

CodePipeline / CodeBuild की मूल संरचना

CodePipeline (ऑर्केस्ट्रेटर)
    │
    ├─ Source स्टेज:  GitHub / CodeCommit से कोड प्राप्त करें
    ├─ Build स्टेज:   CodeBuild से बिल्ड, टेस्ट, Docker इमेज बनाएं
    ├─ Test स्टेज:    इंटीग्रेशन टेस्ट, सुरक्षा स्कैन (वैकल्पिक)
    └─ Deploy स्टेज:  ECS / Elastic Beanstalk / S3 पर डिप्लॉय करें

CodeBuild, buildspec.yml में लिखे कमांड्स चलाता है। इसे GitHub Actions के steps: के समकक्ष समझें।

चरण 1: buildspec.yml स्वचालित रूप से जेनरेट करें

claude -p "
निम्नलिखित आवश्यकताओं के साथ CodeBuild के लिए buildspec.yml जेनरेट करें।

[बिल्ड सामग्री]
- Node.js 20 वातावरण
- npm ci से इंस्टॉल
- TypeScript बिल्ड (npm run build)
- यूनिट टेस्ट चलाएं (npm test)
- Docker इमेज बनाएं और ECR पर पुश करें
- इमेज टैग: CODEBUILD_RESOLVED_SOURCE_VERSION (Git SHA)
- साथ ही latest टैग भी लगाएं

[सुरक्षा स्कैन]
- ECR इमेज पुश के बाद Trivy स्कैन चलाएं
- HIGH/CRITICAL कमज़ोरियां मिलने पर बिल्ड फेल करें

[आर्टिफैक्ट]
- imagedefinitions.json आउटपुट करें (ECS डिप्लॉय के लिए)
"

जेनरेट की गई buildspec.yml:

version: 0.2

env:
  variables:
    AWS_DEFAULT_REGION: ap-south-1
    ECR_REPO_NAME: myapp
  parameter-store:
    ECR_REGISTRY: /myapp/ecr-registry

phases:
  install:
    runtime-versions:
      nodejs: 20
    commands:
      - echo "डिपेंडेंसी इंस्टॉल कर रहे हैं..."
      - npm ci

  pre_build:
    commands:
      - echo "टेस्ट चला रहे हैं..."
      - npm test
      - echo "Amazon ECR में लॉगिन कर रहे हैं..."
      - aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_REGISTRY
      - IMAGE_TAG=$CODEBUILD_RESOLVED_SOURCE_VERSION
      - IMAGE_URI=$ECR_REGISTRY/$ECR_REPO_NAME:$IMAGE_TAG

  build:
    commands:
      - echo "TypeScript बिल्ड कर रहे हैं..."
      - npm run build
      - echo "Docker इमेज बना रहे हैं..."
      - docker build -t $IMAGE_URI -t $ECR_REGISTRY/$ECR_REPO_NAME:latest .

  post_build:
    commands:
      - echo "ECR पर इमेज पुश कर रहे हैं..."
      - docker push $IMAGE_URI
      - docker push $ECR_REGISTRY/$ECR_REPO_NAME:latest
      - echo "इमेज में कमज़ोरियां स्कैन कर रहे हैं..."
      - |
        docker run --rm \
          -v /var/run/docker.sock:/var/run/docker.sock \
          aquasec/trivy:latest image \
          --exit-code 1 \
          --severity HIGH,CRITICAL \
          $IMAGE_URI
      - echo "imagedefinitions.json बना रहे हैं..."
      - printf '[{"name":"app","imageUri":"%s"}]' $IMAGE_URI > imagedefinitions.json

artifacts:
  files:
    - imagedefinitions.json

reports:
  test-reports:
    files:
      - "coverage/junit.xml"
    file-format: JUNITXML

चरण 2: CDK से पूरा पाइपलाइन बनाएं

claude -p "
lib/pipeline-stack.ts में निम्नलिखित CodePipeline को CDK TypeScript में लागू करें।

[पाइपलाइन कॉन्फ़िगरेशन]
- Source: GitHub (owner/repo की main ब्रांच)
- Build: CodeBuild (ऊपर का buildspec.yml उपयोग करके)
- Deploy: ECS सेवा में Blue/Green डिप्लॉयमेंट

[सूचनाएं]
- पाइपलाइन फेल होने पर SNS → Slack पर सूचना
- सफल डिप्लॉयमेंट पर भी Slack सूचना

[आर्टिफैक्ट स्टोर]
- S3 बकेट (एन्क्रिप्शन और वर्शनिंग सक्षम)
"

// lib/pipeline-stack.ts
import * as cdk from "aws-cdk-lib";
import * as codepipeline from "aws-cdk-lib/aws-codepipeline";
import * as codepipeline_actions from "aws-cdk-lib/aws-codepipeline-actions";
import * as codebuild from "aws-cdk-lib/aws-codebuild";
import * as s3 from "aws-cdk-lib/aws-s3";
import * as iam from "aws-cdk-lib/aws-iam";
import * as sns from "aws-cdk-lib/aws-sns";
import * as ecs from "aws-cdk-lib/aws-ecs";

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

    // आर्टिफैक्ट स्टोर S3 बकेट
    const artifactBucket = new s3.Bucket(this, "ArtifactBucket", {
      versioned: true,
      encryption: s3.BucketEncryption.S3_MANAGED,
      removalPolicy: cdk.RemovalPolicy.RETAIN,
    });

    // आर्टिफैक्ट परिभाषाएं
    const sourceOutput = new codepipeline.Artifact("SourceOutput");
    const buildOutput = new codepipeline.Artifact("BuildOutput");

    // CodeBuild प्रोजेक्ट
    const buildProject = new codebuild.PipelineProject(this, "BuildProject", {
      buildSpec: codebuild.BuildSpec.fromSourceFilename("buildspec.yml"),
      environment: {
        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
        privileged: true,  // Docker बिल्ड के लिए आवश्यक
      },
      environmentVariables: {
        AWS_ACCOUNT_ID: { value: this.account },
      },
    });

    // ECR एक्सेस अधिकार प्रदान करें
    buildProject.addToRolePolicy(new iam.PolicyStatement({
      actions: [
        "ecr:GetAuthorizationToken",
        "ecr:BatchCheckLayerAvailability",
        "ecr:PutImage",
        "ecr:InitiateLayerUpload",
        "ecr:UploadLayerPart",
        "ecr:CompleteLayerUpload",
      ],
      resources: ["*"],
    }));

    // पाइपलाइन
    const pipeline = new codepipeline.Pipeline(this, "Pipeline", {
      pipelineName: "myapp-pipeline",
      artifactBucket,
      stages: [
        {
          stageName: "Source",
          actions: [
            new codepipeline_actions.GitHubSourceAction({
              actionName: "GitHub_Source",
              owner: "your-org",
              repo: "your-repo",
              branch: "main",
              oauthToken: cdk.SecretValue.secretsManager("github-token"),
              output: sourceOutput,
            }),
          ],
        },
        {
          stageName: "Build",
          actions: [
            new codepipeline_actions.CodeBuildAction({
              actionName: "Build_and_Test",
              project: buildProject,
              input: sourceOutput,
              outputs: [buildOutput],
            }),
          ],
        },
        {
          stageName: "Deploy",
          actions: [
            new codepipeline_actions.EcsDeployAction({
              actionName: "Deploy_to_ECS",
              service: ecs.FargateService.fromFargateServiceAttributes(
                this, "EcsService", {
                  cluster: ecs.Cluster.fromClusterArn(
                    this, "Cluster",
                    `arn:aws:ecs:${this.region}:${this.account}:cluster/myapp-cluster`
                  ),
                  serviceName: "myapp-service",
                }
              ),
              input: buildOutput,
            }),
          ],
        },
      ],
    });

    // फेलर सूचनाएं
    const alertTopic = new sns.Topic(this, "AlertTopic");
    pipeline.notifyOnAnyStageStateChange("PipelineNotification", alertTopic, {
      events: [
        codepipeline.PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED,
        codepipeline.PipelineNotificationEvents.PIPELINE_EXECUTION_SUCCEEDED,
      ],
    });
  }
}

चरण 3: टेस्ट परिणाम रिपोर्ट कॉन्फ़िगर करें

claude -p "
CodeBuild में टेस्ट परिणाम CodeBuild Reports को भेजना चाहता हूं
ताकि प्रत्येक PR पर गुणवत्ता रिपोर्ट देख सकूं।

- टेस्ट फ्रेमवर्क: Vitest
- कवरेज रिपोर्ट: Istanbul (lcov फॉर्मेट)
- buildspec.yml में reports सेक्शन जोड़ें
- CDK से रिपोर्ट ग्रुप भी परिभाषित करें
"

# buildspec.yml का reports सेक्शन
reports:
  UnitTestResults:
    files:
      - "test-results/junit.xml"
    file-format: JUNITXML
  CodeCoverage:
    files:
      - "coverage/lcov.info"
    file-format: CLOVERXML

चरण 4: मल्टी-एन्वायरनमेंट पाइपलाइन डिज़ाइन

claude -p "
3 एन्वायरनमेंट के लिए CDK में चरणबद्ध डिप्लॉयमेंट पाइपलाइन डिज़ाइन करें: dev → staging → prod।

- dev: main ब्रांच पर पुश होने पर ऑटो-डिप्लॉय
- staging: dev सफल होने के बाद, मैन्युअल अप्रूवल के साथ डिप्लॉय
- prod: staging सफल होने के बाद, मैन्युअल अप्रूवल के साथ डिप्लॉय
- हर एन्वायरनमेंट का डिप्लॉयमेंट पूरा होने पर Slack को सूचित करें
"

// staging → prod के लिए मैन्युअल अप्रूवल गेट्स जोड़ें
{
  stageName: "Approve_Staging",
  actions: [
    new codepipeline_actions.ManualApprovalAction({
      actionName: "Approve_Deploy_to_Staging",
      notificationTopic: alertTopic,
      additionalInformation: "Staging पर डिप्लॉयमेंट स्वीकृत करें?",
    }),
  ],
},
{
  stageName: "Deploy_Staging",
  actions: [
    new codepipeline_actions.EcsDeployAction({
      actionName: "Deploy_to_Staging",
      service: stagingService,
      input: buildOutput,
    }),
  ],
},

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

1. CodeBuild में privileged: true भूल जाना

Docker इमेज बनाने के लिए privileged: true जरूरी है। इसके बिना Cannot connect to the Docker daemon एरर आता है।

2. GitHub OAuth टोकन की अपर्याप्त अनुमतियां

GitHub सोर्स को repo स्कोप चाहिए। केवल public_repo प्राइवेट रिपोजिटरी के लिए काम नहीं करता।

3. S3 आर्टिफैक्ट बकेट रीजन

पाइपलाइन और आर्टिफैक्ट S3 बकेट एक ही रीजन में होने चाहिए। क्रॉस-रीजन पाइपलाइन के लिए अलग कॉन्फ़िगरेशन चाहिए।

4. ECS डिप्लॉय एक्शन के लिए imagedefinitions.json फॉर्मेट

ECS डिप्लॉयमेंट के लिए सटीक फॉर्मेट जरूरी है:

[{"name": "कंटेनर-नाम", "imageUri": "इमेज-URI"}]

कंटेनर नाम टास्क डेफिनिशन के कंटेनर नाम से बिल्कुल मेल खाना चाहिए।

पहले Source-Build-Test-Deploy की न्यूनतम संरचना तय करें

शुरुआती लोगों के लिए CodePipeline को release conveyor belt मानना आसान है। pipeline पूरा flow है। stage Source, Build, Test या Deploy जैसा भाग है। action उस भाग में चलने वाला काम है। artifact वह package है जो अगली action को दिया जाता है, जैसे source code या CodeBuild से बना dist.

AWS की CodePipeline concepts page भी यही मॉडल बताती है। Claude Code को pipeline बनवाते समय ये चार शब्द साफ लिखें, तो IAM और artifact wiring ज्यादा सुरक्षित बनती है।

पहला practical flow Source -> Build -> Test -> Approve -> Deploy रखें। AWS creation guide के अनुसार pipeline में source stage और कम से कम एक build या deploy stage चाहिए। Production से पहले Manual approval रखना beginners के लिए बहुत अच्छा safety gate है।

aws codepipeline create-pipeline --cli-input-json file://pipeline.json
aws codepipeline get-pipeline-state --name webapp-main
aws codepipeline start-pipeline-execution --name webapp-main

S3/CloudFront और Lambda deploy उदाहरण

Static site में CodeBuild dist बनाता है और S3 deploy action उसे bucket में extract करती है। CloudFront invalidation को बाद की CodeBuild या Lambda invoke action में रखना साफ रहता है। Lambda में CodeBuild package बनाता है और CloudFormation packaged template deploy करता है।

version: 0.2

env:
  variables:
    AWS_REGION: ap-northeast-1
    S3_BUCKET: my-webapp-prod
    CLOUDFRONT_DISTRIBUTION_ID: E1234567890ABC

phases:
  install:
    runtime-versions:
      nodejs: 20
    commands:
      - npm ci
  pre_build:
    commands:
      - npm test
      - npm run lint
  build:
    commands:
      - npm run build
  post_build:
    commands:
      - aws s3 sync ./dist s3://$S3_BUCKET/ --delete --cache-control "public,max-age=300"
      - aws cloudfront create-invalidation --distribution-id $CLOUDFRONT_DISTRIBUTION_ID --paths "/*"

artifacts:
  base-directory: dist
  files:
    - "**/*"

तीन real examples उपयोगी हैं: Astro या Next.js static site को S3/CloudFront पर deploy करना, Lambda API को CloudFormation से update करना, और team flow जिसमें staging automatic है लेकिन production में approval चाहिए। इन्हें अलग रखने से artifact name और IAM review आसान होता है।

Failure होने पर क्या देखें

Source fail हो तो ConnectionArn, branch और artifact format देखें। Build fail हो तो CodeBuild logs, buildspec, environment variables और IAM देखें। Deploy fail हो तो input artifact name, S3 bucket permission, CloudFormation role, Lambda package path और region mismatch देखें।

aws codepipeline get-pipeline-state --name webapp-main
aws codepipeline list-action-executions --pipeline-name webapp-main --max-results 5
aws logs tail /aws/codebuild/webapp-build --since 30m --follow

Common failure examples हैं: BuildOutput बनाया लेकिन Deploy में SourceOutput पढ़ा; CodeBuild service role को S3, CloudFront, CloudFormation या Lambda permission नहीं मिली; secret को plaintext environment variable में रखा। AWS actions guide Source, Build, Test, Deploy, Approval और Invoke को अलग करती है, इसलिए permission भी action के हिसाब से review करें।

Claude Code के लिए safe prompt

इस repository में AWS CodePipeline + CodeBuild CI/CD जोड़ें।
Goal: GitHub main को Source बनाएं, CodeBuild में npm ci/test/build चलाएं, smoke test अलग action में रखें, production से पहले Manual approval जोड़ें, dist को S3 में deploy करें और CloudFront invalidation करें।
Restrictions: AdministratorAccess नहीं, broad wildcard IAM नहीं, approval के बिना production deploy नहीं, plaintext secret नहीं, existing pipeline या bucket delete नहीं।
Deliverables: buildspec.yml, pipeline.json या CDK stack, failure check commands, README operation guide.
Verification: change से पहले current setup समझाएं, diff दिखाएं, aws codepipeline get-pipeline-state और CodeBuild log check document करें।

यह prompt Create a pipeline, stages, and actions और Define CI/CD pipelines के हिसाब से है। Claude Code से official concept भी explain करवाएं, review तेज होता है।

Masa style verification note और अगला कदम

सबसे असरदार आदत artifact names fix करना है: SourceOutput, BuildOutput, TestOutput. इससे failure point जल्दी दिखता है। Beginners के लिए पहले JSON या console version देखना, फिर CDK में बदलना ज्यादा आसान है।

यह topic AWS IAM guide, AWS S3 guide और AWS Lambda guide से जुड़ता है। अकेले सीख रहे हैं तो free PDF से शुरू करें। Team CI/CD में buildspec, IAM, approval, rollback और incident checks साथ design करने चाहिए; इसके लिए Claude Code training/consultation अच्छा next step है।

सारांश

कार्य	Claude Code का योगदान
buildspec.yml जेनरेशन	बिल्ड, टेस्ट, Docker और सुरक्षा स्कैन सहित जेनरेट
CDK पाइपलाइन	Source→Build→Deploy के सभी स्टेज ऑटो-जेनरेट
मल्टी-एन्वायरनमेंट डिज़ाइन	मैन्युअल अप्रूवल गेट्स के साथ चरणबद्ध डिप्लॉयमेंट
टेस्ट रिपोर्ट	CodeBuild Reports कॉन्फ़िगरेशन स्वचालित

CodePipeline कॉन्फ़िगरेशन जटिल लग सकती है, लेकिन Claude Code को बस बताएं “मुझे इस तरह का पाइपलाइन चाहिए” और यह buildspec.yml और CDK कोड दोनों एक बार में दे देगा। पहले buildspec.yml से शुरुआत करें।