Claude Code × AWS Lambda Vollständiger Leitfaden | Von der Funktionsgenerierung zur Deployment-Automatisierung

Kennen Sie diese Erfahrungen bei der AWS Lambda-Entwicklung? Typdefinitionen für Handler sind lästig, IAM-Policies müssen jedes Mal nachgeschlagen werden, das Schreiben von SAM-Templates wurde vergessen… Claude Code löst all das auf einmal.

Von der Lambda-Funktionsimplementierung über IAM-Policy-Generierung, lokales Testing bis zum Produktions-Deployment — wir erläutern jeden Schritt der blitzschnellen AWS Lambda-Entwicklung mit Claude Code anhand echter Code-Beispiele.

Warum Claude Code × AWS Lambda?

Die „mühsamen Teile” der Lambda-Entwicklung sind fast ausschließlich Boilerplate.

Typdefinitionen für Handler-Funktionen (APIGatewayProxyHandler, S3Handler …)
Fehlerbehandlung und Antwortformate
IAM-Policy-Design nach dem Prinzip der minimalen Rechte
SAM / CloudFormation Template-Schreibung
Konfiguration der lokalen Testumgebung

Claude Code generiert all das mit einem einzigen Satz wie „Ich brauche eine Lambda, die X macht”. In Kombination mit AWS CLI und SAM CLI können Sie alles von der Code-Generierung bis zum Deployment in einem Durchgang ausführen.

Umgebungseinrichtung

# Erforderliche Tools prüfen
aws --version        # AWS CLI v2
sam --version        # SAM CLI 1.100+
node --version       # Node.js 24+

# AWS-Anmeldeinformationen konfigurieren (falls noch nicht konfiguriert)
aws configure
# → Access Key ID, Secret Access Key, Region (eu-central-1), Output (json)

<!-- In CLAUDE.md einfügen -->
## AWS-Konfiguration
- Standard-Region: eu-central-1
- Lambda-Laufzeit: nodejs24.x
- Deployment-Tool: AWS SAM
- Quellverzeichnis: src/functions/
- SAM-Template: template.yaml
- Stack-Name: my-app-{dev|staging|prod}

## IAM-Policy-Richtlinien
- Prinzip der minimalen Rechte strikt einhalten
- Keine Wildcards (*) verwenden
- Ressourcen-ARNs konkret angeben

Beispiel 1: API Gateway + Lambda (REST API)

Das grundlegendste Muster — eine Lambda, die HTTP-Anfragen empfängt und verarbeitet.

Anweisungen an Claude Code

claude -p "
Wenn ein GET-Request auf /users/{userId} eingeht,
Benutzerinformationen aus der DynamoDB-Tabelle Users abrufen und zurückgeben.
Lambda-Funktion in TypeScript implementieren.

- Laufzeit: Node.js 24
- Tabellenname: UsersTable (wird über Umgebungsvariable übergeben)
- Fehlerbehandlung: geeignete 404/500-Antworten zurückgeben
- Typdefinitionen: @types/aws-lambda verwenden
- Ausgabe nach: src/functions/getUser/index.ts
"

Generierte Implementierung

// 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 wird ebenfalls automatisch generiert

# template.yaml (Auszug)
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

Beispiel 2: S3-Event-Trigger Lambda

Eine Lambda, die durch Datei-Uploads ausgelöst wird und Verarbeitungsaufgaben übernimmt.

// 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/-Präfix überspringen (Endlosschleife verhindern)
  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(`Thumbnail erstellt: s3://${bucket}/${thumbnailKey}`);
};

Beispiel 3: Geplante Lambda (EventBridge)

# EventBridge-Konfiguration in template.yaml
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 = MEZ 1:00 / MESZ 2:00

IAM-Policies von Claude Code entwerfen lassen

claude -p "
Generiere eine Minimal-Privilege-IAM-Policy in JSON für eine Lambda, die folgendes benötigt:
- GetObject aus S3-Bucket my-uploads
- PutItem/UpdateItem auf DynamoDB-Tabelle ProcessingJobs
- SendMessage an SQS ProcessingQueue
- Schreiben in CloudWatch Logs

Spezifische ARNs aus den angegebenen Ressourcennamen ableiten.
"

{
  "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:eu-central-1:*:table/ProcessingJobs"
    },
    {
      "Effect": "Allow",
      "Action": ["sqs:SendMessage"],
      "Resource": "arn:aws:sqs:eu-central-1:*:ProcessingQueue"
    },
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/*"
    }
  ]
}

Lokales Testing und Produktions-Deployment

# Build
sam build

# API lokal starten
sam local start-api --port 3001

# Einzelner Test-Aufruf
sam local invoke GetUserFunction --event events/get-user.json

# Alles mit Claude Code ausführen
claude -p "
sam build ausführen,
Ergebnisse mit sam local invoke GetUserFunction --event events/test-get-user.json prüfen.
Wenn alles in Ordnung, sam deploy --config-env dev ausführen.
"

Die 5 häufigsten Fallstricke

1. Initialisierung ohne Berücksichtigung von Cold Starts

// ❌ Client bei jedem Aufruf im Handler erstellen
export const handler = async () => {
  const ddb = new DynamoDBClient({});  // ← wird bei jedem Aufruf instanziiert
};

// ✅ Einmalig im Modulbereich initialisieren
const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));
export const handler = async () => { /* ddb wiederverwenden */ };

