Lesson 23-Serverless Performance Optimization – TianyaSchool – Science, Technology & Engineering Learning Platform

Function Performance Optimization

Cold Start Optimization

Cold Start Root Causes:

Virtual machine/container initialization
Runtime environment loading
Dependency package loading
Initialization code execution

Optimization Strategies:

(1) Warm-Up Mechanism

# serverless.yml configuration example
provider:
  reservedConcurrency: 5 # Reserved concurrent instances
  provisionedConcurrency: 3 # Pre-warmed instances (AWS-specific)

# serverless.yml configuration example
provider:
  reservedConcurrency: 5 # Reserved concurrent instances
  provisionedConcurrency: 3 # Pre-warmed instances (AWS-specific)

Warm-Up Implementation:

# Scheduled trigger configuration (runs every 5 minutes to keep active)
functions:
  warmer:
    handler: handler.warmer
    events:
      - schedule: rate(5 minutes)

# Scheduled trigger configuration (runs every 5 minutes to keep active)
functions:
  warmer:
    handler: handler.warmer
    events:
      - schedule: rate(5 minutes)

Optimization Effect Comparison:

Metric	Without Warm-Up	With Warm-Up
Cold Start Time	800ms-2s	150-300ms
Success Rate	95%	99.9%
Resource Cost	Low	20-30% Higher

(2) Initialization Optimization

// Before optimization (reloads on every cold start)
const heavyLib = require('heavy-library');

exports.handler = async (event) => {
  // ...
};

// After optimization (global variable caching)
let heavyLib;
exports.handler = async (event) => {
  if (!heavyLib) {
    heavyLib = require('heavy-library');
  }
  // ...
};

// Before optimization (reloads on every cold start)
const heavyLib = require('heavy-library');

exports.handler = async (event) => {
  // ...
};

// After optimization (global variable caching)
let heavyLib;
exports.handler = async (event) => {
  if (!heavyLib) {
    heavyLib = require('heavy-library');
  }
  // ...
};

Initialization Optimization Techniques:

Lazy-load non-essential dependencies
Use singleton pattern to cache resources
Minimize global variable initialization

Execution Time Optimization

Performance Analysis Tools:

AWS X-Ray
Google Cloud Trace
Azure Application Insights

Optimization Techniques:

(1) Asynchronous Processing

// Synchronous processing (blocking)
exports.handler = async (event) => {
  const data = await fetchData();
  const result = processData(data);
  return sendResponse(result);
};

// Asynchronous processing (non-blocking)
exports.handler = async (event) => {
  const dataPromise = fetchData();
  const resultPromise = dataPromise.then(processData);
  
  // Can execute other tasks in parallel
  const otherTask = doOtherWork();
  
  return resultPromise.then(sendResponse);
};

// Synchronous processing (blocking)
exports.handler = async (event) => {
  const data = await fetchData();
  const result = processData(data);
  return sendResponse(result);
};

// Asynchronous processing (non-blocking)
exports.handler = async (event) => {
  const dataPromise = fetchData();
  const resultPromise = dataPromise.then(processData);
  
  // Can execute other tasks in parallel
  const otherTask = doOtherWork();
  
  return resultPromise.then(sendResponse);
};

(2) Batch Processing Optimization

// Single-record processing (inefficient)
exports.handler = async (event) => {
  for (const record of event.Records) {
    await processRecord(record);
  }
};

// Batch processing (efficient)
exports.handler = async (event) => {
  const batch = event.Records.map(processRecord);
  await Promise.all(batch);
};

// Single-record processing (inefficient)
exports.handler = async (event) => {
  for (const record of event.Records) {
    await processRecord(record);
  }
};

// Batch processing (efficient)
exports.handler = async (event) => {
  const batch = event.Records.map(processRecord);
  await Promise.all(batch);
};

Performance Comparison:

Scenario	Synchronous Processing	Asynchronous/Batch Processing
Processing Time	Linear growth	Near constant
Throughput	Low	High
Resource Utilization	Low	High

Memory and Performance Trade-Offs

Memory Configuration Impact:

Higher memory → Higher CPU allocation
Linear cost increase
Reduced execution time

Optimization Strategies:

(1) Memory Configuration Testing

