AWS Lambda 定价

适用于各种工作负载的无服务器计算

概述

AWS Lambda 是一项无服务器计算服务，仅按实际使用量向您收费。Lambda 事件函数按请求次数和执行时长定价。Lambda MicroVM 按实例秒数定价。Lambda Web 函数按请求次数和活跃 CPU 时间定价。
  • 事件函数

  • Lambda 事件函数定价

    Lambda 事件函数根据所处理的请求数量和代码运行的持续时间进行定价，以 GB 秒为单位。您可以选择分配给函数的内存并按比例获得 CPU 和资源。免费套餐包含每月 1 百万次请求以及 400000 GB 秒的计算时间。

    异步事件（包括来自 S3、SNS、EventBridge、StepFunctions、Cloudwatch 日志的事件）：对于每一次异步事件前 256 KB 的载荷，您需要支付 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 定价。

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

      月度费用

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

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

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

      每月总费用
      总费用 = 请求费用 + EC2 实例费用 + 管理费
      总费用 = 20 USD + 91.40 USD + 48.96 USD = 160.36 USD

    Lambda 耐用函数定价

    Lambda 耐用函数可简化您直接在 Lambda 的现有编程模型内构建可靠的多步骤应用程序和人工智能工作流的方式，从而支持弹性、经济高效、长期运行的工作负载。在耐用函数中，您可以使用“步骤”和“等待”等持久化操作；这些操作相当于检查点，可存储相关数据并长期保留，从而使您的函数能够在中断后恢复执行。当函数恢复执行时，系统会执行重播，从头开始自动重新执行事件处理程序，同时跳过已完成的检查点并从中断处继续执行。生命周期可能包含多个子调用（在发生等待操作、重试或基础设施故障之后进行恢复时执行的 Lambda 函数调用），以便完成执行。 

    需要支付现有的 Lambda 计算费用，包括来自重播的子调用的费用。使用等待操作时，此函数会暂停执行，对于按需函数，在恢复执行之前不会产生持续时间费用。此外，您还需要为耐用操作（例如开始执行、完成步骤和创建等待）付费。您还需要为这些操作写入的数据量（以 GB 为单位）以及执行期间和执行之后的数据留存付费（以 GB 月为单位，按比例计算）。可以将完成之后的保留期配置为 1 到 90 天（默认为 14 天）。 

    有关耐用操作的完整列表和详细描述，请参阅 Lambda 开发人员指南。

    • 一个保险索赔处理系统使用 Lambda 耐用函数来分析索赔以便检测欺诈行为，协调对高额索赔进行的人工审查，并处理已批准的付款。这一过程从文档分析步骤开始，此步骤需要花费 30 秒钟的时间执行基于 LLM 的欺诈检测和风险评估。随后，此次执行使用一个等待操作来暂停执行以便进行人工审查（通常等待 7 天），在此期间，理算师会审查超过自动批准阈值的索赔。最后，付款步骤需要花费 2 秒钟的时间处理用于启动付款的批准决定。该系统每月处理 100 万次保险索赔。每次执行都使用 8 KB 的调用有效载荷和 32 KB 的有效负载来进行索赔分析（步骤 1）、批准决策（等待）和最终付款处理（步骤 2）。此函数在基于 ARM 的处理器上配有 1 GB 的内存。为了进行审计和确保合规性，已完成的索赔记录将保留 14 天。注意：示例基于美国东部（弗吉尼亚州北部）的价格。所有执行都从月初开始，所有步骤在首次尝试时都取得了成功，无需重试，以便简化计算。

      注意：示例基于美国东部（弗吉尼亚州北部）的价格。所有执行都从月初开始，所有步骤在首次尝试时都成功，无需重试，以简化计算。

      月度计算费用

      总计算（秒） 100 万 × 32 秒 = 3200 万秒
      总计算（GB-s） 3200 万 × 1 GB = 3200 万 GB-s
      应计费计算 3200 万 - 40 万免费套餐 = 3160 万 GB-s
      计算成本 3160 万 × 0.0000133334 美元 = 421.34 美元

      月度请求费用

      请求总数 2 次调用（初始 + 等待之后）× 100 万 = 200 万个请求
      计费请求 200 万 - 100 万免费套餐 = 100 万
      请求成本 100 万 × 0.20 美元/百万次 = 0.20 美元


      月度耐用函数费用

      操作 100 万 ×（1 次开始执行 + 2 个步骤 + 1 次等待）= 400 万
      操作成本 400 万 × 8.00 美元/百万次 = 32.00 美元
      写入的数据 1M ×（8KB 调用 + 3 × 32KB 步骤/等待）= 104GB
      写入数据成本 104 GB × 0.25 美元/GB = 26.00 美元
      存储（正在运行，包括 7 天等待） 104GB × (7/30) = 24.27 GB-月
      存储（保留 14 天） 104GB ×（14/30）= 48.53 GB-月
      保留数据成本 （24.27 + 48.53）GB-月 × 0.15 USD/GB-月 = 10.92 USD

       

      月度总费用

      总费用 421.34 美元 + 0.20 美元 + 32.00 美元 + 26.00 美元 + 10.92 美元 = 490.46 美元

    租户隔离定价

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

    • 多租户 SaaS 应用程序

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

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

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

      费用将按以下方式计算：

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

      月度请求费用：10M * 0.2 USD/M = 2 USD。

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

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

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

      每月为 1000 个租户创建的执行环境数：200 * 1K = 20 万
      每月租户隔离费：20 万 * 0.000167 USD * 1024 MB / 1024MB = 33.4 USD

      每月费用总额
      总费用 = 请求费用 + 计算费用 + 租户隔离费用
      总费用 = 2 USD + 333.34 USD + 33.4 USD = 368.74 USD

    Lambda 临时存储定价

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

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

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

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

      月度计算费用

      月度计算价格为每 GB-s 0.0000166667 USD，免费套餐提供 40 万 GB-s。
      总计算（秒）= 300 万 * 120 ms = 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 万个月度计费请求
      每月请求费用 = 200 万 * 0.2 USD/百万次 = 0.40 USD

      月度总费用

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

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

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

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

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

      每月请求费用 → 744 万 * 0.20 USD/百万次 = 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 USD，免费套餐提供 40 万 GB-s。
      总计算（秒）= 6M * 280ms = 1680000 秒
      总计算（GB-s）= 1680000 * 4096 MB/1024 MB = 6720000 GB-s
      总计算 - AWS 免费套餐计算 = 每月计费计算 GB-s
      6720000 GB-s - 400000 个免费套餐 GB-s = 6320000 GB-s
      每月计算费用 = 6320000 * 0.0000166667 USD = 105.33 USD

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

      月度临时存储费用：
      月度临时存储价格为每 GB 秒 0.0000000309 美元，Lambda 提供 512 MB 存储（无需额外成本）。
      总计算（秒）= 6M * 280ms = 1680000 秒
      可计费的临时存储空间总量 = 2048 MB - 512 MB = 1536 MB
      临时存储总量（GB-s）= 1680000 * 1536 MB/1024 MB = 2520000 GB-s
      每月临时存储费 = 2520000 * 0.0000000309 USD = 0.08 USD

      月度总费用：
      总费用 = 计算费用 + 请求费用 = 105.33 USD + 1 USD + 0.08 USD = 每月 106.41 USD

    预置并发定价

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

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

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

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

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

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

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

      您在发布新版本的移动应用程序，您已经对它进行了大量营销。您预计在产品发布当天中午 12 点到晚上 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 秒 * 1536 MB / 1024 MB = 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 Event 函数上启用预置并发，以使您的应用程序即使在遇到流量峰值时也能快速响应。

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

      费用将按以下方式计算：

      预置并发费用：
      预置并发价格为每 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
      每月请求费用 = 200 万 * 0.2 USD/百万次 = 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）：14.88M 秒 * 1024 MB/1024 MB = 14.88M GB-s
      每月计算费用： 14.88M GB-s * 0.0000166667 USD = 248.00 USD

      SnapStart 费用：

      函数版本处于活动状态的总时间段（秒）：24 小时 * 31 天 * 3600 秒 = 2678400 秒
      分配的函数内存：1024MB/1024MB -> 1 GB
      使用的 SnapStart 缓存总量：1 GB * 2678400 s -> 2678400 GB-S
      SnapStart 缓存费用： 268 万 GB-s * 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 Event 函数可以返回 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 美元，免费套餐提供 400000 GB-s
      总计算（秒）= 1000000 * 30 * 2 秒 = 60000000 秒
      总计算（GB-s）= 60000000 * 1024MB/1024 = 60000000 GB-s
      总计算 - 免费套餐计算 = 每月计费计算 GB-s
      60000000 GB-s - 400000 个免费套餐 GB-s = 59600000 GB-s
      每月计算费用 = 59600000 * 0.0000166667 USD = 993.3 USD

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

      ESM 预置模式的月度费用
      EPU 费用 = 800 EPU 小时 * 0.185 USD = 148 USD
      ESM 预置模式的月度费用 = 148 USD

      费用总额
      总费用 = 计算费用 + 请求费用 + ESM 预置模式费用
      总费用 = 993.3 USD + 12 USD + 148 USD = 1153.3 USD

       

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

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

      每月计算费用
      每月计算价格为每 GB-s 0.0000166667 USD
      总计算（秒）= 100 万 * 30 * 1 秒 = 3000 万秒
      总计算（GB-s）= 3000 万 * 1024MB/1024 = 3000 万 GB-s
      总计算 = 每月计费计算 GB-s * 0.0000166667 USD
      每月计算费用 = 3000 万 * 0.0000166667 USD = 500 USD

      每月请求费用
      每月请求价格为每 100 万个请求 0.20 USD
      每月请求费用 = 3000 万个请求 * 0.20 USD = 6 USD

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

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

    • 假设您是一家全球客户联络中心解决方案提供商，并且拥有将与呼叫体验相关的元数据发送到数十个 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 USD，免费套餐提供 400000 GB-s
      总计算（秒）= 1,000,000 * 30 * 0.2 秒 = 6000000 秒
      总计算（GB-s）= 6000000 * 1024MB/1024 = 6000000 GB-s
      所有 10 个 ESM 的总计算量（GB-s）= 6000000 GB-s * 10 = 60000000 GB-s
      每月计算费用 = 60000000 * 0.0000166667 USD = 1000 USD
      每月请求费用
      每月请求价格为每 100 万个请求 0.20 USD。
      所有 100 个 ESM 的月度请求总数 = 100 万 * 30 天 * 10 个 ESM = 3 亿个请求
      每月请求费用 = 3 亿个请求 * 0.20 USD = 60.00 USD
      ESM 预置模式的每月费用
      EPU 小时价格为每小时 0.185 USD，每个 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 USD
      费用总额
      总费用 = 计算费用 + 请求费用 + ESM 预置模式的费用
      总费用 = 1000 USD + 60 USD + 133.2 USD = 10 个 ESM 每月 1,193.2 USD
      每个 ESM 的每月费用 = 1193.2 USD / 10 = 每个 ESM 每月 119.3 USD

    数据传输和其他费用

    数据传输
    从执行函数的区域以外传入和传出您的 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 Event 函数将产生额外费用，如 Amazon Elastic Compute Cloud（EC2）按需定价页面所述。VPC 对等连接是两个 VPC 之间的网络连接，通过此连接，您可以使用私有 IPv4 地址或 IPv6 地址在这两个 VPC 之间路由流量。 

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

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

    Lambda@Edge 定价

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

  • MicroVM

  • Lambda MicroVM 定价

    AWS Lambda MicroVMs 的定价基于您使用的计算资源、快照读/写操作和存储以及按标准 AWS 费率传输的数据。

    计算

    使用 Lambda MicroVM，您无需再为应对业务高峰而精确调整每个计算环境的规模。您可以通过设置内存来定义基准配置；CPU 将按 2:1 的内存与 CPU 比例进行分配（默认配置为 2 GB 内存 / 1 个 vCPU）。当业务达到高峰时，MicroVM 可自动进行垂直扩展，最高可达基准配置的 4 倍（最高为 8 GB 内存和 4 个 vCPU），无需您执行任何额外操作。
     
    在 MicroVM 运行期间，您需要为基准计算资源付费。当工作负载消耗的资源超过基准配置时，您只需为超出部分的内存和 vCPU 的实际使用时长付费，而无需为峰值容量本身付费。这意味着您可以根据常规工作负载进行配置，并将业务高峰期的资源需求交给 Lambda 来处理。计算资源的使用按秒计费。有关调整 MicroVM 大小的详细信息，请参阅  创建 MicroVM 映像。
    • x86
    • Graviton (ARM)

    快照

    Lambda MicroVM 利用快照实现近乎即时的启动，并降低空闲状态下的成本。MicroVM 映像是应用程序预初始化状态的快照。MicroVM 不会从零开始“冷启动”，而是直接基于此映像启动。在空闲期间，您可以将正在运行的 MicroVM 挂起（最长可达 8 小时）；在此过程中，系统会保留其内存和磁盘状态，且您无需支付计算费用。当流量恢复时，被挂起的 MicroVM 可通过自动或编程方式迅速恢复运行。您需要为快照存储、快照数据读取（在启动或恢复时）以及快照数据写入（在挂起时）付费。
    * MicroVM 映像存储的最短保留期为 1 周。

    数据传输

    数据传输：您需要按标准 AWS 数据传输费率付费。您还需要为在 Lambda MicroVMs 和 Amazon VPC 之间传输的数据付费，如  在同一 AWS 区域内传输数据中所述。

    ​​Lambda MicroVM - 定价示例：

    以下所有示例均基于美国东部（弗吉尼亚州北部）的定价，使用 ARM（Graviton）架构。对于配置的每个 GB 内存，Lambda MicroVMs 以 2:1 的比例分配 vCPU（例如，配置 8 GB 内存会分配 4 个 vCPU）。
    • 假设您正在构建一个平台，为每位开发人员提供一个隔离的沙盒 Linux 环境，用于人工智能辅助编程。每个环境均在 Lambda MicroVM 中运行，其基准配置为 2 GB 内存和 1 个 vCPU；在执行编译或测试等资源密集型任务时，可垂直扩展至 8 GB 内存和 4 个 vCPU。您的组织维护着 5 个标准的 MicroVM 映像（Rust、Python、Node.js、Java 和 Go），每个映像的大小均为 2 GB。每位开发人员每天会基于这些 2 GB 的映像启动一个环境。在 8 小时的标准工作日内，每个环境的实际使用时长为 2.5 小时：其中 75% 的时间使用基准资源配置（2 GB 内存和 1 个 vCPU），其余 25% 的时间则垂直扩展至峰值资源配置（8 GB 内存和 4 个 vCPU）。在工作日其余 5.5 小时的空闲期间（例如开发人员暂时离开或切换至其他任务时），环境会自动进入挂起状态，同时保留 2 GB 的运行状态（包括工作目录、进程状态和文件缓存）。由于开发人员会在编程与其他活动之间频繁切换，每个环境每天会经历 6 次挂起/恢复循环。通过挂起/恢复机制，您无需为空闲期间持续运行的计算资源付费，同时还能完整保留当前的工作状态。开发人员可以从上次中断的地方无缝继续工作，无需重启环境或重新初始化运行状态。您的团队共有 100 名开发人员，每人每月使用该开发平台 20 天。您的月度费用将按以下方式计算：​​​​​

      月度计算费用

      总而言之，75% 的计算时间用于基准资源消耗，25% 的计算时间花在峰值资源消耗上。​

      峰值使用秒数：100 名开发者 x 20 天 x 2.5 小时 x 25% = 450 万秒
      高峰使用费用：
      vCPU：450 万秒 x 4 vCPU x 0.0000276944 USD/vCPU-秒 = 498.50 USD
      内存：450 万秒 x 8 GB 内存 x 0.0000036667 USD/GB-s = 132.00 USD
      总计：630.50 USD

      基准使用秒数：100 名开发者 x 20 天 x 2.5 小时 x 75% = 1350 万秒
      基准用量收费：
      vCPU：1350 万秒 x 1 个 vCPU x 0.0000276944 USD/vCPU-秒 = 373.87 USD
      内存：1350 万秒 x 2 GB 内存 x 0.0000036667 USD/GB-s = 99.00 USD
      总计：472.88​ USD

      月度计算费用：630.50 USD + 472.88 USD = 1103.38​ USD

      每月快照费用

      快照读取/写入：
      每月挂起/恢复周期：100 名开发者 x 20 天 x 6 个周期 = 12000 个周期
      快照写入（挂起）费用：12000 个周期 x 2 GB x 0.0038 USD/GB = 91.20 USD
      快照读取（恢复）费用：12000 个周期 x 2 GB x 0.00155 USD/GB = 37.20 USD

      每月启动次数：100 名开发者 x 每天 1 次启动 x 20 天 = 2000 次启动
      快照读取（启动）费用：2000 次启动 x 2 GB x 0.00155 USD/GB = 6.20 USD

      每月快照读取/写入费用总额：91.20 USD + 37.20 USD + 6.20 USD = 134.60 USD

      快照存储：
      MicroVM 映像存储费用：5 个映像 x 2 GB x 0.08 USD/GB-月 = 0.80 USD
      挂起 MicroVM 费用：100 名开发者 x 2 GB x（5.5 个空闲小时/天 x 20 天/720 小时）x 0.08 USD/GB-月 = 2.44 USD

      月度快照存储费用：3.24 USD  

      月度总费用

      总费用 = 计算费用 + 快照读/写费用 + 快照存储费用 = 1103.38 USD + 134.60 USD + 3.24 USD = 1241.22 USD

      每位开发者的月度费用：1241.22 USD/100 = 12.41 USD

    • 假设您正在构建一个为多个最终用户运行安全扫描或 CI/CD 作业的平台。每个作业都会执行不可信或半可信的代码，例如安装依赖项、执行构建脚本或运行漏洞扫描程序。因此，每个作业都需要自己的硬件隔离环境。由于流量不可预测，您过去不得不维护一个庞大的空闲环境资源池，以便随时满足延迟要求。借助 Lambda MicroVM，环境可以从快照中快速启动，因此您无需再维护空闲资源池。每个环境均配置了 8 GB 内存和 4 个 vCPU 的基准规格；在执行资源密集型的编译或扫描阶段时，该环境可垂直扩展至 32 GB 内存和 16 个 vCPU。作业会一次性运行直至完成，无需挂起或恢复。每个作业平均运行 10 分钟，其中 10% 的时间处于峰值状态（32 GB 内存和 16 个 vCPU），其余 90% 的时间处于基准状态（8 GB 内存和 4 个 vCPU）。您只需维护一个标准的 MicroVM 映像（2 GB）即可。借助基于快照的启动机制，您无需再为闲置的备用资源池付费——每个环境均可按需快速启动，并在作业完成后自动终止。您的平台每月运行 10000 个作业。费用将按以下方式计算：

      月度计算费用

      总而言之，90% 的计算时间花在基准资源消耗上，10% 花在峰值资源消耗上。

      峰值使用秒数：10000 个作业 x 600 秒 x 10% = 60 万秒
      高峰使用费用：
      vCPU：60 万秒 x 16 个 vCPU x 0.0000276944 USD/vCPU-秒 = 265.87 USD
      内存：60 万秒 x 32 GB 内存 x 0.0000036667 USD/GB-s = 70.40 USD
      总计：336.27 USD

      基准使用秒数：10000 个作业 x 600 秒 x 90% = 540 万秒
      基准用量收费：
      vCPU：540 万秒 x 4 个 vCPU x 0.0000276944 USD/vCPU-秒 = 598.20 USD
      内存：540 万秒 x 8 GB 内存 x 0.0000036667 USD/GB-s = 158.40 USD
      总计：756.60 USD

      月度计算费用：336.27 USD + 756.60 USD = 1092.87 USD

      每月快照费用

      快照读取/写入：​
      每月启动次数：10000 个作业 x 每个 1 次启动 = 10000 次启动
      快照读取（启动）费用：10000 次启动 x 2 GB x 0.00155 USD/GB = 31 USD

      每月快照读取/写入费用总额：31 USD

      快照存储：
      MicroVM 映像存储费用：1 个映像 x 2 GB x 0.08 USD/GB-月 = 0.16 USD

      月度快照存储费用：0.16 USD

      月度总费用

      总费用 = 计算费用 + 快照读/写费用 + 快照存储费用 = 1092.87 USD + 31 USD + 0.16 USD = 1124.03 USD

      每个作业的成本：$1124.03 / 10000 = 0.112​ USD 

  • Web 函数

  • Lambda Web 函数定价

    Lambda Web 函数的定价基于所处理的请求数量、活跃 CPU 时间、内存消耗量以及标准的 AWS 数据传输量。

    您需要为请求付费，并根据代码实际占用的 CPU 时间以及每个执行环境在运行期间所消耗的内存进行计费。计算资源按 1 毫秒的粒度计费。由于单个执行环境可以同时处理多个并发请求，因此计算资源和内存消耗会在这些请求之间共享。

    • Graviton (ARM)
    请求

    我们将根据针对您的函数发起的请求总数（无论请求来自何处）向您收费。

    数据传输

    数据传输：您需要按标准 AWS 数据传输费率付费。您还需要为在 Lambda Web 函数和 Amazon VPC 之间传输的数据付费，如在同一 AWS 区域内传输数据中所述。

    Lambda Web 函数 - 定价示例

    以下示例展示了针对典型工作负载如何计算月度账单。所有示例均基于美国东部（弗吉尼亚州北部）区域、采用 Arm 架构的定价；为简化计算，未计入免费额度及数据传输费用。计算资源按 1 毫秒的粒度计费。每个执行环境均根据其占用的内存量及运行持续时间（包括请求之间的间隔时间）进行计费。Lambda 会根据您的流量需求扩展或缩减执行环境的数量。为简化计算，这些示例假设流量在 30 天（2592000 秒）内均匀分布，且请求频率足以确保始终有一个执行环境处于运行状态，并处理全部流量。

    • 假设您运行一个服务器端渲染的 Web 应用程序，其中每个页面都在请求时由服务器进行渲染。该应用程序每月处理 1500 万个请求。每个请求的端到端耗时为 150 毫秒，其中 CPU 活跃时间为 40 毫秒。执行环境占用的内存约为 500 MB（0.49 GB）。

      月度计算费用

      活跃 vCPU 的价格为每 vCPU-秒 0.0000276944 美元，内存价格为每 GB-秒 0.0000036667 美元。

      • 活跃 vCPU：15000000 x 0.040 s = 600000 vCPU 秒 x 0.0000276944 USD = 16.62 USD。
      • 内存：0.49 GB x 2592000 s = 1270080 GB 秒 x 0.0000036667 USD = 4.66 USD。

      月度请求费用

      • 请求：15000000 x 0.30 USD/百万次 = 4.50 USD。

      月度总费用

      总费用 = 计算费用 + 请求费用 =（16.62 USD + 4.66 USD）+ 4.50 USD = 25.78 USD

    • 假设您运行着一个 API 后端服务，其中大部分请求处理时间都消耗在等待数据库响应或下游 API 调用上。该服务每月处理 1000 万次请求。每个请求的端到端耗时为 200 毫秒，其中仅 50 毫秒涉及实际的 CPU 计算。执行环境占用的内存约为 300 MB（0.29 GB）。

      月度计算费用

      • 活跃 vCPU：10000000 x 0.050 秒 = 500000 vCPU-秒 x 0.0000276944 USD = 13.85 USD。
      • 内存：0.29 GB x 2592000 秒 = 751680 GB 秒 x 0.0000036667 USD = 2.76 USD。

      月度请求费用

      • 请求：10000000 × 每百万次 0.30 USD = 3.00 USD。

      月度总费用

      总费用 = 计算费用 + 请求费用 = (13.85 USD + 2.76 USD) + 3.00 USD = 19.61 USD
      由于 CPU 是在代码积极处理时计费的，因此您需要为 50 毫秒的活跃工作付费。

    • 假设您运行一个轻量级授权程序，该程序会在您的应用程序接收到每个请求时执行。该服务每月处理 1 亿次请求。每个请求从开始到结束耗时 50 ms，其中 CPU 实际运行时间为 12 ms。执行环境占用的内存约为 145 MB（0.14 GB）。

      月度计算费用

      • 活跃 vCPU：100000000 x 0.012 s = 1200000 vCPU-秒 x 0.0000276944 USD = 33.23 USD
      • 内存：0.14 GB x 2592000 s = 362880 GB 秒 x 0.0000036667 USD = 1.33 USD

      月度请求费用

      • 请求：100000000 × 每百万 0.30 美元 = 30.00 美元

      月度总费用

      总费用 = 计算费用 + 请求费用 =（33.23 USD + 1.33 USD）+ 30.00 USD = 64.56 USD

    • 假设您运行一项服务，通过长连接从大语言模型（LLM）流式传输返回 Token。该服务每月处理 500 万个请求。每个请求的端到端持续时间为 3000 毫秒，其中 CPU 活跃时间为 200 毫秒。执行环境占用约 512 MB (0.50 GB) 内存。

      月度计算费用

      • 活跃 vCPU：5000000 × 0.200 秒 = 1000000 vCPU-秒 x 0.0000276944 USD = 27.69 USD。
      • 内存：0.50 GB x 2592000 s = 1296000 GB-s x 0.0000036667 USD = 4.75 USD。

      月度请求费用

      • 请求费用： 5000000 x 0.30 USD/百万次 = 1.50 USD。

      月度总费用

      总费用 = 计算费用 + 请求费用 =（27.69 USD + 4.75 USD）+ 1.50 USD = 33.94 USD
      这正是基于 CPU 活跃时间的计费发挥关键作用的地方。每个请求的持续时间为 3 秒，但您只需为 200 毫秒的 CPU 活跃时间付费。并发处理请求还能降低内存费用。由于每个请求大部分时间都在等待，而非占用 CPU，因此单个执行环境可以同时处理多个请求。当大约六个请求同时进行时，它们会共享同一个环境的内存；也就是说，您只需为一个环境付费，而非六个。

其他定价资源

AWS 定价计算器

轻松计算 AWS 的月度费用

获取定价协助

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