AWS Lambda

AWS Lambda 定价

开始免费使用
请求报价

概览

AWS Lambda 是一项无服务器计算服务，让您无需预置或管理服务器即可运行代码。创建工作负载感知型集群扩展逻辑，维护事件集成，并轻松管理运行时。借助 Lambda，您几乎可以为任何类型的应用程序或后端服务运行代码，而且完全无需管理，且仅需按您的使用量付费。我们将根据您函数的请求数量和执行代码所花费的持续时间向您收费。

Lambda 在每次为了响应事件通知触发器从 Amazon Simple Notification Service（SNS）或 Amazon EventBridge 等服务、或调用 Amazon API Gateway 等服务或通过 AWS 开发工具包（包括来自 AWS 管理控制台的测试调用）开始执行请求时将计算一次请求。

持续时间从您的代码开始执行时算起直到其返回或以其他方式终止为止，舍入到最近的 1ms*。价格取决于您为函数分配的内存量。在 AWS Lambda 资源模型中，您可以选择用于函数的内存量，这会分配等比例的 CPU 计算能力和其他资源。内存大小的增加会导致函数可用的 CPU 的等效增加。要了解更多，请参阅函数配置文档。

您可以在基于 x86 或 Arm 架构构建的处理器上运行 Lambda 函数。在 Graviton2 上运行的 AWS Lambda 函数，使用由 AWS 设计、基于 Arm 的处理器架构，与在 x86 处理器上运行的函数相比，性价比提升最高可达 34%。这可用于多种不同的无服务器工作负载，例如 Web 和移动后端、数据，以及媒体处理。

* 持续时间收费适用于在函数的处理程序中运行的代码以及在处理程序外部声明的初始化代码。对于使用 AWS Lambda 扩展的 Lambda 函数，持续时间还包括最后运行的扩展中的代码在关闭阶段完成执行所需的时间。对于使用 SnapStart 配置的 Lambda 函数，持续时间还包括加载运行时系统所需的时间、在运行时钩子中运行的任何代码以及在创建为恢复而创建的快照副本时执行的初始化代码。有关更多详细信息，请参阅 Lambda 编程模型文档。

AWS Lambda 免费套餐包括每月 100 万次免费请求和 400000GB 秒的计算时间，可用于由 x86、Graviton2 处理器或两者整合提供支持的函数。此外，免费套餐包括每月 100GiB 的 HTTP 响应流，不包括每个请求的前 6MB（免费）。Lambda 还为超过某些每月使用阈值的按需持续时间，提供分层定价选项。AWS Lambda 参加了 Compute Savings Plans，后者是一种灵活的定价模式，它以较低的 Amazon Elastic Compute Cloud (Amazon EC2)、AWS Fargate 和 Lambda 使用价格，换取在一年或三年期限内的稳定使用量承诺（以美元/小时为单位衡量）。通过 Compute Savings Plans，您最多可节省 17% 的 AWS Lambda 成本。Savings 适用于持续时间和预置的并发。了解更多

people at desk

AWS 定价计算器

在单次估计中计算您的 AWS Lambda 和架构成本。

立即创建您的自定义估计

hands with calculator

AWS Lambda 定价

Lambda（默认）函数

异步事件（包括来自 S3、SNS、EventBridge、StepFunctions、Cloudwatch Logs 的事件）：对于前 256KB，每个异步 Event 需要支付 1 次请求的费用。单个事件大小超过 256KB 时，每增加 64KB 数据块将需要额外支付 1 次请求的费用，直至 1MB。

持续时间成本取决于您为函数分配的内存量。您可以为函数分配介于 128MB 至 10240MB 之间的任何内存量，调节精度为 1MB。下表包含一些在不同内存大小下的每 1 毫秒价格示例，适用于属于第一个定价层的使用量，例如，美国东部（俄亥俄州）为最高 60 亿 GB 秒/月。

  • x86 价格
  • Arm 价格

Lambda 按需持续时间定价层适用于账户内，同一区域中采用相同架构（分别为 x86 或 Arm）所运行函数的每月累积持续时间。如果您在 AWS Organizations 中使用整合计费，则定价层将适用于跨组织的所有账户，在相同区域，采用相同架构运行的函数的每月累计持续时间。

Lambda 托管实例

Lambda 托管实例使您能够在完全托管于 VPC 中的 EC2 实例上运行 Lambda 函数，将 Lambda 的无服务器开发人员体验与 EC2 的成本效益和硬件灵活性相结合。此功能非常适合稳态、高容量的工作负载，在这些工作负载中，您希望在优化成本的同时，保持 Lambda 的操作简便性。

