本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 轮换 Amazon Secrets Manager 秘密
轮换 密钥

*Rotation* 是定期更新密钥的过程。当轮换密钥时，会同时更新密钥和数据库或服务中的凭据。在 Secrets Manager 中，您可以为密钥设置自动轮换。轮换有两种形式：
+ [托管轮换](rotate-secrets_managed.md) – 对于大多数[托管密钥](service-linked-secrets.md)，可以使用托管轮换，其中服务为您配置和管理轮换。托管轮换不使用 Lambda 函数。
+ [轮换 Secrets Manager 托管的外部机密](rotate-secrets_external.md)— 对于 Secrets Manager 合作伙伴持有的机密，您可以使用托管外部密钥轮换来更新合作伙伴系统上的密钥。这不需要 Lambda 函数。
+ [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md) – 对于其他类型的密钥，Secrets Manager 轮换使用 Lambda 函数来更新密钥和数据库或服务。

# Amazon Secrets Manager 密钥的托管轮换
托管轮换

部分服务提供*托管轮换*，即服务为您配置和管理轮换。使用托管轮换，您无需使用 Amazon Lambda 函数来更新数据库中的密钥和凭据。

以下服务提供托管轮换：
+ None（无）

**提示**  
有关所有其他类型的密钥，请参阅 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)。

托管秘密的轮换通常会在一分钟内完成。在轮换期间，检索秘密的新连接可能会获得先前版本的凭证。在应用程序中，我们强烈建议您遵循使用以您的应用程序所需的最低权限创建的数据库用户的最佳实践，而不是使用主用户。对于应用程序用户，为了获得最高可用性，可以使用[交替用户轮换策略](rotation-strategy.md)。

如需了解 Secrets Manager 合作伙伴持有的机密，

**更改托管轮换的计划**

1. 在 Secrets Manager 控制台中打开托管密钥。您可以访问管理服务中的链接，也可以在 Secrets Manager 控制台中[搜索密钥](service-linked-secrets.md)。

1. 在 **Rotation schedule**（轮换计划）下，在 **Schedule expression builder**（计划表达式生成器）或 **Schedule expression**（计划表达式）中，以 UTC 时区格式输入您的计划。Secrets Manager 会将您的计划存储为 `rate()` 或 `cron()` 表达式。轮换时段将自动从午夜开始，除非您指定 **Start time**（开始时间）。您可以每四小时轮换一次密钥。有关更多信息，请参阅 [轮换计划](rotate-secrets_schedule.md)。

1. （可选）对于 **Window duration**（时段持续时间），选择您希望 Secrets Manager 在其间轮换密钥的时段长度，例如 **3h** 表示三个小时的时段。该时段不得延伸到下一个轮换时段。如果未指定 **Window duration**（时段持续时间），则对于以小时为单位的轮换计划，时段将在一小时后自动关闭。对于以天为单位的轮换计划，时段将在一天结束时自动关闭。

1. 选择**保存**。

**更改托管轮换的计划 (Amazon CLI)**
+ 调用 [https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/rotate-secret.html](https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/rotate-secret.html)。以下示例在每月 1 日和 15 日 UTC 16:00 至 18:00 之间轮换密钥。有关更多信息，请参阅 [轮换计划](rotate-secrets_schedule.md)。

  ```
  aws secretsmanager rotate-secret \
      --secret-id MySecret \
      --rotation-rules \
          "{\"ScheduleExpression\": \"cron(0 16 1,15 * ? *)\", \"Duration\": \"2h\"}"
  ```

# 轮换 Secrets Manager 托管的外部机密
轮换托管的外部机密

Secrets Manager 已与精选软件供应商合作，提供托管外部机密。此功能可通过自动处理轮换来帮助客户管理密钥生命周期。借助托管外部密钥，客户不再需要为存储在不同合作伙伴中的每个密钥维护特定的轮换逻辑。这将由 Secrets Manager 处理。