2. Timeout auf dem Standardwert (3 Sekunden) belassen Für DynamoDB + externe APIs mindestens 10-30 Sekunden einstellen. Immer entsprechend der tatsächlichen Verarbeitungsanforderungen konfigurieren.

3. Secrets direkt in Umgebungsvariablen schreiben

# ❌ Direkt im Template eingetragen
Environment:
  Variables:
    DB_PASSWORD: "my-secret"

# ✅ Über Secrets Manager
Environment:
  Variables:
    DB_PASSWORD: !Sub "{{resolve:secretsmanager:myapp/db-password}}"

4. Cold-Start-Verzögerungen bei VPC-Lambda Das Platzieren einer Lambda innerhalb einer VPC für RDS-Konnektivität fügt dem Cold Start mehrere Sekunden hinzu. Mit Provisioned Concurrency oder RDS Proxy beheben.

5. Überdimensionierte Deployment-Pakete Das Paketieren von node_modules kann das Limit von 250 MB erreichen. Gemeinsam genutzte Bibliotheken in ein Lambda Layer auslagern.

Zusammenfassung

Aufgabe	Beitrag von Claude Code
Handler-Implementierung	Typdefinitionen, Fehlerbehandlung und Logik in einem Schritt generieren
SAM-Template	Events, IAM und Umgebungsvariablen automatisch ausgeben
IAM-Policy	Minimal-Privilege-Design präzise generieren
Lokales Testing	sam invoke-Ausführung und Ergebnisauswertung automatisieren
Deployment	Build + Deploy als einheitlichen Workflow ausführen

Claude Code übernimmt die zeitaufwendigsten Teile der Lambda-Entwicklung — Typdefinitionen und Template-Schreibung. Die Konzentration auf die Geschäftslogik kann die Implementierungsgeschwindigkeit um das 3-5-fache steigern.

Wann Lambda passt und wann nicht

Lambda passt zu kurzen, ereignisförmigen Aufgaben, die sicher wiederholt werden können: Order-API, Bildverarbeitung nach S3-Upload, tägliche EventBridge-Reports und Stripe- oder GitHub-Webhooks. Für lange Worker, dauerhafte Verbindungen, große warme Modelle oder komplexen WebSocket-State ist sie schwach. Lassen Sie Claude Code zuerst Pro und Contra formulieren.

Begriffe einfach erklärt

Term	Plain meaning
handler	The function Lambda calls. API Gateway passes an HTTP event; S3 passes an object event.
event	The JSON payload given to Lambda. API Gateway, S3, and EventBridge shapes are different.
least privilege	Grant only the exact actions and resources the function needs.
cold start	The slower first run when Lambda creates a new execution environment.
idempotency	The same event can run twice without duplicate payment, email, or database writes.

Kopierbarer Unit-Test für Node.js 24

// 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- und EventBridge-Events trennen

API Gateway brauchtstatusCode undbody. S3 liest bucket/key ausRecords. EventBridge nutzt oftsource, detail-type und detail. Benennen Sie den Trigger genau: HTTP API v2, S3 ObjectCreated oder EventBridge schedule.

Umgebungsvariablen, Secrets Manager und Least-Privilege-IAM

Umgebungsvariablen sind für Konfiguration wieUSERS_TABLE undAPP_STAGE. API-Keys, Passwörter und Webhook-Secrets gehören in Secrets Manager; Lambda erhält nur den ARN. IAM braucht konkrete Actions und ARNs.

CloudWatch Logs, Retries und Idempotenz

CloudWatch Logs ist die erste Diagnosequelle. Fehlen Logs, prüfen Sie Region, Funktionsname, Rollenrechte und Stack. S3, EventBridge und asynchrone Invokes können retryen; nutzen Sie IDs als Idempotenzschlüssel.

Claude-Code-Prompt für Security Review

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.

CTA für Monetarisierung, Training und Beratung

ClaudeCodeLab bietet Training und Beratung für Lambda, IAM, SAM, Log-Audits und Review-Gates. Einzelne starten mit Gratis-PDF und Gumroad; Teams nutzen Training und Beratung für Rechte, Freigaben und Umsatzpfade.

Praktisches Ergebnis

Die Beispiele sind in Handler und Tests getrennt und mitnpm test prüfbar. Kein echtessam deploy, weil Konto, Region, ARN und Tabelle variieren. Produktion braucht Notizen zusam validate --lint, sam build, sam local invoke, Logs und IAM-Diff.