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

# 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: nodejs20.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 20
- 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: 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

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: 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 = 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.

Verwandte Artikel

• Claude Code × AWS S3 Betriebsautomatisierung
• Claude Code × AWS DynamoDB Schema-Design
• Claude Code Sicherheits-Best-Practices Vollständiger Leitfaden

Referenzen

• AWS Lambda Offizielle Dokumentation
• AWS SAM Offizielle Dokumentation
• AWS SDK für JavaScript v3