Claude Code × AWS Lambda संपूर्ण गाइड | फंक्शन जनरेशन से डिप्लॉयमेंट ऑटोमेशन तक

क्या आपने AWS Lambda डेवलपमेंट में ऐसा अनुभव किया है? हैंडलर्स के टाइप डेफिनेशन थकाऊ होते हैं, हर बार IAM पॉलिसी खोजनी पड़ती है, SAM टेम्पलेट लिखना भूल गए… Claude Code इन सभी समस्याओं को एक साथ हल करता है।

Lambda फंक्शन इम्प्लीमेंटेशन से लेकर IAM पॉलिसी जनरेशन, लोकल टेस्टिंग और प्रोडक्शन डिप्लॉयमेंट तक — हम वास्तविक कोड उदाहरणों के साथ Claude Code के साथ AWS Lambda के तेज़ डेवलपमेंट के हर चरण को समझाते हैं।

Claude Code × AWS Lambda क्यों?

Lambda डेवलपमेंट के “थकाऊ हिस्से” लगभग पूरी तरह से बॉयलरप्लेट हैं।

• हैंडलर फंक्शन के टाइप डेफिनेशन (APIGatewayProxyHandler, S3Handler …)
• एरर हैंडलिंग और रिस्पॉन्स फॉर्मेट
• न्यूनतम विशेषाधिकार IAM पॉलिसी डिज़ाइन
• SAM / CloudFormation टेम्पलेट लेखन
• लोकल टेस्ट एनवायरनमेंट कॉन्फ़िगरेशन

Claude Code यह सब “मुझे X करने वाली Lambda चाहिए” जैसे एक वाक्य से जनरेट करता है। AWS CLI और SAM CLI के साथ मिलाकर, आप कोड जनरेशन से डिप्लॉयमेंट तक सब कुछ एक बार में चला सकते हैं।

एनवायरनमेंट सेटअप

# आवश्यक टूल्स की जाँच करें
aws --version        # AWS CLI v2
sam --version        # SAM CLI 1.100+
node --version       # Node.js 20+

# AWS क्रेडेंशियल्स कॉन्फ़िगर करें (यदि अभी तक नहीं किया है)
aws configure
# → Access Key ID, Secret Access Key, Region (ap-south-1), Output (json)

<!-- CLAUDE.md में जोड़ें -->
## AWS कॉन्फ़िगरेशन
- डिफ़ॉल्ट रीजन: ap-south-1 (मुंबई)
- Lambda रनटाइम: nodejs20.x
- डिप्लॉयमेंट टूल: AWS SAM
- सोर्स डायरेक्टरी: src/functions/
- SAM टेम्पलेट: template.yaml
- स्टैक नाम: my-app-{dev|staging|prod}

## IAM पॉलिसी दिशानिर्देश
- न्यूनतम विशेषाधिकार के सिद्धांत का कड़ाई से पालन करें
- वाइल्डकार्ड (*) का उपयोग न करें
- रिसोर्स ARN को विशेष रूप से निर्दिष्ट करें

उदाहरण 1: API Gateway + Lambda (REST API)

सबसे मौलिक पैटर्न — एक Lambda जो HTTP रिक्वेस्ट प्राप्त करती है और उन्हें प्रोसेस करती है।

Claude Code को निर्देश

claude -p "
जब /users/{userId} पर GET रिक्वेस्ट आए,
DynamoDB की Users टेबल से यूज़र जानकारी प्राप्त करके वापस करें।
Lambda फंक्शन TypeScript में इम्प्लीमेंट करें।

- रनटाइम: Node.js 20
- टेबल नाम: UsersTable (एनवायरनमेंट वैरिएबल के जरिए मिलेगा)
- एरर हैंडलिंग: उचित 404/500 रिस्पॉन्स लौटाएँ
- टाइप डेफिनेशन: @types/aws-lambda का उपयोग करें
- आउटपुट: src/functions/getUser/index.ts
"

जनरेट किया गया इम्प्लीमेंटेशन

