So stellen Sie im Jahr 2026 eine Python-App für AWS Lambda bereit: Serverloser Leitfaden

AWS Lambda führt Ihren Code aus, ohne Server verwalten zu müssen – Sie zahlen nur für die Ausführungszeit und er skaliert automatisch von null auf Tausende gleichzeitiger Anfragen. In diesem Leitfaden wird eine Python-API für Lambda mit API Gateway von Grund auf bereitgestellt.

Wann man Lambda verwenden sollte

• Gute Passform: APIs mit variablem Datenverkehr, geplante Jobs, Ereignisverarbeitung, Webhooks, leichtgewichtige Microservices
• Schlechte Passform: Lang laufende Prozesse (15-Minuten-Limit), konstant hoher Datenverkehr (günstiger auf ständig aktiven Servern), Apps, die dauerhafte Verbindungen benötigen (WebSockets benötigen API Gateway v2)

Methode 1: Einfache Lambda-Funktion (Konsole)

# handler.py — the entry point
import json

def lambda_handler(event, context):
    # event contains the request data
    name = event.get('queryStringParameters', {}).get('name', 'World')

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps({'message': f'Hello, {name}!'})
    }

Verpackungsabhängigkeiten

Lambda benötigt gebündelte Abhängigkeiten. Für Pakete wierequests:

# Install dependencies into a package directory
mkdir package
pip install requests -t package/

# Add your handler
cp handler.py package/

# Zip it
cd package
zip -r ../deployment.zip .
cd ..

# Upload deployment.zip to Lambda

Methode 2: Serverloses Framework (empfohlen)

npm install -g serverless
serverless create --template aws-python3 --path my-api
cd my-api
npm install serverless-python-requirements

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: python3.12
  region: us-east-1
  environment:
    STAGE: ${sls:stage}
    DB_URL: ${env:DB_URL}

functions:
  api:
    handler: handler.lambda_handler
    events:
      - httpApi:
          path: /hello
          method: get
      - httpApi:
          path: /users/{id}
          method: get
    timeout: 29
    memorySize: 256

plugins:
  - serverless-python-requirements

custom:
  pythonRequirements:
    dockerizePip: true   # builds native deps in a Lambda-compatible container

# requirements.txt
requests==2.32.0
boto3==1.34.0

# Deploy
serverless deploy

# Output gives your API Gateway URL:
# endpoint: GET - https://abc123.execute-api.us-east-1.amazonaws.com/hello

Behandeln von API-Gateway-Ereignissen

import json

def lambda_handler(event, context):
    # httpApi (v2) event structure
    method = event['requestContext']['http']['method']
    path   = event['requestContext']['http']['path']
    params = event.get('pathParameters') or {}
    query  = event.get('queryStringParameters') or {}
    body   = json.loads(event['body']) if event.get('body') else {}

    if path.startswith('/users/'):
        user_id = params.get('id')
        return respond(200, {'userId': user_id})

    return respond(404, {'error': 'Not found'})

def respond(status, data):
    return {
        'statusCode': status,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(data)
    }

Kaltstarts verwalten

Lambda „kalt startet“, wenn ein neuer Container hochfährt (erste Anfrage oder nach Leerlauf). Auswirkungen minimieren:

• Halten Sie das Paket klein: Weniger Abhängigkeiten = schnellerer Kaltstart. Importieren Sie nur das, was Sie verwenden.
• Außerhalb des Handlers initialisieren: Datenbank-Clients und Konfiguration werden einmal pro Container geladen und bei Warm-Aufrufen wiederverwendet
• Verwenden Sie bereitgestellte Parallelität für latenzkritische Endpunkte (hält Container warm, kostet extra)
• Speicher vergrößern: Mehr Speicher bedeutet auch mehr CPU, wodurch die Initialisierungszeit verkürzt wird

# ✅ Initialize clients OUTSIDE the handler (reused across invocations)
import boto3
dynamodb = boto3.resource('dynamodb')  # created once per container
table = dynamodb.Table('users')

def lambda_handler(event, context):
    # table is already initialized — no per-request setup cost
    return table.get_item(Key={'id': '1'})

Umgebungsvariablen und Geheimnisse

# Non-sensitive config: environment variables (serverless.yml)
environment:
  LOG_LEVEL: info

# Sensitive secrets: use AWS Secrets Manager or SSM Parameter Store
import boto3
ssm = boto3.client('ssm')

def get_secret(name):
    resp = ssm.get_parameter(Name=name, WithDecryption=True)
    return resp['Parameter']['Value']

DB_PASSWORD = get_secret('/myapp/db_password')  # loaded once per container

Häufig gestellte Fragen

F: Wie viel kostet Lambda?
A: Das kostenlose Kontingent umfasst 1 Million Anfragen und 400.000 GB-Sekunden pro Monat. Darüber hinaus zahlen Sie pro Anfrage und pro GB-Sekunde Ausführung. Für APIs mit variablem Datenverkehr ist es oft weitaus günstiger als ein ständig verfügbarer Server.

F: Was ist die maximale Ausführungszeit?
A: 15 Minuten. Verwenden Sie für längere Aufgaben AWS Step Functions, um mehrere Lambdas zu orchestrieren, oder wechseln Sie für lang laufende Prozesse zu ECS/Fargate.

F: Wie verbinde ich Lambda mit einer Datenbank?
A: Für serverlose Datenbanken verwenden Sie DynamoDB oder Aurora Serverless. Verwenden Sie für herkömmliches Postgres/MySQL den RDS-Proxy, um das Verbindungspooling zu verwalten (die Skalierung von Lambda kann andernfalls DB-Verbindungen erschöpfen).

F: Kann ich ein vollständiges Web-Framework auf Lambda ausführen?
A: Ja – verwenden Sie Mangum (für FastAPI/Starlette) oder Zappa (für Flask/Django), um WSGI/ASGI-Apps an Lambda anzupassen. Gut für die Migration vorhandener Apps, obwohl native Handler einfacher sind.

F: Wie debugge ich Lambda lokal?
A: Verwenden Sieserverless invoke local oder AWS SAM CLIssam local start-api um Funktionen lokal auszuführen. CloudWatch Logs erfassen alle Produktionsausführungsprotokolle.

Fazit

Mit AWS Lambda können Sie Python-APIs bereitstellen, die automatisch skalieren und im Leerlauf keine Kosten verursachen. Der Serverless Framework-Ansatz –serverless.yml plusserverless-python-requirements – verwaltet Paketierung, API-Gateway und Bereitstellung in einem Befehl. Initialisieren Sie Clients außerhalb des Handlers, um Kaltstartkosten zu reduzieren, verwenden Sie SSM/Secrets Manager für Anmeldeinformationen und greifen Sie nur dann auf bereitgestellte Parallelität zurück, wenn die Latenz wirklich wichtig ist. Es eignet sich hervorragend für APIs mit variablem Datenverkehr und ereignisgesteuerte Workloads.