Claude Code & AWS Lambda: Serverless Functions in Minuten statt Stunden

AWS Lambda ist mächtig — und gleichzeitig eines der Themen, bei denen Entwickler die meiste Zeit nicht mit dem eigentlichen Code verbringen, sondern mit Infrastruktur. SAM-Templates schreiben, IAM-Rollen konfigurieren, Deployment-Skripte pflegen, Cold-Start-Probleme debuggen. Der eigentliche Business-Code macht oft weniger als 20 % der Gesamtarbeit aus.

Claude Code dreht dieses Verhältnis um. Handler generieren, SAM-Templates schreiben, CloudWatch-Logs analysieren — das übernimmt Claude Code. Du konzentrierst dich auf die Logik. Dieser Artikel zeigt, wie das in der Praxis aussieht.

1. Was ist AWS Lambda — und warum Serverless?

AWS Lambda ist ein ereignisgesteuerter, serverloser Compute-Dienst. Du schreibst eine Funktion, definierst was sie auslöst — und AWS kümmert sich um alles andere: Server, Skalierung, Verfügbarkeit. Du zahlst nur für die tatsächliche Ausführungszeit, nicht für bereitgestellte Kapazität.

Das Modell hat drei Kernvorteile:

• Serverless: Keine Server provisionieren, patchen oder skalieren. AWS managed die Infrastruktur vollständig.
• Event-driven: Funktionen starten nur, wenn sie gebraucht werden — ausgelöst durch HTTP-Requests, S3-Events, Queue-Nachrichten oder Zeitpläne.
• Pay-per-Use: Abrechnung nach Millisekunden Ausführungszeit und Anzahl der Aufrufe. Bei geringer Last nahezu kostenlos, bei hoher Last linear skalierend.

Lambda eignet sich ideal für API-Backends, Datenverarbeitungs-Pipelines, Webhooks, Cron-Jobs und event-getriebene Microservices. Was es nicht ist: ein Ersatz für dauerhaft laufende Prozesse oder Anwendungen, die persistente Verbindungen brauchen.

2. Handler-Struktur: event, context — Python und Node.js

Jede Lambda-Funktion hat denselben Grundaufbau: eine Handler-Funktion, die zwei Parameter empfängt — event und context. event enthält die eingehenden Daten (z.B. den HTTP-Request, das S3-Event). context liefert Metadaten über die Ausführung selbst.

Python-Handler

import json

def handler(event, context):
    # event enthält die eingehenden Daten
    body = json.loads(event.get('body', '{}'))
    user_id = body.get('user_id')

    # context liefert Ausführungsmetadaten
    print(f"Request ID: {context.aws_request_id}")
    print(f"Verbleibende Zeit: {context.get_remaining_time_in_millis()}ms")

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps({'message': f'Hallo, User {user_id}'})
    }

Node.js-Handler

export const handler = async (event, context) => {
  const body = JSON.parse(event.body || '{}');
  const { userId } = body;

  console.log('Request ID:', context.awsRequestId);

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: `Hallo, User ${userId}` })
  };
};

Claude Code generiert diese Handler auf Zuruf. Beschreibe, was die Funktion tun soll — welche Eingaben sie erwartet, welche Ausgabe sie produziert, welche Fehlerbehandlung nötig ist — und bekommst einen vollständigen, produktionsreifen Handler zurück, inklusive Logging, Error-Handling und korrekter Response-Struktur.

3. Trigger: API Gateway, S3, SQS, CloudWatch Events

Lambda-Funktionen werden durch Trigger gestartet. Der Trigger bestimmt, welche Daten in event ankommen — und damit, wie der Handler aufgebaut sein muss. Die vier wichtigsten Trigger-Typen:

• API Gateway: HTTP-Requests aus dem Web. Das event-Objekt enthält Method, Path, Headers, Query-Params und Body. Lambda wird zur API.
• S3 Events: Wird ausgelöst wenn eine Datei hochgeladen, verändert oder gelöscht wird. event.Records[0].s3 enthält Bucket-Name und Object-Key. Klassischer Use-Case: Bild-Resizing, PDF-Verarbeitung, ETL-Pipelines.
• SQS: Verarbeitet Nachrichten aus einer Queue. Lambda liest Batches, verarbeitet jede Nachricht und kann fehlgeschlagene Nachrichten in eine Dead-Letter-Queue weiterleiten.
• CloudWatch Events / EventBridge: Zeitgesteuerte Ausführung wie ein Cron-Job. rate(5 minutes) oder cron(0 8 * * ? *) — Lambda startet nach Zeitplan, ohne HTTP-Request.

Claude Code kennt die Event-Strukturen aller Trigger und generiert Handler, die korrekt auf den jeweiligen event-Typ reagieren. Kein Nachschlagen in der Dokumentation, kein Raten der Feldnamen.

4. Deployment: SAM, CDK, Serverless Framework

Code allein reicht nicht — Lambda-Funktionen müssen deployed werden, zusammen mit ihrer Infrastruktur: IAM-Rollen, API-Gateway-Konfiguration, Trigger-Definitionen, Environment-Variablen. Drei etablierte Tools:

AWS SAM (Serverless Application Model)