# Test execution time under different memory configurations
for mem in 128 256 512 1024; do
  serverless deploy --memory-size $mem --stage test
  serverless invoke --function testFunc --stage test
done

# Test execution time under different memory configurations
for mem in 128 256 512 1024; do
  serverless deploy --memory-size $mem --stage test
  serverless invoke --function testFunc --stage test
done

Test Results Example:

Memory (MB)	Execution Time (ms)	Cost (per million invocations)
128	450	$1.20
256	320	$2.40
512	200	$4.80
1024	150	$9.60

Cost-Performance Sweet Spot: Typically around 512MB for optimal cost-performance balance

(2) Memory-Sensitive Optimization

// Before optimization (memory-intensive operation)
function processData(data) {
  const bigArray = new Array(1000000).fill(0);
  // ...
}

// After optimization (stream processing)
async function processData(data) {
  for await (const chunk of dataStream) {
    // Process small chunks of data
  }
}

// Before optimization (memory-intensive operation)
function processData(data) {
  const bigArray = new Array(1000000).fill(0);
  // ...
}

// After optimization (stream processing)
async function processData(data) {
  for await (const chunk of dataStream) {
    // Process small chunks of data
  }
}

Data Access Optimization

Database Connection Pooling

Traditional Connection Issues:

Creating new connections per invocation (high latency)
Connection limits (database bottleneck)

Optimization Solutions:

(1) External Connection Pool Service

# Use external Redis as a connection pool proxy
functions:
  dbHandler:
    handler: handler.dbHandler
    environment:
      DB_POOL_URL: redis://pool-service:6379

# Use external Redis as a connection pool proxy
functions:
  dbHandler:
    handler: handler.dbHandler
    environment:
      DB_POOL_URL: redis://pool-service:6379

(2) Persistent Connections

// Use global variable to maintain connection (only for long-running functions)
let dbConnection;

exports.handler = async (event) => {
  if (!dbConnection) {
    dbConnection = await createDBConnection();
  }
  return await dbConnection.query(event.query);
};

// Use global variable to maintain connection (only for long-running functions)
let dbConnection;

exports.handler = async (event) => {
  if (!dbConnection) {
    dbConnection = await createDBConnection();
  }
  return await dbConnection.query(event.query);
};

Note: Use persistent connections cautiously in Serverless environments, considering timeouts and reconnection mechanisms.

Caching Strategies

Caching Layers:

In-Memory Cache: Function-level variables
Local Cache: Redis/Memcached
Distributed Cache: Cloud provider cache services

Implementation Example:

// Redis cache implementation
const redis = require('redis');
const client = redis.createClient();

exports.handler = async (event) => {
  const cacheKey = `cache:${event.id}`;
  
  // Try to get from cache
  const cached = await client.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }
  
  // Cache miss, query database
  const data = await queryDatabase(event.id);
  
  // Set cache with expiration
  await client.set(cacheKey, JSON.stringify(data), 'EX', 3600);
  
  return data;
};

// Redis cache implementation
const redis = require('redis');
const client = redis.createClient();

exports.handler = async (event) => {
  const cacheKey = `cache:${event.id}`;
  
  // Try to get from cache
  const cached = await client.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }
  
  // Cache miss, query database
  const data = await queryDatabase(event.id);
  
  // Set cache with expiration
  await client.set(cacheKey, JSON.stringify(data), 'EX', 3600);
  
  return data;
};

Cache Strategy Selection:

Strategy	Use Case	Advantages	Disadvantages
Cache-Aside	Read-heavy, write-light	Simple	Risk of cache inconsistency
Write-Through	Write-heavy	High data consistency	Higher write latency
TTL Expiration	Infrequent data changes	Automatic updates	Potential for stale data

Data Prefetching and Batch Processing

Prefetching Optimization:

// Preload potentially needed data
exports.handler = async (event) => {
  // Prefetch related data
  const [mainData, relatedData] = await Promise.all([
    fetchMainData(event.id),
    fetchRelatedData(event.id) // Preload
  ]);
  
  // Processing logic
};

// Preload potentially needed data
exports.handler = async (event) => {
  // Prefetch related data
  const [mainData, relatedData] = await Promise.all([
    fetchMainData(event.id),
    fetchRelatedData(event.id) // Preload
  ]);
  
  // Processing logic
};