要查看已加入 Secrets Manager 的合作伙伴列表，请参阅[托管外部机密](https://docs.amazonaws.cn/secretsmanager/latest/userguide/mes-partners.html)合作伙伴。

## 在控制台中设置轮换


要为通过指定相应[集成合作伙伴](https://docs.amazonaws.cn/secretsmanager/latest/userguide/mes-partners.html)指定的密钥类型和值创建的现有托管外部密钥配置轮换，请使用以下步骤：

1. 打开 Secrets Manager 控制台。

1. 从列表中选择您的托管外部密钥。

1. 选择**配置**选项卡。

1. 在**旋转配置**部分，选择**编辑旋转**。

1. 启用 **Automatic rotation**（自动轮换）。

1. 在 “**轮换元数据**” 下，添加轮换所需的所有合作伙伴特定的元数据：

   请按照您的集成合作伙伴提供的指南获取其他必需的元数据

1. 在**密钥轮换的服务权限**中，选择或创建轮换的 IAM 角色：
   + 选择 “**创建新角色**” 可自动创建具有必要权限的角色
   + 或者为你的合作伙伴选择一个具有适当权限的现有角色

   默认情况下，权限的范围仅限于创建密钥的区域中的个人合作伙伴

1. 设置**轮换时间表**（例如，每 30 天自动轮换一次）。

1. 选择 “**保存**” 以应用旋转配置。

在此过程中配置的两个关键元数据字段是：


| 字段 | 说明 | 
| --- | --- | 
| ExternalSecretRotationMetadata | 轮换所需的合作伙伴特定元数据，例如 Salesforce 的 API 版本 | 
| ExternalSecretRotationRoleArn | 用于轮换的 IAM 角色的 ARN，权限范围仅限于集成合作伙伴 | 

有关这些字段的更多信息，请参阅使用 Secrets Manager [托管的外部密钥管理第三方机密](https://docs.amazonaws.cn/secretsmanager/latest/userguide/managed-external-secrets.html)。

## 使用 CLI 设置轮换


运行以下命令为 Salesforce 密钥设置轮换。此命令指定密钥 ID、轮换的 IAM 角色 ARN、轮换计划以及轮换过程所需的任何合作伙伴特定元数据。

```
aws secretsmanager rotate-secret \
            --secret-id SampleSecret \
            --external-secret-rotation-role-arn arn:aws:iam::123412341234:role/xyz \
            --rotation-rules AutomaticallyAfterDays=1 \
            --external-secret-rotation-metadata '[{"Key":"apiVersion","Value":"v65.0"}]'
```

# 通过 Lambda 函数进行轮换


对于许多类型的密钥，Secrets Manager 使用 Amazon Lambda 函数来更新密钥以及数据库或服务。有关使用 Lambda 函数的成本的信息，请参阅 [定价](intro.md#asm_pricing)。

对于某些 [由其他服务管理的密钥](service-linked-secrets.md)，可使用*托管轮换*。要使用 [托管轮换](rotate-secrets_managed.md)，请首先通过管理服务来创建密钥。

在轮换期间，Secrets Manager 会录入指示轮换状态的事件。有关更多信息，请参阅 [使用记录 Amazon Secrets Manager 事件 Amazon CloudTrail](monitoring-cloudtrail.md)。

为了轮换密钥，Secrets Manager 会根据您设置的轮换计划调用 [Lambda 函数](rotate-secrets_lambda-functions.md)。如果在设置自动轮换时也手动更新密钥值，则 Secrets Manager 在计算下一次轮换日期时会认为这是有效的轮换。

在轮换过程中，Secrets Manager 调用几次同一函数，每次使用不同的参数。Secrets Manager 调用具有以下 JSON 请求参数结构的函数：

```
{
    "Step" : "request.type",
    "SecretId" : "string",
    "ClientRequestToken" : "string",
    "RotationToken" : "string"
}
```

**参数：**
+ **步骤** – 轮换步骤：`create_secret`、`set_secret`、`test_secret` 或 `finish_secret`。有关更多信息，请参阅 [轮换函数的四个步骤](rotate-secrets_lambda-functions.md#rotate-secrets_lambda-functions-code)。
+ **SecretId**— 轮换秘密的 ARN。
+ **ClientRequestToken**— 新版本密钥的唯一标识符。此值有助于确保幂等性。有关更多信息，请参阅 *Amazon Secrets Manager API 参考 ClientRequestToken*中的 [PutSecretValue：](https://docs.amazonaws.cn/secretsmanager/latest/apireference/API_PutSecretValue.html#SecretsManager-PutSecretValue-request-ClientRequestToken)。
+ **RotationToken**— 表示请求来源的唯一标识符。使用代入角色轮换密钥或跨账户轮换所必需的条件，即您使用另一个账户中的 Lambda 轮换函数来轮换一个账户中的密钥。在这两种情况下，轮换函数都担任 IAM 角色来调用 Secrets Manager，然后 Secrets Manager 使用轮换令牌来验证 IAM 角色身份。

如果任何轮换步骤失败，Secrets Manager 会多次重试整个轮换过程。

**Topics**
+ [自动轮换数据库密钥（控制台）](rotate-secrets_turn-on-for-db.md)
+ [自动轮换非数据库密钥（控制台）](rotate-secrets_turn-on-for-other.md)
+ [自动轮换（Amazon CLI）](rotate-secrets_turn-on-cli.md)
+ [

# Lambda 函数轮换策略
](rotation-strategy.md)
+ [

# Lambda 轮换函数
](rotate-secrets_lambda-functions.md)
+ [轮换函数模板](reference_available-rotation-templates.md)
+ [轮换权限](rotating-secrets-required-permissions-function.md)
+ [

# Amazon Lambda 轮换功能的网络接入
](rotation-function-network-access.md)
+ [轮换问题排查](troubleshoot_rotation.md)

# 为 Amazon RDS、Amazon Aurora、Amazon Redshift 或 Amazon DocumentDB 密钥设置自动轮换
自动轮换数据库密钥（控制台）

本教程介绍了如何为数据库密钥设置 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)。Rotation 是定期更新密钥的过程。轮换密钥时，您会同时更新密钥和数据库中的凭证。在 Secrets Manager 中，您可以为数据库密钥设置自动轮换。

要使用控制台设置轮换，您需要先选择轮换策略。然后配置密钥以进行轮换，如果您还没有 Lambda 轮换函数，这将创建一个 Lambda 轮换函数。控制台还会为 Lambda 函数执行角色设置权限。最后一步是确保 Lambda 轮换函数可以通过网络访问 Secrets Manager 和数据库。

**警告**  
要启用自动轮换，您必须有权为 Lambda 轮换函数创建 IAM 执行角色并向其附加权限策略。您需要拥有 `iam:CreateRole` 和 `iam:AttachRolePolicy` 两个权限。授予这些权限允许身份授予自己任何权限。

**Topics**
+ [

## 步骤 1：选择轮换策略并（可选）创建超级用户密钥
](#rotate-secrets_turn-on-for-db_step1)
+ [

## 步骤 2：配置轮换并创建轮换函数
](#rotate-secrets_turn-on-for-db_step2)
+ [

## 第 3 步：（可选）为轮换函数设置额外的权限条件
](#rotate-secrets_turn-on-for-db_step3)
+ [

## 步骤 4：为轮换函数设置网络访问
](#rotate-secrets_turn-on-for-db_step4)
+ [

## 后续步骤
](#rotate-secrets_turn-on-for-db_stepnext)

## 步骤 1：选择轮换策略并（可选）创建超级用户密钥


有关 Secrets Manager 提供的策略的信息，请参阅 [Lambda 函数轮换策略](rotation-strategy.md)。

如果选择 *alternating users strategy*（交替用户策略），您必须 [创建密钥](create_secret.md) 并在其中存储数据库超级用户凭证。您需要一个包含超级用户凭证的密钥，因为轮换会克隆第一个用户，而大多数用户没有该权限。请注意，Amazon RDS 代理不支持交替用户策略。

## 步骤 2：配置轮换并创建轮换函数


**为 Amazon RDS、Amazon DocumentDB 或 Amazon Redshift 密钥启用轮换**

1. 打开 Secrets Manager 控制台，网址为[https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)。

1. 在**密钥**列表页上，选择您的密钥。

1. 在 **Secret details (密钥详细信息)** 页上的 **Rotation configuration (轮换配置)** 部分中，选择 **Edit rotation (编辑轮换)**。

1. 在**编辑轮换配置**对话框中，执行以下操作：

   1. 启用 **Automatic rotation**（自动轮换）。

   1. 在 **Rotation schedule**（轮换计划）下，在 **Schedule expression builder**（计划表达式生成器）或 **Schedule expression**（计划表达式）中，以 UTC 时区格式输入您的计划。Secrets Manager 会将您的计划存储为 `rate()` 或 `cron()` 表达式。轮换时段将自动从午夜开始，除非您指定 **Start time**（开始时间）。您可以每四小时轮换一次密钥。有关更多信息，请参阅 [轮换计划](rotate-secrets_schedule.md)。

   1. （可选）对于 **Window duration**（时段持续时间），选择您希望 Secrets Manager 在其间轮换密钥的时段长度，例如 **3h** 表示三个小时的时段。该时段不得延伸到下一个轮换时段。如果未指定 **Window duration**（时段持续时间），则对于以小时为单位的轮换计划，时段将在一小时后自动关闭。对于以天为单位的轮换计划，时段将在一天结束时自动关闭。

   1. （可选）请选择 **Rotate immediately when the secret is stored**（在存储密钥时立即轮换），以在保存更改时轮换密钥。如果您清除该复选框，则第一次轮换将按照您设置的计划开始。

      如果轮换失败，例如因为步骤 3 和 4 尚未完成，Secrets Manager 会多次重试轮换过程。

   1. 在 **Rotation function**（轮换函数）下，执行以下操作之一：
      + 选择 **Create a new Lambda function**（创建新的 Lambda 函数），然后输入新函数的名称。Secrets Manager 会将 `SecretsManager` 添加到函数名称的开头。Secrets Manager 会基于相应的[模板](reference_available-rotation-templates.md)创建函数并为 Lambda 执行角色设置必要的[权限](rotating-secrets-required-permissions-function.md)。
      + 选择 **Use an existing Lambda function**（使用现有 Lambda 函数），以重复使用用于另一个密钥的轮换函数。在 **Recommended VPC configurations**（建议的 VPC 配置）下列出的轮换函数，与数据库具有相同的 VPC 和安全组，有助于函数访问数据库。

   1. 对于**轮换策略**，选择**单用户**或**交替用户**策略。有关更多信息，请参阅 [步骤 1：选择轮换策略并（可选）创建超级用户密钥](#rotate-secrets_turn-on-for-db_step1)。

1. 选择 **Save**。

## 第 3 步：（可选）为轮换函数设置额外的权限条件


我们建议您在轮换函数的资源策略中包括上下文密钥 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)，以防止 Lambda 被用作[混淆代理](https://docs.amazonaws.cn/IAM/latest/UserGuide/confused-deputy.html)。对于某些 Amazon 服务，为了避免混淆副手的情况， Amazon 建议您同时使用[https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)和[https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)全局条件键。但如果轮换函数策略中包括 `aws:SourceArn` 条件，则轮换函数只能用于轮换该 ARN 指定的密钥。我们建议您仅在其中包括上下文键 `aws:SourceAccount`，以便对多个密钥使用轮换函数。

**更新轮换函数资源策略**

1. 在 Secrets Manager 控制台中选择您的密钥，然后在详细信息页面中的 **Rotation configuration**（轮换配置）下，选择 Lambda 轮换函数。Lambda 控制台将打开。

1. 按照 [Using resource-based policies for Lambda](https://docs.amazonaws.cn/lambda/latest/dg/access-control-resource-based.html)（将基于资源的策略用于 Lambda）中的说明添加 `aws:sourceAccount` 条件。

   ```
   "Condition": {
       "StringEquals": {
           "AWS:SourceAccount": "123456789012"
       }
   },
   ```

如果密钥使用 Amazon 托管式密钥 `aws/secretsmanager` 以外的 KMS 密钥进行加密，则 Secrets Manager 会向 Lambda 执行角色授予使用该密钥的权限。您可以使用 [SecretARN 加密上下文](security-encryption.md#security-encryption-encryption-context) 来限制解密函数的使用，从而确保轮换函数角色只能解密其负责轮换的密钥。

**更新轮换函数执行角色**

1. 从 Lambda 轮换函数中选择**配置**，然后在**执行角色**下，选择**角色名称**。

1. 按照 [修改角色权限策略](https://docs.amazonaws.cn/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) 中的说明添加 `kms:EncryptionContext:SecretARN` 条件。

   ```
   "Condition": {
       "StringEquals": {
           "kms:EncryptionContext:SecretARN": "SecretARN"
       }
   },
   ```

## 步骤 4：为轮换函数设置网络访问


有关更多信息，请参阅 [Amazon Lambda 轮换功能的网络接入](rotation-function-network-access.md)。

## 后续步骤


请参阅[排除 Amazon Secrets Manager 轮换故障](troubleshoot_rotation.md)。

# 为非数据库 Amazon Secrets Manager 密钥设置自动轮换
自动轮换非数据库密钥（控制台）

本教程介绍了如何为非数据库密钥设置 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)。Rotation 是定期更新密钥的过程。轮换密钥时，会同时更新密钥以及拥有密钥的数据库或服务中的凭证。

有关数据库密钥的信息，请参阅 [自动轮换数据库密钥（控制台）](rotate-secrets_turn-on-for-db.md)。

**警告**  
要启用自动轮换，您必须有权为 Lambda 轮换函数创建 IAM 执行角色并向其附加权限策略。您需要拥有 `iam:CreateRole` 和 `iam:AttachRolePolicy` 两个权限。授予这些权限允许身份授予自己任何权限。

**Topics**
+ [

## 步骤 1：创建通用轮换函数
](#rotate-secrets_turn-on-for-other_create)
+ [

## 步骤 2：编写轮换函数代码
](#rotate-secrets_turn-on-for-other_write)
+ [

## 步骤 3：配置密钥以进行轮换
](#rotate-secrets_turn-on-for-other_configure)
+ [

## 步骤 4：允许轮换函数访问 Secrets Manager 以及您的数据库或服务
](#rotate-secrets_turn-on-for-other_perms)
+ [

## 步骤 5：允许 Secrets Manager 调用轮换函数
](#rotate-secrets_turn-on-for-other_perms2)
+ [

## 步骤 6：为轮换函数设置网络访问
](#rotate-secrets_turn-on-for-other_network)
+ [

## 后续步骤
](#rotate-secrets_turn-on-for-other_stepnext)

## 步骤 1：创建通用轮换函数


首先，创建一个 Lambda 轮换函数。它不包含用于轮换您的密钥的代码，因此您将在后面的步骤中编写该代码。有关轮换函数如何工作的信息，请参阅 [Lambda 轮换函数](rotate-secrets_lambda-functions.md)。

在支持的区域中 Amazon Serverless Application Repository ，您可以使用从模板创建函数。有关受支持区域的列表，请参阅[Amazon Serverless Application Repository FAQs](https://www.amazonaws.cn/serverless/serverlessrepo/faqs/)。在其他区域，您将从头开始创建函数并将模板代码复制到函数中。

**创建通用轮换函数**

1. 要确定您所在的地区 Amazon Serverless Application Repository 是否支持，请参阅《*Amazon 一般参考*》中的[Amazon Serverless Application Repository 终端节点和配额](https://docs.amazonaws.cn/general/latest/gr/serverlessrepo.html)。

1. 请执行以下操作之一：
   + 如果您 Amazon Serverless Application Repository 所在的地区支持：

     1. 在 Lambda 控制台中，选择**应用程序**，然后选择**创建应用程序**。

     1. 在**创建应用程序**页面上，选择**无服务器应用程序**选项卡。

     1. 在**公用应用程序**下的搜索框中，输入 **SecretsManagerRotationTemplate**。

     1. 选择**显示创建自定义 IAM 角色或资源策略的应用程序**。

     1. 选择 **SecretsManagerRotationTemplate** 磁贴。

     1. 在**查看、配置和部署**页面上的**应用程序设置**磁贴中，填写必填字段。
        + 对于**端点**，输入您所在区域的端点，包括 **https://**。有关 终端节点的列表，请参阅[Amazon Secrets Manager 端点](asm_access.md#endpoints)。
        + 要将 Lambda 函数放在 VPC 中，请添加 **vpcSecurityGroupID** 和。**vpcSubnetIds**

     1. 选择**部署**。
   + 如果您所在的地区 Amazon Serverless Application Repository 不支持：

     1. 在 Lambda 控制台中，选择**函数**，然后选择**创建函数**。

     1. 在 **Create function (创建函数)** 页面上，执行以下操作：

        1. 选择**从头开始创作**。

        1. 在 **Function name**（函数名称）中，输入轮换函数的名称。

        1. 对于**运行时**，选择 **Python 3.10**。

        1. 选择**创建函数**。

## 步骤 2：编写轮换函数代码


在此步骤中，您将编写用于更新密钥以及该密钥所针对的服务或数据库的代码。有关轮换函数作用的信息（包括编写自己的轮换函数的提示），请参阅 [Lambda 轮换函数](rotate-secrets_lambda-functions.md)。您可以使用 [轮换函数模板](reference_available-rotation-templates.md) 作为参考。

## 步骤 3：配置密钥以进行轮换


在此步骤中，您将为密钥设置轮换计划，并将轮换函数连接到密钥。

**配置轮换并创建空轮换函数**

1. 打开 Secrets Manager 控制台，网址为[https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)。

1. 在**密钥**列表页上，选择您的密钥。

1. 在 **Secret details (密钥详细信息)** 页上的 **Rotation configuration (轮换配置)** 部分中，选择 **Edit rotation (编辑轮换)**。在**编辑轮换配置**对话框中，执行以下操作：

   1. 启用 **Automatic rotation**（自动轮换）。

   1. 在 **Rotation schedule**（轮换计划）下，在 **Schedule expression builder**（计划表达式生成器）或 **Schedule expression**（计划表达式）中，以 UTC 时区格式输入您的计划。Secrets Manager 会将您的计划存储为 `rate()` 或 `cron()` 表达式。轮换时段将自动从午夜开始，除非您指定 **Start time**（开始时间）。您可以每四小时轮换一次密钥。有关更多信息，请参阅 [轮换计划](rotate-secrets_schedule.md)。

   1. （可选）对于 **Window duration**（时段持续时间），选择您希望 Secrets Manager 在其间轮换密钥的时段长度，例如 **3h** 表示三个小时的时段。该时段不得延伸到下一个轮换时段。如果未指定 **Window duration**（时段持续时间），则对于以小时为单位的轮换计划，时段将在一小时后自动关闭。对于以天为单位的轮换计划，时段将在一天结束时自动关闭。

   1. （可选）请选择 **Rotate immediately when the secret is stored**（在存储密钥时立即轮换），以在保存更改时轮换密钥。如果您清除该复选框，则第一次轮换将按照您设置的计划开始。

   1. 在**轮换函数**下，选择在步骤 1 中创建的 Lambda 函数。

   1. 选择**保存**。

## 步骤 4：允许轮换函数访问 Secrets Manager 以及您的数据库或服务


Lambda 轮换函数需要权限才能访问 Secrets Manager 中的密钥，并且需要权限才能访问您的数据库或服务。在此步骤中，您将向 Lambda 执行角色授予这些权限。如果密钥使用 Amazon 托管式密钥 `aws/secretsmanager` 以外的 KMS 密钥进行加密，则您需要向 Lambda 执行角色授予使用该密钥的权限。您可以使用 [SecretARN 加密上下文](security-encryption.md#security-encryption-encryption-context) 来限制解密函数的使用，从而确保轮换函数角色只能解密其负责轮换的密钥。有关策略示例，请参阅 [轮换权限](rotating-secrets-required-permissions-function.md)。

有关说明，请参阅 *Amazon Lambda 开发人员指南*中的 [Lambda 执行角色](https://docs.amazonaws.cn/lambda/latest/dg/lambda-intro-execution-role.html)。

## 步骤 5：允许 Secrets Manager 调用轮换函数


要允许 Secrets Manager 按照您设置的轮换计划调用轮换函数，您需要在 Lambda 函数的资源策略中向 Secrets Manager 服务主体授予 `lambda:InvokeFunction` 权限。

我们建议您在轮换函数的资源策略中包括上下文密钥 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)，以防止 Lambda 被用作[混淆代理](https://docs.amazonaws.cn/IAM/latest/UserGuide/confused-deputy.html)。对于某些 Amazon 服务，为了避免混淆副手的情况， Amazon 建议您同时使用[https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)和[https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)全局条件键。但如果轮换函数策略中包括 `aws:SourceArn` 条件，则轮换函数只能用于轮换该 ARN 指定的密钥。我们建议您仅在其中包括上下文键 `aws:SourceAccount`，以便对多个密钥使用轮换函数。

要将资源策略附加到 Lambda 函数，请参阅[将基于资源的策略用于 Lambda](https://docs.amazonaws.cn/lambda/latest/dg/access-control-resource-based.html)。

以下策略允许 Secrets Manager 调用 Lambda 函数。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Id": "default",
    "Statement": [
    {
        "Effect": "Allow",
        "Principal": {
            "Service": "secretsmanager.amazonaws.com"
            },
        "Action": "lambda:InvokeFunction",
        "Condition": {
            "StringEquals": {
                "AWS:SourceAccount": "123456789012"
            }
        },
        "Resource": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
    }
    ]
}
```

------

## 步骤 6：为轮换函数设置网络访问


在此步骤中，您将允许轮换函数连接到 Secrets Manager 以及该密钥所针对的服务或数据库。旋转函数必须能够访问两者才能轮换密钥。请参阅[Amazon Lambda 轮换功能的网络接入](rotation-function-network-access.md)。

## 后续步骤


当在步骤 3 中配置轮换时，您会设置一个轮换密钥的计划。如果轮换在计划时失败，Secrets Manager 将多次尝试轮换。您也可以按照 [立即轮换密钥](rotate-secrets_now.md) 中的说明立即开始轮换。

如果轮换失败，请参阅 [轮换问题排查](troubleshoot_rotation.md)。

# 使用设置自动旋转 Amazon CLI
自动轮换（Amazon CLI）

本教程介绍如何使用[通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)进行设置 Amazon CLI。轮换密钥时，会同时更新密钥以及拥有密钥的数据库或服务中的凭证。

您也可以使用控制台设置轮换。有关数据库密钥的信息，请参阅 [自动轮换数据库密钥（控制台）](rotate-secrets_turn-on-for-db.md)。有关所有其他类型的密钥，请参阅 [自动轮换非数据库密钥（控制台）](rotate-secrets_turn-on-for-other.md)。

要使用设置轮换 Amazon CLI，如果您要轮换数据库密钥，则首先需要选择轮换策略。如果选择 alternating users strategy（交替用户策略），您必须存储一个单独密钥，其中包含数据库超级用户凭证。接下来，编写轮换函数代码。Secrets Manager 会提供模板，您可以基于该模板创建函数。然后，使用代码创建 Lambda 函数，并为 Lambda 函数和 Lambda 执行角色设置权限。下一步是确保 Lambda 函数可以通过网络访问 Secrets Manager 和数据库或服务。最后，配置密钥以进行轮换。

**Topics**
+ [

## 数据库密钥的先决条件：选择轮换策略
](#rotate-secrets_turn-on-cli_step1)
+ [

## 步骤 1：编写轮换函数代码
](#rotate-secrets_turn-on-cli_write)
+ [

## 第 2 步：创建 Lambda 函数
](#w2aac21c11c25c15)
+ [

## 步骤 3：设置网络访问
](#w2aac21c11c25c17)
+ [

## 步骤 4：配置要轮换的密钥
](#w2aac21c11c25c19)
+ [

## 后续步骤
](#w2aac21c11c25c21)

## 数据库密钥的先决条件：选择轮换策略


有关 Secrets Manager 提供的策略的信息，请参阅 [Lambda 函数轮换策略](rotation-strategy.md)。

### 选项 1：单用户策略


如果选择*单用户策略*，则可以继续执行步骤 1。

### 选项 2：交替用户策略


如果选择*交替用户策略*，则必须：
+ [创建一个密钥](create_secret.md#create_secret_cli)并在其中存储数据库超级用户凭证。您需要一个包含超级用户凭证的密钥，因为交替用户轮换会克隆第一个用户，而大多数用户没有该权限。
+ 将超级用户密钥的 ARN 添加到原始密钥。有关更多信息，请参阅 [Amazon Secrets Manager 密钥的 JSON 结构](reference_secret_json_structure.md)。

请注意，Amazon RDS 代理不支持交替用户策略。

## 步骤 1：编写轮换函数代码


要轮换密钥，您需要轮换函数。轮换函数是 Secrets Manager 为轮换密钥而调用的 Lambda 函数。有关更多信息，请参阅 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)。在此步骤中，您将编写用于更新密钥以及该密钥所针对的服务或数据库的代码。

Secrets Manager 在 [轮换函数模板](reference_available-rotation-templates.md) 中提供了 Amazon RDS、Amazon Aurora、Amazon Redshift 和 Amazon DocumentDB 数据库密钥的模板。

**编写轮换函数代码**

1. 请执行以下操作之一：
   + 查看[轮换函数模板](reference_available-rotation-templates.md)列表。如果有与您的服务和轮换策略匹配的模板，请复制代码。
   + 对于其他类型的密钥，请编写您自己的轮换函数。有关说明，请参阅[Lambda 轮换函数](rotate-secrets_lambda-functions.md)。

1. 将该文件*my-function.zip*连同所有必需的依赖项一起保存在 ZIP 文件中。

## 第 2 步：创建 Lambda 函数


在此步骤中，您将使用在步骤 1 中创建的 ZIP 文件创建 Lambda 函数。您还将设置 [Lambda 执行角色](https://docs.amazonaws.cn/lambda/latest/dg/lambda-intro-execution-role.html)，即调用函数时 Lambda 代入的角色。

**创建 Lambda 轮换函数和执行角色**

1. 为 Lambda 执行角色创建信任策略并将其另存为 JSON 文件。有关示例和更多信息，请参阅 [Lambda 轮换函数的执行角色权限 Amazon Secrets Manager](rotating-secrets-required-permissions-function.md)。该策略必须：
   + 允许角色对密钥调用 Secrets Manager 操作。
   + 允许角色调用密钥所针对的服务，例如创建新密码。

1. 通过调用 [https://docs.amazonaws.cn/cli/latest/reference/iam/create-role.html](https://docs.amazonaws.cn/cli/latest/reference/iam/create-role.html) 来创建 Lambda 执行角色并应用在上一步中创建的信任策略。

   ```
   aws iam create-role \
       --role-name rotation-lambda-role \
       --assume-role-policy-document file://trust-policy.json
   ```

1. 通过调用 [https://docs.amazonaws.cn/cli/latest/reference/lambda/create-function.html](https://docs.amazonaws.cn/cli/latest/reference/lambda/create-function.html) 从 ZIP 文件创建 Lambda 函数。

   ```
   aws lambda create-function \
     --function-name my-rotation-function \
     --runtime python3.7 \
     --zip-file fileb://my-function.zip \
     --handler .handler \
     --role arn:aws:iam::123456789012:role/service-role/rotation-lambda-role
   ```

1. 在 Lambda 函数上设置资源策略，以允许 Secrets Manager 通过调用 [https://docs.amazonaws.cn/cli/latest/reference/lambda/add-permission.html](https://docs.amazonaws.cn/cli/latest/reference/lambda/add-permission.html) 来调用该资源策略。

   ```
   aws lambda add-permission \
     --function-name my-rotation-function \
     --action lambda:InvokeFunction \
     --statement-id SecretsManager \
     --principal secretsmanager.amazonaws.com \
     --source-account 123456789012
   ```

## 步骤 3：设置网络访问


有关更多信息，请参阅 [Amazon Lambda 轮换功能的网络接入](rotation-function-network-access.md)。

## 步骤 4：配置要轮换的密钥


要为密钥开启自动轮换功能，请调用 [https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/rotate-secret.html](https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/rotate-secret.html)。您可以使用 `cron()` 或 `rate()` 计划表达式设置轮换计划，也可以设置轮换时段持续时间。有关更多信息，请参阅 [轮换计划](rotate-secrets_schedule.md)。

```
aws secretsmanager rotate-secret \
    --secret-id MySecret \
    --rotation-lambda-arn arn:aws:lambda:Region:123456789012:function:my-rotation-function \
    --rotation-rules "{\"ScheduleExpression\": \"cron(0 16 1,15 * ? *)\", \"Duration\": \"2h\"}"
```

## 后续步骤


请参阅[排除 Amazon Secrets Manager 轮换故障](troubleshoot_rotation.md)。

# Lambda 函数轮换策略


对于 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)，对于数据库密钥，Secrets Manager 提供了两种轮换策略。

## 轮换策略：单用户
单用户

此策略在一个密钥中更新一个用户的凭证。对于 Amazon RDS Db2 实例，由于用户无法更改自己的密码，因此您必须在单独的秘密中提供管理员凭证。**这是最简单的轮换策略，适用于大多数使用场景。**具体而言，建议您为一次性（临时）用户或交互式用户的凭证使用此策略。

轮换密钥时，不会删除打开的数据库连接。在进行轮换时，在数据库中的密码更改后一小段时间，相应的密码才会更新。在此期间，数据库有较低的风险拒绝使用轮换凭证的调用。您可以使用[适当的重试策略](https://www.amazonaws.cn/blogs/architecture/exponential-backoff-and-jitter/)来降低风险。轮换后，新连接将使用新凭证。

## 轮换策略：交替用户
交替用户

此策略在一个密钥中更新两个用户的凭证。您创建第一个用户，然后在第一次轮换期间，轮换函数将进行克隆以创建第二个用户。每次轮换密钥时，轮换函数都会交替更新其更新的用户密码。由于大多数用户无权克隆自己，因此您必须在另一个密钥中为 `superuser` 提供凭证。如果数据库中的克隆用户与原始用户具有的权限不同，或者涉及一次性（临时）用户或交互式用户的凭证，我们建议使用单用户轮换策略。

此策略适用于具有权限模型的数据库，其中一个角色拥有数据库表，而另一个角色具有访问数据库表的权限。其也适用于需要高可用性的应用程序。如果应用程序在轮换期间检索密钥，则该应用程序仍会获得一组有效的凭证。轮换后，`user` 和 `user_clone` 凭证均有效。在这种类型的轮换期间，应用程序获得拒绝的可能性甚至比单用户轮换获得拒绝的可能性更小。如果数据库托管在服务器场中，密码更改需要时间传播到所有服务器，则存在数据库拒绝使用新凭证的调用的风险。您可以使用[适当的重试策略](https://www.amazonaws.cn/blogs/architecture/exponential-backoff-and-jitter/)来降低风险。

Secrets Manager 将创建权限与原始用户相同的克隆用户。如果您在创建克隆用户后更改了原始用户的权限，则还必须更改克隆用户的权限。

例如，假设您使用某个数据库用户的凭证创建了一个密钥，则该密钥包含一个带有这些凭证的版本。

 ![\[The secret contains one secret version labeled AWSCURRENT. The username for the AWSCURRENT version is MyUser.\]](http://docs.amazonaws.cn/secretsmanager/latest/userguide/images/AlternatingUsers1.png) 

**第一次轮换** – 轮换函数使用生成的密码创建克隆用户，这些凭证将成为当前的密钥版本。

 ![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser_clone.\]](http://docs.amazonaws.cn/secretsmanager/latest/userguide/images/AlternatingUsers2.png) 

**第二次轮换** – 轮换函数更新原始用户的密码。

 ![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser.\]](http://docs.amazonaws.cn/secretsmanager/latest/userguide/images/AlternatingUsers3.png) 

**第三次轮换** – 轮换函数更新克隆用户的密码。

 ![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser_clone.\]](http://docs.amazonaws.cn/secretsmanager/latest/userguide/images/AlternatingUsers4.png) 

# Lambda 轮换函数


在中[通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)， Amazon Lambda 函数轮换密钥。 Amazon Secrets Manager 在轮换期间使用[暂存标签](whats-in-a-secret.md)来识别秘密版本。

如果 Amazon Secrets Manager 没有为您的密钥类型提供[轮换函数模板](reference_available-rotation-templates.md)，则可以创建自定义轮换函数。编写轮换函数时请遵循以下准则：

**自定义轮换函数的最佳实践**
+ 使用[常规轮换模板](reference_available-rotation-templates.md#OTHER_rotation_templates)作为起点。
+ 谨慎使用调试或日志记录语句。他们可以将信息写入 Amazon CloudWatch 日志。确保日志不包含敏感信息。

  有关日志语句的示例，请参阅 [Amazon Secrets Manager 旋转函数模板](reference_available-rotation-templates.md) 源代码。
+ 为了安全起见， Amazon Secrets Manager 仅允许 Lambda 轮换函数直接轮换密钥。轮换函数无法调用另一个 Lambda 函数来轮换密钥。
+ 有关调试指南，请参阅[测试和调试无服务器应用程序](https://docs.amazonaws.cn/serverless-application-model/latest/developerguide/serverless-test-and-debug.html)。
+ 例如，如果您使用外部二进制文件和库来连接资源，则需要负责对其进行修补和更新。
+ Package 将旋转函数和所有依赖项打包到 ZIP 文件中，例如*my-function.zip*。

**警告**  
由于 Lambda 函数的执行线程不足，将预置的并发参数设置为低于 10 的值可能会导致节流。有关更多信息，请参阅《 Amazon Lambda Amazon Lambda 开发人员指南》中的[了解预留并发和预置并发](https://docs.amazonaws.cn/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned)。

## 轮换函数的四个步骤


**Topics**
+ [

### `createSecret`：创建密钥的新版本
](#w2aac21c11c29c11b5)
+ [

### **setSecret**：更改数据库或服务中的凭证
](#w2aac21c11c29c11b7)
+ [

### **testSecret**：测试新的密钥版本
](#w2aac21c11c29c11b9)
+ [

### **finishSecret**：完成轮换
](#w2aac21c11c29c11c11)

### `createSecret`：创建密钥的新版本


方法 `createSecret` 首先通过使用传入的 `ClientRequestToken` 调用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_secret_value](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_secret_value) 来检查密钥是否存在。如果没有密钥，它会使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.create_secret](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.create_secret) 创建一个新密钥，并将令牌作为 `VersionId`。然后它使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_random_password](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_random_password) 生成一个新的密钥值。接下来，它调用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.put_secret_value](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.put_secret_value) 以将其与暂存标签 `AWSPENDING` 一起存储。将新的密钥值存储在 `AWSPENDING` 中有助于确保幂等性。如果由于任何原因轮换失败，您可以在后续调用中引用该密钥值。请参阅[如何使我的 Lambda 函数具有幂等性](https://www.amazonaws.cn/premiumsupport/knowledge-center/lambda-function-idempotent/)。

**编写自己的轮换函数的技巧**
+ 确保新的密钥值仅包含对数据库或服务有效的字符。使用 `ExcludeCharacters` 参数排除字符。
+ 在测试函数时，使用查看版本阶段：调用[https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/describe-secret.html](https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/describe-secret.html)并查看`VersionIdsToStages`。 Amazon CLI 
+ 对于 Amazon RDS MySQL，在交替用户轮换中，Secrets Manager 会创建一个名称不超过 16 个字符的克隆用户。您可以修改轮换函数以允许使用更长的用户名。MySQL 5.7 及更高版本支持最多 32 个字符的用户名，但 Secrets Manager 会在用户名末尾附加“\$1clone”（六个字符），因此用户名最多必须保持在 26 个字符以内。

### **setSecret**：更改数据库或服务中的凭证


方法 `setSecret` 更改数据库或服务中的凭证以匹配密钥的 `AWSPENDING` 版本中的新密钥值。

**编写自己的轮换函数的技巧**
+ 如果将语句传递给解释语句的服务（如数据库），请使用查询参数化。有关更多信息，请参阅 *OWASP 网站*上的 [Query Parameterization Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Query_Parameterization_Cheat_Sheet.html)。
+ 轮换函数作为特权代理，有权访问和修改 Secrets Manager 密钥和目标资源中的客户凭证。为防范潜在的[混淆代理攻击](https://docs.amazonaws.cn/IAM/latest/UserGuide/confused-deputy.html)，您需要确保攻击者无法使用该函数访问其他资源。在更新凭证之前：
  + 检查密钥 `AWSCURRENT` 版本中的凭证是否有效。如果 `AWSCURRENT` 凭证无效，请放弃轮换尝试。
  + 检查 `AWSCURRENT` 和 `AWSPENDING` 密钥值是否适用于同一资源。对于用户名和密码，检查 `AWSCURRENT` 和 `AWSPENDING` 用户名是否相同。
  + 检查目标服务资源是否相同。对于数据库，检查 `AWSCURRENT` 和 `AWSPENDING` 主机名是否相同。
+ 在极少数情况下，您可能希望为数据库自定义现有轮换功能。例如，对于交替用户轮换，Secrets Manager 通过复制第一个用户的[运行时配置参数](https://www.postgresql.org/docs/8.0/runtime-config.html)来创建克隆用户。如果要包含更多属性，或更改授予克隆用户的属性，则需要更新 `set_secret` 函数中的代码。

### **testSecret**：测试新的密钥版本


然后，Lambda 轮换函数将使用该密钥来访问数据库或服务，从而测试密钥的 `AWSPENDING` 版本。基于 [轮换函数模板](reference_available-rotation-templates.md) 测试的轮换函数使用读取访问权限测试新的密钥。

### **finishSecret**：完成轮换


最后，Lambda 轮换函数将标签 `AWSCURRENT` 从之前的密钥版本移动到此版本，这将同时在同一 API 调用中移除 `AWSPENDING` 标签。Secrets Manager 添加 `AWSPREVIOUS` 暂存标注到以前的版本，以便您保留密钥的上次已知良好的版本。

方法 **finish\$1secret** 使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.update_secret_version_stage](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.update_secret_version_stage) 将暂存标签 `AWSCURRENT` 从早期密钥版本移动到新的密钥版本。Secrets Manager 会将 `AWSPREVIOUS` 暂存标签自动添加到早期版本，以便您保留上次已知良好的密钥版本。

**编写自己的轮换函数的技巧**
+ 在此之前请不要移除 `AWSPENDING`，也不要使用单独的 API 调用将其移除，因为这可能向 Secrets Manager 表明轮换未成功完成。Secrets Manager 添加 `AWSPREVIOUS` 暂存标注到以前的版本，以便您保留密钥的上次已知良好的版本。

成功轮换后，`AWSPENDING` 暂存标签可能附加到与 `AWSCURRENT` 版本相同的版本，也可能未附加到任何版本。如果 `AWSPENDING` 暂存标签存在但未附加到与 `AWSCURRENT` 相同的版本，则以后对轮换的任何调用都假定先前的轮换请求仍在进行中并返回错误。轮换不成功时，`AWSPENDING` 暂存标签可能会附加到空密钥版本。有关更多信息，请参阅 [轮换问题排查](troubleshoot_rotation.md)。

# Amazon Secrets Manager 旋转函数模板
轮换函数模板

Amazon Secrets Manager 提供了一组轮换函数模板，可帮助自动对各种数据库系统和服务的凭据进行安全管理。这些模板是 ready-to-use Lambda 函数，它们实现了证书轮换的最佳实践，可帮助您在无需人工干预的情况下保持安全状态。

这些模板支持两种主要的轮换策略：
+ *单用户轮换*，用于更新单个用户的凭证。
+ *交替用户轮换*，可保留两个独立的用户，以帮助消除凭证更改期间的停机时间。

Secrets Manager 还提供一个通用模板作为任何类型密钥的起点。

若要使用模板，请参阅：
+ [自动轮换数据库密钥（控制台）](rotate-secrets_turn-on-for-db.md)
+ [自动轮换非数据库密钥（控制台）](rotate-secrets_turn-on-for-other.md)

要编写自己的轮换函数，请参阅 [Write a rotation function](rotate-secrets_lambda-functions.md)。

**Contents**
+ [

## Amazon RDS 和 Amazon Aurora
](#RDS_rotation_templates)
  + [

### Amazon RDS Db2 单用户
](#sar-template-db2-singleuser)
  + [

### Amazon RDS Db2 交替用户
](#sar-template-db2-multiuser)
  + [

### Amazon RDS MariaDB 单用户
](#sar-template-mariadb-singleuser)
  + [

### Amazon RDS MariaDB 交替用户
](#sar-template-mariadb-multiuser)
  + [

### Amazon RDS 和 Amazon Aurora MySQL 单用户
](#sar-template-mysql-singleuser)
  + [

### Amazon RDS 和 Amazon Aurora MySQL 交替用户
](#sar-template-mysql-multiuser)
  + [

### Amazon RDS Oracle 单用户
](#sar-template-oracle-singleuser)
  + [

### Amazon RDS Oracle 交替用户
](#sar-template-oracle-multiuser)
  + [

### Amazon RDS 和 Amazon Aurora PostgreSQL 单用户
](#sar-template-postgre-singleuser)
  + [

### Amazon RDS 和 Amazon Aurora PostgreSQL 交替用户
](#sar-template-postgre-multiuser)
  + [

### 亚马逊 RDS 微软 SQLServer 单用户
](#sar-template-sqlserver-singleuser)
  + [

### 亚马逊 RDS 微软 SQLServer 交替用户
](#sar-template-sqlserver-multiuser)
+ [

## Amazon DocumentDB（兼容 MongoDB）
](#NON-RDS_rotation_templates)
  + [

### Amazon DocumentDB 单个用户
](#sar-template-mongodb-singleuser)
  + [

### Amazon DocumentDB 交替用户
](#sar-template-mongodb-multiuser)
+ [

## Amazon Redshift
](#template-redshift)
  + [

### Amazon Redshift 单用户
](#sar-template-redshift-singleuser)
  + [

### Amazon Redshift 交替用户
](#sar-template-redshift-multiuser)
+ [

## Amazon Timestream for InfluxDB
](#template-TimeStream)
  + [

### Amazon Timestream for InfluxDB 单用户
](#template-TimeStream-singleuser)
  + [

### Amazon Timestream for InfluxDB 交替用户
](#template-TimeStream-multiuser)
+ [

## Amazon ElastiCache
](#template-ELC)
+ [

## Active Directory
](#template-AD)
  + [

### Active Directory 凭证
](#template-AD-password)
  + [

### Active Directory keytab
](#template-AD-keytab)
+ [

## 其他密钥类型
](#OTHER_rotation_templates)

## Amazon RDS 和 Amazon Aurora


### Amazon RDS Db2 单用户

+ **模板名称：** SecretsManagerRDSDb2RotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **`SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationSingleUser/lambda_function.py)
+ **依赖关系：**[python-ibmdb](https://github.com/ibmdb/python-ibmdb)

### Amazon RDS Db2 交替用户

+ **模板名称：** SecretsManagerRDSDb2RotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **`SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationMultiUser/lambda_function.py)
+ **依赖关系：**[python-ibmdb](https://github.com/ibmdb/python-ibmdb)

### Amazon RDS MariaDB 单用户

+ **模板名称：** SecretsManagerRDSMariaDBRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **`SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationSingleUser/lambda_function.py)
+ **依赖关系：**PyMySQL 1.0.2。如果你使用 sha256 密码进行身份验证，则为 PyMy SQL [rsa]。有关在 Lambda 运行时中使用含编译代码的包的信息，请参阅 *Amazon 知识中心* 中的[如何将含已编译二进制文件的 Python 包添加到我的部署包，并使该包与 Lambda 兼容？](https://repost.aws/knowledge-center/lambda-python-package-compatible)。

### Amazon RDS MariaDB 交替用户

+ **模板名称：** SecretsManagerRDSMariaDBRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **`SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationMultiUser/lambda_function.py)
+ **依赖关系：**PyMySQL 1.0.2。如果你使用 sha256 密码进行身份验证，则为 PyMy SQL [rsa]。有关在 Lambda 运行时中使用含编译代码的包的信息，请参阅 *Amazon 知识中心* 中的[如何将含已编译二进制文件的 Python 包添加到我的部署包，并使该包与 Lambda 兼容？](https://repost.aws/knowledge-center/lambda-python-package-compatible)。

### Amazon RDS 和 Amazon Aurora MySQL 单用户

+ **模板名称：** SecretsManagerRDSMySQLRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationSingleUser/lambda_function.py)
+ **依赖关系：**PyMySQL 1.0.2。如果你使用 sha256 密码进行身份验证，则为 PyMy SQL [rsa]。有关在 Lambda 运行时中使用含编译代码的包的信息，请参阅 *Amazon 知识中心* 中的[如何将含已编译二进制文件的 Python 包添加到我的部署包，并使该包与 Lambda 兼容？](https://repost.aws/knowledge-center/lambda-python-package-compatible)。

### Amazon RDS 和 Amazon Aurora MySQL 交替用户

+ **模板名称：** SecretsManagerRDSMySQLRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationMultiUser/lambda_function.py)
+ **依赖关系：**PyMySQL 1.0.2。如果你使用 sha256 密码进行身份验证，则为 PyMy SQL [rsa]。有关在 Lambda 运行时中使用含编译代码的包的信息，请参阅 *Amazon 知识中心* 中的[如何将含已编译二进制文件的 Python 包添加到我的部署包，并使该包与 Lambda 兼容？](https://repost.aws/knowledge-center/lambda-python-package-compatible)。

### Amazon RDS Oracle 单用户

+ **模板名称：** SecretsManagerRDSOracleRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationSingleUser/lambda_function.py)
+ **依赖项：**[python-oracledb 2.4.1](https://github.com/oracle/python-oracledb)

### Amazon RDS Oracle 交替用户

+ **模板名称：** SecretsManagerRDSOracleRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationMultiUser/lambda_function.py)
+ **依赖项：**[python-oracledb 2.4.1](https://github.com/oracle/python-oracledb)

### Amazon RDS 和 Amazon Aurora PostgreSQL 单用户

+ **模板名称：** SecretsManagerRDSPostgreSQLRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationSingleUser/lambda_function.py)
+ **依赖关系：**PyGreSQL 5.2.5

### Amazon RDS 和 Amazon Aurora PostgreSQL 交替用户

+ **模板名称：** SecretsManagerRDSPostgreSQLRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationMultiUser/lambda_function.py)
+ **依赖关系：**PyGreSQL 5.2.5

### 亚马逊 RDS 微软 SQLServer 单用户

+ **模板名称：** SecretsManagerRDSSQLServerRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationSingleUser/lambda_function.py)
+ **依赖关系：**Pymssql 2.2.2

### 亚马逊 RDS 微软 SQLServer 交替用户

+ **模板名称：** SecretsManagerRDSSQLServerRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon RDS 和 Aurora 凭证](reference_secret_json_structure.md#reference_secret_json_structure_rds)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationMultiUser/lambda_function.py)
+ **依赖关系：**Pymssql 2.2.2

## Amazon DocumentDB（兼容 MongoDB）
Amazon DocumentDB

### Amazon DocumentDB 单个用户

+ **模板名称：** SecretsManagerMongoDBRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon DocumentDB 凭证](reference_secret_json_structure.md#reference_secret_json_structure_docdb)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationSingleUser/lambda_function.py)
+ **依赖关系：**PyMongo 4.2.0

### Amazon DocumentDB 交替用户

+ **模板名称：** SecretsManagerMongoDBRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon DocumentDB 凭证](reference_secret_json_structure.md#reference_secret_json_structure_docdb)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationMultiUser/lambda_function.py)
+ **依赖关系：**PyMongo 4.2.0

## Amazon Redshift


### Amazon Redshift 单用户

+ **模板名称：** SecretsManagerRedshiftRotationSingleUser
+ **轮换策略：** [轮换策略：单用户](rotation-strategy.md#rotating-secrets-one-user-one-password)。
+ **预期的 `SecretString` 结构：**[Amazon Redshift 凭证](reference_secret_json_structure.md#reference_secret_json_structure_RS)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationSingleUser/lambda_function.py)
+ **依赖关系：**PyGreSQL 5.2.5

### Amazon Redshift 交替用户

+ **模板名称：** SecretsManagerRedshiftRotationMultiUser
+ **轮换策略：** [轮换策略：交替用户](rotation-strategy.md#rotating-secrets-two-users)。
+ **预期的 `SecretString` 结构：**[Amazon Redshift 凭证](reference_secret_json_structure.md#reference_secret_json_structure_RS)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationMultiUser/lambda_function.py)
+ **依赖关系：**PyGreSQL 5.2.5

## Amazon Timestream for InfluxDB


要使用这些模板，请参阅《*Amazon Timestream 开发人员指南*》中的 [Amazon Timestream for InfluxDB 如何使用密钥](https://docs.amazonaws.cn/timestream/latest/developerguide/timestream-for-influx-security-db-secrets.html)。

### Amazon Timestream for InfluxDB 单用户

+ **模板名称：** SecretsManagerInflux DBRotation SingleUser
+ **预期的 `SecretString` 结构：**[Amazon Timestream for InfluxDB 密钥结构](reference_secret_json_structure.md#reference_secret_json_structure_TIME)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationSingleUser/lambda_function.py)
+ **依赖项：**InfluxDB 2.0 python 客户端

### Amazon Timestream for InfluxDB 交替用户

+ **模板名称：** SecretsManagerInfluxDBRotationMultiUser
+ **预期的 `SecretString` 结构：**[Amazon Timestream for InfluxDB 密钥结构](reference_secret_json_structure.md#reference_secret_json_structure_TIME)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationMultiUser/lambda_function.py)
+ **依赖项：**InfluxDB 2.0 python 客户端

## Amazon ElastiCache


要使用此模板，请参阅 *Amazon 用户指南中的自动轮换 ElastiCache 用户*[密码](https://docs.amazonaws.cn/AmazonElastiCache/latest/red-ug/User-Secrets-Manager.html)。
+ **模板名称：** SecretsManagerElasticacheUserRotation
+ **预期的 `SecretString` 结构：**[Amazon ElastiCache 凭证](reference_secret_json_structure.md#reference_secret_json_structure_ELC)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerElasticacheUserRotation/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerElasticacheUserRotation/lambda_function.py)

## Active Directory


### Active Directory 凭证

+ **模板名称：** SecretsManagerActiveDirectoryRotationSingleUser
+ **预期的 `SecretString` 结构：**[Active Directory 凭证](reference_secret_json_structure.md#reference_secret_json_structure_AD)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryRotationSingleUser/lambda_function.py)

### Active Directory keytab

+ **模板名称：** SecretsManagerActiveDirectoryAndKeytabRotationSingleUser
+ **预期的 `SecretString` 结构：**[Active Directory 凭证](reference_secret_json_structure.md#reference_secret_json_structure_AD)。
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryAndKeytabRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryAndKeytabRotationSingleUser/lambda_function.py)
+ **依赖项：**msktutil

## 其他密钥类型


Secrets Manager 提供此模板作为您为任何类型密钥创建轮换函数的起点。
+ **模板名称：** SecretsManagerRotationTemplate
+ **源代码：https://github.com/aws-samples/**[aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRotationTemplate/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRotationTemplate/lambda_function.py)

# Lambda 轮换函数的执行角色权限 Amazon Secrets Manager
轮换权限

对于 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)，当 Secrets Manager 使用 Lambda 函数轮换密钥时，Lambda 将代入 [IAM 执行角色](https://docs.amazonaws.cn/lambda/latest/dg/lambda-intro-execution-role.html)并将这些凭证提供给 Lambda 函数代码。有关如何设置自动轮换的说明，请参阅：
+ [自动轮换数据库密钥（控制台）](rotate-secrets_turn-on-for-db.md)
+ [自动轮换非数据库密钥（控制台）](rotate-secrets_turn-on-for-other.md)
+ [自动轮换（Amazon CLI）](rotate-secrets_turn-on-cli.md)

以下示例显示了适用于 Lambda 轮换函数执行角色的内联策略。要创建执行角色并附加权限策略，请参阅 [Amazon Lambda 执行角色](https://docs.amazonaws.cn/lambda/latest/dg/lambda-intro-execution-role.html)。

**Topics**
+ [

## 适用于 Lambda 轮换函数执行角色的策略
](#rotating-secrets-required-permissions-function-example)
+ [

## 适用于客户托管密钥的策略语句
](#rotating-secrets-required-permissions-function-cust-key-example)
+ [

## 适用于交替用户策略的策略语句
](#rotating-secrets-required-permissions-function-alternating-example)

## 适用于 Lambda 轮换函数执行角色的策略


以下示例策略允许轮换函数：
+ 运行 Secrets Manager 的操作*SecretARN*。
+ 创建新密码。
+ 如果数据库或服务在 VPC 中运行，则设置所需的配置。请参阅[配置 Lambda 函数以访问 VPC 中的资源](https://docs.amazonaws.cn/lambda/latest/dg/configuration-vpc.html)。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:DescribeSecret",
                "secretsmanager:GetSecretValue",
                "secretsmanager:PutSecretValue",
                "secretsmanager:UpdateSecretVersionStage"
            ],
            "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
    },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetRandomPassword"
            ],
            "Resource": "*"
        },
        {
            "Action": [
                "ec2:CreateNetworkInterface",
                "ec2:DeleteNetworkInterface",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DetachNetworkInterface"
            ],
            "Resource": "*",
            "Effect": "Allow"
        }
    ]
}
```

------

## 适用于客户托管密钥的策略语句


如果密钥使用 Amazon 托管式密钥 `aws/secretsmanager` 以外的 KMS 密钥进行加密，则您需要向 Lambda 执行角色授予使用该密钥的权限。您可以使用 [SecretARN 加密上下文](security-encryption.md#security-encryption-encryption-context) 来限制解密函数的使用，从而确保轮换函数角色只能解密其负责轮换的密钥。以下示例演示了要添加到执行角色策略中，以使用 KMS 密钥将密钥解密的语句。

```
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:DescribeKey",
                "kms:GenerateDataKey"
            ],
            "Resource": "KMSKeyARN",
            "Condition": {
                "StringEquals": {
                    "kms:EncryptionContext:SecretARN": "SecretARN"
                }
            }
        }
```

要对使用客户托管密钥加密的多个密钥使用轮换函数，请添加如下示例所示的语句以允许执行角色解密该密钥。

```
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:DescribeKey",
                "kms:GenerateDataKey"
            ],
            "Resource": "KMSKeyARN",
            "Condition": {
                "StringEquals": {
                    "kms:EncryptionContext:SecretARN": [
                        "arn1",
                        "arn2"
                    ]
                }
            }
        }
```

## 适用于交替用户策略的策略语句


有关*交替用户轮换策略*的信息，请参阅 [Lambda 函数轮换策略](rotation-strategy.md)。

对于包含 Amazon RDS 凭证的密钥，如果您使用的是交替用户策略，并且超级用户密钥[由 Amazon RDS 管理](rotate-secrets_managed.md)，则还必须允许轮换函数在 APIs Amazon RDS 上以只读方式调用，这样它才能获取数据库的连接信息。我们建议您附上 Amazon 托管政策 [Amazon RDSRead OnlyAccess](https://docs.amazonaws.cn/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html)。

以下示例策略允许函数：
+ 运行 Secrets Manager 的操作*SecretARN*。
+ 在超级用户密钥中检索凭证。Secrets Manager 会使用超级用户密钥中的凭证更新轮换密钥中的凭证。
+ 创建新密码。
+ 如果数据库或服务在 VPC 中运行，则设置所需的配置。有关更多信息，请参阅[配置 Lambda 函数以访问 VPC 中的资源](https://docs.amazonaws.cn/lambda/latest/dg/vpc.html)。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:DescribeSecret",
                "secretsmanager:GetSecretValue",
                "secretsmanager:PutSecretValue",
                "secretsmanager:UpdateSecretVersionStage"
            ],
            "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
    },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue"
            ],
            "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
    },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetRandomPassword"
            ],
            "Resource": "*"
        },
        {
            "Action": [
                "ec2:CreateNetworkInterface",
                "ec2:DeleteNetworkInterface",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DetachNetworkInterface"
            ],
            "Resource": "*",
            "Effect": "Allow"
        }
    ]
}
```

------

# Amazon Lambda 轮换功能的网络接入


对于 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)，当 Secrets Manager 使用 Lambda 函数轮换密钥时，Lambda 轮换函数必须能够访问该密钥。如果您的密钥包含凭证，则 Lambda 函数还必须能够访问这些凭证的来源，例如数据库或服务。

**访问密钥**  
Lambda 轮换功能必须能够访问 Secrets Manager 端点。如果您的 Lambda 函数可以访问互联网，则可以使用公共端点。若要查找端点，请参阅 [Amazon Secrets Manager 端点](asm_access.md#endpoints)。  
如果您的 Lambda 函数在不具备互联网访问权限的 VPC 中运行，我们建议您在 VPC 内配置 Secrets Manager 服务私有端点。然后，您的 VPC 可以拦截发往公共区域端点的请求并将其重定向到私有端点。有关更多信息，请参阅 [VPC 端点（Amazon PrivateLink）](vpc-endpoint-overview.md)。  
或者，您可以通过向 VPC 添加 [NAT 网关](https://docs.amazonaws.cn/vpc/latest/userguide/vpc-nat-gateway.html)或[互联网网关](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_Internet_Gateway.html)（这将允许来自您 VPC 的流量访问公有端点），允许 Lambda 函数访问 Secrets Manager 公有端点。这会使 VPC 面临一定的风险，因为网关的 IP 地址可能会受到来自公有 Internet 的攻击。

**（可选）访问数据库或服务**  
对于诸如 API 密钥之类的密钥，无需随密钥更新源数据库或服务。  
如果您的数据库或服务在 VPC 中的 Amazon EC2 实例上运行，我们建议您将您的 Lambda 函数配置为在同一 VPC 中运行。然后轮换功能可以直接与您的服务通信。有关更多信息，请参阅[配置 VPC 访问](https://docs.amazonaws.cn/lambda/latest/dg/configuration-vpc.html#vpc-configuring)。  
要允许 Lambda 函数访问数据库或服务，您必须确保附加到 Lambda 轮换函数的安全组允许与数据库或服务的出站连接。您还必须确保附加到数据库或服务的安全组允许来自 Lambda 轮换函数进行入站连接。

# 排除 Amazon Secrets Manager 轮换故障
轮换问题排查

对于许多服务，Secrets Manager 使用 Lambda 函数来轮换密钥。有关更多信息，请参阅 [通过 Lambda 函数进行轮换](rotate-secrets_lambda.md)。Lambda 轮换函数与拥有密钥的数据库或服务以及 Secrets Manager 交互。当轮换无法按预期进行时，应先检查日 CloudWatch 志。

**注意**  
某些服务可以为您管理密钥，包括管理自动轮换。有关更多信息，请参阅 [Amazon Secrets Manager 密钥的托管轮换](rotate-secrets_managed.md)。

**Topics**
+ [

## 如何对函数中的密钥轮换失败进行 Amazon Lambda 故障排除
](#troubleshooting-secret-rotation-failures)
+ [

## “在环境变量中找到凭证”之后没有活动
](#troubleshoot_rotation_timing-out)
+ [

## “createSecret”之后没有活动
](#troubleshoot_rotation_createSecret)
+ [

## 错误：“不允许访问 KMS”
](#troubleshoot_rotation_kms-key)
+ [

## 错误：“Key is missing from secret JSON（密钥 JSON 中缺少密钥）”
](#tshoot-lambda-mismatched-secretvalue)
+ [

## 错误：“setSecret: Unable to log into database（setSecret：无法登录数据库）”
](#troubleshoot_rotation_setSecret)
+ [

## 错误：“无法导入模块‘lambda\$1function’”
](#tshoot-python-version)
+ [

## 将现有的轮换函数版本从 Python 3.7 升级到 Python 3.9
](#troubleshoot_rotation_python39)
+ [

## 将现有的轮换函数版本从 Python 3.9 升级到 Python 3.10
](#troubleshoot_rotation_python_310)
+ [

## Amazon Lambda 秘密轮换`PutSecretValue`失败
](#troubleshoot_rotation_putsecretvalue)
+ [

## 错误：“*<arn>*在*<a rotation>*步骤中执行 lambda 时出错”
](#concurrency-related-failures)

## 如何对函数中的密钥轮换失败进行 Amazon Lambda 故障排除
故障排除步骤

如果您的 Lambda 函数遇到密钥轮换失败，请遵循以下步骤排查并解决问题。

### 可能的原因

+ Lambda 函数的并发执行次数不足
+ 由于轮换期间的多个 API 调用而导致出现争用情况
+ Lambda 函数逻辑不正确
+ Lambda 函数和数据库之间存在联网问题

### 一般故障排除步骤


1. 分析 CloudWatch 日志：
   + 在 Lambda 函数日志中查找特定的错误消息或意外行为
   + 验证是否正在尝试所有轮换步骤（**CreateSecret**、**SetSecret**、**TestSecret**、**FinishSecret**）

1. 审核轮换期间的 API 调用：
   + 避免在 Lambda 轮换期间对密钥进行可变 API 调用
   + 确保 **RotateSecret** 和 **PutSecretValue** 调用之间没有争用情况

1. 验证 Lambda 函数逻辑：
   + 确认你使用的是最新的密钥轮换 Amazon 示例代码
   + 如果使用自定义代码，请审核代码以正确处理所有轮换步骤

1. 检查网络配置：
   + 验证安全组规则是否允许 Lambda 函数访问数据库
   + 确保 Secrets Manager 能够正确访问 VPC 端点或公有端点

1. 测试密钥版本：
   + 验证密钥的 AWSCURRENT 版本是否允许访问数据库
   + 检查 AWSPREVIOUS 或 AWSPENDING 版本是否有效

1. 清除待处理的轮换：
   + 如果轮换一直失败，请清除 AWSPENDING 暂存标签并重试轮换

1. 检查 Lambda 并发设置：
   + 验证并发设置是否适合您的工作负载
   + 如果您怀疑存在并发问题，请参阅“排查并发相关的轮换故障”部分

## “在环境变量中找到凭证”之后没有活动


如果“在环境变量中找到凭证”之后没有活动，并且任务持续时间很长，例如默认 Lambda 超时为 30000 毫秒，则 Lambda 函数可能会在尝试访问 Secrets Manager 端点时超时。

Lambda 轮换功能必须能够访问 Secrets Manager 端点。如果您的 Lambda 函数可以访问互联网，则可以使用公共端点。若要查找端点，请参阅 [Amazon Secrets Manager 端点](asm_access.md#endpoints)。

如果您的 Lambda 函数在不具备互联网访问权限的 VPC 中运行，我们建议您在 VPC 内配置 Secrets Manager 服务私有端点。然后，您的 VPC 可以拦截发往公共区域端点的请求并将其重定向到私有端点。有关更多信息，请参阅 [VPC 端点（Amazon PrivateLink）](vpc-endpoint-overview.md)。

或者，您可以通过向 VPC 添加 [NAT 网关](https://docs.amazonaws.cn/vpc/latest/userguide/vpc-nat-gateway.html)或[互联网网关](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_Internet_Gateway.html)（这将允许来自您 VPC 的流量访问公有端点），允许 Lambda 函数访问 Secrets Manager 公有端点。这会使 VPC 面临一定的风险，因为网关的 IP 地址可能会受到来自公有 Internet 的攻击。

## “createSecret”之后没有活动


以下问题可能会在 createSecret 之后导致轮换停止：

**VPC 网络 ACLs 不允许 HTTPS 流量进出。**  
有关更多信息，请参阅 *Amazon VPC 用户指南 ACLs*中的[使用网络控制子网流量](https://docs.amazonaws.cn/vpc/latest/userguide/vpc-network-acls.html)。

**Lambda 函数超时配置过短，无法执行任务。**  
有关更多信息，请参阅 *Amazon Lambda 开发人员指南*中的[配置 Lambda 函数选项](https://docs.amazonaws.cn/lambda/latest/dg/configuration-function-common.html)。

**Secrets Manager VPC CIDRs 终端节点不允许 VPC 进入分配的安全组。**  
有关更多信息，请参阅《Amazon VPC 用户指南》中的[使用安全组控制到资源的流量](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_SecurityGroups.html)。

**Secrets Manager VPC 端点策略不允许 Lambda 使用 VPC 端点。**  
有关更多信息，请参阅 [使用 Amazon Secrets Manager VPC 终端节点](vpc-endpoint-overview.md)。

**该密钥使用交替用户轮换策略，超级用户密钥由 Amazon RDS 管理，并且 Lambda 函数无法访问 RDS API。**  
对于超级用户秘密[由其他 Amazon 服务管理](service-linked-secrets.md)的[交替用户轮换](rotation-strategy.md#rotating-secrets-two-users)，Lambda 轮换函数必须能够调用服务端点以获取数据库连接信息。我们建议您为数据库服务配置 VPC 端点。有关更多信息，请参阅:  
+  《*Amazon RDS 用户指南*》中的 [Amazon RDS API 和接口 VPC 端点](https://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/vpc-interface-endpoints.html)。
+ 《*Amazon Redshift 管理指南*》中的[使用 VPC 端点](https://docs.amazonaws.cn/redshift/latest/mgmt/enhanced-vpc-working-with-endpoints.html)。

## 错误：“不允许访问 KMS”


如果您看到 `ClientError: An error occurred (AccessDeniedException) when calling the GetSecretValue operation: Access to KMS is not allowed`，则轮换函数无权使用密钥加密所用的 KMS 密钥来将密钥解密。权限策略中可能存在将加密上下文限定为特定密钥的条件。有关所需权限的信息，请参阅 [适用于客户托管密钥的策略语句](rotating-secrets-required-permissions-function.md#rotating-secrets-required-permissions-function-cust-key-example)。

## 错误：“Key is missing from secret JSON（密钥 JSON 中缺少密钥）”


Lambda 轮换函数要求密钥值采用特定的 JSON 结构。如果显示此错误，则 JSON 可能缺少轮换函数尝试访问的密钥。有关每种密钥类型的 JSON 结构的信息，请参阅 [Amazon Secrets Manager 密钥的 JSON 结构](reference_secret_json_structure.md)。

## 错误：“setSecret: Unable to log into database（setSecret：无法登录数据库）”


以下问题可能导致此错误：

**轮换函数无法访问数据库。**  
如果任务持续时间过长，例如超过 5000 毫秒，则 Lambda 轮换函数可能无法通过网络访问数据库。  
如果数据库或服务在 VPC 中的 Amazon EC2 实例上运行，建议将 Lambda 函数配置为在同一 VPC 中运行。然后轮换功能可以直接与您的服务通信。有关更多信息，请参阅[配置 VPC 访问](https://docs.amazonaws.cn/lambda/latest/dg/configuration-vpc.html#vpc-configuring)。  
要允许 Lambda 函数访问数据库或服务，您必须确保附加到 Lambda 轮换函数的安全组允许与数据库或服务的出站连接。您还必须确保附加到数据库或服务的安全组允许来自 Lambda 轮换函数进行入站连接。

**密钥中的凭证有误。**  
如果任务持续时间过短，则 Lambda 轮换函数可能无法使用密钥中的凭证进行身份验证。使用 Amazon CLI 命令使用密钥`AWSCURRENT`和`AWSPREVIOUS`版本中的信息手动登录，检查凭据[https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.amazonaws.cn/cli/latest/reference/secretsmanager/get-secret-value.html)。

**数据库使用 `scram-sha-256` 加密密码。**  
如果您的数据库是 Aurora PostgreSQL 版本 13 或更高版本，并且使用 `scram-sha-256` 加密密码，但轮换函数使用不支持 `scram-sha-256` 的 `libpq` 版本 9 或更旧版本，则轮换函数无法连接到数据库。  

**确定哪些数据库用户使用 `scram-sha-256` 加密**
+ 请参阅博客 [RDS for PostgreSQL 13 中的 SCRAM 身份验证](https://www.amazonaws.cn/blogs/database/scram-authentication-in-rds-for-postgresql-13/)中的*检查使用非 SCRAM 密码的用户*。

**确定您的轮换函数使用哪个 `libpq` 版本**

1. 在基于 Linux 的计算机上，在 Lambda 控制台上导航到您的轮换函数并下载部署包。将 zip 文件解压缩到工作目录中。

1. 在命令行上，在工作目录中运行：

   `readelf -a libpq.so.5 | grep RUNPATH`

1. 如果看到字符串 *`PostgreSQL-9.4.x`* 或任何低于 10 的主要版本，则轮换函数不支持 `scram-sha-256`。
   + 不支持 `scram-sha-256` 的轮换函数的输出：

     `0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild-a1b2c/workspace/build/PostgreSQL/PostgreSQL-9.4.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild-a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
   + 支持 `scram-sha-256` 的轮换函数的输出：

     `0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild-a1b2c/workspace/build/PostgreSQL/PostgreSQL-10.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild-a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
   + 支持 `scram-sha-256` 的轮换函数的输出：

     `0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild- a1b2c /workspace/build/PostgreSQL/PostgreSQL-14.x_client_only. 123456 .0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild- a1b2c /workspace/src/PostgreSQL/build/private/install/lib]`
   + 支持 `scram-sha-256` 的轮换函数的输出：

     `0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild- a1b2c/workspace/build/PostgreSQL/PostgreSQL- 14.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil- path/build.libfarm/lib:/local/p4clients/pkgbuild- a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
如果您在 2021 年 12 月 30 日之前设置了自动密钥轮换，则轮换函数捆绑了不支持 `scram-sha-256` 的较早版本 `libpq`。为了支持 `scram-sha-256`，您需要[重新创建您的轮换函数](rotate-secrets_turn-on-for-db.md)。

**数据库需要 SSL/TLS 访问权限。**  
如果您的数据库需要 SSL/TLS 连接，但轮换函数使用未加密的连接，则轮换函数无法连接到数据库。适用于 Amazon RDS（Oracle 和 Db2 除外）和 Amazon DocumentDB 的轮换函数将自动使用安全套接字层 (SSL) 或传输层安全性协议 (TLS) 来连接到数据库（如果可用）。否则，他们将使用未加密的连接。  
如果您在 2021 年 12 月 20 日之前设置了自动密钥轮换，则轮换功能可能基于不支持的早期模板SSL/TLS. To support connections that use SSL/TLS，则需要[重新创建轮换函数](rotate-secrets_turn-on-for-db.md)。

**确定您的轮换函数的创建时间**

1. 在 Secrets Manager 控制台中 [https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)，打开你的密钥。在 **Rotation configuration**（轮换配置）中的 **Lambda rotation function**（Lambda 轮换函数）下，您将看到 **Lambda function ARN**（Lambda 函数 ARN），例如，`arn:aws:lambda:aws-region:123456789012:function:SecretsManagerMyRotationFunction `。在此示例 ` SecretsManagerMyRotationFunction ` 中，从 ARN 末尾复制函数名称。

1. 在 Amazon Lambda 控制台的 “**函数**” 下 [https://console.aws.amazon.com/lambda/](https://console.amazonaws.cn/lambda/)，将您的 Lambda 函数名称粘贴到搜索框中，选择 Enter，然后选择 Lambda 函数。

1. 在函数详细信息页面中，在 **Configuration**（配置）选项卡上的 **Tags**（标签）下，复制键 **aws:cloudformation:stack-name** 旁边的值。

1. 在 Amazon CloudFormation 控制台 [https://console.aws.amazon.com/cloudformation](https://console.amazonaws.cn/cloudformation/) 的 **Stacks** 下，将密钥值粘贴到搜索框中，然后选择 Enter。

1. 堆栈列表将进行筛选，以便只显示创建 Lambda 轮换函数的堆栈。在 **Created date**（创建日期）列中，查看堆栈的创建日期。这是 Lambda 轮换函数的创建日期。

## 错误：“无法导入模块‘lambda\$1function’”


如果您运行的是早期版本的 Lambda 函数，且该函数是从 Python 3.7 自动升级到更新版本的 Python 的，则可能会遇到此错误。要解决此错误，您可以将 Lambda 函数版本改回 Python 3.7，然后 [将现有的轮换函数版本从 Python 3.7 升级到 Python 3.9](#troubleshoot_rotation_python39)。要了解更多信息，请参阅 *Amazon re:Post* 中的 [为什么我的 Secrets Manager Lambda 函数轮换失败并出现“找不到 pg 模块”错误？](https://repost.aws/knowledge-center/secrets-manager-lambda-rotation)。

## 将现有的轮换函数版本从 Python 3.7 升级到 Python 3.9


2022 年 11 月之前创建的部分轮换函数使用 Python 3.7。适用于 Python 的 Amazon 软件开发工具包于 2023 年 12 月停止支持 Python 3.7。有关更多信息，请参阅 [Python 支持政策更新 Amazon SDKs 和工具](https://www.amazonaws.cn/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/)。要切换到使用 Python 3.9 的新轮换函数，可以在现有轮换函数中添加运行时系统属性或重新创建轮换函数。

**查找使用 Python 3.7 的 Lambda 轮换函数**

1. 登录 Amazon Web Services 管理控制台 并打开 Amazon Lambda 控制台，网址为[https://console.aws.amazon.com/lambda/](https://console.amazonaws.cn/lambda/)。

1. 在**函数**列表中，筛选 **SecretsManager**。

1. 在筛选后的函数列表中，在**运行时系统**下，查找 Python 3.7。

**Topics**
+ [

### 选项 1：使用重新创建旋转函数 Amazon CloudFormation
](#update-python-opt-1)
+ [

### 选项 2：使用更新现有旋转函数的运行时间 Amazon CloudFormation
](#update-python-opt-2)
+ [

### 选项 3：对于 Amazon CDK 用户，升级 CDK 库
](#update-python-opt-3)

### 选项 1：使用重新创建旋转函数 Amazon CloudFormation


当您使用 Secrets Manager 控制台开启轮换功能时，Secrets Manager 会使用 Amazon CloudFormation 创建必要的资源，包括 Lambda 轮换函数。如果您使用控制台开启轮换，或者使用 Amazon CloudFormation 堆栈创建了旋转功能，则可以使用相同的 Amazon CloudFormation 堆栈重新创建具有新名称的旋转函数。新函数将使用最新版本的 Python。

**查找创建旋转函数的 Amazon CloudFormation 堆栈**
+ 在 Lambda 函数的详细信息页面的**配置**选项卡上，选择**标签**。查看 **aws:cloudformation:stack-id** 旁的 ARN。

  堆栈名称已嵌入在 ARN 中，如下例所示。
  + ARN：`arn:aws:cloudformation:us-west-2:408736277230:stack/SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda-3CUDHZMDMBO8/79fc9050-2eef-11ed-80f0-021fb13c0537`
  + 堆栈名称：**SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda**

**重新创建轮换函数（Amazon CloudFormation）**

1. 在中 Amazon CloudFormation，按名称搜索堆栈，然后选择**更新**。

   如果出现建议您更新根堆栈的对话框，请选择**转到根堆栈**，然后选择**更新**。

1. 在**更新堆栈**页面上的**准备模板**下，选择**在应用程序编辑器中编辑**，然后在**在应用程序编辑器中编辑模板**下，选择**在应用程序编辑器中编辑**按钮。

1. 在应用程序编辑器中，执行以下操作：

   1. 在模板代码中，在 `SecretRotationScheduleHostedRotationLambda` 中将 `"functionName": "SecretsManagerTestRotationRDS"` 的值替换为新的函数名称，例如在 JSON 中为 `"functionName": "SecretsManagerTestRotationRDSupdated"` 

   1. 选择**更新模板**。

   1. 在**继续使用 Amazon CloudFormation** 对话框中，选择**确认并继续使用 Amazon CloudFormation**。

1. 继续完成 Amazon CloudFormation 堆栈工作流程，然后选择**提交**。

### 选项 2：使用更新现有旋转函数的运行时间 Amazon CloudFormation


当您使用 Secrets Manager 控制台开启轮换功能时，Secrets Manager 会使用 Amazon CloudFormation 创建必要的资源，包括 Lambda 轮换函数。如果您使用控制台开启轮换，或者使用 Amazon CloudFormation 堆栈创建了旋转函数，则可以使用相同的 Amazon CloudFormation 堆栈来更新旋转功能的运行时间。

**查找创建旋转函数的 Amazon CloudFormation 堆栈**
+ 在 Lambda 函数的详细信息页面的**配置**选项卡上，选择**标签**。查看 **aws:cloudformation:stack-id** 旁的 ARN。

  堆栈名称已嵌入在 ARN 中，如下例所示。
  + ARN：`arn:aws:cloudformation:us-west-2:408736277230:stack/SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda-3CUDHZMDMBO8/79fc9050-2eef-11ed-80f0-021fb13c0537`
  + 堆栈名称：**SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda**

**更新轮换函数的运行时系统（Amazon CloudFormation）**

1. 在中 Amazon CloudFormation，按名称搜索堆栈，然后选择**更新**。

   如果出现建议您更新根堆栈的对话框，请选择**转到根堆栈**，然后选择**更新**。

1. 在**更新堆栈**页面上的**准备模板**下，选择**在应用程序编辑器中编辑**，然后在**在应用程序编辑器中编辑模板**下，选择**在应用程序编辑器中编辑**按钮。

1. 在应用程序编辑器中，执行以下操作：

   1. 在模板 JSON 中，对于 `SecretRotationScheduleHostedRotationLambda`，在 `Properties` 下的 `Parameters` 下方，添加 **"runtime": "python3.9"**。

   1. 选择**更新模板**。

   1. 在**继续使用 Amazon CloudFormation** 对话框中，选择**确认并继续使用 Amazon CloudFormation**。

1. 继续完成 Amazon CloudFormation 堆栈工作流程，然后选择**提交**。

### 选项 3：对于 Amazon CDK 用户，升级 CDK 库


如果您使用 v2.94.0 Amazon CDK 之前的版本为密钥设置轮换，则可以通过升级到 v2.94.0 或更高版本来更新 Lambda 函数。有关更多信息，请参见 [Amazon Cloud Development Kit (Amazon CDK) v2 开发人员指南](https://docs.amazonaws.cn/cdk/v2/guide/home.html)。

## 将现有的轮换函数版本从 Python 3.9 升级到 Python 3.10


Secrets Manager 正在针对 Lambda 轮换函数从 Python 3.9 过渡到 Python 3.10。要切换到使用 Python 3.10 的新轮换函数，需要遵循基于部署方法的升级路径。使用以下过程升级 Python 版本和底层依赖项。

**要查找哪些 Lambda 旋转函数使用 Python 3.9**

1. 登录 Amazon Web Services 管理控制台 并打开 Amazon Lambda 控制台，网址为[https://console.aws.amazon.com/lambda/](https://console.amazonaws.cn/lambda/)。

1. 在**函数**列表中，筛选 **SecretsManager**。

1. 在筛选后的函数列表中，在**运行时系统**下，查找 **Python 3.9**。

### 按部署方法更新路径


此列表中标识的 Lambda 轮换函数可以通过 Secrets Manager 控制台、 Amazon Serverless Application Repository 应用程序或 Amazon CloudFormation 转换进行部署。每种这些部署策略有着不同的更新路径。

根据函数的部署方式，使用以下过程之一更新您的 Lambda 轮换函数。

------
#### [ Amazon Secrets Manager console-deployed functions ]

必须通过 Amazon Secrets Manager 控制台部署新的 Lambda 函数，因为您无法手动更新现有 Lambda 函数的依赖关系。

使用以下步骤升级 Amazon Secrets Manager 控制台部署的功能。

1. 打开 Secrets Manager 控制台，网址为[https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)。

1. 在 **Amazon Secrets Manager** 下方，选择**密钥**。选择使用希望更新的 Lambda 函数的密钥。

1. 导航到**轮换**选项卡，然后选择**更新轮换配置**选项。

1. 在**轮换函数**下，选择**创建新的 Lambda 函数**，然后为 Lambda 轮换函数输入一个名称。

   1. （可选）更新完成后，您可以测试更新后的 Lambda 函数以确认其按预期运行。在**轮换**选项卡下，选择**立即轮换密钥**以启动立即轮换。

   1. （可选）您可以在 Amazon 中查看您的函数日志和运行时使用的 Python 版本 CloudWatch。有关更多信息，请参阅*Amazon Lambda 开发人员*指南中的[查看 Lambda 函数的 CloudWatch 日志](https://docs.amazonaws.cn/lambda/latest/dg/monitoring-cloudwatchlogs-view.html#monitoring-cloudwatchlogs-console)。

1. 设置新的轮换函数后，您可以删除旧的轮换函数。

------
#### [ Amazon Serverless Application Repository deployments ]

以下过程说明如何升级 Amazon Serverless Application Repository 部署。通过部署的 Lambda 函数 Amazon Serverless Application Repository 有一个横幅，`This function belongs to an application. Click here to manage it.`其中包含指向该函数所属的 Lambda 应用程序的链接。

**重要**  
Amazon Serverless Application Repository 可用性 Amazon Web Services 区域 视情况而定。

使用以下过程更新 Amazon Serverless Application Repository 已部署的函数。

1. 打开 Amazon Lambda 控制台，网址为[https://console.aws.amazon.com/lambda/](https://console.amazonaws.cn/lambda/)。

1. 导航到需要更新的 Lambda 函数的**配置**选项卡。

   1. 更新已部署的 Amazon Serverless Application Repository 应用程序时，您需要以下有关您的函数的信息。您可以在 Lambda 控制台中找到这些信息。
     + **Lambda 应用程序的名称**
       + 使用横幅中的链接可以找到 Lambda 应用程序的名称。例如，横幅声明以下 `serverlessrepo-SecretsManagerRedshiftRotationSingleUser`。在本示例中，名称为 `SecretsManagerRedshiftRotationSingleUser`。
     + **Lambda 轮换函数名称**
     + **Secrets Manager 端点**
       + 该端点可以在分配给 **SECRETS\$1MANAGER\$1ENDPOINT** 变量的**配置**和**环境变量**选项卡下找到。

1. 要升级 Python，必须更新无服务器应用程序的语义版本。请参阅 *Amazon Serverless Application Repository 开发人员指南*中的[更新应用程序](https://docs.amazonaws.cn/serverlessrepo/latest/devguide/serverlessrepo-how-to-consume-new-version.html#update-applications)。

------
#### [ Custom Lambda rotation functions ]

如果您创建自定义 Lambda 轮换函数，则需要升级这些函数的每个软件包依赖项和运行时。有关更多信息，请参阅[将 Lambda 函数运行时升级到最新版本](https://repost.aws/knowledge-center/lambda-upgrade-function-runtime)。

------
#### [ Amazon::SecretsManager-2024-09-16 transform macro ]

如果通过此转换部署 Lambda 函数，则[使用现有模板更新堆栈](https://docs.amazonaws.cn/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-direct.html)将允许您使用更新后的 Lambda 运行时。

使用以下步骤使用现有模板更新 Amazon CloudFormation 堆栈。

1. 在 [https://console.aws.amazon.com/cloudformat](https://console.amazonaws.cn/cloudformation/) ion 上打开 Amazon CloudFormation 控制台。

1. 在**堆栈**页面上，选择要更新的堆栈。

1. 在堆栈详细信息窗格上，选择**更新**。

1. 在**选择模板更新方法**中，选择**直接更新**。

1. 在**选择模板**页面上，选择**使用现有模板**。

1. 将所有其他选项保留为默认值，然后选择**更新堆栈**。

如果您在更新堆栈时遇到问题，请参阅 *Amazon CloudFormation 用户指南*中的[确定堆栈故障的原因](https://docs.amazonaws.cn/AWSCloudFormation/latest/UserGuide/determine-root-cause-for-stack-failures.html)。

------
#### [ Amazon::SecretsManager-2020-07-23 transform macro ]

如果您正在使用 `Amazon::SecretsManager-2020-07-23`，我们建议您迁移到较新的转换版本。有关更多信息[，请参阅*Amazon 安全*博客中的介绍增强版 Amazon Secrets Manager 转换 Amazon::: SecretsManager -2024-09-16](https://www.amazonaws.cn/blogs/security/introducing-an-enhanced-version-of-the-aws-secrets-manager-transform-awssecretsmanager-2024-09-16/)。如果您继续使用 `Amazon::SecretsManager-2020-07-23`，则可能会遇到运行时版本与 Lambda 函数代码构件不匹配的错误。有关更多信息，请参阅《*Amazon CloudFormation 模板参考*》RotationSchedule HostedRotationLambda中的[Amazon SecretsManager::::](https://docs.amazonaws.cn/AWSCloudFormation/latest/TemplateReference/aws-properties-secretsmanager-rotationschedule-hostedrotationlambda.html#cfn-secretsmanager-rotationschedule-hostedrotationlambda-runtime)。

如果您在更新堆栈时遇到问题，请参阅 *Amazon CloudFormation 用户指南*中的[确定堆栈故障的原因](https://docs.amazonaws.cn/AWSCloudFormation/latest/UserGuide/determine-root-cause-for-stack-failures.html)。

------

**验证 Python 升级**  
要验证 Python 升级情况，请打开 Lambda 控制台 ([https://console.aws.amazon.com/lambda/](https://console.amazonaws.cn/lambda/)) 并访问**函数**页面。选择您更新的函数。在**代码源**部分下，查看目录中包含的文件，并确保 Python .so 文件是版本 `3.10`。

## Amazon Lambda 秘密轮换`PutSecretValue`失败


如果您在 Secrets Manager 中使用代入角色或跨账户轮换，并且在中发现了一个 CloudTrail 带有以下消息**RotationFailed**的事件：*LAMBDA\$1ARN.*Lambda 未创建 Secret 的待处理密钥*SECRET\$1ARN *版本*VERSION\$1ID *移除暂存标签并重启轮换，则需要更新 Lambda 函数才能使用`AWSPENDING`该参数。`RotationToken`<a name="troubleshoot_rotation_procedure"></a>

## 更新 Lambda 轮换函数以包括 `RotationToken`


1. 下载 Lambda 函数代码
   + 打开 Lambda 控制台
   + 在导航窗格中，选择**函数**
   + 针对**函数名称**选择您的 Lambda 密钥轮换函数
   + 在**下载**中，选择**函数代码 .zip**、**Amazon SAM 文件**、**两者**中的一个选项
   + 选择**确定**将该函数保存在本地计算机上。

1. 编辑 `Lambda_handler`

   在跨账户轮换的 create\$1secret 步骤中包括 rotation\$1token 参数：

   ```
   def lambda_handler(event, context):
       """Secrets Manager Rotation Template
   
       This is a template for creating an AWS Secrets Manager rotation lambda
   
       Args:
           event (dict): Lambda dictionary of event parameters. These keys must include the following:
               - SecretId: The secret ARN or identifier
               - ClientRequestToken: The ClientRequestToken of the secret version
               - Step: The rotation step (one of createSecret, setSecret, testSecret, or finishSecret)
               - RotationToken: the rotation token to put as parameter for PutSecretValue call
   
           context (LambdaContext): The Lambda runtime information
   
       Raises:
           ResourceNotFoundException: If the secret with the specified arn and stage does not exist
   
           ValueError: If the secret is not properly configured for rotation
   
           KeyError: If the event parameters do not contain the expected keys
   
       """
       arn = event['SecretId']
       token = event['ClientRequestToken']
       step = event['Step']
       # Add the rotation token
       rotation_token = event['RotationToken']
   
       # Setup the client
       service_client = boto3.client('secretsmanager', endpoint_url=os.environ['SECRETS_MANAGER_ENDPOINT'])
   
       # Make sure the version is staged correctly
       metadata = service_client.describe_secret(SecretId=arn)
       if not metadata['RotationEnabled']:
           logger.error("Secret %s is not enabled for rotation" % arn)
           raise ValueError("Secret %s is not enabled for rotation" % arn)
       versions = metadata['VersionIdsToStages']
       if token not in versions:
           logger.error("Secret version %s has no stage for rotation of secret %s." % (token, arn))
           raise ValueError("Secret version %s has no stage for rotation of secret %s." % (token, arn))
       if "AWSCURRENT" in versions[token]:
           logger.info("Secret version %s already set as AWSCURRENT for secret %s." % (token, arn))
           return
       elif "AWSPENDING" not in versions[token]:
           logger.error("Secret version %s not set as AWSPENDING for rotation of secret %s." % (token, arn))
           raise ValueError("Secret version %s not set as AWSPENDING for rotation of secret %s." % (token, arn))
       # Use rotation_token
       if step == "createSecret":
           create_secret(service_client, arn, token, rotation_token)
   
       elif step == "setSecret":
           set_secret(service_client, arn, token)
       
       elif step == "testSecret":
           test_secret(service_client, arn, token)
           
       elif step == "finishSecret":
           finish_secret(service_client, arn, token)
           
       else:
           raise ValueError("Invalid step parameter")
   ```

1. 编辑 `create_secret` 代码

   修订 `create_secret` 函数以接受并使用 `rotation_token` 参数：

   ```
   # Add rotation_token to the function
   def create_secret(service_client, arn, token, rotation_token):
   """Create the secret
   
   This method first checks for the existence of a secret for the passed in token. If one does not exist, it will generate a
   new secret and put it with the passed in token.
   
   Args:
   service_client (client): The secrets manager service client
   
   arn (string): The secret ARN or other identifier
   
   token (string): The ClientRequestToken associated with the secret version
   
   rotation_token (string): the rotation token to put as parameter for PutSecretValue call
   
   Raises:
   ResourceNotFoundException: If the secret with the specified arn and stage does not exist
   
   """
   # Make sure the current secret exists
   service_client.get_secret_value(SecretId=arn, VersionStage="AWSCURRENT")
   
   # Now try to get the secret version, if that fails, put a new secret
   try:
   service_client.get_secret_value(SecretId=arn, VersionId=token, VersionStage="AWSPENDING")
   logger.info("createSecret: Successfully retrieved secret for %s." % arn)
   except service_client.exceptions.ResourceNotFoundException:
   # Get exclude characters from environment variable
   exclude_characters = os.environ['EXCLUDE_CHARACTERS'] if 'EXCLUDE_CHARACTERS' in os.environ else '/@"\'\\'
   # Generate a random password
   passwd = service_client.get_random_password(ExcludeCharacters=exclude_characters)
   
   # Put the secret, using rotation_token
   service_client.put_secret_value(SecretId=arn, ClientRequestToken=token, SecretString=passwd['RandomPassword'], VersionStages=['AWSPENDING'], RotationToken=rotation_token)
   logger.info("createSecret: Successfully put secret for ARN %s and version %s." % (arn, token))
   ```

1. 更新已更新的 Lambda 函数代码

   更新您的 Lambda 函数代码后，[将其上传以轮换密钥](https://docs.amazonaws.cn/lambda/latest/dg/configuration-function-zip.html#configuration-function-update)。

## 错误：“*<arn>*在*<a rotation>*步骤中执行 lambda 时出错”
间歇性轮换失败

如果您的 Lambda 函数在指令集合循环中卡住，例如在 **CreateSecret** 和 **SetSecret** 之间，此时您遇到间歇性密钥轮换故障，则该问题可能与并发设置有关。

### 并发问题排查步骤


**警告**  
由于 Lambda 函数的执行线程不足，将预置的并发参数设置为低于 10 的值可能会导致节流。有关更多信息，请参阅《 Amazon Lambda Amazon Lambda 开发人员指南》中的[了解预留并发和预置并发](https://docs.amazonaws.cn/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned)。

1. 检查并调整 Lambda 并发设置：
   + 验证 `reserved_concurrent_executions` 是否设置太低（例如 1）
   + 如果使用预留并发，请将其值至少设置为 10
   + 考虑使用非预留并发以获得更大的灵活性

1. 对于预置并发：
   + 不要显式设置预配置并发参数（例如，在 Terraform 中）。
   + 如果必须设置此参数，请使用至少为 10 的值。
   + 全面测试以确保所选值适用于您的使用案例。

1. 监控和调整并发：
   + 使用以下公式计算并发：并发 =（每秒平均请求数）\$1（以秒为单位的平均请求持续时间）。有关更多信息，请参阅[估算预留并发](https://docs.amazonaws.cn/lambda/latest/dg/configuration-concurrency.html#estimating-reserved-concurrency)。
   + 观察并记录轮换期间的值，以确定适当的并发设置。
   + 请谨慎设置低并发值。如果没有足够的可用执行线程，它们可能会导致节流。

有关配置 Lambda 并发的更多信息，请参阅开发人员指南中的[配置预留并发](https://docs.amazonaws.cn/lambda/latest/dg/configuration-concurrency.html)和[配置预配置并发](https://docs.amazonaws.cn/lambda/latest/dg/provisioned-concurrency.html)。 Amazon Lambda 

# 轮换计划


Secrets Manager 会在您设置的轮换时段内按照计划轮换您的密钥。要设置计划和时段，请使用 **cron()** 或 **rate()** 表达式以及时段持续时间。Secrets Manager 将在轮换时段内随时轮换密钥。您可以在短至一小时的轮换时段内每四小时轮换一次密钥。

要启用轮换，请参阅：
+ [Amazon Secrets Manager 密钥的托管轮换](rotate-secrets_managed.md)
+ [为 Amazon RDS、Amazon Aurora、Amazon Redshift 或 Amazon DocumentDB 密钥设置自动轮换](rotate-secrets_turn-on-for-db.md)
+ [为非数据库 Amazon Secrets Manager 密钥设置自动轮换](rotate-secrets_turn-on-for-other.md)

Secrets Manager 轮换计划使用 UTC 时区。

## 轮换时段


Secrets Manager 轮换时段与维护时段类似。当您想要轮换密钥时，可以设置轮换时段，Secrets Manager 会在轮换时段内的某个时间轮换您的密钥。

Secrets Manager 轮换时段总是按小时开始。对于使用 `rate()` 表达式（以天为单位）的轮换计划，轮换时段从午夜开始。您可以使用 `cron()` 表达式设置轮换时段的开始时间。有关示例，请参阅 [Cron 表达式](#rotate-secrets_schedule-cron)。

默认情况下，对于按*小时*计算的轮换计划，轮换时段在一小时后关闭；对于按*天*计算的轮换计划，轮换时段在一天结束时关闭。

要更改轮换时段的长度，请设置**时段持续时间**。您可以将轮换时段设置为短至一小时。该轮换时段不得延伸到下一个轮换时段。换句话说，对于以*小时*为单位的轮换计划，请确认轮换时段小于或等于轮换之间的小时数。对于以*天*为单位的轮换计划，请确认起始小时数加上时段持续时间小于或等于 24 小时。

## Rate 表达式


Secrets Manager 速率表达式采用以下格式，其中*Value*为正整数`hour`，*Unit*可以是`hours``day`、、或`days`：

```
rate(Value Unit)
```

您可以每四小时轮换一次密钥。最长轮换周期为 999 天。示例：
+ `rate(4 hours)` 意味着密钥每四小时轮换一次。
+ `rate(1 day)` 意味着密钥每天轮换一次。
+ `rate(10 days)` 意味着密钥每 10 天轮换一次。

## Cron 表达式


Secrets Manager cron 表达式具有以下格式：

```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```

包含小时增量的 cron 表达式每天都会重置。例如，`cron(0 4/12 * * ? *)` 表示凌晨 4:00、下午 4:00，然后是第二天凌晨 4:00、下午 4:00。Secrets Manager 轮换计划使用 UTC 时区。


| 示例计划 | Expression | 
| --- | --- | 
| 每八小时一次，从午夜开始。 |  `cron(0 /8 * * ? *)`  | 
| 每八小时一次，从早上 8:00 开始。 |  `cron(0 8/8 * * ? *)`  | 
| 每十小时一次，从凌晨 2:00 开始。 轮换时段将从 2:00、12:00 和 22:00 开始，然后在第二天的 2:00、12:00 和 22:00 进行。 |  `cron(0 2/10 * * ? *)`  | 
| 每天上午 10:00。 |  `cron(0 10 * * ? *)`  | 
|  每星期六下午 6:00。  |  `cron(0 18 ? * SAT *)`  | 
|  每月第 1 天上午 8:00。  |  `cron(0 8 1 * ? *)`  | 
|  每三个月第一个星期日凌晨 1:00。  |  `cron(0 1 ? 1/3 SUN#1 *)`  | 
|  每月最后一天下午 5:00。  |  `cron(0 17 L * ? *)`  | 
|  星期一到星期五上午 8:00。  |  `cron(0 8 ? * MON-FRI *)`  | 
|  每月第 1 天和第 15 天下午 4:00。  |  `cron(0 16 1,15 * ? *)`  | 
|  每月第一个星期日午夜。  |  `cron(0 0 ? * SUN#1 *)`  | 
|  从一月份开始，每 11 个月的第一个星期一的午夜。  |  `cron(0 0 ? 1/11 2#1 *)`  | 

### Secrets Manager 中的 Cron 表达式要求


Secrets Manager 对可以用于 cron 表达式的内容有一些限制。Secrets Manager 的 cron 表达式的分钟字段必须填写 **0**，因为 Secrets Manager 轮换时段在整点开始。其年份字段必须填写 **\$1**，因为 Secrets Manager 不支持相隔一年以上的轮换计划。下表显示了可以使用的选项。


| **字段** | **值** | **通配符** | 
| --- | --- | --- | 
|  Minutes  | 必须为 0 | 无 | 
|  小时  |  0–23  |  使用 **/**（正斜杠）指定增量。例如，`2/10` 意味着从凌晨 2:00 开始每 10 小时一次。您可以每四小时轮换一次密钥。  | 
|  D ay-of-month  |  1-31  |  使用 **,**（逗号）包含其他值。例如，`1,15` 当前当月的第 1 天和第 15 天。 使用 **-**（短划线）指定范围。例如，`1–15` 表示当月的第 1 天到第 15 天。 使用 **\$1**（星号）包含该字段中的所有值。例如，`*` 表示当月的每一天。 **?**（问号）通配符用于指定一个或另一个。您无法在同一 cron 表达式中为 `Day-of-month` 和 `Day-of-week` 字段同时指定值。如果您在其中一个字段中指定了值，则必须在另一个字段中使用 **?**（问号）。 使用 **/**（正斜杠）指定增量。例如，`1/2` 表示从第 1 天开始每两天一次，换句话说，第 1 天、第 3 天、第 5 天，依此类推。 使用 **L** 指定当月的最后一天。 使用 ***DAY*L** 指定该月中最后一个命名的日期。例如，`SUNL` 表示当月的最后一个星期日。  | 
|  月份  |  1-12 或 JAN-DEC  |  使用 **,**（逗号）包含其他值。例如，`JAN,APR,JUL,OCT` 表示一月、四月、七月和十月。 使用 **-**（短划线）指定范围。例如，`1–3` 表示一年的第 1 个月至第 3 个月。 使用 **\$1**（星号）包含该字段中的所有值。例如，`*` 表示每个月。 使用 **/**（正斜杠）指定增量。例如，`1/3` 表示每三个月一次，从第 1 个月开始，即第 1、4、7 和 10 个月。  | 
|  D ay-of-week  |  1-7 或 SUN-SAT  |  使用 **\$1** 指定某个月内一周的星期几。例如，`TUE#3` 表示该月的第三个星期二。 使用 **,**（逗号）包含其他值。例如，`1,4` 表示一周的第一天和第四天。 使用 **-**（短划线）指定范围。例如，`1–4` 表示一周的第 1 天到第 4 天。 使用 **\$1**（星号）包含该字段中的所有值。例如，`*` 表示一周的每一天。 **?**（问号）通配符用于指定一个或另一个。您无法在同一 cron 表达式中为 `Day-of-month` 和 `Day-of-week` 字段同时指定值。如果您在其中一个字段中指定了值，则必须在另一个字段中使用 **?**（问号）。 使用 **/**（正斜杠）指定增量。例如，`1/2` 表示一周的每隔一天，从第一天开始，即第 1 天、第 3 天、第 5 天和第 7 天。 使用 **L** 指定一周的最后一天。  | 
|  Year  | 必须是 \$1 | 无 | 

# 立即轮换 Amazon Secrets Manager 密钥
立即轮换密钥

您只能轮换已配置了轮换的密钥。要确定密钥是否已配置为轮换，请在控制台中查看密钥并向下滚动到 **Rotation configuration**（轮换配置）部分。如果 **Rotation status**（轮换状态）为 **Enabled**（启用），则密钥配置为轮换。如果不是，请参阅[轮换 Amazon Secrets Manager 秘密](rotating-secrets.md)。

**要立即轮换密码（控制台）**

1. 打开 Secrets Manager 控制台，网址为[https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)。

1. 选择您的密钥。

1. 在密钥详细信息页面上，在**旋转配置**下方，选择**立即轮换密钥**。

1. 在**轮换密钥**对话框中，选择**轮换**。

## Amazon CLI


**Example 立即轮换密钥**  
以下 [https://docs.amazonaws.cn//cli/latest/reference/secretsmanager/rotate-secret.html](https://docs.amazonaws.cn//cli/latest/reference/secretsmanager/rotate-secret.html) 示例将立即开始轮换。密钥必须已配置轮换。  

```
$ aws secretsmanager rotate-secret \
    --secret-id MyTestSecret
```

# 查找未轮换的密钥


您可以使用 Amazon Config 来评估您的密钥，以查看它们是否符合您的标准。您可以使用 Amazon Config 规则定义对机密的内部安全和合规性要求。然后 Amazon Config 可以识别不符合你规则的秘密。您还可以跟踪对密钥元数据、轮换配置、用于密钥加密的 KMS 密钥、Lambda 轮换函数以及与密钥关联的标签等进行的更改。

如果您的组织中有多个 Amazon Web Services 账户 密钥，则可以聚合该配置和合规性数据。 Amazon Web Services 区域 有关更多信息，请参阅 [Multi-account Multi-Region data aggregation](https://docs.amazonaws.cn/config/latest/developerguide/aggregate-data.html)。

**评测密钥是否正在轮换**

1. 按照使用[Amazon Config 规则评估资源中的说明进行](https://docs.amazonaws.cn/config/latest/developerguide/evaluating-your-resources.html)操作，并从以下规则中进行选择：
   + `[secretsmanager-rotation-enabled-check](https://docs.amazonaws.cn/config/latest/developerguide/secretsmanager-rotation-enabled-check.html)` — 检查是否为存储在 Secrets Manager 中的密钥配置了轮换。
   + `[secretsmanager-scheduled-rotation-success-check](https://docs.amazonaws.cn/config/latest/developerguide/secretsmanager-scheduled-rotation-success-check.html)`— 检查上次成功的轮换是否在配置的轮换频率内。检查的最低频率为每天。
   + `[secretsmanager-secret-periodic-rotation](https://docs.amazonaws.cn/config/latest/developerguide/secretsmanager-secret-periodic-rotation.html)` — 检查是否已在指定的天数内轮换了密钥。

1. （可选）配置 Amazon Config 为在密钥不合规时通知您。有关更多信息，请参阅[Amazon Config 发送至 Amazon SNS 主题的通知](https://docs.amazonaws.cn/config/latest/developerguide/notifications-for-AWS-Config.html)。

# 在 Secrets Manager 中取消自动轮换
取消自动轮换

如果为密钥配置了[自动轮换](rotating-secrets.md)，并且想要停止轮换，则可以取消轮换。

**取消自动轮换**

1. 打开 Secrets Manager 控制台，网址为[https://console.aws.amazon.com/secretsmanager/](https://console.amazonaws.cn/secretsmanager/)。

1. 选择您的密钥。

1. 在密钥详细信息页上的**轮换配置**下，选择**编辑轮换**。

1. 在**编辑轮换配置**对话框中，关闭**自动轮换**，然后选择**保存**。

   Secrets Manager 会保留轮换配置信息，以便您在将来决定重新启用轮换时可以使用它。