# 配置 AWS Lambda 函数
了解如何使用 Lambda API 或控制台配置 Lambda 函数的核心功能和选项。
**[.zip 文件归档](configuration-function-zip.md) **
当您希望包含依赖项、自定义运行时层或除函数代码之外的任何文件时，请创建一个 Lambda 函数部署包。部署包是包含函数代码及其依赖项的 .zip 文件存档。
**[容器映像](images-create.md) **
当您需要对构建过程有更多控制权，或者您的函数需要自定义运行时配置时，请使用容器映像来打包您的函数代码及依赖项。您可以使用 Docker CLI 之类的工具，将 Lambda 函数构建、测试并部署为容器映像。
**[内存](configuration-memory.md)**
了解如何及何时增加函数内存。
**[临时存储](configuration-ephemeral-storage.md) **
了解如何以及何时增加函数的临时存储容量。
**[超时](configuration-timeout.md) **
了解如何以及何时增加函数的超时值。
**[持久配置](durable-configuration.md) **
使您的 Lambda 函数能够长时间运行（最长一年），同时在每次调用之间还能保持状态。为长时间运行的有状态工作流配置执行超时、状态保留和版本控制行为。持久性函数使您能够构建复杂的多步骤流程，这些流程可以暂停、恢复和自动处理中断。
** [环境变量](configuration-envvars.md)**
您可以使您的函数代码可移植，并通过环境变量将密钥存储在函数配置中，从而将该密钥存放在代码之外。
**[出站联网](configuration-vpc.md) **
您可以将 Lambda 函数与 Amazon VPC 中的 AWS 资源结合使用。通过将函数连接到 VPC，您可以访问私有子网中的资源，例如关系数据库和缓存。
** [入站联网](configuration-vpc-endpoints.md)**
您可以使用此接口 VPC 端点来调用您的 Lambda 函数，无需跨越公有 Internet。
**[文件系统](configuration-filesystem.md)**
您可以使用 Lambda 函数将 Amazon EFS 挂载到本地目录。文件系统允许您的函数代码在高并发下安全地访问和修改共享资源。
**[别名](configuration-aliases.md)**
您可以对客户端进行配置，以便可以使用别名调用特定的 Lambda 函数版本，而不是更新客户端。
**[版本](configuration-versions.md)**
通过发布一个函数版本，您可以将代码和配置存储为一个单独的资源，该资源无法更改。
**[标签](configuration-tags.md)**
使用标签启用基于属性的访问权限控制（ABAC）、组织 Lambda 函数并使用 AWS Cost Explorer 或 AWS 账单和成本管理服务筛选和生成有关函数的报告。
**[响应流式处理](configuration-response-streaming.md)**
配置 Lambda 函数 URL 以将响应负载流式传输回客户端。响应流式处理可通过提高首字节时间（TTFB）性能，使延迟敏感型应用程序受益。这是因为您可以在部分响应可用时将其发送回客户端。此外，您可以使用响应流式处理来构建返回较大负载的函数。
**[元数据端点](configuration-metadata-endpoint.md)**
使用 Lambda 元数据端点可发现函数在哪个可用区中运行，从而通过路由到相同可用区的资源来优化延迟，并实施可感知可用区的弹性模式。
# 将 Lambda 函数部署为 .zip 文件归档
创建 Lambda 函数时，您可将函数代码打包到部署程序包中。Lambda 支持两种类型的部署程序包：容器镜像和 .zip 文件归档。创建函数的工作流取决于部署包类型。使用 [使用容器映像创建 Lambda 函数](images-create.md) 控制台创建定义为容器镜像的函数。
您可使用 Lambda 控制台和 Lambda API 创建定义为 .zip 文件归档的 Lambda 函数。此外，您还可上载更新的 .zip 文件更改函数代码。
**注意**
您无法更改现有函数的[部署包类型](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType)（.zip 或容器映像）。例如，您无法将容器映像函数转换为使用 .zip 文件归档。您必须创建新函数。
**Topics**
+ [
## 创建函数
](#configuration-function-create)
+ [
## 使用控制台代码编辑器
](#configuration-functions-console-update)
+ [
## 更新函数代码
](#configuration-function-update)
+ [
## 更改运行时
](#configuration-function-runtime)
+ [
## 更改架构
](#configuration-function-arch)
+ [
## 使用 Lambda API
](#configuration-function-api)
+ [
## 下载函数代码
](#configuration-function-download)
+ [
## CloudFormation
](#configuration-function-cloudformation)
+ [
# 加密 Lambda .zip 部署包
](encrypt-zip-package.md)
## 创建函数
创建定义为 .zip 文件归档的 Lambda 函数时，请选择代码模板、语言版本及函数的执行角色。您可以在 Lambda 创建函数后添加函数代码。
**创建函数**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择 **Create function**（创建函数）。
1. 选择 **Author from scratch**（从头开始创作）或者 **Use a blueprint**（使用蓝图）创建函数。
1. 在 **Basic information**（基本信息）中，执行以下操作：
1. 对于 **Function name**（函数名称），输入函数名称。函数名称的长度限制为 64 个字符。
1. 对于**Runtime**（运行时），请选择函数使用的语言版本。
1. （可选）对于**架构**，选择要用于函数的指令集架构。默认架构为 x86\$164。为您的函数构建部署包时，请确保它与此[指令集架构](foundation-arch.md)兼容。
1. （可选）在 **Permissions**（权限）下，展开 **Change default execution role**（更改默认执行角色）。您可以使用现有角色，也可以创建一个**执行角色**。
1. （可选）展开 **Advanced settings**（高级设置）。您可以为函数选择**代码签名配置**。您还可以为要访问的函数配置 (Amazon VPC)。
1. 选择 **Create function**（创建函数）。
Lambda 将创建新函数。现在，您可以使用控制台添加函数代码并配置其他函数参数和特性。有关代码部署说明，请参阅函数使用的运行时的处理程序页面。
------
#### [ Node.js ]
[使用 .zip 文件归档部署 Node.js Lambda 函数](nodejs-package.md)
------
#### [ Python ]
[将 .zip 文件归档用于 Python Lambda 函数](python-package.md)
------
#### [ Ruby ]
[使用 .zip 文件归档部署 Ruby Lambda 函数](ruby-package.md)
------
#### [ Java ]
[使用 .zip 或 JAR 文件归档部署 Java Lambda 函数](java-package.md)
------
#### [ Go ]
[使用 .zip 文件归档部署 Go Lambda 函数](golang-package.md)
------
#### [ C\$1 ]
[使用 .zip 文件归档构建和部署 C\$1 Lambda 函数](csharp-package.md)
------
#### [ PowerShell ]
[使用 .zip 文件归档部署 PowerShell Lambda 函数](powershell-package.md)
------
## 使用控制台代码编辑器
控制台将使用单个源文件创建一个 Lambda 函数。对于脚本语言，您可以在内置代码编辑器中编辑此文件并添加更多文件。要保存您的更改，请选择 **Save**（保存）。然后，要运行代码，请选择 **Test**（测试）。
保存函数代码时，Lambda 控制台会创建一个 .zip 文件归档部署包。在控制台外部开发函数代码时（使用 IDE），您需要[创建部署程序包](nodejs-package.md)将代码上载到 Lambda 函数。
## 更新函数代码
对于脚本语言（Node.js、Python 及 Ruby），您可以在嵌入式编辑器中编辑函数代码。如果代码大于 3MB，或者如果需要添加库，或对于编辑器不支持的语言（Java、Go、C\$1），您必须将函数代码以 .zip 归档上载。如果 .zip 文件归档小于 50 MB，则可以从本地计算机上传 .zip 文件归档。如果文件大于 50MB，请将文件从 Simple Storage Service (Amazon S3) 存储桶上载到函数。
**将函数代码以 .zip 归档上载**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择要更新的函数，然后选择 **Code**（代码）选项卡。
1. 在 **Code source**（代码源）下，选择 **Upload from**（上载自）。
1. 选择 **.zip file** (.zip 文件)，然后选择 **Upload file** (上载文件)。
1. 在文件选择器中，选择新映像版本，然后依次选择 **Open** (打开)、**Save** (保存)。
1. （步骤 4 的替代方案）选择 **Amazon S3 location**（Simple Storage Service (Amazon S3) 位置）。
1. 在文本框中，输入 .zip 文件归档的 S3 链接 URL，然后选择 **Save**（保存）。
## 更改运行时
如果您更新函数配置以使用新的运行时版本，则可能需要更新函数代码才能与新的运行时版本兼容。如果您将函数配置更新为使用其他运行时，则**必须**提供与运行时和架构兼容的新函数代码。有关如何为函数代码创建部署包的说明，请参阅函数使用的运行时的处理程序页面。
Node.js 20、Python 3.12、Java 21、.NET 8、Ruby 3.3 及更高版本的基础映像都基于 Amazon Linux 2023 最小容器映像。早期的基础映像使用 Amazon Linux 2。与 Amazon Linux 2 相比，AL2023 具有多项优势，包括较小的部署占用空间以及 `glibc` 等更新版本的库。有关更多信息，请参阅 AWS 计算博客上的[AWS Lambda 的 Amazon Linux 2023 运行时系统简介](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/)。
**更改运行时**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择要更新的函数，然后选择 **Code**（代码）选项卡。
1. 向下滚动至位于代码编辑器下方的 **Runtime settings**（运行时设置）部分。
1. 选择**编辑**。
1. 对于 **Runtime**（运行时），请选择运行时标识符。
1. 对于 **Handler**（处理程序），请为您的函数指定文件名和处理程序。
1. 对于**架构**，选择要用于您的函数的指令集架构。
1. 选择**保存**。
## 更改架构
在更改指令集架构之前，您需要确保函数的代码与目标架构兼容。
如果您使用 Node.js、Python 或 Ruby 并在嵌入式编辑器中编辑函数代码，则现有代码可以在不修改的情况下运行。
但是，如果您使用 .zip 文件归档部署包提供函数代码，则必须准备一个新的 .zip 文件归档，针对目标运行时和指令集架构正确编译和构建此归档。有关说明，请参阅函数运行时的处理程序页面。
**更改指令集架构**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择要更新的函数，然后选择 **Code**（代码）选项卡。
1. 在 **Runtime settings**（运行时设置）中，选择 **Edit**（编辑）。
1. 对于**架构**，选择要用于您的函数的指令集架构。
1. 选择**保存**。
## 使用 Lambda API
要创建和配置使用 .zip 文件归档的函数，请使用以下 API 操作：
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
## 下载函数代码
您可以通过 Lambda 控制台下载函数代码 .zip 文件的当前未发布（`$LATEST`）版本。要完成此操作，请首先确保您拥有以下 IAM 权限：
+ `iam:GetPolicy`
+ `iam:GetPolicyVersion`
+ `iam:GetRole`
+ `iam:GetRolePolicy`
+ `iam:ListAttachedRolePolicies`
+ `iam:ListRolePolicies`
+ `iam:ListRoles`
**下载函数代码 .zip 文件**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择您要下载其函数代码 .zip 文件的函数。
1. 在**函数概述**中，选择**下载**按钮，然后选择**下载函数代码.zip 文件**。
1. 或者，选择**下载 AWS SAM 文件**，根据您的函数配置生成并下载 SAM 模板。您也可以选择**两者都下载**，同时下载.zip 文件和 SAM 模板。
## CloudFormation
您可以使用 CloudFormation 创建使用 .zip 文件归档的 Lambda 函数。在 CloudFormation 模板中，`AWS::Lambda::Function` 资源将指定 Lambda 函数。有关 `AWS::Lambda::Function` 资源中属性的描述，请参阅 *AWS CloudFormation 用户指南*中的 [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)。
在 `AWS::Lambda::Function` 资源中，设置以下属性以创建定义为 .zip 文件归档的函数：
+ AWS::Lambda::Function
+ PackageType – 设置为 `Zip`。
+ 代码 – 在 `S3Bucket` 和 `S3Key` 字段中输入 Amazon S3 存储桶名称和 .zip 文件名。对于 Node.js 或 Python，您可以提供 Lambda 函数的内联源代码。
+ 运行时 – 设置运行时值。
+ 架构 - 将架构值设置为 `arm64` 以使用 AWS Graviton2 处理器。默认情况下，架构值为 `x86_64`。
# 加密 Lambda .zip 部署包
Lambda 始终为 .zip 部署包和带有 AWS KMS key的函数配置详细信息提供静态服务器端加密。默认情况下，Lambda 使用 [AWS 拥有的密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk)。如果此默认行为适合您的工作流，则您无需设置任何其他内容。AWS 不会向您收取使用此密钥的费用。
如果您愿意，可以提供 AWS KMS 客户托管式密钥。这样做可能是为了控制 KMS 密钥的轮换，或者是为了满足组织管理 KMS 密钥的要求。当您使用客户自主管理型密钥时，只有您账户中有权访问 KMS 密钥的用户才能查看或管理函数的代码或配置。
客户托管式密钥产生标准 AWS KMS 费用。有关更多信息，请参阅 [AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing/)。
## 创建客户托管密钥
您可以使用 AWS 管理控制台 或 AWS KMS API 创建对称的客户托管密钥。
**创建对称的客户托管密钥**：
请按照《AWS Key Management Service 开发人员指南》**中[创建对称加密 创建对称 KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk)的步骤操作。
### 权限
**密钥策略**
[密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)控制对客户自主管理型密钥的访问。每个客户托管式密钥必须只有一个密钥策略，其中包含确定谁可以使用密钥以及如何使用密钥的声明。有关更多信息，请参阅《AWS Key Management Service 开发人员指南》**中的[如何更改密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to)。
当您使用客户自主管理型密钥加密 .zip 部署包时，Lambda 不会向该密钥添加[授权](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)。相反，您的 AWS KMS 密钥策略必须允许 Lambda 代表您调用以下 AWS KMS API 操作：
+ [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)
+ [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
以下示例密钥策略允许账户 111122223333 中的所有 Lambda 函数调用指定客户自主管理型密钥所需的 AWS KMS 操作：
**Example AWS KMS 密钥政策**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id",
"Condition": {
"StringLike": {
"kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*"
}
}
}
]
}
```
有关[密钥访问故障排除](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam)的信更多息，请参阅**《AWS Key Management Service 开发人员指南》。
**主体权限**
当您使用客户自主管理型密钥加密 .zip 部署包时，只有有权访问该密钥的[主体](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html)才能访问 .zip 部署包。例如，无法访问客户自主管理型密钥的主体无法使用 [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) 响应中包含的预签名 S3 URL 下载 .zip 包。响应的 `Code` 部分中会返回 `AccessDeniedException`。
**Example AWS KMS AccessDeniedException**
```
{
"Code": {
"RepositoryType": "S3",
"Error": {
"ErrorCode": "AccessDeniedException",
"Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy"
},
"SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id"
},
...
```
有关 AWS KMS 密钥的权限的更多信息，请参阅 [AWS KMS 的身份验证和访问控制](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html)。
## 对 .zip 部署包使用客户自主管理型密钥
使用以下 API 参数为 .zip 部署包配置客户自主管理型密钥：
+ [SourceKMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn)：加密源 .zip 部署包（您上传的文件）。
+ [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn)：加密[环境变量](configuration-envvars-encryption.md)和 [Lambda SnapStart](snapstart.md) 快照。
同时指定 `SourceKMSKeyArn` 和 `KMSKeyArn` 时，Lambda 使用 `KMSKeyArn` 密钥来加密 Lambda 用于调用该函数的程序包的解压缩版本。如果已指定 `SourceKMSKeyArn` 但未指定 `KMSKeyArn`，则 Lambda 使用 [AWS 托管式密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)加密程序包的解压缩版本。
------
#### [ Lambda console ]
**在创建函数时添加客户自主管理型密钥加密**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择 **Create function**（创建函数）。
1. 选择 **Author from scratch**（从头开始编写）或 **Container image**（容器映像）。
1. 在 **Basic information**（基本信息）中，执行以下操作：
1. 对于 **Function name（函数名称）**，输入函数名称。
1. 对于**Runtime**（运行时），请选择函数使用的语言版本。
1. 展开**高级设置**，然后选择**使用 AWS KMS 客户自主管理型密钥启用加密**。
1. 选择客户托管密钥。
1. 选择**创建函数**。
要删除客户自主管理型密钥加密或使用其他密钥，必须再次上传 .zip 部署包。
**向现有函数添加客户自主管理型密钥加密**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择一个函数的名称。
1. 在**代码源**窗格中，选择**上传自**。
1. 选择 **.zip 文件**或 **Amazon S3 位置**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/upload-zip.png)
1. 上传文件，或者输入 Amazon S3 位置。
1. 选择**使用 AWS KMS 客户自主管理型密钥启用加密**。
1. 选择客户托管密钥。
1. 选择**保存**。
------
#### [ AWS CLI ]
**在创建函数时添加客户自主管理型密钥加密**
在以下 [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) 示例中：
+ `--code`：指定至 .zip 部署包（`ZipFile`）的本地路径以及用于加密它的客户自主管理型密钥（`SourceKMSKeyArn`）。
+ `--kms-key-arn`：指定用于加密环境变量和部署包解压缩版本的客户自主管理型密钥。
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
在以下 [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) 示例中：
+ `--code`：指定 .zip 文件在 Amazon S3 存储桶（`S3Bucket`、`S3Key`、`S3ObjectVersion`）中的位置以及用于加密该文件的客户自主管理型密钥（`SourceKMSKeyArn`）。
+ `--kms-key-arn`：指定用于加密环境变量和部署包解压缩版本的客户自主管理型密钥。
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
**向现有函数添加客户自主管理型密钥加密**
在以下 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 示例中：
+ `--zip-file`：指定 .zip 部署包的本地路径。
+ `--source-kms-key-arn`：指定用于加密部署包压缩版本的客户自主管理型密钥。Lambda 使用 AWS 拥有的密钥对解压缩包进行加密，以进行函数调用。如果要使用客户自主管理型密钥来加密程序包的解压缩版本，则请运行带有 `--kms-key-arn` 选项的 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令。
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip \
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
在以下 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 示例中：
+ `--s3-bucket`：指定 .zip 文件在 Amazon S3 存储桶中的位置。
+ `--s3-key`：指定部署包的 Amazon S3 密钥。
+ `--s3-object-version`：对于版本控制的对象，指要使用的部署程序包对象的版本。
+ `--source-kms-key-arn`：指定用于加密部署包压缩版本的客户自主管理型密钥。Lambda 使用 AWS 拥有的密钥对解压缩包进行加密，以进行函数调用。如果要使用客户自主管理型密钥来加密程序包的解压缩版本，则请运行带有 `--kms-key-arn` 选项的 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令。
```
aws lambda update-function-code \
--function-name myFunction \
--s3-bucket amzn-s3-demo-bucket \
--s3-key myFileName.zip \
--s3-object-version myObject Version
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
**从现有函数中删除客户自主管理型密钥加密**
在以下 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 示例中，`--zip-file` 指定 .zip 部署包的本地路径。当您在没有 `--source-kms-key-arn` 选项的情况下运行此命令时，Lambda 会使用 AWS 拥有的密钥对部署包的压缩版本进行加密。
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip
```
------
# 使用容器映像创建 Lambda 函数
您的 AWS Lambda 函数代码由脚本或编译的程序及其依赖项组成。您可以使用*部署包*将函数代码部署到 Lambda。Lambda 支持两种类型的部署包：容器镜像和 .zip 文件归档。
有三种方法可以为 Lambda 函数构建容器映像：
+ [使用 Lambda 的 AWS 基本映像](#runtimes-images-lp)
[AWS 基本映像](#runtimes-images-lp)会预加载一个语言运行时系统、一个用于管理 Lambda 和函数代码之间交互的运行时系统接口客户端，以及一个用于本地测试的运行时系统接口仿真器。
+ [使用 AWS 仅限操作系统的基础镜像](#runtimes-images-provided)
[AWS 仅限操作系统的运行时系统](https://gallery.ecr.aws/lambda/provided)包含 Amazon Linux 发行版和[运行时系统接口模拟器](https://github.com/aws/aws-lambda-runtime-interface-emulator/)。这些镜像通常用于为编译语言（例如 [Go](go-image.md#go-image-provided) 和 [Rust](lambda-rust.md)）以及 Lambda 未提供基础映像的语言或语言版本（例如 Node.js 19）创建容器镜像。您也可以使用仅限操作系统的基础映像来实施[自定义运行时系统](runtimes-custom.md)。要使映像与 Lambda 兼容，则必须在映像中包含适用于您的语言的[运行时系统接口客户端](#images-ric)。
+ [使用非 AWS 基本映像](#images-types)
您还可以使用其他容器注册表的备用基本映像，例如 Alpine Linux 或 Debian。您还可以使用您的组织创建的自定义映像。要使映像与 Lambda 兼容，则必须在映像中包含适用于您的语言的[运行时系统接口客户端](#images-ric)。
**提示**
要缩短 Lambda 容器函数激活所需的时间，请参阅 Docker 文档中的[使用多阶段构建](https://docs.docker.com/build/building/multi-stage/)。要构建高效的容器映像，请遵循[编写 Dockerfiles 的最佳实践](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)。
要从容器映像创建 Lambda 函数，请在本地构建映像，然后将其上传到 Amazon Elastic Container Registry（Amazon ECR）存储库。如果您使用的是 [AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html) 卖家提供的容器映像，则需要先将该映像克隆到您的私有 Amazon ECR 存储库中。然后，在您创建该函数时指定存储库 URI。Amazon ECR 存储库必须与 Lambda 函数位于同一 AWS 区域 内。只要映像与 Lambda 函数位于同一区域内，您就可以使用其他 AWS 账户中的映像创建函数。有关更多信息，请参阅 [Amazon ECR 跨账户权限](#configuration-images-xaccount-permissions)。
**注意**
对于容器映像，Lambda 不支持 Amazon ECR FIPS 端点。如果您的存储库 URI 包含 `ecr-fips`，则表示您使用的是 FIPS 端点。示例：`111122223333.dkr.ecr-fips.us-east-1.amazonaws.com`。
本页面介绍了创建与 Lambda 兼容的容器映像的基本映像类型和要求。
**注意**
您无法更改现有函数的[部署包类型](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType)（.zip 或容器映像）。例如，您无法将容器映像函数转换为使用 .zip 文件归档。您必须创建新函数。
**Topics**
+ [
## 要求
](#images-reqs)
+ [
## 使用 Lambda 的 AWS 基本映像
](#runtimes-images-lp)
+ [
## 使用 AWS 仅限操作系统的基础镜像
](#runtimes-images-provided)
+ [
## 使用非 AWS 基本映像
](#images-types)
+ [
## 运行时接口客户端
](#images-ric)
+ [
## Amazon ECR 权限
](#gettingstarted-images-permissions)
+ [
## 函数周期
](#images-lifecycle)
## 要求
安装 [AWS CLI 版本 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 和 [Docker CLI](https://docs.docker.com/get-docker)。此外，请注意以下要求：
+ 容器映像必须实施 [将 Lambda 运行时 API 用于自定义运行时](runtimes-api.md)。AWS开源[运行时接口客户端](#images-ric)实施 API。您可以将运行时接口客户端添加到首选基本映像中以使其与 Lambda 兼容。
+ 容器映像必须能够在只读文件系统上运行。您的函数代码可以访问具有介于 512 MB 至 10,240 MB（以 1 MB 为增量）的存储空间的可写 `/tmp` 目录。
+ 默认 Lambda 用户必须能够读取运行函数代码所需的所有文件。Lambda 通过定义具有最低权限的默认 Linux 用户来遵循安全最佳实践。这意味着您无需在 Dockerfile 中指定 [USER](https://docs.docker.com/reference/dockerfile/#user)。验证您的应用程序代码是否不依赖于其他 Linux 用户被限制运行的文件。
+ Lambda 仅支持基于 Linux 的容器映像。
+ Lambda 提供多架构基础映像。但是，您为函数构建的映像必须仅针对其中一个架构。Lambda 不支持使用多架构容器映像的函数。
## 使用 Lambda 的 AWS 基本映像
您可以使用 Lambda 的其中一个 [AWS 基本映像](https://gallery.ecr.aws/lambda/)，为函数代码构建容器映像。基本镜像预加载了语言运行时和在 Lambda 上运行容器镜像所需的其他组件。将函数代码和依赖项添加到基本镜像中，然后将其打包为容器镜像。
AWS定期为 Lambda 的AWS基本映像提供更新。如果 Dockerfile 在 FROM 属性中包含映像名称，则 Docker 客户端将从 [Amazon ECR 存储库](https://gallery.ecr.aws/lambda/)中提取最新版本的映像。要使用更新后的基本映像，必须重建容器映像并[更新函数代码](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)。
Node.js 20、Python 3.12、Java 21、.NET 8、Ruby 3.3 及更高版本的基础映像都基于 [Amazon Linux 2023 最小容器映像](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html)。早期的基础映像使用 Amazon Linux 2。与 Amazon Linux 2 相比，AL2023 具有多项优势，包括较小的部署占用空间以及 `glibc` 等更新版本的库。
基于 AL2023 的映像使用 `microdnf`（符号链接为 `dnf`）作为软件包管理器，而不是 Amazon Linux 2 中的默认软件包管理器 `yum`。`microdnf` 是 `dnf` 的独立实现。有关基于 AL2023 的映像中已包含软件包的列表，请参阅[比较 Amazon Linux 2023 容器映像上安装的软件包](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html)中的**最小容器**列。有关 AL2023 和 Amazon Linux 2 之间区别的更多信息，请参阅 AWS Compute Blog 上的 [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/)。
**注意**
要在本地运行基于 AL2023 的映像，包括使用 AWS Serverless Application Model（AWS SAM），您必须使用 Docker 版本 20.10.10 或更高版本。
要使用 AWS 基本映像构建容器映像，请选择您的首选语言的说明：
+ [Node.js](nodejs-image.md#nodejs-image-instructions)
+ [TypeScript](typescript-image.md#base-image-typescript)（使用 Node.js 基本映像）
+ [Python](python-image.md#python-image-instructions)
+ [Java](java-image.md#java-image-instructions)
+ [Go](go-image.md#go-image-provided)
+ [.NET](csharp-image.md#csharp-image-instructions)
+ [Ruby](ruby-image.md#ruby-image-instructions)
## 使用 AWS 仅限操作系统的基础镜像
[AWS 仅限操作系统的运行时系统](https://gallery.ecr.aws/lambda/provided)包含 Amazon Linux 发行版和[运行时系统接口模拟器](https://github.com/aws/aws-lambda-runtime-interface-emulator/)。这些镜像通常用于为编译语言（例如 [Go](go-image.md#go-image-provided) 和 [Rust](lambda-rust.md)）以及 Lambda 未提供基础映像的语言或语言版本（例如 Node.js 19）创建容器镜像。您也可以使用仅限操作系统的基础映像来实施[自定义运行时系统](runtimes-custom.md)。要使映像与 Lambda 兼容，则必须在映像中包含适用于您的语言的[运行时系统接口客户端](#images-ric)。
| 标签 | 运行时 | 操作系统 | Dockerfile | 弃用 |
| --- | --- | --- | --- | --- |
| al2023 | 仅限操作系统的运行时系统 | Amazon Linux 2023 | [GitHub 上用于仅限操作系统的运行时系统的 Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 2029 年 6 月 30 日 |
| al2 | 仅限操作系统的运行时系统 | Amazon Linux 2 | [GitHub 上用于仅限操作系统的运行时系统的 Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 2026 年 7 月 31 日 |
Amazon Elastic Container Registry Public Gallery：[gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## 使用非 AWS 基本映像
Lambda 支持符合以下映像清单格式之一的任何映像：
+ Docker Image Manifest V2，Schema 2（与 Docker 版本 1.10 和更新版本配合使用）
+ Open Container Initiative (OCI) 规范（v1.0.0 和更高版本）
Lambda 支持的最大未压缩图像大小为 10GB，包括所有层。
**注意**
要使映像与 Lambda 兼容，则必须在映像中包含适用于您的语言的[运行时系统接口客户端](#images-ric)。
为了获得最佳性能，请将图像清单大小保持在 25,400 字节以下。为了减少图像清单的大小，请尽量减少图像中的图层数量并减少注释。
## 运行时接口客户端
如果使用[仅限操作系统的基础映像](#runtimes-images-provided)或者备用基础映像，则必须在映像中包括运行时系统接口客户端。该运行时系统接口客户端必须扩展 [将 Lambda 运行时 API 用于自定义运行时](runtimes-api.md)，它管理 Lambda 与函数代码之间的交互。AWS 为以下语言提供开源运行时系统接口客户端：
+ [Node.js](nodejs-image.md#nodejs-image-clients)
+ [Python](python-image.md#python-image-clients)
+ [Java](java-image.md#java-image-clients)
+ [.NET](csharp-image.md#csharp-image-clients)
+ [Go](go-image.md#go-image-clients)
+ [Ruby](ruby-image.md#ruby-image-clients)
+ [Rust](lambda-rust.md) –
如果您使用的语言没有 AWS 提供的运行时系统接口客户端，则必须创建您自己的运行时系统接口客户端。
## Amazon ECR 权限
在从容器映像创建 Lambda 函数之前，您必须在本地构建映像并将其上传到 Amazon ECR 存储库。在您创建该函数时，指定 Amazon ECR 存储库 URI。
确保创建函数的用户或角色的权限包含 `GetRepositoryPolicy`、`SetRepositoryPolicy`、`BatchGetImage` 和 `GetDownloadUrlForLayer`。
例如，使用 IAM 控制台创建具有以下策略的角色：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ecr:SetRepositoryPolicy",
"ecr:GetRepositoryPolicy",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world"
}
]
}
```
------
### Amazon ECR 存储库策略
要将相同账户中的函数用作 Amazon ECR 中的容器映像，您可以向 Amazon ECR 存储库策略添加 `ecr:BatchGetImage` 和 `ecr:GetDownloadUrlForLayer` 权限。以下示例显示最小策略：
```
{
"Sid": "LambdaECRImageRetrievalPolicy",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
]
}
```
有关更多 Amazon ECR 存储库权限的信息，请参阅《Amazon Elastic Container Registry 用户指南》**中的[私有存储库策略](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html)。
如果 Amazon ECR 存储库不包含这些权限，则 Lambda 会尝试自动添加这些权限。仅当调用 Lambda 的主体具有 `ecr:getRepositoryPolicy` 和 `ecr:setRepositoryPolicy` 权限时，Lambda 才能添加这些权限。
要查看或编辑您的 Amazon ECR 存储库权限，请参阅《Amazon Elastic Container Registry 用户指南》**中的[设置私有存储库策略声明](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html)。
#### Amazon ECR 跨账户权限
相同区域中的不同账户可以创建一个使用您的账户拥有的容器镜像的函数。在以下示例中，您的 [Amazon ECR 存储库权限策略](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html)需要以下语句，才能向账号 123456789012 授予访问权限。
+ **CrossAccountPermission** – 允许账号 123456789012 创建和更新使用此 ECR 存储库中的镜像的 Lambda 函数。
+ **LambdaECRImageCrossAccountRetrievalPolicy**：如果在延迟期内未调用 Lambda，则 Lambda 最终会将函数的状态设置为不活动。此语句是必需的，以便 Lambda 可以检索容器镜像，代表 123456789012 拥有的函数进行优化和缓存。
**Example – 添加对存储库的跨账户权限**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountPermission",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
},
{
"Sid": "LambdaECRImageCrossAccountRetrievalPolicy",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Condition": {
"ArnLike": {
"aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*"
}
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
}
]
}
```
要授予对多个账户的访问权限，您可以在 `CrossAccountPermission` 策略中将该账户 ID 添加到主体列表，并在 `LambdaECRImageCrossAccountRetrievalPolicy` 中将该账户 ID 添加到条件评估列表。
如果您在 AWS Organization 中使用多个账户，我们建议您在 ECR 权限策略中枚举每个账户 ID。此方法遵循在 IAM 策略中设置窄权限的 AWS 安全最佳实践。
除了 Lambda 权限外，创建函数的用户或角色还必须拥有 `BatchGetImage` 和 `GetDownloadUrlForLayer` 权限。
## 函数周期
上传新的或更新的容器镜像后，Lambda 会在函数可以处理调用之前优化镜像。优化过程可能需要几秒钟的时间。函数会一直处于 `Pending` 状态，直到过程完成，此时状态将转为 `Active`。在函数到达 `Active` 状态之前，您无法调用该函数。
如果函数在数周内未被调用，则 Lambda 回收其优化版本，函数将转换为 `Inactive` 状态。要重新激活函数，必须调用它。Lambda 拒绝第一次调用，函数进入 `Pending` 状态，直到 Lambda 重新优化镜像。然后函数返回到 `Active` 状态。
Lambda 定期从 Amazon ECR 存储库获取关联的容器映像。如果相应的容器镜像不再存在于 Amazon ECR 上或权限已撤消，则函数将进入 `Failed` 状态，并且 Lambda 将对任何函数调用返回失败。
您可以使用 Lambda API 获取函数状态的相关信息。有关更多信息，请参阅 [Lambda 函数状态](functions-states.md)。
# 配置 Lambda 函数内存
Lambda 根据配置的内存量按比例分配 CPU 功率。*内存*是在运行时可用于 Lambda 函数的内存量。请使用**内存**设置增加分配给函数的内存和 CPU 处理能力。您可以以 1MB 的增量将内存配置在 128MB 与 10240MB 之间。大小为 1769 MB 时，函数相当于一个 vCPU（每秒一个 vCPU 秒的积分）的处理能力。
本页介绍如何以及何时更新 Lambda 函数的内存设置。
**Topics**
+ [
## 确定 Lambda 函数的适当内存设置
](#configuration-memory-use-cases)
+ [
## 配置函数内存（控制台）
](#configuration-memory-console)
+ [
## 配置函数内存（AWS CLI）
](#configuration-memory-cli)
+ [
## 配置函数内存（AWS SAM）
](#configuration-memory-sam)
+ [
## 接受函数内存推荐（控制台）
](#configuration-memory-optimization-accept)
## 确定 Lambda 函数的适当内存设置
内存是控制函数性能的主要杠杆。默认设置 128MB 是可能的最低设置。建议您仅将 128MB 用于简单的 Lambda 函数，例如用于转换事件并将其路由到其他 AWS 服务的函数。更高的内存分配可以提高函数的性能，这些函数使用导入的库、[Lambda 层](chapter-layers.md)、Amazon Simple Storage Service（Amazon S3）或 Amazon Elastic File System（Amazon EFS）。按比例增加更多内存会增加 CPU 的容量，从而提高可用的总体计算能力。如果函数受限于 CPU、网络或内存，则增加内存设置可以显著提高其性能。
要找到正确的内存配置，请使用 Amazon CloudWatch 监控您的函数，并设置在内存消耗接近配置的最大值时发出警报。这有助于识别内存受限函数。对于 CPU 受限和 IO 受限函数，监控持续时间通常可以提供洞察。在这些情况下，增加内存可以协助解决计算或网络瓶颈。
您也可以考虑使用开源的 [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning) 工具。此工具使用 AWS Step Functions 在不同的内存分配下运行 Lambda 函数的多个并行版本并衡量性能。输入函数在您的 AWS 账户中运行，以执行实时 HTTP 调用和 SDK 交互，从而衡量实时制作场景中可能的性能。您也可以实施 CI/CD 流程，以使用此工具自动衡量所部署的新函数的性能。
## 配置函数内存（控制台）
您可以在 Lambda 控制台中配置函数内存。
**要更新函数内存**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择函数。
1. 选择**配置**选项卡，然后选择**常规配置**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/configuration-tab.png)
1. 在**常规配置**下，选择**编辑**。
1. 对于**内存**，设置一个从 128MB 到 10240MB 的值。
1. 选择**保存**。
## 配置函数内存（AWS CLI）
您可以使用 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令来配置函数的内存。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--memory-size 1024
```
## 配置函数内存（AWS SAM）
您可以使用 [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) 来配置函数的内存。更新 `template.yaml` 文件中的 [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize) 属性，然后运行 [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 1024
# Other function properties...
```
## 接受函数内存推荐（控制台）
如果您在 AWS Identity and Access Management (IAM) 中拥有管理员权限，则可以选择加入以接收来自 AWS Compute Optimizer 的 Lambda 函数内存设置推荐。有关选择加入您账户或企业的内存推荐的说明，请参阅 *AWS Compute Optimizer 用户指南*中的[选择加入您的账户](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in)。
**注意**
Compute Optimizer 只支持使用 x86\$164 架构的函数。
当您选择加入并且 [Lambda 函数符合 Compute Optimizer 要求](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions)时，您可以在**常规配置**中的 Lambda 控制台的 Compute Optimizer 中查看和接受函数内存推荐。
# 为 Lambda 函数配置短暂存储
Lambda 为 `/tmp` 目录中的函数提供短暂存储。此存储是临时的，并且对于每个执行环境都是独一无二的。您可以使用**短暂存储**设置来控制分配给函数的短暂存储量。您可以以 1MB 的增量将短暂存储配置在 512MB 与 10240MB 之间。存储在 `/tmp` 中的所有数据都是使用由 AWS 管理密钥进行静态加密。
本页介绍常见应用场景以及如何更新 Lambda 函数的短暂存储。
**Topics**
+ [
## 增加短暂存储的常见应用场景
](#configuration-ephemeral-storage-use-cases)
+ [
## 配置短暂存储（控制台）
](#configuration-ephemeral-storage-console)
+ [
## 配置短暂存储（AWS CLI）
](#configuration-ephemeral-storage-cli)
+ [
## 配置短暂存储（AWS SAM）
](#configuration-ephemeral-storage-sam)
## 增加短暂存储的常见应用场景
以下是几个可从增加短暂存储中受益的常见应用场景：
+ **提取-转换-加载（ETL）作业：**当您的代码执行中间计算或下载其他资源以完成处理时，增加短暂存储。更多的临时空间允许在 Lambda 函数中运行更复杂的 ETL 作业。
+ **机器学习（ML）推理：**许多推理任务依赖于大型参考数据文件，包括库和模型。有了更多短暂存储，您可以从 Amazon Simple Storage Service（Amazon S3）将更大的模型下载到 `/tmp` 并将其用于处理。
+ **数据处理：**对于从 Amazon S3 下载对象以响应 S3 事件的工作负载，更多的 `/tmp` 空间使得无需使用内存中处理即可处理较大的对象。创建 PDF 或处理媒体的工作负载也将从更多短暂的存储中获益。
+ **图形处理：**图像处理是基于 Lambda 的应用程序的常见应用场景。对于处理大型 TIFF 文件或卫星图像的工作负载，更多的短暂存储可以更轻松地在 Lambda 中使用库和执行计算。
## 配置短暂存储（控制台）
您可以在 Lambda 控制台中配置临时存储。
**要修改函数的临时存储**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数。
1. 选择**配置**选项卡，然后选择**常规配置**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/configuration-tab.png)
1. 在**常规配置**下，选择**编辑**。
1. 对于**短暂存储**，以 1MB 的增量将值设置在 512MB 与 10240MB 之间。
1. 选择**保存**。
## 配置短暂存储（AWS CLI）
您可以使用 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令来配置短暂存储。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--ephemeral-storage '{"Size": 1024}'
```
## 配置短暂存储（AWS SAM）
您可以使用 [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) 为您的函数配置短暂存储。更新 `template.yaml` 文件中的 [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage) 属性，然后运行 [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs22.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
# Other function properties...
```
# 为 Lambda 函数选择和配置指令集架构
Lambda 函数的*指令集架构*决定了 Lambda 用于运行该函数的计算机处理器类型。Lambda 提供了多种指令集架构以供选择：
+ arm64 - 64 位 ARM 架构，适用于 AWS Graviton2 处理器。
+ x86\$164 - 64 位 x86 架构，适用于基于 x86 的处理器。
**注意**
arm64 架构在大多数 AWS 区域 中都可用。有关更多信息，请参阅[AWS Lambda定价](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135)。在内存价格表中，选择 **Arm Price**（Arm 定价）选项卡，然后打开 **Region**（区域）下拉列表，查看哪些 AWS 区域 支持使用 Lambda 的 arm64。
有关如何使用 arm64 架构创建函数的示例，请参阅 [AWS Graviton2 处理器提供支持的 AWS Lambda 函数](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/)。
**Topics**
+ [
## 使用 arm64 架构的优势
](#foundation-arch-adv)
+ [
## 迁移到 arm64 架构的要求
](#foundation-arch-consider)
+ [
## 函数代码与 arm64 架构的兼容性
](#foundation-arch-considerations)
+ [
## 如何迁移到 arm64 架构
](#foundation-arch-steps)
+ [
## 配置指令集架构
](#foundation-arch-config)
## 使用 arm64 架构的优势
与在 x86\$164 架构上运行的同等函数相比，使用 arm64 架构的 Lambda 函数（AWS Graviton2 处理器）价格更低廉且性能更出色。可考虑将 arm64 用于计算密集型应用程序，例如高性能计算、视频编码和模拟工作负载。
Graviton2 CPU 使用 Neoverse N1 内核，并支持 Armv8.2（包括 CRC 和加密扩展）以及其他几个架构扩展。
Graviton2 通过为每个 vCPU 提供更大的二级缓存来缩短内存读取时间，从而提高了 Web 和移动后端、微服务和数据处理系统的延迟性能。Graviton2 还提供了改进的加密性能，并支持可改善基于 CPU 的机器学习推断延迟的指令集。
有关 AWS Graviton2 的更多信息，请参阅 [AWS Graviton 处理器](https://aws.amazon.com/ec2/graviton)。
## 迁移到 arm64 架构的要求
当您选择要迁移到 arm64 架构的 Lambda 函数时，为确保顺利迁移，请确保函数满足以下要求：
+ 部署包只包含您控制的开源组件和源代码，从而您可以对迁移进行任何必要的更新。
+ 如果函数代码包含第三方依赖项，则每个库或软件包都提供 arm64 版本。
## 函数代码与 arm64 架构的兼容性
您的 Lambda 函数代码必须与函数的指令集架构兼容。在将函数迁移到 arm64 架构之前，请注意有关当前函数代码的以下几点：
+ 如果您使用嵌入式代码编辑器添加函数代码，那么您的代码可能不作任何修改地在任一架构上运行
+ 如果您上传了函数代码，则必须上传与目标架构兼容的新代码。
+ 如果您的函数使用层，则必须[检查每个层](adding-layers.md#finding-layer-information)以确保它与新架构兼容。如果层不兼容，请编辑函数以将当前层版本替换为兼容的层版本。
+ 如果您的函数使用 Lambda 扩展，则必须检查每个扩展以确保它与新架构兼容。
+ 如果您的函数使用容器映像部署包类型，则必须创建与该函数架构兼容的新容器映像。
## 如何迁移到 arm64 架构
要将 Lambda 函数迁移到 arm64 架构，我们建议执行以下步骤：
1. 为应用程序或工作负载构建依赖项列表。常见的依赖项包括：
+ 该函数使用的所有库和软件包。
+ 用于构建、部署和测试函数的工具，例如编译器、测试套件、持续集成和持续交付 (CI/CD) 管道、调配工具和脚本。
+ 您用于监控生产中函数的 Lambda 扩展和第三方工具。
1. 对于每个依赖项，请检查版本，然后检查 arm64 版本是否可用。
1. 构建环境以迁移应用程序
1. 引导启动应用程序。
1. 测试和调试应用程序。
1. 测试 arm64 函数的性能。将此性能与 x86\$164 版本进行比较。
1. 更新您的基础设施管道以支持 arm64 Lambda 函数。
1. 将部署投入生产阶段。
例如，使用[别名路由配置](configuring-alias-routing.md)在函数的 x86 和 arm64 版本之间拆分流量，并比较性能和延迟。
有关如何为 arm64 架构创建代码环境的更多信息，包括 Java、Go、.NET 和 Python 的语言特定信息，请参阅[AWS Graviton 入门](https://github.com/aws/aws-graviton-getting-started) GitHub 存储库。
## 配置指令集架构
您可以使用 Lambda 控制台、AWS 开发工具包、AWS Command Line Interface (AWS CLI) 或 CloudFormation 为新的和现有 Lambda 函数配置指令集架构。按照以下步骤从控制台对现有 Lambda 函数的指令集架构进行更改。
1. 打开 Lamba 控制台的[函数页面](https://console.aws.amazon.com/lambda/home#/functions)。
1. 选择要为其配置指令集架构的函数的名称。
1. 在主**代码**选项卡上，对于**运行时设置**部分，选择**编辑**。
1. 对于**架构**，选择要用于您的函数的指令集架构。
1. 选择**保存**。
# 配置 Lambda 函数超时
在超时之前，Lambda 会在设定的时间内运行您的代码。*超时*是 Lambda 函数可以运行的最大时间量（以秒为单位）。此设置的默认值为 3 秒，但您可以按照 1 秒增量调整此值，最大值为 900 秒（15 分钟）。
本页介绍如何以及何时更新 Lambda 函数的超时设置。
**Topics**
+ [
## 确定 Lambda 函数的适当超时值
](#configuration-timeout-use-cases)
+ [
## 配置超时（控制台）
](#configuration-timeout-console)
+ [
## 配置超时（AWS CLI）
](#configuration-timeout-cli)
+ [
## 配置超时（AWS SAM）
](#configuration-timeout-sam)
## 确定 Lambda 函数的适当超时值
如果超时值接近函数的平均持续时间，则该函数意外超时的风险较高。函数的持续时间可能因数据传输和处理量以及与该函数交互的任何服务的延迟而不同。导致超时的一些常见原因包括：
+ Amazon Simple Storage Service（Amazon S3）下载量大于平均水平或需要的时间更长。
+ 一个函数向另一项服务发出请求，这需要更长的时间才能响应。
+ 提供给函数的参数要求函数具有更高的计算复杂度，这会导致调用花费更长的时间。
在测试应用程序时，请确保您的测试准确反映数据的大小和数量以及真实的参数值。为方便起见，测试通常使用少量样本，但您应该在您的工作负载合理预期值的上限使用数据集。
## 配置超时（控制台）
您可以在 Lambda 控制台中配置函数的超时时间。
**修改函数的超时时间**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数。
1. 选择**配置**选项卡，然后选择**常规配置**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/configuration-tab.png)
1. 在**常规配置**下，选择**编辑**。
1. 对于**超时**，设置一个介于 1 到 900 秒（15 分钟）之间的值。
1. 选择**保存**。
## 配置超时（AWS CLI）
您可以使用 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令来配置超时值，以秒为单位。以下示例命令将函数超时增加到 120 秒（2 分钟）。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--timeout 120
```
## 配置超时（AWS SAM）
您可以使用 [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) 来配置函数的超时值。更新 `template.yaml` 文件中的 [Timeout](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) 属性，然后运行 [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
# Other function properties...
```
# 配置 Lambda 持久性函数
要为您的 Lambda 函数启用持久执行，您需要配置特定的设置项，以控制您的函数运行的时长、状态数据的保留时长，以及所需的权限。
## 启用持久执行
要为您的 Lambda 函数启用持久执行，请在您的函数配置中配置 `DurableConfig`。此设置将控制执行超时、状态保留和版本控制行为。
------
#### [ AWS CLI ]
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--durable-config '{
"ExecutionTimeout": 3600,
"RetentionPeriodInDays": 30,
"AllowInvokeLatest": true
}'
```
------
#### [ CloudFormation ]
```
Resources:
MyDurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-durable-function
Runtime: nodejs18.x
Handler: index.handler
Code:
ZipFile: |
// Your durable function code
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 30
AllowInvokeLatest: true
```
------
**配置参数：**
+ `ExecutionTimeout`：最长执行时间，以秒为单位（一年最多 31536000 秒）
+ `RetentionPeriodInDays`：将执行状态和历史记录保留的时长（1-365 天）
+ `AllowInvokeLatest`：是否允许调用 \$1LATEST 版本进行持久执行
## 持久性函数的 IAM 权限
除了标准 Lambda 执行角色之外，持久性函数还需要其他 IAM 权限。您的函数的执行角色必须包括状态管理和持久执行 API 的权限。
**所需的最低权限：**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ManageDurableState",
"lambda:GetDurableExecution",
"lambda:ListDurableExecutions"
],
"Resource": "arn:aws:lambda:*:*:function:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**CloudFormation 执行角色示例：**
```
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: DurableFunctionPolicy
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- lambda:ManageDurableState
- lambda:GetDurableExecution
- lambda:ListDurableExecutions
Resource: '*'
```
## 配置最佳实践
在配置持久性函数以供生产使用时，请遵循以下最佳实践：
+ **设置适当的执行超时**：根据工作流程的最大预期持续时间配置 `ExecutionTimeout`。请勿设置过长的超时时间，因为这会影响成本和资源分配。
+ **平衡保留期和存储成本**：根据您的调试和审计要求设置 `RetentionPeriodInDays`。延长保留期会增加存储成本。
+ **在生产环境中使用版本控制**：在生产环境中将 `AllowInvokeLatest` 设置为 `false`，并使用特定的函数版本或别名进行持久执行。
+ **监控状态大小**：大型状态对象会增加存储成本并可能影响性能。保持状态信息简洁，并将大量数据存储在外部存储中。
+ **配置适当的日志记录**：启用详细日志记录，以便对长时间运行的工作流程进行故障排除，但要注意日志量和成本。
**生产配置示例：**
```
{
"ExecutionTimeout": 86400,
"RetentionPeriodInDays": 7,
"AllowInvokeLatest": false
}
```
# 使用 Lambda 环境变量
您可以使用环境变量来调整函数的行为，而无需更新代码。环境变量是存储在函数的版本特定配置中的一对字符串。Lambda 运行时使环境变量可用于您的代码，并设置其他环境变量，这些变量包含有关函数和调用请求的信息。
**注意**
为了提高安全性，建议使用 AWS Secrets Manager 而非环境变量来存储数据库凭证和其他敏感信息，例如 API 密钥或授权令牌。有关更多信息，请参阅 [在 Lambda 函数中使用 Secrets Manager 密钥](with-secrets-manager.md)。
环境变量不会在调用函数之前评估。您定义的任何值都将被视为文字字符串，且不会被展开。在函数代码中执行变量估算。
## 创建 Lambda 环境变量
您可以使用 Lambda 控制台、AWS Command Line Interface（AWS CLI）、AWS Serverless Application Model（AWS SAM）或使用 AWS SDK 在 Lambda 中配置环境变量。
------
#### [ Console ]
您可以在函数的未发布版本上定义环境变量。发布一个版本时，会锁定该版本的环境变量以及其他[特定于版本的配置设置](configuration-versions.md)。
您可以通过定义键和值为函数创建环境变量。您的函数使用键名来检索环境变量的值。
**在 Lambda 控制台中设置环境变量**
1. 打开 Lamba 控制台的 [Functions](https://console.aws.amazon.com/lambda/home#/functions)（函数）页面。
1. 选择函数。
1. 选择**配置**，然后选择**环境变量**。
1. 在 **Environment variables (环境变量)** 下，选择 **Edit (编辑)**。
1. 选择 **Add environment variable (添加环境变量)**。
1. 输入键和值。
**要求**
+ 密钥以字母开头，并且至少为两个字符。
+ 键仅包含字母、数字和下划线字符 (`_`)。
+ [Lambda 不会保留](#configuration-envvars-runtime)密钥。
+ 所有环境变量的总大小不超过 4 KB。
1. 选择**保存**。
**在控制台代码编辑器中生成环境变量列表**
您可以在 Lambda 代码编辑器中生成环境变量列表。这是在编码时快速引用环境变量的方法。
1. 选择**节点**选项卡。
1. 向下滚动到代码编辑器的**环境变量**部分。下面列出了现有的环境变量：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/env-var.png)
1. 要创建新的环境变量，请选择加号（![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/add-plus.png)）：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-env-var.png)
在控制台代码编辑器中列出时，环境变量会保持加密状态。如果您为传输中的加密启用了加密帮助程序，这些设置则会保持不变。有关更多信息，请参阅 [保护 Lambda 环境变量](configuration-envvars-encryption.md)。
环境变量列表是只读的，仅在 Lambda 控制台上可用。当您下载函数的.zip 文件存档时，此文件并不包括在内；您也无法通过上传此文件来添加环境变量。
------
#### [ AWS CLI ]
以下示例在名为 `my-function` 的函数上设置两个环境变量。
```
aws lambda update-function-configuration \
--function-name my-function \
--environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}"
```
使用 `update-function-configuration` 命令应用环境变量时，会替换 `Variables` 结构的整个内容。要在添加新环境变量时保留现有环境变量，请在请求中包含所有现有值。
要获取当前配置，请使用 `get-function-configuration` 命令。
```
aws lambda get-function-configuration \
--function-name my-function
```
您应看到以下输出：
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::111122223333:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "amzn-s3-demo-bucket",
"KEY": "file.txt"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}
```
您可以将 `get-function-configuration` 输出中的修订版 ID 作为参数传递给 `update-function-configuration`。此举可确保这些值在您读取配置和更新配置之间不会发生变化。
要配置函数的加密密钥，请设置 `KMSKeyARN` 选项。
```
aws lambda update-function-configuration \
--function-name my-function \
--kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```
------
#### [ AWS SAM ]
您可以使用 [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) 来为您的函数配置环境变量。更新 `template.yaml` 文件中的 [Environment](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) 和 [Variables](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) 属性，然后运行 [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs24.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
Environment:
Variables:
BUCKET: amzn-s3-demo-bucket
KEY: file.txt
# Other function properties...
```
------
#### [ AWS SDKs ]
要使用 AWS SDK 管理环境变量，请使用以下 API 操作。
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
要了解更多信息，请参阅您首选编程语言的 [AWS SDK 文档](https://aws.amazon.com/developer/tools/)。
------
## 环境变量的示例场景
您可以使用环境变量来自定义测试环境和生产环境中的函数行为。例如，您可以创建两个具有相同代码但不同配置的函数。一个函数连接到测试数据库，另一个函数连接到生产数据库。在这种情况下，您可以使用环境变量向函数传递数据库的主机名和其他连接详细信息。
以下示例说明如何将数据库主机和数据库名称定义为环境变量。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/console-env.png)
如果希望测试环境生成比生产环境更多的调试信息，可以设置环境变量来配置测试环境使用更详细的日志记录或跟踪。
例如，您可以在测试环境中设置一个环境变量，其键为 `LOG_LEVEL`，值表示调试或跟踪的日志级别。然后，在 Lambda 函数的代码中，您可以使用此环境变量来设置日志级别。
以下 Python 和 Node.js 代码示例说明如何实现这一目标。这些示例假设您的环境变量在 Python 中的值为 `DEBUG`，在 Node.js 中的值为 `debug`。
------
#### [ Python ]
**Example 设置日志级别的 Python 代码**
```
import os
import logging
# Initialize the logger
logger = logging.getLogger()
# Get the log level from the environment variable and default to INFO if not set
log_level = os.environ.get('LOG_LEVEL', 'INFO')
# Set the log level
logger.setLevel(log_level)
def lambda_handler(event, context):
# Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment')
logger.info('This is a log with standard information - shown in production and test environments')
```
------
#### [ Node.js (ES module format) ]
**Example 设置日志级别的 Node.js 代码**
此示例使用 `winston` 日志记录库。使用 npm 将此库添加到函数的部署包中。有关更多信息，请参阅 [创建含依赖项的 .zip 部署包](nodejs-package.md#nodejs-package-create-dependencies)。
```
import winston from 'winston';
// Initialize the logger using the log level from environment variables, defaulting to INFO if not set
const logger = winston.createLogger({
level: process.env.LOG_LEVEL || 'info',
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
export const handler = async (event) => {
// Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment');
logger.info('This is a log with standard information - shown in production and test environment');
};
```
------
## 检索 Lambda 环境变量
要检索函数代码中的环境变量，请使用编程语言的标准方法。
------
#### [ Node.js ]
```
let region = process.env.AWS_REGION
```
------
#### [ Python ]
```
import os
region = os.environ['AWS_REGION']
```
**注意**
在某些情况下，您可能需要使用以下格式：
```
region = os.environ.get('AWS_REGION')
```
------
#### [ Ruby ]
```
region = ENV["AWS_REGION"]
```
------
#### [ Java ]
```
String region = System.getenv("AWS_REGION");
```
------
#### [ Go ]
```
var region = os.Getenv("AWS_REGION")
```
------
#### [ C\$1 ]
```
string region = Environment.GetEnvironmentVariable("AWS_REGION");
```
------
#### [ PowerShell ]
```
$region = $env:AWS_REGION
```
------
Lambda 通过静态加密来安全地存储环境变量。您可以[配置 Lambda 以使用不同的加密密钥](configuration-envvars-encryption.md)、在客户端加密环境变量值或使用 AWS Secrets Manager 在 CloudFormation 模板中设置环境变量。
## 定义运行时环境变量
Lambda [运行时](lambda-runtimes.md)会在初始化过程中设置多个环境变量。大多数环境变量提供有关函数或运行时的信息。这些环境变量的键是*预留* 的，无法在函数配置中设置。
**预留环境变量**
+ `_HANDLER` – 函数上配置的处理程序位置。
+ `_X_AMZN_TRACE_ID` – [X-Ray 跟踪标头](services-xray.md)。此环境变量会随着每次调用发生变化。
+ 此环境变量不是为仅限操作系统的运行时系统（`provided` 运行时系统系列）定义的。您可以使用来自 [下一个调用](runtimes-api.md#runtimes-api-next) 的 `Lambda-Runtime-Trace-Id` 响应标头设置用于自定义运行时的 `_X_AMZN_TRACE_ID`。
+ 对于 Java 运行时系统版本 17 及更高版本，不使用此环境变量。相反，Lambda 将把跟踪信息存储在 `com.amazonaws.xray.traceHeader` 系统属性中。
+ `AWS_DEFAULT_REGION` – 执行 Lambda 函数的默认 AWS 区域。
+ `AWS_REGION` – 执行 Lambda 函数的 AWS 区域。如果定义了该值，该值将会覆盖 `AWS_DEFAULT_REGION`。
+ 有关在 AWS SDK 中使用 AWS 区域 环境变量的更多信息，请参阅《AWS SDK 和工具参考指南》**中的 [AWS 区域](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat)。
+ `AWS_EXECUTION_ENV` – [运行时标识符](lambda-runtimes.md)，前缀为 `AWS_Lambda_`（例如 `AWS_Lambda_java8`）。此环境变量不是为仅限操作系统的运行时系统（`provided` 运行时系统系列）定义的。
+ `AWS_LAMBDA_FUNCTION_NAME` – 函数的名称。
+ `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` – 对函数可用的内存量（以 MB 为单位）。
+ `AWS_LAMBDA_FUNCTION_VERSION` – 要执行的函数的版本。
+ `AWS_LAMBDA_INITIALIZATION_TYPE`：函数的初始化类型，即 `on-demand`、`provisioned-concurrency`、`snap-start` 或 `lambda-managed-instances`。有关信息，请参阅[配置预置并发](provisioned-concurrency.md)、[使用 Lambda SnapStart 提高启动性能](snapstart.md) 或 [Lambda 托管实例](lambda-managed-instances.md)。
+ `AWS_LAMBDA_LOG_GROUP_NAME`、`AWS_LAMBDA_LOG_STREAM_NAME` – Amazon CloudWatch Logs 组和函数的流名称。`AWS_LAMBDA_LOG_GROUP_NAME` 和 `AWS_LAMBDA_LOG_STREAM_NAME` [环境变量](#configuration-envvars-runtime)在 Lambda SnapStart 函数中不可用。
+ `AWS_ACCESS_KEY`、`AWS_ACCESS_KEY_ID`、`AWS_SECRET_ACCESS_KEY``AWS_SESSION_TOKEN` – 从函数的[执行角色](lambda-intro-execution-role.md)中获取的访问密钥。
+ `AWS_LAMBDA_RUNTIME_API` –（[自定义运行时](runtimes-custom.md)）[运行时 API](runtimes-api.md) 的主机和端口。
+ `LAMBDA_TASK_ROOT` – Lambda 函数代码的路径。
+ `LAMBDA_RUNTIME_DIR` – 运行时库的路径。
+ `AWS_LAMBDA_MAX_CONCURRENCY`：（仅限 Lambda 托管实例）Lambda 将向一个执行环境发送的最大并发调用次数。
+ `AWS_LAMBDA_METADATA_API`–格式为 `{ipv4_address}:{port}` 的[元数据端点](configuration-metadata-endpoint.md)服务器地址（例如，`169.254.100.1:9001`）。
+ `AWS_LAMBDA_METADATA_TOKEN`–当前执行环境的唯一身份验证令牌，用于对[元数据端点](configuration-metadata-endpoint.md)的请求进行身份验证。Lambda 在初始化时会自动生成此令牌。
以下附加环境变量并非预留，可以在函数配置中扩展。
**非预留环境变量**
+ `LANG` – 运行时的区域设置 (`en_US.UTF-8`)。
+ `PATH` – 执行路径 (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`)。
+ `LD_LIBRARY_PATH` – 系统库路径 (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`)。
+ `NODE_PATH` – ([Node.js](lambda-nodejs.md)) Node.js 库路径 (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`)。
+ `NODE_OPTIONS` – ([Node.js](lambda-nodejs.md)) 对于 Node.js 运行时，可以使用 `NODE_OPTIONS` 来重新启用 Lambda 默认禁用的实验性功能。
+ `PYTHONPATH` –（[Python](lambda-python.md)）Python 库路径（`$LAMBDA_RUNTIME_DIR`）。
+ `GEM_PATH` –（[Ruby](lambda-ruby.md)）Ruby 库路径 (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`)。
+ `AWS_XRAY_CONTEXT_MISSING` – 对于 X-Ray 跟踪，Lambda 会将其设置为 `LOG_ERROR`，以避免从 X-Ray 开发工具包引发运行时错误。
+ `AWS_XRAY_DAEMON_ADDRESS` – 对于 X-Ray 跟踪，X-Ray 进程守护程序的 IP 地址和端口。
+ `AWS_LAMBDA_DOTNET_PREJIT` –（[.NET](lambda-csharp.md)）将此变量设置为启用或禁用 .NET 特定的运行时优化。值包括 `always`、`never` 和 `provisioned-concurrency`。有关更多信息，请参阅 [为函数配置预置并发](provisioned-concurrency.md)。
+ `TZ` – 环境的时区 (`:UTC`)。执行环境使用 NTP 同步系统时钟。
显示的示例值反映了最新的运行时。特定变量或其值是否存在会因早先的运行时而异。
# 保护 Lambda 环境变量
为了保护环境变量，您可以使用服务器端加密来保护静态数据，使用客户端加密来保护传输中数据。
**注意**
为了提高数据库的安全性，建议您使用 AWS Secrets Manager 而不是环境变量来存储数据库凭证。有关更多信息，请参阅 [在 Lambda 函数中使用 Secrets Manager 密钥](with-secrets-manager.md)。
**静态安全**
Lambda 始终使用 AWS KMS key 提供服务器端静态加密。默认情况下，Lambda 使用 AWS 托管式密钥。如果此默认行为适合您的工作流，您无需设置任何其他内容。Lambda 将在账户中创建 AWS 托管式密钥，并为您管理权限。AWS 不会向您收取使用此密钥的费用。
如果您愿意，可以提供 AWS KMS 客户托管式密钥。这样做可能是为了控制 KMS 密钥的轮换，或者是为了满足组织管理 KMS 密钥的要求。当您使用客户托管式密钥时，只有您账户中有权访问 KMS 密钥的用户才能查看或管理函数上的环境变量。
客户托管式密钥产生标准 AWS KMS 费用。有关更多信息，请参阅 [AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing/)。
**传输过程中的安全**
为了提高安全性，您可以为传输中加密启用帮助程序，这样可以确保环境变量在客户端加密，以便在传输过程中提供保护。
**为环境变量配置加密**
1. 使用 AWS Key Management Service（AWS KMS）创建任意客户托管式密钥，供 Lambda 用于服务器端和客户端加密。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[创建密钥](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)。
1. 使用 Lambda 控制台，导航到 **Edit environment variables (编辑环境变量)** 页面。
1. 打开 Lamba 控制台的 [Functions](https://console.aws.amazon.com/lambda/home#/functions)（函数）页面。
1. 选择函数。
1. 选择 **Configuration (配置)**，然后从左侧导航栏选择 **Environment variables (环境变量)**。
1. 在 **Environment variables (环境变量)** 部分中，选择 **Edit (编辑)**。
1. 展开 **Encryption configuration (加密配置)**。
1. （可选）启用控制台加密帮助程序，以使用客户端加密来保护传输中数据。
1. 在 **Encryption in transit (传输中加密)** 下，选择 **Enable helpers for encryption in transit (为传输中加密启用帮助程序)**。
1. 对于要为其启用控制台加密帮助程序的每个环境变量，选择环境变量旁的 **Encrypt**（加密）。
1. 在要传输中加密的 AWS KMS key 下，选择在此过程开始时创建的客户托管式密钥。
1. 选择 **Execution role policy (执行角色策略)**并复制策略。此策略授予函数执行角色解密环境变量的权限。
保存此策略以便在此过程的最后一步中使用。
1. 将代码添加到解密环境变量的函数中。选择**解密密钥代码段**来查看示例。
1. （可选）为静态加密指定您的客户托管密钥。
1. 选择 **Use a customer master key (使用客户主密钥)**。
1. 选择在此过程开始时创建的客户托管式密钥。
1. 选择 **Save**（保存）。
1. 设置权限。
如果您使用带有服务器端加密的客户托管密钥，请将权限授予您希望能查看或管理函数上的环境变量的任何用户或角色。有关更多信息，请参阅 [管理服务器端加密 KMS 密钥的权限](#managing-permissions-to-your-server-side-encryption-key)。
如果您为传输中的安全性启用客户端加密，您的函数需要调用 `kms:Decrypt` API 操作的权限。将之前在此过程中保存的策略添加到函数的[执行角色](lambda-intro-execution-role.md)。
## 管理服务器端加密 KMS 密钥的权限
您的用户或函数的执行角色不需要 AWS KMS 权限，即可使用默认加密密钥。要使用客户托管式密钥，您需要具有使用密钥的权限。Lambda 使用您的权限在密钥上创建授权。Lambda 可将其用于加密。
+ `kms:ListAliases` – 在 Lambda 控制台中查看密钥。
+ `kms:CreateGrant`、`kms:Encrypt` – 在函数上配置客户托管式密钥。
+ `kms:Decrypt` – 查看和管理使用客户托管式密钥加密的环境变量。
您可以从您的 AWS 账户 或从密钥的基于资源的权限策略获取这些权限。`ListAliases` 由 [Lambda 的托管策略](access-control-identity-based.md)提供。密钥策略将剩余权限授予**密钥用户**组中的用户。
没有 `Decrypt` 权限的用户仍然可以管理函数，但无法在 Lambda 控制台中查看或管理环境变量。要防止用户查看环境变量，请向用户的权限添加一条语句，该语句拒绝访问默认密钥、客户托管式密钥或所有密钥。
**Example IAM policy – 按密钥 ARN 拒绝访问**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc"
}
]
}
```
有关托管密钥权限的详细信息，请参阅《AWS Key Management Service 开发人员指南》**中的[使用 AWS KMS 的密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)。
# 授予 Lambda 函数访问 Amazon VPC 中资源的权限
使用 Amazon Virtual Private Cloud（Amazon VPC），您可以在自己的 AWS 账户中创建私有网络，以用于托管 Amazon Elastic Compute Cloud（Amazon EC2）实例、Amazon Relational Database Service（Amazon RDS）实例和 Amazon ElastiCache 实例等资源。您可以通过包含相关资源的私有子网将函数附加到 VPC，从而向您的 Lambda 函数授予访问在 Amazon VPC 中托管的资源的权限。按照以下各节中的说明，通过 Lambda 控制台、AWS Command Line Interface（AWS CLI）或 AWS SAM 将 Lambda 函数附加到 Amazon VPC。
**注意**
每个 Lambda 函数都在由 Lambda 服务拥有和管理的 VPC 内运行。这些 VPC 由 Lambda 自动维护，对客户不可见。配置您的函数以访问 Amazon VPC 中的其他 AWS 资源，不会影响在其中运行函数的由 Lambda 托管的 VPC。
**Topics**
+ [
## 所需的 IAM 权限
](#configuration-vpc-permissions)
+ [
## 将 Lambda 函数附加到您的 AWS 账户 中的 Amazon VPC
](#configuration-vpc-attaching)
+ [
## 连接到 VPC 时的互联网访问权限
](#configuration-vpc-internet-access)
+ [
## IPv6 支持
](#configuration-vpc-ipv6)
+ [
## 将 Lambda 与 Amazon VPC 结合使用的最佳实践
](#configuration-vpc-best-practice)
+ [
## 了解 Hyperplane 弹性网络接口（ENI）
](#configuration-vpc-enis)
+ [
## 将 IAM 条件键用于 VPC 设置
](#vpc-conditions)
+ [
## VPC 教程
](#vpc-tutorials)
## 所需的 IAM 权限
要将 Lambda 函数附加到您的 AWS 账户中的 Amazon VPC，Lambda 需要具有创建和管理网络接口的权限，以向您的函数授予访问该 VPC 中资源的权限。
Lambda 创建的网络接口被称为 Hyperplane 弹性网络接口，简称 Hyperplane ENI。要了解有关这些网络接口的更多信息，请参阅 [了解 Hyperplane 弹性网络接口（ENI）](#configuration-vpc-enis)。
您可以通过将 AWS 托管式策略 [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) 附加到函数的执行角色，从而向函数授予所需的权限。当您在 Lambda 控制台中创建新函数并将其附加到 VPC 时，Lambda 会自动为您添加此权限策略。
如果您希望创建自己的 IAM 权限策略，请务必添加以下所有权限，并在所有资源中 (`"Resource": "*"`) 启用：
+ ec2:CreateNetworkInterface
+ ec2:DescribeNetworkInterfaces
+ ec2:DescribeSubnets
+ ec2:DeleteNetworkInterface
+ ec2:AssignPrivateIpAddresses
+ ec2:UnassignPrivateIpAddresses
请注意，函数的角色需要这些权限只是为了创建网络接口，而不是调用您的函数。将函数附加到 Amazon VPC 后，即使您从函数的执行角色中移除了这些权限，您仍然可以成功调用该函数。
要将您的函数附加到 VPC，Lambda 还需要使用您的 IAM 用户角色验证网络资源。确保您的用户角色具有以下 IAM 权限：
+ **ec2:DescribeSecurityGroups**
+ **ec2:DescribeSubnets**
+ **ec2:DescribeVpcs**
+ **ec2:GetSecurityGroupsForVpc**
**注意**
Lambda 服务使用授予函数执行角色的 Amazon EC2 权限，将函数附加到 VPC。不过，您还会隐式向函数的代码授予这些权限。这意味着函数代码能够进行这些 Amazon EC2 API 调用。有关遵循安全性最佳实践的建议，请参阅 [安全最佳实践](#configuration-vpc-best-practice-security)。
## 将 Lambda 函数附加到您的 AWS 账户 中的 Amazon VPC
通过 Lambda 控制台、AWS CLI 或 AWS SAM 将您的函数附加到您的 AWS 账户中的 Amazon VPC。如果使用 AWS CLI 或 AWS SAM，或者使用 Lambda 控制台将现有的函数附加到 VPC，请确保函数的执行角色具有上一节中列出的必要权限。
Lambda 函数无法直接连接到具有[专用实例租赁](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html)的 VPC。要连接到专用 VPC 中的资源，[请使其与具有默认租赁的第二个 VPC 对等](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/)。
------
#### [ Lambda console ]
**在创建函数时将函数附加到 Amazon VPC**
1. 打开 Lambda 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面，然后选择**创建函数**。
1. 在**基本信息**下方的**函数名称**中，输入函数的名称。
1. 通过执行以下操作配置函数的 VPC 设置：
1. 展开 **Advanced settings**（高级设置）。
1. 选择**启用 VPC**，然后选择您希望附加该函数的 VPC。
1. （可选）要允许[出站 IPv6 流量](#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 选择要为其创建网络接口的子网和安全组。如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
**注意**
要访问私有资源，请将函数连接到私有子网。如果函数需要互联网访问权限，请参阅[为连接到 VPC 的 Lambda 函数启用互联网访问权限](configuration-vpc-internet.md)。将函数连接到公有子网不会授予其 Internet 访问权限或公有 IP 地址。
1. 选择**创建函数**。
**将现有函数附加到 Amazon VPC**
1. 打开 Lambda 控制台的[“函数”页面](https://console.aws.amazon.com/lambda/home#/functions)，然后选择函数。
1. 选择**配置**选项卡，然后选择 **VPC**。
1. 选择**编辑**。
1. 在 **VPC** 下，选择要附加您的函数的 Amazon VPC。
1. （可选）要允许[出站 IPv6 流量](#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 选择要为其创建网络接口的子网和安全组。如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
**注意**
要访问私有资源，请将函数连接到私有子网。如果函数需要互联网访问权限，请参阅[为连接到 VPC 的 Lambda 函数启用互联网访问权限](configuration-vpc-internet.md)。将函数连接到公有子网不会授予其 Internet 访问权限或公有 IP 地址。
1. 选择**保存**。
------
#### [ AWS CLI ]
**在创建函数时将函数附加到 Amazon VPC**
+ 要创建 Lambda 函数并将其附加到 VPC，请运行以下 CLI `create-function` 命令。
```
aws lambda create-function --function-name my-function \
--runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
指定您自己的子网和安全组，并根据您的使用案例将 `Ipv6AllowedForDualStack` 设置为 `true` 或 `false`。
**将现有函数附加到 Amazon VPC**
+ 要将现有的 Lambda 函数附加到 VPC，请运行以下 CLI `update-function-configuration` 命令。
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
**从 VPC 分离函数**
+ 要从 VPC 分离函数，请使用空白的子网和安全组列表运行以下 `update-function-configuration` CLI 命令。
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config SubnetIds=[],SecurityGroupIds=[]
```
------
#### [ AWS SAM ]
**将函数附加到 VPC**
+ 要将 Lambda 函数附加到 Amazon VPC，请将 `VpcConfig` 属性添加到函数定义中，如以下示例模板所示。有关此属性的更多信息，请参阅《CloudFormation 用户指南》**中的 [AWS::Lambda::Function VpcConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html)（将 AWS SAM `VpcConfig` 属性直接传递给 CloudFormation `AWS::Lambda::Function` 资源的 `VpcConfig` 属性）。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./lambda_function/
Handler: lambda_function.handler
Runtime: python3.12
VpcConfig:
SecurityGroupIds:
- !Ref MySecurityGroup
SubnetIds:
- !Ref MySubnet1
- !Ref MySubnet2
Policies:
- AWSLambdaVPCAccessExecutionRole
MySecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for Lambda function
VpcId: !Ref MyVPC
MySubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.1.0/24
MySubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.2.0/24
MyVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
```
有关在 AWS SAM 中配置 VPC 的更多信息，请参阅《CloudFormation 用户指南》中的 [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html)**。
------
## 连接到 VPC 时的互联网访问权限
默认情况下，Lambda 函数可以访问公共互联网。当您将函数附加到 VPC 时，该函数只能访问该 VPC 内可用的资源。要使您的函数能够访问互联网，您还需要将 VPC 配置为可以访问互联网。要了解更多信息，请参阅[为连接到 VPC 的 Lambda 函数启用互联网访问权限](configuration-vpc-internet.md)。
## IPv6 支持
您的函数可以通过 IPv6 连接到双堆栈 VPC 子网中的资源。默认情况下，此选项处于关闭状态。要允许出站 IPv6 流量，请使用控制台或使用带有 [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) 或 [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) 命令的 `--vpc-config Ipv6AllowedForDualStack=true`选项。
**注意**
要在 VPC 中允许出站 IPv6 流量，连接到该函数的所有子网都必须是双堆栈子网。Lambda 不支持 VPC 中针对仅限 IPv6 的子网的出站 IPv6 连接，也不支持未连接到 VPC 的函数的出站 IPv6 连接。
您可以更新函数代码以通过 IPv6 显式连接到子网资源。以下 Python 示例会打开一个套接字并连接到 IPv6 服务器。
**Example ：连接到 IPv6 服务器**
```
def connect_to_server(event, context):
server_address = event['host']
server_port = event['port']
message = event['message']
run_connect_to_server(server_address, server_port, message)
def run_connect_to_server(server_address, server_port, message):
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
try:
# Send data
sock.connect((server_address, int(server_port), 0, 0))
sock.sendall(message.encode())
BUFF_SIZE = 4096
data = b''
while True:
segment = sock.recv(BUFF_SIZE)
data += segment
# Either 0 or end of data
if len(segment) < BUFF_SIZE:
break
return data
finally:
sock.close()
```
## 将 Lambda 与 Amazon VPC 结合使用的最佳实践
为确保您的 Lambda VPC 配置符合最佳实践指南，请遵循以下各节中的建议。
### 安全最佳实践
要将您的 Lambda 函数附加到 VPC，您需要向函数的执行角色授予一些 Amazon EC2 权限。在创建函数用来访问 VPC 中资源的网络接口时将需要这些权限。不过，还会向函数的代码隐式授予这些权限。这意味着函数代码具有进行这些 Amazon EC2 API 调用的权限。
为遵循最低权限原则，请在函数的执行角色中添加与如下例类似的拒绝策略。此策略可阻止您的函数代码调用 Amazon EC2 API，同时仍允许 Lambda 服务代表您管理 VPC 资源。该策略使用 `lambda:SourceFunctionArn` 条件键，其仅适用于函数代码在执行期间进行的 API 调用。有关更多信息，请参阅 [使用源函数 ARN 控制函数访问行为](permissions-source-function-arn.md)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSubnets",
"ec2:DetachNetworkInterface",
"ec2:AssignPrivateIpAddresses",
"ec2:UnassignPrivateIpAddresses"
],
"Resource": [ "*" ],
"Condition": {
"ArnEquals": {
"lambda:SourceFunctionArn": [
"arn:aws:lambda:us-west-2:123456789012:function:my_function"
]
}
}
}
]
}
```
------
AWS 提供了*[安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)*和*[网络访问控制列表（ACL）](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)*功能来增强 VPC 中的安全性。安全组可以控制您的资源的入站和出站流量，网络 ACL 可以控制您的子网的入站和出站流量。安全组为大多数子网提供足够的访问控制。如果需要为 VPC 增加额外安全保护，您可以使用网络 ACL。有关使用 Amazon VPC 时的安全最佳实践的一般指南，请参阅《Amazon Virtual Private Cloud 用户指南》中的 [VPC 的安全最佳实践](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html)**。
### 性能最佳实践
当您将函数附加到 VPC 时，Lambda 会检查是否有可用来连接的可用网络资源（Hyperplane ENI）。Hyperplane ENI 与特定的安全组和 VPC 子网组合相关联。将一个函数附加到 VPC 后，如果在附加其他函数时指定相同的子网和安全组，这将意味着 Lambda 可以共享网络资源，无需创建新的 Hyperplane ENI。有关 Hyperplane ENI 及其生命周期的更多信息，请参阅 [了解 Hyperplane 弹性网络接口（ENI）](#configuration-vpc-enis)。
## 了解 Hyperplane 弹性网络接口（ENI）
Hyperplane ENI 是一种托管式资源，在您的 Lambda 函数和您希望函数连接到的资源之间充当网络接口。当您将函数附加到 VPC 时，Lambda 服务会自动创建和管理这些 ENI。
Hyperplane ENI 对您并不直接可见，因此您无需对其进行配置或管理。不过，了解其工作原理有助您在将函数附加到 VPC 时了解其行为。
首次使用特定的子网和安全组组合将函数附加到 VPC 时，Lambda 将创建一个 Hyperplane ENI。您账户中使用相同子网和安全组组合的其他函数也可以使用该 ENI。Lambda 会尽可能重复使用现有的 ENI 来优化资源利用率并减少新 ENI 的创建。每个 Hyperplane ENI 最多支持 65,000 个连接/端口。如果连接数超过此限制，Lambda 会根据网络流量和并发要求自动扩展 ENI 的数量。
对于新函数，当 Lambda 创建 Hyperplane ENI 时，您的函数仍处于“待处理”状态，因此无法调用。只有在 Hyperplane ENI 准备就绪后，您的函数才会变为“活动”状态，这可能需要几分钟。对于现有函数，您无法执行以该函数为目标的其他操作（例如创建版本或更新函数的代码），但可以继续调用该函数的早期版本。
作为管理 ENI 生命周期的一部分，Lambda 可能会删除并重新创建 ENI，以便对各个 ENI 的网络流量进行负载均衡或解决在 ENI 运行状况检查中发现的问题。此外，如果 Lambda 函数持续 14 天保持空闲状态，Lambda 将会回收任何未使用的 Hyperplane ENI，并将函数状态设置为`Inactive`。新调用尝试将会失败，并且函数会重新进入“待处理”状态，直到 Lambda 完成 Hyperplane ENI 创建或分配。我们建议您的设计不要依赖于 ENI 的持久性。
当您更新函数以删除其 VPC 配置时，Lambda 最多需要 20 分钟才能删除连接的 Hyperplane ENI。仅当没有其他函数（或已发布的函数版本）使用该 Hyperplane ENI 时，Lambda 才会删除 ENI。
Lambda 依赖于函数[执行角色](lambda-intro-execution-role.md)中的权限来删除 Hyperplane ENI。如果您在 Lambda 删除 Hyperplane ENI 之前删除执行角色，则 Lambda 将无法删除该 Hyperplane ENI。您可以手动执行删除。
## 将 IAM 条件键用于 VPC 设置
您可以将特定于 Lambda 的条件键用于 VPC 设置，从而为您的 Lambda 函数提供额外的权限控制。例如，您可以要求组织中的所有函数都连接到 VPC。您还可以指定函数的用户可以使用和不能使用的子网和安全组。
Lambda 在 IAM 策略中支持以下条件键：
+ **lambda:VpcIds** – 允许或拒绝一个或多个 VPC。
+ **lambda:SubnetIds** – 允许或拒绝一个或多个子网。
+ **lambda:SecurityGroupIds** – 允许或拒绝一个或多个安全组。
Lambda API 操作 [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) 和 [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) 支持这些条件键。有关在 IAM 策略中使用条件键的更多信息，请参阅《IAM 用户指南》**中的 [IAM JSON 策略元素：Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)。
**提示**
如果您的函数已包含来自前一个 API 请求的 VPC 配置，则可以发送不带 VPC 配置的 `UpdateFunctionConfiguration` 请求。
### 带有用于 VPC 设置的条件键的示例策略
以下示例演示如何将条件键用于 VPC 设置。创建具有所需限制的策略语句后，为目标用户或角色附加策略语句。
#### 确保用户仅部署与 VPC 连接的函数
要确保所有用户仅部署与 VPC 连接的函数，您可以拒绝不包含有效 VPC ID 的函数创建和更新操作。
请注意，VPC ID 不是 `CreateFunction` 或 `UpdateFunctionConfiguration` 请求的输入参数。Lambda 根据子网和安全组参数检索 VPC ID 值。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}
```
------
#### 拒绝用户访问特定的 VPC、子网或安全组
要拒绝用户访问特定 VPC，请使用 `StringEquals` 检查 `lambda:VpcIds` 条件的值。以下示例拒绝用户访问 `vpc-1` 和 `vpc-2`。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
要拒绝用户访问特定子网，请使用 `StringEquals` 检查 `lambda:SubnetIds` 条件的值。以下示例拒绝用户访问 `subnet-1` 和 `subnet-2`。
```
{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
要拒绝用户访问特定安全组，请使用 `StringEquals` 检查 `lambda:SecurityGroupIds` 条件的值。以下示例拒绝用户访问 `sg-1` 和 `sg-2`。
```
{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
#### 允许用户使用特定 VPC 设置创建和更新函数
要允许用户访问特定的 VPC，请使用 `StringEquals` 检查 `lambda:VpcIds` 条件的值。以下示例允许用户访问 `vpc-1` 和 `vpc-2`。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
要允许用户访问特定子网，请使用 `StringEquals` 检查 `lambda:SubnetIds` 条件的值。以下示例允许用户访问 `subnet-1` 和 `subnet-2`。
```
{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
要允许用户访问特定的安全组， 请使用 `StringEquals` 检查 `lambda:SecurityGroupIds` 条件的值。以下示例允许用户访问 `sg-1` 和 `sg-2`。
```
{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
## VPC 教程
在以下教程中，您会将 Lambda 函数连接到 VPC 中的资源。
+ [教程：使用 Lambda 函数，以便在 Amazon VPC 中访问 Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)
+ [教程：配置 Lambda 函数，以便在 Amazon VPC 中访问 Amazon ElastiCache](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html)
# 授予 Lambda 函数访问其他账户中 Amazon VPC 中资源的权限
可以为 AWS Lambda 函数提供权限来访问由其他账户管理的 Amazon Virtual Private Cloud 中 Amazon VPC 中的资源，而无需将任一 VPC 暴露在互联网中。此访问模式支持使用 AWS 与其他组织共享数据。使用此访问模式，可以在 VPC 之间共享数据，安全性和性能都比通过互联网共享更高。将 Lambda 函数配置为使用 Amazon VPC 对等连接来访问这些资源。
**警告**
如果您允许在账户或 VPC 之间进行访问，请检查您的计划是否符合管理这些账户的相应组织的安全要求。按照本文档中的说明进行操作，将影响资源的安全状况。
在本教程中，将使用 IPv4 通过对等连接将两个账户连接在一起。配置的 Lambda 函数尚未连接到 Amazon VPC。需配置 DNS 解析以将函数连接到不提供静态 IP 的资源。要使这些说明适应其他对等互连场景，请参阅《[VPC Peering Guide](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html)》。
## 先决条件
要让 Lambda 函数访问其他账户中的资源，您必须具有：
+ 一个 Lambda 函数，配置为使用您的资源进行身份验证，然后从中读取。
+ 其他账户中的资源，例如 Amazon RDS 集群，可通过 Amazon VPC 获得。
+ Lambda 函数账户和资源账户的凭证。如果您无权使用您的资源账户，请联系授权用户准备好该账户。
+ 用于创建和更新 VPC（以及支持的 Amazon VPC 资源）以与 Lambda 函数关联的权限。
+ 用于更新 Lambda 函数的执行角色和 VPC 配置的权限。
+ 用于在 Lambda 函数的账户中创建 VPC 对等连接的权限。
+ 用于在资源账户中接受 VPC 对等连接的权限。
+ 用于更新资源的 VPC（以及支持的 Amazon VPC 资源）的配置的权限。
+ 用于调用 Lambda 函数的权限。
## 在函数账户中创建 Amazon VPC
在 Lambda 函数账户中创建 Amazon VPC、子网、路由表和安全组。
**使用控制台创建 VPC、子网和其他 VPC 资源**
1. 通过以下网址打开 Amazon VPC 控制台：[https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在控制面板上，选择**创建 VPC**。
1. 对于 **IPv4 CIDR 块**，请提供私有 CIDR 块。CIDR 块不得与资源 VPC 中的块重叠。不要选择资源 VPC 用于为资源分配 IP 的块，也不要选择资源 VPC 中已在路由表中定义的块。有关定义相应的 CIDR 块的更多信息，请参阅 [VPC CIDR 块](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html)。
1. 选择**自定义可用区**。
1. 选择与您的资源相同的可用区。
1. 对于**公有子网数量**，选择 **0**。
1. 对于 **VPC endpoints**（VPC 端点），选择 **None**（无）。
1. 选择**创建 VPC**。
## 将 VPC 权限授予函数的执行角色
将 [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) 附加到函数的执行角色以允许其连接到 VPC。
**将 VPC 权限授予函数的执行角色**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数的名称。
1. 选择**配置**。
1. 选择**权限**。
1. 在**角色名称**下，选择执行角色。
1. 在**权限策略**部分中，选择**添加权限**。
1. 在下拉列表中选择**附加策略**。
1. 在搜索框中，输入 `AWSLambdaVPCAccessExecutionRole`。
1. 选中策略名称左侧的复选框。
1. 选择**添加权限**。
**将函数附加到 Amazon VPC**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数的名称。
1. 选择**配置**选项卡，然后选择 **VPC**。
1. 选择**编辑**。
1. 在 **VPC** 下方，选择您的 VPC。
1. 在**子网**下方，选择您的子网。
1. 在**安全组**下方，选择 VPC 的默认安全组。
1. 选择**保存**。
## 创建 VPC 对等连接请求
创建从函数 VPC（请求者 VPC）到资源 VPC（接受方 VPC）的 VPC 对等连接请求。
**请求从函数 VPC 进行 VPC 对等连接**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择 **Peering Connections**（对等连接）。
1. 选择 **Create Peering Connection**（创建对等连接）。
1. 对于 **VPC ID（请求者）**，请选择函数的 VPC。
1. 对于 **账户 ID**，输入资源账户的 ID。
1. 对于 **VPC ID（接受者）**，输入资源的 VPC。
## 准备好资源账户
要创建对等连接并准备资源的 VPC 以使用该连接，请使用具有先决条件中列出的权限的角色登录资源账户。根据账户安全保障方式，登录步骤可能会有所不同。有关如何登录 AWS 账户的更多信息，请参阅《[AWS Sign-in User Guide](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html)》。在资源账户中，执行以下过程。
**接受 VPC 对等连接请求**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择 **Peering Connections**（对等连接）。
1. 选择待处理的 VPC 对等连接（状态为“待接受”）。
1. 选择**操作**。
1. 从下拉列表中选择**接受请求**。
1. 当系统提示进行确认时，选择**接受请求**。
1. 选择**立即修改我的路由表**，以向 VPC 的主路由表添加路由，从而确保您可以通过对等连接收发流量。
检查路由表，了解资源的 VPC。根据资源 VPC 的设置方式，Amazon VPC 生成的路由可能无法建立连接。检查 VPC 的新路由和现有配置之间是否存在冲突。有关问题排查的更多信息，请参阅《Amazon Virtual Private Cloud VPC 对等连接指南》**中的[对 VPC 对等连接进行问题排查](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html)。
**更新资源的安全组**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择**安全组**。
1. 为资源选择安全组。
1. 选择**操作**。
1. 从下拉列表中选择**编辑入站规则**。
1. 选择**添加规则**。
1. 对于**来源**，请输入函数的账户 ID 和安全组 ID，用正斜线分隔（例如 111122223333/sg-1a2b3c4d）。
1. 选择**编辑出站规则**。
1. 检查出站流量是否受到限制。默认 VPC 设置允许所有出站流量。如果出站流量受到限制，请继续执行下一步。
1. 选择**添加规则**。
1. 对于**目的地**，请输入函数的账户 ID 和安全组 ID，用正斜线分隔（例如 111122223333/sg-1a2b3c4d）。
1. 选择**保存规则**。
**实现对对等连接的 DNS 解析**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择 **Peering Connections**（对等连接）。
1. 选择对等连接。
1. 选择**操作**。
1. 选择**编辑 DNS 设置**。
1. 在**接受方 DNS 解析**下方，选择**允许请求者 VPC 将接受方 VPC 主机的 DNS 解析为私有 IP**。
1. 选择**保存更改**。
## 更新函数账户中的 VPC 配置
登录函数账户，然后更新 VPC 配置。
**为 VPC 对等连接添加路由**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择 **Route tables**（路由表）。
1. 选中与函数关联之子网的路由表名称旁边的复选框。
1. 选择**操作**。
1. 选择 **Edit routes (编辑路由)**。
1. 选择 **Add route**（添加路由）。
1. 对于**目的地**，输入资源 VPC 的 CIDR 块。
1. 对于**目标**，选择 VPC 对等连接。
1. 选择**保存更改**。
有关在更新路由表时可能遇到的注意事项的更多信息，请参阅[为 VPC 对等连接更新路由表](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html)。
**更新 Lambda 函数的安全组**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择**安全组**。
1. 选择**操作**。
1. 选择**编辑入站规则**。
1. 选择**添加规则**。
1. 对于**来源**，请输入资源的账户 ID 和安全组 ID，用正斜线分隔（例如 111122223333/sg-1a2b3c4d）。
1. 选择**保存规则**。
**实现对对等连接的 DNS 解析**
1. 打开 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 在导航窗格中，选择 **Peering Connections**（对等连接）。
1. 选择对等连接。
1. 选择**操作**。
1. 选择**编辑 DNS 设置**。
1. 在**请求者 DNS 解析**下方，选择**允许接受方 VPC 将请求者 VPC 主机的 DNS 解析为私有 IP**。
1. 选择**保存更改**。
## 测试函数
**创建测试事件并检查函数的输出**
1. 在**代码源**窗格中，选择**测试**。
1. 选择**创建新事件**。
1. 在**事件 JSON** 面板中，将默认值替换为适合 Lambda 函数的输入。
1. 选择 ** 调用**。
1. 在**执行结果**选项卡中，确认**响应**包含预期输出。
此外，可以检查函数的日志，以验证日志是否符合预期。
**在 CloudWatch Logs 中查看函数的调用记录**
1. 选择**监控**选项卡。
1. 选择**查看 CloudWatch 日志**。
1. 在**日志流**选项卡上，选择函数调用的日志流。
1. 确认日志符合预期。
# 为连接到 VPC 的 Lambda 函数启用互联网访问权限
默认情况下，Lambda 函数在可访问互联网的 Lambda 托管 VPC 中运行。要访问账户中 VPC 内的资源，可以向函数添加 VPC 配置。此举会将该函数限制为仅针对该 VPC 内的资源，除非该 VPC 可以访问互联网。本页内容会介绍如何为连接到 VPC 的 Lambda 函数提供互联网访问权限。
## 尚无 VPC
### 创建 VPC
**创建 VPC 工作流程**可创建 Lambda 函数从私有子网访问公有互联网所需的所有 VPC 资源，包括子网、NAT 网关、互联网网关和路由表条目。
**创建 VPC**
1. 通过 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 打开 Amazon VPC 控制台。
1. 在控制面板上，选择**创建 VPC**。
1. 对于**要创建的资源**，选择 **VPC 等**。
1. **配置 VPC**
1. 对于 **Name tag auto-generation**（名称标签自动生成），为 VPC 输入名称。
1. 对于 **IPv4 CIDR 块**，您可以保留默认建议，也可以输入应用程序或网络所需的 CIDR 块。
1. 如果应用程序使用 IPv6 地址进行通信，则选择 **IPv6 CIDR 块**、**Amazon 提供的 IPv6 CIDR 块**。
1. **配置子网**
1. 对于**可用区数量**，选择 **2**。为了获得高可用性，建议至少选择两个 AZ。
1. 对于**Number of public subnets**（公有子网数量），选择 **2**。
1. 对于 **Number of private subnets**（私有子网数量），选择 **2**。
1. 您可以保留公有子网的默认 CIDR 块，也可以展开**自定义子网 CIDR 块**并输入 CIDR 块。有关更多信息，请参阅[子网 CIDR 块](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html)。
1. 对于 **NAT 网关**，选择**每个可用区 1 个**以提高故障恢复能力。
1. 对于**仅限出口的互联网网关**，如果选择了包含 IPv6 CIDR 块，则选择**是**。
1. 对于 **VPC 端点**，请保留默认值（**S3 网关**）。选择此项不会产生任何费用。有关更多信息，请参阅[适用于 Amazon S3 的 VPC 端点类型](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3)。
1. 对于 **DNS 选项**，保留默认设置。
1. 选择**创建 VPC**。
### 配置 Lambda 函数
**在创建函数时配置 VPC**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择 **Create function**（创建函数）。
1. 在**基本信息**下的**函数名称**中输入函数的名称。
1. 展开 **Advanced settings**（高级设置）。
1. 选择**启用 VPC**，再选择一个 VPC。
1. （可选）要允许[出站 IPv6 流量](configuration-vpc.md#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 对于**子网**，选择全部私有子网。私有子网可以通过 NAT 网关访问互联网。将函数连接到公有子网并不会授予其互联网访问权限。
**注意**
如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
1. 对于**安全组**，选择一个允许出站流量的安全组。
1. 选择**创建函数**。
Lambda 使用 [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS 托管策略自动创建执行角色。只有在为 VPC 配置创建弹性网络接口时需要此策略中的权限，调用函数时并不需要。要应用最低权限，可以在创建函数和 VPC 配置之后，从执行角色中删除 **AWSLambdaVPCAccessExecutionRole** 策略。有关更多信息，请参阅 [所需的 IAM 权限](configuration-vpc.md#configuration-vpc-permissions)。
**为现有函数配置 VPC**
要将 VPC 配置添加到现有函数，该函数的执行角色必须具有[创建和管理弹性网络接口的权限](configuration-vpc.md#configuration-vpc-permissions)。[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS 托管策略包含这些必要权限。要应用最低权限，可以在创建 VPC 配置之后，从执行角色中删除 **AWSLambdaVPCAccessExecutionRole** 策略。
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数。
1. 选择**配置**选项卡，然后选择 **VPC**。
1. 在 **VPC** 下，选择 **Edit**（编辑）。
1. 选择 VPC。
1. （可选）要允许[出站 IPv6 流量](configuration-vpc.md#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 对于**子网**，选择全部私有子网。私有子网可以通过 NAT 网关访问互联网。将函数连接到公有子网并不会授予其互联网访问权限。
**注意**
如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
1. 对于**安全组**，选择一个允许出站流量的安全组。
1. 选择**保存**。
### 测试此函数
使用以下示例代码，确认连接到 VPC 的函数是否可以访问公有互联网。如果成功，代码将返回 `200` 状态代码。如果失败，函数将超时。
------
#### [ Node.js ]
1. 在 Lambda 控制台的**代码源**窗格中，将以下代码粘贴到 **index.mjs** 文件中。该函数向公有端点发出 HTTP GET 请求，再返回 HTTP 响应代码来测试该函数是否可以访问公有互联网。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/code-source-nodejs.png)
**Example 示例：包含 async/await 的 HTTP 请求**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. 选择**测试**选项卡。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-tab.png)
1. 选择**测试**。
1. 该函数返回 `200` 状态代码。此结果表示该函数具有出站互联网访问权限。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-successful-200.png)
如果该函数无法访问公有互联网，则会收到如下错误消息：
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. 在 Lambda 控制台的**代码源**窗格中，将以下代码粘贴到 **ambda\$1function.py** 文件中。该函数向公有端点发出 HTTP GET 请求，再返回 HTTP 响应代码来测试该函数是否可以访问公有互联网。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. 选择**测试**选项卡。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-tab.png)
1. 选择**测试**。
1. 该函数返回 `200` 状态代码。此结果表示该函数具有出站互联网访问权限。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-successful-200.png)
如果该函数无法访问公有互联网，则会收到如下错误消息：
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
## 已有 VPC
如果已有 VPC，但需要为 Lambda 函数配置公有互联网访问权限，请按照以下步骤操作。此过程假设 VPC 至少有两个子网。如果没有两个子网，请参阅《Amazon VPC 用户指南》**中的[创建子网](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html)。
### 验证路由表配置
1. 通过 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 打开 Amazon VPC 控制台。
1. 选择 **VPC ID**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/vpc-id.png)
1. 向下滚动到**资源映射**部分。请注意路由表映射。打开映射到子网的每个路由表。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-associations.png)
1. 向下滚动到**路由**选项卡。查看路由以确定您的 VPC 是否同时具有以下两个路由表。这些要求中的每一项都必须由单独的路由表来满足。
+ 将面向互联网的流量（IPv4 的路由为 `0.0.0.0/0`，IPv6 的路由为 `::/0`）路由到互联网网关 (`igw-xxxxxxxxxx`)。这表示与路由表关联的子网是公有子网。
**注意**
如果子网没有 IPv6 CIDR 块，则只能看到 IPv4 的路由 (`0.0.0.0/0`)。
**Example 公有子网路由表**
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/routes-public.png)
+ 将 IPv4 (`0.0.0.0/0`) 面向互联网的流量路由到与公有子网关联的 NAT 网关 (`nat-xxxxxxxxxx`)。这表示子网属于可以通过 NAT 网关访问互联网的私有子网。
**注意**
如果子网具有 IPv6 CIDR 块，则路由表还必须将面向互联网的 IPv6 流量 (`::/0`) 路由到“仅出口互联网网关”(`eigw-xxxxxxxxxx`)。如果子网没有 IPv6 CIDR 块，则只能看到 IPv4 的路由 (`0.0.0.0/0`)。
**Example 私有子网路由表**
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/routes-private.png)
1. 重复上一步操作，直到查看了与 VPC 中子网关联的每个路由表，并确认存在带有互联网网关的路由表和带有 NAT 网关的路由表。
如果没有两个路由表（一个带有指向互联网网关的路由，另一个带有指向 NAT 网关的路由），则按照以下步骤创建缺失的资源和路由表条目。
### 创建路由表
请按照以下步骤创建路由表，再将之与子网相关联。
**使用 Amazon VPC 控制台创建自定义路由表**
1. 通过 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 打开 Amazon VPC 控制台。
1. 在导航窗格中，选择 **Route tables**（路由表）。
1. 选择**创建路由表**。
1. （可选）对于 **Name**（名称），为您的路由表输入名称。
1. 对于 **VPC**，选择您的 VPC。
1. （可选）若要添加标签，请选择 **Add new tag**（添加新标签），然后输入标签键和标签值。
1. 选择**创建路由表**。
1. 在 **Subnet associations (子网关联)** 选项卡上，选择 **Edit subnet associations (编辑子网关联)**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-subnet.png)
1. 选中要与路由表关联的子网的复选框。
1. 选择 **Save associations (保存关联)**。
### 创建互联网网关
按照以下步骤创建互联网网关，再将其附加到 VPC，然后将之添加到公有子网的路由表中。
**创建互联网网关**
1. 通过 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 打开 Amazon VPC 控制台。
1. 在导航窗格中，选择 **Internet gateways**（互联网网关）。
1. 选择**创建互联网网关**。
1. （可选）输入互联网网关的名称。
1. （可选）若要添加标签，请选择 **Add new tag**（添加新标签），然后输入该标签的键和值。
1. 选择**创建互联网网关**。
1. 从屏幕顶部的横幅中选择**附加到 VPC**，再选择可用的 VPC，然后选择**附加互联网网关**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/igw-attach-vpc.png)
1. 选择 **VPC ID**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/igw-subnet-1.png)
1. 再次选择 **VPC ID** 打开 VPC 详细信息页面。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/igw-your-vpcs.png)
1. 向下滚动到**资源映射**部分，然后选择一个子网。子网详细信息显示在新选项卡中。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/vpc-subnets.png)
1. 选择**路由表**下的链接。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/subnet-route-table.png)
1. 选择**路由表 ID** 打开路由表的详细信息页面。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-id.png)
1. 在**路由**下，选择**编辑路由**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/edit-routes.png)
1. 选择**添加路由**，然后在**目的地**框中输入 `0.0.0.0/0`。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-route-1.png)
1. 在**目标**中选择**互联网网关**，然后选择之前创建的互联网网关。如果子网具有 IPv6 CIDR 块，还须添加指向同一互联网网关的 `::/0` 路由。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-route-2.png)
1. 选择**保存更改**。
### 创建 NAT 网关
按照以下步骤创建 NAT 网关，再将其与公有子网关联，然后将之添加到私有子网的路由表中。
**创建 NAT 网关并将之与公有子网关联**
1. 在导航窗格中，选择 **NAT 网关**。
1. 选择**创建 NAT 网关**。
1. （可选）输入 NAT 网关的名称。
1. 对于**子网**，选择 VPC 中的公有子网。（公有子网是其路由表中具有指向互联网网关的直接路由的子网。）
**注意**
NAT 网关与公有子网关联，但路由表条目位于私有子网中。
1. 对于**弹性 IP 分配 ID**，请选择弹性 IP 地址或选择**分配弹性 IP**。
1. 选择**创建 NAT 网关**。
**在私有子网的路由表中向 NAT 网关添加路由**
1. 在导航窗格中，选择 **Subnets**(子网)。
1. 选择 VPC 中的私有子网。（私有子网是其路由表中不具有指向互联网网关的路由的子网。）
1. 选择**路由表**下的链接。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/subnet-route-table.png)
1. 选择**路由表 ID** 打开路由表的详细信息页面。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-id.png)
1. 向下滚动并选择**路由**选项卡，然后选择**编辑路由**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-edit-routes.png)
1. 选择**添加路由**，然后在**目的地**框中输入 `0.0.0.0/0`。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-route-1.png)
1. 在**目标**中选择 **NAT 网关**，然后选择之前创建的 NAT 网关。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-route-nat.png)
1. 选择**保存更改**。
### 创建“仅出口互联网网关”（仅限 IPv6）
按照以下步骤创建“仅出口互联网网关”，在将之添加到私有子网的路由表中。
**创建“仅出口互联网网关”**
1. 在导航窗格中，选择**仅出口互联网网关**。
1. 选择**创建仅出口互联网网关**。
1. （可选）输入名称。
1. 选择要在其中创建“仅出口互联网网关”的 VPC。
1. 选择**创建仅出口互联网网关**。
1. 选择**附加的 VPC ID**下的链接。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/eigw-details.png)
1. 选择 **VPC ID** 下的链接，打开 VPC 详细信息页面。
1. 向下滚动到**资源映射**部分，然后选择一个私有子网。（私有子网是其路由表中不具有指向互联网网关的路由的子网。） 子网详细信息显示在新选项卡中。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/vpc-subnet-private.png)
1. 选择**路由表**下的链接。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/private-subnet-route-table.png)
1. 选择**路由表 ID** 打开路由表的详细信息页面。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/route-table-id.png)
1. 在**路由**下，选择**编辑路由**。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/edit-routes.png)
1. 选择**添加路由**，然后在**目的地**框中输入 `::/0`。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/create-route-1.png)
1. 在**目标**中选择**仅限出口互联网网关**，然后选择之前创建的网关。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/eigw-route.png)
1. 选择**保存更改**。
### 配置 Lambda 函数
**在创建函数时配置 VPC**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择 **Create function**（创建函数）。
1. 在**基本信息**下的**函数名称**中输入函数的名称。
1. 展开 **Advanced settings**（高级设置）。
1. 选择**启用 VPC**，再选择一个 VPC。
1. （可选）要允许[出站 IPv6 流量](configuration-vpc.md#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 对于**子网**，选择全部私有子网。私有子网可以通过 NAT 网关访问互联网。将函数连接到公有子网并不会授予其互联网访问权限。
**注意**
如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
1. 对于**安全组**，选择一个允许出站流量的安全组。
1. 选择**创建函数**。
Lambda 使用 [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS 托管策略自动创建执行角色。只有在为 VPC 配置创建弹性网络接口时需要此策略中的权限，调用函数时并不需要。要应用最低权限，可以在创建函数和 VPC 配置之后，从执行角色中删除 **AWSLambdaVPCAccessExecutionRole** 策略。有关更多信息，请参阅 [所需的 IAM 权限](configuration-vpc.md#configuration-vpc-permissions)。
**为现有函数配置 VPC**
要将 VPC 配置添加到现有函数，该函数的执行角色必须具有[创建和管理弹性网络接口的权限](configuration-vpc.md#configuration-vpc-permissions)。[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS 托管策略包含这些必要权限。要应用最低权限，可以在创建 VPC 配置之后，从执行角色中删除 **AWSLambdaVPCAccessExecutionRole** 策略。
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数。
1. 选择**配置**选项卡，然后选择 **VPC**。
1. 在 **VPC** 下，选择 **Edit**（编辑）。
1. 选择 VPC。
1. （可选）要允许[出站 IPv6 流量](configuration-vpc.md#configuration-vpc-ipv6)，请选择**允许双堆栈子网的 IPv6 流量**。
1. 对于**子网**，选择全部私有子网。私有子网可以通过 NAT 网关访问互联网。将函数连接到公有子网并不会授予其互联网访问权限。
**注意**
如果您已选择**允许双堆栈子网的 IPv6 流量**，则所有选定的子网都必须具有 IPv4 CIDR 数据块和 IPv6 CIDR 数据块。
1. 对于**安全组**，选择一个允许出站流量的安全组。
1. 选择**保存**。
### 测试此函数
使用以下示例代码，确认连接到 VPC 的函数是否可以访问公有互联网。如果成功，代码将返回 `200` 状态代码。如果失败，函数将超时。
------
#### [ Node.js ]
1. 在 Lambda 控制台的**代码源**窗格中，将以下代码粘贴到 **index.mjs** 文件中。该函数向公有端点发出 HTTP GET 请求，再返回 HTTP 响应代码来测试该函数是否可以访问公有互联网。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/code-source-nodejs.png)
**Example 示例：包含 async/await 的 HTTP 请求**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. 选择**测试**选项卡。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-tab.png)
1. 选择**测试**。
1. 该函数返回 `200` 状态代码。此结果表示该函数具有出站互联网访问权限。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-successful-200.png)
如果该函数无法访问公有互联网，则会收到如下错误消息：
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. 在 Lambda 控制台的**代码源**窗格中，将以下代码粘贴到 **ambda\$1function.py** 文件中。该函数向公有端点发出 HTTP GET 请求，再返回 HTTP 响应代码来测试该函数是否可以访问公有互联网。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. 在**部署**部分，选择**部署**以更新函数的代码：
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. 选择**测试**选项卡。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-tab.png)
1. 选择**测试**。
1. 该函数返回 `200` 状态代码。此结果表示该函数具有出站互联网访问权限。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-successful-200.png)
如果该函数无法访问公有互联网，则会收到如下错误消息：
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
# 连接 Lambda 的入站接口 VPC 端点
如果您使用 Amazon Virtual Private Cloud (Amazon VPC) 托管AWS资源，则可以在您的 VPC 和 Lambda 之间建立连接。您可以使用此连接来调用您的 Lambda 函数，而无需跨越公有互联网。
您可以通过创建[接口 VPC 终端节点](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html)在 VPC 和 Lambda 之间建立私有连接。接口端点由 [AWS PrivateLink](https://aws.amazon.com/privatelink) 提供支持，您可使用该技术通过私有连接访问 Lambda API，而无需采用互联网网关、NAT 设备、VPN 连接或 AWS Direct Connect 连接。VPC 中的实例即使没有公有 IP 地址也可与 Lambda API 进行通信。VPC 和 Lambda 之间的流量不会脱离 AWS 网络。
每个接口端点均由子网中的一个或多个[弹性网络接口](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html)表示。网络接口提供一个私有 IP 地址，此地址可用作指向 Lambda 的流量的入口点。
**Topics**
+ [
## Lambda 接口端点的注意事项
](#vpc-endpoint-considerations)
+ [
## 为 Lambda 创建接口端点
](#vpc-endpoint-create)
+ [
## 为 Lambda 创建接口端点策略
](#vpc-endpoint-policy)
## Lambda 接口端点的注意事项
请务必先查看 *Amazon VPC 用户指南*中的[接口端点属性和限制](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations)，然后再为 Lambda 设置接口端点。
您可以从 VPC 调用任何 Lambda API 操作。例如，您可以通过在 VPC 内调用 `Invoke` API 来调用 Lambda 函数。有关 Lambda API 的完整列表，请参阅 Lambda API 参考中的[操作](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html)。
`use1-az3` 是支持 Lambda VPC 函数的有限容量区域。您不应将此可用区中的子网与 Lambda 函数一起使用，因为这可能会在发生中断时导致可用区冗余减少。
### 对于持久性连接保持连接状态
Lambda 随时间推移逐渐清除空闲连接，因此您必须使用 keep-alive 指令来维护持久连接。在调用函数时尝试重用空闲连接会导致连接错误。要维护您的持久连接，请使用与运行时关联的 keep-alive 指令。有关示例，请参阅 *适用于 JavaScript 的 AWS SDK 开发人员指南* 中的[在 Node.js 中重复使用具有保持连接功能的连接](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html)。
### 计费注意事项
通过接口端点访问 Lambda 函数不会产生额外费用。有关 Lambda 定价的更多信息，请参阅 [AWS Lambda 定价](https://aws.amazon.com/lambda/pricing/)。
AWS PrivateLink 的标准定价适用于 Lambda 的接口端点。您的AWS账户将按在每个可用区中预置的每小时以及通过接口端点处理的数据进行计费。有关接口端点定价的更多信息，请参阅 [AWS PrivateLink 定价](https://aws.amazon.com/privatelink/pricing/)。
### VPC 对等连接注意事项
您可以使用 [VPC 对等连接](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html)通过接口端点将其他 VPC 连接到 VPC。VPC 对等连接是两个 VPC 之间的网络连接。您可以在自己的两个 VPC 之间建立 VPC 对等连接，或者在自己的 VPC 与其他 AWS 账户中的 VPC 之间建立此连接。VPC 也可以位于两个不同的AWS区域中。
对等 VPC 之间的流量保留在AWS网络上，不会穿越公有互联网。建立对等 VPC 连接后，两个 VPC 中的资源（如 Amazon Elastic Compute Cloud (Amazon EC2) 实例、Amazon Relational Database Service (Amazon RDS) 实例或启用 VPC 的 Lambda 函数等）可以通过在其中一个 VPC 中创建的接口端点访问 Lambda API。
## 为 Lambda 创建接口端点
您可以使用 Amazon VPC 控制台或 AWS Command Line Interface (AWS CLI) 为 Lambda 创建 VPC 端点。有关更多信息，请参阅 *Amazon VPC 用户指南*中的[创建接口端点](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint)。
**为 Lambda（控制台）创建接口端点**
1. 打开 Amazon VPC 控制台的 [Endpoints（端点）页面](https://console.aws.amazon.com/vpc/home?#Endpoints)。
1. 选择 **Create Endpoint**（创建端点）。
1. 对于**服务类别**，请确认已选择 **AWS 服务**。
1. 对于**服务名称**，选择 **com.amazonaws.*region*.lambda**。验证**类型**为**接口**。
1. 创建 VPC 和子网。
1. 要为接口端点启用私有 DNS，请选中 **Enable DNS Name**（启用 DNS 名称）复选框。我们建议您为 AWS 服务 的 VPC 端点启用私有 DNS 名称。这可以确保使用公有服务端点的请求（例如通过 AWS SDK 发出的请求）解析到您的 VPC 端点。
1. 对于**安全组**，选择一个或多个安全组。
1. 选择 **Create Endpoint**（创建端点）。
要使用私有 DNS 选项，您必须设置 VPC 的 `enableDnsHostnames` 和 `enableDnsSupportattributes`。有关更多信息，请参阅 *Amazon VPC 用户指南*中的[查看和更新 VPC 的 DNS 支持](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating)。如果为接口端点启用私有 DNS，则可使用区域默认 DNS 名称向 Lambda 发出 API 请求，例如 `lambda.us-east-1.amazonaws.com`。有关更多服务端点，请参阅《AWS 一般参考》中的[服务端点和配额](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html)。
有关更多信息，请参阅 *Amazon VPC 用户指南*中的[通过接口端点访问服务](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint)。
有关使用 CloudFormation 创建和配置端点的信息，请参阅 *AWS CloudFormation 用户指南*中的 [AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) 资源。
**为 Lambda (AWS CLI) 创建接口端点**
使用 [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html) 命令并指定 VPC ID、VPC 端点类型（接口）、服务名称、将使用端点的子网以及要与端点的网络接口关联的安全组。例如：
```
aws ec2 create-vpc-endpoint
--vpc-id vpc-ec43eb89
--vpc-endpoint-type Interface
--service-name com.amazonaws.us-east-1.lambda
--subnet-id subnet-abababab
--security-group-id sg-1a2b3c4d
```
## 为 Lambda 创建接口端点策略
要控制哪些用户可以使用您的接口端点，以及用户可以访问哪些 Lambda 功能，您可以将端点策略附加到端点。该策略指定以下信息：
+ 可执行操作的主体。
+ 主体可以执行的操作。
+ 委托人可以对其执行操作的资源。
有关更多信息，请参阅 *Amazon VPC 用户指南* 中的[使用 VPC 终端节点控制对服务的访问](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)。
**示例：用于 Lambda 操作的接口端点策略**
以下是用于 Lambda 的端点策略示例。连接到端点时，此策略允许 `MyUser` 用户调用函数 `my-function`。
**注意**
资源中需要同时包含限定函数和非限定函数 ARN。
```
{
"Statement":[
{
"Principal":
{
"AWS": "arn:aws:iam::111122223333:user/MyUser"
},
"Effect":"Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-function",
"arn:aws:lambda:us-east-2:123456789012:function:my-function:*"
]
}
]
}
```
# 配置 Lambda 函数的文件系统访问
您可以配置函数以将 Amazon Elastic File System (Amazon EFS) 文件系统挂载到本地目录。借助 Amazon EFS，您的函数代码可以安全且高并发地访问和修改共享资源。
## 支持的区域
Amazon EFS for Lambda 在除亚太地区（新西兰）、亚太地区（台北）、亚太地区（马来西亚）、墨西哥（中部）、亚太地区（泰国）和加拿大西部（卡尔加里）以外的所有[商业区域](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region)可用。
**Topics**
+ [
## 支持的区域
](#configuration-filesystem-supported-regions)
+ [
## 执行角色和用户权限
](#configuration-filesystem-permissions)
+ [
## 配置文件系统和访问点
](#configuration-filesystem-setup)
+ [
## 连接到文件系统（控制台）
](#configuration-filesystem-config)
## 执行角色和用户权限
如果文件系统没有用户配置的 AWS Identity and Access Management（IAM）policy，EFS 将使用默认策略，该策略授予对可以使用文件系统挂载目标连接到文件系统的任何客户端的完全访问权限。如果文件系统具有用户配置的 IAM policy，则您的函数的执行角色必须具有正确的 `elasticfilesystem` 权限。
**执行角色权限**
+ **elasticfilesystem:ClientMount**
+ **elasticfilesystem:ClientWrite（只读连接不需要）**
这些权限包含在 **AmazonElasticFileSystemClientReadWriteAccess** 托管式策略中。此外，您的执行角色必须具有[连接到文件系统的 VPC 所需的权限](configuration-vpc.md#configuration-vpc-permissions)。
配置文件系统时，Lambda 使用您的权限来验证挂载目标。要配置函数以连接到文件系统，您的用户需要以下权限：
**用户权限**
+ **elasticfilesystem:DescribeMountTargets**
## 配置文件系统和访问点
在 Amazon EFS 中创建一个文件系统，该文件系统在函数连接到的每个可用区都有一个挂载目标。为了获得性能和恢复能力，请至少使用两个可用区。例如，在简单配置中，您可能有一个 VPC 包含两个私有子网，这两个子网位于不同的可用区。函数连接到两个子网，每个子网中都存在一个挂载目标。确保函数和挂载目标使用的安全组允许 NFS 流量（端口 2049）。
**注意**
创建文件系统时，您可以选择以后无法更改的性能模式。**General purpose (通用)** 模式具有较低的延迟，**Max I/O (最大 I/O)** 模式支持较高的最大吞吐量和 IOPS。如需帮助选择，请参阅 *Amazon Elastic File System 用户指南*中的 [Amazon EFS 性能](https://docs.aws.amazon.com/efs/latest/ug/performance.html)。
访问点将函数的每个实例连接到该实例连接到的可用区的正确装挂目标。为了获得最佳性能，请使用非根路径创建访问点，并限制您在每个目录中创建的文件数。以下示例在文件系统上创建一个名为 `my-function` 的目录，然后将拥有者 ID 设置为 1001 并具有标准目录权限 (755)。
**Example 访问点配置**
+ **名称** – `files`
+ **User ID**（用户名 ID）– `1001`
+ **Group ID**（组 ID）– `1001`
+ **路径** – `/my-function`
+ **权限** – `755`
+ **Owner user ID**（拥有者用户 ID）– `1001`
+ **Group user ID**（组用户 ID）– `1001`
当函数使用访问点时，它将被赋予用户 ID 1001 并具有对该目录的完全访问权限。
有关更多信息，请参阅 *Amazon Elastic File System 用户指南*中的以下主题：
+ [为 Amazon EFS 创建资源](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
+ [使用用户、组和权限](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html)
## 连接到文件系统（控制台）
函数通过 VPC 中的本地网络连接到文件系统。函数连接到的子网可以是包含文件系统挂载点的相同子网，也可以是位于同一可用区中的子网，这些子网可以将 NFS 流量（端口 2049）路由到文件系统。
**注意**
如果函数尚未连接到 VPC，请参阅[授予 Lambda 函数访问 Amazon VPC 中资源的权限](configuration-vpc.md)。
**配置文件系统访问**
1. 打开 Lamba 控制台的 [Functions](https://console.aws.amazon.com/lambda/home#/functions)（函数）页面。
1. 选择函数。
1. 选择 **Configuration（配置）**，然后选择 **File systems（文件系统）**。
1. 在 **File system (文件系统)** 下，选择 **Add file system (添加文件系统)**。
1. 配置以下属性：
+ **EFS file system**（EFS 文件系统）– 同一 VPC 中的文件系统的访问点。
+ **Local mount path**（本地挂载路径） – 文件系统在 Lambda 函数上的挂载位置，以 `/mnt/` 开头。
**定价**
Amazon EFS 对存储和吞吐量收费，费率因存储类别而异。有关详细信息，请参阅 [Amazon EFS 定价](https://aws.amazon.com/efs/pricing)。
Lambda 对 VPC 之间的数据传输收费。这仅在函数的 VPC 与另一个具有文件系统的 VPC 对等时才适用。费率与同一区域中 VPC 之间的 Amazon EC2 数据传输费率相同。有关详细信息，请参阅 [Lambda 定价](https://aws.amazon.com/lambda/pricing)。
# 为 Lambda 函数创建别名
您可以为 Lambda 函数创建别名。Lambda 别名是您可以更新的指向函数版本的指针。函数的用户可以使用别名 Amazon 资源名称（ARN）访问函数版本。部署新版本时，您可以更新别名以使用新版本，或者在两个版本之间拆分流量。
------
#### [ Console ]
**使用控制台创建别名**
1. 打开 Lamba 控制台的 [Functions](https://console.aws.amazon.com/lambda/home#/functions)（函数）页面。
1. 选择函数。
1. 选择 **Aliases**（别名），然后选择 **Create alias**（创建别名）。
1. 在**创建别名**页面上，执行以下操作：
1. 输入别名的**名称**。
1. （可选）输入别名的**描述**。
1. 对于**版本**，选择希望别名指向的函数版本。
1. （可选）要在别名上配置路由，请展开**加权别名**。有关更多信息，请参阅[使用加权别名实施 Lambda 金丝雀部署](configuring-alias-routing.md)。
1. 选择**保存**。
------
#### [ AWS CLI ]
要使用 AWS Command Line Interface（AWS CLI）创建别名，请使用 [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) 命令。
```
aws lambda create-alias \
--function-name my-function \
--name alias-name \
--function-version version-number \
--description " "
```
要更改别名以便指向函数的新版本，请使用 [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) 命令。
```
aws lambda update-alias \
--function-name my-function \
--name alias-name \
--function-version version-number
```
要删除别名，请使用 [delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html) 命令。
```
aws lambda delete-alias \
--function-name my-function \
--name alias-name
```
以上步骤中的 AWS CLI 命令对应于以下 Lambda API 操作：
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
------
# 在事件源和权限策略中使用 Lambda 别名
每个别名都有唯一的 ARN。别名只能指向函数版本，而不能指向其他别名。可以更新别名以便指向函数的新版本。
事件源（Amazon Simple Storage Service (Amazon S3) 等）会调用您的 Lambda 函数。这些事件源维护一个映射，该映射标识在发生事件时要调用的函数。如果在映射配置中指定 Lambda 函数别名，则当函数版本发生更改时，您不需要更新映射。有关更多信息，请参阅[Lambda 如何处理来自基于流和队列的事件源的记录](invocation-eventsourcemapping.md)。
在资源策略中，您可以为事件源授予权限，以便使用您的 Lambda 函数。如果在策略中指定别名 ARN，则当函数版本发生更改时，您不需要更新策略。
## 资源策略
您可以使用[基于资源的策略](access-control-resource-based.md)授予服务、资源或账户对您的函数的访问权限。该权限的范围取决于您要将其应用于别名、版本还是整个函数。例如，如果使用别名（如 `helloworld:PROD`），该权限将允许您使用别名 ARN (`helloworld`) 调用 `helloworld:PROD` 函数。
如果您尝试在不指定别名或具体版本的情况下调用该函数，则会出现权限错误。即使您尝试直接调用与别名关联的函数版本，也会发生此权限错误。
例如，以下 AWS CLI 命令会向 Amazon S3 授予在 Amazon S3 代表 `amzn-s3-demo-bucket` 执行操作时调用 `helloworld` 函数的 PROD 别名的权限。
```
aws lambda add-permission \
--function-name helloworld \
--qualifier PROD \
--statement-id 1 \
--principal s3.amazonaws.com \
--action lambda:InvokeFunction \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
有关在策略中使用资源名称的更多信息，请参阅[微调策略的“资源和条件”部分](lambda-api-permissions-ref.md)。
# 使用加权别名实施 Lambda 金丝雀部署
您可以使用加权别名在同一函数的两个不同[版本](configuration-versions.md)之间拆分流量。通过此方法，您可以用一小部分流量测试新版本的函数，并在必要时快速回滚。这称为[金丝雀部署](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html)。金丝雀部署与蓝/绿部署的不同之处在于，它只向部分请求公开新版本，而不是一次切换所有流量。
您可以将别名最多指向两个 Lambda 函数版本。版本必须满足以下条件：
+ 两个版本必须具有相同的[执行角色](lambda-intro-execution-role.md)。
+ 两个版本必须具有相同的[死信队列](invocation-async-retain-records.md#invocation-dlq)配置，或者都没有死信队列配置。
+ 这两个版本必须都已发布。别名不能指向 `$LATEST`。
**注意**
Lambda 使用简单的概率模型在两个函数版本之间分发流量。低流量级别情况下，您可能会看到每个版本上配置的流量百分比与实际流量百分比之间的差异很大。如果您的函数使用预配置并发，则可以避免[溢出调用](monitoring-metrics-types.md#invocation-metrics)，方法是在别名路由处于活动状态期间配置更多的预配置并发实例。
## 创建加权别名
------
#### [ Console ]
**使用控制台对别名配置路由**
**注意**
确保函数至少具有两个已发布版本。要创建其他版本，请按照 [创建函数版本](configuration-versions.md#configuration-versions-config)中的说明操作。
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择函数。
1. 选择 **Aliases**（别名），然后选择 **Create alias**（创建别名）。
1. 在**创建别名**页面上，执行以下操作：
1. 输入别名的**名称**。
1. （可选）输入别名的**描述**。
1. 对于**版本**，选择希望别名指向的第一个函数版本。
1. 展开**加权别名**。
1. 对于**其他版本**，请选择希望别名指向的第二个函数版本。
1. 对于**权重 (%)**，输入函数的权重值。*权重*是在调用别名时分配给该版本的流量百分比。第一个版本接收剩余权重。例如，如果为**其他版本**指定 10%，则会自动为第一个版本分配 90%。
1. 选择**保存**。
------
#### [ AWS CLI ]
使用 [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) 和 [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) AWS CLI 命令配置两个函数版本之间的流量权重。创建或更新别名时，您可以使用 `routing-config` 参数指定流量权重。
以下示例会创建一个名为 **routing-alias** 的 Lambda 函数别名，该别名指向函数的版本 1。函数的版本 2 接收 3% 的流量。其余 97% 的流量路由到版本 1。
```
aws lambda create-alias \
--name routing-alias \
--function-name my-function \
--function-version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}
```
使用 `update-alias` 命令可提高流入版本 2 的流量的百分比。在下面的示例中，将该流量提高到 5%。
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--routing-config AdditionalVersionWeights={"2"=0.05}
```
要将所有流量路由到版本 2，请使用 `update-alias` 命令更改 `function-version` 属性，以使别名指向版本 2。该命令还将重置路由配置。
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--function-version 2 \
--routing-config AdditionalVersionWeights={}
```
以上步骤中的 AWS CLI 命令对应于以下 Lambda API 操作：
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
------
## 确定调用的版本
配置两个函数版本之间的流量权重时，可以通过两种方法确定已调用的 Lambda 函数版本：
+ **CloudWatch Logs** – 对于每次函数调用，Lambda 会自动发出包含调用的版本 ID 的 `START` 日志条目。示例：
`START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2`
对于别名调用，Lambda 会使用 `ExecutedVersion` 维度按调用的版本筛选指标数据。有关更多信息，请参阅 [查看 Lambda 函数的指标](monitoring-metrics-view.md)。
+ **响应负载 (同步调用)** – 同步函数调用的响应包含 `x-amz-executed-version` 标头以指示已调用的函数版本。
## 使用加权别名创建滚动部署
使用 AWS CodeDeploy 和 AWS Serverless Application Model（AWS SAM）创建滚动部署，该部署可自动检测函数代码的更改、部署函数的新版本，并逐渐增加流向新版本的流量。您可以配置的参数包括流量和增长率。
在滚动部署中，AWS SAM 会执行以下任务：
+ 配置您的 Lambda 函数并创建别名。加权别名路由配置是实施滚动部署的基础功能。
+ 创建一个 CodeDeploy 应用程序和一个部署组。部署组可管理滚动部署和回滚（如果需要）。
+ 检测您何时创建 Lambda 函数的新版本。
+ 触发 CodeDeploy 启动部署新版本。
### 示例 AWS SAM 模板
下面的示例演示了用于简单滚动部署的 [AWS SAM 模板](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html)。
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs24.x
# Creates an alias named "live" for the function, and automatically publishes when you update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes
```
此模板定义一个名为 `myDateTimeFunction` 的 Lambda 函数，其中包含以下属性。
**AutoPublishAlias **
`AutoPublishAlias` 属性创建一个名为 `live` 的别名。此外，AWS SAM 框架会自动检测您何时为函数保存新代码。然后，框架发布新的函数版本并更新 `live` 别名以便指向新版本。
**DeploymentPreference**
`DeploymentPreference` 属性决定 CodeDeploy 应用程序将流量从 Lambda 函数的原始版本转移到新版本的速率。`Linear10PercentEvery2Minutes` 值每两分钟将额外 10% 的流量转移到新版本。
有关预定义部署配置的列表，请参阅[部署配置](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html)。
有关如何使用 CodeDeploy 和 AWS SAM 创建滚动部署的更多信息，请参阅以下内容：
+ [教程：Deploy an updated Lambda function with CodeDeploy and the AWS Serverless Application Model](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html)
+ [Deploying serverless applications gradually with AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html)
# 管理 Lambda 函数版本
您可以使用版本来管理函数的部署。例如，您可以发布函数的新版本用于测试版测试，而不会影响稳定的生产版本的用户。您每次发布函数时，Lambda 都会为函数创建一个新版本。新版本是函数的未发布版本的副本。未发布版本的名为 `$LATEST`。
重要的是，每当您部署函数代码时，都会覆盖 `$LATEST` 中的当前代码。要保存 `$LATEST` 的当前迭代，请创建一个新的函数版本。如果 `$LATEST` 与之前发布的版本相同，则在将更改部署到 `$LATEST` 之前，您无法创建新版本。这些更改可能会包括更新代码或修改函数配置设置。
发布函数版本后，其代码、运行时、架构、内存、层和大多数其他配置设置都不可变。这意味着，如果不从 `$LATEST` 发布新版本，则无法更改这些设置。您可以为已发布函数版本配置以下项目：
+ [触发器](lambda-services.md#lambda-invocation-trigger)
+ [目标](invocation-async-retain-records.md#create-destination)
+ [预配置并发](provisioned-concurrency.md)
+ [异步调用](invocation-async.md)
+ [数据库连接和代理](services-rds.md#rds-configuration)
**注意**
在**自动**模式下使用[运行时管理控件](runtimes-update.md#runtime-management-controls)时，此函数版本使用的运行时版本会自动更新。使用 **Function update**（函数更新）或 **Manual**（手动）模式时，不会更新运行时版本。有关更多信息，请参阅 [了解 Lambda 如何管理运行时版本更新](runtimes-update.md)。
**Topics**
+ [
## 创建函数版本
](#configuration-versions-config)
+ [
## 使用版本
](#versioning-versions-using)
+ [
## 授予权限
](#versioning-permissions)
## 创建函数版本
只能在函数的未发布版本上更改函数代码和设置。在您发布版本时，Lambda 会锁定代码和大多数设置，以便为该版本的用户维持一致的体验。
您可以使用 Lambda 控制台创建函数版本。
**创建新函数版本**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择一个函数，然后选择**版本**选项卡。
1. 在版本配置页面上，选择 **Publish new version（发布新版本）**。
1. （可选）输入版本说明。
1. 选择 **Publish**。
或者，您可以使用 [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html) API 操作发布函数版本。
以下 AWS CLI 命令发布函数的新版本。响应返回有关新版本的配置信息，包括版本号和具有版本后缀的函数 ARN。
```
aws lambda publish-version --function-name my-function
```
您应看到以下输出：
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "function.handler",
"Runtime": "nodejs24.x",
...
}
```
**注意**
Lambda 会分配单调递增的序列号，以便进行版本控制。Lambda 不会重复使用版本号，即使是删除并重新创建函数之后也是如此。
## 使用版本
您可以使用限定的 ARN 或非限定的 ARN 来引用您的 Lambda 函数。
+ **限定的 ARN** – 具有版本后缀的函数 ARN。以下示例引用 `helloworld` 函数的版本 42。
```
arn:aws:lambda:aws-region:acct-id:function:helloworld:42
```
+ **非限定的 ARN** – 不具有版本后缀的函数 ARN。
```
arn:aws:lambda:aws-region:acct-id:function:helloworld
```
您可以在所有相关 API 操作中使用限定或非非限定的 ARN。但是，不能使用非限定 ARN 来创建别名。
如果您决定不发布函数版本，可以使用[事件源映射](invocation-eventsourcemapping.md)中的限定或非限定 ARN 来调用函数。当您使用非限定 ARN 调用函数时，Lambda 会隐式调用 `$LATEST`。
每个 Lambda 函数版本的限定 ARN 都是唯一的。发布版本后，您无法更改 ARN 或函数代码。
Lambda 仅在代码从未发布过或自上次发布版本后已发生更改时，才会发布新函数版本。如果没有任何更改，函数版本将保持为上次发布的版本。
当您发布版本时，Lambda 会创建函数代码和配置的不可变快照。并非所有配置更改都会触发新版本的发布。以下配置更改使函数有资格发布版本：
+ 函数代码
+ 环境变量
+ 运行时
+ 处理程序
+ 层
+ 内存大小
+ 超时
+ VPC 配置
+ 死信队列 (DLQ) 配置
+ IAM 角色
+ 说明
+ 架构（x86\$164 或 arm64）
+ 临时存储大小
+ 包类型
+ 日志记录配置
+ 文件系统配置
+ SnapStart
+ 跟踪配置
[预留并发](configuration-concurrency.md)等操作设置在更改时不会触发新版本的发布。
## 授予权限
您可以使用基于[资源的策略](access-control-resource-based.md)或[基于身份的策略](access-control-identity-based.md)授予对函数的访问权限。权限的范围取决于您要将策略应用于整个函数还是函数的某个版本。有关策略中的函数资源名称的更多信息，请参阅[微调策略的“资源和条件”部分](lambda-api-permissions-ref.md)。
您可以使用函数别名，简化事件源和 AWS Identity and Access Management (IAM) 策略的管理。有关更多信息，请参阅[为 Lambda 函数创建别名](configuration-aliases.md)。
# 在 Lambda 函数上使用标签
可以通过为函数添加标签来组织和管理资源。标签是与资源关联的自由格式键值对，在 AWS 服务中受支持。有关标签用例的更多信息，请参阅《Tagging AWS Resources and Tag Editor Guide》**中的 [Common tagging strategies](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies)。
标签应用在函数级别，而不是应用于版本或别名。标签不会包含在您发布版本时 AWS Lambda 创建快照的版本特定配置的快照中。可以使用 Lambda API 来查看和更新标签。在 Lambda 控制台中管理特定函数时，还可以查看和更新标签。
**Topics**
+ [
## 使用标签所需的权限
](#fxn-tags-required-permissions)
+ [
## 通过 Lambda 控制台使用标签
](#using-tags-with-the-console)
+ [
## 通过 AWS CLI 使用标签
](#configuration-tags-cli)
## 使用标签所需的权限
要允许 AWS Identity and Access Management（IAM）身份（用户、组或角色）读取资源或为其设置标签，请授予该身份相应的权限：
+ **lambda:ListTags** – 当资源有标签时，将此权限授予需要在其上调用 `ListTags` 的任何人。对于带标签的函数，`GetFunction` 也需要此权限。
+ **lambda:TagResource** – 将此权限授予需要调用 `TagResource` 或执行在创建时授予标记的操作的任何人。
或者，也可以考虑授予 **lambda:UntagResource** 权限以允许 `UntagResource` 调用该资源。
有关更多信息，请参阅 [Lambda 的基于身份的 IAM policy](access-control-identity-based.md)。
## 通过 Lambda 控制台使用标签
您可以使用 Lambda 控制台创建具有标签的函数、向现有函数添加标签以及按添加的标签筛选函数。
**要在创建函数时添加标签**
1. 打开 Lamba 控制台的 [Functions page](https://console.aws.amazon.com/lambda/home#/functions)（函数页面）。
1. 选择 **Create function**（创建函数）。
1. 选择 **Author from scratch**（从头开始编写）或 **Container image**（容器映像）。
1. 在**基本信息**下，设置您的函数。有关配置函数的更多信息，请参阅 [配置 AWS Lambda 函数](lambda-functions.md)。
1. 展开 **Advanced settings**（高级设置），然后选择 **Enable tags**（启用标签）。
1. 选择 **Add new tag**（添加新标签），然后输入 **Key**（键）和可选 **Value**（值）。要添加更多标签，请重复此步骤。
1. 选择**创建函数**。
**要将标签添加到现有函数**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择一个函数的名称。
1. 选择 **Configuration**（配置），然后选择 **Tags**（标签）。
1. 在**标签**下，选择**管理标签**。
1. 选择 **Add new tag**（添加新标签），然后输入 **Key**（键）和可选 **Value**（值）。要添加更多标签，请重复此步骤。
1. 选择**保存**。
**使用标签过滤函数**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择搜索框以查看函数属性和标签键列表。
1. 选择一个标签键以查看当前 AWS 区域中正在使用的值的列表。
1. 选择**使用：“tag-name”**以查看所有使用此键标记的函数，或者选择一个**运算符**进一步按值筛选。
1. 选择标签值以按标签键和值的组合进行筛选。
搜索栏还支持搜索标签键。输入 `tag` 以仅查看标签键列表，或输入键的名称以在列表中查找它。
## 通过 AWS CLI 使用标签
可以使用 Lambda API 在现有 Lambda 资源（包括函数）上添加和删除标签。还可以在创建函数时添加标签，这样就可以在资源的整个生命周期中对其进行标记。
### 使用 Lambda 标签 API 更新标签
可以通过 [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html) 和 [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html) API 操作，添加和删除受支持 Lambda 资源的标签。
可以使用 AWS CLI 调用这些操作。要向现有资源添加标签，请使用 `tag-resource` 命令。此示例添加了两个标签，一个带有键 *Department*，另一个带有键 *CostCenter*。
```
aws lambda tag-resource \
--resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \
--tags Department=Marketing,CostCenter=1234ABCD
```
要删除标签，请使用 `untag-resource` 命令。此示例删除了键为 *Department* 的标签。
```
aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \
--tag-keys Department
```
### 在创建函数时添加标签
要使用标签创建新的 Lambda 函数，请使用 [CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html) API 操作。指定 `Tags` 参数。您可以使用 `create-function` CLI 命令和 --tags 选项调用此操作。在将标签参数与 `CreateFunction` 一起使用之前，请确保您的角色拥有标记资源的权限以及此操作所需的常规权限。有关标记权限的更多信息，请参阅 [使用标签所需的权限](#fxn-tags-required-permissions)。此示例添加了两个标签，一个带有键 *Department*，另一个带有键 *CostCenter*。
```
aws lambda create-function --function-name my-function
--handler index.js --runtime nodejs24.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD
```
### 查看函数上的标签
要查看应用于特定 Lambda 资源的标签，请使用 `ListTags` API 操作。有关更多信息，请参阅 [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html)。
可以提供 ARN（Amazon 资源名称），以使用 `list-tags` AWS CLI 命令调用此操作。
```
aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier
```
可以通过 [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) API 操作来查看应用于特定资源的标签。类似的功能不适用于其他资源类型。
可以使用 `get-function` CLI 命令调用此操作：
```
aws lambda get-function --function-name my-function
```
### 按标签筛选资源
您可以使用 AWS Resource Groups Tagging API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html) API 操作按标签筛选资源。`GetResources` 操作最多可接收 10 个筛选条件，每个筛选条件包含一个标签键和最多 10 个标签值。提供具有 `ResourceType` 的 `GetResources`，可按特定资源类型进行筛选。
可以使用 `get-resources` AWS CLI 命令调用此操作。有关使用 `get-resources` 的示例，请参阅《AWS CLI Command Reference》**中的 [get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples)。
# Lambda 函数的响应流
Lambda 函数可以通过 [Lambda 函数 URL](urls-configuration.md) 或使用 [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) API（通过 AWS SDK 或直接调用 API），将响应有效载荷在本机流式传输回客户端。您的 Lambda 函数还可以通过 [Amazon API Gateway 代理集成](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html)流式处理响应有效载荷，该集成使用 [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) API 来调用您的函数。响应流式处理可通过提高首字节时间（TTFB）性能，使延迟敏感型应用程序受益。这是因为您可以在部分响应可用时将其发送回客户端。此外，响应流式传输函数最多可以返回 200MB 的有效载荷，而缓冲响应的最大有效载荷为 6 MB。流式处理响应还意味着您的函数不需要在内存中容纳整个响应。对于非常大的响应，这样可以减少您需要为函数配置的内存量。
**注意**
Lambda 响应流式处理在所有 AWS 区域中均不可用。请参阅 Builder Center 的 [按区域划分的 AWS 功能](https://builder.aws.com/build/capabilities)，了解按区域划分的特征可用性。
Lambda 流式处理您的响应的速度取决于响应大小。函数响应的前 6MB 的流式处理速率无上限。对于大于 6MB 的响应，响应的其余部分受带宽上限的限制。有关流式处理带宽的详细信息，请参阅[响应流式处理的带宽限制](#config-rs-bandwidth-cap)。
当调用的客户端连接中断时，流式处理响应会产生成本，并且流式处理的响应不会中断或停止。将按整个函数运行的完整时长来向客户收取费用，因此客户在设置过长的函数超时时间时应谨慎行事。
Lambda 在 Node.js 托管式运行时系统上支持响应流式处理。对于包括 Python 在内的其他语言，您也可以[使用带有自定义运行时系统 API 集成的自定义运行时系统](runtimes-custom.md#runtimes-custom-response-streaming)来流式处理响应或使用 [Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter)。
**注意**
通过 Lambda 控制台测试函数时，将始终显示缓冲响应。
**Topics**
+ [
## 响应流式处理的带宽限制
](#config-rs-bandwidth-cap)
+ [
## VPC 与响应流的兼容性
](#config-rs-vpc-compatibility)
+ [
# 编写支持响应流式处理的 Lambda 函数
](config-rs-write-functions.md)
+ [
# 使用 Lambda 函数 URL 调用支持响应流式处理的函数
](config-rs-invoke-furls.md)
+ [
# 教程：使用函数 URL 创建响应流式处理 Lambda 函数
](response-streaming-tutorial.md)
## 响应流式处理的带宽限制
函数响应有效载荷的前 6MB 的带宽无上限。在此初始突增之后，Lambda 会以最大 2MBps 的速率流式处理您的响应。如果您的函数响应从未超出 6MB，则此带宽限制永远不适用。
**注意**
带宽限制仅适用于您的函数的响应负载，不适用于您的函数的网络访问。
无上限带宽的速率因多种因素而异，其中包括函数的处理速度。通常，函数响应的前 6MB 的速率高于 2MBps。如果您的函数将响应流式处理到 AWS 以外的目标，则流式处理速率还取决于外部互联网连接的速度。
## VPC 与响应流的兼容性
在 VPC 环境中使用 Lambda 函数时，响应流有一些重要注意事项：
+ Lambda 函数 URL 不支持 VPC 环境内的响应流。
+ 您可以使用 `InvokeWithResponseStream` API 通过 AWS SDK 调用 Lambda 函数来在 VPC 中使用响应流。这需要为 Lambda 设置适当的 VPC 端点。
+ 对于 VPC 环境，您需要为 Lambda 创建一个接口 VPC 端点，以实现 VPC 中的资源与 Lambda 服务之间的通信。
VPC 中响应流的典型架构可能包括：
```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```
# 编写支持响应流式处理的 Lambda 函数
为响应流式处理函数编写处理程序不同于典型的处理程序模式。编写流式处理函数时，请确保执行以下操作：
+ 使用 `awslambda.streamifyResponse()` 装饰器包装您的函数。`awslambda` 全局对象由 Lambda 的 Node.js 运行时环境提供。
+ 正常结束流，以确保所有数据处理完成。
## 配置处理程序函数以流式处理响应
要向运行时系统指示 Lambda 应该流式处理函数的响应，您必须使用 `streamifyResponse()` 装饰器包装函数。从而指示运行时系统使用正确的响应流式处理逻辑路径，同时确保函数能够流式处理响应。
`streamifyResponse()` 装饰器接受可接受以下参数的函数：
+ `event` – 提供有关函数 URL 的调用事件的信息，例如 HTTP 方法、查询参数和请求正文。
+ `responseStream` – 提供可写流。
+ `context` – 提供的方法和属性包含有关调用、函数和执行环境的信息。
`responseStream` 对象为 [Node.js `writableStream`](https://nodesource.com/blog/understanding-streams-in-nodejs/)。与任何此类流一样，您应该使用 `pipeline()` 方法。
**注意**
`awslambda` 全局对象由 Lambda 的 Node.js 运行时自动提供，无需导入。
**Example 支持响应流式处理的处理程序**
```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';
export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
// As an example, convert event to a readable stream.
const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
await pipeline(requestStream, responseStream);
});
```
尽管 `responseStream` 提供了写入流的 `write()` 方法，但建议您尽可能使用 [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback)。使用 `pipeline()` 能够确保可写流不会被速度更快的可读流所淹没。
## 结束流
确保在处理程序返回之前正确结束流。`pipeline()` 方法会自动处理此问题。
对于其他使用案例，请调用 `responseStream.end()` 方法以正确结束流。此方法表示不应向流写入更多数据。如果您使用 `pipeline()` 或 `pipe()` 写入流，则不需要使用此方法。
从 Node.js 24 开始，在您的处理程序返回或响应流结束后，Lambda 不再等待未解决的 Promise 完成。如果您的函数依赖于其他异步操作，例如计时器或获取，则应在处理程序中 `await` 它们。
**Example 使用 pipeline() 结束流的示例**
```
import { pipeline } from 'node:stream/promises';
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
await pipeline(requestStream, responseStream);
});
```
**Example 不使用 pipeline() 结束流的示例**
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
responseStream.write("Hello ");
responseStream.write("world ");
responseStream.write("from ");
responseStream.write("Lambda!");
responseStream.end();
});
```
# 使用 Lambda 函数 URL 调用支持响应流式处理的函数
**注意**
您的 Lambda 函数现在可以通过 [Amazon API Gateway 代理集成](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html)流式传输响应有效载荷。
您可以通过更改函数 URL 的调用模式来调用支持响应流式处理的函数。调用模式决定 Lambda 使用哪个 API 操作来调用函数。可用的调用模式有：
+ `BUFFERED` – 这是默认选项。Lambda 通过 `Invoke` API 操作调用函数。负载完成后，调用结果可用。最大负载大小为 6MB。
+ `RESPONSE_STREAM` – 使函数能够在负载结果可用时对其进行流式处理。Lambda 通过 `InvokeWithResponseStream` API 操作调用函数。最大响应有效载荷为 200MB。
通过直接调用 `Invoke` API 操作，您仍然可以在不进行响应流式处理的情况下调用函数。但是，Lambda 会流式处理通过函数 URL 发出的调用的所有响应负载，直到您将调用模式更改为 `BUFFERED`。
------
#### [ Console ]
**设置函数 URL 的调用模式（控制台）**
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 选择您要为其设置调用模式的函数的名称。
1. 选择 **Configuration**（配置）选项卡，然后选择 **Function URL**（函数 URL）。
1. 选择**编辑**，然后选择**其他设置**。
1. 在**调用模式**下，选择所需的调用模式。
1. 选择**保存**。
------
#### [ AWS CLI ]
**设置函数 URL 的调用模式（AWS CLI）**
```
aws lambda update-function-url-config \
--function-name my-function \
--invoke-mode RESPONSE_STREAM
```
------
#### [ CloudFormation ]
**设置函数 URL 的调用模式（CloudFormation）**
```
MyFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: AWS_IAM
InvokeMode: RESPONSE_STREAM
```
------
有关配置函数 URL 的更多信息，请参阅 [Lambda 函数 URL](urls-configuration.md)。
# 教程：使用函数 URL 创建响应流式处理 Lambda 函数
在本教程中，您将创建一个 Lambda 函数，该函数定义为 .zip 文件存档，其函数 URL 端点会返回响应流。有关配置函数 URL 的更多信息，请参阅 [函数 URL](urls-configuration.md)。
## 先决条件
本教程假设您对 Lambda 基本操作和 Lambda 控制台有一定了解。如果您还没有了解，请按照 [使用控制台创建 Lambda 函数](getting-started.md#getting-started-create-function) 中的说明创建您的第一个 Lambda 函数。
要完成以下步骤，您需要 [AWS CLI 版本 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)。在单独的数据块中列出了命令和预期输出：
```
aws --version
```
您应看到以下输出：
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
对于长命令，使用转义字符 (`\`) 将命令拆分为多行。
在 Linux 和 macOS 中，可使用您首选的 shell 和程序包管理器。
**注意**
在 Windows 中，操作系统的内置终端不支持您经常与 Lambda 一起使用的某些 Bash CLI 命令（例如 `zip`）。[安装 Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，获取 Ubuntu 和 Bash 与 Windows 集成的版本。本指南中的示例 CLI 命令使用 Linux 格式。如果您使用的是 Windows CLI，则必须重新格式化包含内联 JSON 文档的命令。
## 创建执行角色
创建[执行角色](lambda-intro-execution-role.md)，向您的 Lambda 函数授予访问AWS资源的权限。
**创建执行角色**
1. 打开 AWS Identity and Access Management（IAM）控制台的 [Roles](https://console.aws.amazon.com/iam/home#/roles)（角色）页面。
1. 选择**创建角色**。
1. 创建具有以下属性的角色：
+ **可信实体类型** – **AWS 服务**
+ **使用场景** – **Lambda**
+ **权限** – **AWSLambdaBasicExecutionRole**
+ **Role name**（角色名称）– **response-streaming-role**
**AWSLambdaBasicExecutionRole** 策略具有函数将日志写入 Amazon CloudWatch Logs 所需的权限。创建角色后，记下其 Amazon 资源名称（ARN）。下一步中需要使用该值。
## 创建响应流式处理函数（AWS CLI）
使用 AWS Command Line Interface（AWS CLI）创建具有函数 URL 端点的响应流式处理 Lambda 函数。
**创建能够流式处理响应的函数**
1. 将以下代码示例复制到名为 `index.js` 的文件中。此函数流式传输三个间隔为 1 秒的响应。
```
exports.handler = awslambda.streamifyResponse(
async (event, responseStream, _context) => {
// Metadata is a JSON serializable JS object. Its shape is not defined here.
const metadata = {
statusCode: 200,
headers: {
"Content-Type": "application/json",
"CustomHeader": "outerspace"
}
};
// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
responseStream.write("Streaming with Helper \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 0 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 1 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 2 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.end();
await responseStream.finished();
}
);
```
1. 创建部署程序包。
```
zip function.zip index.js
```
1. 使用 `create-function` 命令创建 Lambda 函数。将 `--role` 的值替换为上一步中的角色 ARN。此命令将函数超时设置为 10 秒，这样函数就可以流式传输三个响应。
```
aws lambda create-function \
--function-name my-streaming-function \
--runtime nodejs24.x \
--zip-file fileb://function.zip \
--handler index.handler \
--timeout 10 \
--role arn:aws:iam::123456789012:role/response-streaming-role
```
**创建函数 URL**
1. 向函数添加基于资源的策略，授予 `lambda:InvokeFunctionUrl` 和 `lambda:InvokeFunction` 权限。每条语句都必须添加到单独的命令中。将 `--principal` 的值替换为您的 AWS 账户 ID。
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunctionUrl \
--statement-id UrlPolicyInvokeURL \
--principal 123456789012 \
--function-url-auth-type AWS_IAM
```
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunction \
--statement-id UrlPolicyInvokeFunction \
--principal 123456789012
```
1. 使用 `create-function-url-config` 命令为函数创建 URL 端点。
```
aws lambda create-function-url-config \
--function-name my-streaming-function \
--auth-type AWS_IAM \
--invoke-mode RESPONSE_STREAM
```
**注意**
如果收到 `--invoke-mode` 错误，可能需要升级到[新版 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)。
## 测试函数 URL 端点
通过调用函数来测试集成。您可以在浏览器中打开函数的 URL，也可以使用 curl。
```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```
我们的函数 URL 使用 `IAM_AUTH` 身份验证类型。这意味着您必须使用 [AWS 访问密钥和私有密钥才能签署请求](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。在上一条命令中，将 `AKIAIOSFODNN7EXAMPLE` 替换为 AWS 访问密钥 ID。请在出现提示时输入 AWS 私有密钥。如果没有 AWS 私有密钥，可以改为[使用临时 AWS 凭证](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)。
应出现如下响应：
```
Streaming with Helper
Hello 0
Hello 1
Hello 2
```
## 清除资源
除非您想要保留为本教程创建的资源，否则可立即将其删除。通过删除您不再使用的 AWS 资源，可防止您的 AWS 账户 产生不必要的费用。
**删除执行角色**
1. 打开 IAM 控制台的[角色页面](https://console.aws.amazon.com/iam/home#/roles)。
1. 选择您创建的执行角色。
1. 选择**删除**。
1. 在文本输入字段中输入角色名称，然后选择**删除**。
**删除 Lambda 函数**
1. 打开 Lamba 控制台的 [Functions（函数）页面](https://console.aws.amazon.com/lambda/home#/functions)。
1. 选择您创建的函数。
1. 依次选择**操作**和**删除**。
1. 在文本输入字段中键入 **confirm**，然后选择 **Delete**（删除）。
# 使用 Lambda 元数据端点
Lambda 元数据端点允许您的函数发现它们在哪个可用区 (AZ) 中运行，从而使您能够通过路由到 Amazon ElastiCache 和 Amazon RDS 端点等相同可用区资源来优化延迟，并实施可用区感知弹性模式。
端点通过执行环境中的本地主机 HTTP API 以简单 JSON 格式返回元数据，运行时和扩展程序均可访问。
**Topics**
+ [
## 开始使用
](#metadata-endpoint-getting-started)
+ [
## 了解可用区 ID
](#metadata-endpoint-az-ids)
+ [
## API 参考
](#metadata-endpoint-api-reference)
## 开始使用
[Powertools for AWS Lambda](https://docs.aws.amazon.com/powertools/) 提供了一个实用工具，用于在 Python、TypeScript、Java 和.NET 中访问 Lambda 元数据端点。该实用程序会在第一次调用后缓存响应，并自动处理 SnapStart 缓存失效。
使用 Powertools for AWS Lambda 元数据实用程序或直接调用元数据端点
------
#### [ Python ]
安装 Powertools 软件包：
```
pip install "aws-lambda-powertools"
```
在处理程序中使用元数据实用程序：
**Example 使用 Powertools (Python) 检索可用区 ID**
```
from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata
def handler(event, context):
metadata = get_lambda_metadata()
az_id = metadata.availability_zone_id # e.g., "use1-az1"
return {"az_id": az_id}
```
------
#### [ TypeScript ]
安装 Powertools 软件包：
```
npm install @aws-lambda-powertools/commons
```
在处理程序中使用元数据实用程序：
**Example 使用 owertools (TypeScript) 检索可用区 ID**
```
import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata';
const metadata = await getMetadata();
export const handler = async () => {
const { AvailabilityZoneID: azId } = metadata;
return azId;
};
```
------
#### [ Java ]
将 Powertools 依赖项添加到 `pom.xml`：
```
software.amazon.lambda
powertools-lambda-metadata
2.10.0
```
在处理程序中使用元数据客户端：
**Example 使用 Powertools (Java) 检索可用区 ID**
```
import software.amazon.lambda.powertools.metadata.LambdaMetadata;
import software.amazon.lambda.powertools.metadata.LambdaMetadataClient;
public class App implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
LambdaMetadata metadata = LambdaMetadataClient.get();
String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1"
return "{\"azId\": \"" + azId + "\"}";
}
}
```
------
#### [ .NET ]
安装 Powertools 软件包：
```
dotnet add package AWS.Lambda.Powertools.Metadata
```
在处理程序中使用元数据类：
**Example 使用 Powertools (.NET) 检索可用区 ID**
```
using AWS.Lambda.Powertools.Metadata;
public class Function
{
public string Handler(object input, ILambdaContext context)
{
var azId = LambdaMetadata.AvailabilityZoneId;
return $"Running in AZ: {azId}";
}
}
```
------
#### [ All Runtimes ]
所有 Lambda 运行时都支持元数据端点，包括自定义运行时和容器映像。使用下面的示例，您可以使用 Lambda 在执行环境中自动设置的环境变量，直接从函数访问元数据 API。
**Example 直接访问元数据端点**
```
# Variables are automatically set by Lambda
METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment"
# Make the request
RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT")
# Parse the AZ ID
AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID')
echo "Function is running in AZ ID: $AZ_ID"
```
------
## 了解可用区 ID
可用区 ID（例如 `use1-az1`）始终指所有 AWS 账户的相同物理位置，而可用区名称（例如 `us-east-1a`）可能映射到特定区域中每个 AWS 账户的不同物理基础设施。有关更多信息，请参阅[跨账户一致性的可用区 ID](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html)。
**将可用区 ID 转换为可用区名称：**
要将可用区 ID 转换为可用区名称，请使用 Amazon EC2 [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html) API。要使用此 API，请将 `ec2:DescribeAvailabilityZones` 权限添加到函数的执行角色中。
## API 参考
### 环境变量
Lambda 在每个执行环境中自动设置以下环境变量：
+ `AWS_LAMBDA_METADATA_API`–`{ipv4_address}:{port}` 元数据服务器地址的格式（例如，`169.254.100.1:9001`）。
+ `AWS_LAMBDA_METADATA_TOKEN`–当前执行环境的唯一身份验证令牌。Lambda 在初始化时会自动生成此令牌。将其包含在所有元数据 API 请求中。
### 端点
`GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment`
### 请求
**必需的标头：**
+ `Authorization`–来自 `AWS_LAMBDA_METADATA_TOKEN` 环境变量的令牌值，使用 Bearer 方案：`Bearer `。这种基于令牌的身份验证提供了针对服务器端请求伪造 (SSRF) 漏洞的深度防御。每个执行环境在初始化时都会收到一个随机生成的唯一令牌。
### 响应
**状态：** `200 OK`
**Content-Type:** `application/json`
**Cache-Control:** `private, max-age=43200, immutable`
响应在执行环境中不可更改。客户端应缓存响应并遵守 `Cache-Control` TTL。对于 SnapStart 函数，TTL 会在初始化期间降低，因此当执行环境可能位于不同的可用区时，客户端可以在还原后刷新元数据。如果使用 Powertools，缓存和 SnapStart 失效会自动处理。
**Body:**
```
{
"AvailabilityZoneID": "use1-az1"
}
```
`AvailabilityZoneID` 字段包含运行执行环境的可用区的唯一标识符。
**注意**
在将来的更新中，可能会在响应中添加其他字段。客户端应忽略未知字段，并且在出现新字段时不会失败。
### 错误响应
+ **401 未授权**–`Authorization` 标头丢失或包含无效标记。验证您是否通过 `Bearer ${AWS_LAMBDA_METADATA_TOKEN}`。
+ **405 方法不允许**–请求方法不是 `GET`。
+ **500 内部服务器错误**–服务器端处理错误。