Chapter 34: Serverless & FaaS

1. What is Serverless

Serverless is a cloud execution model where the provider manages all infrastructure—servers, scaling, patching, and capacity planning. You deploy code, and the platform handles everything else.

Core Characteristics

• No Server Management: No provisioning, patching, or capacity planning
• Pay-Per-Invocation: Billed per request and execution time, not for idle capacity
• Auto-Scale to Zero: Scales from 0 to thousands of instances automatically
• Event-Driven: Functions triggered by events (HTTP, queue, storage, scheduler)
• Stateless Execution: Each invocation is independent (ephemeral storage only)

Serverless vs Traditional

2. FaaS (Functions as a Service)

FaaS is the most common serverless model: deploy functions that execute in response to events. The provider manages runtime, scaling, and infrastructure.

Major FaaS Providers

FaaS Execution Model

Lambda Anatomy

// Node.js Lambda Handler
export const handler = async (event, context) => {
    // event: trigger data (API Gateway request, S3 event, etc.)
    // context: runtime info (requestId, functionName, remainingTime)

    console.log('Event:', JSON.stringify(event));
    console.log('Request ID:', context.requestId);
    console.log('Time remaining (ms):', context.getRemainingTimeInMillis());

    // Business logic
    const result = await processData(event.body);

    // Return response
    return {
        statusCode: 200,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ result })
    };
};

3. Cold Starts

A cold start is the initialization latency when a function is invoked after being idle. This is the biggest drawback of serverless for latency-sensitive applications.

Cold Start Phases

1. Container Creation: AWS provisions execution environment (micro-VM or container)
2. Runtime Initialization: Load runtime (Node.js, Python, JVM, .NET CLR)
3. Code Initialization: Download deployment package, import dependencies, run init code
4. Handler Execution: Run your function code (this is NOT part of cold start)

Cold Start Latencies (AWS Lambda)

Cold Start Triggers

• First Invocation: Function never run before
• Idle Timeout: No invocations for ~10-15 minutes (container recycled)
• Concurrency Spike: Traffic exceeds warm containers (need new instances)
• Code Deployment: New version deployed (old containers drained)
• Configuration Change: Memory, timeout, environment variables updated

Provisioned Concurrency

Keep N execution environments initialized and warm at all times. Eliminates cold starts but incurs hourly charges (similar to always-on instances).

# Configure provisioned concurrency
aws lambda put-provisioned-concurrency-config \
  --function-name my-function \
  --provisioned-concurrent-executions 10

# Cost: ~$0.015/hour per GB-hour (vs $0.0000166667/GB-second on-demand)

4. Event-Driven Architecture

Serverless functions are event-driven: they execute in response to triggers from other services. This decouples components and enables reactive, scalable architectures.

AWS Lambda Event Sources

Event-Driven Pattern Example

Event Structure Examples

// API Gateway Event
{
    "httpMethod": "POST",
    "path": "/users",
    "headers": { "Content-Type": "application/json" },
    "body": "{\"name\":\"Alice\"}",
    "requestContext": { "requestId": "abc123" }
}

// S3 Event
{
    "Records": [{
        "eventName": "ObjectCreated:Put",
        "s3": {
            "bucket": { "name": "my-bucket" },
            "object": { "key": "uploads/file.pdf", "size": 1024000 }
        }
    }]
}

// SQS Event (Batch)
{
    "Records": [
        { "messageId": "msg1", "body": "{\"orderId\":123}" },
        { "messageId": "msg2", "body": "{\"orderId\":124}" }
    ]
}

5. Execution Model

Lambda Lifecycle

1. Invocation: Function triggered by event or direct invocation
2. Execution Environment: AWS creates/reuses micro-VM with runtime
3. Handler Execution: Your code runs (subject to timeout, memory limits)
4. Response: Return value sent to caller (synchronous) or discarded (async)
5. Container Reuse: Environment kept warm for next invocation (~10-15 min)

Key Constraints

Stateless Execution

Lambda functions are stateless: each invocation is independent. However, containers may be reused (warm starts), so:

• Global Variables Persist: Across warm invocations (use for connection pooling, caches)
• /tmp Storage Persists: Across warm invocations (but not guaranteed)
• Environment Variables: Set at deployment time, same for all invocations

// Connection pooling example (global scope)
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';

const dynamoDb = new DynamoDBClient({}); // Created once, reused across warm invocations

export const handler = async (event) => {
    // dynamoDb client reused (no reconnection overhead)
    const result = await dynamoDb.send(new GetItemCommand({ ... }));
    return result;
};

6. Common Patterns

1. API Backend