SAM ist der AWS-native Standard. Eine template.yaml beschreibt alle Ressourcen, sam build und sam deploy deployen sie.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  UserUpdateFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/user_update.handler
      Runtime: python3.12
      MemorySize: 256
      Timeout: 30
      Environment:
        Variables:
          TABLE_NAME: !Ref UsersTable
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref UsersTable
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /users/{id}
            Method: PUT

Claude Code schreibt SAM-Templates auf Basis deiner Beschreibung — inklusive korrekter IAM-Policies, Environment-Variablen-Referenzen und Event-Definitionen.

AWS CDK und Serverless Framework

Wer Infrastructure-as-Code in TypeScript oder Python bevorzugt, nutzt das AWS CDK. Das Serverless Framework ist eine beliebte Open-Source-Alternative mit einfacherer Syntax. Claude Code beherrscht alle drei und wählt das richtige Tool — oder generiert auf Wunsch Varianten in allen Formaten.

5. Layers: Dependencies auslagern

Lambda-Funktionen haben ein Deployment-Paketlimit. Wer größere Dependencies (NumPy, Pandas, boto3-Extensions) nutzt, lagert sie in Lambda Layers aus. Ein Layer ist ein ZIP-Archiv, das mehrere Funktionen gleichzeitig nutzen können — ohne dass jede Funktion die Dependencies mitbringt.

# Layer-Struktur für Python
python/
  lib/
    python3.12/
      site-packages/
        requests/
        boto3/

Layers haben weitere Vorteile: Sie reduzieren Deployment-Zeiten, erlauben getrennte Versionierung von Code und Dependencies, und erleichtern Compliance (alle Funktionen nutzen dieselbe, geprüfte Library-Version). Claude Code generiert nicht nur den Layer-Aufbau, sondern auch das SAM-Template das den Layer referenziert und die Build-Skripte die ihn erstellen.

6. Cold Starts vermeiden: Provisioned Concurrency und Warm-up

Das bekannteste Lambda-Problem: Cold Starts. Wenn eine Funktion lange nicht aufgerufen wurde oder AWS neue Container hochfährt, dauert der erste Request länger — manchmal mehrere Sekunden. Für APIs, die schnelle Antwortzeiten brauchen, ist das inakzeptabel.

Zwei Hauptstrategien:

• Provisioned Concurrency: AWS hält eine definierte Anzahl Container dauerhaft warm. Kein Cold Start, aber laufende Kosten auch ohne Traffic. Sinnvoll für kritische Produktions-APIs.
• Warm-up-Strategie: Ein CloudWatch-Event ruft die Funktion alle 5–10 Minuten mit einem speziellen Ping-Event auf. Die Funktion erkennt den Ping und antwortet sofort, ohne echte Arbeit zu tun. Günstig, aber nicht so zuverlässig wie Provisioned Concurrency.

# Warm-up-Check im Handler
def handler(event, context):
    # Warm-up-Ping erkennen und sofort antworten
    if event.get('source') == 'serverless-warmup':
        print('Warm-up ping empfangen')
        return {'statusCode': 200, 'body': 'warm'}

    # Normaler Handler-Code folgt...
    return process_request(event)

7. Claude Code Lambda-Tipps: Was wirklich Arbeit spart

Die praktischen Anwendungsfälle von Claude Code bei Lambda-Projekten gehen weit über "Code generieren" hinaus:

Handler aus Anforderungen generieren

Beschreibe den Use-Case in natürlicher Sprache — Claude Code schreibt den vollständigen Handler inklusive Error-Handling, Logging und Response-Struktur. Kein Copy-Paste aus der Dokumentation, keine vergessenen Edge Cases.

claude "Schreib einen Lambda-Handler der S3-Upload-Events verarbeitet,
das hochgeladene Bild auf 800x600 resized, in einen anderen Bucket
speichert und bei Fehler einen Alert via SNS schickt."

SAM-Templates aus bestehendem Code generieren

Hast du Handler-Code ohne Infrastruktur-Definition? Claude Code liest die Handler-Dateien und generiert das passende SAM-Template — mit korrekten IAM-Policies, die aus dem Code abgeleitet werden (z.B. DynamoDB-Zugriff wenn boto3.resource('dynamodb') im Code steht).

CloudWatch Logs analysieren

Lambda-Logs in CloudWatch sind notorisch schwer zu lesen — viele Requests gleichzeitig, durchmischte Log-Streams, kryptische Error-Messages. Claude Code analysiert Log-Exports und trennt primäre Fehler von Folgefehlern:

claude "Was ist der Hauptfehler in diesen Lambda-Logs?" < cloudwatch-export.json

Deployment-Fehler debuggen

sam deploy schlägt fehl mit einem CloudFormation-Stacktrace — Claude Code liest den Fehler, identifiziert ob es ein IAM-Problem, ein Resource-Conflict oder ein Konfigurationsfehler ist, und schlägt den konkreten Fix vor.

Zwei verwandte Artikel die auf diesem Thema aufbauen:

• Claude Code für Python-Projekte — wie du Claude Code in Python-Workflows und -Debugging einsetzt
• Claude Code für Unternehmen — Deployment, Zugriffskontrolle und Team-Workflows auf Unternehmensebene