Claude Code × AWS CodePipeline/CodeBuild पूर्ण गाइड | CI/CD पाइपलाइन स्वचालित रूप से बनाएं

“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";

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"}]

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

---

सारांश

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

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

संबंधित लेख

• Claude Code × AWS ECS/Fargate पूर्ण गाइड
• Claude Code × AWS CloudFormation/CDK पूर्ण गाइड
• Claude Code × AWS IAM पूर्ण गाइड

संदर्भ

• AWS CodePipeline आधिकारिक दस्तावेज़
• AWS CodeBuild buildspec संदर्भ
• CDK CodePipeline मॉड्यूल