// src/functions/getUser/index.ts
import {
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({ region: process.env.AWS_REGION });
const ddb = DynamoDBDocumentClient.from(client);

const response = (statusCode: number, body: unknown): APIGatewayProxyResult => ({
  statusCode,
  headers: {
    "Content-Type": "application/json",
    "Access-Control-Allow-Origin": "*",
  },
  body: JSON.stringify(body),
});

export const handler: APIGatewayProxyHandler = async (event) => {
  const userId = event.pathParameters?.userId;

  if (!userId) {
    return response(400, { error: "userId is required" });
  }

  try {
    const result = await ddb.send(
      new GetCommand({
        TableName: process.env.USERS_TABLE!,
        Key: { userId },
      })
    );

    if (!result.Item) {
      return response(404, { error: `User '${userId}' not found` });
    }

    return response(200, result.Item);
  } catch (err) {
    console.error("DynamoDB error:", err);
    return response(500, { error: "Internal server error" });
  }
};

SAM टेम्पलेट भी स्वचालित रूप से जनरेट होता है

# template.yaml (अंश)
GetUserFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: src/functions/getUser/index.handler
    Runtime: nodejs20.x
    Timeout: 10
    Environment:
      Variables:
        USERS_TABLE: !Ref UsersTable
    Policies:
      - DynamoDBReadPolicy:
          TableName: !Ref UsersTable
    Events:
      GetUserApi:
        Type: Api
        Properties:
          Path: /users/{userId}
          Method: GET

UsersTable:
  Type: AWS::DynamoDB::Table
  Properties:
    TableName: !Sub "${AWS::StackName}-users"
    BillingMode: PAY_PER_REQUEST
    AttributeDefinitions:
      - AttributeName: userId
        AttributeType: S
    KeySchema:
      - AttributeName: userId
        KeyType: HASH

उदाहरण 2: S3 इवेंट ट्रिगर Lambda

फ़ाइल अपलोड से ट्रिगर होकर प्रोसेसिंग चलाने वाली Lambda।

// src/functions/generateThumbnail/index.ts
import { S3Handler } from "aws-lambda";
import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
import sharp from "sharp";

const s3 = new S3Client({ region: process.env.AWS_REGION });

export const handler: S3Handler = async (event) => {
  const record = event.Records[0];
  const bucket = record.s3.bucket.name;
  const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, " "));

  // thumbnails/ प्रीफिक्स को अनदेखा करें (अनंत लूप रोकें)
  if (key.startsWith("thumbnails/")) return;

  const { Body } = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
  const buffer = Buffer.from(await Body!.transformToByteArray());

  const thumbnail = await sharp(buffer)
    .resize(200, 200, { fit: "cover" })
    .webp({ quality: 85 })
    .toBuffer();

  const thumbnailKey = `thumbnails/${key.replace(/\.[^.]+$/, ".webp")}`;
  await s3.send(
    new PutObjectCommand({
      Bucket: bucket,
      Key: thumbnailKey,
      Body: thumbnail,
      ContentType: "image/webp",
    })
  );

  console.log(`थंबनेल बनाया गया: s3://${bucket}/${thumbnailKey}`);
};

उदाहरण 3: शेड्यूल्ड Lambda (EventBridge)

# template.yaml में EventBridge कॉन्फ़िगरेशन
SendReminderFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: src/functions/sendReminder/index.handler
    Runtime: nodejs20.x
    Timeout: 300
    Environment:
      Variables:
        DATABASE_URL: !Sub "{{resolve:secretsmanager:${AWS::StackName}/database-url}}"
        RESEND_API_KEY: !Sub "{{resolve:secretsmanager:${AWS::StackName}/resend-api-key}}"
    Events:
      DailyReminder:
        Type: Schedule
        Properties:
          Schedule: cron(0 0 * * ? *)  # UTC 0:00 = IST 5:30

Claude Code से IAM पॉलिसी डिज़ाइन करवाएं

claude -p "
एक Lambda के लिए न्यूनतम विशेषाधिकार IAM पॉलिसी JSON में जनरेट करें जिसे चाहिए:
- S3 बकेट my-uploads से GetObject
- DynamoDB टेबल ProcessingJobs पर PutItem/UpdateItem
- SQS ProcessingQueue को SendMessage
- CloudWatch Logs में लिखना