借助 Lambda 托管实例，您可以从多种最新一代 EC2 实例类型中进行选择以满足您的工作负载要求，从 EC2 实例节省计划、计算类节省计划和预留实例等 EC2 定价选项中受益，并在同一个执行环境中并行处理多个请求以最大限度地提高资源利用率。Lambda 可自动管理实例配置、扩展、补丁和生命周期管理，同时您保留熟悉的 Lambda 编程模型，并与 SQS、Kinesis 和 Kafka 等事件源无缝集成。

定价：
Lambda 托管实例的定价包含三个组成部分：

1.请求费用：每百万个请求 0.20 美元
2.计算管理费：对于由 Lambda 预置和管理的实例（对于下文提供的每种实例类型，需要高级才可享有），按 EC2 按需型实例价格收取 15% 的溢价
3.EC2 实例费用：标准 EC2 实例定价适用于在您容量提供商中预置的实例。您可以使用计算类节省计划、预留实例或其他 EC2 定价选项来降低成本

请注意，与 Lambda（默认）计算类型函数不同，Lambda 托管实例函数不会为每个请求的执行时长单独付费。

事件源映射：对于使用预置的事件轮询器单元 (EPU) 和 Kafka 或 SQS 等事件源的工作负载，适用每 EPU 小时 0.00925 美元的标准 EPU 定价。

  • 假设你正在运行一个高流量 API 服务，每月处理 1 亿个请求，每个请求的平均持续时间为 200 毫秒。您可以将 Lambda 托管实例容量提供商配置为使用 m7g.xlarge 实例（4 个 vCPU、16 GB 内存、Graviton3），并使用三年期计算节省类计划以最大限度地节省成本。

    月度费用

    请求费用
    每月请求：1 亿个请求
    请求价格：每百万个请求 0.20 美元
    月度请求费用：1 亿/100 万 × 0.20 美元 = 20 美元

    计算费用
    实例类型：m7g.xlarge
    EC2 按需价格：每小时 0.1632 美元（美国东部（弗吉尼亚北部））
    享有三年期计算类节省计划折扣 (72%)：每小时 0.0457 美元
    预计所需的实例小时数：约 2000 小时/月（基于工作负载模式和多并发性）
    每月 EC2 实例费用：2000 × 0.0457 美元 = 91.40 美元

    管理费用
    管理费：EC2 按需价格的 15%
    每小时管理费：0.1632 美元 × 0.15 美元 = 每小时 0.02448 美元
    每月管理费：2000 × 0.02448 美元 = 48.96 美元

    月度总费用
    总费用 = 请求费用 + EC2 实例费用 + 管理费
    总费用 = 20 美元 + 91.40 美元 + 48.96 美元 = 160.36 美元

租户隔离定价

启用租户隔离模式，隔离调用 Lambda 函数的个人最终用户或租户的请求处理。租户隔离的 Lambda 函数的底层执行环境始终与特定租户相关联，从不用于执行来自调用相同函数的其他租户的请求。此功能简化了多租户应用程序的开发和维护，这些应用程序在租户之间具有严格的隔离要求的情况下处理租户特定的代码或数据。当 Lambda 创建新的租户隔离执行环境来处理请求时，您需要付费，具体取决于您分配给函数的内存量和使用的 CPU 架构。要了解有关 Lambda 租户隔离功能的更多信息，请阅读文档。

  • 多租户 SaaS 应用程序

    假设你正在构建一个自动化平台，该平台执行用户提供的代码以响应事件。例如，当新员工加入其组织或跨部门调动时，IT 团队可能希望执行自动化工作流程。再举一个例子，当开发人员向其源代码存储库提交代码更改时，DevOps 团队可能希望触发 CI/CD 工作流程。您的自动化平台是多租户的，这意味着它为多个最终用户提供服务。由于您预计需求会因一天中的不同时间以及每个最终用户或租户而异，因此您可以使用包括 AWS Lambda 在内的无服务器服务来构建平台。

    您的自动化平台支持运行用户提供的代码以响应事件的功能。由于您无法控制用户提供的代码，因此您可以启用租户隔离模式，以确保在相互隔离的单独执行环境中处理每个最终用户的 Lambda 函数调用。

    假设您已使用 1024MB 的内存和 x86 CPU 架构配置了 Lambda 函数。在一个典型的月份中，您的函数处理 1000 万次调用，每次调用的平均持续时间为 2 秒。有 1K 个最终用户或租户使用您的 SaaS 平台。为简单起见，假设每个租户平均每月生成 10K 次调用，而 Lambda 为每个租户创建 200 个执行环境（即每个租户的冷启动率为 2%）。

    费用将按以下方式计算：

    请求费用
    您的函数每月执行 1000 万次。

    月度请求费用：1000 万 * 0.2 美元/M = 2 美元。

    计算费用
    您的函数每月执行 1000 万次，平均持续时间为 2 秒。您的函数的配置内存为 1024 MB。

    每月计算时长（秒）：1000 万 * 2 秒 = 20M 秒
    每月计算 (GB-s)：2000 万秒 * 1024MB/1024 MB = 2000 万 GB-s
    每月计算费用 = 2000 万 * 0.0000166667 美元 = 333.34 美元

    租户隔离费
    平均而言，您的函数每月为 1K 个独立租户提供服务。每个租户调用该函数 10K 次，平均每个租户创建 200 个执行环境（即每个租户的平均冷启动率为 2%）。

    每月为 1K 租户创建的执行环境数：200 * 1K = 200K
    每月租户隔离费用：200K * 0.000167 美元 * 1024 MB/1024 MB = 33.4 美元

    月度总费用
    总费用 = 请求费用 + 计算费用 + 租户隔离费用
    总费用 = 2 美元 + 333.34 美元 + 33.4 美元 = 368.74 美元

