AWS ALB + Lambda - 502 Bad Gateway przez przekroczenie limitu payload lub timeout

# lambda_handler.py - obejście limitu 1MB na upload
import json
import boto3
import uuid

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

def handler(event, context):
    """Endpoint do generowania presigned URL dla dużych uploadów."""
    # Klient najpierw pyta o URL do uploadu
    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 minut na upload
        )
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "upload_url": presigned_url,
                "file_key": file_key,
            }),
        }

    # Po uploadzie klient informuje Lambda o pliku do przetworzenia
    if event["path"] == "/upload/process" and event["httpMethod"] == "POST":
        body = json.loads(event["body"])
        file_key = body["file_key"]
        # Przetwórz plik bezpośrednio z S3 (brak limitu 1MB)
        obj = s3.get_object(Bucket=BUCKET, Key=file_key)
        content = obj["Body"].read()
        # ... przetwarzanie ...
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({"status": "processed", "size": len(content)}),
        }

# Gdy Lambda generuje response >1MB, zapisz do S3 i zwróć link
import json
import boto3
import gzip

s3 = boto3.client("s3")

def handler(event, context):
    """Zwraca duże odpowiedzi przez S3 presigned URL."""
    # Generuj dużą odpowiedź
    large_result = generate_report()  # np. 5MB JSON

    result_json = json.dumps(large_result)

    if len(result_json) > 900_000:  # Zostaw margines (limit 1MB)
        # Zapisz do S3 i zwróć presigned URL do pobrania
        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)
# Klient polluje status lub używa 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):
    """Asynchroniczny endpoint dla operacji trwających >29s."""
    path = event["path"]
    method = event["httpMethod"]

    # POST /jobs - rozpocznij długą operację
    if path == "/jobs" and method == "POST":
        job_id = str(uuid.uuid4())
        body = json.loads(event.get("body", "{}"))

        # Uruchom Step Function (może trwać godziny)
        sfn.start_execution(
            stateMachineArn=STATE_MACHINE_ARN,
            name=job_id,
            input=json.dumps({"job_id": job_id, "params": body}),
        )

        # Zapisz status w 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} - sprawdź 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"),
            }),
        }

# POPRAWNY format odpowiedzi Lambda dla ALB:
def handler(event, context):
    return {
        "statusCode": 200,                    # WYMAGANE: int, nie string
        "statusDescription": "200 OK",        # opcjonalne
        "headers": {                           # WYMAGANE: dict
            "Content-Type": "application/json",
        },
        "isBase64Encoded": False,             # WYMAGANE: bool
        "body": json.dumps({"key": "value"})  # WYMAGANE: string (nie dict!)
    }

# BŁĘDNE formaty powodujące 502:
# ❌ return {"statusCode": "200", ...}         # statusCode jako string
# ❌ return {"status_code": 200, ...}          # błędna nazwa klucza
# ❌ return {"statusCode": 200, "body": {...}} # body jako dict zamiast string
# ❌ return "Hello World"                       # string zamiast dict
# ❌ return {"statusCode": 200}                # brak body i headers