AWS 无服务器架构

// Node.js Lambda Handler
// handler.js
// 在 handler 外部初始化（在多次调用间复用）
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
// Handler 函数
exports.handler = async (event, context) => {
  // 可选：不等待事件循环清空 (Node.js)
  context.callbackWaitsForEmptyEventLoop = false;
try {
    // 根据事件源解析输入
    const body = typeof event.body === 'string'
      ? JSON.parse(event.body)
      : event.body;
// 业务逻辑
    const result = await processRequest(body);
// 返回兼容 API Gateway 的响应
    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json',
        'Access-Control-Allow-Origin': '*'
      },
      body: JSON.stringify(result)
    };
  } catch (error) {
    console.error('Error:', JSON.stringify({
      error: error.message,
      stack: error.stack,
      requestId: context.awsRequestId
    }));
return {
      statusCode: error.statusCode || 500,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        error: error.message || 'Internal server error'
      })
    };
  }
};
async function processRequest(data) {
  // 此处编写业务逻辑
  const result = await docClient.send(new GetCommand({
    TableName: process.env.TABLE_NAME,
    Key: { id: data.id }
  }));
  return result.Item;
}

# Python Lambda Handler
handler.py
import json
import os
import logging
import boto3
from botocore.exceptions import ClientError
在 handler 外部初始化（在多次调用间复用）
logger = logging.getLogger()
logger.setLevel(logging.INFO)
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])
def handler(event, context):
    try:
        # 解析输入
        body = json.loads(event.get('body', '{}')) if isinstance(event.get('body'), str) else event.get('body', {})
# 业务逻辑
        result = process_request(body)
return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Contr

### 最佳实践

在 handler 外部初始化客户端（可在热启动调用中复用）
始终返回标准的 API Gateway 响应格式
使用结构化 JSON 日志以便于 CloudWatch Insights 分析
在错误日志中包含请求 ID 以便追踪
API Gateway 集成模式
REST API 和 HTTP API 与 Lambda 的集成
适用场景：构建由 Lambda 支持的 REST API，或需要为函数提供 HTTP 端点

### 目录结构

project/
├── template.yaml      # SAM 模板
├── src
/
│   ├── handlers/
│   │   ├── get.js
│   │   ├── create.js
│   │   └── delete.js
│   └── lib/
│       └── dynamodb.js
└── events/
    └── event.json     # 测试事件
Api_comparison (API 对比)
Http_api:
  - 低延迟 (~10ms)
  - 低成本 (便宜 50-70%)
  - 更简单，功能较少
  - 适用场景：大多数 REST API
Rest_api:
  - 功能更丰富 (缓存、请求验证、WAF)
  - 支持使用计划 (Usage plans) 和 API 密钥
  - 支持请求/响应转换
  - 适用场景：复杂 API、企业级功能
Event-Driven SQS Pattern (SQS 事件驱动模式)
由 SQS 触发 Lambda 以实现可靠的异步处理
适用场景：解耦、异步处理、需要重试逻辑和死信队列 (DLQ)、批量处理消息

### Best_practices (最佳实践)

将 VisibilityTimeout 设置为 Lambda 超时时间的 6 倍
使用 ReportBatchItemFailures 处理部分批次失败
为“毒药消息” (poison messages) 始终配置 DLQ
确保消息处理具有幂等性
DynamoDB Streams Pattern (DynamoDB Streams 模式)
使用 Lambda 对 DynamoDB 表的变更做出响应
适用场景：对数据变更的实时响应、跨区域复制、审计日志、通知

e: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/stream.handler
      Events:
        Stream:
          Type: DynamoDB
          Properties:
            Stream: !GetAtt ItemsTable.StreamArn
            StartingPosition: TRIM_HORIZON
            BatchSize: 100
            MaximumRetryAttempts: 3
            DestinationConfig:
              OnFailure:
                Destination: !GetAtt StreamDLQ.Arn

StreamDLQ:
    Type: AWS::SQS::Queue

// src/handlers/stream.js
exports.handler = async (event) => {
  for (const record of event.Records) {
    const eventName = record.eventName;  // INSERT, MODIFY, REMOVE
// 将 DynamoDB 格式反序列化为普通 JS 对象
    const newImage = record.dynamodb.NewImage
      ? unmarshall(record.dynamodb.NewImage)
      : null;
    const oldImage = record.dynamodb.OldImage
      ? unmarshall(record.dynamodb.OldImage)
      : null;
console.log(${eventName}: , { newImage, oldImage });
switch (eventName) {
      case 'INSERT':
        await handleInsert(newImage);
        break;
      case 'MODIFY':
        await handleModify(oldImage, newImage);
        break;
      case 'REMOVE':
        await handleRemove(oldImage);
        break;
    }
  }
};
// 使用 AWS SDK v3 的 unmarshall
const { unmarshall } = require('@aws-sdk/util-dynamodb');

// 使用模块化的 AWS SDK v3 导入
// 推荐 - 仅导入所需模块
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');
// 不推荐 - 导入整个 SDK
const AWS = require('aws-sdk');  // 避免这样做！

