AWS ALB + Lambda - 502 Bad Gateway Due to Payload Limit or Timeout

# lambda_handler.py - workaround for 1MB upload limit
import json
import boto3
import uuid

s3 = boto3.client("s3")
BUCKET = "my-uploads-bucket"

def handler(event, context):
    """Endpoint for generating presigned URL for large uploads."""
    # Client first requests an upload URL
    if event["path"] == "/upload/presign" and event["httpMethod"] == "POST":
        file_key = f"uploads/{uuid.uuid4()}"
        presigned_url = s3.generate_presigned_url(
            "put_object",
            Params={"Bucket": BUCKET, "Key": file_key},
            ExpiresIn=300,  # 5 minutes to upload
        )
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "upload_url": presigned_url,
                "file_key": file_key,
            }),
        }

    # After upload, client notifies Lambda of the file to process
    if event["path"] == "/upload/process" and event["httpMethod"] == "POST":
        body = json.loads(event["body"])
        file_key = body["file_key"]
        # Process file directly from S3 (no 1MB limit)
        obj = s3.get_object(Bucket=BUCKET, Key=file_key)
        content = obj["Body"].read()
        # ... processing ...
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({"status": "processed", "size": len(content)}),
        }

# When Lambda generates a response >1MB, save to S3 and return a link
import json
import boto3
import gzip

s3 = boto3.client("s3")

def handler(event, context):
    """Returns large responses via S3 presigned URL."""
    # Generate large response
    large_result = generate_report()  # e.g. 5MB JSON

    result_json = json.dumps(large_result)

    if len(result_json) > 900_000:  # Leave margin (1MB limit)
        # Save to S3 and return presigned URL for download
        key = f"results/{context.aws_request_id}.json.gz"
        s3.put_object(
            Bucket="my-results-bucket",
            Key=key,
            Body=gzip.compress(result_json.encode()),
            ContentType="application/json",
            ContentEncoding="gzip",
        )
        download_url = s3.generate_presigned_url(
            "get_object",
            Params={"Bucket": "my-results-bucket", "Key": key},
            ExpiresIn=3600,
        )
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "status": "complete",
                "result_url": download_url,
                "size_bytes": len(result_json),
            }),
        }
    else:
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": result_json,
        }

# Pattern: ALB → Lambda (start job) → SQS/Step Functions → Lambda (process)
# Client polls for status or uses WebSocket

import json
import boto3
import uuid

sfn = boto3.client("stepfunctions")
dynamodb = boto3.resource("dynamodb")
jobs_table = dynamodb.Table("async-jobs")

STATE_MACHINE_ARN = "arn:aws:states:eu-west-1:123456789012:stateMachine:long-processing"

def handler(event, context):
    """Asynchronous endpoint for operations taking >29s."""
    path = event["path"]
    method = event["httpMethod"]

    # POST /jobs - start a long-running operation
    if path == "/jobs" and method == "POST":
        job_id = str(uuid.uuid4())
        body = json.loads(event.get("body", "{}"))

        # Start Step Function (can run for hours)
        sfn.start_execution(
            stateMachineArn=STATE_MACHINE_ARN,
            name=job_id,
            input=json.dumps({"job_id": job_id, "params": body}),
        )

        # Save status in DynamoDB
        jobs_table.put_item(Item={
            "job_id": job_id,
            "status": "PROCESSING",
            "created_at": context.get_remaining_time_in_millis(),
        })

        return {
            "statusCode": 202,  # Accepted
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "job_id": job_id,
                "status": "PROCESSING",
                "poll_url": f"/jobs/{job_id}",
            }),
        }

    # GET /jobs/{id} - check status (polling)
    if path.startswith("/jobs/") and method == "GET":
        job_id = path.split("/")[-1]
        item = jobs_table.get_item(Key={"job_id": job_id}).get("Item")

        if not item:
            return {"statusCode": 404, "body": json.dumps({"error": "Job not found"})}

        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "job_id": job_id,
                "status": item["status"],
                "result_url": item.get("result_url"),
            }),
        }

# CORRECT Lambda response format for ALB:
def handler(event, context):
    return {
        "statusCode": 200,                    # REQUIRED: int, not string
        "statusDescription": "200 OK",        # optional
        "headers": {                           # REQUIRED: dict
            "Content-Type": "application/json",
        },
        "isBase64Encoded": False,             # REQUIRED: bool
        "body": json.dumps({"key": "value"})  # REQUIRED: string (not dict!)
    }

# INCORRECT formats causing 502:
# ❌ return {"statusCode": "200", ...}         # statusCode as string
# ❌ return {"status_code": 200, ...}          # wrong key name
# ❌ return {"statusCode": 200, "body": {...}} # body as dict instead of string
# ❌ return "Hello World"                       # string instead of dict
# ❌ return {"statusCode": 200}                # missing body and headers