Use Cases (अपडेट: 2/6/2026)

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

Claude Code से AWS Lambda बनाएं: Node.js 24, SAM, IAM, API Gateway, S3 triggers, logs और pitfalls.

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 24+

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

<!-- CLAUDE.md में जोड़ें -->
## AWS कॉन्फ़िगरेशन
- डिफ़ॉल्ट रीजन: ap-south-1 (मुंबई)
- Lambda रनटाइम: nodejs24.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 24
- टेबल नाम: 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: nodejs24.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: nodejs24.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 गुना बढ़ सकती है।

संबंधित लेख

Lambda कब सही है और कब नहीं

Lambda short, event-shaped और safely retry होने वाले काम के लिए सही है: order API, S3 upload के बाद image processing, EventBridge daily report, Stripe/GitHub webhook. Long worker, persistent connection, बड़ा warm model या complex WebSocket state के लिए ECS/Fargate, App Runner, EC2 या Step Functions देखें। Claude Code से पहले fit और non-fit दोनों लिखवाएं।

Terms को सरल भाषा में समझें

TermPlain meaning
handlerThe function Lambda calls. API Gateway passes an HTTP event; S3 passes an object event.
eventThe JSON payload given to Lambda. API Gateway, S3, and EventBridge shapes are different.
least privilegeGrant only the exact actions and resources the function needs.
cold startThe slower first run when Lambda creates a new execution environment.
idempotencyThe same event can run twice without duplicate payment, email, or database writes.

Node.js 24 के लिए copy-paste unit test

// test/getUser.test.ts
import { describe, expect, it, vi } from "vitest";
import type { APIGatewayProxyEvent } from "aws-lambda";

const mockSend = vi.fn();
vi.mock("@aws-sdk/lib-dynamodb", async () => {
  const actual = await vi.importActual<typeof import("@aws-sdk/lib-dynamodb")>("@aws-sdk/lib-dynamodb");
  return { ...actual, DynamoDBDocumentClient: { from: () => ({ send: mockSend }) } };
});

const { handler } = await import("../src/functions/getUser/index");

function event(userId?: string): APIGatewayProxyEvent {
  return {
    pathParameters: userId ? { userId } : null,
    httpMethod: "GET",
    path: userId ? "/users/" + userId : "/users",
    headers: {},
    multiValueHeaders: {},
    queryStringParameters: null,
    multiValueQueryStringParameters: null,
    body: null,
    isBase64Encoded: false,
    requestContext: {} as APIGatewayProxyEvent["requestContext"],
    resource: "/users/{userId}",
    stageVariables: null,
  };
}

describe("getUser Lambda", () => {
  it("returns 200 when the user exists", async () => {
    process.env.USERS_TABLE = "UsersTable";
    mockSend.mockResolvedValueOnce({ Item: { userId: "u-1", name: "Masa" } });

    const res = await handler(event("u-1"), {} as never, vi.fn());

    expect(res.statusCode).toBe(200);
    expect(JSON.parse(res.body).userId).toBe("u-1");
  });

  it("returns 400 when path parameter is missing", async () => {
    const res = await handler(event(), {} as never, vi.fn());
    expect(res.statusCode).toBe(400);
  });
});

API Gateway, S3 और EventBridge events अलग रखें

API Gateway कोstatusCode औरbody चाहिए। S3Records से bucket/key पढ़ता है। EventBridge अक्सरsource, detail-type, detail देखता है। Prompt में HTTP API v2, S3 ObjectCreated या EventBridge schedule साफ लिखें।

Environment variables, Secrets Manager और least-privilege IAM

Environment variablesUSERS_TABLE, APP_STAGE जैसी config के लिए हैं। API key, DB password और webhook secret Secrets Manager में रखें; Lambda को सिर्फ ARN दें। IAM specific actions और ARNs तक सीमित रखें।

CloudWatch Logs, retries और idempotency

CloudWatch Logs पहला diagnostic स्थान है। Logs न मिलें तो region, function name, role permissions और stack देखें। S3, EventBridge और async invoke retry कर सकते हैं; event ID या business ID को idempotency key बनाएं।

Claude Code security review prompt

Review this AWS Lambda change before production.
Check handler shape, API Gateway/S3/EventBridge event type, IAM least privilege, Secrets Manager usage, CloudWatch Logs, retries, idempotency, cold starts, timeout, memory, and cost risk.
Return blockers first, then recommended fixes, missing tests, and human approvals required before deploy.

Monetization, training और consultation CTA

ClaudeCodeLab Lambda, IAM, SAM, log audit और review gates पर training/consultation देता है। Solo builders free PDF और Gumroad से शुरू करें; teams training और consultation से permissions, approvals और revenue path design करें।

Hands-on result

Examples को handler और tests में बांटा गया है ताकिnpm test चल सके। Realsam deploy account, region, ARN और table पर निर्भर है, इसलिए यहाँ नहीं चलाया। Production मेंsam validate --lint, sam build, sam local invoke, logs और IAM diff दर्ज करें।

आंतरिक लिंक चेकलिस्ट

संदर्भ

#claude-code #aws #lambda #serverless #api-gateway #typescript
मुफ़्त

मुफ़्त PDF: Claude Code cheatsheet

Email डालें और commands, review habits तथा safe workflow वाली एक-page PDF पाएँ.

हम आपका data सुरक्षित रखते हैं और spam नहीं भेजते.

Masa

लेखक के बारे में

Masa

Claude Code workflow और team adoption पर काम करने वाला engineer.

संबंधित लेख