Batch Processing Implementation:

// Batch insert instead of single inserts
async function batchInsert(items) {
  const chunkSize = 100; // Adjust based on database limits
  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    await db.batchInsert(chunk);
  }
}

// Batch insert instead of single inserts
async function batchInsert(items) {
  const chunkSize = 100; // Adjust based on database limits
  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    await db.batchInsert(chunk);
  }
}

Performance Comparison:

Operation Type	Single Processing	Batch Processing
Database Calls	N times	1 time
Total Time	N×t	~t
Cost	N×c	~c

Network Optimization

HTTP/2 and Serverless

HTTP/2 Advantages:

Multiplexing (reduces connection overhead)
Header compression (lowers bandwidth)
Server push (preloads resources)

Implementation:

# API Gateway configuration (requires custom domain + CloudFront)
resources:
  Resources:
    ApiGatewayHttp2:
      Type: AWS::ApiGateway::RestApi
      Properties:
        Name: Http2Api
        EndpointConfiguration:
          Types:
            - REGIONAL
        ApiKeySourceType: HEADER

# API Gateway configuration (requires custom domain + CloudFront)
resources:
  Resources:
    ApiGatewayHttp2:
      Type: AWS::ApiGateway::RestApi
      Properties:
        Name: Http2Api
        EndpointConfiguration:
          Types:
            - REGIONAL
        ApiKeySourceType: HEADER

Performance Comparison:

Metric	HTTP/1.1	HTTP/2
Connection Setup Time	High (new connection per request)	Low (connection reuse)
Header Overhead	High (uncompressed)	Low (HPACK compression)
Concurrency	Low (serial)	High (multiplexing)

CDN and Edge Computing

CDN Configuration Example:

# CloudFront distribution configuration
resources:
  Resources:
    CloudFrontDistribution:
      Type: AWS::CloudFront::Distribution
      Properties:
        DistributionConfig:
          Origins:
            - DomainName: api.example.com
              Id: ApiOrigin
              CustomOriginConfig:
                HTTPPort: 80
                HTTPSPort: 443
                OriginProtocolPolicy: https-only
          Enabled: true
          DefaultCacheBehavior:
            TargetOriginId: ApiOrigin
            ViewerProtocolPolicy: redirect-to-https
            MinTTL: 0
            MaxTTL: 31536000
            DefaultTTL: 86400

# CloudFront distribution configuration
resources:
  Resources:
    CloudFrontDistribution:
      Type: AWS::CloudFront::Distribution
      Properties:
        DistributionConfig:
          Origins:
            - DomainName: api.example.com
              Id: ApiOrigin
              CustomOriginConfig:
                HTTPPort: 80
                HTTPSPort: 443
                OriginProtocolPolicy: https-only
          Enabled: true
          DefaultCacheBehavior:
            TargetOriginId: ApiOrigin
            ViewerProtocolPolicy: redirect-to-https
            MinTTL: 0
            MaxTTL: 31536000
            DefaultTTL: 86400

Edge Computing Implementation:

// Lambda@Edge example (modifying request headers)
exports.handler = async (event) => {
  const request = event.Records[0].cf.request;
  
  // Add security headers
  request.headers['strict-transport-security'] = [
    { key: 'Strict-Transport-Security', value: 'max-age=63072000' }
  ];
  
  return request;
};

// Lambda@Edge example (modifying request headers)
exports.handler = async (event) => {
  const request = event.Records[0].cf.request;
  
  // Add security headers
  request.headers['strict-transport-security'] = [
    { key: 'Strict-Transport-Security', value: 'max-age=63072000' }
  ];
  
  return request;
};

Performance Improvements:

Time to First Byte (TTFB): Reduced by 50-80%
Throughput: Increased by 2-5x
Latency: Reduced by 300-800ms on average for global users

Request Compression and Optimization

Compression Configuration:

# API Gateway response compression
provider:
  apiGateway:
    binaryMediaTypes:
      - '*/*'
    minimumCompressionSize: 0 # Force compression for all responses

# API Gateway response compression
provider:
  apiGateway:
    binaryMediaTypes:
      - '*/*'
    minimumCompressionSize: 0 # Force compression for all responses

