Serverless Computing Principles

Evolution of Infrastructure Management

Cost Comparison Example: API with 1M Requests/Month

Stateless Architecture Example

// AWS Lambda function handling user authentication
exports.handler = async (event) => {
  console.log('Received event:', JSON.stringify(event, null, 2));
  
  // Don't rely on variables outside the handler function
  // They might be initialized between invocations, but there's no guarantee
  
  // Don't store state in the filesystem
  // Any files you create might not be available in subsequent invocations
  
  // Instead, use external services for state
  const userId = event.userId;
  
  // Get user data from database (external state)
  const user = await getUserFromDatabase(userId);
  
  // Authenticate user
  const isAuthenticated = verifyCredentials(user, event.credentials);
  
  // Store authentication result in external service if needed
  if (isAuthenticated) {
    await storeAuthToken(userId, generateToken());
  }
  
  return {
    statusCode: isAuthenticated ? 200 : 401,
    body: JSON.stringify({
      authenticated: isAuthenticated,
      message: isAuthenticated ? 'Authentication successful' : 'Authentication failed'
    })
  };
};
        

Monolith vs. Microservices vs. Functions

BaaS Integration Example

// Using Firebase Authentication and Firestore
import { initializeApp } from 'firebase/app';
import { getAuth, signInWithEmailAndPassword } from 'firebase/auth';
import { getFirestore, collection, addDoc } from 'firebase/firestore';

// Initialize Firebase
const firebaseConfig = {
  apiKey: "your-api-key",
  authDomain: "your-project.firebaseapp.com",
  projectId: "your-project",
  storageBucket: "your-project.appspot.com",
  messagingSenderId: "your-messaging-id",
  appId: "your-app-id"
};

const app = initializeApp(firebaseConfig);
const auth = getAuth(app);
const db = getFirestore(app);

// Authentication
async function loginUser(email, password) {
  try {
    const userCredential = await signInWithEmailAndPassword(auth, email, password);
    return userCredential.user;
  } catch (error) {
    console.error('Authentication error:', error);
    throw error;
  }
}

// Database operation
async function createOrder(userId, orderData) {
  try {
    const docRef = await addDoc(collection(db, "orders"), {
      userId: userId,
      items: orderData.items,
      total: orderData.total,
      timestamp: new Date()
    });
    console.log("Order created with ID: ", docRef.id);
    return docRef.id;
  } catch (error) {
    console.error("Error adding order: ", error);
    throw error;
  }
}
        

Operational Tasks Comparison

Real-World Scaling Example: Black Friday Sale

An e-commerce company using serverless architecture for their Black Friday sale:

• Normal traffic: 100 requests/second
• Sale period peak: 5,000 requests/second
• With traditional architecture: Would need to provision 50x capacity weeks in advance
• With serverless: Functions automatically scale up within seconds of traffic increase
• Cost efficiency: Only paying for the actual compute used during the peak, not for the entire month

Cold Start Mitigation Techniques

• Keep functions warm: Schedule periodic pings to prevent idle timeout
• Optimize function size: Smaller dependencies and code lead to faster initialization
• Use provisioned concurrency: Pre-warm function instances (AWS Lambda)
• Optimize language choice: Languages with faster startup times (Node.js vs Java)
• Separate latency-sensitive functions: Use different functions for critical vs. non-critical paths

State Management Approaches

// Example of state management with Redis in AWS Lambda
const Redis = require('ioredis');

// Initialize Redis client
let redisClient;