Lambda 短暂存储定价

短暂存储成本取决于您分配给函数的短暂存储量，以及函数执行持续时间（以毫秒为单位）。您可以以 1MB 为增量为函数分配介于 512MB 至 10240MB 之间的任何额外存储量。您可以为在 x86 和 Arm 架构上运行的函数配置短暂存储。每个 Lambda 函数都可以免费使用 512MB 短暂存储。您只需为配置的额外短暂存储付费。

以下所有示例均基于美国东部（弗吉尼亚北部）的价格。

  • 假设您是一名移动应用程序开发人员，正在构建食品订购应用程序。客户可以使用该应用程序从特定的餐厅点餐、接收订单状态更新，并在订单准备好时取餐。因为您预计需求会根据一天中的时间和餐厅位置有很大的变化，所以您使用无服务器服务构建移动后端，包括 AWS Lambda。

    为简单起见，我们假设您的应用程序每月处理 300 万个请求。函数平均执行持续时间为 120 ms。您在基于 x86 的处理器上为您的函数配置了 1536MB 的内存。费用将按以下方式计算：

    月度计算费用

    月度计算价格为每 GB-s 0.0000166667 美元，免费套餐提供 40 万 GB-s。
    总计算时间（秒）= 300 万 * 120ms = 360000 秒
    总计算量 (GB-s) = 360000 * 1536MB/1024 MB = 540000 GB-s
    总计算 – 免费套餐计算 = 月度计费计算 GB- s
    540000 GB-s – 400000 免费套餐 GB-s = 140000 GB-s
    月度计算费用 =     140000 * 0.0000166667 USD = 2.33 USD

    月度请求费用

    月度请求价格为每 100 万个请求 0.20 USD，免费套餐每月提供 100 万个请求。
    总请求数量 – 免费套餐请求数量 = 月度计费请求数量
    300 万请求 – 100 万免费套餐请求 = 200 万月度计费请求
    月度请求费用 = 2M * 0.2 USD/M = 0.40 USD

    月度总费用

    总费用 = 计算费用 + 请求费用 = 2.33 USD + 0.40 USD = 2.73 USD/月

  • 假设您是一家物流公司，在现场有一支车队，每辆车都配备了传感器和 4G/5G 连接，用于将遥测数据发送到 Amazon Kinesis 数据流中。您想要使用您开发的机器学习 (ML) 模型推断车辆的运行状况，并预测何时需要对特定组件进行维护。

    假设您在现场有 10000 辆车辆，每辆车每小时以交错的方式发射一次遥测信号，并且带有足够的抖动。您打算对每个有效负载执行此推断，以确保车辆被及时安排进行维护，并确保车队处于最佳运行状态。

    假设 ML 模型随函数一起打包，且大小为 512MB。为了进行推断，您已经为函数配置了 1GB 内存，且在基于 x86 的处理器上，函数执行平均需要 2 秒才能完成。

    月度请求费用：
    车辆每月发送 10000 * 24 * 31 = 7440000 条消息，这些消息将由 Lambda 函数处理。

    月度请求费用 → 7.44M * 0.20 USD/M = 1.488 USD ~= 1.49 USD

    月度计算费用：
    每条消息每月将执行一次函数，时间为两秒钟。

    月度计算持续时间（秒） → 744 万 * 2 秒 = 1488 万秒
    月度计算量 (GB-s) → 1488 万秒 * 1024 MB/1024 MB = 14.88 GB-s
    月度计算费用 → 1488 万 GB-s * 0.0000166667 USD = 248.00 USD

    月度总费用：
    月度总费用 = 请求费用 + 计算费用 = 1.49 USD + 248.00 USD = 249.49 USD

  • 假设您是一家金融服务公司，希望更好地了解您的主要客户服务问题。您的目标是改善客户体验，减少客户流失。您的客户可以通过您提供的移动应用程序与客户支持人员实时聊天。您决定部署自然语言处理 (NLP) 模型。

    在本例中，您将使用 AWS Lambda 中热门的基于转换器的双向编码器表示形式 (BERT) 模型。该模型帮助您解析、分析和理解通过移动应用程序进行的客户服务交互，以显示相关的支持内容或将客户路由到适当的客户服务代理。您的推理模型处理的支持查询的数量在一周内变化很大。

    假设您运行推理模型的函数每月收到 600 万个请求。函数平均执行持续时间为 280 ms。您在基于 x86 的处理器上为您的函数配置了 4096MB 的内存。

    您还可以将函数配置为使用 2048MB 短暂存储。

    费用将按以下方式计算：

    月度计算费用：
    月度计算价格为每 GB-s 0.0000166667 美元，免费套餐提供 40 万 GB-s。
    总计算时间（秒）= 600 万 * 280ms = 168 万秒
    总计算 (GB-s) = 1680000 * 4096 MB/1024 MB = 6720,000 GB-s
    总计算 – AWS 免费套餐计算 = 月度计费计算 GB- s
    6720000 GB-s – 400000 免费套餐 GB-s = 6320000 GB-s
    月度计算费用 = 632 万 * 0.0000166667 美元 = 105.33 美元

    月度请求费用：
    月度请求价格为每 100 万个请求 0.20 美元，免费套餐每月提供 100 万个请求。
    总请求数量 – 免费套餐请求数量 = 月度计费请求数量
    600 万请求 – 100 万免费套餐请求 = 500 万月度计费请求
    月度请求费用 = 500 万 * 0.2 美元/100 万 = 1 美元

    月度短暂存储费用：
    月度短暂存储价格为每 GB 秒 0.0000000309 美元，Lambda 提供 512 MB 存储（无需额外成本）。
    总计算时间（秒）= 600 万 * 280ms = 168 万秒
    短暂存储总应计费 = 2048MB – 512MB = 1536MB
    短暂存储总计 (GB-s) = 168 万 * 1536MB/1024MB = 252 万 GB-s
    月度短暂存储费用 = 252 万 * 0.0000000309 美元 = 0.08 美元

    月度总费用：
    总费用 = 计算费用 + 请求费用 = 105.33 美元 + 1 美元 + 0.08 美元 = 106.41 美元/月

