Lambda

AWS Lambda runs Python handlers without managing servers. boto3 lets you invoke functions, publish versions, and wire automation around deployments while keeping function code in your repo.

Recipe

import json
import boto3
 
client = boto3.client("lambda")
 
resp = client.invoke(
    FunctionName="process-order",
    InvocationType="RequestResponse",
    Payload=json.dumps({"order_id": "ord_123"}),
)
print(resp["StatusCode"], resp["Payload"].read())

When to reach for this:

• Event-driven tasks (S3, SQS, EventBridge)
• Infrequent workloads where always-on servers waste money
• Async fan-out with InvocationType="Event"
• Glue code between managed AWS services

Working Example

Deploy artifact metadata update, synchronous invoke, and async invoke with error handling.

import json
import logging
 
import boto3
from botocore.exceptions import ClientError
 
log = logging.getLogger(__name__)
lambda_client = boto3.client("lambda")
 
def invoke_sync(function_name: str, payload: dict) -> dict:
    try:
        resp = lambda_client.invoke(
            FunctionName=function_name,
            InvocationType="RequestResponse",
            Payload=json.dumps(payload).encode(),
        )
    except ClientError as exc:
        log.error("invoke failed: %s", exc.response["Error"]["Code"])
        raise
    raw = resp["Payload"].read()
    return json.loads(raw or b"{}")
 
def invoke_async(function_name: str, payload: dict) -> int:
    resp = lambda_client.invoke(
        FunctionName=function_name,
        InvocationType="Event",
        Payload=json.dumps(payload).encode(),
    )
    return resp["StatusCode"]
 
if __name__ == "__main__":
    result = invoke_sync("demo-python-fn", {"action": "ping"})
    print(result)
    status = invoke_async("demo-python-fn", {"action": "enqueue"})
    print("async status", status)

What this demonstrates:

• RequestResponse waits for handler return; Event is fire-and-forget
• Payload must be JSON bytes for structured events
• ClientError codes include ResourceNotFoundException, TooManyRequestsException

Deep Dive

How It Works

• Upload zip/container image to Lambda; handler string points to module.function
• Cold start loads Python runtime and imports; reuse clients outside handler
• Concurrency limits and reserved concurrency protect downstream systems
• Versions and aliases (prod) enable safe rollouts

Packaging Notes

Python Notes

# handler.py - create boto3 clients outside handler
import boto3
s3 = boto3.client("s3")
 
def handler(event, context):
    return {"ok": True, "remaining_ms": context.get_remaining_time_in_millis()}

Gotchas

• Creating boto3 client per invocation - slows cold/warm starts. Fix: module-level client reuse.
• Huge deployment packages - slow cold starts. Fix: slim deps, layers, or container with prebuilt venv.
• Blocking the event loop in async handlers - timeouts. Fix: offload CPU work or use sync handler with appropriate timeout/memory.
• No idempotency on async retries - duplicate side effects. Fix: idempotent handlers with dedupe keys (SQS FIFO or DynamoDB conditional writes).
• Logging to stdout only without structure - hard to trace. Fix: JSON logs with request_id from context.aws_request_id.

Alternatives

FAQs

Related

• AWS Lambda & Serverless - packaging and cold starts
• SQS & SNS - event sources
• S3 - object triggers
• boto3 Basics - client patterns
• Secrets Manager & SSM - env secrets

Stack versions: This page was written for Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, and uv 0.6+.