Node.js Serverless 部署实战：Vercel、AWS Lambda 到多云策略

// api/hello.js
export default function handler(req, res) {
    const { name = 'World' } = req.query;
    res.status(200).json({ message: `Hello, ${name}!` });
}

// api/users/[id].js — 动态路由
export default function handler(req, res) {
    const { id } = req.query;
    // 模拟数据库查询
    const user = { id, name: `User ${id}`, createdAt: new Date().toISOString() };
    res.status(200).json(user);
}

{
  "functions": {
    "api/**/*.js": {
      "maxDuration": 30
    }
  },
  "headers": [
    {
      "source": "/api/(.*)",
      "headers": [
        { "key": "Access-Control-Allow-Origin", "value": "*" }
      ]
    }
  ]
}

// middleware.js — 边缘中间件
export const config = {
    matcher: '/api/:path*'
};

export default function middleware(request) {
    const country = request.geo?.country || 'US';
    const response = NextResponse.next();
    response.headers.set('X-User-Country', country);
    return response;
}

// pages/blog/[slug].js
export async function getStaticProps({ params }) {
    const post = await fetchPost(params.slug);
    return {
        props: { post },
        revalidate: 60  // 60 秒后下次访问触发后台重新生成
    };
}

export async function getStaticPaths() {
    const posts = await fetchAllPosts();
    return {
        paths: posts.map(p => ({ params: { slug: p.slug } })),
        fallback: 'blocking'
    };
}

// 基础 Handler（CommonJS）
exports.handler = async (event, context) => {
    console.log('RequestId:', context.awsRequestId);
    console.log('Remaining time:', context.getRemainingTimeInMillis());
    
    const { httpMethod, path, queryStringParameters, body } = event;
    
    if (httpMethod === 'GET' && path === '/users') {
        const users = await getUsers(queryStringParameters);
        return {
            statusCode: 200,
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(users)
        };
    }
    
    return { statusCode: 404, body: JSON.stringify({ error: 'Not found' }) };
};

// TypeScript 版本 + 依赖注入风格
import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { UserService } from './services/userService';

const userService = new UserService();  // 复用连接等初始化