# template.yaml
Resources:
  JavaFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: com.example.Handler::handleRequest
      Runtime: java21
      SnapStart:
        ApplyOn: PublishedVersions  # 启用 SnapStart
      AutoPublishAlias: live

# 内存越多 = CPU 越多 = 初始化越快
Resources:
  FastFunction:
    Type: AWS::Serverless::Function
    Properties:
      MemorySize: 1024  # 1GB 可获得完整的 vCPU
      Timeout: 30

Resources:
  CriticalFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/critical.handler
      AutoPublishAlias: live
ProvisionedConcurrency:
    Type: AWS::Lambda::ProvisionedConcurrencyConfig
    Properties:
      FunctionName: !Ref CriticalFunction
      Qualifier: live
      ProvisionedConcurrentExecutions: 5

# 推荐 - 延迟初始化
_table = None
def get_table():
    global _table
    if _table is None:
        dynamodb = boto3.resource('dynamodb')
        _table = dynamodb.Table(os.environ['TABLE_NAME'])
    return _table
def handler(event, context):
    table = get_table()  # 仅在首次使用时初始化
    # ...

# 安装 SAM CLI
pip install aws-sam-cli
初始化新项目
sam init --runtime nodejs20.x --name my-api
构建项目
sam build
本地运行
sam local start-api
调用单个函数
sam local invoke GetItemFunction --event events/get.json
本地调试 (Node.js 配合 VS Code)
sam local invoke --debug-port 5858 GetItemFunction
部署
sam deploy --guided

// events/get.json (测试事件)
{
  "pathParameters": {
    "id": "123"
  },
  "httpMethod": "GET",
  "path": "/items/123"
}

// .vscode/launch.json (用于调试)
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to SAM CLI",
      "type": "node",
      "request": "attach",
      "address": "localhost",
      "port": 5858,
      "localRoot": "${workspaceRoot}/src",
      "remoteRoot": "/var/task/src",
      "protocol": "inspector"
    }
  ]
}

// lib/api-stack.ts
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
export class ApiStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
// DynamoDB 表
    const table = new dynamodb.Table(this, 'ItemsTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.DESTROY, // 仅用于开发环境
    });
// Lambda 函数
    const getItemFn = new lambda.Function(this, 'GetItemFunction', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'get.handler',
      code: lambda.Code.fromAsset('src/handlers'),
      environment: {
        TABLE_NAME: table.tableName,
      },
      memorySize: 256,
      timeout: cdk.Duration.seconds(30),
    });
// 授予权限
    table.grantReadData(getItemFn);
// API Gateway
    const api = new apigateway.RestApi(this, 'ItemsApi', {
      restApiName: 'Items Service',
      defaultCorsPreflightOptions: {
        allowOrigins: apigateway.Cors.ALL_ORIGINS,
        allowMethods: apigateway.Cors.ALL_METHODS,
      },
    });
const items = api.root.addResource('items');
    const item = items.addResource('{id}');
item.addMethod('GET', new apigateway.LambdaIntegration(getItemFn));
// 输出 API URL
    new cdk.CfnOutput(this, 'ApiUrl', {
      value: api.url,
    });
  }
}

# CDK 命令
npm install -g aws-cdk
cdk init app --language typescript
cdk synth    # 生成 CloudFormation 模板
cdk diff     # 显示变更差异
cdk deploy   # 部署到 AWS

# 在 CloudWatch Logs 中检查 INIT_REPORT
查看 Init Duration（毫秒）
日志示例：
INIT_REPORT Init Duration: 423.45 ms

// 1. 最小化包体积
// 使用 tree shaking，排除开发依赖
// npm prune --production
// 2. 延迟加载重型依赖
let heavyLib = null;
function getHeavyLib() {
  if (!heavyLib) {
    heavyLib = require('heavy-library');
  }
  return heavyLib;
}
// 3. 使用 AWS SDK v3 的模块化导入
const { S3Client } = require('@aws-sdk/client-s3');
// 不要使用: const AWS = require('aws-sdk');

Resources:
  JavaFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: java21
      SnapStart:
        ApplyOn: PublishedVersions

// 使用自定义指标追踪冷启动
let isColdStart = true;
exports.handler = async (event) => {
  if (isColdStart) {
    console.log('COLD_START');
    // 在此处添加 CloudWatch 自定义指标
    isColdStart = false;
  }
  // ...
};

# template.yaml
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Timeout: 30  # 秒 (最大 900)
      # 设置为：预期时长 + 缓冲时间

exports.handler = async (event, context) => {
  // 获取剩余时间
  const remainingTime = context.getRemainingTimeInMillis();
// 如果时间不足，优雅地报错
  if (remainingTime < 5000) {
    console.warn('Running low on time, aborting');
    throw new Error('Insufficient time remaining');
  }
// 对于耗时操作，定期检查
  for (const item of items) {
    if (context.getRemainingTimeInMillis() < 10000) {
      // 保存进度并优雅退出
      await saveProgress(processedItems);
      throw new Error('Timeout approaching, saved progress');
    }
    await processItem(item);
  }
};

