冷启动优化策略#

import { parse, format } from 'date-fns';
import { debounce, cloneDeep } from 'lodash';
import axios from 'axios';

// Bundle: date-fns + lodash + axios = ~150KB

// 使用原生 API
const parse = (date: string) => new Date(date);
const format = (date: Date) => date.toISOString();

// 使用原生 fetch (Node 18+)
// Bundle: ~0KB (无额外依赖)

// 不要这样做 - 每次调用都创建连接
export const handler = async (event: APIGatewayProxyEvent) => {
  const client = new DynamoDBClient({});
  const command = new GetItemCommand({...});
  const response = await client.send(command);
  return response;
};

import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';

// 连接在模块初始化时创建，整个容器生命周期复用
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);

// 预热连接
const warmup = async () => {
  await docClient.send(new GetCommand({
    TableName: 'dummy',
    Key: { pk: 'warmup' }
  }));
};
// 不要导出 warmup，在模块加载时调用

import { docClient } from './lib/dynamodb';

// 每次调用复用同一个连接
export const handler = async (event: APIGatewayProxyEvent) => {
  const response = await docClient.send(new GetCommand({
    TableName: process.env.TABLE_NAME!,
    Key: { pk: event.pathParameters?.id }
  }));
  return response;
};

import mysql from 'mysql2/promise';

const pool = mysql.createPool({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  // 连接复用配置
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0,
  enableKeepAlive: true,
  keepAliveInitialDelay: 10000,
});

export const query = async (sql: string, params: any[]) => {
  const [rows] = await pool.execute(sql, params);
  return rows;
};

import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';

const client = new LambdaClient({});
const functions = [
  'user-service-prod',
  'order-service-prod',
  'payment-service-prod',
];

export const scheduledWarmup = async () => {
  await Promise.all(
    functions.map(fn => client.send(new InvokeCommand({
      FunctionName: fn,
      InvocationType: 'Event',  // 异步调用，不等待响应
    }))
  ));
};

import { LambdaClient, PutFunctionConcurrencyCommand } from '@aws-sdk/client-lambda';

const client = new LambdaClient({});

await client.send(new PutFunctionConcurrencyCommand({
  FunctionName: 'production-api',
  // 保持 5 个实例始终热状态
  ProvisionedConcurrencyConfig: {
    ProvisionedConcurrentExecutions: 5,
  },
}));

import { CloudWatchClient, GetMetricDataCommand } from '@aws-sdk/client-cloudwatch';

const client = new CloudWatchClient({});

export const autoScaleConcurrency = async () => {
  // 获取过去 5 分钟的并发请求数
  const metrics = await client.send(new GetMetricDataCommand({
    MetricDataQueries: [{
      Id: 'concurrentReqs',
      MetricStat: {
        Metric: {
          Namespace: 'AWS/Lambda',
          MetricName: 'ConcurrentExecutions',
          Dimensions: [{ Name: 'FunctionName', Value: 'production-api' }]
        },
        Period: 300,
        Stat: 'Average',
      },
    }],
    ScanBy: 'TimestampDescending',
    StartTime: new Date(Date.now() - 300000),
    EndTime: new Date(),
  }));

  const avgConcurrent = metrics.MetricDataResults?.[0]?.Values?.[0] || 0;
  const target = Math.max(2, Math.ceil(avgConcurrent * 1.2));

  // 更新并发配置
  await client.send(new PutFunctionConcurrencyCommand({
    FunctionName: 'production-api',
    ProvisionedConcurrencyConfig: {
      ProvisionedConcurrentExecutions: target,
    },
  }));
};

// 共享代码，不打入每个函数 bundle
export const heavyComputation = (input: string) => {
  // 复杂计算
  return result;
};

import { heavyComputation } from '/opt/nodejs/lib/shared';

export const handler = async (event: any) => {
  return heavyComputation(event.input);
};

// 重量级初始化（连接池、缓存等）
// 在模块顶层执行，容器启动时执行一次

export const initServices = async () => {
  await Promise.all([
    initDatabase(),
    initCache(),
    initMLModel(),
  ]);
};

let servicesInitialized = false;

export const withServices = async <T>(
  handler: () => Promise<T>
): Promise<T> => {
  if (!servicesInitialized) {
    await initServices();
    servicesInitialized = true;
  }
  return handler();
};

export const handler = async (event: any) => {
  return withServices(async () => {
    // 每次调用执行的业务逻辑
    return processEvent(event);
  });
};

// API 响应快速返回
export const handler = async (event: APIGatewayProxyEvent) => {
  // 快速响应用户
  await sqs.send(new SendMessageCommand({
    QueueUrl: process.env.QUEUE_URL!,
    MessageBody: JSON.stringify(event),
  }));

  return {
    statusCode: 202,
    body: JSON.stringify({ message: "Request accepted" }),
  };
};

// 后台处理
export const handler = async (event: SQSEvent) => {
  for (const record of event.Records) {
    await processMessage(JSON.parse(record.body));
  }
};

import { CloudWatchClient, PutMetricDataCommand } from '@aws-sdk/client-cloudwatch';

const client = new CloudWatchClient({});

export const recordColdStart = async (functionName: string, duration: number) => {
  await client.send(new PutMetricDataCommand({
    Namespace: 'Serverless/Perf',
    MetricData: [{
      MetricName: 'ColdStartDuration',
      Dimensions: [{ Name: 'FunctionName', Value: functionName }],
      Value: duration,
      Unit: 'Milliseconds',
    }],
  }));
};

// 在函数开头记录开始时间
const startTime = Date.now();

// 在函数返回前计算并上报
process.on('beforeExit', () => {
  const duration = Date.now() - startTime;
  if (duration > 100) {  // 只记录超过 100ms 的冷启动
    recordColdStart(process.env.AWS_LAMBDA_FUNCTION_NAME!, duration);
  }
});