AWS Lambda Advanced Patterns and Cost Optimization: The Complete Production Guide

// Layer 1: Heavy, rarely-changing dependencies// /opt/nodejs/package.json in layer{  "dependencies": {    "@aws-sdk/client-dynamodb": "^3.400.0",    "datadog-lambda-js": "^8.67.0",    "pino": "^8.15.0"  }}
// Function code uses layer dependenciesimport { DynamoDBClient } from '@aws-sdk/client-dynamodb'; // From layerimport { datadogLambda } from 'datadog-lambda-js';  // From layerimport pino from 'pino';  // From layer
// Function-specific code (not in layer)import { validateUserInput } from './validation';  // Function-specificimport { processPayment } from './payment';  // Function-specific

// Non-VPC Lambda (accessing DynamoDB via internet)// Cold start: ~800ms (varies by region and load)// Warm execution: ~45ms// Cost: $0.0001 per 100ms
// VPC Lambda (accessing RDS in private subnet)// Cold start: ~12-15 seconds (ENI creation, varies significantly)// Warm execution: ~45ms (same)// Cost: $0.0001 per 100ms + VPC endpoint costs

// ENI optimization through function warmthconst keepWarmSchedule = new Rule(this, 'KeepVpcLambdaWarm', {  schedule: Schedule.rate(Duration.minutes(5)),  targets: [new LambdaFunction(vpcLambdaFunction, {    event: RuleTargetInput.fromObject({       source: 'keep-warm',      warmup: true     })  })]});
// Handler optimization for VPC functionsexport const handler = async (event: any) => {  // Handle warmup events  if (event.source === 'keep-warm') {    return { statusCode: 200, body: 'Staying warm' };  }    // Your actual logic  return processBusinessLogic(event);};