预置并发定价

为 Lambda 函数启用预置并发，使您能够更好地控制无服务器应用程序的性能。启用后，预置并发将使函数保持初始化状态，并准备好在两位数毫秒内进行响应。您需要为配置的并发量以及配置所用的时间付费。为您的函数启用预置并发并执行它时，您还需要根据以下价格为请求和持续时间付费。如果函数超过配置的并发量，则您需要按照上面 AWS Lambda 定价部分中列出的费率为多余的函数执行支付费用。您可以为在 x86 和 Arm 架构上运行的函数启用预置并发。有关预置并发的更多信息，请阅读文档。

预置并发从在函数上启用它时开始算起直至将其禁用，舍入到最近的 5 分钟。价格取决于您为函数分配的内存量以及在其上面配置的并发量。持续时间从您的代码开始执行时算起直到其返回或以其他方式终止为止，舍入到最近的 1ms**。价格取决于您为函数分配的内存量。

** 持续时间收费适用于在函数的处理程序中运行的代码以及在处理程序外部声明的初始化代码。对于使用 AWS Lambda 扩展程序的 Lambda 函数，持续时间还包括为了完成在关闭阶段期间的执行而最后一次运行扩展程序所用的时间。对于使用预置并发配置的函数，AWS Lambda 会定期循环执行环境并重新运行初始化代码。有关更多详细信息，请参阅 Lambda 编程模型文档。

Lambda 免费套餐不适用于启用预置并发的函数。如果已为函数启用预配置并发并执行它，则您需要根据以下价格为请求和持续时间付费。

