Claude Code × AWS ECS/Fargate संपूर्ण गाइड | कंटेनर डिप्लॉयमेंट को स्वचालित करें

“मैं AWS पर कंटेनर चलाना चाहता हूं, लेकिन ECS कॉन्फिगरेशन बहुत जटिल है” — यह वह दीवार है जिससे कई डेवलपर्स पहले टकराते हैं। टास्क डेफिनिशन, सर्विस, क्लस्टर, लोड बैलेंसर, ऑटो स्केलिंग… इतनी सेटिंग्स हैं कि समझ नहीं आता कहां से शुरू करें।

मैं काम पर ECS/Fargate के साथ सर्वरलेस कंटेनर एनवायरनमेंट बना रहा हूं, और जब से मैंने Claude Code का उपयोग अपनी आर्किटेक्चर बताने के लिए करना शुरू किया और इससे टास्क डेफिनिशन से लेकर CDK कोड तक सब कुछ जेनरेट करवाना शुरू किया, डिप्लॉयमेंट बहुत आसान हो गई है। यह लेख व्यावहारिक चरणों को बताता है।

---

3 मिनट में ECS/Fargate की मूल बातें

Cluster:          ECS कंटेनर चलाने की "बॉक्स"
Task Definition:  कंटेनर स्पेसिफिकेशन (इमेज, CPU, मेमोरी, एनवायरनमेंट वेरिएबल्स)
Service:          कितने टास्क चलाने हैं (ऑटो स्केलिंग सहित)
Fargate:          सर्वरलेस कंटेनर एक्जीक्यूशन इंजन — कोई सर्वर मैनेजमेंट नहीं

EC2 के विपरीत, Fargate में सर्वर प्रोविजनिंग या पैच मैनेजमेंट की जरूरत नहीं। आप पूरी तरह कंटेनर कॉन्फिगरेशन पर ध्यान दे सकते हैं।

---

Step 1: टास्क डेफिनिशन को स्वचालित रूप से जेनरेट करें

claude -p "
निम्नलिखित आवश्यकताओं के साथ ECS टास्क डेफिनिशन JSON में जेनरेट करें:

- App: Node.js API (पोर्ट 3000)
- CPU: 512 (0.5 vCPU)
- Memory: 1024 MB
- Environment variables: DATABASE_URL (Secrets Manager से प्राप्त), NODE_ENV=production
- Logging: CloudWatch Logs (log group /ecs/myapp)
- Health check: /health endpoint, 30 सेकंड इंटरवल
- Container image: 123456789.dkr.ecr.ap-northeast-1.amazonaws.com/myapp:latest
- Execution role: ecsTaskExecutionRole
- Task role: myapp-task-role (DynamoDB और S3 तक पहुंच)
"

जेनरेट की गई टास्क डेफिनिशन:

{
  "family": "myapp-task",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "executionRoleArn": "arn:aws:iam::123456789:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::123456789:role/myapp-task-role",
  "containerDefinitions": [
    {
      "name": "myapp",
      "image": "123456789.dkr.ecr.ap-northeast-1.amazonaws.com/myapp:latest",
      "portMappings": [{ "containerPort": 3000, "protocol": "tcp" }],
      "environment": [{ "name": "NODE_ENV", "value": "production" }],
      "secrets": [
        {
          "name": "DATABASE_URL",
          "valueFrom": "arn:aws:secretsmanager:ap-northeast-1:123456789:secret:prod/database-url"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/myapp",
          "awslogs-region": "ap-northeast-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "healthCheck": {
        "command": ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
        "interval": 30,
        "timeout": 5,
        "retries": 3,
        "startPeriod": 60
      }
    }
  ]
}

---

Step 2: CDK से ECS/Fargate इन्फ्रास्ट्रक्चर बनाएं

सिर्फ टास्क डेफिनिशन नहीं, बल्कि क्लस्टर, सर्विस और ALB सभी को एक साथ CDK से जेनरेट करते हैं।

claude -p "
lib/ecs-stack.ts में निम्नलिखित ECS/Fargate environment को CDK TypeScript में implement करें:

- VPC: मौजूदा VPC import करें (vpcId environment variable से)
- ECS Cluster: केवल Fargate
- Task Definition: ऊपर जेनरेट की गई स्पेसिफिकेशन के अनुसार
- ALB: HTTPS (ACM certificate ARN environment variable से), HTTP 301 से redirect
- Service: minimum 2, maximum 10 tasks के साथ auto scaling
  - 70% CPU utilization पर scale out
  - Target tracking scaling
- Blue/Green deploy सपोर्ट (CodeDeploy integration)
- CloudWatch dashboard में service status दिखाएं
"

// lib/ecs-stack.ts
import * as cdk from "aws-cdk-lib";
import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecsp from "aws-cdk-lib/aws-ecs-patterns";
import * as acm from "aws-cdk-lib/aws-certificatemanager";

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

    // मौजूदा VPC import करें
    const vpc = ec2.Vpc.fromLookup(this, "Vpc", {
      vpcId: process.env.VPC_ID!,
    });

    // ECS Cluster
    const cluster = new ecs.Cluster(this, "Cluster", {
      vpc,
      clusterName: "myapp-cluster",
      containerInsights: true,  // CloudWatch Container Insights सक्षम करें
    });

    // ACM Certificate
    const certificate = acm.Certificate.fromCertificateArn(
      this, "Certificate",
      process.env.CERTIFICATE_ARN!
    );

    // Task Definition
    const taskDef = new ecs.FargateTaskDefinition(this, "TaskDef", {
      cpu: 512,
      memoryLimitMiB: 1024,
    });

    const container = taskDef.addContainer("app", {
      image: ecs.ContainerImage.fromEcrRepository(
        ecr.Repository.fromRepositoryName(this, "Repo", "myapp")
      ),
      environment: { NODE_ENV: "production" },
      logging: ecs.LogDrivers.awsLogs({ streamPrefix: "ecs" }),
      healthCheck: {
        command: ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
        interval: cdk.Duration.seconds(30),
        timeout: cdk.Duration.seconds(5),
        retries: 3,
        startPeriod: cdk.Duration.seconds(60),
      },
    });
    container.addPortMappings({ containerPort: 3000 });

    // ALB + Fargate Service (patterns से संक्षिप्त)
    const service = new ecsp.ApplicationLoadBalancedFargateService(
      this, "Service", {
        cluster,
        taskDefinition: taskDef,
        desiredCount: 2,
        certificate,
        redirectHTTP: true,
        publicLoadBalancer: true,
      }
    );

    // Auto Scaling कॉन्फिगरेशन
    const scaling = service.service.autoScaleTaskCount({
      minCapacity: 2,
      maxCapacity: 10,
    });
    scaling.scaleOnCpuUtilization("CpuScaling", {
      targetUtilizationPercent: 70,
      scaleInCooldown: cdk.Duration.seconds(60),
      scaleOutCooldown: cdk.Duration.seconds(60),
    });

    // Output
    new cdk.CfnOutput(this, "LoadBalancerDns", {
      value: service.loadBalancer.loadBalancerDnsName,
    });
  }
}

---

Step 3: GitHub Actions से CI/CD Pipeline बनाएं

claude -p "
GitHub Actions से निम्नलिखित CI/CD pipeline बनाएं:

1. main branch पर push होने पर trigger
2. Docker image build करके ECR में push
3. ECS task definition में image tag को नए SHA से अपडेट करें
4. ECS service में नई task definition deploy करें
5. Deployment पूरा होने पर Slack को notify करें

Environment: ap-northeast-1, ECR repository name: myapp
"

name: Deploy to ECS

on:
  push:
    branches: [main]

env:
  AWS_REGION: ap-northeast-1
  ECR_REPOSITORY: myapp
  ECS_CLUSTER: myapp-cluster
  ECS_SERVICE: myapp-service
  CONTAINER_NAME: app

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build, tag, and push image to ECR
        id: build-image
        env:
          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
          IMAGE_TAG: ${{ github.sha }}
        run: |
          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
          echo "image=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG" >> $GITHUB_OUTPUT

      - name: Download task definition
        run: |
          aws ecs describe-task-definition --task-definition myapp-task \
            --query taskDefinition > task-definition.json

      - name: Update ECS task definition with new image
        id: task-def
        uses: aws-actions/amazon-ecs-render-task-definition@v1
        with:
          task-definition: task-definition.json
          container-name: ${{ env.CONTAINER_NAME }}
          image: ${{ steps.build-image.outputs.image }}

      - name: Deploy to ECS
        uses: aws-actions/amazon-ecs-deploy-task-definition@v1
        with:
          task-definition: ${{ steps.task-def.outputs.task-definition }}
          service: ${{ env.ECS_SERVICE }}
          cluster: ${{ env.ECS_CLUSTER }}
          wait-for-service-stability: true

      - name: Notify Slack on success
        if: success()
        uses: slackapi/slack-github-action@v1
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK }}
          payload: |
            {"text": "✅ Deployed to ECS: ${{ github.sha }}"}