const axios = require('axios');
// 为 HTTP 调用始终设置超时
const response = await axios.get('https://api.example.com/data', {
  timeout: 5000  // 5 秒
});

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      MemorySize: 1024  # MB (128-10240)
      # 内存越多 = CPU 性能越强

// 错误做法 - 将整个文件加载到内存
const data = await s3.getObject(params).promise();
const content = data.Body.toString();
// 正确做法 - 流式处理
const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
const s3 = new S3Client({});
const response = await s3.send(new GetObjectCommand(params));
const stream = response.Body;
// 分块处理流
for await (const chunk of stream) {
  await processChunk(chunk);
}

exports.handler = async (event, context) => {
  const used = process.memoryUsage();
  console.log('Memory:', {
    heapUsed: Math.round(used.heapUsed / 1024 / 1024) + 'MB',
    heapTotal: Math.round(used.heapTotal / 1024 / 1024) + 'MB'
  });
  // ...
};

# 寻找最佳内存设置
https://github.com/alexcasalboni/aws-lambda-power-tuning

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      VpcConfig:
        SecurityGroupIds:
          - !Ref LambdaSecurityGroup
        SubnetIds:
          - !Ref PrivateSubnet1
          - !Ref PrivateSubnet2  # 跨多个可用区 (AZ)
LambdaSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Lambda SG
      VpcId: !Ref VPC
      SecurityGroupEgress:
        - IpProtocol: tcp
          FromPort: 443
          ToPort: 443
          CidrIp: 0.0.0.0/0  # 允许 HTTPS 出站流量

# 避免调用 AWS 服务时经过 NAT 网关
DynamoDBEndpoint:
  Type: AWS::EC2::VPCEndpoint
  Properties:
    ServiceName: !Sub com.amazonaws.${AWS::Region}.dynamodb
    VpcId: !Ref VPC
    RouteTableIds:
      - !Ref PrivateRouteTable
    VpcEndpointType: Gateway
S3Endpoint:
  Type: AWS::EC2::VPCEndpoint
  Properties:
    ServiceName: !Sub com.amazonaws.${AWS::Region}.s3
    VpcId: !Ref VPC
    VpcEndpointType: Gateway

exports.handler = async (event, context) => {
  // 不要等待事件循环清空
  context.callbackWaitsForEmptyEventLoop = false;
// 业务代码
  const result = await processRequest(event);
return {
    statusCode: 200,
    body: JSON.stringify(result)
  };
};

// 对于数据库连接，请使用连接池或显式关闭连接
const mysql = require('mysql2/promise');
exports.handler = async (event, context) => {
  context.callbackWaitsForEmptyEventLoop = false;
const connection = await mysql.createConnection({...});
  try {
    const [rows] = await connection.query('SELECT * FROM users');
    return { statusCode: 200, body: JSON.stringify(rows) };
  } finally {
    await connection.end();  // 务必关闭
  }
};

// 使用 S3 预签名 URL，而不是通过 API Gateway 传输
const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
exports.handler = async (event) => {
  const s3 = new S3Client({});
const command = new PutObjectCommand({
    Bucket: process.env.BUCKET_NAME,
    Key: uploads/${Date.now()}.file
  });
const uploadUrl = await getSignedUrl(s3, command, { expiresIn: 300 });
return {
    statusCode: 200,
    body: JSON.stringify({ uploadUrl })
  };
};

// 存储在 S3 中，返回预签名的下载 URL
exports.handler = async (event) => {
  const largeData = await generateLargeReport();
await s3.send(new PutObjectCommand({
    Bucket: process.env.BUCKET_NAME,
    Key: reports/${reportId}.json,
    Body: JSON.stringify(largeData)
  }));
const downloadUrl = await getSignedUrl(s3,
    new GetObjectCommand({
      Bucket: process.env.BUCKET_NAME,
      Key: reports/${reportId}.json
    }),
    { expiresIn: 3600 }
  );
return {
    statusCode: 200,
    body: JSON.stringify({ downloadUrl })
  };
};

# 带有前缀过滤的 S3 触发器
Events:
  S3Event:
    Type: S3
    Properties:
      Bucket: !Ref InputBucket
      Events: s3:ObjectCreated:*
      Filter:
        S3Key:
          Rules:
            - Name: prefix
              Value: uploads/  # 仅在 uploads/ 目录下触发
输出到不同的存储桶或前缀
OutputBucket 或 processed/ 前缀

exports.handler = async (event) => {
  for (const record of event.Records) {
    const key = record.s3.object.key;
// 如果是已处理的文件则跳过
    if (key.startsWith('processed/')) {
      console.log('Skipping already processed file:', key);
      continue;
    }
// 处理并写入到不同位置
    await processFile(key);
    await writeToS3(processed/${key}, result);
  }
};

Resources:
  RiskyFunction:
    Type: AWS::Serverless::Function
    Properties:
      ReservedConcurrentExecutions: 10  # 最大 10 个并行实例
      # 限制失控调用带来的影响范围

InvocationAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    MetricName: Invocations
    Namespace: AWS/Lambda
    Statistic: Sum
    Period: 60
    EvaluationPeriods: 1
    Threshold: 1000  # 每分钟调用数 >1000 时报警
    ComparisonOperator: GreaterThanThreshold