以下所有示例均基于美国东部（弗吉尼亚北部）的价格。

  • 假您是一名移动应用程序开发人员，正在构建食品订购移动应用程序。客户可以使用该应用程序从特定的餐厅点餐、接收订单状态更新，并在订单准备好时取餐。因为您预计您的应用程序需求会根据一天中的时间和餐厅位置有很大的变化，所以您使用无服务器服务构建移动后端，包括 AWS Lambda。

    为简单起见，我们假设您的应用程序每月处理 300 万个请求。函数
    平均执行持续时间为 120 ms。您在基于 x86 的处理器上为您的函数配置了 1536MB 的内存。

    您在发布新版本的移动应用程序，您已经对它进行了大量营销。您预计发布当天（从中午到晚上 8 点）需求会出现高峰。您希望您的移动应用程序即使在需求快速扩展和缩减也能响应，因此您在 Lambda 函数上启用了预置并发。您将预置并发设置为 100。

    在这八小时期间，您的函数收到 500000 个请求。启用预置并发时
    函数平均执行持续时间为 100 ms。在该月剩下的时间里，您的应用程序将收到额外的 250 万个请求，而您的函数将在未启用预置并发的情况下响应这些请求。

    费用将按以下方式计算：

    预置并发费用：
    预置并发价格为每 GB-s 0.0000041667 USD
    预置并发启用的总时长（秒）：8 小时 * 3600 秒 = 28800 秒
    配置的总并发 (GB)：100 * 1536MB/1024MB = 150 GB
    总预置并发量 (GB-s) = 150 GB * 28800 秒 =4320000 GB-s
    预置并发费用：432 万 GB-s * 0.0000041667 USD = 18 USD

    请求费用：
    月度请求价格为每 100 万个请求 0.20 USD，免费套餐每月提供 100 万个请求。
    总请求数量 – 免费套餐请求数量 = 月度计费请求数量
    300 万个请求 – 100 万个免费套餐请求 = 200 万个月度计费请求
    月度请求费用 = 2 * 0.20 USD = 0.40 USD

    预置并发启用时的计算费用：
    计算价格为每 GB-s 0.0000097222 USD
    总计算持续时间（秒）= 500000 * 100ms = 50000 秒
    总计算 (GB-s) = 50000 秒 * 1536MB / 1024MB = 75000 GB-s。
    总计算费用 = 75000 GB-s * 0.0000097222 USD = 0.73 USD

    预置并发禁用时的计算费用：
    月度计算价格为每 GB-s 0.0000166667 USD，免费套餐提供 40 万 GB-s。
    总计算（秒）= 250 万 * 120ms = 300000 秒
    总计算 (GB-s) = 300000 * 1536 MB / 1024 MB = 450000 GB-s
    总计算 – 免费套餐计算 = 月度计费计算 GB- s
    450000 GB-s – 400000 免费套餐 GB-s = 50000 GB-s
    月度计算费用 = 50000 * 0.0000166667 USD = 0.83 USD

    月度总费用：
    总费用 = 预置并发费用 + 请求费用 + 启用预置并发时的计算费用 + 禁用预置并发时的计算费用
    总费用 = 18 USD + 0.40 USD + 0.73 USD + 0.83 USD = 19.96 USD

  • 假设您是一个在 Cyber Monday（网络星期一）进行大减价的零售商，“网络星期一”是美国的一个电子商务节日，在感恩节后的周一举行。您的客户可以通过您提供的移动应用程序与客户支持实时聊天。您决定部署自然语言处理 (NLP) 模型。

    在本例中，您将使用 AWS Lambda 中热门的基于转换器的双向编码器表示形式 (BERT) 模型。该模型帮助您解析、分析和理解通过移动应用程序进行的客户服务交互，以显示相关的支持内容或将客户路由到适当的客户服务代理。在这次销售期间，您将收到比平时多得多的客户支持咨询，因此您决定在 Lambda 函数上启用预置并发，以使您的应用程序即使在遇到流量峰值时也能快速响应。

    假设您的函数在启用了预置并发的情况下在此次 24 小时的销售活动内收到 200 万个请求。函数平均执行持续时间为 280 ms。您在基于 x86 的处理器上为您的函数配置了 4096MB 的内存，并将预置并发设置为 7。

    费用将按以下方式计算：

    预置并发费用：
    预置并发价格为每 GB-s 0.0000041667 USD。
    预置并发启用的总时长（秒）= 24 小时 * 3600 秒 = 86400 秒
    配置的总并发 (GB)：7 * 4096 MB / 1024 MB = 28 GB
    总预置并发量 (GB-s) = 28 GB * 86400 秒 = 2419200 GB-s
    预置并发费用 = 2419200 GB-s * 0.0000041667 USD = 10.08 USD

    预置并发启用时的计算费用：
    计算价格为 0.0000097222 USD/GB-s。
    总计算持续时间（秒）= 2000000 * 280ms = 560000 秒
    总计算 (GB-s) = 560000 秒 * 4096 MB / 1024 MB = 2240000 GB-s。
    月度计算费用 = 2240000 GB-s * 0.0000097222 USD = 21.78 USD

    月度请求费用：
    月度请求价格为每 100 万个请求 0.20 USD。
    月度请求费用 = 2M * 0.2 USD/M = 0.40 USD

    月度总费用：
    总费用 = 预置并发费用 + 启用预置并发时的计算费用 + 请求费用 = 10.08 USD + 21.78 USD + 0.40 USD = 32.26 USD