Use Lambda + API Gateway to build serverless REST APIs. Each endpoint is a separate function (or use monolithic handler).

Pros: Zero idle cost, auto-scale, pay per request

Cons: Cold starts (add provisioned concurrency for critical paths), 15-min timeout

2. Event Processing

Process events from queues, streams, or storage. Common for ETL, notifications, and async workflows.

Example: Image upload to S3 triggers Lambda to resize, OCR text, store metadata in DynamoDB.

3. Scheduled Tasks (Cron Jobs)

Use EventBridge (CloudWatch Events) to trigger Lambda on a schedule.

# EventBridge rule: every 5 minutes
rate(5 minutes)

# Cron expression: daily at 2 AM UTC
cron(0 2 * * ? *)

Use Cases: Backups, cleanup, report generation, health checks

4. Stream Processing

Process real-time streams from Kinesis or DynamoDB Streams.

Note: Lambda processes stream in batches (100-10000 records). Parallelism = shard count.

5. Orchestration with Step Functions

Coordinate multiple Lambda functions into workflows. Step Functions handles retries, error handling, and state management.

Use Case: Order processing (validate payment, update inventory, send confirmation, handle failures)

7. Limitations

8. BaaS (Backend as a Service)

BaaS provides fully managed backend services: authentication, databases, storage, search, and APIs. You integrate via SDKs; provider manages infrastructure, scaling, and security.

BaaS vs FaaS

Popular BaaS Providers

BaaS Example (Firebase)

// Frontend code (no backend required)
import { initializeApp } from 'firebase/app';
import { getAuth, signInWithEmailAndPassword } from 'firebase/auth';
import { getFirestore, collection, addDoc } from 'firestore/firestore';

const app = initializeApp({ /* config */ });
const auth = getAuth(app);
const db = getFirestore(app);

// Authenticate
await signInWithEmailAndPassword(auth, email, password);

// Write to database
await addDoc(collection(db, 'orders'), {
    userId: auth.currentUser.uid,
    items: cartItems,
    total: 99.99,
    createdAt: new Date()
});

// Realtime listener (updates UI automatically)
onSnapshot(collection(db, 'orders'), (snapshot) => {
    snapshot.forEach(doc => console.log(doc.data()));
});

9. Serverless vs Containers

Decision Matrix

Hybrid Approach

Many systems use both:

• Lambda: API Gateway endpoints, event processing, short tasks
• ECS/Fargate: Long-running services, stateful apps, background workers
• Example: Lambda handles API requests, publishes to SQS; Fargate workers process queue (video transcoding, ETL)

10. Cost Analysis

Lambda Pricing Model (AWS, us-east-1)

• Requests: $0.20 per 1M requests
• Compute (GB-seconds): $0.0000166667 per GB-second
• Provisioned Concurrency: $0.0000041667 per GB-second (~$0.015/hour per GB)
• Free Tier: 1M requests + 400,000 GB-seconds per month (permanent)

Cost Example: REST API

Scenario: 1 million requests/month, 1 GB memory, 200ms avg execution

# Lambda (on-demand)
Requests: 1M * $0.20 / 1M = $0.20
Compute: 1M * 0.2s * 1GB * $0.0000166667 = $3.33
Total: $3.53/month

# EC2 t3.small (always-on)
Instance cost: $0.0208/hour * 730 hours = $15.18/month

# Break-even: ~4M requests/month (at 200ms, 1GB)

Cost Comparison Table

Provisioned Concurrency Cost

# Keep 10 instances warm (1 GB each, 24/7)
Provisioned cost: 10 * 1GB * 730 hours * $0.015 = $109.50/month

# On-demand compute still charged for execution time
Execution cost: (same as on-demand)

# Total: $109.50 + execution cost

When to use: Latency-critical APIs with unpredictable traffic (cold starts unacceptable, but don't want always-on VMs). Often cheaper than EC2 if traffic is still bursty.

Cost Optimization Strategies

1. Right-Size Memory: Test different memory settings (CPU scales with memory). Higher memory may be cheaper if faster execution offsets cost.
2. Batch Processing: Process SQS/Kinesis in batches (10-100 records) to amortize invocation cost.
3. Connection Pooling: Reuse DB connections across warm invocations (avoid reconnection overhead).
4. Reduce Package Size: Smaller deployments = faster cold starts = lower init cost.
5. Use Lambda Layers: Share dependencies across functions (reduce redundant uploads, faster deploys).
6. Monitor with Cost Explorer: Track Lambda cost by function, identify expensive outliers.
7. Shift to Containers: At high sustained traffic (10M+ req/month), ECS/Fargate often cheaper.