Lesson 19-Serverless Architecture Components – TianyaSchool – Science, Technology & Engineering Learning Platform

Function Compute

Function Lifecycle

Function Lifecycle Stages:

Creation Stage:
- Code upload and deployment
- Dependency installation and packaging
- Execution environment configuration
Initialization Stage:
- Initialize execution environment during cold start
- Load dependency libraries
- Initialize global state (e.g., database connections)
Execution Stage:
- Receive event trigger
- Execute function logic
- Return response result
Termination Stage:
- Resource reclamation
- Connection closure
- Log upload

Lifecycle Management Example (AWS Lambda):

# serverless.yml configuration example
functions:
  myFunction:
    handler: handler.main
    timeout: 30 # Execution timeout (seconds)
    memorySize: 512 # Memory allocation (MB)
    reservedConcurrency: 10 # Reserved concurrency
    provisionedConcurrency: 5 # Pre-warmed instances

# serverless.yml configuration example
functions:
  myFunction:
    handler: handler.main
    timeout: 30 # Execution timeout (seconds)
    memorySize: 512 # Memory allocation (MB)
    reservedConcurrency: 10 # Reserved concurrency
    provisionedConcurrency: 5 # Pre-warmed instances

Cold Start and Hot Caching

Cold Start Process:

Virtual machine/container initialization
Runtime environment loading
Dependency package installation/loading
Function code initialization

Hot Caching Mechanism:

Memory Caching: Use /tmp directory (e.g., AWS Lambda) to cache data
Connection Pooling: Pre-establish database connections
Provisioned Concurrency: Keep active instances to reduce cold starts

Optimization Strategy:

// Node.js cold start optimization example
let cachedData = null;

exports.handler = async (event) => {
  // Check cache
  if (!cachedData) {
    cachedData = await loadData(); // Load on first invocation
  }
  
  // Use cached data
  return processEvent(event, cachedData);
};

// Node.js cold start optimization example
let cachedData = null;

exports.handler = async (event) => {
  // Check cache
  if (!cachedData) {
    cachedData = await loadData(); // Load on first invocation
  }
  
  // Use cached data
  return processEvent(event, cachedData);
};

Performance Comparison:

Metric	Cold Start	Hot Execution
Latency	500ms-2s	10-50ms
Resource Usage	High (init overhead)	Low
Use Case	Infrequent calls	Frequent calls

Function Execution Limits

Common Limits:

Limit Type	AWS Lambda	Azure Functions	Google Cloud Functions
Memory	128MB-10GB	128MB-3.75GB	128MB-8GB
Execution Time	15 minutes	60 minutes	9 minutes
Concurrent Executions	1000 (default)	100-1000 (configurable)	No hard limit
Request Size	6MB (sync)/256KB (async)	100MB	10MB
Environment Variables	4KB	4KB	4KB

Workarounds for Limits:

Large File Processing: Use S3 chunked uploads
Long-Running Tasks: Split into multiple short-lived functions
State Management: Use external storage (e.g., DynamoDB)

Event-Driven Architecture

Event Source Types

Primary Event Sources:

Event Source	Description	Typical Use Cases
SQS	Message queue	Async task processing, service decoupling
SNS	Publish-subscribe	Notification broadcast, event distribution
DynamoDB	Database changes	Real-time data synchronization
Kinesis	Streaming data	Real-time data processing
EventBridge	Event bus	Cross-service event routing

Configuration Example (AWS Lambda Trigger):

functions:
  processOrder:
    handler: handler.processOrder
    events:
      - sqs:
          arn: arn:aws:sqs:us-east-1:123456789012:orders-queue
          batchSize: 10
          maximumBatchingWindow: 30 # Batch window (seconds)

functions:
  processOrder:
    handler: handler.processOrder
    events:
      - sqs:
          arn: arn:aws:sqs:us-east-1:123456789012:orders-queue
          batchSize: 10
          maximumBatchingWindow: 30 # Batch window (seconds)

Event Processing Flow

Typical Processing Flow:

Event Source → Event Bus/Queue → Trigger → Lambda Function → [Downstream Services]