SnapStart 定价

对于延迟敏感的应用程序，SnapStart 可以将启动性能从几秒提高到亚秒级。SnapStart 通过对函数的初始化内存（和磁盘）状态进行快照并缓存此快照来实现低延迟访问。当您的函数随后被调用时，Lambda 会从这个预初始化的快照恢复执行环境，而不是从头开始初始化它们，从而缩短启动延迟。

每次在启用 SnapStart 的情况下发布新版本的函数时，都会创建一个快照。您需要为函数版本处于活动状态期间的快照缓存付费，3 小时起付，之后按毫秒收费。价格取决于您为函数分配的内存量。每次 Lambda 通过恢复快照来恢复执行环境时，也会向您收费，具体价格取决于您为函数分配的内存量。

SnapStart 定价不适用于受支持的 Java 管理运行时。

  • 假设您是一家物流公司，在现场有一支车队，每辆车都配备了传感器和 4G/5G 连接，用于将遥测数据发送到 Amazon Kinesis 数据流中。您想要使用您开发的机器学习 (ML) 模型推断车辆的运行状况，并预测何时需要对特定组件进行维护。

    假设您在现场有 10000 辆车辆，每辆车每小时以交错的方式发射一次遥测信号，并且带有足够的抖动。您打算对每个有效负载执行此推断，以确保车辆被及时安排进行维护，并确保车队处于最佳运行状态。

    假设 ML 模型随函数一起打包，且大小为 512MB。为了进行推理，您已经为函数配置了 1GB 内存，并且在基于 x86 的处理器上，计费执行时长平均为两秒。您可以维护函数的单一版本。为简单起见，我们假设 1% 的请求会导致新执行环境的创建。

    您注意到，对于这 1% 的请求，端到端处理需要几秒钟。这是由于您的函数初始化需要几秒钟，因为您在初始化期间导入了大型软件模块和机器学习模型。您希望减少这些请求的端到端处理时间，因此您在函数上启用了 SnapStart 并发布了新版本。

    费用将按以下方式计算：

    请求费用
    车辆每月发送 10000 * 24 * 31 = 7440000 条消息，这些消息将由 Lambda 函数处理。

    月度请求费用：744 万 * 0.20 USD/百万次 = 1.49 USD

    月度计算费用
    您的函数每个月将在每条消息中执行一次，持续两秒钟。

    月度计算持续时间（秒）：744 万 * 2 秒 = 1488 万秒
    每月计算（GB-s）：1488 万秒 * 1024 MB/1024 MB = 1488 万 GB-s
    月度计算费用：1488 万 GB-s * 0.0000166667 USD = 248.00 USD

    SnapStart 收费：

    函数版本处于活动状态的总时间段（秒）：24 小时 * 31 天 * 3600 秒 = 2678400 秒
    分配的函数内存：1024MB/1024MB -> 1 GB
    SnapStart 缓存总使用量：1GB * 2678400 秒 -> 2678400 GB-S
    SnapStart 缓存费用：268 万 GB-秒 * 0.0000015046 USD = 4.03 USD

    使用 SnapStart 还原的请求数：744 万的 1% = 74400
    SnapStart 还原总使用量：74400 * 1 GB = 74400 GB
    SnapStart 还原费用：74400 GB * 0.0001397998 USD = 10.4 USD

    SnapStart 总费用：SnapStart 缓存费用 + SnapStart 还原费用
    SnapStart 总费用：4.03 USD + 10.4 USD = 14.43 USD

    月度总费用

    总费用 = 请求费用 + 计算费用 + SnapStart 费用
    总费用 = 1.49 USD + 248.00 USD + 14.43 USD = 263.92 USD

Lambda HTTP 响应流定价

通过 InvokeWithResponseStream API 或使用 ResponseStream 调用模式通过函数 URL 调用时，AWS Lambda 函数可以返回 HTTP 响应流。HTTP 响应流可以提高首字节时间性能，并支持大于 6 MB 的有效负载。使用 HTTP 响应流时，您需要为函数写入响应流的每 GB 付费。您可以免费流式传输每个请求的前 6 MB。

以下所有示例均基于美国东部（弗吉尼亚州北部）的价格。

事件源映射（ESM）预置模式的定价