Client Optimization:

// Request header setup (automatic compression negotiation)
fetch('/api/data', {
  headers: {
    'Accept-Encoding': 'gzip, deflate, br'
  }
});

// Request header setup (automatic compression negotiation)
fetch('/api/data', {
  headers: {
    'Accept-Encoding': 'gzip, deflate, br'
  }
});

Compression Algorithm Comparison:

Algorithm	Compression Ratio	CPU Usage	Use Case
Gzip	High	Medium	General
Brotli	Highest	High	Modern browsers
Zstandard	High	Low	Real-time applications

Performance Data:

Gzip: ~70% text compression, 10-20% CPU increase
Brotli: ~80% text compression, 20-30% CPU increase
No Compression: Original size, zero CPU overhead

Comprehensive Optimization Strategies

Performance Monitoring and Tuning

Monitoring Metrics:

Cold start frequency
Execution time distribution
Error rate
Resource utilization

Toolchain:

# Monitoring configuration example
provider:
  tracing:
    apiGateway: true
    lambda: true

resources:
  Resources:
    CloudWatchAlarm:
      Type: AWS::CloudWatch::Alarm
      Properties:
        MetricName: Errors
        Namespace: AWS/Lambda
        Statistic: Sum
        Period: 60
        EvaluationPeriods: 1
        Threshold: 5
        ComparisonOperator: GreaterThanOrEqualToThreshold

# Monitoring configuration example
provider:
  tracing:
    apiGateway: true
    lambda: true

resources:
  Resources:
    CloudWatchAlarm:
      Type: AWS::CloudWatch::Alarm
      Properties:
        MetricName: Errors
        Namespace: AWS/Lambda
        Statistic: Sum
        Period: 60
        EvaluationPeriods: 1
        Threshold: 5
        ComparisonOperator: GreaterThanOrEqualToThreshold

Cost and Performance Balance

Cost Model:

Total Cost = Compute Cost + Storage Cost + Network Cost + Other Service Costs

Total Cost = Compute Cost + Storage Cost + Network Cost + Other Service Costs

Optimization Suggestions:

Compute Cost:
- Set reasonable memory (512MB is typically the sweet spot)
- Use Provisioned Concurrency to trade cost for performance
Storage Cost:
- Use Redis for hot data
- Use S3 Glacier for cold data
Network Cost:
- Set appropriate TTL to reduce cache invalidation
- Compress data to reduce transfer volume

Security Optimization

Security Practices:

// Input validation middleware
function validateInput(event) {
  if (!event.pathParameters || !event.pathParameters.id) {
    throw new Error('Invalid input');
  }
  
  // Additional validation logic...
}

exports.handler = async (event) => {
  try {
    validateInput(event);
    // Processing logic...
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: error.message })
    };
  }
};

// Input validation middleware
function validateInput(event) {
  if (!event.pathParameters || !event.pathParameters.id) {
    throw new Error('Invalid input');
  }
  
  // Additional validation logic...
}

exports.handler = async (event) => {
  try {
    validateInput(event);
    // Processing logic...
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: error.message })
    };
  }
};

Security Enhancements:

API Protection:
- Use AWS WAF to filter malicious requests
- Enable CORS to restrict origins
Data Protection:
- Encrypt sensitive data in transit (TLS)
- Encrypt stored data (KMS)
Access Control:
- Use least-privilege IAM roles
- Implement resource-level permission policies

Course: Micro Frontends & Serverless: Modular Web Development

Function Performance Optimization

Cold Start Optimization

(1) Warm-Up Mechanism

(2) Initialization Optimization

Execution Time Optimization

(1) Asynchronous Processing

(2) Batch Processing Optimization

Memory and Performance Trade-Offs

(1) Memory Configuration Testing

(2) Memory-Sensitive Optimization

Data Access Optimization

Database Connection Pooling

(1) External Connection Pool Service

(2) Persistent Connections

Caching Strategies

Data Prefetching and Batch Processing

Network Optimization

HTTP/2 and Serverless

CDN and Edge Computing

Request Compression and Optimization

Comprehensive Optimization Strategies

Performance Monitoring and Tuning

Cost and Performance Balance

Security Optimization

Trending now