Event Source → Event Bus/Queue → Trigger → Lambda Function → [Downstream Services]

Error Handling Flow:

Event Processing Failure → Dead Letter Queue (DLQ) → Retry Strategy → Manual Intervention

Event Processing Failure → Dead Letter Queue (DLQ) → Retry Strategy → Manual Intervention

Processing Modes:

Synchronous Processing: Returns result immediately
Asynchronous Processing: Delays processing via SQS/Kinesis
Batch Processing: Aggregates multiple events before processing

Event Retry and Error Handling

Retry Strategies:

Strategy	Description	Use Case
Exponential Backoff	Increasing delay between retries	Unstable network
Fixed Interval	Fixed time between retries	Predictable failures
Dead Letter Queue	Failed events sent to DLQ	Requires manual intervention

Configuration Example (SQS Trigger Retry):

functions:
  retryHandler:
    handler: handler.retryHandler
    events:
      - sqs:
          arn: arn:aws:sqs:us-east-1:123456789012:retry-queue
          batchSize: 5
          maximumBatchingWindow: 60
          maxReceiveCount: 3 # Retry attempts before Lambda invocation

functions:
  retryHandler:
    handler: handler.retryHandler
    events:
      - sqs:
          arn: arn:aws:sqs:us-east-1:123456789012:retry-queue
          batchSize: 5
          maximumBatchingWindow: 60
          maxReceiveCount: 3 # Retry attempts before Lambda invocation

Custom Error Handling:

exports.handler = async (event) => {
  try {
    return await processEvent(event);
  } catch (error) {
    console.error('Processing failed:', error);
    
    // Custom error handling
    if (shouldRetry(error)) {
      throw error; // Trigger retry
    } else {
      await sendToDLQ(event); // Send to dead letter queue
      return { status: 'failed', error: error.message };
    }
  }
};

exports.handler = async (event) => {
  try {
    return await processEvent(event);
  } catch (error) {
    console.error('Processing failed:', error);
    
    // Custom error handling
    if (shouldRetry(error)) {
      throw error; // Trigger retry
    } else {
      await sendToDLQ(event); // Send to dead letter queue
      return { status: 'failed', error: error.message };
    }
  }
};

Data Storage and Services

Serverless Databases

Primary Options:

Database	Type	Features	Use Cases
DynamoDB	NoSQL	Fully managed, auto-scaling, low latency	High-frequency read/write, key-value/document storage
FaunaDB	NoSQL	Globally distributed, serverless, GraphQL support	Real-time apps, complex queries
Aurora Serverless	Relational	Auto-scaling, MySQL/PostgreSQL compatible	Complex transactions, relational data

DynamoDB Configuration Example:

resources:
  Resources:
    OrdersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: Orders
        AttributeDefinitions:
          - AttributeName: orderId
            AttributeType: S
        KeySchema:
          - AttributeName: orderId
            KeyType: HASH
        BillingMode: PAY_PER_REQUEST

resources:
  Resources:
    OrdersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: Orders
        AttributeDefinitions:
          - AttributeName: orderId
            AttributeType: S
        KeySchema:
          - AttributeName: orderId
            KeyType: HASH
        BillingMode: PAY_PER_REQUEST

Object Storage

Primary Services:

Service	Features	Typical Use Cases
S3	High durability, versioning, lifecycle management	Static files, backups, big data analytics
Azure Blob Storage	Tiered storage, CDN integration	Media files, document storage
GCS	High throughput, global replication	Big data analytics, ML datasets

S3 Configuration Example:

resources:
  Resources:
    MediaBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: ${self:service}-${self:provider.stage}-media
        AccessControl: PublicRead
        VersioningConfiguration:
          Status: Enabled
        LifecycleConfiguration:
          Rules:
            - Id: ExpireOldVersions
              Status: Enabled
              NoncurrentVersionExpirationInDays: 30

resources:
  Resources:
    MediaBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: ${self:service}-${self:provider.stage}-media
        AccessControl: PublicRead
        VersioningConfiguration:
          Status: Enabled
        LifecycleConfiguration:
          Rules:
            - Id: ExpireOldVersions
              Status: Enabled
              NoncurrentVersionExpirationInDays: 30