ESM 的预置模式允许您分配最小和最大数量的资源（称为事件轮询器）并在配置的最小和最大限制之间自动扩展，从而优化 ESM 的吞吐量。事件轮询器是一种可配置资源，它支持预置模式下的 ESM。定价基于预置的最小事件轮询器和自动扩展期间使用的事件轮询器。使用称为事件轮询器单元（EPU）的计费单位计算费用。您需要为使用的 EPU 数量和持续时间（以事件轮询器单元小时为单位）付费。

SQS ESM：EPU 支持一个事件轮询器，每个轮询器提供高达 1 MB/s 的吞吐量。 每个 SQS ESM 至少需要 2 个事件轮询器。

MSK 或自管理 Kafka（SMK）ESM：每个 EPU 支持高达 20 MB/s 的事件轮询吞吐能力，默认为 10 个事件轮询器。每个事件轮询器最多可以纵向扩展到 5 MB/s 的吞吐量。在 EPU 上分配的事件轮询器的数量取决于每个事件轮询器消耗的计算容量。您可以在同一 Amazon VPC 中对多个 ESM 进行分组，以共享 EPU 容量和成本。要了解 Kafka ESM 的预置模式，请阅读文档。 

数据传输：根据标准的 AWS 数据传输费率向您收取费用。

持续时间：定价以秒为单位计算，最低标准为 1 分钟。

  • 示例：使用 Kafka 进行实时流式传输数据分析

    假设您是一家全球客户联络中心解决方案提供商，并且拥有将与呼叫体验相关的元数据发送到 Amazon MSK（Kafka）主题进行实时分析的管道。由于流量可能出现高峰且不可预测，因此您希望使用 ESM 的预置模式来微调 ESM 的性能。假设处理这些消息的 Lambda 函数为 x86 处理器配置了 1024MB 内存，并且每天经历 100 万次调用，平均持续时间为 2 秒。假设您使用默认的 1 个事件轮询器为 ESM 激活了预置模式，并且您的 ESM 在美国东部（弗吉尼亚州北部）每月消耗 800 个 EPU 小时。

    月度计算费用
    月度计算价格为每 GB-s 0.0000166667 美元，免费套餐提供 40 万 GB-s
    总计算（秒）= 100 万 * 30 * 2 秒 = 6000 万秒
    总计算（GB-s）= 6000 万 * 1024MB/1024 = 6000 万 GB-s
    总计算 – 免费套餐计算 = 月度计费计算 GB-s
    6000 万 GB-s – 40 万免费套餐 GB-s = 5960 万 GB-s
    每月计算费用 = 5960 万 * 0.0000166667 美元 = 993.3 美元

    月度请求费用
    月度请求价格为每 100 万个请求 0.20 美元。
    月度请求费用 = 6000 万个请求 * 0.20 美元 = 12.00 美元

    ESM 费用的按月预置模式
    EPU 费用 = 800 EPU 小时 * 0.185 美元 = 148 美元
    ESM 费用的每月预置模式 = 148 美元

    总费用
    总费用 = 计算费用 + 请求费用 + ESM 费用的预置模式
    总费用 = 993.3 美元 + 12 美元 + 148 美元 = 1153.3 美元

     

  • 示例：使用 Amazon SQS 进行实时事件处理

    假设你是一家金融服务公司，使用面向客户的实时金融应用程序，通过事件驱动的微服务来处理市场数据源并执行金融交易。由于流量可能出现激增且无法预测，因此您希望使用 ESM 的预置模式以微调 ESM 的性能。假设处理这些消息的 Lambda 函数为 x86 处理器配置了 1024 MB 内存，并且每天经历 1M 次调用，平均持续时间为 1 秒。您要处理的最大事件 TPS 为 100，最大延迟为 0.2 秒。为了实现这种延迟性能，您已经激活了 SQS ESM 的预置模式，并启用了至少 10 个事件轮询器，并且您的 ESM 可以纵向扩展到在美国东部（弗吉尼亚北部）地区每月消耗 8000 个 EPU 小时，以处理高峰的低延迟流量。

    月度计算费用
    月度计算价格为 0.0000166667 美元/GB-s
    总计算（秒）= 1000000 * 30 * 1 秒 = 30000000 秒
    总计算（GB-s）= 30000000 * 1024MB/1024 = 30000000GB-s
    总计算 = 月度计费计算 GB-s * 0.0000166667 美元
    每月计算费用 = 30000000 * 0.0000166667 美元 = 500 美元

    月度请求费用
    月度请求价格为每 100 万个请求 0.20 美元。
    月度请求费用 = 3000 万个请求 * 0.20 美元 = 6.00 美元

    SQS ESM 费用的每月预置模式
    EPU 价格为每 EPU 小时 0.00925 美元
    EPU 费用 = 8000 EPU 小时 * 0.00925 美元 = 74 美元
    ESM 费用的每月预置模式 = 74 美元

    总费用
    总费用 = 计算费用 + 请求费用 + ESM 费用的预置模式
    总费用 = 500 美元 + 6 美元 + 74 美元 = 580 美元

  • 假设您是一家全球客户联络中心解决方案提供商，并且拥有将与呼叫体验相关的元数据发送到数十个 Amazon MSK（Kafka）主题，每个主题都会从您的多种产品中提取信息。每个主题每秒最多提取 500 条消息，平均消息大小为 3 KB，峰值吞吐量为 1.5 MB/s。由于流量可能出现高峰且不可预测，因此您希望使用 ESM 的预置模式来微调 ESM 的性能。假设处理这些消息的 Lambda 函数为 x86 处理器配置了 1024 MB 内存，并且每天经历 100 万次调用，平均持续时间为 0.2 秒。您创建了 10 个 Kafka ESM 用于事件处理，每个 ESM 的吞吐量小于 1.5 MB/s，您决定将它们归入同一 Poller 组以优化成本。假设您使用默认的 1 个事件轮询器为 ESM 激活了预置模式，并且您正在使用美国东部（弗吉尼亚北部）同一个轮询器组中的所有 10 个 ESM。

    月度计算费用
    月度计算价格为每 GB-s 0.0000166667 美元，免费套餐提供 40 万 GB-s
    总计算（秒）= 1000000 * 30 * 2 秒 = 6000000 万秒
    总计算（GB-s）= 6000000 * 1024MB/1024 = 6000000GB-s
    所有 10 个 ESM 的总计算量 (GB-s) = 6000000Gb-s * 10 = 60000000GB-s
    每月计算费用 = 60000000 * 0.0000166667 美元 = 1000 美元
    月度请求费用
    月度请求价格为每 100 万个请求 0.20 美元。
    所有 100 个 ESM 的月度请求总数 = 100 万 * 30 天 * 10 个 ESM = 3 亿个请求
    月度请求费用 = 3 亿个请求 * 0.20 美元 = 60.00 美元
    ESM 费用的每月预置模式
    EPU 小时价格为每小时 0.185 美元，每个 EPU 支持 10 个事件轮询器。
    每小时事件轮询器总数 = 1 个事件轮询器 * 10 个 ESM = 10 个事件轮询器
    使用的 EPU = 使用 10 个事件轮询器/每个 EPU 支持 10 个事件轮询器 = 1 个 EPU
    每月总计 EPU = 1 EPU * 每月 720 小时 = 720 EPU 小时
    EPU 费用 = 720 EPU 小时 * 0.185 美元 = 133.2 美元
    ESM 费用的每月预置模式 = 133.2 美元
    总费用
    总费用 = 计算费用 + 请求费用 + ESM 费用的预置模式
    总费用 = 1000 美元 + 60 美元 + 133.2 美元 = 10 个 ESM 每月 1193.2 美元
    每个 ESM 的每月费用 = 1193.2 美元/10 = 每个 ESM 每月 119.3 美元

