FaaS — Function as a Service Explained

In this tutorial, you will learn about FaaS. We cover key concepts, practical examples, and best practices to help you master this topic.

Function as a Service (FaaS) is the core execution model of serverless computing where you deploy individual functions that run in response to events and scale automatically.

What You'll Learn

By the end of this lesson you will understand what FaaS is, how functions are invoked, the lifecycle of a function invocation, and how FaaS compares to other cloud service models.

Why It Matters

FaaS abstracts all infrastructure concerns so you focus purely on business logic. No operating systems, no runtime management, no scaling configuration. You write a function, define its trigger, and the platform handles the rest.

Real-World Use

An e-commerce site processes new orders through a FaaS function that validates the order, charges the customer via Stripe, updates inventory in a database, and sends a confirmation email -- all triggered by a new row appearing in a database table.

flowchart LR
    W[Write Code] --> D[Deploy to FaaS]
    D --> T[Configure Trigger]
    T --> E[Event Arrives]
    E --> C[Container Created]
    C --> R[Code Executes]
    R --> S[Response]
    S --> I[Container Idle]
    I -->|Timeout| K[Container Destroyed]
    I -->|New Event| R
    style D fill:#f90,color:#fff

FaaS Lifecycle

When you deploy a function the platform stores your code. On first invocation the platform creates a container, downloads your code and dependencies, initializes the runtime, and executes your handler. The container stays warm for subsequent invocations for a period determined by the provider.

# faas_lifecycle.py
# Simulating the FaaS lifecycle

import time

def cold_start_simulation():
    """Simulate what happens during a cold start."""
    print("[Cold Start] Downloading function code...")
    time.sleep(0.5)
    print("[Cold Start] Installing dependencies...")
    time.sleep(0.3)
    print("[Cold Start] Initializing runtime...")
    time.sleep(0.2)
    print("[Cold Start] Executing handler...")
    return {"status": "warm"}

def warm_start_simulation():
    """Simulate a warm invocation."""
    print("[Warm Start] Executing handler immediately...")
    return {"status": "warm"}

print("--- First invocation (cold) ---")
cold_start_simulation()

print("\n--- Second invocation (warm) ---")
warm_start_simulation()

print("\n--- After idle timeout (cold again) ---")
cold_start_simulation()

Expected output:

--- First invocation (cold) ---
[Cold Start] Downloading function code...
[Cold Start] Installing dependencies...
[Cold Start] Initializing runtime...
[Cold Start] Executing handler...
--- Second invocation (warm) ---
[Warm Start] Executing handler immediately...
--- After idle timeout (cold again) ---
[Cold Start] Downloading function code...
[Cold Start] Installing dependencies...
[Cold Start] Initializing runtime...
[Cold Start] Executing handler...

FaaS Providers

AWS Lambda is the most mature FaaS platform supporting multiple languages with 15-minute timeout. Azure Functions integrates deeply with the Microsoft ecosystem. Google Cloud Functions excels at HTTP-triggered workloads.

# faas_providers.py
# Working with different FaaS provider patterns

def aws_lambda_handler(event, context):
    """AWS Lambda handler signature."""
    print(f"AWS Lambda invoked with event type: {type(event).__name__}")
    return {
        "statusCode": 200,
        "headers": {"Content-Type": "application/json"},
        "body": '{"message": "Hello from AWS Lambda"}'
    }

def azure_function_handler(req):
    """Azure Function handler signature."""
    name = req.params.get('name', 'World')
    return f"Hello {name} from Azure Functions"

def google_cloud_function_handler(request):
    """Google Cloud Function handler signature."""
    request_json = request.get_json(silent=True)
    name = request_json.get('name') if request_json else None
    return f"Hello {name or 'World'} from Google Cloud Functions"

# Test AWS Lambda
result = aws_lambda_handler({"key": "value"}, None)
print(f"AWS Result: {result}")

Expected output:

AWS Lambda invoked with event type: dict
AWS Result: {'statusCode': 200, 'headers': {'Content-Type': 'application/json'}, 'body': '{"message": "Hello from AWS Lambda"}'}

FaaS vs PaaS vs Containers

PaaS runs entire applications with auto-scaling but you still manage the application framework. Containers give you full control of the runtime environment. FaaS runs individual functions with the highest level of abstraction.

# deployment_comparison.py
# Comparing code deployment models

def faas_deployment():
    return "Upload function code. Set trigger. Done."

def paas_deployment():
    return "Configure app server. Set scaling rules. Deploy app artifact."

def container_deployment():
    return "Write Dockerfile. Build image. Configure orchestrator. Deploy."

models = {
    "FaaS": faas_deployment(),
    "PaaS": container_deployment(),
    "Containers": paas_deployment(),
}

for model, description in models.items():
    print(f"{model:12s} -> {description}")

Common Mistakes

1. Writing monolith functions: One function should do one thing. Avoid creating a single function that handles multiple unrelated concerns.

2. Ignoring deployment package size: Large deployments increase cold start time. Minimize dependencies and use layers for shared libraries.

3. Not using environment variables for configuration: Hardcoding configuration in code requires redeployment for changes.

4. Overlooking concurrent execution limits: Each FaaS platform has per-account concurrency limits. Without proper configuration your functions may throttle.

5. Missing error handling and retries: Failed invocations may not be retried automatically. Implement proper error handling and dead-letter queues.

Practice Questions

1. What is the difference between FaaS and PaaS? FaaS runs individual functions triggered by events. PaaS runs entire applications with a runtime environment you configure.

2. What happens during a cold start? The platform provisions a new container, downloads code and dependencies, initializes the runtime, then executes the handler.

3. Which FaaS provider has the longest execution timeout? AWS Lambda allows up to 15 minutes. Google Cloud Functions allows 9 minutes for HTTP and 60 for background functions.

4. How does FaaS handle concurrent requests? The platform creates new container instances per concurrent invocation, scaling up to account-level limits.

5. Challenge: Write a FaaS function that processes a CSV file from an HTTP upload, validates each row, stores valid rows in a database, and returns a summary of processed records.

FAQ

Mini Project

Create a FaaS-style function that accepts an array of numbers via HTTP POST, calculates the sum, average, min, and max, and returns the results.

import json

def stats_function(event, context):
    body = json.loads(event.get("body", "[]"))
    if not isinstance(body, list) or not body:
        return {"statusCode": 400, "body": json.dumps({"error": "Provide an array of numbers"})}
    
    numbers = [n for n in body if isinstance(n, (int, float))]
    result = {
        "count": len(numbers),
        "sum": sum(numbers),
        "average": sum(numbers) / len(numbers) if numbers else 0,
        "min": min(numbers) if numbers else None,
        "max": max(numbers) if numbers else None,
    }
    return {"statusCode": 200, "body": json.dumps(result)}

test_event = {"body": json.dumps([10, 20, 30, 40, 50])}
print(stats_function(test_event, None)["body"])

Expected output:

{"count": 5, "sum": 150, "average": 30.0, "min": 10, "max": 50}

What's Next

Next: Serverless vs Containers to understand when to choose each approach.