热启动与实例复用#

// 全局变量在实例复用时保留
let dbClient: DatabaseClient | null = null;
let cacheConnection: Redis | null = null;

const getDBClient = async () => {
  if (!dbClient) {
    // 只在第一次初始化
    dbClient = new DatabaseClient({
      host: process.env.DB_HOST!,
      connectionLimit: 10,
    });
    await dbClient.connect();
  }
  return dbClient;
};

const getCache = () => {
  if (!cacheConnection) {
    cacheConnection = new Redis(process.env.REDIS_URL!);
  }
  return cacheConnection;
};

export const handler = async (event: any) => {
  const db = await getDBClient();
  const cache = getCache();

  // 业务逻辑
  return processEvent(event, db, cache);
};

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

const client = new LambdaClient({});

interface WarmupConfig {
  functions: Array<{
    name: string;
    regions?: string[];
  }>;
  concurrency?: number;
}

export const runWarmup = async (config: WarmupConfig) => {
  const { functions, concurrency = 1 } = config;

  const promises: Promise<any>[] = [];

  for (const fn of functions) {
    const regions = fn.regions || [process.env.AWS_REGION!];

    for (const region of regions) {
      const regionClient = new LambdaClient({ region });

      for (let i = 0; i < concurrency; i++) {
        promises.push(
          regionClient.send(new InvokeCommand({
            FunctionName: fn.name,
            InvocationType: 'Event',  // 异步，不等待响应
            Payload: JSON.stringify({ warmup: true }),
          })).catch(err => {
            console.error(`Warmup failed for ${fn.name}:`, err);
          })
        );
      }
    }
  }

  await Promise.all(promises);
  console.log(`Warmed up ${functions.length} functions`);
};

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

const client = new LambdaClient({});

export const setProvisionedConcurrency = async (
  functionName: string,
  count: number
) => {
  const response = await client.send(new PutFunctionConcurrencyCommand({
    FunctionName: functionName,
    ProvisionedConcurrencyConfig: {
      ProvisionedConcurrentExecutions: count,
    },
  }));

  console.log(`Set ${count} provisioned concurrency for ${functionName}`);
  return response;
};

// 查看当前配置
export const getProvisionedConcurrency = async (functionName: string) => {
  const response = await client.send(new GetFunctionConcurrencyCommand({
    FunctionName: functionName,
  }));

  return response.ProvisionedConcurrencyConfig;
};

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

const cloudwatch = new CloudWatchClient({});
const lambda = new LambdaClient({});

interface ScalingConfig {
  functionName: string;
  min: number;
  max: number;
  targetUtilization: number;  // 0.7 = 70%
}

export const scaleProvisionedConcurrency = async (config: ScalingConfig) => {
  const { functionName, min, max, targetUtilization } = config;

  // 获取并发执行数
  const metrics = await cloudwatch.send(new GetMetricDataCommand({
    MetricDataQueries: [{
      Id: 'concurrent',
      MetricStat: {
        Metric: {
          Namespace: 'AWS/Lambda',
          MetricName: 'ConcurrentExecutions',
          Dimensions: [{ Name: 'FunctionName', Value: functionName }]
        },
        Period: 300,
        Stat: 'Maximum',
      },
    }, {
      Id: 'invocations',
      MetricStat: {
        Metric: {
          Namespace: 'AWS/Lambda',
          MetricName: 'Invocations',
          Dimensions: [{ Name: 'FunctionName', Value: functionName }]
        },
        Period: 300,
        Stat: 'Sum',
      },
    }],
    StartTime: new Date(Date.now() - 3600000),
    EndTime: new Date(),
  }));

  const maxConcurrent = metrics.MetricDataResults?.[0]?.Values?.[0] || 0;
  const invocations = metrics.MetricDataResults?.[1]?.Values?.[0] || 0;

  // 计算目标并发数
  // 估算：最大并发 / 目标利用率，向上取整
  const estimatedPeak = maxConcurrent / targetUtilization;
  let target = Math.ceil(estimatedPeak);

  // 限制在 min-max 范围内
  target = Math.max(min, Math.min(max, target));

  await lambda.send(new PutFunctionConcurrencyCommand({
    FunctionName: functionName,
    ProvisionedConcurrencyConfig: {
      ProvisionedConcurrentExecutions: target,
    },
  }));

  console.log(`Scaled ${functionName} to ${target} provisioned concurrency`);
};

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

const client = new CloudWatchClient({});

// Lambda 内部可以访问初始化时间
const initStartTime = Date.now();

export const recordMetrics = async () => {
  const functionName = process.env.AWS_LAMBDA_FUNCTION_NAME!;
  const memoryLimit = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE!);
  const initDuration = Date.now() - initStartTime;

  // 判断是否是冷启动
  const isColdStart = process.env.AWS_LAMBDA_INITIALIZATION_TYPE === 'on-demand';

  await client.send(new PutMetricDataCommand({
    Namespace: 'Serverless/Metrics',
    MetricData: [{
      MetricName: 'ColdStart',
      Value: isColdStart ? 1 : 0,
      Unit: 'Count',
      Dimensions: [{ Name: 'FunctionName', Value: functionName }],
    }, {
      MetricName: 'InitDuration',
      Value: initDuration,
      Unit: 'Milliseconds',
      Dimensions: [{ Name: 'FunctionName', Value: functionName }],
    }],
  }));
};

// 昂贵但只需要执行一次的初始化
const initializeExpensiveResource = async () => {
  // ML 模型加载 (~50MB)
  // 预计算数据
  // 第三方 SDK 初始化
};

// 在模块加载时执行
if (require.main === module) {
  initializeExpensiveResource().catch(console.error);
}

export const handler = async (event: any) => {
  let db;

  try {
    db = await getDBClient();
  } catch (error) {
    // 连接失败时重置，强制重建
    dbClient = null;
    throw error;  // 让调用失败而不是返回错误数据
  }

  return processEvent(event, db);
};