export const handler = async (
    event: APIGatewayProxyEvent,
    context: Context
): Promise<APIGatewayProxyResult> => {
    context.callbackWaitsForEmptyEventLoop = false;  // 重要：防止连接池等待
    
    try {
        const userId = event.pathParameters?.id;
        const user = await userService.findById(userId);
        
        return {
            statusCode: 200,
            headers: {
                'Content-Type': 'application/json',
                'Cache-Control': 'max-age=300'
            },
            body: JSON.stringify({ data: user })
        };
    } catch (error) {
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

// 初始化阶段：只执行一次
const dbClient = new MongoClient(process.env.MONGODB_URI, {
    maxPoolSize: 5,  // Lambda 场景下连接池不宜过大
    minPoolSize: 1
});

let dbConnection = null;

async function getDb() {
    if (!dbConnection) {
        await dbClient.connect();
        dbConnection = dbClient.db(process.env.DB_NAME);
    }
    return dbConnection;
}

// 调用阶段：每次请求都执行
exports.handler = async (event, context) => {
    context.callbackWaitsForEmptyEventLoop = false;
    const db = await getDb();
    const users = await db.collection('users').find({ active: true }).toArray();
    return { statusCode: 200, body: JSON.stringify(users) };
};

# serverless.yml 中使用 Layers
provider:
  name: aws
  runtime: nodejs20.x
  layers:
    - arn:aws:lambda:us-east-1:123456789012:layer:common-utils:1

functions:
  api:
    handler: dist/handler.api
    layers:
      - ${cf:layers-stack.CommonLayerArn}

// ❌ 每次调用都重新实例化
exports.handler = async (event) => {
    const db = new Database();  // 错误：每次调用都创建新连接
    const result = await db.query('SELECT * FROM users');
    return result;
};

// ✅ 初始化逻辑放在 handler 外部
const db = new Database();  // 冷启动时执行一次
const cache = new Map();     // 实例级缓存

exports.handler = async (event) => {
    // 复用已有的 db 连接
    const result = await db.query('SELECT * FROM users WHERE active = true');
    return result;
};

# serverless.yml
provider:
  name: aws
  runtime: nodejs20.x
  httpApi:
    cors: true
    authorizers:
      jwtAuthorizer:
        type: jwt
        identitySource: $request.header.Authorization
        issuerUrl: https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx
        audience:
          - xxxxxxxxxx

functions:
  createOrder:
    handler: dist/handlers/order.create
    events:
      - httpApi:
          path: /orders
          method: post
          authorizer:
            name: jwtAuthorizer

  getOrder:
    handler: dist/handlers/order.get
    events:
      - httpApi:
          path: /orders/{id}
          method: get

// 统一响应格式封装
function createResponse(statusCode, data, meta = {}) {
    return {
        statusCode,
        headers: {
            'Content-Type': 'application/json',
            'X-Request-ID': crypto.randomUUID()
        },
        body: JSON.stringify({
            success: statusCode < 400,
            data,
            meta: {
                timestamp: new Date().toISOString(),
                ...meta
            }
        })
    };
}

// Azure Durable Functions 编排示例
const df = require('durable-functions');

const orchestrator = df.orchestrator(function* (context) {
    const outputs = [];
    
    // 并行调用多个子函数
    const tasks = [
        context.df.callActivity('GetUserProfile', context.bindings.userId),
        context.df.callActivity('GetUserOrders', context.bindings.userId),
        context.df.callActivity('GetUserPreferences', context.bindings.userId)
    ];
    
    const results = yield context.df.Task.all(tasks);
    
    //  sequential 步骤：根据并行结果做聚合
    const summary = yield context.df.callActivity('BuildUserSummary', results);
    return summary;
});

module.exports = orchestrator;

// Google Cloud Functions（Firebase 风格）
const functions = require('firebase-functions');
const admin = require('firebase-admin');

admin.initializeApp();

// HTTP 函数
exports.createUserProfile = functions
    .runWith({
        memory: '512MB',
        timeoutSeconds: 30,
        minInstances: 1  // 保持最小实例以减少冷启动
    })
    .https.onCall(async (data, context) => {
        if (!context.auth) {
            throw new functions.https.HttpsError('unauthenticated', '请先登录');
        }
        
        const { displayName, avatar } = data;
        await admin.firestore().collection('profiles').doc(context.auth.uid).set({
            displayName,
            avatar,
            createdAt: admin.firestore.FieldValue.serverTimestamp()
        });
        
        return { success: true };
    });

# 使用 webpack/esbuild 打包，只包含使用到的代码
# 对比效果：
# 原始 node_modules: 150MB
# 打包后: 3MB

# 生产依赖分离
npm ci --production
# 排除开发依赖、测试文件、文档

# 使用 AWS Lambda Power Tuning 工具找到最佳平衡点
# 通常 1769MB 是 CPU 完全可用的临界点
curl -O https://raw.githubusercontent.com/alexcasalboni/aws-lambda-power-tuning/master/template.yml

// 数据库连接启用 keep-alive
const https = require('https');
const agent = new https.Agent({ keepAlive: true });

// AWS SDK v3 默认支持 keep-alive
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const client = new DynamoDBClient({
    maxAttempts: 3,
    requestHandler: {
        requestTimeout: 3000,
        httpsAgent: agent
    }
});

# serverless.yml
functions:
  criticalApi:
    handler: dist/critical.handler
    provisionedConcurrency: 10  # 始终保持 10 个热实例

# Java 函数已支持 SnapStart，Node.js 可通过 Lambda Extensions 近似实现
functions:
  snapOptimized:
    handler: dist/handler.main
    snapStart: true  # 仅 Java 运行时官方支持

// 使用 EventBridge 每 5 分钟调用一次关键函数
// CloudWatch Synthetics Canaries 是更可靠的替代方案

const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand } = require('@aws-sdk/lib-dynamodb');

// 客户端在初始化阶段复用
const client = DynamoDBDocumentClient.from(new DynamoDBClient({}), {
    marshallOptions: { convertEmptyValues: false, removeUndefinedValues: true }
});

const TABLE_NAME = process.env.TABLE_NAME;

exports.getUser = async (event) => {
    const { userId } = event.pathParameters;
    
    const result = await client.send(new GetCommand({
        TableName: TABLE_NAME,
        Key: { userId },
        ConsistentRead: false  // 最终一致性已满足大多数场景
    }));
    
    return {
        statusCode: 200,
        body: JSON.stringify(result.Item || {})
    };
};

exports.listUserOrders = async (event) => {
    const { userId } = event.pathParameters;
    const { limit = '20', lastKey } = event.queryStringParameters || {};
    
    const result = await client.send(new QueryCommand({
        TableName: TABLE_NAME,
        KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
        ExpressionAttributeValues: {
            ':pk': `USER#${userId}`,
            ':prefix': 'ORDER#'
        },
        Limit: parseInt(limit),
        ExclusiveStartKey: lastKey ? JSON.parse(Buffer.from(lastKey, 'base64')) : undefined,
        ScanIndexForward: false  // 降序（最新在前）
    }));
    
    return {
        statusCode: 200,
        body: JSON.stringify({
            items: result.Items,
            nextCursor: result.LastEvaluatedKey 
                ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString('base64')
                : null
        })
    };
};

// 使用 REST API 方式连接 Upstash（无客户端连接数限制）
const UPSTASH_REDIS_REST_URL = process.env.UPSTASH_REDIS_REST_URL;
const UPSTASH_REDIS_REST_TOKEN = process.env.UPSTASH_REDIS_REST_TOKEN;

async function redisCommand(command, ...args) {
    const response = await fetch(`${UPSTASH_REDIS_REST_URL}`, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${UPSTASH_REDIS_REST_TOKEN}`,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify([command, ...args])
    });
    return response.json();
}

exports.handler = async (event) => {
    const cacheKey = `products:${event.pathParameters.category}`;
    
    // 先查缓存
    const cached = await redisCommand('GET', cacheKey);
    if (cached.result) {
        return { statusCode: 200, body: cached.result };
    }
    
    // 回源查询
    const products = await fetchProductsFromDB(event.pathParameters.category);
    
    // 写入缓存（TTL 300 秒）
    await redisCommand('SETEX', cacheKey, 300, JSON.stringify(products));
    
    return { statusCode: 200, body: JSON.stringify(products) };
};

npm install -g serverless
serverless create --template aws-nodejs-typescript --path my-api
cd my-api
npm install

service: my-node-api

provider:
  name: aws
  runtime: nodejs20.x
  stage: ${opt:stage, 'dev'}
  region: ${opt:region, 'ap-southeast-1'}
  memorySize: 512
  timeout: 10
  environment:
    NODE_ENV: ${self:provider.stage}
    TABLE_NAME: ${self:custom.tableName}
    LOG_LEVEL: ${self:custom.logLevel}
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:GetItem
            - dynamodb:PutItem
            - dynamodb:Query
          Resource:
            - Fn::GetAtt: [UsersTable, Arn]

custom:
  tableName: ${self:service}-users-${self:provider.stage}
  logLevel: ${self:provider.stage} == 'prod' ? 'warn' : 'debug'
  serverless-offline:
    httpPort: 3000
    lambdaPort: 3002

plugins:
  - serverless-offline
  - serverless-plugin-typescript

functions:
  getUser:
    handler: src/handlers/user.get
    events:
      - http:
          path: users/{id}
          method: get
          cors: true
          request:
            parameters:
              paths:
                id: true

  createUser:
    handler: src/handlers/user.create
    events:
      - http:
          path: users
          method: post
          cors: true

resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: ${self:custom.tableName}
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: userId
            AttributeType: S
        KeySchema:
          - AttributeName: userId
            KeyType: HASH

# 启动本地 API Gateway 模拟器
serverless offline

# 调用本地函数
serverless invoke local -f getUser -p events/getUser.json

# 热重载开发
serverless offline --reloadHandler

# .github/workflows/deploy.yml
name: Deploy Serverless API

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm run lint
      - run: npm run test
      - run: npx serverless deploy --stage prod
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

// 结构化日志 — 便于 CloudWatch Logs Insights 查询
const logger = {
    info: (message, meta = {}) => {
        console.log(JSON.stringify({
            level: 'info',
            message,
            timestamp: new Date().toISOString(),
            ...meta
        }));
    },
    error: (message, error, meta = {}) => {
        console.error(JSON.stringify({
            level: 'error',
            message,
            errorName: error.name,
            errorMessage: error.message,
            stack: error.stack,
            timestamp: new Date().toISOString(),
            ...meta
        }));
    }
};

exports.handler = async (event, context) => {
    logger.info('Processing request', {
        requestId: context.awsRequestId,
        path: event.path,
        userAgent: event.headers?.['User-Agent']
    });
    
    try {
        const result = await processRequest(event);
        logger.info('Request completed', { requestId: context.awsRequestId, duration: Date.now() - start });
        return result;
    } catch (error) {
        logger.error('Request failed', error, { requestId: context.awsRequestId });
        throw error;
    }
};

const AWSXRay = require('aws-xray-sdk-core');
const AWS = AWSXRay.captureAWS(require('aws-sdk'));

const dynamo = new AWS.DynamoDB.DocumentClient();

exports.handler = async (event) => {
    const segment = AWSXRay.getSegment();
    const subsegment = segment.addNewSubsegment('DatabaseQuery');
    
    try {
        subsegment.addAnnotation('tableName', process.env.TABLE_NAME);
        const result = await dynamo.get({
            TableName: process.env.TABLE_NAME,
            Key: { id: event.pathParameters.id }
        }).promise();
        subsegment.close();
        return { statusCode: 200, body: JSON.stringify(result.Item) };
    } catch (error) {
        subsegment.addError(error);
        subsegment.close(error);
        throw error;
    }
};

# CloudFormation 模板片段 — 告警配置
Resources:
  HighErrorRateAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: !Sub "${ServiceName}-HighErrorRate"
      MetricName: Errors
      Namespace: AWS/Lambda
      Statistic: Sum
      Period: 60
      EvaluationPeriods: 2
      Threshold: 10
      ComparisonOperator: GreaterThanThreshold
      Dimensions:
        - Name: FunctionName
          Value: !Ref MyLambdaFunction
      AlarmActions:
        - !Ref NotificationTopic