Serverless with Lambda

import json
import boto3

def handler(event, context):
    """
    event   - the trigger payload (dict)
    context - runtime metadata (request ID, remaining time, etc.)
    """
    print(f"Request ID: {context.aws_request_id}")
    print(f"Remaining time: {context.get_remaining_time_in_millis()}ms")

    # Return a response (for API Gateway triggers)
    return {
        "statusCode": 200,
        "headers": {"Content-Type": "application/json"},
        "body": json.dumps({"message": "Hello from Lambda"}),
    }

import boto3

s3 = boto3.client("s3")

def handler(event, context):
    # S3 can batch multiple records in one invocation
    for record in event["Records"]:
        bucket = record["s3"]["bucket"]["name"]
        key = record["s3"]["object"]["key"]
        size = record["s3"]["object"]["size"]

        print(f"New file: s3://{bucket}/{key} ({size} bytes)")

        # Process the file - e.g., generate a thumbnail
        response = s3.get_object(Bucket=bucket, Key=key)
        content = response["Body"].read()
        # ... processing logic here

import json

def handler(event, context):
    for record in event["Records"]:
        # SQS message body is a string, parse if JSON
        body = json.loads(record["body"])
        receipt_handle = record["receiptHandle"]

        print(f"Processing order: {body.get('orderId')}")

        try:
            process_order(body)
            # SQS auto-deletes the message on successful return
        except Exception as e:
            # Raising an exception causes SQS to retry
            # After maxReceiveCount retries, message goes to DLQ
            raise e

def process_order(order: dict):
    # Your business logic here
    pass

# Package your function
zip function.zip lambda_function.py

# Create the Lambda function
aws lambda create-function \
  --function-name my-function \
  --runtime python3.12 \
  --role arn:aws:iam::123456789012:role/MyLambdaRole \
  --handler lambda_function.handler \
  --zip-file fileb://function.zip \
  --timeout 30 \
  --memory-size 256 \
  --environment 'Variables={TABLE_NAME=Orders,STAGE=prod}'

# Update the code only (faster than recreating)
aws lambda update-function-code \
  --function-name my-function \
  --zip-file fileb://function.zip

# Invoke synchronously and see the response
aws lambda invoke \
  --function-name my-function \
  --payload '{"test": true}' \
  --cli-binary-format raw-in-base64-out \
  response.json && cat response.json

from aws_durable_execution_sdk_python import DurableContext, durable_execution

@durable_execution
def lambda_handler(event, context: DurableContext):
    order_id = event['orderId']
    amount = event['amount']
    items = event['items']

    # Each step is checkpointed: on replay, completed steps are skipped
    inventory = context.step(
        lambda _: inventory_service.reserve(items),
        name='reserve-inventory'
    )

    payment = context.step(
        lambda _: payment_service.charge(amount),
        name='process-payment'
    )

    shipment = context.step(
        lambda _: shipping_service.create_shipment(order_id, inventory),
        name='create-shipment'
    )

    return {'orderId': order_id, 'status': 'completed', 'shipment': shipment}

from aws_durable_execution_sdk_python import DurableContext, durable_execution, WaitConfig

@durable_execution
def lambda_handler(event, context: DurableContext):
    doc_id = event['documentId']
    reviewers = event['reviewers']

    context.step(
        lambda _: document_service.prepare(doc_id),
        name='prepare-document'
    )

    # Suspend here - zero compute charges while waiting up to 24 hours
    approval = context.wait_for_callback(
        lambda callback_id: notification_service.send_approval_request({
            'documentId': doc_id,
            'reviewers':  reviewers,
            'callbackId': callback_id,
            'expiresIn':  86400,
        }),
        name='approval-callback',
        config=WaitConfig(timeout=86400),
    )

    if approval and approval.get('approved'):
        context.step(
            lambda _: document_service.finalize(doc_id, approval.get('comments')),
            name='finalize-document'
        )
        return {'status': 'approved', 'documentId': doc_id}

    context.step(
        lambda _: document_service.archive(doc_id, approval.get('reason')),
        name='archive-rejected'
    )
    return {'status': 'rejected', 'documentId': doc_id}

# 1. Create a signing profile (Lambda-specific ECDSA platform)
aws signer put-signing-profile \
  --profile-name MyLambdaProfile \
  --platform-id AWSLambda-SHA384-ECDSA

# 2. Sign the deployment package (bucket must have versioning enabled)
aws signer start-signing-job \
  --source 's3={bucketName=my-deploy-bucket,key=function.zip,version=S3_VERSION_ID}' \
  --destination 's3={bucketName=my-deploy-bucket,prefix=signed/}' \
  --profile-name MyLambdaProfile

# Check signing job status
aws signer describe-signing-job --job-id JOB_ID

# 3. Create a code signing configuration (Enforce blocks unsigned deploys)
aws lambda create-code-signing-config \
  --description "Production signing policy" \
  --allowed-publishers SigningProfileVersionArns=arn:aws:signer:us-east-1:123456789012:/signing-profiles/MyLambdaProfile/versions/VERSION_ARN \
  --code-signing-policies UntrustedArtifactOnDeployment=Enforce

# 4. Attach the config to your function
aws lambda put-function-code-signing-config \
  --function-name my-function \
  --code-signing-config-arn arn:aws:lambda:us-east-1:123456789012:code-signing-config:csc-0123456789abcdef0

# 5. Deploy using the signed artifact from S3
aws lambda update-function-code \
  --function-name my-function \
  --s3-bucket my-deploy-bucket \
  --s3-key signed/function.zip