Frontend Integration Example:

// Upload file to S3 using AWS SDK
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

const s3 = new S3Client({ region: 'us-east-1' });

async function uploadFile(file) {
  const params = {
    Bucket: 'my-media-bucket',
    Key: file.name,
    Body: file,
    ContentType: file.type
  };
  
  await s3.send(new PutObjectCommand(params));
}

// Upload file to S3 using AWS SDK
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

const s3 = new S3Client({ region: 'us-east-1' });

async function uploadFile(file) {
  const params = {
    Bucket: 'my-media-bucket',
    Key: file.name,
    Body: file,
    ContentType: file.type
  };
  
  await s3.send(new PutObjectCommand(params));
}

Message Queues and Stream Processing

Message Queue Services:

Service	Type	Features	Use Cases
SQS	Message Queue	Fully managed, FIFO support	Async task processing, service decoupling
Kinesis	Streaming Data	Real-time processing, high throughput	Log collection, real-time analytics
EventBridge	Event Bus	Cross-service routing	Event-driven architecture

Kinesis Configuration Example:

resources:
  Resources:
    OrderStream:
      Type: AWS::Kinesis::Stream
      Properties:
        Name: OrderStream
        ShardCount: 2

resources:
  Resources:
    OrderStream:
      Type: AWS::Kinesis::Stream
      Properties:
        Name: OrderStream
        ShardCount: 2

Stream Processing Function Example:

exports.handler = async (event) => {
  for (const record of event.Records) {
    const data = JSON.parse(Buffer.from(record.kinesis.data, 'base64').toString());
    console.log('Processing order:', data.orderId);
    
    // Process business logic...
  }
  
  return { statusCode: 200 };
};

exports.handler = async (event) => {
  for (const record of event.Records) {
    const data = JSON.parse(Buffer.from(record.kinesis.data, 'base64').toString());
    console.log('Processing order:', data.orderId);
    
    // Process business logic...
  }
  
  return { statusCode: 200 };
};

Message Routing Example (EventBridge):

resources:
  Resources:
    OrderEventBus:
      Type: AWS::Events::EventBus
      Properties:
        Name: OrderEventBus
    
    OrderRule:
      Type: AWS::Events::Rule
      Properties:
        EventBusName: OrderEventBus
        EventPattern:
          source:
            - "ecommerce.orders"
          detail-type:
            - "OrderCreated"
        Targets:
          - Arn: !Sub arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:processOrder
            Id: ProcessOrderFunction

resources:
  Resources:
    OrderEventBus:
      Type: AWS::Events::EventBus
      Properties:
        Name: OrderEventBus
    
    OrderRule:
      Type: AWS::Events::Rule
      Properties:
        EventBusName: OrderEventBus
        EventPattern:
          source:
            - "ecommerce.orders"
          detail-type:
            - "OrderCreated"
        Targets:
          - Arn: !Sub arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:processOrder
            Id: ProcessOrderFunction

omprehensive Practice Recommendations

Performance Optimization:
- Set appropriate memory configuration (affects CPU allocation)
- Use Provisioned Concurrency for pre-warmed instances
- Optimize cold start time (reduce dependencies, use lightweight runtimes)
Cost Control:
- Monitor and optimize execution time
- Set reasonable timeout durations
- Use reserved concurrency to control costs
Security Practices:
- Configure IAM roles with least privilege principles
- Use Secrets Manager for sensitive data
- Enable VPC to isolate sensitive resources
Monitoring and Operations:
- Configure CloudWatch alarms
- Implement structured logging
- Establish automated alerting mechanisms
Architecture Design:
- Prioritize event-driven design
- Design stateless functions
- Maintain loosely coupled service boundaries

By effectively combining these components and services, you can build high-performance, highly available Serverless applications. Start with simple scenarios, gradually expand to complex functionalities, and continuously refine architecture design.

Course: Micro Frontends & Serverless: Modular Web Development