---

Step 4: Blue/Green Deployment कॉन्फिगर करें

claude -p "
ECS service के लिए Blue/Green deployment (CodeDeploy) सेट करने के लिए
CDK code और AppSpec file जेनरेट करें।
Rollback condition: deployment के 5 मिनट के भीतर CloudWatch alarm fire होने पर automatic rollback
"

# appspec.yaml (CodeDeploy के लिए)
version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: <TASK_DEFINITION>
        LoadBalancerInfo:
          ContainerName: app
          ContainerPort: 3000
        PlatformVersion: LATEST
Hooks:
  - BeforeAllowTraffic: "arn:aws:lambda:ap-northeast-1:123456789:function:health-check"
  - AfterAllowTraffic: "arn:aws:lambda:ap-northeast-1:123456789:function:smoke-test"

---

5 सबसे बड़ी गलतियां

1. Health check में startPeriod भूल जाना

Fargate कंटेनर शुरू होते ही health check करता है, लेकिन अगर एप्लिकेशन धीरे-धीरे शुरू होती है तो वह तुरंत UNHEALTHY हो जाती है। एप्लिकेशन को शुरू होने का समय देने के लिए startPeriod: 60 (सेकंड) सेट करें।

2. Task role और execution role को मिलाना

executionRole (ecsTaskExecutionRole): कंटेनर शुरू करने के लिए जरूरी permissions
  → ECR से image pull करना, CloudWatch Logs में लिखना

taskRole (myapp-task-role): एप्लिकेशन द्वारा उपयोग की जाने वाली permissions
  → DynamoDB, S3, SQS आदि तक पहुंच

गलत role में permissions जोड़ना बहुत आम गलती है।

3. awsvpc network mode में security group कॉन्फिगरेशन

Fargate के लिए awsvpc network mode जरूरी है। अगर कंटेनर के security group को सिर्फ ALB से ट्रैफिक तक सीमित करना भूल जाएं, तो कंटेनर सीधे इंटरनेट पर एक्सपोज हो जाता है।

4. Secrets Manager से fetch करने के लिए execution role जरूरी है

secrets से Secrets Manager का मान प्राप्त करने के लिए executionRole में secretsmanager:GetSecretValue permission होनी चाहिए। इस permission के न होने से कंटेनर अक्सर शुरू नहीं होता।

5. Deployment के दौरान desired_count: 0 की समस्या

Auto scaling में minimum 0 वाली service रात को सभी कंटेनर बंद कर सकती है, जिससे सुबह slow startup होती है। Production में minimum कम से कम 2 रखें।

---

सारांश

टास्क	Claude Code का योगदान
Task definition जेनरेशन	सिर्फ आवश्यकताओं से पूरा JSON
CDK implementation	Cluster, service, ALB, auto scaling एक साथ जेनरेट
CI/CD सेटअप	GitHub Actions workflow जेनरेशन
Blue/Green deployment	AppSpec और CodeDeploy config स्वचालित रूप से जेनरेट
समस्या समाधान	Error logs से कारण और समाधान खोजना

ECS में बहुत सारे कॉन्फिगरेशन आइटम हैं, लेकिन Claude Code को “मुझे इस तरह का सेटअप चाहिए” बताने से आपको best practices के अनुसार पूरी कॉन्फिगरेशन मिल जाती है। CDK से शुरू करना सबसे आसान और अनुशंसित तरीका है।

संबंधित लेख

• Claude Code × AWS Lambda संपूर्ण गाइड
• Claude Code × AWS IAM संपूर्ण गाइड
• Claude Code × AWS CloudFormation/CDK संपूर्ण गाइड

संदर्भ

• Amazon ECS आधिकारिक दस्तावेज़
• AWS Fargate गाइड
• ECS CDK Patterns