// Assume role pattern for cross-account accessimport { STSClient, AssumeRoleCommand } from '@aws-sdk/client-sts';
export class CrossAccountExecutor {  private stsClient: STSClient;    constructor() {    this.stsClient = new STSClient({});  }
  async executeInAccount(    accountId: string,     roleName: string,     action: () => Promise<any>  ) {    const roleArn = `arn:aws:iam::${accountId}:role/${roleName}`;        try {      const assumeRoleCommand = new AssumeRoleCommand({        RoleArn: roleArn,        RoleSessionName: `lambda-cross-account-${Date.now()}`,        DurationSeconds: 3600      });            const response = await this.stsClient.send(assumeRoleCommand);            // Create temporary credentials      const tempCredentials = {        accessKeyId: response.Credentials!.AccessKeyId!,        secretAccessKey: response.Credentials!.SecretAccessKey!,        sessionToken: response.Credentials!.SessionToken!      };            // Execute action with temporary credentials      return await action();          } catch (error) {      console.error(`Cross-account execution failed:`, error);      throw error;    }  }}

// Secure environment variable handlingexport class SecureConfig {  private static instance: SecureConfig;  private config: Map<string, string> = new Map();    private constructor() {    this.loadConfig();  }    public static getInstance(): SecureConfig {    if (!SecureConfig.instance) {      SecureConfig.instance = new SecureConfig();    }    return SecureConfig.instance;  }    private loadConfig() {    // Load from Parameter Store at runtime    const requiredParams = [      'DB_CONNECTION_STRING',      'API_KEY',      'JWT_SECRET'    ];        // Validate all required parameters exist    const missingParams = requiredParams.filter(      param => !process.env[param]    );        if (missingParams.length > 0) {      throw new Error(`Missing required parameters: ${missingParams.join(', ')}`);    }        requiredParams.forEach(param => {      this.config.set(param, process.env[param]!);    });  }    public get(key: string): string {    const value = this.config.get(key);    if (!value) {      throw new Error(`Configuration key '${key}' not found`);    }    return value;  }}

// Cost analysis script using AWS Cost Explorer APIimport { CostExplorerClient, GetDimensionValuesCommand, GetRightsizingRecommendationCommand } from '@aws-sdk/client-cost-explorer';
export class LambdaCostAnalyzer {  private costExplorer: CostExplorerClient;    constructor() {    this.costExplorer = new CostExplorerClient({});  }    async analyzeLambdaCosts(startDate: string, endDate: string) {    const costAnalysis = await this.costExplorer.send(new GetDimensionValuesCommand({      TimePeriod: {        Start: startDate,        End: endDate      },      Dimension: 'SERVICE',      SearchString: 'Lambda',      Context: 'COST_AND_USAGE'    }));        // Detailed function-level analysis    const functionCosts = await this.getFunctionLevelCosts(startDate, endDate);        return {      totalCost: functionCosts.totalCost,      costByFunction: functionCosts.functions,      recommendations: this.generateOptimizationRecommendations(functionCosts)    };  }    private generateOptimizationRecommendations(costs: any) {    const recommendations = [];        costs.functions.forEach(func => {      // High memory, low utilization      if (func.memoryMB > 1024 && func.avgMemoryUsed < func.memoryMB * 0.5) {        recommendations.push({          function: func.name,          type: 'REDUCE_MEMORY',          currentMemory: func.memoryMB,          recommendedMemory: Math.ceil(func.avgMemoryUsed * 1.2),          estimatedSavings: func.cost * 0.4        });      }            // High duration, could benefit from more memory      if (func.avgDuration > 5000 && func.memoryMB < 1024) {        recommendations.push({          function: func.name,          type: 'INCREASE_MEMORY',          reason: 'CPU-bound workload',          estimatedSpeedup: '30-50%'        });      }    });        return recommendations;  }}

// Automated memory optimization based on CloudWatch metricsexport class MemoryOptimizer {  async optimizeFunction(functionName: string) {    const metrics = await this.getCloudWatchMetrics(functionName, 30); // 30 days        const analysis = {      avgMemoryUsed: metrics.avgMemoryUsed,      maxMemoryUsed: metrics.maxMemoryUsed,      currentMemoryAllocated: metrics.currentMemory,      avgDuration: metrics.avgDuration,      invocations: metrics.invocations    };        // Calculate optimal memory    const recommendedMemory = this.calculateOptimalMemory(analysis);        if (recommendedMemory !== analysis.currentMemoryAllocated) {      return {        recommendation: 'UPDATE_MEMORY',        current: analysis.currentMemoryAllocated,        recommended: recommendedMemory,        expectedSavings: this.calculateSavings(analysis, recommendedMemory),        confidence: this.calculateConfidence(metrics)      };    }        return { recommendation: 'NO_CHANGE', reason: 'Already optimized' };  }    private calculateOptimalMemory(analysis: any): number {    // Add 20% buffer to max memory usage    const memoryWithBuffer = Math.ceil(analysis.maxMemoryUsed * 1.2);        // Round up to nearest valid Lambda memory size    const validSizes = [128, 256, 512, 1024, 1536, 3008];    return validSizes.find(size => size >= memoryWithBuffer) || 3008;  }}

// Lambda Extension for real-time cost monitoringimport { CloudWatch } from '@aws-sdk/client-cloudwatch';
class CostMonitoringExtension {  private cloudWatch: CloudWatch;  private functionName: string;  private startTime: number;    constructor() {    this.cloudWatch = new CloudWatch({});    this.functionName = process.env.AWS_LAMBDA_FUNCTION_NAME!;    this.startTime = Date.now();  }    async init() {    // Register extension    const response = await fetch(      `http://${process.env.AWS_LAMBDA_RUNTIME_API}/2020-01-01/lambda/extensions`,      {        method: 'POST',        body: JSON.stringify({          'lambda-extension-name': 'cost-monitor',          'lambda-extension-events': ['INVOKE', 'SHUTDOWN']        }),        headers: {          'Lambda-Extension-Name': 'cost-monitor'        }      }    );        const data = await response.json();    return data.functionResponseMode;  }    async processEvents() {    while (true) {      const eventResponse = await fetch(        `http://${process.env.AWS_LAMBDA_RUNTIME_API}/2020-01-01/lambda/extensions/event/next`,        { method: 'GET' }      );            const event = await eventResponse.json();            switch (event.eventType) {        case 'INVOKE':          this.startTime = Date.now();          break;                  case 'SHUTDOWN':          await this.reportCosts();          break;      }    }  }    private async reportCosts() {    const duration = Date.now() - this.startTime;    const memoryMB = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE!);        // Calculate cost (simplified)    const cost = this.calculateInvocationCost(duration, memoryMB);        await this.cloudWatch.send(new PutMetricDataCommand({      Namespace: 'Lambda/Cost',      MetricData: [{        MetricName: 'InvocationCost',        Value: cost,        Unit: 'None',        Dimensions: [          { Name: 'FunctionName', Value: this.functionName },          { Name: 'MemorySize', Value: memoryMB.toString() }        ]      }]    }));  }    private calculateInvocationCost(durationMs: number, memoryMB: number): number {    // AWS Lambda pricing: $0.0000166667 per GB-second    const gbSeconds = (memoryMB / 1024) * (durationMs / 1000);    return gbSeconds * 0.0000166667;  }}
// Extension entry pointconst extension = new CostMonitoringExtension();extension.init().then(() => extension.processEvents());

// Structured logging extension with automatic error reportingclass StructuredLoggingExtension {  private logs: any[] = [];  private functionName: string;    constructor() {    this.functionName = process.env.AWS_LAMBDA_FUNCTION_NAME!;    this.setupLogCapture();  }    private setupLogCapture() {    // Capture all console.* calls    const originalConsole = { ...console };        console.log = (...args) => {      this.logs.push({        level: 'INFO',        timestamp: new Date().toISOString(),        message: args.join(' '),        functionName: this.functionName      });      originalConsole.log(...args);    };        console.error = (...args) => {      this.logs.push({        level: 'ERROR',        timestamp: new Date().toISOString(),        message: args.join(' '),        functionName: this.functionName,        alert: true // Flag for immediate alerting      });      originalConsole.error(...args);    };  }    async flushLogs() {    if (this.logs.length === 0) return;        // Send to your logging service    await this.sendToLogService(this.logs);        // Send alerts for errors    const errors = this.logs.filter(log => log.alert);    if (errors.length > 0) {      await this.sendAlerts(errors);    }        this.logs = [];  }}

// 1. Extract discrete functions first// From monolithic ECS service to focused Lambda functions
// Before: Single ECS task handling everythingclass PaymentAPI {  async processPayment(req: Request) { /* ... */ }  async validateCard(req: Request) { /* ... */ }  async sendNotification(req: Request) { /* ... */ }  async updateInventory(req: Request) { /* ... */ }}
// After: Specialized Lambda functions// payment-processor-lambdaexport const handler = async (event: PaymentEvent) => {  return processPayment(event.paymentData);};
// card-validator-lambda  export const handler = async (event: CardEvent) => {  return validateCard(event.cardData);};
// notification-sender-lambdaexport const handler = async (event: NotificationEvent) => {  return sendNotification(event.notificationData);};

// Problem: ECS service had in-memory caching// Solution: External state with DynamoDB
// Before (in ECS memory)const cache = new Map<string, UserData>();
// After (Lambda with DynamoDB)import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
export class UserCache {  private dynamodb = new DynamoDBClient({});    async get(userId: string): Promise<UserData | null> {    // Use DynamoDB with TTL for caching    const result = await this.dynamodb.send(new GetItemCommand({      TableName: 'UserCache',      Key: { userId: { S: userId } }    }));        return result.Item ? JSON.parse(result.Item.data.S!) : null;  }}

// Problem: ECS had persistent DB connections// Solution: Connection per invocation with RDS Proxy
// Before (ECS with persistent connections)const pool = new Pool({  host: 'db.internal',  max: 20,  idleTimeoutMillis: 30000});
// After (Lambda with RDS Proxy)import { Client } from 'pg';
export const handler = async (event: any) => {  const client = new Client({    host: 'rds-proxy.cluster-xyz.us-east-1.rds.amazonaws.com',    port: 5432,    database: 'mydb',    user: process.env.DB_USER,    password: process.env.DB_PASSWORD,    ssl: { rejectUnauthorized: false }  });    await client.connect();  try {    const result = await client.query('SELECT * FROM users WHERE id = $1', [event.userId]);    return result.rows[0];  } finally {    await client.end();  }};

// Saga pattern implementation for distributed transactionsexport class PaymentSaga {  private stepFunctions: SFNClient;    constructor() {    this.stepFunctions = new SFNClient({});  }    async executePayment(paymentData: PaymentData) {    const sagaDefinition = {      Comment: 'Payment processing saga',      StartAt: 'ValidatePayment',      States: {        ValidatePayment: {          Type: 'Task',          Resource: 'arn:aws:lambda:us-east-1:123456789:function:validate-payment',          Next: 'ProcessPayment',          Catch: [            {              ErrorEquals: ['ValidationError'],              Next: 'PaymentFailed'            }          ]        },        ProcessPayment: {          Type: 'Task',           Resource: 'arn:aws:lambda:us-east-1:123456789:function:process-payment',          Next: 'UpdateInventory',          Catch: [            {              ErrorEquals: ['PaymentError'],              Next: 'CompensateValidation'            }          ]        },        UpdateInventory: {          Type: 'Task',          Resource: 'arn:aws:lambda:us-east-1:123456789:function:update-inventory',           Next: 'SendConfirmation',          Catch: [            {              ErrorEquals: ['InventoryError'],              Next: 'CompensatePayment'            }          ]        },        SendConfirmation: {          Type: 'Task',          Resource: 'arn:aws:lambda:us-east-1:123456789:function:send-confirmation',          End: true        },        // Compensation states        CompensatePayment: {          Type: 'Task',          Resource: 'arn:aws:lambda:us-east-1:123456789:function:refund-payment',          Next: 'CompensateValidation'        },        CompensateValidation: {          Type: 'Task',           Resource: 'arn:aws:lambda:us-east-1:123456789:function:cleanup-validation',          Next: 'PaymentFailed'        },        PaymentFailed: {          Type: 'Fail',          Cause: 'Payment processing failed'        }      }    };        const execution = await this.stepFunctions.send(new StartExecutionCommand({      stateMachineArn: process.env.PAYMENT_SAGA_STATE_MACHINE!,      input: JSON.stringify(paymentData)    }));        return execution.executionArn;  }}

// Circuit breaker for external service callsexport class CircuitBreaker {  private failures: number = 0;  private lastFailureTime: number = 0;  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';    constructor(    private failureThreshold: number = 5,    private recoveryTimeMs: number = 60000  ) {}    async execute<T>(operation: () => Promise<T>): Promise<T> {    if (this.state === 'OPEN') {      if (Date.now() - this.lastFailureTime > this.recoveryTimeMs) {        this.state = 'HALF_OPEN';      } else {        throw new Error('Circuit breaker is OPEN');      }    }        try {      const result = await operation();      this.onSuccess();      return result;    } catch (error) {      this.onFailure();      throw error;    }  }    private onSuccess() {    this.failures = 0;    this.state = 'CLOSED';  }    private onFailure() {    this.failures++;    this.lastFailureTime = Date.now();        if (this.failures >= this.failureThreshold) {      this.state = 'OPEN';    }  }}
// Usage in Lambda functionconst circuitBreaker = new CircuitBreaker(5, 30000);
export const handler = async (event: any) => {  try {    return await circuitBreaker.execute(async () => {      return await callExternalService(event.data);    });  } catch (error) {    return {      statusCode: 503,      body: JSON.stringify({ error: 'Service temporarily unavailable' })    };  }};