数据传输和其他费用

数据传输
从函数执行区域外“转入”和“转出”AWS Lambda 函数的数据，将按照“数据传输”下列出的 Amazon EC2 数据传输速率收费。

在同一个 AWS 区域内，在以下服务之间使用 AWS Lambda 函数进行数据传输是免费的：Amazon Simple Storage Service (S3)、Amazon Glacier、Amazon DynamoDB、Amazon Simple Email Service (SES)、Amazon Simple Queue Service (SQS)、Amazon Kinesis、Amazon Elastic Container Registry (ECR)、Amazon Simple Notification Service (SNS)、Amazon Elastic File System (EFS) 和 Amazon SimpleDB。

结合使用 Amazon Virtual Private Cloud（VPC）或 VPC 对等连接与 AWS Lambda 函数将产生额外的费用，如 Amazon Elastic Compute Cloud（EC2）按需定价页面上所述。VPC 对等连接是两个 VPC 之间的网络连接，通过此连接，您可以使用私有 IPv4 地址或 IPv6 地址在这两个 VPC 之间路由流量。 

额外费用
如果您的 Lambda 函数使用了其他 AWS 服务或传输了数据，则可能会产生额外费用。例如， 如果您的 Lambda 函数从 Amazon S3 读取或写入数据，您将因发送读写请求或在 Amazon S3 中存储数据而产生费用。

有关 AWS 服务定价的详情，请参阅相关 AWS 服务详情页面的定价部分。

Lambda@Edge 定价

Lambda@Edge 函数的最小计费时间单位为 1ms

其他定价资源

AWS 定价计算器

轻松计算 AWS 的月度费用

获取定价协助

联系 AWS 专家获取个性化报价