exports.handler = async (event) => {
  // Reuse Redis connection if it exists
  if (!redisClient) {
    console.log('Creating new Redis connection');
    redisClient = new Redis({
      host: process.env.REDIS_HOST,
      port: process.env.REDIS_PORT,
      password: process.env.REDIS_PASSWORD
    });
  }
  
  const sessionId = event.headers.sessionId;
  
  // Step 1: Retrieve state from external store
  let sessionData;
  try {
    const sessionJson = await redisClient.get(`session:${sessionId}`);
    sessionData = sessionJson ? JSON.parse(sessionJson) : { visits: 0 };
  } catch (error) {
    console.error('Error retrieving session data:', error);
    sessionData = { visits: 0 };
  }
  
  // Step 2: Update state
  sessionData.visits += 1;
  sessionData.lastVisit = new Date().toISOString();
  
  // Step 3: Store updated state
  try {
    await redisClient.set(`session:${sessionId}`, JSON.stringify(sessionData), 'EX', 3600); // Expire in 1 hour
  } catch (error) {
    console.error('Error storing session data:', error);
  }
  
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Welcome back! Visit count: ${sessionData.visits}`,
      lastVisit: sessionData.visits > 1 ? sessionData.lastVisit : null
    })
  };
};
        

Local Testing Tools

• AWS SAM CLI: Local testing for AWS Lambda functions
• Serverless Framework: Cross-platform local invocation
• LocalStack: AWS cloud service emulator
• Azure Functions Core Tools: Local Azure Functions runtime
• Firebase Emulator Suite: Local Firebase services

Reducing Vendor Lock-in

• Use abstraction layers: Tools like Serverless Framework provide cross-provider compatibility
• Hexagonal architecture: Separate core business logic from provider-specific code
• Dependency injection: Abstract cloud services behind interfaces
• Open standards: Use CloudEvents for event standardization
• Infrastructure as Code: Use IaC tools with multi-cloud support

Serverless REST API Example with AWS SAM

# AWS SAM template for a serverless API
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  # API Gateway
  ProductsApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: prod
      Cors:
        AllowOrigin: "'*'"
        AllowMethods: "'GET,POST,PUT,DELETE'"
        AllowHeaders: "'Content-Type,Authorization'"

  # Lambda Functions
  GetProductsFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src/
      Handler: getProducts.handler
      Runtime: nodejs16.x
      Events:
        GetProducts:
          Type: Api
          Properties:
            RestApiId: !Ref ProductsApi
            Path: /products
            Method: get

  GetProductFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src/
      Handler: getProduct.handler
      Runtime: nodejs16.x
      Events:
        GetProduct:
          Type: Api
          Properties:
            RestApiId: !Ref ProductsApi
            Path: /products/{id}
            Method: get

  CreateProductFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src/
      Handler: createProduct.handler
      Runtime: nodejs16.x
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref ProductsTable
      Events:
        CreateProduct:
          Type: Api
          Properties:
            RestApiId: !Ref ProductsApi
            Path: /products
            Method: post

  # DynamoDB Table
  ProductsTable:
    Type: AWS::Serverless::SimpleTable
    Properties:
      PrimaryKey:
        Name: id
        Type: String
      ProvisionedThroughput:
        ReadCapacityUnits: 5
        WriteCapacityUnits: 5

Outputs:
  ApiEndpoint:
    Description: "API Gateway endpoint URL"
    Value: !Sub "https://${ProductsApi}.execute-api.${AWS::Region}.amazonaws.com/prod/"
        

Image Processing Pipeline

Scheduled Task Example with AWS EventBridge

# CloudFormation template for a scheduled task
Resources:
  ScheduledFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src/
      Handler: dailyReport.handler
      Runtime: nodejs16.x
      Events:
        DailyReport:
          Type: Schedule
          Properties:
            Schedule: cron(0 8 * * ? *)  # Run at 8 AM UTC every day
            Description: "Generate daily sales report"
            Enabled: true
      Environment:
        Variables:
          DATABASE_URL: !Ref DatabaseUrl
          REPORT_BUCKET: !Ref ReportBucket
          
  ReportBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub "${AWS::StackName}-reports"
        

Function Composition with AWS Step Functions

{
  "Comment": "Order processing workflow",
  "StartAt": "ValidateOrder",
  "States": {
    "ValidateOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ValidateOrder",
      "Next": "CheckInventory",
      "Catch": [
        {
          "ErrorEquals": ["ValidationError"],
          "Next": "OrderRejected"
        }
      ]
    },
    "CheckInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:CheckInventory",
      "Next": "ProcessPayment",
      "Catch": [
        {
          "ErrorEquals": ["OutOfStockError"],
          "Next": "OrderRejected"
        }
      ]
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ProcessPayment",
      "Next": "CreateOrder",
      "Catch": [
        {
          "ErrorEquals": ["PaymentFailedError"],
          "Next": "OrderRejected"
        }
      ]
    },
    "CreateOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:CreateOrder",
      "Next": "NotifyCustomer"
    },
    "NotifyCustomer": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:NotifyCustomer",
      "End": true
    },
    "OrderRejected": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HandleRejection",
      "End": true
    }
  }
}
        

Saga Pattern Implementation

Starting Point: User Authentication Flow