दिए गए रिसोर्स नामों से विशिष्ट ARN का अनुमान लगाएं।
"

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::my-uploads/*"
    },
    {
      "Effect": "Allow",
      "Action": ["dynamodb:PutItem", "dynamodb:UpdateItem"],
      "Resource": "arn:aws:dynamodb:ap-south-1:*:table/ProcessingJobs"
    },
    {
      "Effect": "Allow",
      "Action": ["sqs:SendMessage"],
      "Resource": "arn:aws:sqs:ap-south-1:*:ProcessingQueue"
    },
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/*"
    }
  ]
}

लोकल टेस्टिंग और प्रोडक्शन डिप्लॉयमेंट

# बिल्ड करें
sam build

# API को लोकली शुरू करें
sam local start-api --port 3001

# एकल टेस्ट इनवोकेशन
sam local invoke GetUserFunction --event events/get-user.json

# Claude Code के साथ सब कुछ चलाएं
claude -p "
sam build चलाएं,
sam local invoke GetUserFunction --event events/test-get-user.json से परिणाम जाँचें।
यदि सब ठीक है तो sam deploy --config-env dev चलाएं।
"

शीर्ष 5 सामान्य गलतियाँ

1. कोल्ड स्टार्ट को नज़रअंदाज़ करने वाला इनिशियलाइज़ेशन

// ❌ हर बार हैंडलर के अंदर क्लाइंट बनाना
export const handler = async () => {
  const ddb = new DynamoDBClient({});  // ← हर इनवोकेशन पर इंस्टेंशिएट होता है
};

// ✅ मॉड्यूल स्कोप में एक बार इनिशियलाइज़ करें
const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));
export const handler = async () => { /* ddb को फिर से उपयोग करें */ };

2. टाइमआउट को डिफ़ॉल्ट (3 सेकंड) पर छोड़ना DynamoDB + बाहरी API के लिए कम से कम 10-30 सेकंड सेट करें। हमेशा वास्तविक प्रोसेसिंग आवश्यकताओं के अनुसार कॉन्फ़िगर करें।

3. सीक्रेट्स को एनवायरनमेंट वैरिएबल में सीधे लिखना

# ❌ टेम्पलेट में हार्डकोड
Environment:
  Variables:
    DB_PASSWORD: "my-secret"

# ✅ Secrets Manager के माध्यम से
Environment:
  Variables:
    DB_PASSWORD: !Sub "{{resolve:secretsmanager:myapp/db-password}}"

4. VPC Lambda में कोल्ड स्टार्ट देरी RDS कनेक्टिविटी के लिए Lambda को VPC में रखने से कोल्ड स्टार्ट में कई सेकंड जुड़ जाते हैं। Provisioned Concurrency या RDS Proxy से हल करें।

5. बड़े डिप्लॉयमेंट पैकेज node_modules के साथ पैकेजिंग से 250 MB की सीमा आ सकती है। साझा लाइब्रेरीज़ को Lambda Layer में ले जाएं।

सारांश

कार्य	Claude Code का योगदान
हैंडलर इम्प्लीमेंटेशन	टाइप डेफिनेशन, एरर हैंडलिंग और लॉजिक एक बार में जनरेट करें
SAM टेम्पलेट	इवेंट, IAM और एनवायरनमेंट वैरिएबल्स स्वचालित रूप से आउटपुट करें
IAM पॉलिसी	न्यूनतम विशेषाधिकार डिज़ाइन को सटीक रूप से जनरेट करें
लोकल टेस्टिंग	sam invoke निष्पादन और परिणाम मूल्यांकन को स्वचालित करें
डिप्लॉयमेंट	build + deploy को एकीकृत वर्कफ़्लो के रूप में चलाएं

Claude Code Lambda डेवलपमेंट के सबसे समय लेने वाले हिस्सों — टाइप डेफिनेशन और टेम्पलेट लेखन — को संभाल लेता है। बिज़नेस लॉजिक पर ध्यान केंद्रित करने से इम्प्लीमेंटेशन की गति 3-5 गुना बढ़ सकती है।

संबंधित लेख

• Claude Code × AWS S3 ऑपरेशन ऑटोमेशन
• Claude Code × AWS DynamoDB स्कीमा डिज़ाइन
• Claude Code सुरक्षा सर्वोत्तम प्रथाओं की संपूर्ण गाइड

संदर्भ

• AWS Lambda आधिकारिक दस्तावेज़ीकरण
• AWS SAM आधिकारिक दस्तावेज़ीकरण
• AWS SDK for JavaScript v3