# Amazon RDS 中的安全性
AWS的云安全性的优先级最高。作为 AWS 客户，您将从专为满足大多数安全敏感型组织的要求而打造的数据中心和网络架构中受益。
安全性是 AWS 和您的共同责任。[责任共担模式](https://aws.amazon.com/compliance/shared-responsibility-model/)将其描述为云*的*安全性和云*中*的安全性：
+ **云的安全性** – AWS 负责保护在 AWS 云中运行 AWS 服务的基础架构。AWS 还向您提供可安全使用的服务。作为 [AWS 合规性计划](https://aws.amazon.com/compliance/programs/)的一部分，第三方审核人员将定期测试和验证安全性的有效性。要了解适用于 Amazon RDS的合规性计划，请参阅 [AWS 按合规性计划提供的范围内服务](https://aws.amazon.com/compliance/services-in-scope/)。
+ **云中的安全性** - 您的责任由您使用的 AWS 服务决定。您还需要对其他因素负责，包括您的数据的敏感性、您组织的要求以及适用的法律法规。
此文档将帮助您了解如何在使用 Amazon RDS 时应用责任共担模式。以下主题说明如何配置 Amazon RDS 以实现您的安全性和合规性目标。您还将了解如何使用其他 AWS 服务来帮助您监控和保护 Amazon RDS 资源。
您可以管理对数据库实例上的 Amazon RDS 资源和数据库的访问。用来管理访问的方法取决于用户需要对 Amazon RDS 执行的任务类型：
+ 在基于 Amazon VPC 服务的虚拟私有云（VPC）中运行数据库实例以获得尽可能大的网络访问控制能力。有关在 VPC 中创建数据库实例的更多信息，请参阅 [Amazon VPC 和 Amazon RDS](USER_VPC.md)。
+ 使用 AWS Identity and Access Management（IAM）策略分配权限，来决定谁可以管理 Amazon RDS 资源。例如，您可以使用 IAM 确定哪些用户可以创建、描述、修改和删除数据库实例、为资源添加标签或修改安全组。
+ 使用安全组可以控制哪些 IP 地址或 Amazon EC2 实例可连接到数据库实例上的数据库。首次创建数据库实例时，除非通过关联安全组指定的规则进行访问，否则实例防火墙会阻止任何数据库访问。
+ 将安全套接字层（SSL）或传输层安全性协议（TLS）连接用于运行 Db2、MySQL、MariaDB、PostgreSQL、Oracle 或 Microsoft SQL Server 数据库引擎的数据库实例。有关将 SSL/TLS 用于数据库实例的更多信息，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
+ 使用 Amazon RDS 加密来保护您的数据库实例和静态快照。Amazon RDS 加密使用行业标准 AES-256 加密算法，来对托管您的数据库实例的服务器上的数据进行加密。有关更多信息，请参阅 [加密 Amazon RDS 资源](Overview.Encryption.md)。
+ 对 Oracle 数据库实例使用网络加密和透明数据加密；有关更多信息，请参阅 [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md) 和 [Oracle 透明数据加密](Appendix.Oracle.Options.AdvSecurity.md)
+ 使用数据库引擎的安全功能，控制哪些用户可以登录数据库实例上的数据库。这些功能就像本地网络上的数据库一样工作。
**注意**
您必须仅为您的使用案例配置安全性。您无需为 Amazon RDS 管理的过程配置安全访问。这些过程包括创建备份、在主数据库实例和只读副本之间复制数据以及其他过程。
有关管理对 Amazon RDS 资源和您的数据库实例上的数据库的访问的更多信息，请参阅以下主题。
**Topics**
+ [
# Amazon RDS 的数据库身份验证
](database-authentication.md)
+ [
# 使用 Amazon RDS 和 AWS Secrets Manager 管理密码
](rds-secrets-manager.md)
+ [
# Amazon RDS 中的数据保护
](DataDurability.md)
+ [
# Amazon RDS 的 Identity and Access Management
](UsingWithRDS.IAM.md)
+ [
# Amazon RDS 中的日志记录和监控
](Overview.LoggingAndMonitoring.md)
+ [
# Amazon RDS 的合规性验证
](RDS-compliance.md)
+ [
# Amazon RDS 中的弹性
](disaster-recovery-resiliency.md)
+ [
# Amazon RDS 中的基础设施安全性
](infrastructure-security.md)
+ [
# Amazon RDS API 和接口 VPC 终端节点 (AWS PrivateLink)
](vpc-interface-endpoints.md)
+ [
# Amazon RDS 的安全最佳实践
](CHAP_BestPractices.Security.md)
+ [
# 使用安全组控制访问权限
](Overview.RDSSecurityGroups.md)
+ [
# 主用户账户权限
](UsingWithRDS.MasterAccounts.md)
+ [
# 将服务相关角色用于 Amazon RDS
](UsingWithRDS.IAM.ServiceLinkedRoles.md)
+ [
# Amazon VPC 和 Amazon RDS
](USER_VPC.md)
# Amazon RDS 的数据库身份验证
Amazon RDS 支持多种对数据库用户进行身份验证的方法。
密码、Kerberos 和 IAM 数据库身份验证使用不同的方法对数据库进行身份验证。因此，特定用户只能使用一种身份验证方法登录到数据库。
对于 PostgreSQL，仅为特定数据库的用户使用以下角色设置之一：
+ 要使用 IAM 数据库身份验证，请为用户分配 `rds_iam` 角色。
+ 要使用 Kerberos 数据库身份验证，请为用户分配 `rds_ad` 角色。
+ 要使用密码身份验证，请勿为用户分配 `rds_iam` 或 `rds_ad` 角色。
不要通过嵌套的授予访问权限直接或间接地将 `rds_iam` 和 `rds_ad` 角色分配给 PostgreSQL 数据库的用户。如果将 `rds_iam` 角色添加到主用户，IAM 身份验证优先于密码身份验证，因此主用户必须以 IAM 用户身份登录。
**重要**
我们强烈建议不要直接在应用程序中使用主用户。请遵守使用数据库用户的最佳实践，按照您的应用程序所需的最少权限创建用户。
**Topics**
+ [
## 密码验证
](#password-authentication)
+ [
## IAM 数据库身份验证
](#iam-database-authentication)
+ [
## Kerberos 身份验证
](#kerberos-authentication)
## 密码验证
使用*密码身份验证*，数据库将执行用户账户的所有管理。您可以使用 `CREATE USER` 等 SQL 语句创建用户，其中包含数据库引擎指定密码所需的适当子句。例如，在 MySQL 中，语句为 `CREATE USER` *名称* `IDENTIFIED BY` *密码*，而在 PostgreSQL 中，语句为 `CREATE USER` *名称* `WITH PASSWORD` *密码*。
使用密码身份验证，数据库可控制和验证用户账户。如果数据库引擎具有强大的密码管理功能，那么可以增强安全性。当您拥有较小的用户社区时，使用密码身份验证可能更易于管理数据库身份验证。因为在这种情况下会生成明文密码，因此与 AWS Secrets Manager 集成可以增强安全性。
有关将 Secrets Manager 与 Amazon RDS 结合使用的信息，请参阅《AWS Secrets Manager User Guide》**中的 [Creating a basic secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) 和 [Rotating secrets for supported Amazon RDS databases](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets-rds.html)。有关以编程方式在自定义应用程序中检索密钥的信息，请参阅 *AWS Secrets Manager 用户指南*中的[检索密钥值](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_retrieve-secret.html)。
## IAM 数据库身份验证
您可以使用 AWS Identity and Access Management（IAM）数据库身份验证对数据库实例进行身份验证。利用此身份验证方法，您在连接到数据库实例时将无需使用密码。而是使用身份验证令牌。
有关 IAM 数据库身份验证的更多信息，包括特定数据库引擎的可用性信息，请参阅[适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.md)。
## Kerberos 身份验证
Amazon RDS 支持使用 Kerberos 和 Microsoft Active Directory 对数据库用户进行外部身份验证。Kerberos 是一种网络身份验证协议，它使用票证和对称密钥加密，而不再需要通过网络传输密码。Kerberos 已内置到 Active Directory 中，用于在网络资源（如数据库）中对用户进行身份验证。
Amazon RDS 支持 Kerberos 和 Active Directory，从而为数据库用户提供单一登录和集中身份验证的好处。您可以将用户凭证保存在 Active Directory 中。Active Directory 提供了一个集中位置，以存储和管理多个数据库实例的凭证。
要使用来自自行管理的 Active Directory 的凭证，您需要针对数据库实例加入的 Microsoft Active Directory 设置与 Directory Service 的信任关系。
RDS for PostgreSQL 和 RDS for MySQL 通过全林性身份验证或选择性身份验证，支持单向和双向林信任关系。
在某些情况下，可以通过外部信任关系配置 Kerberos 身份验证。这要求自行管理的 Active Directory 具有更多设置。这包括但不限于 [Kerberos Forest Search Order](https://learn.microsoft.com/en-us/troubleshoot/windows-server/active-directory/kfso-not-work-in-external-trust-event-is-17)。
Microsoft SQL Server 和 PostgreSQL 数据库实例支持单向和双向林信任关系。Oracle 数据库实例支持单向和双向外部和林信任关系。有关更多信息，请参阅 *Directory Service 管理指南* 中的[何时创建信任关系](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/setup_trust.html)。
有关针对特定数据库引擎的 Kerberos 身份验证的信息，请参阅以下内容：
+ [将 AWS Managed Active Directory 用于 RDS for SQL Server](USER_SQLServerWinAuth.md)
+ [对 Amazon RDS for MySQL 进行 Kerberos 身份验证](mysql-kerberos.md)
+ [为 Amazon RDS for Oracle 配置 Kerberos 身份验证](oracle-kerberos.md)
+ [在 Amazon RDS for PostgreSQL 中使用 Kerberos 身份验证](postgresql-kerberos.md)
+ [将 Kerberos 身份验证用于 Amazon RDS for Db2](db2-kerberos.md) .
**注意**
目前，MariaDB 数据库实例不支持 Kerberos 身份验证。
# 使用 Amazon RDS 和 AWS Secrets Manager 管理密码
Amazon RDS 集成了 Secrets Manager，以管理您的数据库实例和多可用区数据库集群的主用户密码。
**Topics**
+ [
## Secrets Manager 与 Amazon RDS 集成的限制
](#rds-secrets-manager-limitations)
+ [
## 使用 AWS Secrets Manager 管理主用户密码的概述
](#rds-secrets-manager-overview)
+ [
## 使用 Secrets Manager 管理主用户密码的优势
](#rds-secrets-manager-benefits)
+ [
## Secrets Manager 集成所需的权限
](#rds-secrets-manager-permissions)
+ [
## 强制 RDS 在 AWS Secrets Manager 中管理主用户密码
](#rds-secrets-manager-auth)
+ [
## 使用 Secrets Manager 管理数据库实例的主用户密码
](#rds-secrets-manager-db-instance)
+ [
## 使用 Secrets Manager 管理 RDS for Oracle 租户数据库的主用户密码
](#rds-secrets-manager-tenant)
+ [
## 使用 Secrets Manager 管理多可用区数据库集群的主用户密码
](#rds-secrets-manager-db-cluster)
+ [
## 轮换数据库实例的主用户密码密钥
](#rds-secrets-manager-rotate-db-instance)
+ [
## 轮换多可用区数据库集群的主用户密码密钥
](#rds-secrets-manager-rotate-db-cluster)
+ [
## 查看有关数据库实例的密钥的详细信息
](#rds-secrets-manager-view-db-instance)
+ [
## 查看有关多可用区数据库集群的密钥的详细信息
](#rds-secrets-manager-view-db-cluster)
+ [
## 查看有关租户数据库的密钥的详细信息
](#rds-secrets-manager-view-tenant)
+ [
## 区域和版本可用性
](#rds-secrets-manager-availability)
## Secrets Manager 与 Amazon RDS 集成的限制
以下功能不支持使用 Secrets Manager 管理主用户密码：
+ 在源数据库或数据库集群使用 Secrets Manager 管理凭证时创建只读副本。这适用于除 RDS for SQL Server 之外的所有数据库引擎。
+ Amazon RDS 蓝绿部署
+ Amazon RDS Custom
+ Oracle Data Guard 切换
## 使用 AWS Secrets Manager 管理主用户密码的概述
借助 AWS Secrets Manager，您可以将代码中的硬编码凭证（包括数据库密码）替换为对 Secrets Manager 的 API 调用，从而以编程方式检索密钥。有关 Secrets Manager 的更多信息，请参阅《AWS Secrets Manager 用户指南》[https://docs.aws.amazon.com/secretsmanager/latest/userguide/](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
当您在 Secrets Manager 中存储数据库密钥时，您的 AWS 账户会产生费用。有关定价的信息，请参阅 [AWS Secrets Manager 定价](https://aws.amazon.com/secrets-manager/pricing)。
在执行以下操作之一时，您可以指定 RDS 在 Secrets Manager 中管理 Amazon RDS 数据库实例或多可用区数据库集群的主用户密码：
+ 创建数据库实例
+ 创建多可用区数据库集群
+ 在 RDS for Oracle CDB 中创建租户数据库
+ 修改数据库实例
+ 修改多可用区数据库集群
+ 修改租户数据库（仅限 RDS for Oracle）
+ 从 Amazon S3 还原数据库实例
+ 将数据库实例从快照还原到某个时间点（仅限 RDS for Oracle）
当您指定 RDS 在 Secrets Manager 中管理主用户密码时，RDS 会生成密码并将其存储在 Secrets Manager 中。您可以直接与密钥交互以检索主用户的凭证。您还可以指定客户托管密钥来加密密钥，或者使用 Secrets Manager 提供的 KMS 密钥。
RDS 管理密钥的设置，默认情况下每七天轮换一次密钥。您可以修改某些设置，例如轮换计划。如果您删除在 Secrets Manager 中管理密钥的数据库实例，则该密钥及其关联的元数据也会被删除。
要使用密钥中的凭证连接到数据库实例或多可用区数据库集群，您可以从 Secrets Manager 检索密钥。有关更多信息，请参阅《AWS Secrets Manager 用户指南》**中的[从 AWS Secrets Manager 中检索密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)和[使用 AWS Secrets Manager 密钥中的凭证连接到 SQL 数据库](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_jdbc.html)。
## 使用 Secrets Manager 管理主用户密码的优势
使用 Secrets Manager 管理 RDS 主用户密码具有以下优势：
+ RDS 会自动生成数据库凭证。
+ RDS 会自动在 AWS Secrets Manager 中存储和管理数据库凭证。
+ RDS 定期轮换数据库凭证，而无需更改应用程序。
+ Secrets Manager 保护数据库凭证免受人员访问和纯文本视图的影响。
+ Secrets Manager 允许在密钥中检索数据库凭证以进行数据库连接。
+ Secrets Manager 允许使用 IAM 细粒度控制对密钥中的数据库凭证的访问权限。
+ 您可以选择使用不同的 KMS 密钥将数据库加密与凭证加密分开。
+ 您可以省去手动管理和轮换数据库凭证。
+ 您可以使用 AWS CloudTrail 和 Amazon CloudWatch 轻松监控数据库凭证。
有关 Secrets Manager 的优势的更多信息，请参阅 [AWS Secrets Manager 用户指南](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
## Secrets Manager 集成所需的权限
用户必须拥有所需的权限才能执行与 Secrets Manager 集成相关的操作。您可以创建 IAM policy，以便授予权限对所需的指定资源执行特定的 API 操作。然后，可以将这些策略附加到需要这些权限的 IAM 权限集或角色。有关更多信息，请参阅 [Amazon RDS 的 Identity and Access Management](UsingWithRDS.IAM.md)。
对于创建、修改或还原操作，指定 Amazon RDS 在 Secrets Manager 中管理主用户密码的用户必须具有执行以下操作的权限：
+ `kms:DescribeKey`
+ `secretsmanager:CreateSecret`
+ `secretsmanager:TagResource`
需要 `kms:DescribeKey` 权限才能访问 `MasterUserSecretKmsKeyId` 的客户托管密钥并描述 `aws/secretsmanager`。
对于创建、修改或还原操作，指定用于在 Secrets Manager 中加密密钥的客户托管密钥的用户必须具有执行以下操作的权限：
+ `kms:Decrypt`
+ `kms:GenerateDataKey`
+ `kms:CreateGrant`
对于修改操作，在 Secrets Manager 中轮换主用户密码的用户必须具有执行以下操作的权限：
+ `secretsmanager:RotateSecret`
## 强制 RDS 在 AWS Secrets Manager 中管理主用户密码
您可以使用 IAM 条件密钥强制 RDS 在 AWS Secrets Manager 中管理主用户密码。除非主用户密码由 RDS 在 Secrets Manager 中进行管理，否则以下策略不支持用户创建或还原数据库实例或数据库集群，或者创建或修改租户数据库。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": ["rds:CreateDBInstance", "rds:CreateDBCluster", "rds:RestoreDBInstanceFromS3", "rds:RestoreDBClusterFromS3",
"rds:RestoreDBInstanceFromDBSnapshot", "rds:RestoreDBInstanceToPointInTime", "rds:CreateTenantDatabase",
"rds:ModifyTenantDatabase"],
"Resource": "*",
"Condition": {
"Bool": {
"rds:ManageMasterUserPassword": false
}
}
}
]
}
```
------
**注意**
此策略在创建时在 AWS Secrets Manager 中强制执行密码管理。但是，您仍然可以禁用 Secrets Manager 集成，并通过修改实例手动设置主密码。
为防止这种情况，请在策略的操作块中包括 `rds:ModifyDBInstance`、`rds:ModifyDBCluster`。请注意，这可以防止用户对未启用 Secrets Manager 集成的现有实例进行任何进一步修改。
有关在 IAM 策略中使用条件密钥的更多信息，请参阅 [Amazon RDS 的策略条件键](security_iam_service-with-iam.md#UsingWithRDS.IAM.Conditions) 和 [示例策略：使用条件键](UsingWithRDS.IAM.Conditions.Examples.md)。
## 使用 Secrets Manager 管理数据库实例的主用户密码
执行以下操作时，可以配置 RDS 在 Secrets Manager 中管理主用户密码：
+ [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)
+ [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)
+ [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md)
+ [还原到数据库实例](USER_RestoreFromSnapshot.md)（仅限 RDS for Oracle）
+ [将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)（仅限 RDS for Oracle）
您可以使用 RDS 控制台、AWS CLI 或 RDS API 来执行上述操作。
### 控制台
按照说明使用 RDS 控制台创建或修改数据库实例：
+ [创建数据库实例](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating)
+ [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)
+ [将数据从 Amazon S3 导入到新的 MySQL 数据库实例](MySQL.Procedural.Importing.md#MySQL.Procedural.Importing.PerformingImport)
当您使用 RDS 控制台执行其中一项操作时，可以在 Secrets Manager 中指定主用户密码由 RDS 管理。当您创建或还原数据库实例时，请在**凭证设置**中选择**在 AWS Secrets Manager 中管理主凭证**。修改数据库实例时，请在**设置**中选择**在 AWS Secrets Manager 中管理主凭证**。
下图是在创建或还原数据库实例时**在 AWS Secrets Manager 中管理主凭证**设置的示例。
![\[在 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-credential-settings-db-instance.png)
当您选择此选项时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
![\[在所选的 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-create-db-instance.png)
您可以选择使用 Secrets Manager 提供的 KMS 密钥或您创建的客户托管密钥对密钥进行加密。在 RDS 管理数据库实例的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。有关创建数据库实例时的可用设置的更多信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。有关修改数据库实例时的可用设置的更多信息，请参阅[数据库实例的设置](USER_ModifyInstance.Settings.md)。
### AWS CLI
要在 Secrets Manager 中使用 RDS 管理主用户密码，请在以下 AWS CLI 命令之一中指定 `--manage-master-user-password` 选项：
+ [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)
+ [restore-db-instance-from-s3](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html)
+ [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)（仅限 RDS for Oracle）
+ [restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)（仅限 RDS for Oracle）
当您在这些命令中指定 `--manage-master-user-password` 选项时，RDS 会生成主用户密码，并在其整个生命周期中在 Secrets Manager 中对其进行管理。
要加密密钥，您可以指定客户托管式密钥或使用 Secrets Manager 提供的原定设置 KMS 密钥。使用 `--master-user-secret-kms-key-id` 选项指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理数据库实例的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。有关创建数据库实例时的可用设置的更多信息，请参阅 [数据库实例的设置](USER_CreateDBInstance.Settings.md)。有关修改数据库实例时的可用设置的更多信息，请参阅 [数据库实例的设置](USER_ModifyInstance.Settings.md)。
以下示例创建一个数据库实例，并指定 RDS 在 Secrets Manager 中管理主用户密码。此密钥使用 Secrets Manager 提供的 KMS 密钥进行加密。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --engine mysql \
4. --engine-version 8.0.39 \
5. --db-instance-class db.r5b.large \
6. --allocated-storage 200 \
7. --master-username testUser \
8. --manage-master-user-password
```
对于：Windows
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --engine mysql ^
4. --engine-version 8.0.39 ^
5. --db-instance-class db.r5b.large ^
6. --allocated-storage 200 ^
7. --master-username testUser ^
8. --manage-master-user-password
```
### RDS API
要指定 RDS 在 Secrets Manager 中管理主用户密码，请在以下 RDS API 操作之一中将 `ManageMasterUserPassword` 参数设置为 `true`：
+ [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)
+ [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)
+ [RestoreDBInstanceFromS3](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html)
+ [RestoreDBInstanceFromSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromSnapshot.html)（仅限 RDS for Oracle）
+ [RestoreDBInstanceToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)（仅限 RDS for Oracle）
当您在其中一个操作中将 `ManageMasterUserPassword` 参数设置为 `true` 时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
要加密密钥，您可以指定客户托管式密钥或使用 Secrets Manager 提供的原定设置 KMS 密钥。使用 `MasterUserSecretKmsKeyId` 参数指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理数据库实例的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
## 使用 Secrets Manager 管理 RDS for Oracle 租户数据库的主用户密码
执行以下操作时，可以配置 RDS 在 Secrets Manager 中管理主用户密码：
+ [将 RDS for Oracle 租户数据库添加到您的 CDB 实例](oracle-cdb-configuring.adding.pdb.md)
+ [修改 RDS for Oracle 租户数据库](oracle-cdb-configuring.modifying.pdb.md)
您可以使用 RDS 控制台、AWS CLI 或 RDS API 来执行前面的操作。
### 控制台
按照使用 RDS 控制台创建或修改 RDS for Oracle 租户数据库的说明进行操作：
+ [将 RDS for Oracle 租户数据库添加到您的 CDB 实例](oracle-cdb-configuring.adding.pdb.md)
+ [修改 RDS for Oracle 租户数据库](oracle-cdb-configuring.modifying.pdb.md)
当您使用 RDS 控制台执行上述操作之一时，您可以指定 RDS 在 Secrets Manager 中管理主密码。创建租户数据库时，请在**凭证设置**中选择**在 AWS Secrets Manager 中管理主凭证**。修改租户数据库时，请在**设置**中选择**在 AWS Secrets Manager 中管理主凭证**。
下图是在创建租户数据库时**在 AWS Secrets Manager 中管理主凭证**设置的示例。
![\[在 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-credential-settings-db-instance.png)
当您选择此选项时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
![\[在所选的 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-create-db-instance.png)
您可以选择使用 Secrets Manager 提供的 KMS 密钥或您创建的客户托管密钥对密钥进行加密。在 RDS 管理租户数据库的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。有关创建租户数据库时的可用设置的更多信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。有关修改租户数据库时的可用设置的更多信息，请参阅[数据库实例的设置](USER_ModifyInstance.Settings.md)。
### AWS CLI
要在 Secrets Manager 中使用 RDS 管理主用户密码，请在以下 AWS CLI 命令之一中指定 `--manage-master-user-password` 选项：
+ [create-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/create-tenant-database.html)
+ [modify-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-tenant-database.html)
当您在前面的命令中指定 `--manage-master-user-password` 选项时，RDS 会生成主用户密码，并在其整个生命周期内在 Secrets Manager 中管理此密码。
要加密密钥，您可以指定客户托管密钥或使用 Secrets Manager 提供的默认 KMS 密钥。使用 `--master-user-secret-kms-key-id` 选项指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理租户数据库的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。有关创建租户数据库时的可用设置的更多信息，请参阅 [create-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/create-tenant-database.html)。有关修改租户数据库时的可用设置的更多信息，请参阅 [modify-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-tenant-database.html)。
以下示例创建一个 RDS for Oracle 租户数据库，并指定 RDS 在 Secrets Manager 中管理主用户密码。此密钥使用 Secrets Manager 提供的 KMS 密钥进行加密。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name mypdb2 \
4. --master-username mypdb2-admin \
5. --character-set-name UTF-16 \
6. --manage-master-user-password
```
对于：Windows
```
1. aws rds create-tenant-database --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name mypdb2 ^
4. --master-username mypdb2-admin ^
5. --character-set-name UTF-16 ^
6. --manage-master-user-password
```
### RDS API
要指定 RDS 在 Secrets Manager 中管理主用户密码，请在以下 RDS API 操作之一中将 `ManageMasterUserPassword` 参数设置为 `true`：
+ [CreateTenantDatabase](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateTenantDatabase.html)
+ [ModifyTenantDatabase](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyTenantDatabase.html)
当您在其中一个操作中将 `ManageMasterUserPassword` 参数设置为 `true` 时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
要加密密钥，您可以指定客户托管式密钥或使用 Secrets Manager 提供的原定设置 KMS 密钥。使用 `MasterUserSecretKmsKeyId` 参数指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理租户数据库的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
## 使用 Secrets Manager 管理多可用区数据库集群的主用户密码
执行以下操作时，可以配置 RDS 在 Secrets Manager 中管理主用户密码：
+ [创建 Amazon RDS 的多可用区数据库集群](create-multi-az-db-cluster.md)
+ [修改 Amazon RDS 的多可用区数据库集群](modify-multi-az-db-cluster.md)
您可以使用 RDS 控制台、AWS CLI 或 RDS API 来执行这些操作。
### 控制台
按照说明使用 RDS 控制台创建或修改多可用区数据库集群：
+ [创建数据库集群](create-multi-az-db-cluster.md#create-multi-az-db-cluster-creating)
+ [修改 Amazon RDS 的多可用区数据库集群](modify-multi-az-db-cluster.md)
当您使用 RDS 控制台执行其中一项操作时，可以在 Secrets Manager 中指定主用户密码由 RDS 管理。要在创建数据库集群时执行此操作，请在**凭证设置**中选择**在 AWS Secrets Manager 中管理主凭证**。修改数据库集群时，请在**设置**中选择**在 AWS Secrets Manager 中管理主凭证**。
下图是在创建数据库集群时**在 AWS Secrets Manager 中管理主凭证**的示例。
![\[在 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-credential-settings.png)
当您选择此选项时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
![\[在所选的 AWS Secrets Manager 中管理主凭证\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-create.png)
您可以选择使用 Secrets Manager 提供的 KMS 密钥或您创建的客户托管密钥对密钥进行加密。在 RDS 管理数据库集群的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。
有关创建多可用区数据库集群时的可用设置的更多信息，请参阅 [创建多可用区数据库集群的设置](create-multi-az-db-cluster.md#create-multi-az-db-cluster-settings)。有关修改多可用区数据库集群时的可用设置的更多信息，请参阅 [修改多可用区数据库集群的设置](modify-multi-az-db-cluster.md#modify-multi-az-db-cluster-settings)。
### AWS CLI
要指定 RDS 在 Secrets Manager 中管理主用户密码，请在以下命令之一中指定 `--manage-master-user-password` 选项：
+ [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)
+ [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)
当您在这些命令中指定 `--manage-master-user-password` 选项时，RDS 会生成主用户密码，并在其整个生命周期中在 Secrets Manager 中对其进行管理。
要加密密钥，您可以指定客户托管密钥或使用 Secrets Manager 提供的默认 KMS 密钥。使用 `--master-user-secret-kms-key-id` 选项指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理数据库集群的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
您可以选择其他设置来满足您的要求。
有关创建多可用区数据库集群时的可用设置的更多信息，请参阅 [创建多可用区数据库集群的设置](create-multi-az-db-cluster.md#create-multi-az-db-cluster-settings)。有关修改多可用区数据库集群时的可用设置的更多信息，请参阅 [修改多可用区数据库集群的设置](modify-multi-az-db-cluster.md#modify-multi-az-db-cluster-settings)。
此示例创建一个多可用区数据库集群，并指定 RDS 在 Secrets Manager 中管理密码。此密钥使用 Secrets Manager 提供的 KMS 密钥进行加密。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-db-cluster \
2. --db-cluster-identifier mysql-multi-az-db-cluster \
3. --engine mysql \
4. --engine-version 8.0.39 \
5. --backup-retention-period 1 \
6. --allocated-storage 4000 \
7. --storage-type io1 \
8. --iops 10000 \
9. --db-cluster-instance-class db.r6gd.xlarge \
10. --master-username testUser \
11. --manage-master-user-password
```
对于：Windows
```
1. aws rds create-db-cluster ^
2. --db-cluster-identifier mysql-multi-az-db-cluster ^
3. --engine mysql ^
4. --engine-version 8.0.39 ^
5. --backup-retention-period 1 ^
6. --allocated-storage 4000 ^
7. --storage-type io1 ^
8. --iops 10000 ^
9. --db-cluster-instance-class db.r6gd.xlarge ^
10. --master-username testUser ^
11. --manage-master-user-password
```
### RDS API
要指定 RDS 在 Secrets Manager 中管理主用户密码，请在以下操作之一中将 `ManageMasterUserPassword` 参数设置为 `true`：
+ [CreateDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html)
+ [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html)
当您在其中一个操作中将 `ManageMasterUserPassword` 参数设置为 `true` 时，RDS 会生成主用户密码并在其整个生命周期中在 Secrets Manager 中对其进行管理。
要加密密钥，您可以指定客户托管式密钥或使用 Secrets Manager 提供的原定设置 KMS 密钥。使用 `MasterUserSecretKmsKeyId` 参数指定客户托管密钥。AWS KMS 密钥标识符是密钥 ARN、密钥 ID、别名 ARN 或者 KMS 密钥的别名。要使用不同 AWS 账户中的密钥，请指定密钥 ARN 或别名 ARN。在 RDS 管理数据库集群的数据库凭证后，您无法更改用于加密密钥的 KMS 密钥。
## 轮换数据库实例的主用户密码密钥
当 RDS 轮换主用户密码密钥时，Secrets Manager 会为现有密钥生成一个新的密钥版本。密钥的新版本包含新的主用户密码。Amazon RDS 更改数据库实例的主用户密码以匹配新密钥版本的密码。
您可以立即轮换密钥，而不必等待计划的轮换。要在 Secrets Manager 中轮换主用户密码密钥，请修改数据库实例。有关修改数据库实例的信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
您可以使用 RDS 控制台、AWS CLI 或 RDS API 立即轮换主用户密码密钥。新密码长度始终为 28 个字符，包含至少一个大写和小写字母、一个数字和一个标点符号。
### 控制台
要使用 RDS 控制台轮换主用户密码密钥，请修改数据库实例并在 **Settings**（设置）中选择 **Rotate secret immediately**（立即轮换密钥）。
![\[立即轮换主用户密码密钥\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-rotate.png)
按照[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)中的说明使用 RDS 控制台修改数据库实例。您必须在确认页面上选择 **Apply immediately**（立即应用）。
### AWS CLI
要使用 AWS CLI 轮换主用户密码密钥，请使用 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 命令并指定 `--rotate-master-user-password` 选项。轮换主密码时必须指定 `--apply-immediately` 选项。
此示例轮换主用户密码密钥。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --rotate-master-user-password \
4. --apply-immediately
```
对于：Windows
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --rotate-master-user-password ^
4. --apply-immediately
```
### RDS API
您可以使用 [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) 操作并将 `RotateMasterUserPassword` 参数设置为 `true` 来轮换主用户密码密钥。轮换主密码时，必须将 `ApplyImmediately` 参数设置为 `true`。
## 轮换多可用区数据库集群的主用户密码密钥
当 RDS 轮换主用户密码密钥时，Secrets Manager 会为现有密钥生成一个新的密钥版本。密钥的新版本包含新的主用户密码。Amazon RDS 更改多可用区数据库集群的主用户密码，以匹配新密钥版本的密码。
您可以立即轮换密钥，而不必等待计划的轮换。要在 Secrets Manager 中轮换主用户密码密钥，请修改多可用区数据库集群。有关修改多可用区数据库集群的信息，请参阅 [修改 Amazon RDS 的多可用区数据库集群](modify-multi-az-db-cluster.md)。
您可以使用 RDS 控制台、AWS CLI 或 RDS API 立即轮换主用户密码密钥。新密码长度始终为 28 个字符，包含至少一个大写和小写字母、一个数字和一个标点符号。
### 控制台
要使用 RDS 控制台轮换主用户密码密钥，请修改多可用区数据库集群并在 **Settings**（设置）中选择 **Rotate secret immediately**（立即轮换密钥）。
![\[立即轮换主用户密码密钥\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-rotate-taz-cluster.png)
按照[修改 Amazon RDS 的多可用区数据库集群](modify-multi-az-db-cluster.md)中的说明使用 RDS 控制台修改多可用区数据库集群。您必须在确认页面上选择 **Apply immediately**（立即应用）。
### AWS CLI
要使用 AWS CLI 轮换主用户密码密钥，请使用 [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) 命令并指定 `--rotate-master-user-password` 选项。轮换主密码时必须指定 `--apply-immediately` 选项。
此示例轮换主用户密码密钥。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds modify-db-cluster \
2. --db-cluster-identifier mydbcluster \
3. --rotate-master-user-password \
4. --apply-immediately
```
对于：Windows
```
1. aws rds modify-db-cluster ^
2. --db-cluster-identifier mydbcluster ^
3. --rotate-master-user-password ^
4. --apply-immediately
```
### RDS API
您可以使用 [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) 操作并将 `RotateMasterUserPassword` 参数设置为 `true` 来轮换主用户密码密钥。轮换主密码时，必须将 `ApplyImmediately` 参数设置为 `true`。
## 查看有关数据库实例的密钥的详细信息
您可以使用控制台（[https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)）或 AWS CLI（[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager 命令）检索您的密钥。
您可以使用 RDS 控制台、AWS CLI 或 RDS API 找到 RDS 在 Secrets Manager 中管理的密钥的 Amazon 资源名称（ARN）。
### 控制台
**查看有关 RDS 在 Secrets Manager 中管理的密钥的详细信息**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择数据库实例的名称以显示其详细信息。
1. 选择**配置**选项卡。
在 **Master Credentials ARN**（主凭证 ARN）中，您可以查看密钥 ARN。
![\[查看有关 RDS 在 Secrets Manager 中管理的密钥的详细信息\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-view-instance.png)
您可以单击 **Manage in Secrets Manager**（在 Secrets Manager 中管理）链接，以在 Secrets Manager 控制台中查看和管理密钥。
### AWS CLI
您可以使用 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) RDS CLI 命令找到有关 RDS 在 Secrets Manager 中管理的密钥的以下信息：
+ `SecretArn` – 密钥的 ARN
+ `SecretStatus` – 密钥的状态
可能的状态值包括：
+ `creating` – 密钥正在创建中。
+ `active` – 密钥可用于正常使用和轮换。
+ `rotating` – 密钥正在轮换。
+ `impaired` – 密钥可用于访问数据库凭证，但不能轮换。例如，如果更改权限以使 RDS 无法再访问密钥或密钥的 KMS 密钥，则密钥可能具有此状态。
当密钥具有此状态时，您可以更正导致该状态的条件。如果您更正导致状态的条件，则状态会一直保持为 `impaired`，直至下一次轮换。或者，您可以修改数据库实例以关闭数据库凭证的自动管理，然后再次修改数据库实例以启用数据库凭证的自动管理。要修改数据库实例，请在 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 命令中使用 `--manage-master-user-password` 选项。
+ `KmsKeyId` – 用于加密密钥的 KMS 密钥的 ARN
指定 `--db-instance-identifier` 选项可显示特定数据库实例的输出。此示例显示数据库实例使用的密钥的输出。
**Example**
```
1. aws rds describe-db-instances --db-instance-identifier mydbinstance
```
以下是密钥的示例输出：
```
"MasterUserSecret": {
"SecretArn": "arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!db-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx",
"SecretStatus": "active",
"KmsKeyId": "arn:aws:kms:eu-west-1:123456789012:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
```
当您拥有密钥 ARN 时，您可以使用 [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager CLI 命令查看有关该密钥的详细信息。
此示例显示先前示例输出中的密钥的详细信息。
**Example**
对于 Linux、macOS 或 Unix：
```
aws secretsmanager get-secret-value \
--secret-id 'arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!db-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx'
```
对于：Windows
```
aws secretsmanager get-secret-value ^
--secret-id 'arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!db-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx'
```
### RDS API
您可以使用 [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) 操作并将 `DBInstanceIdentifier` 参数设置为数据库实例标识符，查看 RDS 在 Secrets Manager 中管理的密钥的 ARN、状态和 KMS 密钥。输出中包含有关密钥的详细信息。
当您拥有密钥 ARN 时，您可以使用 [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) Secrets Manager 操作查看有关该密钥的详细信息。
## 查看有关多可用区数据库集群的密钥的详细信息
您可以使用控制台（[https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)）或 AWS CLI（[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager 命令）检索您的密钥。
您可以使用 RDS 控制台、AWS CLI 或 RDS API 找到 RDS 在 Secrets Manager 中管理的密钥的 Amazon 资源名称（ARN）。
### 控制台
**查看有关 Secrets Manager 中 RDS 管理的密钥的详细信息**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择多可用区数据库集群的名称以显示其详细信息。
1. 选择**配置**选项卡。
在 **Master Credentials ARN**（主凭证 ARN）中，您可以查看密钥 ARN。
![\[查看有关 RDS 在 Secrets Manager 中管理的密钥的详细信息\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/secrets-manager-integration-view-taz-cluster.png)
您可以单击 **Manage in Secrets Manager**（在 Secrets Manager 中管理）链接，以在 Secrets Manager 控制台中查看和管理密钥。
### AWS CLI
您可以使用 RDS AWS CLI [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html) 命令查找有关 RDS 在 Secrets Manager 中管理的密钥的以下信息：
+ `SecretArn` – 密钥的 ARN
+ `SecretStatus` – 密钥的状态
可能的状态值包括：
+ `creating` – 密钥正在创建中。
+ `active` – 密钥可用于正常使用和轮换。
+ `rotating` – 密钥正在轮换。
+ `impaired` – 密钥可用于访问数据库凭证，但不能轮换。例如，如果更改权限以使 RDS 无法再访问密钥或密钥的 KMS 密钥，则密钥可能具有此状态。
当密钥具有此状态时，您可以更正导致该状态的条件。如果您更正导致状态的条件，则状态会一直保持为 `impaired`，直至下一次轮换。或者，您可以修改数据库集群以关闭数据库凭证的自动管理，然后再次修改数据库集群以开启数据库凭证的自动管理。要修改数据库集群，请在 [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) 命令中使用 `--manage-master-user-password` 选项。
+ `KmsKeyId` – 用于加密密钥的 KMS 密钥的 ARN
指定 `--db-cluster-identifier` 选项可显示特定数据库集群的输出。此示例显示数据库集群使用的密钥的输出。
**Example**
```
1. aws rds describe-db-clusters --db-cluster-identifier mydbcluster
```
以下示例显示密钥的输出：
```
"MasterUserSecret": {
"SecretArn": "arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!cluster-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx",
"SecretStatus": "active",
"KmsKeyId": "arn:aws:kms:eu-west-1:123456789012:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
```
当您拥有密钥 ARN 时，您可以使用 [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager CLI 命令查看有关该密钥的详细信息。
此示例显示先前示例输出中的密钥的详细信息。
**Example**
对于 Linux、macOS 或 Unix：
```
aws secretsmanager get-secret-value \
--secret-id 'arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!cluster-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx'
```
对于：Windows
```
aws secretsmanager get-secret-value ^
--secret-id 'arn:aws:secretsmanager:eu-west-1:123456789012:secret:rds!cluster-033d7456-2c96-450d-9d48-f5de3025e51c-xmJRDx'
```
### RDS API
您可以使用 [DescribeDBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) RDS 操作并将 `DBClusterIdentifier` 参数设置为数据库集群标识符，查看 RDS 在 Secrets Manager 中管理的密钥的 ARN、状态和 KMS 密钥。输出中包含有关密钥的详细信息。
当您拥有密钥 ARN 时，您可以使用 [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) Secrets Manager 操作查看有关该密钥的详细信息。
## 查看有关租户数据库的密钥的详细信息
您可以使用控制台（[https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)）或 AWS CLI（[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager 命令）检索您的密钥。
您可以使用 Amazon RDS 控制台、AWS CLI 或 Amazon RDS API 找到 Amazon RDS 在 AWS Secrets Manager 中管理的密钥的 Amazon 资源名称（ARN）。
### 控制台
**查看有关 Amazon RDS 在 AWS Secrets Manager 中管理的租户数据库密钥的详细信息**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择包含租户数据库的数据库实例的名称，即可显示其详细信息。
1. 选择**配置**选项卡。
在**租户数据库**部分，找到租户数据库并查看其**主凭证 ARN**。
您可以单击 **Manage in Secrets Manager**（在 Secrets Manager 中管理）链接，以在 Secrets Manager 控制台中查看和管理密钥。
### AWS CLI
您可以使用 [describe-tenant-databases](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-tenant-databases.html) Amazon RDS AWS CLI 命令找到有关 Amazon RDS 在 AWS Secrets Manager 中管理的租户数据库密钥的以下信息：
+ `SecretArn` – 密钥的 ARN
+ `SecretStatus` – 密钥的状态
可能的状态值包括：
+ `creating` – 密钥正在创建中。
+ `active` – 密钥可用于正常使用和轮换。
+ `rotating` – 密钥正在轮换。
+ `impaired` – 密钥可用于访问数据库凭证，但不能轮换。例如，如果权限发生了更改，使得 Amazon RDS 无法再访问密钥或密钥的 KMS 密钥，则密钥可能具有此状态。
当密钥具有此状态时，您可以更正导致该状态的条件。如果您更正导致状态的条件，则状态会一直保持为 `impaired`，直至下一次轮换。或者，您可以修改租户数据库以关闭数据库凭证的自动管理，然后再次修改租户数据库以开启数据库凭证的自动管理。要修改租户数据库，请在 [modify-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-tenant-database.html) 命令中使用 `--manage-master-user-password` 选项。
+ `KmsKeyId` – 用于加密密钥的 KMS 密钥的 ARN
指定 `--db-instance-identifier` 选项可显示特定数据库实例中的租户数据库输出。您也可以指定 `--tenant-db-name` 选项来显示特定租户数据库的输出。此示例显示租户数据库使用的密钥的输出。
**Example**
```
1. aws rds describe-tenant-databases \
2. --db-instance-identifier database-3 \
3. --query "TenantDatabases[0].MasterUserSecret"
```
以下是密钥的示例输出：
```
{
"SecretArn": "arn:aws:secretsmanager:us-east-2:123456789012:secret:rds!db-ABC123",
"SecretStatus": "active",
"KmsKeyId": "arn:aws:kms:us-east-2:123456789012:key/aa11bb22-####-####-####-fedcba123456"
}
```
当您拥有密钥 ARN 时，您可以使用 [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Secrets Manager AWS CLI 命令查看有关该密钥的详细信息。
此示例显示先前示例输出中的密钥的详细信息。
**Example**
对于 Linux、macOS 或 Unix：
```
aws secretsmanager get-secret-value \
--secret-id 'arn:aws:secretsmanager:us-east-2:123456789012:secret:rds!db-ABC123'
```
对于：Windows
```
aws secretsmanager get-secret-value ^
--secret-id 'arn:aws:secretsmanager:us-east-2:123456789012:secret:rds!db-ABC123'
```
### Amazon RDS API
您可以使用 [DescribeTenantDatabases](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeTenantDatabases.html) 操作并将 `DBInstanceIdentifier` 参数设置为数据库实例标识符，查看 Amazon RDS 在 AWS Secrets Manager 中管理的密钥的 ARN、状态和 KMS 密钥。您也可以将 `TenantDBName` 参数设置为特定的租户数据库名称。输出中包含有关密钥的详细信息。
当您拥有密钥 ARN 时，您可以使用 [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) Secrets Manager 操作查看有关该密钥的详细信息。
## 区域和版本可用性
功能可用性和支持因每个数据库引擎的特定版本以及 AWS 区域而异。有关 Secrets Manager 与 Amazon RDS 集成的版本和区域可用性的更多信息，请参阅 [支持将 Secrets Manager 与 Amazon RDS 进行集成的区域和数据库引擎](Concepts.RDS_Fea_Regions_DB-eng.Feature.SecretsManager.md)。
# Amazon RDS 中的数据保护
AWS [责任共担模式](https://aws.amazon.com/compliance/shared-responsibility-model/)适用于 Amazon Relational Database Service 中的数据保护。如该模式中所述，AWS 负责保护运行所有 AWS 云 的全球基础结构。您负责维护对托管在此基础结构上的内容的控制。您还负责您所使用的 AWS 服务 的安全配置和管理任务。有关数据隐私的更多信息，请参阅[数据隐私常见问题](https://aws.amazon.com/compliance/data-privacy-faq/)。有关欧洲数据保护的信息，请参阅 *AWS Security Blog* 上的 [AWS Shared Responsibility Model and GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) 博客文章。
出于数据保护目的，建议您保护 AWS 账户 凭证并使用 AWS IAM Identity Center 或 AWS Identity and Access Management（IAM）设置单个用户。这样，每个用户只获得履行其工作职责所需的权限。还建议您通过以下方式保护数据：
+ 对每个账户使用多重身份验证（MFA）。
+ 使用 SSL/TLS 与 AWS 资源进行通信。我们要求使用 TLS 1.2，建议使用 TLS 1.3。
+ 使用 AWS CloudTrail 设置 API 和用户活动日记账记录。有关使用 CloudTrail 跟踪来捕获 AWS 活动的信息，请参阅《AWS CloudTrail 用户指南》**中的[使用 CloudTrail 跟踪](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html)。
+ 使用 AWS 加密解决方案以及 AWS 服务中的所有默认安全控制。
+ 使用高级托管安全服务（例如 Amazon Macie），它有助于发现和保护存储在 Amazon S3 中的敏感数据。
+ 如果在通过命令行界面或 API 访问 AWS 时需要经过 FIPS 140-3 验证的加密模块，请使用 FIPS 端点。有关可用的 FIPS 端点的更多信息，请参阅[《美国联邦信息处理标准（FIPS）第 140-3 版》](https://aws.amazon.com/compliance/fips/)。
强烈建议您切勿将机密信息或敏感信息（如您客户的电子邮件地址）放入标签或自由格式文本字段（如**名称**字段）。这包括当您通过控制台、API、AWS CLI 或 AWS SDK 使用 Amazon RDS 或其他 AWS 服务 时。在用于名称的标签或自由格式文本字段中输入的任何数据都可能会用于计费或诊断日志。如果您向外部服务器提供网址，强烈建议您不要在网址中包含凭证信息来验证对该服务器的请求。
**Topics**
+ [
# 使用加密保护数据
](Encryption.md)
+ [
# 互联网络流量隐私
](inter-network-traffic-privacy.md)
# 使用加密保护数据
您可以为数据库资源启用加密。您也可以加密与数据库实例的连接。
**Topics**
+ [
# 加密 Amazon RDS 资源
](Overview.Encryption.md)
+ [
# AWS KMS key 管理
](Overview.Encryption.Keys.md)
+ [
# 使用 SSL/TLS 加密与数据库实例或集群的连接
](UsingWithRDS.SSL.md)
+ [
# 轮换 SSL/TLS 证书
](UsingWithRDS.SSL-certificate-rotation.md)
# 加密 Amazon RDS 资源
Amazon RDS 可以加密您的 Amazon RDS 数据库实例。静态加密的数据包括数据库实例的底层存储、其日志、自动备份、只读副本和快照。
Amazon RDS 加密的数据库实例使用行业标准 AES-256 加密算法，对托管 Amazon RDS 数据库实例的服务器上的数据进行加密。
在加密数据后，Amazon RDS 将以透明方式处理访问的身份验证和数据的解密，并且对性能产生的影响最小。您无需修改数据库客户端应用程序来使用加密。
**注意**
对于加密和未加密数据库实例，将对在源与只读副本之间发送的数据进行加密，即使在 AWS 区域之间复制时也是如此。
**Topics**
+ [
## Amazon RDS 资源加密概览
](#Overview.Encryption.Overview)
+ [
## 加密数据库实例
](#Overview.Encryption.Enabling)
+ [
## 确定是否为数据库实例启用加密
](#Overview.Encryption.Determining)
+ [
## Amazon RDS 加密的可用性
](#Overview.Encryption.Availability)
+ [
## 传输中加密
](#Overview.Encryption.InTransit)
+ [
## Amazon RDS 加密的数据库实例的限制
](#Overview.Encryption.Limitations)
## Amazon RDS 资源加密概览
Amazon RDS 加密的数据库实例通过保护您的数据免受未经授权的访问来为基础存储提供额外一层数据保护。您可以使用 Amazon RDS 加密来增强对云中部署的应用程序的数据保护，并满足静态数据加密的合规性要求。可为 Amazon RDS 加密的数据库实例加密所有日志、备份和快照。有关加密功能的可用性和限制的更多信息，请参阅 [Amazon RDS 加密的可用性](#Overview.Encryption.Availability)和 [Amazon RDS 加密的数据库实例的限制](#Overview.Encryption.Limitations)。
Amazon RDS 使用 AWS Key Management Service 密钥加密这些资源。AWS KMS 将安全、高度可用的硬件和软件结合起来，提供面向云端扩展的密钥管理系统。您可以使用 AWS 托管式密钥，也可以创建客户托管的密钥。
创建加密数据库实例时，您可以为 Amazon RDS 选择客户托管密钥或 AWS 托管式密钥 来加密您的数据库实例。如果您没有为客户托管密钥指定密钥标识符，则 Amazon RDS 会将 AWS 托管式密钥 用于您的新数据库实例。Amazon RDS 为您的 AWS 账户创建用于 Amazon RDS 的 AWS 托管式密钥。您的 AWS 账户在每个 AWS 区域都有用于 Amazon RDS 的不同 AWS 托管式密钥。
要管理用于加密和解密 Amazon RDS 资源的客户自主管理型密钥，您可以使用 [AWS Key Management Service（AWS KMS）](https://docs.aws.amazon.com/kms/latest/developerguide/)。
利用 AWS KMS，您可创建客户自主管理型密钥，并定义策略来控制这些客户自主管理型密钥的使用方式。AWS KMS 支持 CloudTrail，因此，您可审核 KMS 密钥使用情况以验证客户自主管理型密钥是否使用得当。可以将客户托管密钥与 Amazon Aurora 和支持的 AWS 服务（例如 Amazon S3、Amazon EBS 和 Amazon Redshift）结合使用。有关与 AWS KMS 集成的服务的列表，请参阅 [AWS 服务集成](https://aws.amazon.com/kms/features/#AWS_Service_Integration)。关于使用 KMS 密钥的一些注意事项：
+ 创建加密的数据库实例后，您无法更改该数据库实例使用的 KMS 密钥。因此，请确保先确定您的 KMS 密钥要求，然后再创建加密的数据库实例。
如果您必须更改数据库实例的加密密钥，请创建实例的手动快照，然后在复制快照时启用加密。有关更多信息，请参阅 [re:Post 知识文章](https://repost.aws/knowledge-center/update-encryption-key-rds)。
+ 如果复制加密快照，则可以使用不同于用于加密源快照的 KMS 密钥来加密目标快照。
+ Amazon RDS 加密实例的只读副本必须使用与主数据库实例相同的 KMS 密钥进行加密，前提是两者在相同的 AWS 区域中。
+ 如果主数据库实例和只读副本位于不同的 AWS 区域中，则使用该 AWS 区域的 KMS 密钥对只读副本进行加密。
+ 如果快照已使用共享该快照的 AWS 托管式密钥 账户的 AWS 进行加密，则您无法共享该快照。
+ Amazon RDS 还支持利用透明数据加密 (TDE) 对 Oracle 或 SQL Server 数据库实例进行加密。TDE 可以与 RDS 静态加密一起使用，但同时使用 TDE 和 RDS 静态加密可能会稍微影响数据库的性能。您必须为每种加密方法管理不同的密钥。有关 TDE 的更多信息，请参阅 [Oracle 透明数据加密](Appendix.Oracle.Options.AdvSecurity.md) 或 [SQL Server 中的透明数据加密支持](Appendix.SQLServer.Options.TDE.md)。
**重要**
禁用 KMS 密钥后，Amazon RDS 会失去对数据库实例的 KMS 密钥的访问权限。如果您失去了对 KMS 密钥的访问权限，则在启用备份的情况下，加密的数据库实例会在检测后的 2 小时进入 `inaccessible-encryption-credentials-recoverable` 状态。数据库实例将保持此状态七天时间，在此期间实例停止运行。在此期间对该数据库实例进行的 API 调用可能不会成功。要恢复数据库实例，请启用 KMS 密钥并重新启动该数据库实例。从 AWS 管理控制台、AWS CLI 或 RDS API 启用 KMS 密钥。使用 AWS CLI 命令 [start-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/start-db-instance.html) 或 AWS 管理控制台重新启动数据库实例。
`inaccessible-encryption-credentials-recoverable` 状态仅适用于可以停止的数据库实例。这种可恢复的状态不适用于无法停止的实例，例如只读副本和带有只读副本的实例。有关更多信息，请参阅 [停止数据库实例的限制](USER_StopInstance.md#USER_StopInstance.Limitations)。
如果数据库实例未在七天内恢复，则该实例会进入终端 `inaccessible-encryption-credentials` 状态。在此状态下，数据库实例将无法再使用，您只能从备份还原数据库实例。强烈建议您始终对加密的数据库实例启用备份以防止数据库中的加密数据丢失。
在数据库实例创建期间，Amazon RDS 会检查发出调用的主体是否有权访问 KMS 密钥，并从 KMS 密钥中生成授权，该授权将在数据库实例的整个生命周期内使用。撤消发出调用的主体对 KMS 密钥的访问权限，不会影响正在运行的数据库。在跨账户场景中使用 KMS 密钥时，例如将快照复制到其他账户，需要与其他账户共享 KMS 密钥。如果您从快照创建数据库实例但未指定不同的 KMS 密钥，则新实例将使用源账户中的 KMS 密钥。创建数据库实例后，撤消密钥访问权限不会影响实例。但是，禁用某个密钥会影响使用该密钥加密的所有数据库实例。为防止出现这种情况，请在快照复制操作期间指定不同的密钥。
在实例修改或恢复期间，具有禁用备份的数据库实例将一直可用，直到卷与主机分离。如果适用，RDS 会将实例移至 `inaccessible-encryption-credentials-recoverable` 状态或 `inaccessible-encryption-credentials` 状态。
有关 KMS 密钥的更多信息，请参阅《AWS Key Management Service 开发人员指南》**中的 [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys) 和[AWS KMS key 管理](Overview.Encryption.Keys.md)。
## 加密数据库实例
要加密新数据库实例，请在 Amazon RDS 控制台上，选择 **Enable encryption**（启用加密）。想要了解有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
如果使用 [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) AWS CLI 命令创建加密的数据库实例，请设置 `--storage-encrypted` 参数。如果使用 [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) API 操作，请将 `StorageEncrypted` 参数设置为 true。
如果使用 AWS CLI `create-db-instance` 命令创建带有客户托管密钥的加密数据库实例，请将 `--kms-key-id` 参数设置为 KMS 密钥的任何密钥标识符。如果您使用 Amazon RDS API `CreateDBInstance` 操作，请将 `KmsKeyId` 参数设置为 KMS 密钥的任何密钥标识符。要在其他 AWS 账户中使用客户托管密钥，请指定密钥 ARN 或别名 ARN。
## 确定是否为数据库实例启用加密
您可以使用 AWS 管理控制台、AWS CLI 或 RDS API 确定是否为数据库实例开启静态加密。
### 控制台
**要确定是否为数据库实例开启静态加密**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择要检查的数据库实例的名称以显示其详细信息。
1. 选择 **Configuration**（配置）选项卡，然后检查 **Storage**（存储）下的 **Encryption**（加密）值。
它显示 **Enabled**（已启用）或 **Not enabled**（未启用）。
![\[检查数据库实例的静态加密\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/encryption-check-db-instance.png)
### AWS CLI
要使用 AWS CLI 确定是否已为数据库实例启用静态加密，请使用以下选项调用 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令：
+ `--db-instance-identifier` – 数据库实例的名称。
下面的示例使用查询就 `mydb` 数据库实例的静态加密返回 `TRUE` 或 `FALSE`。
**Example**
```
1. aws rds describe-db-instances --db-instance-identifier mydb --query "*[].{StorageEncrypted:StorageEncrypted}" --output text
```
### RDS API
要使用 Amazon RDS API 确定是否已为数据库实例启用静态加密，请使用以下参数调用 [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) 操作：
+ `DBInstanceIdentifier` – 数据库实例的名称。
## Amazon RDS 加密的可用性
Amazon RDS 加密当前可用于所有数据库引擎和存储类型。
Amazon RDS 加密适用于大多数数据库实例类。下表列出了*不支持* Amazon RDS 加密的数据库实例类：
| 实例类型 | 实例类 |
| --- | --- |
| 通用型（M1） | db.m1.small db.m1.medium db.m1.large db.m1.xlarge |
| 内存优化（M2） | db.m2.xlarge db.m2.2xlarge db.m2.4xlarge |
| 突增型（T2） | db.t2.micro |
## 传输中加密
**物理层加密**
所有在 AWS 全球网络上跨 AWS 区域流动的数据在离开受 AWS 保护的设施之前，都会在物理层自动加密。可用区之间的所有流量均已加密。其它加密层（包括本节中列出的加密层）可能会提供额外保护。
**Amazon VPC 对等连接和 Transit Gateway 跨区域对等连接提供的加密**
使用 Amazon VPC 和 Transit Gateway 对等连接的所有跨区域流量在退出区域时都会自动批量加密。所有流量在离开受 AWS 保护的设施之前，均会在物理层自动提供额外一层加密。
**实例之间的加密**
AWS 在所有类型的数据库实例之间提供安全的私有连接。此外，某些实例类型使用底层 Nitro 系统硬件的卸载功能，自动加密实例之间的传输中流量。此加密使用关联数据的身份验证加密（AEAD）算法，采用 256 位加密。这对网络性能没有影响。要在实例之间支持这种额外的传输中流量加密，必须满足以下要求：
+ 使用以下实例类型：
+ **通用型：**M6i、M6id、M6in、M6idn、M7g
+ **内存优化型：**R6i、R6id、R6in、R6idn、R7g、X2idn、X2iedn、X2iezn
+ 这些实例位于同一 AWS 区域。
+ 这些实例位于相同 VPC 或对等的 VPC 中，并且流量不会通过虚拟网络设备或服务（如负载均衡器或中转网关）传输。
## Amazon RDS 加密的数据库实例的限制
Amazon RDS 加密的数据库实例存在以下限制：
+ 您只能在创建 Amazon RDS 数据库实例时而不是创建该数据库实例之后加密该数据库实例。
不过，由于您可以加密未加密快照的副本，因此，您可以高效地为未加密的数据库实例添加加密。也就是说，您可以创建数据库实例快照，然后创建该快照的加密副本。然后，您可以从加密快照还原数据库实例，从而获得原始数据库实例的加密副本。有关更多信息，请参阅 [复制 Amazon RDS 的数据库快照](USER_CopySnapshot.md)。
+ 您无法在加密的数据库实例上关闭加密。
+ 您无法创建未加密数据库实例的加密快照。
+ 加密数据库实例的快照必须使用与数据库实例相同的 KMS 密钥进行加密。
+ 您无法拥有未加密数据库实例的加密只读副本或加密数据库实例的未加密只读副本。
+ 如果加密的只读副本位于同一 AWS 区域，则它们的 KMS 密钥必须与源数据库实例的相同。
+ 您不能将未加密的备份或快照还原到加密的数据库实例。
+ 要将已加密快照从一个 AWS 区域复制到另一个区域，您必须指定目标 AWS 区域的 KMS 密钥。这是因为 KMS 密钥特定于在其中创建它们的 AWS 区域。
源快照在复制过程中保持加密状态。Amazon RDS 使用信封加密在复制过程中保护数据。有关信封加密的更多信息，请参阅*AWS Key Management Service开发人员指南*中的[信封加密](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping)。
+ 您无法对加密数据库实例取消加密。但是，您可以从加密的数据库实例中导出数据，然后将数据导入未加密的数据库实例。
# AWS KMS key 管理
Amazon RDS 自动与 [AWS Key Management Service（AWS KMS）](https://docs.aws.amazon.com/kms/latest/developerguide/)集成以进行密钥管理。Amazon RDS 使用信封加密。有关信封加密的更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[信封加密](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping)。
您可以使用两种类型的 AWS KMS 密钥来加密数据库实例。
+ 要完全控制 KMS 密钥，您必须创建*客户托管密钥*。有关客户托管密钥的更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[客户托管密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)。
+ *AWS 托管式密钥* 是由与 AWS KMS 集成的 AWS 服务代表您在账户中创建、管理和使用的 KMS 密钥。默认情况下，RDS AWS 托管式密钥（`aws/rds`）用于加密。您无法管理、轮换或删除 RDS AWS 托管式密钥。有关 AWS 托管式密钥 的更多信息，请参阅《AWS Key Management Service 开发人员指南》**中的 [AWS 托管式密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)。
要管理用于 Amazon RDS 加密数据库实例的 KMS 密钥，您可以使用 [AWS KMS 控制台](https://console.aws.amazon.com/kms)中的 [AWS Key Management Service（AWS KMS）](https://docs.aws.amazon.com/kms/latest/developerguide/)、AWS CLI 或 AWS KMS API。要查看利用 AWS 托管式或客户托管密钥执行的每个操作的审计日志，请使用 [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/)。有关密钥轮换的更多信息，请参阅[轮换 AWS KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html)。
## 授权使用客户托管密钥
RDS 在加密操作中使用客户自主管理型密钥时，其代表创建或更改 RDS 资源的用户执行操作。
要使用客户自主管理型密钥创建 RDS 资源，用户必须具有对客户自主管理型密钥调用以下操作的权限：
+ `kms:CreateGrant`
+ `kms:DescribeKey`
您可以在密钥策略中指定这些所需权限，或者在密钥策略允许的情况下在 IAM 策略中指定这些权限。
**重要**
当您在 Amazon RDS 等托管式服务的 AWS KMS 密钥策略中对所有资源（\$1）使用显式拒绝语句时，您必须指定一个条件来支持拥有资源的账户。如果没有此条件，操作可能会失败，即使拒绝规则中包含针对您的 IAM 用户的例外情况也是如此。
**提示**
为遵循最小特权原则，请不要允许对 `kms:CreateGrant` 拥有完全访问权限。而是仅当 AWS 服务代表用户创建授权时，才使用 [kms:ViaService 条件密钥](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service)来支持用户对 KMS 密钥创建授权。
您可以通过各种方式使 IAM 策略更严格。例如，如果您要支持将客户自主管理型密钥仅用于源自 RDS 的请求，请将 [kms:ViaService 条件密钥](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service)与 `rds..amazonaws.com` 值结合使用。此外，您可以使用[Amazon RDS 加密上下文](#Overview.Encryption.Keys.encryptioncontext)中的密钥或值作为使用客户托管密钥进行加密的条件。
有关更多信息，请参阅《AWS Key Management Service 开发人员指南》**中的[允许其他账户中的用户使用 KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying-external-accounts.html)和 [AWS KMS 中的密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies)。
## Amazon RDS 加密上下文
当 RDS 使用您的 KMS 密钥时，或者当 Amazon EBS 代表 RDS 使用 KMS 密钥时，服务会指定[加密上下文](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)。加密上下文是 AWS KMS 用于确保数据完整性而使用的[额外的身份验证数据](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) (AAD)。在为加密操作指定加密上下文时，该服务必须为解密操作指定同一加密上下文。否则，解密将失败。加密上下文还将写至您的 [AWS CloudTrail](https://aws.amazon.com/cloudtrail/) 日志中，以帮助您了解为什么使用给定的 KMS 密钥。您的 CloudTrail 日志可能包含多个描述 KMS 密钥使用情况的条目，但每个日志条目中的加密上下文可以帮助您确定该特定使用的原因。
至少，Amazon RDS 始终将数据库实例 ID 用于加密上下文，如以下 JSON 格式的示例所示：
```
{ "aws:rds:db-id": "db-CQYSMDPBRZ7BPMH7Y3RTDG5QY" }
```
此加密上下文可以帮助您确定使用您的 KMS 密钥的数据库实例。
当您的 KMS 密钥用于特定的数据库实例和特定的 Amazon EBS 卷时，数据库实例 ID 和 Amazon EBS 卷 ID 将用于加密上下文，如以下 JSON 格式的示例所示：
```
{
"aws:rds:db-id": "db-BRG7VYS3SVIFQW7234EJQOM5RQ",
"aws:ebs:id": "vol-ad8c6542"
}
```
# 使用 SSL/TLS 加密与数据库实例或集群的连接
您可以使用应用程序中的安全套接字层（SSL）或传输层安全性协议（TLS）来加密与运行 Db2、MariaDB、Microsoft SQL Server、MySQL、Oracle 或 PostgreSQL 的数据库的连接。
SSL/TLS 连接对在客户端和数据库实例或集群之间移动的数据进行加密，从而提供一层额外的安全性。（可选）您的 SSL/TLS 连接可以通过验证安装在数据库上的服务器证书来执行服务器身份验证。要请求服务器身份验证，请遵循以下一般流程：
1. 为数据库选择对**数据库服务器证书**进行签名的**证书颁发机构（CA）**。有关证书颁发机构的更多信息，请参阅[证书颁发机构](#UsingWithRDS.SSL.RegionCertificateAuthorities)。
1. 下载证书包，以便在连接到数据库时使用。要下载证书捆绑包，请参阅。。[按 AWS 区域列出的证书捆绑包](#UsingWithRDS.SSL.CertificatesAllRegions)。
**注意**
只能使用 SSL/TLS 连接下载所有证书。
1. 使用数据库引擎用于实现 SSL/TLS 连接的过程连接到数据库。每个数据库引擎都有自己的用于实施 SSL/TLS 的过程。要了解如何为您的数据库实施 SSL/TLS，请使用对应于您的数据库引擎的链接：
+ [对 Amazon RDS for Db2 数据库实例使用 SSL/TLS](Db2.Concepts.SSL.md)
+ [Amazon RDS 上 MariaDB 数据库实例的 SSL/TLS 支持](MariaDB.Concepts.SSLSupport.md)
+ [将 SSL 与 Microsoft SQL Server 数据库实例结合使用](SQLServer.Concepts.General.SSL.Using.md)
+ [Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)
+ [对 RDS for Oracle 数据库实例使用 SSL](Oracle.Concepts.SSL.md)
+ [将 SSL 与 PostgreSQL 数据库实例结合使用](PostgreSQL.Concepts.General.SSL.md)
## 证书颁发机构
**证书颁发机构（CA）**是用于标识证书链顶部的根 CA 的证书。CA 签署安装在每个数据库实例上的**数据库服务器证书**。数据库服务器证书将数据库实例标识为可信服务器。
![\[证书颁发机构概述\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/certificate-authority-overview.png)
Amazon RDS 提供以下 CA 来签署数据库的数据库服务器证书。
****
| 证书颁发机构（CA） | 说明 | 公用名 (CN) |
| --- | --- | --- |
| rds-ca-rsa2048-g1 | 在大多数 AWS 区域中，使用具有 RSA 2048 私有密钥算法和 SHA256 签名算法的证书颁发机构。 在 AWS GovCloud (US) Regions中，此 CA 使用具有 RSA 2048 私有密钥算法和 SHA384 签名算法的证书颁发机构。 此 CA 支持服务器证书自动轮换。 | Amazon RDS region-identifier Root CA RSA2048 G1 |
| rds-ca-rsa4096-g1 | 使用具有 RSA 4096 私有密钥算法和 SHA384 签名算法的证书颁发机构。此 CA 支持服务器证书自动轮换。 | Amazon RDS region-identifier Root CA RSA4096 G1 |
| rds-ca-ecc384-g1 | 使用具有 ECC 384 私有密钥算法和 SHA384 签名算法的证书颁发机构。此 CA 支持服务器证书自动轮换。 | Amazon RDS region-identifier Root CA ECC384 G1 |
**注意**
如果您使用的是 AWS CLI，则可以使用 [describe-certificates](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-certificates.html) 查看上面列出的证书颁发机构的有效性。
这些 CA 证书包含在区域和全球证书捆绑包中。当您将 rds-ca-rsa2048-g1、rds-ca-rsa4096-g1 或 rds-ca-ecc384-g1 CA 用于数据库时，RDS 会管理数据库上的数据库服务器证书。RDS 会在数据库服务器证书过期之前自动轮换此证书。
### 为数据库设置 CA
您可以在执行以下任务时为数据库设置 CA：
+ 创建数据库实例或多可用区数据库集群 – 您可以在创建数据库实例或集群时设置 CA。有关说明，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)或[创建 Amazon RDS 的多可用区数据库集群](create-multi-az-db-cluster.md)。
+ 修改数据库实例或多可用区数据库集群 - 您可以通过修改数据库实例或集群为其设置 CA。有关说明，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)或[修改 Amazon RDS 的多可用区数据库集群](modify-multi-az-db-cluster.md)。
**注意**
默认 CA 设置为 rds-ca-rsa2048-g1。您可以使用 [modify-certificates](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-certificates.html) 命令为您的 AWS 账户覆盖默认 CA。
可用的 CA 取决于数据库引擎和数据库引擎版本。使用 AWS 管理控制台时，您可以使用 **Certificate authority**（证书颁发机构）设置选择 CA，如下图所示。
![\[证书颁发机构选项\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/certificate-authority.png)
控制台仅显示可用于数据库引擎和数据库引擎版本的 CA。如果您使用的是 AWS CLI，则可以使用 [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) 或 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 命令为数据库实例设置 CA。您可以使用 [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html) 或 [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) 命令为多可用区数据库集群设置 CA。
如果您使用的是 AWS CLI，则可以使用 [describe-certificates](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-certificates.html) 命令查看您账户的可用 CA。此命令还在输出的 `ValidTill` 中显示每个 CA 的到期日期。您可以使用 [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) 命令找到适用于特定数据库引擎和数据库引擎版本的 CA。
以下示例显示了可用于默认 RDS for PostgreSQL 数据库引擎版本的 CA。
```
aws rds describe-db-engine-versions --default-only --engine postgres
```
输出类似于以下内容。`SupportedCACertificateIdentifiers` 中列出了可用的 CA。输出还显示数据库引擎版本是否支持在 `SupportsCertificateRotationWithoutRestart` 中不重新启动的情况下轮换证书。
```
{
"DBEngineVersions": [
{
"Engine": "postgres",
"MajorEngineVersion": "13",
"EngineVersion": "13.4",
"DBParameterGroupFamily": "postgres13",
"DBEngineDescription": "PostgreSQL",
"DBEngineVersionDescription": "PostgreSQL 13.4-R1",
"ValidUpgradeTarget": [],
"SupportsLogExportsToCloudwatchLogs": false,
"SupportsReadReplica": true,
"SupportedFeatureNames": [
"Lambda"
],
"Status": "available",
"SupportsParallelQuery": false,
"SupportsGlobalDatabases": false,
"SupportsBabelfish": false,
"SupportsCertificateRotationWithoutRestart": true,
"SupportedCACertificateIdentifiers": [
"rds-ca-rsa2048-g1",
"rds-ca-ecc384-g1",
"rds-ca-rsa4096-g1"
]
}
]
}
```
### 数据库服务器证书有效期
数据库服务器证书的有效期取决于数据库引擎和数据库引擎版本。如果数据库引擎版本支持在不重启的情况下轮换证书，则数据库服务器证书的有效期为 1 年。否则，有效期为 3 年。
有关数据库服务器证书轮换的更多信息，请参阅[自动服务器证书轮换](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-server-cert-rotation)。
### 查看数据库实例的 CA
您可以通过查看控制台中的**连接性和安全性**选项卡来查看有关数据库的 CA 的详细信息，如下图所示。
![\[证书颁发机构详细信息\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/certificate-authority-details.png)
如果您使用的是 AWS CLI，您可以使用 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令，查看有关数据库实例的 CA 的详细信息。您可以使用 [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html) 命令查看有关多可用区数据库集群的 CA 的详细信息。
## 下载 Amazon RDS 的证书捆绑包
当您使用 SSL 或 TLS 连接到数据库时，数据库实例需要来自 Amazon RDS 的信任证书。在下表中选择相应的链接，来下载与托管数据库的 AWS 区域相对应的捆绑包。
### 按 AWS 区域列出的证书捆绑包
所有 AWS 区域和 GovCloud（美国）区域的证书捆绑包均包含以下根 CA 证书：
+ `rds-ca-rsa2048-g1`
+ `rds-ca-rsa4096-g1`
+ `rds-ca-ecc384-g1`
`rds-ca-rsa4096-g1` 和 `rds-ca-ecc384-g1` 证书在以下区域不可用：
+ 亚太地区（孟买）
+ 亚太地区（墨尔本）
+ 加拿大西部（卡尔加里）
+ 欧洲（苏黎世）
+ 欧洲（西班牙）
+ 以色列（特拉维夫）
您的应用程序信任存储只需要注册根 CA 证书。请勿将中间 CA 证书注册到您的信任存储区，因为当 RDS 自动轮换您的数据库服务器证书时，这可能会导致连接问题。
**注意**
Amazon RDS 代理使用来自 AWS Certificate Manager（ACM）的证书。如果您使用的是 RDS 代理，则无需下载 Amazon RDS 证书或更新使用 RDS 代理连接的应用程序。有关更多信息，请参阅 [将 TLS/SSL 与 RDS 代理结合使用](rds-proxy.howitworks.md#rds-proxy-security.tls)。
要下载 AWS 区域的证书捆绑包，请在下表中选择与托管数据库的 AWS 区域相对应的链接。
| **AWS 区域** | **证书捆绑包 (PEM)** | **证书捆绑包 (PKCS7)** |
| --- | --- | --- |
| 任何商业 AWS 区域 | [global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem) | [global-bundle.p7b](https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b) |
| 美国东部（弗吉尼亚州北部） | [us-east-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/us-east-1/us-east-1-bundle.pem) | [us-east-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/us-east-1/us-east-1-bundle.p7b) |
| US East (Ohio) | [us-east-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/us-east-2/us-east-2-bundle.pem) | [us-east-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/us-east-2/us-east-2-bundle.p7b) |
| 美国西部（加利福尼亚北部） | [us-west-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/us-west-1/us-west-1-bundle.pem) | [us-west-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/us-west-1/us-west-1-bundle.p7b) |
| 美国西部（俄勒冈州） | [us-west-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/us-west-2/us-west-2-bundle.pem) | [us-west-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/us-west-2/us-west-2-bundle.p7b) |
| Africa (Cape Town) | [af-south-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/af-south-1/af-south-1-bundle.pem) | [af-south-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/af-south-1/af-south-1-bundle.p7b) |
| Asia Pacific (Hong Kong) | [ap-east-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-east-1/ap-east-1-bundle.pem) | [ap-east-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-east-1/ap-east-1-bundle.p7b) |
| 亚太地区（海得拉巴） | [ap-south-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-south-2/ap-south-2-bundle.pem) | [ap-south-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-south-2/ap-south-2-bundle.p7b) |
| 亚太地区（雅加达） | [ap-southeast-3-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-3/ap-southeast-3-bundle.pem) | [ap-southeast-3-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-3/ap-southeast-3-bundle.p7b) |
| 亚太地区（马来西亚） | [ap-southeast-5-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-5/ap-southeast-5-bundle.pem) | [ap-southeast-5-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-5/ap-southeast-5-bundle.p7b) |
| 亚太地区（墨尔本） | [ap-southeast-4-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-4/ap-southeast-4-bundle.pem) | [ap-southeast-4-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-4/ap-southeast-4-bundle.p7b) |
| 亚太地区（孟买） | [ap-south-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-south-1/ap-south-1-bundle.pem) | [ap-south-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-south-1/ap-south-1-bundle.p7b) |
| 亚太地区（大阪） | [ap-northeast-3-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-northeast-3/ap-northeast-3-bundle.pem) | [ap-northeast-3-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-northeast-3/ap-northeast-3-bundle.p7b) |
| 亚太地区（泰国） | [ap-southeast-7-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-7/ap-southeast-7-bundle.pem) | [ap-southeast-7-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-7/ap-southeast-7-bundle.p7b) |
| 亚太区域（东京） | [ap-northeast-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-northeast-1/ap-northeast-1-bundle.pem) | [ap-northeast-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-northeast-1/ap-northeast-1-bundle.p7b) |
| 亚太地区（首尔） | [ap-northeast-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-northeast-2/ap-northeast-2-bundle.pem) | [ap-northeast-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-northeast-2/ap-northeast-2-bundle.p7b) |
| 亚太地区（新加坡） | [ap-southeast-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-1/ap-southeast-1-bundle.pem) | [ap-southeast-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-1/ap-southeast-1-bundle.p7b) |
| 亚太地区（悉尼） | [ap-southeast-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/ap-southeast-2/ap-southeast-2-bundle.pem) | [ap-southeast-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ap-southeast-2/ap-southeast-2-bundle.p7b) |
| 加拿大（中部） | [ca-central-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ca-central-1/ca-central-1-bundle.pem) | [ca-central-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ca-central-1/ca-central-1-bundle.p7b) |
| 加拿大西部（卡尔加里） | [ca-west-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/ca-west-1/ca-west-1-bundle.pem) | [ca-west-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/ca-west-1/ca-west-1-bundle.p7b) |
| 欧洲地区（法兰克福） | [eu-central-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-central-1/eu-central-1-bundle.pem) | [eu-central-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-central-1/eu-central-1-bundle.p7b) |
| 欧洲地区（爱尔兰） | [eu-west-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-west-1/eu-west-1-bundle.pem) | [eu-west-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-west-1/eu-west-1-bundle.p7b) |
| 欧洲地区（伦敦） | [eu-west-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-west-2/eu-west-2-bundle.pem) | [eu-west-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-west-2/eu-west-2-bundle.p7b) |
| 欧洲地区（米兰） | [eu-south-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-south-1/eu-south-1-bundle.pem) | [eu-south-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-south-1/eu-south-1-bundle.p7b) |
| 欧洲地区（巴黎） | [eu-west-3-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-west-3/eu-west-3-bundle.pem) | [eu-west-3-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-west-3/eu-west-3-bundle.p7b) |
| 欧洲（西班牙） | [eu-south-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-south-2/eu-south-2-bundle.pem) | [eu-south-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-south-2/eu-south-2-bundle.p7b) |
| 欧洲地区（斯德哥尔摩） | [eu-north-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-north-1/eu-north-1-bundle.pem) | [eu-north-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-north-1/eu-north-1-bundle.p7b) |
| 欧洲（苏黎世） | [eu-central-2-bundle.pem](https://truststore.pki.rds.amazonaws.com/eu-central-2/eu-central-2-bundle.pem) | [eu-central-2-bundle.p7b](https://truststore.pki.rds.amazonaws.com/eu-central-2/eu-central-2-bundle.p7b) |
| 以色列（特拉维夫） | [il-central-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/il-central-1/il-central-1-bundle.pem) | [il-central-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/il-central-1/il-central-1-bundle.p7b) |
| 墨西哥（中部） | [mx-central-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/mx-central-1/mx-central-1-bundle.pem) | [mx-central-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/mx-central-1/mx-central-1-bundle.p7b) |
| 中东（巴林） | [me-south-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/me-south-1/me-south-1-bundle.pem) | [me-south-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/me-south-1/me-south-1-bundle.p7b) |
| 中东（阿联酋） | [me-central-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/me-central-1/me-central-1-bundle.pem) | [me-central-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/me-central-1/me-central-1-bundle.p7b) |
| 南美洲（圣保罗） | [sa-east-1-bundle.pem](https://truststore.pki.rds.amazonaws.com/sa-east-1/sa-east-1-bundle.pem) | [sa-east-1-bundle.p7b](https://truststore.pki.rds.amazonaws.com/sa-east-1/sa-east-1-bundle.p7b) |
| 任何 AWS GovCloud (US) Region | [global-bundle.pem](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/global/global-bundle.pem) | [global-bundle.p7b](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/global/global-bundle.p7b) |
| AWS GovCloud（美国东部） | [us-gov-east-1-bundle.pem](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/us-gov-east-1/us-gov-east-1-bundle.pem) | [us-gov-east-1-bundle.p7b](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/us-gov-east-1/us-gov-east-1-bundle.p7b) |
| AWS GovCloud（美国西部） | [us-gov-west-1-bundle.pem](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/us-gov-west-1/us-gov-west-1-bundle.pem) | [us-gov-west-1-bundle.p7b](https://truststore.pki.us-gov-west-1.rds.amazonaws.com/us-gov-west-1/us-gov-west-1-bundle.p7b) |
### 查看 CA 证书的内容
要检查您的 CA 证书包的内容，请使用以下命令：
```
keytool -printcert -v -file global-bundle.pem
```
# 轮换 SSL/TLS 证书
Amazon RDS 证书颁发机构证书 rds-ca-2019 于 2024 年 8 月到期。如果您使用或计划使用带有证书验证的安全套接字层（SSL）或传输层安全性协议（TLS）来连接您的 RDS 数据库实例或多可用区数据库集群，则考虑使用新的 CA 证书之一：rds-ca-rsa2048-g1、rds-ca-rsa4096-g1 或 rds-ca-ecc384-g1。如果您当前未将 SSL/TLS 用于证书验证，则可能仍有过期的 CA 证书，如果您计划为证书验证使用 SSL/TLS 连接到 RDS 数据库，则必须将它们更新为新的 CA 证书。
Amazon RDS 提供新 CA 证书作为AWS最佳安全实践。有关新证书和受支持的 AWS 区域的信息，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
要更新数据库的 CA 证书，请使用以下方法：
+ [通过修改数据库实例或集群来更新 CA 证书](#UsingWithRDS.SSL-certificate-rotation-updating)
+ [通过应用维护来更新 CA 证书](#UsingWithRDS.SSL-certificate-rotation-maintenance-update)
更新数据库实例或多可用区数据库集群来使用新的 CA 证书之前，请确保更新连接到 RDS 数据库的客户端或应用程序。
## 轮换证书的注意事项
在轮换证书之前，请考虑以下情况：
+ Amazon RDS 代理使用来自 AWS Certificate Manager（ACM）的证书。如果您使用的是 RDS 代理，当您轮换 SSL/TLS 证书时，您不需要更新使用 RDS 代理连接的应用程序。有关更多信息，请参阅 [将 TLS/SSL 与 RDS 代理结合使用](rds-proxy.howitworks.md#rds-proxy-security.tls)。
+ 如果您将 Go 版本 1.15 应用程序与在 2020 年 7 月 28 日之前创建或更新到 rds-ca-2019 证书的数据库实例或多可用区数据库集群一起使用，则必须再次更新证书。将证书更新为 rds-ca-rsa2048-g1、rds-ca-rsa4096-g1 或 rds-ca-ecc384-g1，具体取决于您的引擎。
使用新的 CA 证书标识符，对数据库实例运行 `modify-db-instance` 命令，或对多可用区数据库集群运行 `modify-db-cluster` 命令。您可以使用 `describe-db-engine-versions` 命令找到适用于特定数据库引擎和数据库引擎版本的 CA。
如果您在 2020 年 7 月 28 日之后创建了数据库或更新了其证书，则无需执行任何操作。有关更多信息，请参阅 [Go GitHub 问题 \$139568](https://github.com/golang/go/issues/39568)。
## 通过修改数据库实例或集群来更新 CA 证书
以下示例将您的 CA 证书从 *rds-ca-2019* 更新为 *rds-ca-rsa2048-g1*。您可以选择其他证书。有关更多信息，请参阅 [证书颁发机构](UsingWithRDS.SSL.md#UsingWithRDS.SSL.RegionCertificateAuthorities)。
更新您的应用程序信任存储，以减少任何与更新 CA 证书相关的停机时间。有关与 CA 证书轮换相关的重启的更多信息，请参阅[自动服务器证书轮换](#UsingWithRDS.SSL-certificate-rotation-server-cert-rotation)。
**通过修改数据库实例或集群来更新 CA 证书**
1. 下载新的 SSL/TLS 证书，如[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)中所述。
1. 更新应用程序以使用新的 SSL/TLS 证书。
更新应用程序以使用新 SSL/TLS 证书的方法取决于特定的应用程序。请与应用程序开发人员一起更新应用程序的 SSL/TLS 证书。
有关检查 SSL/TLS 连接和更新每个数据库引擎的应用程序的信息，请参阅以下主题：
+ [更新应用程序以使用新的 SSL/TLS 证书连接到 MariaDB 实例](ssl-certificate-rotation-mariadb.md)
+ [更新应用程序以使用新的 SSL/TLS 证书连接到 Microsoft SQL Server 数据库实例](ssl-certificate-rotation-sqlserver.md)
+ [更新应用程序以使用新的 SSL/TLS 证书连接到 MySQL 数据库实例](ssl-certificate-rotation-mysql.md)
+ [更新应用程序以使用新的 SSL/TLS 证书连接到 Oracle 数据库实例](ssl-certificate-rotation-oracle.md)
+ [更新应用程序以使用新的 SSL/TLS 证书连接到 PostgreSQL 数据库实例](ssl-certificate-rotation-postgresql.md)
有关更新 Linux 操作系统信任存储的示例脚本，请参阅[将证书导入信任存储的示例脚本](#UsingWithRDS.SSL-certificate-rotation-sample-script)。
**注意**
证书捆绑包包含新旧 CA 证书，因此您可以安全地升级应用程序并在转换期间保持连接。如果您正在使用 AWS Database Migration Service 将数据库迁移到数据库实例或集群，我们建议您使用证书捆绑包来确保迁移期间的连接性。
1. 修改数据库实例或多可用区数据库集群，以便将 CA 从 **rds-ca-2019** 更改为 **rds-ca-rsa2048-g1**。要检查您的数据库是否需要重启才能更新 CA 证书，请使用 [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) 命令并检查 `SupportsCertificateRotationWithoutRestart` 标志。
**重要**
如果您在证书到期后遇到连接问题，请通过在控制台中指定 **Apply immediately (立即应用)** 或者 使用 `--apply-immediately` 指定 AWS CLI 选项来使用“立即应用”选项。默认情况下，此操作安排在您的下个维护时段运行。
对于 RDS for Oracle 数据库实例，建议您重新启动 Oracle 数据库以防止出现任何连接错误。
对于启用了 AlwaysOn 或镜像选项的 RDS for SQL Server 多可用区实例，在证书轮换后重启实例时，预计会进行失效转移。
要为与默认 RDS CA 不同的实例 CA 设置覆盖，请使用 [modify-certificates](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-certificates.html) CLI 命令。
您可以使用 AWS 管理控制台或 AWS CLI，对于数据库实例或多可用区数据库集群，将 CA 证书从 **rds-ca-2019** 更改为 **rds-ca-rsa2048-g1**。
------
#### [ Console ]
1. 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择**数据库**，然后选择要修改的数据库实例或多可用区数据库集群。
1. 选择 **Modify**(修改)。
![\[修改数据库实例或多可用区数据库集群\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-modify.png)
1. 在**连接**部分中，选择 **rds-ca-rsa2048-g1**。
![\[选择 CA 证书\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-ca-rsa2048-g1.png)
1. 选择**继续**，查看修改摘要。
1. 要立即应用更改，请选择**立即应用**。
1. 在确认页面上，检查您的更改。如果更改正确无误，请选择**修改数据库实例**或**修改集群**以保存更改。
**重要**
安排此操作时，请确保已预先更新客户端信任存储。
也可以选择 **Back** 编辑您的更改，或选择 **Cancel** 取消更改。
------
#### [ AWS CLI ]
要使用 AWS CLI 将数据库实例或多可用区数据库集群的 CA 从 **rds-ca-2019** 更改为 **rds-ca-rsa2048-g1**，请调用 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 或 [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) 命令。指定数据库实例或集群标识符和 `--ca-certificate-identifier` 选项。
使用 `--apply-immediately` 参数可立即应用更新。默认情况下，此操作安排在您的下个维护时段运行。
**重要**
安排此操作时，请确保已预先更新客户端信任存储。
**Example**
**数据库实例**
以下示例通过将 CA 证书设置为 `rds-ca-rsa2048-g1` 来修改 `mydbinstance`。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--ca-certificate-identifier rds-ca-rsa2048-g1
```
对于：Windows
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--ca-certificate-identifier rds-ca-rsa2048-g1
```
如果您的实例需要重启，可以使用 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) CLI 命令并指定 `--no-certificate-rotation-restart` 选项。
**Example**
**多可用区数据库集群**
以下示例通过将 CA 证书设置为 `rds-ca-rsa2048-g1` 来修改 `mydbcluster`。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-cluster \
--db-cluster-identifier mydbcluster \
--ca-certificate-identifier rds-ca-rsa2048-g1
```
对于：Windows
```
aws rds modify-db-cluster ^
--db-cluster-identifier mydbcluster ^
--ca-certificate-identifier rds-ca-rsa2048-g1
```
------
## 通过应用维护来更新 CA 证书
完成以下步骤，通过应用维护来更新 CA 证书。
------
#### [ Console ]
**通过应用维护来更新 CA 证书**
1. 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择**证书更新**。
![\[证书轮换导航窗格选项\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-certupdate.png)
将显示**需要更新证书的数据库**页面。
![\[更新数据库的 CA 证书\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-update-multiple.png)
**注意**
该页面仅显示当前 AWS 区域的数据库实例和集群。如果您在多个 AWS 区域中有数据库，请检查每个 AWS 区域中的该页面，以查看具有旧 SSL/TLS 证书的所有数据库实例。
1. 选择要更新的数据库实例或多可用区数据库集群。
您可以通过选择**计划**来计划下一维护时段的证书轮换。通过选择**立即应用**来立即应用轮换。
**重要**
如果您在证书到期后遇到连接问题，请使用**立即应用**选项。
1.
1. 如果您选择**计划**，系统会提示您确认 CA 证书轮换。此提示还说明更新的计划时段。
![\[确认证书轮换\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-confirm-schedule.png)
1. 如果您选择**立即应用**，系统会提示您确认 CA 证书轮换。
![\[确认证书轮换\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/ssl-rotate-cert-confirm-now.png)
**重要**
在计划数据库上的 CA 证书轮换之前，请更新使用 SSL/TLS 和服务器证书进行连接的所有客户端应用程序。这些更新特定于您的数据库引擎。更新这些客户端应用程序后，可以确认 CA 证书轮换。
要继续，请选中该复选框，然后选择 **Confirm (确认)**。
1. 对要更新的每个数据库实例和集群重复步骤 3 和 4。
------
## 自动服务器证书轮换
如果根 CA 支持自动服务器证书轮换，RDS 会自动处理数据库服务器证书的轮换。RDS 使用相同的根 CA 进行自动轮换，因此您无需下载新的 CA 服务包。请参阅[证书颁发机构](UsingWithRDS.SSL.md#UsingWithRDS.SSL.RegionCertificateAuthorities)。
数据库服务器证书的轮换和有效期取决于您的数据库引擎：
+ 如果您的数据库引擎支持无需重启即可轮换，则 RDS 会自动轮换数据库服务器证书，而无需您执行任何操作。RDS 尝试在您首选的维护时段中，在数据库服务器证书的半生命周期轮换您的数据库服务器证书。新的数据库服务器证书的有效期为 12 个月。
+ 如果您的数据库引擎不支持无需重启的证书轮换，Amazon RDS 会在证书有效期过半时或至少在到期前 3 个月，通过 Describe-pending-maintenance-actions API 显示 `server-certificate-rotation` 待处理的维护操作。您可以使用 apply-pending-maintenance-action API 来应用轮换。新的数据库服务器证书的有效期为 36 个月。
使用 [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) 命令并检查 `SupportsCertificateRotationWithoutRestart`标志，以确定数据库引擎版本是否支持无需重启即可轮换证书。有关更多信息，请参阅 [为数据库设置 CA](UsingWithRDS.SSL.md#UsingWithRDS.SSL.RegionCertificateAuthorities.Selection)。
## 将证书导入信任存储的示例脚本
以下是将证书捆绑包导入信任存储的示例 shell 脚本。
每个示例 Shell 脚本都使用 keytool，它是 Java 开发工具包 (JDK) 的一部分。有关安装 JDK 的信息，请参阅 [JDK 安装指南](https://docs.oracle.com/en/java/javase/17/install/overview-jdk-installation.html)。
------
#### [ Linux ]
下面是一个示例 Shell 脚本，它将证书捆绑包导入 Linux 操作系统上的信任存储。
```
mydir=tmp/certs
if [ ! -e "${mydir}" ]
then
mkdir -p "${mydir}"
fi truststore=${mydir}/rds-truststore.jks storepassword=changeit
curl -sS "https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem"> ${mydir}/global-bundle.pem
awk 'split_after == 1 {n++;split_after=0} /-----END CERTIFICATE-----/ {split_after=1}{print > "rds-ca-" n+1 ".pem"}' < ${mydir}/global-bundle.pem
for CERT in rds-ca-*; do alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
echo "Importing $alias"
keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
rm $CERT
done
rm ${mydir}/global-bundle.pem
echo "Trust store content is: "
keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias
do expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
echo " Certificate ${alias} expires in '$expiry'"
done
```
------
#### [ macOS ]
下面是一个示例 Shell 脚本，它将证书捆绑包导入 macOS 上的信任存储。
```
mydir=tmp/certs
if [ ! -e "${mydir}" ]
then
mkdir -p "${mydir}"
fi truststore=${mydir}/rds-truststore.jks storepassword=changeit
curl -sS "https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem"> ${mydir}/global-bundle.pem
split -p "-----BEGIN CERTIFICATE-----" ${mydir}/global-bundle.pem rds-ca-
for CERT in rds-ca-*; do alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
echo "Importing $alias"
keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
rm $CERT
done
rm ${mydir}/global-bundle.pem
echo "Trust store content is: "
keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias
do expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
echo " Certificate ${alias} expires in '$expiry'"
done
```
------
# 互联网络流量隐私
Amazon RDS 与本地应用程序之间以及 Amazon RDS 与同一 AWS 区域内的其他 AWS 资源之间的连接都受到保护。
## 服务与本地客户端和应用之间的流量
在您的私有网络和 AWS 之间有两个连接选项：
+ 一个AWS Site-to-Site VPN 连接。有关更多信息，请参阅[什么是 AWS Site-to-Site VPN？](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html)
+ 一个 Direct Connect 连接。有关更多信息，请参阅[什么是 Direct Connect？](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html)
您可使用 AWS 发布的 API 操作，通过网络获取对 Amazon RDS 的访问权限。客户端必须支持以下内容：
+ 传输层安全性协议（TLS）。我们要求使用 TLS 1.2，建议使用 TLS 1.3。
+ 具有完全向前保密（PFS）的密码套件，例如 DHE（临时 Diffie-Hellman）或 ECDHE（临时椭圆曲线 Diffie-Hellman）。大多数现代系统（如 Java 7 及更高版本）都支持这些模式。
此外，必须使用访问密钥 ID 和与 IAM 主体关联的秘密访问密钥来对请求进行签名。或者，您可以使用 [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html)（AWS STS）生成临时安全凭证来对请求进行签名。
# Amazon RDS 的 Identity and Access Management
AWS Identity and Access Management（IAM）是一项 AWS 服务，可以帮助管理员安全地控制对 AWS 资源的访问。IAM 管理员控制谁可以*通过身份验证*（登录）和*获得授权*（具有权限）以使用 Amazon RDS 资源。IAM 是一项无需额外费用即可使用的 AWS 服务。
**Topics**
+ [
## 受众
](#security_iam_audience)
+ [
## 使用身份进行身份验证
](#security_iam_authentication)
+ [
## 使用策略管理访问
](#security_iam_access-manage)
+ [
# Amazon RDS 如何与 IAM 协同工作
](security_iam_service-with-iam.md)
+ [
# Amazon RDS 的基于身份的策略示例
](security_iam_id-based-policy-examples.md)
+ [
# AWS适用于 Amazon RDS 的 托管式策略
](rds-security-iam-awsmanpol.md)
+ [
# AWS 托管式策略的 Amazon RDS 更新
](rds-manpol-updates.md)
+ [
# 防范跨服务混淆代理问题
](cross-service-confused-deputy-prevention.md)
+ [
# 适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证
](UsingWithRDS.IAMDBAuth.md)
+ [
# 对 Amazon RDS 身份和访问权限问题进行故障排除
](security_iam_troubleshoot.md)
## 受众
如何使用 AWS Identity and Access Management (IAM) 因您在 Amazon RDS 中执行的操作而异。
**服务用户** – 如果您使用 Amazon RDS 服务来完成作业，则您的管理员会为您提供所需的凭证和权限。当您使用更多 Amazon RDS 功能来完成工作时，您可能需要额外权限。了解如何管理访问权限可帮助您向管理员请求适合的权限。如果您无法访问 Amazon RDS 中的一项功能，请参阅[对 Amazon RDS 身份和访问权限问题进行故障排除](security_iam_troubleshoot.md)。
**服务管理员** – 如果您在公司负责管理 Amazon RDS 资源，则您可能具有 Amazon RDS 的完全访问权限。您有责任确定您的员工应访问哪些 Amazon RDS 功能和资源。然后，您必须向 管理员提交请求，这样才能更改您的服务用户的权限。请查看该页面上的信息以了解 IAM 的基本概念。要了解有关您的公司如何将 IAM 与 Amazon RDS 搭配使用的更多信息，请参阅[Amazon RDS 如何与 IAM 协同工作](security_iam_service-with-iam.md)。
**管理员** – 如果您是管理员，您可能希望了解有关您可以如何编写策略以管理 Amazon RDS 的访问权限的详细信息。要查看您可在 IAM 中使用的基于身份的 Amazon RDS 示例策略，请参阅[Amazon RDS 的基于身份的策略示例](security_iam_id-based-policy-examples.md)。
## 使用身份进行身份验证
身份验证是您使用身份凭证登录 AWS 的方法。您必须作为 AWS 账户根用户、IAM 用户或通过代入 IAM 角色进行身份验证。
您可以使用来自身份源 [例如 AWS IAM Identity Center（IAM Identity Center）] 的凭证、单点登录身份验证或 Google/Facebook 凭证，以联合身份进行登录。有关登录的更多信息，请参阅《AWS 登录 User Guide》**中的 [How to sign in to your AWS 账户](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html)。
对于编程访问，AWS 提供了 SDK 和 CLI 来对请求进行加密签名。有关更多信息，请参阅《IAM 用户指南》**中的[适用于 API 请求的 AWS 签名版本 4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html)。
### AWS 账户根用户
当您创建 AWS 账户时，最初使用的是一个对所有 AWS 服务和资源拥有完全访问权限的登录身份（称为 AWS 账户*根用户*）。强烈建议您不要使用根用户执行日常任务。有关需要根用户凭证的任务，请参阅《IAM 用户指南》**中的[需要根用户凭证的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。
### 联合身份
作为最佳实践，请要求人类用户必须使用带有身份提供者的联合身份验证才能使用临时凭证访问 AWS 服务。
*联合身份*是来自企业目录、Web 身份提供者的用户，或 Directory Service 中的用户（这些用户使用来自身份源的凭证访问 AWS 服务）。联合身份代入可提供临时凭证的角色。
要集中管理访问权限，建议使用 AWS IAM Identity Center。有关更多信息，请参阅*《AWS IAM Identity Center 用户指南》*中的[什么是 IAM Identity Center？](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)。
### IAM 用户和群组
*[IAM 用户](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)*是对单个人员或应用程序具有特定权限的身份。我们建议使用临时凭证，而非具有长期凭证的 IAM 用户。有关更多信息，请参阅《IAM 用户指南》中的[要求人类用户使用带有身份提供商的联合身份验证才能使用临时凭证访问 AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp)**。
[https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html)指定一组 IAM 用户，便于对大量用户进行权限管理。有关更多信息，请参阅《IAM 用户指南》**中的 [IAM 用户的使用案例](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html)。
可以使用 IAM 数据库身份验证对数据库实例进行身份验证。
IAM 数据库身份验证使用以下数据库引擎：
+ RDS for MariaDB
+ RDS for MySQL
+ RDS for PostgreSQL
有关使用 IAM 对数据库实例进行身份验证的更多信息，请参阅 [适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.md)。
### IAM 角色
*[IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)*是 AWS 账户中具有特定权限的身份。它类似于用户，但未与特定人员关联。您可以通过[切换角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html)，在 AWS 管理控制台 中暂时代入 IAM 角色。您可以调用 AWS CLI 或 AWS API 操作或使用自定义网址以担任角色。有关使用角色的方法的更多信息，请参阅《IAM 用户指南》中的[使用 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html)**。
具有临时凭证的 IAM 角色在以下情况下很有用：
+ **临时用户权限** – 用户可代入 IAM 角色，暂时获得针对特定任务的不同权限。
+ **联合用户访问**：要向联合身份分配权限，请创建角色并为角色定义权限。当联合身份进行身份验证时，该身份将与角色相关联并被授予由此角色定义的权限。有关用于联合身份验证的角色的信息，请参阅《IAM 用户指南》**中的[针对第三方身份提供者创建角色（联合身份验证）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html)。如果您使用 IAM Identity Center，则需要配置权限集。为控制您的身份在进行身份验证后可以访问的内容，IAM Identity Center 将权限集与 IAM 中的角色相关联。有关权限集的信息，请参阅 *AWS IAM Identity Center 用户指南*中的[权限集](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html)。
+ **跨账户访问**：您可以使用 IAM 角色以允许不同账户中的某个人（可信主体）访问您的账户中的资源。角色是授予跨账户访问权限的主要方式。但是，对于某些 AWS 服务，您可以将策略直接附加到资源（而不是使用角色作为代理）。要了解用于跨账户访问的角色和基于资源的策略之间的差别，请参阅*《IAM 用户指南》*中的 [IAM 角色与基于资源的策略有何不同](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html)。
+ **跨服务访问**：某些 AWS 服务使用其它 AWS 服务中的特征。例如，当您在某个服务中进行调用时，该服务通常会在 Amazon EC2 中运行应用程序或在 Simple Storage Service（Amazon S3）中存储对象。服务可能会使用发出调用的主体的权限、使用服务角色或使用服务相关角色来执行此操作。
+ **转发访问会话** – 转发访问会话（FAS）使用调用 AWS 服务 的主体的权限，与发出请求的 AWS 服务 结合，来向下游服务发出请求。有关发出 FAS 请求时的策略详情，请参阅[转发访问会话](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html)。
+ **服务角色** - 服务角色是服务代表您在您的账户中执行操作而分派的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。IAM 管理员可以在 IAM 中创建、修改和删除服务角色。有关更多信息，请参阅《IAM 用户指南》**中的[创建向 AWS 服务委派权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
+ **服务相关角色**：服务相关角色是与 AWS 服务 关联的一种服务角色。服务可以代入代表您执行操作的角色。服务相关角色显示在您的 AWS 账户 中，并由该服务拥有。IAM 管理员可以查看但不能编辑服务相关角色的权限。
+ **在 Amazon EC2 上运行的应用程序**：您可以使用 IAM 角色管理在 EC2 实例上运行并发出 AWS CLI 或 AWS API 请求的应用程序的临时凭证。这优先于在 EC2 实例中存储访问密钥。要将 AWS 角色分配给 EC2 实例并使其对该实例的所有应用程序可用，您可以创建一个附加到实例的实例配置文件。实例配置文件包含角色，并使 EC2 实例上运行的程序能够获得临时凭证。有关更多信息，请参阅《IAM 用户指南》**中的[使用 IAM 角色向在 Amazon EC2 实例上运行的应用程序授予权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html)。
要了解是否使用 IAM 角色，请参阅 *IAM 用户指南* 中的[何时创建 IAM 角色（而不是用户）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role)。
## 使用策略管理访问
您将创建策略并将其附加到 IAM 身份或 AWS 资源，以便控制 AWS 中的访问。策略是 AWS 中的对象；在与身份或资源相关联时，策略定义其权限。在某个实体（根用户、用户或 IAM 角色）发出请求时，AWS 将评估这些策略。策略中的权限确定是允许还是拒绝请求。大多数策略在 AWS 中存储为 JSON 文档。有关 JSON 策略文档的结构和内容的更多信息，请参阅 *IAM 用户指南*中的 [JSON 策略概览](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json)。
管理员可以使用策略来指定哪些用户有权访问 AWS 资源，以及他们可以对这些资源执行哪些操作。每个 IAM 实体（权限集或角色）最初没有任何权限。换言之，预设情况下，用户什么都不能做，甚至不能更改他们自己的密码。要为用户授予执行某些操作的权限，管理员必须将权限策略附加到用户。或者，管理员可以将用户添加到具有预期权限的组中。当管理员为某个组授予访问权限时，该组内的全部用户都会获得这些访问权限。
IAM 策略定义操作的权限，无关乎您使用哪种方法执行操作。例如，假设您有一个允许 `iam:GetRole` 操作的策略。具有该策略的用户可以从 AWS 管理控制台、AWS CLI 或 AWS API 获取角色信息。
### 基于身份的策略
基于身份的策略是可附加到身份（如权限集或角色）的 JSON 权限策略文档。这些策略控制身份可在何种条件下对哪些资源执行哪些操作。要了解如何创建基于身份的策略，请参阅 *IAM 用户指南*中的[创建 IAM policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)。
基于身份的策略可以进一步归类为*内联策略*或*托管策略*。内联策略直接嵌入到单个权限集或角色中。托管式策略是可以附加到 AWS 账户中的多个权限集和角色的独立策略。托管式策略包括 AWS 托管式策略和客户管理型策略。要了解如何在托管式策略和内联策略之间进行选择，请参阅 *IAM 用户指南*中的[在托管式策略与内联策略之间进行选择](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline)。
有关特定于 Amazon RDS 的 AWS 托管式策略的信息，请参阅[AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md)。
### 其他策略类型
AWS 支持额外的、不太常用的策略类型。这些策略类型可以设置更常用的策略类型向您授予的最大权限。
+ **权限边界** – 权限边界是一项高级功能，借助该功能，您可以设置基于身份的策略可以授予 IAM 实体（权限集或角色）的最大权限。您可为实体设置权限边界。这些结果权限是实体的基于身份的策略及其权限边界的交集。在 `Principal` 字段中指定权限集或角色的基于资源的策略不受权限边界限制。任一项策略中的显式拒绝将覆盖允许。有关权限边界的更多信息，请参阅 *IAM 用户指南*中的 [IAM 实体的权限边界](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)。
+ **服务控制策略 (SCP) ** – SCP 是 JSON 策略，指定了组织或组织单位 (OU) 在 AWS Organizations 中的最大权限。AWS Organizations 是一项服务，用于分组和集中管理您的企业拥有的多个 AWS 账户。如果在组织内启用了所有特征，则可对任意或全部账户应用服务控制策略（SCP）。SCP 限制成员账户中实体（包括每个 AWS 账户根用户）的权限。有关 Organizations 和 SCP 的更多信息，请参阅《AWS Organizations 用户指南》**中的 [SCP 的工作原理](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html)。
+ **会话策略** – 会话策略是当您以编程方式为角色或联合用户创建临时会话时作为参数传递的高级策略。结果会话的权限是权限集或角色的基于身份的策略和会话策略的交集。权限也可以来自基于资源的策略。任一项策略中的显式拒绝将覆盖允许。有关更多信息，请参阅 *IAM 用户指南*中的[会话策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session)。
### 多个策略类型
当多个类型的策略应用于一个请求时，生成的权限更加复杂和难以理解。要了解 AWS 如何确定在涉及多种策略类型时是否允许请求，请参阅 *IAM 用户指南*中的[策略评测逻辑](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html)。
# Amazon RDS 如何与 IAM 协同工作
在使用 IAM 管理对 Amazon RDS 的访问之前，您应了解哪些 IAM 功能可与 Amazon RDS 协同工作。
下表列出了可与 Amazon RDS 结合使用的 IAM 功能：
| IAM 功能 | Amazon RDS 支持 |
| --- | --- |
| [基于身份的策略](#security_iam_service-with-iam-id-based-policies) | 是 |
| [基于资源的策略](#security_iam_service-with-iam-resource-based-policies) | 否 |
| [策略操作](#security_iam_service-with-iam-id-based-policies-actions) | 是 |
| [策略资源](#security_iam_service-with-iam-id-based-policies-resources) | 是 |
| [策略条件键（特定于服务）](#UsingWithRDS.IAM.Conditions) | 是 |
| [ACL](#security_iam_service-with-iam-acls) | 否 |
| [基于属性的访问控制 (ABAC)（策略中的标签）](#security_iam_service-with-iam-tags) | 是 |
| [临时凭证](#security_iam_service-with-iam-roles-tempcreds) | 是 |
| [转发访问会话](#security_iam_service-with-iam-principal-permissions) | 是 |
| [服务角色](#security_iam_service-with-iam-roles-service) | 是 |
| [服务关联角色](#security_iam_service-with-iam-roles-service-linked) | 是 |
要大致了解 Amazon RDS 和其他 AWS 服务如何与 IAM 一起使用，请参阅《IAM 用户指南》**中的[与 IAM 一起使用的 AWS 服务](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)。
**Topics**
+ [
## Amazon RDS 基于身份的策略
](#security_iam_service-with-iam-id-based-policies)
+ [
## Amazon RDS 内基于资源的策略
](#security_iam_service-with-iam-resource-based-policies)
+ [
## Amazon RDS 的策略操作
](#security_iam_service-with-iam-id-based-policies-actions)
+ [
## Amazon RDS 的策略资源
](#security_iam_service-with-iam-id-based-policies-resources)
+ [
## Amazon RDS 的策略条件键
](#UsingWithRDS.IAM.Conditions)
+ [
## Amazon RDS 中的访问控制列表 (ACL)
](#security_iam_service-with-iam-acls)
+ [
## 策略中具有 Amazon RDS 标签的基于属性的访问控制 (ABAC)
](#security_iam_service-with-iam-tags)
+ [
## 将临时凭证用于 Amazon RDS
](#security_iam_service-with-iam-roles-tempcreds)
+ [
## Amazon RDS 的转发访问会话
](#security_iam_service-with-iam-principal-permissions)
+ [
## Amazon RDS 的服务角色
](#security_iam_service-with-iam-roles-service)
+ [
## Amazon RDS 的服务相关角色
](#security_iam_service-with-iam-roles-service-linked)
## Amazon RDS 基于身份的策略
**支持基于身份的策略：**是。
基于身份的策略是可附加到身份（如 IAM 用户、用户组或角色）的 JSON 权限策略文档。这些策略控制用户和角色可在何种条件下对哪些资源执行哪些操作。要了解如何创建基于身份的策略，请参阅《IAM 用户指南》**中的[使用客户管理型策略定义自定义 IAM 权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)。
通过使用 IAM 基于身份的策略，您可以指定允许或拒绝的操作和资源以及允许或拒绝操作的条件。要了解可在 JSON 策略中使用的所有元素，请参阅《IAM 用户指南》**中的 [IAM JSON 策略元素引用](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html)。
### Amazon RDS 基于身份的策略示例
要查看 Amazon RDS 基于身份的策略的示例，请参阅 [Amazon RDS 的基于身份的策略示例](security_iam_id-based-policy-examples.md)。
## Amazon RDS 内基于资源的策略
**支持基于资源的策略：**否。
基于资源的策略是附加到资源的 JSON 策略文档。基于资源的策略的示例包括 IAM *角色信任策略*和 Amazon S3 *存储桶策略*。在支持基于资源的策略的服务中，服务管理员可以使用它们来控制对特定资源的访问。对于在其中附加策略的资源，策略定义指定主体可以对该资源执行哪些操作以及在什么条件下执行。您必须在基于资源的策略中[指定主体](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html)。主体可以包括账户、用户、角色、联合用户或。AWS 服务
要启用跨账户访问，您可以将整个账户或其他账户中的 IAM 实体指定为基于资源的策略中的主体。有关更多信息，请参阅《IAM 用户指南》**中的 [IAM 中的跨账户资源访问](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html)。
## Amazon RDS 的策略操作
**支持策略操作：**是。
管理员可以使用 AWS JSON 策略来指定谁有权访问什么内容。也就是说，哪个**主体**可以对什么**资源**执行**操作**，以及在什么**条件**下执行。
JSON 策略的 `Action` 元素描述可用于在策略中允许或拒绝访问的操作。在策略中包含操作以授予执行关联操作的权限。
Amazon RDS 中的策略操作在操作前使用以下前缀：`rds:`。例如，要授予某人使用 Amazon RDS `DescribeDBInstances` API 操作妙手数据库实例的权限，您应将 `rds:DescribeDBInstances` 操作纳入其策略中。策略语句必须包含 `Action` 或 `NotAction` 元素。Amazon RDS 定义了一组自己的操作，以描述您可以使用该服务执行的任务。
要在单个语句中指定多项 操作，请使用逗号将它们隔开，如下所示。
```
"Action": [
"rds:action1",
"rds:action2"
```
您也可以使用通配符 (\$1) 指定多个操作。例如，要指定以单词 `Describe` 开头的所有操作，请包括以下操作。
```
"Action": "rds:Describe*"
```
有关 Amazon RDS 操作的列表，请参阅*服务授权参考*中的 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)。
## Amazon RDS 的策略资源
**支持策略资源：**是。
管理员可以使用 AWS JSON 策略来指定谁有权访问什么内容。也就是说，哪个**主体**可以对什么**资源**执行**操作**，以及在什么**条件**下执行。
`Resource` JSON 策略元素指定要向其应用操作的一个或多个对象。作为最佳实践，请使用其 [Amazon 资源名称（ARN）](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html)指定资源。对于不支持资源级权限的操作，请使用通配符 (\$1) 指示语句应用于所有资源。
```
"Resource": "*"
```
数据库实例资源具有以下 Amazon 资源名称 (ARN)。
```
arn:${Partition}:rds:${Region}:${Account}:{ResourceType}/${Resource}
```
有关 ARN 格式的更多信息，请参阅 [Amazon Resource Name (ARN) 和 AWS 服务命名空间](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
例如，要在语句中指定 `dbtest` 数据库实例，请使用以下 ARN。
```
"Resource": "arn:aws:rds:us-west-2:123456789012:db:dbtest"
```
要指定属于特定账户的所有数据库实例，请使用通配符 (\$1)。
```
"Resource": "arn:aws:rds:us-east-1:123456789012:db:*"
```
某些 RDS API 操作（例如，用于创建资源的那些操作）无法在特定资源上执行。在这些情况下，请使用通配符 (\$1)。
```
"Resource": "*"
```
许多 Amazon RDS API 操作涉及多种资源。例如，`CreateDBInstance` 创建数据库实例。您可以指定，在创建数据库实例时， 用户必须使用特定的安全组和参数组。要在单个语句中指定多个资源，请使用逗号分隔 ARN。
```
"Resource": [
"resource1",
"resource2"
```
有关 Amazon RDS 资源类型及其 ARN 的列表，请参阅*服务授权参考*中的 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-resources-for-iam-policies)。要了解您可以在哪些操作中指定每个资源的 ARN，请参阅 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)。
## Amazon RDS 的策略条件键
**支持特定于服务的策略条件键：**是。
管理员可以使用 AWS JSON 策略来指定谁有权访问什么内容。也就是说，哪个**主体**可以对什么**资源**执行**操作**，以及在什么**条件**下执行。
`Condition` 元素根据定义的条件指定语句何时执行。您可以创建使用[条件运算符](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)（例如，等于或小于）的条件表达式，以使策略中的条件与请求中的值相匹配。要查看所有 AWS 全局条件键，请参阅《IAM 用户指南》**中的 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。
Amazon RDS 定义了自己的一组条件键，还支持使用一些全局条件键。要查看所有 AWS 全局条件键，请参阅 *IAM 用户指南*中的 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) 。
所有 RDS API 操作都支持 `aws:RequestedRegion` 条件键。
有关 Amazon RDS 条件键的列表，请参阅*服务授权参考*中的 [Amazon RDS 的条件键](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-policy-keys)。要了解您可以对哪些操作和资源使用条件键，请参阅 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)。
## Amazon RDS 中的访问控制列表 (ACL)
**支持访问控制列表（ACL）：**否
访问控制列表（ACL）控制哪些主体（账户成员、用户或角色）有权访问资源。ACL 与基于资源的策略类似，但它们不使用 JSON 策略文档格式。
## 策略中具有 Amazon RDS 标签的基于属性的访问控制 (ABAC)
**在策略中支持基于属性的访问权限控制（ABAC）标签：**是
基于属性的访问权限控制（ABAC）是一种授权策略，该策略基于称为标签的属性来定义权限。您可以将标签附加到 IAM 实体和 AWS 资源，然后设计 ABAC 策略，以支持在主体的标签与资源上的标签匹配时执行操作。
要基于标签控制访问，您需要使用 `aws:ResourceTag/key-name``aws:RequestTag/key-name` 或 `aws:TagKeys` 条件键在策略的[条件元素](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)中提供标签信息。
如果某个服务对于每种资源类型都支持所有这三个条件键，则对于该服务，该值为**是**。如果某个服务仅对于部分资源类型支持所有这三个条件键，则该值为**部分**。
有关 ABAC 的更多信息，请参阅《IAM 用户指南》**中的[使用 ABAC 授权定义权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)。要查看设置 ABAC 步骤的教程，请参阅《IAM 用户指南》**中的[使用基于属性的访问权限控制（ABAC）](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html)。
有关标记 Amazon RDS 资源的更多信息，请参阅[指定条件：使用自定义标签](UsingWithRDS.IAM.SpecifyingCustomTags.md)。要查看基于身份的策略（用于根据资源上的标签来限制对该资源的访问）的示例，请参阅[授予权限以允许对在特定标签中包含两个不同值的资源执行操作](security_iam_id-based-policy-examples-create-and-modify-examples.md#security_iam_id-based-policy-examples-grant-permissions-tags)。
## 将临时凭证用于 Amazon RDS
**支持临时凭证：**是。
临时凭证提供对 AWS 资源的短期访问权限，并且是在您使用联合身份验证或切换角色时自动创建的。AWS 建议您动态生成临时凭证，而不是使用长期访问密钥。有关更多信息，请参阅《IAM 用户指南》**中的 [IAM 中的临时安全凭证](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)和[使用 IAM 的。AWS 服务](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)
## Amazon RDS 的转发访问会话
**支持转发访问会话：**是。
转发访问会话（FAS）使用调用 AWS 服务 的主体的权限，与发出请求的 AWS 服务 结合，向下游服务发出请求。有关发出 FAS 请求时的策略详情，请参阅[转发访问会话](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html)。
## Amazon RDS 的服务角色
**支持服务角色：**是。
服务角色是由一项服务担任、代表您执行操作的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。IAM 管理员可以在 IAM 中创建、修改和删除服务角色。有关更多信息，请参阅《IAM 用户指南》**中的[创建向 AWS 服务 委派权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
**警告**
更改服务角色的权限可能会破坏 Amazon RDS 功能。仅当 Amazon RDS 提供相关指导时才编辑服务角色。
## Amazon RDS 的服务相关角色
**支持服务相关角色：**是。
服务关联角色是一种与 AWS 服务 关联的服务角色。服务可以代入代表您执行操作的角色。服务关联角色显示在您的 AWS 账户 中，并由该服务拥有。IAM 管理员可以查看但不能编辑服务关联角色的权限。
有关使用 Amazon RDS 服务相关角色的详细信息，请参阅[将服务相关角色用于 Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md)。
# Amazon RDS 的基于身份的策略示例
原定设置情况下，权限集和角色没有创建或修改 Amazon RDS 资源的权限。它们还无法使用 AWS 管理控制台、AWS CLI 或 AWS API 执行任务。管理员必须创建 IAM policy，以便为权限集和角色授予权限以对所需的指定资源执行特定的 API 操作。然后，管理员必须将这些策略附加到需要这些权限的权限集或角色。
要了解如何使用这些示例 JSON 策略文档创建 IAM 基于身份的策略，请参阅《*IAM 用户指南*》中的[在 JSON 选项卡上创建策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor)。
**Topics**
+ [
## 策略最佳实践
](#security_iam_service-with-iam-policy-best-practices)
+ [
## 使用 Amazon RDS 控制台
](#security_iam_id-based-policy-examples-console)
+ [
## 使用控制台所需的权限
](#UsingWithRDS.IAM.RequiredPermissions.Console)
+ [
## 允许用户查看他们自己的权限
](#security_iam_id-based-policy-examples-view-own-permissions)
+ [
# 在 Amazon RDS 中创建、修改和删除资源的权限策略
](security_iam_id-based-policy-examples-create-and-modify-examples.md)
+ [
# 示例策略：使用条件键
](UsingWithRDS.IAM.Conditions.Examples.md)
+ [
# 指定条件：使用自定义标签
](UsingWithRDS.IAM.SpecifyingCustomTags.md)
+ [
# 在创建过程中授予为 Amazon RDS 资源添加标签的权限
](security_iam_id-based-policy-examples-grant-permissions-tags-on-create.md)
## 策略最佳实践
基于身份的策略确定某个人是否可以创建、访问或删除您账户中的 Amazon RDS 资源。这些操作可能会使 AWS 账户产生成本。创建或编辑基于身份的策略时，请遵循以下指南和建议：
+ **AWS 托管式策略及转向最低权限许可入门**：要开始向用户和工作负载授予权限，请使用 *AWS 托管式策略*来为许多常见使用场景授予权限。您可以在 AWS 账户 中找到这些策略。建议通过定义特定于您的使用场景的 AWS 客户托管式策略来进一步减少权限。有关更多信息，请参阅《IAM 用户指南》**中的 [AWS 托管策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies)或[工作职能的 AWS 托管策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html)。
+ **应用最低权限**：在使用 IAM 策略设置权限时，请仅授予执行任务所需的权限。为此，您可以定义在特定条件下可以对特定资源执行的操作，也称为*最低权限许可*。有关使用 IAM 应用权限的更多信息，请参阅《IAM 用户指南》**中的 [IAM 中的策略和权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)。
+ **使用 IAM 策略中的条件进一步限制访问权限**：您可以向策略添加条件来限制对操作和资源的访问。例如，您可以编写策略条件来指定必须使用 SSL 发送所有请求。如果通过特定 AWS 服务（例如 CloudFormation）使用服务操作，您还可以使用条件来授予对服务操作的访问权限。有关更多信息，请参阅《IAM 用户指南》**中的 [IAM JSON 策略元素：条件](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)。
+ **使用 IAM Access Analyzer 验证您的 IAM 策略，以确保权限的安全性和功能性**：IAM Access Analyzer 会验证新策略和现有策略，以确保策略符合 IAM 策略语言（JSON）和 IAM 最佳实践。IAM Access Analyzer 提供 100 多项策略检查和可操作的建议，以帮助您制定安全且功能性强的策略。有关更多信息，请参阅《IAM 用户指南》**中的[使用 IAM Access Analyzer 验证策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html)。
+ **需要多重身份验证（MFA）**：如果您所处的场景要求您的 AWS 账户 中有 IAM 用户或根用户，请启用 MFA 来提高安全性。若要在调用 API 操作时需要 MFA，请将 MFA 条件添加到您的策略中。有关更多信息，请参阅《IAM 用户指南》**中的[使用 MFA 保护 API 访问](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)。
有关 IAM 中的最佳实操的更多信息，请参阅《IAM 用户指南》**中的 [IAM 中的安全最佳实践](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)。
## 使用 Amazon RDS 控制台
要访问 Amazon RDS 控制台，您必须拥有一组最低的权限。这些权限必须允许您列出和查看有关您的 AWS 账户中的 Amazon RDS 资源的详细信息。如果创建比必需的最低权限更为严格的基于身份的策略，对于附加了该策略的实体（用户或角色），控制台将无法按预期正常运行。
对于只需要调用 AWS CLI 或 AWS API 的用户，无需为其提供最低控制台权限。相反，只允许访问与您尝试执行的 API 操作相匹配的操作。
要确保这些实体仍可使用 Amazon RDS 控制台，也可向实体附加以下AWS托管策略。
```
AmazonRDSReadOnlyAccess
```
有关更多信息，请参阅 *IAM 用户指南* 中的[为用户添加权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)。
## 使用控制台所需的权限
对于要使用控制台的用户，该用户必须拥有一组最小权限。这些权限允许用户描述其AWS账户的 Amazon RDS 资源并提供其他相关信息（包括 Amazon EC2 安全和网络信息）。
如果创建比必需的最低权限更为严格的 IAM 策略，对于附加了该 IAM 策略的用户，控制台无法按预期正常运行。要确保这些用户仍可使用控制台，也可向用户附加 `AmazonRDSReadOnlyAccess` 托管策略，如[使用策略管理访问](UsingWithRDS.IAM.md#security_iam_access-manage)中所述。
对于只需要调用 AWS CLI 或 Amazon RDS API 的用户，无需为其提供最低限度的控制台权限。
以下策略授予对AWS根账户的所有 Amazon RDS 资源的完全访问权：
```
AmazonRDSFullAccess
```
## 允许用户查看他们自己的权限
该示例说明了您如何创建策略，以允许 IAM 用户查看附加到其用户身份的内联和托管式策略。此策略包括在控制台上完成此操作或者以编程方式使用 AWS CLI 或 AWS API 所需的权限。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# 在 Amazon RDS 中创建、修改和删除资源的权限策略
以下各节展示了授予和限制资源访问权限的权限策略示例：
## 允许用户在 AWS 账户中创建数据库实例
以下是支持 ID 为 `123456789012` 的账户为您的 AWS 账户创建数据库实例的示例策略。该策略要求新数据库实例的名称以 `test` 开头。新数据库实例还必须使用 MySQL 数据库引擎和 `db.t2.micro` 数据库实例类。此外，新数据库实例必须使用以 `default` 开头的选项组和数据库参数组，并且它必须使用 `default` 子网组。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateDBInstanceOnly",
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:db:test*",
"arn:aws:rds:*:123456789012:og:default*",
"arn:aws:rds:*:123456789012:pg:default*",
"arn:aws:rds:*:123456789012:subgrp:default"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql",
"rds:DatabaseClass": "db.t2.micro"
}
}
}
]
}
```
------
此策略包含一个为 用户指定以下权限的语句：
+ 该策略可让该账户使用 [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) API 操作创建数据库实例（这还适用于 [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) AWS CLI 命令和 AWS 管理控制台）。
+ `Resource` 元素指定用户可以执行操作的资源。使用 Amazon Resource Name (ARN) 指定资源。此 ARN 包括资源所属服务的名称（`rds`）、AWS 区域（在该示例中，`*` 指示任何区域）、AWS 账号（在该示例中，`123456789012` 为账号）以及资源的类型。有关创建 ARN 的更多信息，请参阅[Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)。
该示例中的 `Resource` 元素为用户指定有关资源的以下策略限制：
+ 新数据库实例的数据库实例标识符必须以 `test` 开头 (例如，`testCustomerData1`、`test-region2-data`)。
+ 新数据库实例的选项组必须以 `default` 开头。
+ 新数据库实例的数据库参数组必须以 `default` 开头。
+ 新数据库实例的子网组必须是 `default` 子网组。
+ `Condition` 元素指定数据库引擎必须是 MySQL 并且数据库实例类必须是 `db.t2.micro`。`Condition` 元素指定策略生效的条件。您可以通过使用 `Condition` 元素添加其他权限或限制。有关指定条件的更多信息，请参阅[Amazon RDS 的策略条件键](security_iam_service-with-iam.md#UsingWithRDS.IAM.Conditions)。此示例指定 `rds:DatabaseEngine` 和 `rds:DatabaseClass` 条件。有关 `rds:DatabaseEngine` 的有效条件值的信息，请参阅 [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) 中的 `Engine` 参数下的列表。有关 `rds:DatabaseClass` 的有效条件值的信息，请参阅 [数据库实例类支持的数据库引擎](Concepts.DBInstanceClass.Support.md) 。
该策略不指定 `Principal` 元素，因为在基于身份的策略中，您未指定获取权限的委托人。附加了策略的用户是隐式委托人。向 IAM 角色附加权限策略后，该角色的信任策略中标识的委托人将获取权限。
有关 Amazon RDS 操作的列表，请参阅*服务授权参考*中的 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)。
## 允许用户对任何 RDS 资源执行任何 Describe 操作
以下权限策略对用户授予权限以运行以 `Describe` 开头的所有操作。这些操作显示有关 RDS 资源 (如数据库实例) 的信息。`Resource` 元素中的通配符 (\$1) 表示可对账户拥有的所有 Amazon RDS 资源执行操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRDSDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## 允许用户创建使用指定数据库参数组和子网组的数据库实例
以下权限策略授予权限以允许用户仅创建必须使用 `mydbpg` 数据库参数组和 `mydbsubnetgroup` 数据库子网组的数据库实例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": [
"arn:aws:rds:*:*:pg:mydbpg",
"arn:aws:rds:*:*:subgrp:mydbsubnetgroup"
]
}
]
}
```
------
## 授予权限以允许对在特定标签中包含两个不同值的资源执行操作
您可以在基于身份的策略中使用条件，以便基于标签控制对 Amazon RDS 资源的访问。以下策略所授予的权限允许对 `stage` 标签设置为 `development` 或 `test` 的实例执行 `CreateDBSnapshot` API 操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
以下策略所授予的权限允许对 `stage` 标签设置为 `development` 或 `test` 的实例执行 `ModifyDBInstance` API 操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
## 防止用户删除数据库实例
以下权限策略授予权限以防止用户删除特定数据库实例。例如，您可能想禁止任何非管理员用户删除您的生产数据库实例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyDelete1",
"Effect": "Deny",
"Action": "rds:DeleteDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:db:my-mysql-instance"
}
]
}
```
------
## 拒绝对资源的所有访问
您可以明确拒绝对资源的访问。拒绝策略优先于允许策略。以下策略明确拒绝用户管理资源的能力：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "rds:*",
"Resource": "arn:aws:rds:us-east-1:123456789012:db:mydb"
}
]
}
```
------
# 示例策略：使用条件键
以下示例说明了如何在 Amazon RDS IAM 权限策略中使用条件键。
## 示例 1：授予权限以创建使用特定数据库引擎的非多可用区数据库实例
以下策略使用 RDS 条件键，并仅允许用户创建采用 MySQL 数据库引擎且不使用多可用区的数据库实例。`Condition` 元素指示数据库引擎须为 MySQL 的要求。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowMySQLCreate",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql"
},
"Bool": {
"rds:MultiAz": false
}
}
}
]
}
```
------
## 示例 2：明确拒绝权限，以禁止创建特定数据库实例类的数据库实例和使用预置 IOPS 的数据库实例
以下策略显式拒绝创建使用数据库实例类 `r3.8xlarge` 和 `m4.10xlarge`（最大、最贵的数据库实例类）的数据库实例的权限。此策略还禁止用户创建使用预置的 IOPS (这会带来额外成本) 的数据库实例。
显式拒绝权限会取代授予的任何其他权限。这可确保用户身份不会无意中获得您绝不希望授予的权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyLargeCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseClass": [
"db.r3.8xlarge",
"db.m4.10xlarge"
]
}
}
},
{
"Sid": "DenyPIOPSCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"NumericNotEquals": {
"rds:Piops": "0"
}
}
}
]
}
```
------
## 示例 3：限制可用于对资源进行标记的一组标签键和值的值
下面的策略使用 RDS 条件键，并允许将键为 `stage` 的标签添加到值为 `test`、`qa` 和 `production` 的资源。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowTagEdits",
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource": "arn:aws:rds:us-east-1:123456789012:db:db-123456",
"Condition": {
"StringEquals": {
"rds:req-tag/stage": [
"test",
"qa",
"production"
]
}
}
}
]
}
```
------
# 指定条件：使用自定义标签
Amazon RDS 支持在 IAM 策略中使用自定义标签指定条件。
例如，假定您将一个名为 `environment` 的标签添加到具有 `beta`、`staging`、`production` 等值的数据库实例。如果您这样做，则可创建一个策略来根据 `environment` 标签值以仅允许某些用户使用数据库实例。
**注意**
自定义标签标识符区分大小写。
下表列出了可以在 `Condition` 元素中使用的 RDS 标签标识符。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.SpecifyingCustomTags.html)
自定义标签条件的语法如下：
`"Condition":{"StringEquals":{"rds:rds-tag-identifier/tag-name": ["value"]} }`
例如，以下 `Condition` 元素适用于具有名为 `environment` 的标签且标签值为 `production` 的数据库实例。
` "Condition":{"StringEquals":{"rds:db-tag/environment": ["production"]} } `
有关创建标签的信息，请参阅[为 Amazon RDS 资源添加标签](USER_Tagging.md)。
**重要**
如果您使用标签管理对 RDS 资源的访问，建议您保护对 RDS 资源的标签的访问。您可通过为 `AddTagsToResource` 和 `RemoveTagsFromResource` 操作创建策略来管理对标签的访问。例如，以下策略不允许用户为所有资源添加或删除标签。之后，您可创建策略来允许特定用户添加或删除标签。
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyTagUpdates",
"Effect":"Deny",
"Action":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
有关 Amazon RDS 操作的列表，请参阅*服务授权参考*中的 [Amazon RDS 定义的操作](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)。
## 示例策略：使用自定义标签
以下示例说明了如何在 Amazon RDS IAM 权限策略中使用自定义标签。有关向 Amazon RDS 资源添加标签的更多信息，请参阅[Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)。
**注意**
所有示例都使用 us-west-2 区域和虚构的账户 ID。
### 示例 1：授予权限以允许对在特定标签中包含两个不同值的资源执行操作
以下策略所授予的权限允许对 `stage` 标签设置为 `development` 或 `test` 的实例执行 `CreateDBSnapshot` API 操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
以下策略所授予的权限允许对 `stage` 标签设置为 `development` 或 `test` 的实例执行 `ModifyDBInstance` API 操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
### 示例 2：明确拒绝权限，以禁止创建使用指定数据库参数组的数据库实例
以下策略通过显式拒绝权限，禁止创建在数据库参数组中包含特定标签值的数据库实例。如果您需要在创建数据库实例时始终使用特定客户创建的数据库参数组，则可以应用此策略。使用 `Deny` 的策略最常用于限制由更宽泛的策略所授予的访问权限。
显式拒绝权限会取代授予的任何其他权限。这可确保用户身份不会无意中获得您绝不希望授予的权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyProductionCreate",
"Effect":"Deny",
"Action":"rds:CreateDBInstance",
"Resource":"arn:aws:rds:*:123456789012:pg:*",
"Condition":{
"StringEquals":{
"rds:pg-tag/usage":"prod"
}
}
}
]
}
```
------
### 示例 3：授予权限以允许对实例名称以用户名为前缀的数据库实例执行操作
以下策略授予的权限允许对具有如下性质的数据库实例调用除 `AddTagsToResource` 和 `RemoveTagsFromResource` 以外的任何 API：该数据库实例的实例名称以用户名称作为前缀，并且具有值为 `stage` 的 `devo` 标签或没有名为 `stage` 的标签。
策略中的 `Resource` 行通过 Amazon Resource Name (ARN) 标识资源。有关对 Amazon RDS 资源使用 ARN 的更多信息，请参阅[Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowFullDevAccessNoTags",
"Effect":"Allow",
"NotAction":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"arn:aws:rds:*:123456789012:db:${aws:username}*",
"Condition":{
"StringEqualsIfExists":{
"rds:db-tag/stage":"devo"
}
}
}
]
}
```
------
# 在创建过程中授予为 Amazon RDS 资源添加标签的权限
某些 RDS API 操作支持在创建资源时指定标签。您可以使用资源标签来实现基于属性的控制（ABAC）。有关更多信息，请参阅[什么是适用于 AWS 的 ABAC？](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)和[使用标签控制对 AWS 资源的访问](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)。
为使用户能够在创建时为资源添加标签，他们必须有权使用创建该资源的操作（如 `rds:CreateDBInstance`）。如果在创建操作中指定了标签，则 RDS 会对 `rds:AddTagsToResource` 操作执行额外的授权，以验证用户是否具备创建标签的权限。因此，用户还必须具有使用 `rds:AddTagsToResource` 操作的显式权限。
在 `rds:AddTagsToResource` 操作的 IAM 策略定义中，可以使用 `aws:RequestTag` 条件键要求在请求中使用标签来为资源加标签。
例如，以下策略支持用户在创建数据库实例期间创建数据库实例和应用标签，但只能使用特定的标签键（`environment` 或 `project`）：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": ["production", "development"],
"aws:RequestTag/project": ["dataanalytics", "webapp"]
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["environment", "project"]
}
}
}
]
}
```
------
此策略拒绝以下任何创建数据库实例请求：包含除 `environment` 或 `project` 标签之外的其它标签，或者未指定这两个标签中的任何一个。此外，用户必须为标签指定与策略中支持的值相匹配的值。
以下策略支持用户创建数据库集群和在创建过程中应用除 `environment=prod` 标签以外的任何标签：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestTag/environment": "prod"
}
}
}
]
}
```
------
## 支持在创建时添加标签的 RDS API 操作
以下 RDS API 操作支持在创建资源时添加标签。对于这些操作，您可以在创建资源时指定标签：
+ `CreateBlueGreenDeployment`
+ `CreateCustomDBEngineVersion`
+ `CreateDBCluster`
+ `CreateDBClusterEndpoint`
+ `CreateDBClusterParameterGroup`
+ `CreateDBClusterSnapshot`
+ `CreateDBInstance`
+ `CreateDBInstanceReadReplica`
+ `CreateDBParameterGroup`
+ `CreateDBProxy`
+ `CreateDBProxyEndpoint`
+ `CreateDBSecurityGroup`
+ `CreateDBShardGroup`
+ `CreateDBSnapshot`
+ `CreateDBSubnetGroup`
+ `CreateEventSubscription`
+ `CreateGlobalCluster`
+ `CreateIntegration`
+ `CreateOptionGroup`
+ `CreateTenantDatabase`
+ `CopyDBClusterParameterGroup`
+ `CopyDBClusterSnapshot`
+ `CopyDBParameterGroup`
+ `CopyDBSnapshot`
+ `CopyOptionGroup`
+ `RestoreDBClusterFromS3`
+ `RestoreDBClusterFromSnapshot`
+ `RestoreDBClusterToPointInTime`
+ `RestoreDBInstanceFromDBSnapshot`
+ `RestoreDBInstanceFromS3`
+ `RestoreDBInstanceToPointInTime`
+ `PurchaseReservedDBInstancesOffering`
如果您使用 AWS CLI 或 API 创建带有标签的资源，则 `Tags` 参数用于在创建期间对资源应用标签。
对于这些 API 操作，如果添加标签失败，则不会创建资源，并且请求失败且显示错误。这可确保要么创建带有标签的资源，要么根本不创建资源，从而防止创建不带所需标签的资源。
# AWS适用于 Amazon RDS 的 托管式策略
要向权限集和角色添加权限，与自己编写策略相比，使用 AWS 托管式策略更简单。创建仅为团队提供所需权限的 [IAM 客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html)需要时间和专业知识。要快速入门，您可以使用我们的 AWS 托管策略。这些策略涵盖常见使用案例，可在您的 AWS 账户 中使用。有关 AWS 托管策略的更多信息，请参阅*《IAM 用户指南》*中的[AWS 托管策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies)。
AWS 服务 负责维护和更新 AWS 托管策略。您无法更改 AWS 托管策略中的权限。服务偶尔会向 AWS 托管式策略添加额外权限以支持新特征。此类型的更新会影响附加了策略的所有身份（权限集和角色）。当启动新特征或新操作可用时，服务最有可能会更新 AWS 托管式策略。服务不会从 AWS 托管式策略中删除权限，因此策略更新不会破坏您的现有权限。
此外，AWS还支持跨多种服务的工作职能的托管式策略。例如，`ReadOnlyAccess` AWS 托管式策略提供对许多 AWS 服务和资源的只读访问权限。当服务启动新特征时，AWS 会为新操作和资源添加只读权限。有关工作职能策略的列表和说明，请参阅《IAM 用户指南》**中的[适用于工作职能的 AWS 托管式策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html)。
**Topics**
+ [
## AWS 托管式策略：AmazonRDSReadOnlyAccess
](#rds-security-iam-awsmanpol-AmazonRDSReadOnlyAccess)
+ [
## AWS 托管式策略：AmazonRDSFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSFullAccess)
+ [
## AWS 托管式策略：AmazonRDSDataFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSDataFullAccess)
+ [
## AWS 托管式策略：AmazonRDSEnhancedMonitoringRole
](#rds-security-iam-awsmanpol-AmazonRDSEnhancedMonitoringRole)
+ [
## AWS 托管式策略：AmazonRDSPerformanceInsightsReadOnly
](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly)
+ [
## AWS 托管式策略：AmazonRDSPerformanceInsightsFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess)
+ [
## AWS 托管式策略：AmazonRDSDirectoryServiceAccess
](#rds-security-iam-awsmanpol-AmazonRDSDirectoryServiceAccess)
+ [
## AWS 托管式策略：AmazonRDSServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy)
+ [
## AWS 托管式策略：AmazonRDSCustomServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSCustomServiceRolePolicy)
+ [
## AWS 托管式策略：AmazonRDSCustom实例ProfileRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy)
+ [
## AWS 托管式策略：AmazonRDSPreviewServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)
+ [
## AWS 托管式策略：AmazonRDSBetaServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)
## AWS 托管式策略：AmazonRDSReadOnlyAccess
此策略允许通过 AWS 管理控制台 对 Amazon RDS 进行只读访问。
**权限详细信息**
该策略包含以下权限：
+ `rds` – 允许主体描述 Amazon RDS 资源并列出 Amazon RDS 资源的标签。
+ `cloudwatch` – 允许主体获取 Amazon CloudWatch 指标统计数据。
+ `ec2` – 可让主体描述可用区和网络资源。
+ `logs` – 允许主体描述日志组的 CloudWatch Logs 日志流，并获取 CloudWatch Logs 日志事件。
+ `devops-guru` – 允许主体描述具有 Amazon DevOps Guru 覆盖范围的资源，该覆盖范围由 CloudFormation 堆栈名称或资源标签指定。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html)。
## AWS 托管式策略：AmazonRDSFullAccess
此策略通过 AWS 管理控制台 提供了对 Amazon RDS 的完全访问权限。
**权限详细信息**
该策略包含以下权限：
+ `rds` – 允许主体完全访问 Amazon RDS。
+ `application-autoscaling` – 允许主体描述和管理 Application Auto Scaling 扩展目标和策略。
+ `cloudwatch` – 允许主体获取 CloudWatch 指标统计数据并管理 CloudWatch 警报。
+ `ec2` – 可让主体描述可用区和网络资源。
+ `logs` – 允许主体描述日志组的 CloudWatch Logs 日志流，并获取 CloudWatch Logs 日志事件。
+ `outposts` – 允许主体获取 AWS Outposts 实例类型。
+ `pi` – 允许主体获取 Performance Insights 指标。
+ `sns` – 允许主体访问 Amazon Simple Notification Service (Amazon SNS) 订阅和主题，并发布 Amazon SNS 消息。
+ `devops-guru` – 允许主体描述具有 Amazon DevOps Guru 覆盖范围的资源，该覆盖范围由 CloudFormation 堆栈名称或资源标签指定。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSFullAccess.html)。
## AWS 托管式策略：AmazonRDSDataFullAccess
此策略提供完全访问权限，允许在特定 AWS 账户中的 Aurora Serverless 集群上使用 Data API 和查询编辑器。此策略允许 AWS 账户从 AWS Secrets Manager 获取密钥的值。
您可以将 `AmazonRDSDataFullAccess` 策略附加到 IAM 身份。
**权限详细信息**
该策略包含以下权限：
+ `dbqms` – 允许主体访问、创建、删除、描述和更新查询。Database Query Metadata Service (`dbqms`) 是一项仅限内部使用的服务。它为 AWS 管理控制台 上多项 AWS 服务（包括 Amazon RDS）提供查询编辑器最近的和保存的查询。
+ `rds-data` – 允许主体在 Aurora Serverless 数据库上运行 SQL 语句。
+ `secretsmanager` – 允许主体从 获取密钥的值。AWS Secrets Manager
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSDataFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDataFullAccess.html)。
## AWS 托管式策略：AmazonRDSEnhancedMonitoringRole
此策略提供了对 Amazon CloudWatch Logs 的访问权限，支持 Amazon RDS 增强监控。
**权限详细信息**
该策略包含以下权限：
+ `logs` – 允许主体创建 CloudWatch Logs 日志组和保留策略，并创建和描述日志组的 CloudWatch Logs 日志流。它还允许主体放置和获取 CloudWatch Logs 日志事件。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSEnhancedMonitoringRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSEnhancedMonitoringRole.html)。
## AWS 托管式策略：AmazonRDSPerformanceInsightsReadOnly
此策略提供了对 Amazon RDS Performance Insights 的只读访问权限，用于处理 Amazon RDS 数据库实例和 Amazon Aurora 数据库集群。
此策略现在包含 `Sid`（语句 ID）作为策略语句的标识符。
**权限详细信息**
该策略包含以下权限：
+ `rds` – 允许主体描述 Amazon RDS 数据库实例和 Amazon Aurora 数据库集群。
+ `pi` – 允许主体调用 Amazon RDS Performance Insights API 并访问 Performance Insights 指标。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSPerformanceInsightsReadOnly](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsReadOnly.html)。
## AWS 托管式策略：AmazonRDSPerformanceInsightsFullAccess
此策略提供了对 Amazon RDS 性能详情的完全访问权限，用于处理 Amazon RDS 数据库实例和 Amazon Aurora 数据库集群。
此策略现在包含 `Sid`（语句 ID）作为策略语句的标识符。
**权限详细信息**
该策略包含以下权限：
+ `rds` – 允许主体描述 Amazon RDS 数据库实例和 Amazon Aurora 数据库集群。
+ `pi` – 允许主体调用 Amazon RDS 性能详情 API，以及创建、查看和删除性能分析报告。
+ `cloudwatch` – 允许主体列出所有 Amazon CloudWatch 指标，并获取指标数据和统计数据。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSPerformanceInsightsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsFullAccess.html)。
## AWS 托管式策略：AmazonRDSDirectoryServiceAccess
此策略允许 Amazon RDS 调用 Directory Service。
**权限详细信息**
此策略包含以下权限：
+ `ds` – 允许主体描述 Directory Service 目录并控制对 Directory Service 目录的授权。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSDirectoryServiceAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDirectoryServiceAccess.html)。
## AWS 托管式策略：AmazonRDSServiceRolePolicy
您不能将 `AmazonRDSServiceRolePolicy` 策略附加到您的 IAM 实体。此附加到服务相关角色的策略允许 Amazon RDS 代表您执行操作。有关更多信息，请参阅 [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions)。
## AWS 托管式策略：AmazonRDSCustomServiceRolePolicy
您不能将 `AmazonRDSCustomServiceRolePolicy` 策略附加到您的 IAM 实体。此策略附加到一个服务相关角色，该角色支持 Amazon RDS 代表 RDS 数据库资源调用 AWS 服务。
该策略包含以下权限：
+ `ec2` - 支持 RDS Custom 在提供时间点还原功能的数据库实例上执行备份操作。
+ `secretsmanager` - 允许 RDS Custom 管理由 RDS Custom 创建的数据库实例特定密钥。
+ `cloudwatch` - 支持 RDS Custom 通过 CloudWatch 代理将数据库实例指标和日志上传到 CloudWatch。
+ `events`、`sqs` - 允许 RDS Custom 发送和接收有关数据库实例的状态信息。
+ `cloudtrail`：支持 RDS Custom 接收有关数据库实例的更改事件
+ `servicequotas`：支持 RDS Custom 读取与数据库实例相关的服务配额
+ `ssm`：支持 RDS Custom 管理数据库实例的底层 EC2 实例。
+ `rds`：支持 RDS Custom 管理数据库实例的 RDS 资源
+ `iam`：支持 RDS Custom 验证实例配置文件并将其附加到数据库实例的底层 EC2 实例。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSCustomServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomServiceRolePolicy.html)。
## AWS 托管式策略：AmazonRDSCustom实例ProfileRolePolicy
您不应将 `AmazonRDSCustomInstanceProfileRolePolicy` 附加到自己的 IAM 实体。只能将其附加到实例配置文件角色，该角色用于向您的 Amazon RDS 自定义数据库实例授予执行各种自动化操作和数据库管理任务的权限。在创建 RDS 自定义实例期间将实例配置文件作为 `custom-iam-instance-profile` 参数传递，并且 RDS Custom 会将此实例配置文件关联到您的数据库实例。
**权限详细信息**
该策略包含以下权限：
+ `ssm`、`ssmmessages`、`ec2messages` - 允许 RDS Custom 通过 Systems Manager 在数据库实例上进行通信、执行自动化和维护代理任务。
+ `ec2`、`s3` - 允许 RDS Custom 在提供时间点还原功能的数据库实例上执行备份操作。
+ `secretsmanager` - 允许 RDS Custom 管理由 RDS Custom 创建的数据库实例特定密钥。
+ `cloudwatch`、`logs` - 允许 RDS Custom 通过 CloudWatch 代理将数据库实例指标和日志上传到 CloudWatch。
+ `events`、`sqs` - 允许 RDS Custom 发送和接收有关数据库实例的状态信息。
+ `kms` - 允许 RDS Custom 使用特定于实例的 KMS 密钥对 RDS Custom 管理的密钥和 S3 对象进行加密。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSCustom实例ProfileRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomInstanceProfileRolePolicy.html)。
## AWS 托管式策略：AmazonRDSPreviewServiceRolePolicy
您不应将 `AmazonRDSPreviewServiceRolePolicy` 附加到自己的 IAM 实体。此策略附加到一个服务相关角色，该角色支持 Amazon RDS 代表 RDS 数据库资源调用 AWS 服务。有关更多信息，请参阅 [Amazon RDS 预览版的服务相关角色](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdspreview)。
**权限详细信息**
该策略包含以下权限：
+ `ec2` – 可让主体描述可用区和网络资源。
+ `secretsmanager` – 允许主体从 获取密钥的值。AWS Secrets Manager
+ `cloudwatch`、`logs` - 可让 Amazon RDS 通过 CloudWatch 代理将数据库实例指标和日志上传到 CloudWatch。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS Managed Policy Reference Guide》**中的 [AmazonRDSPreviewServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPreviewServiceRolePolicy.html)。
## AWS 托管式策略：AmazonRDSBetaServiceRolePolicy
您不应将 `AmazonRDSBetaServiceRolePolicy` 附加到自己的 IAM 实体。此策略附加到一个服务相关角色，该角色支持 Amazon RDS 代表 RDS 数据库资源调用 AWS 服务。有关更多信息，请参阅 [Amazon RDS 测试版的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdsbeta)。
**权限详细信息**
该策略包含以下权限：
+ `ec2` - 可让 Amazon RDS 在提供时间点还原功能的数据库实例上执行备份操作。
+ `secretsmanager` - 可让 Amazon RDS 管理由 Amazon RDS 创建的数据库实例特定密钥。
+ `cloudwatch`、`logs` - 可让 Amazon RDS 通过 CloudWatch 代理将数据库实例指标和日志上传到 CloudWatch。
有关此策略的更多信息，包括 JSON 策略文档，请参阅《AWS 托管式策略参考指南》**中的 [AmazonRDSBetaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSBetaServiceRolePolicy.html)。
# AWS 托管式策略的 Amazon RDS 更新
查看有关 Amazon RDS 的 AWS 托管式策略的更新的详细信息（自从此服务开始跟踪这些更改）。有关此页面更改的自动提示，请订阅 Amazon RDS [文档历史记录](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/WhatsNew.html)页面上的 RSS 源。
| 更改 | 描述 | 日期 |
| --- | --- | --- |
| [AWS 托管式策略：AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy) – 对现有策略的更新 | Amazon RDS 从 `AWSServiceRoleForRDSPreview` 服务相关角色的 `AmazonRDSPreviewServiceRolePolicy` 中删除了 `sns:Publish` 权限。有关更多信息，请参阅 [AWS 托管式策略：AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)。 | 2024 年 8 月 7 日 |
| [AWS 托管式策略：AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy) - 对现有策略的更新 | Amazon RDS 从 `AWSServiceRoleForRDSBeta` 服务相关角色的 `AmazonRDSBetaServiceRolePolicy` 中删除了 `sns:Publish` 权限。有关更多信息，请参阅 [AWS 托管式策略：AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)。 | 2024 年 8 月 7 日 |
| [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) - 对现有策略的更新 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些权限可让 RDS Custom 在其它 AWS 区域中与 Amazon RDS 服务进行通信并复制 EC2 映像。有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2024 年 7 月 18 日 |
| [AWS 托管式策略：AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy) - 对现有策略的更新 | Amazon RDS 从 ` AWSServiceRoleForRDS` 服务相关角色的 `AmazonRDSServiceRolePolicy` 中删除了 `sns:Publish` 权限。有关更多信息，请参阅 [AWS 托管式策略：AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy)。 | 2024 年 7 月 2 日 |
| [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) - 对现有策略的更新 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这项新权限允许 RDS Custom 将服务角色作为实例配置文件关联到 RDS Custom 实例。有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2024 年 4 月 19 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) - 对现有策略的更新 | Amazon RDS 向 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了一项新权限，允许 RDS Custom for SQL Server 修改底层数据库主机实例类型。RDS 还增加了用于获取数据库主机的实例类型信息的 `ec2:DescribeInstanceTypes` 权限。有关更多信息，请参阅 [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md)。 | 2024 年 4 月 8 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md)：新策略 | Amazon RDS 添加了一个名为 AmazonRDSCustomInstanceProfileRolePolicy 的新托管式策略，允许 RDS Custom 通过 EC2 实例配置文件执行自动化操作和数据库管理任务。有关更多信息，请参阅 [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md)。 | 2024 年 2 月 27 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDS` 服务相关角色的 `AmazonRDSServiceRolePolicy` 添加了新的语句 ID。 有关更多信息，请参阅 [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions)。 | 2024 年 1 月 19 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) – 对现有策略的更新 | `AmazonRDSPerformanceInsightsReadOnly` 和 `AmazonRDSPerformanceInsightsFullAccess` 托管式策略现在将 `Sid`（语句 ID）作为标识符包括在策略语句中。 有关更多信息，请参阅[AWS 托管式策略：AmazonRDSPerformanceInsightsReadOnly](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly)和[AWS 托管式策略：AmazonRDSPerformanceInsightsFullAccess](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess) | 2023 年 10 月 23 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些新权限允许 RDS Custom for Oracle 创建、修改和删除 EventBridge 托管式规则。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 9 月 20 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) – 对现有策略的更新 | Amazon RDS 将新权限添加到 `AmazonRDSFullAccess` 托管式策略。这些权限允许您生成、查看和删除一段时间内的性能分析报告。 有关为性能详情配置访问策略的更多信息，请参阅[为 Performance Insights 配置访问策略](USER_PerfInsights.access-control.md)。 | 2023 年 8 月 17 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) – 新策略和对现有策略的更新 | Amazon RDS 向 `AmazonRDSPerformanceInsightsReadOnly` 托管式策略和名为 `AmazonRDSPerformanceInsightsFullAccess` 的新托管式策略添加了新权限。这些权限允许您分析一段时间内的性能详情、查看分析结果和建议以及删除报告。 有关为性能详情配置访问策略的更多信息，请参阅[为 Performance Insights 配置访问策略](USER_PerfInsights.access-control.md)。 | 2023 年 8 月 16 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些新权限允许 RDS Custom for Oracle 使用数据库快照。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 6 月 23 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些新权限允许 RDS Custom for Oracle 使用数据库快照。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 6 月 23 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些新权限允许 RDS Custom 创建网络接口。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 5 月 30 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。这些新权限允许 RDS Custom 调用 Amazon EBS 来检查存储限额。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 4 月 18 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS Custom 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限，以便与 Amazon SQS 集成。RDS Custom 需要与 Amazon SQS 集成，才能在客户账户中创建和管理 SQS 队列。SQS 队列名称遵循格式 `do-not-delete-rds-custom-[identifier]` 并标记为 `Amazon RDS Custom`。还添加了 `ec2:CreateSnapshot` 的权限，以允许 RDS Custom 为连接到实例的卷创建备份。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2023 年 4 月 6 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) – 更新到现有策略 | Amazon RDS 向 `AmazonRDSFullAccess` 和 `AmazonRDSReadOnlyAccess` 添加了新的 Amazon CloudWatch 命名空间 `ListMetrics`。 Amazon RDS 需要此命名空间来列出特定的资源使用情况指标。 有关更多信息，请参阅《Amazon CloudWatch 用户指南》**中的[管理对您的 CloudWatch 资源的访问权限的概述](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html)。 | 2023 年 4 月 4 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md) – 更新到现有策略 | Amazon RDS 向 `AmazonRDSFullAccess` 和 `AmazonRDSReadOnlyAccess` 托管式策略添加了新权限，以允许在 RDS 控制台中显示 Amazon DevOps Guru 调查发现。 需要此权限才能显示 DevOps Guru 调查发现。 有关更多信息，请参阅 [Amazon RDS 对 AWS 托管式策略的更新](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-manpol-updates.html)。 | 2023 年 3 月 30 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDS` 服务相关角色的 `AmazonRDSServiceRolePolicy` 添加了新权限，以便与 AWS Secrets Manager 集成。RDS 需要与 Secrets Manager 集成才能在 Secrets Manager 中管理主用户密码。该密钥使用保留的命名惯例并限制客户更新。 有关更多信息，请参阅 [使用 Amazon RDS 和 AWS Secrets Manager 管理密码](rds-secrets-manager.md)。 | 2022 年 12 月 22 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDSCustom` 服务相关角色的 `AmazonRDSCustomServiceRolePolicy` 添加了新权限。RDS Custom 支持数据库集群。策略中的这些新权限允许 RDS Custom 代表您的数据库集群调用 AWS 服务。 有关更多信息，请参阅 [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2022 年 11 月 9 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 为 `AWSServiceRoleForRDS` 服务相关角色添加了新权限，以便与 AWS Secrets Manager 集成。 需要与 Secrets Manager 集成，SQL Server Reporting Services（SSRS）电子邮件才能在 RDS 上运行。SSRS 电子邮件代表客户创建一个密钥。该密钥使用保留的命名惯例并限制客户更新。 有关更多信息，请参阅 [使用 SSRS 电子邮件发送报告](SSRS.Email.md)。 | 2022 年 8 月 26 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 向 `PutMetricData` 的 `AmazonRDSPreviewServiceRolePolicy` 添加了新的 Amazon CloudWatch 命名空间。 Amazon RDS 需要此命名空间来发布资源用量指标。 有关更多信息，请参阅《Amazon CloudWatch 用户指南》中的[使用条件键限制对 CloudWatch 命名空间的访问](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html)**。 | 2022 年 6 月 7 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 向 `PutMetricData` 的 `AmazonRDSBetaServiceRolePolicy` 添加了新的 Amazon CloudWatch 命名空间。 Amazon RDS 需要此命名空间来发布资源用量指标。 有关更多信息，请参阅《Amazon CloudWatch 用户指南》中的[使用条件键限制对 CloudWatch 命名空间的访问](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html)**。 | 2022 年 6 月 7 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 向 `PutMetricData` 的 `AWSServiceRoleForRDS` 添加了新的 Amazon CloudWatch 命名空间。 Amazon RDS 需要此命名空间来发布资源用量指标。 有关更多信息，请参阅《Amazon CloudWatch 用户指南》中的[使用条件键限制对 CloudWatch 命名空间的访问](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html)**。 | 2022 年 4 月 22 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 向 `AWSServiceRoleForRDS` 服务相关角色添加了新权限，以管理客户拥有的 IP 池和本地网关路由表 (LGW-RTB) 的权限。 RDS on Outposts 需要这些权限，才能跨 Outposts 的本地网络执行多可用区复制。 有关更多信息，请参阅 [使用 Amazon RDS on AWS Outposts 的多可用区部署](rds-on-outposts.maz.md)。 | 2022 年 4 月 19 日 |
| [基于身份的策略](UsingWithRDS.IAM.md#security_iam_access-manage-id-based-policies) – 更新到现有策略 | Amazon RDS 向 `AmazonRDSFullAccess` 托管式策略添加了一项新权限，以描述对 LGW-RTB 的权限。 需要此权限来描述 RDS on Outposts 跨 Outposts 的本地网络执行多可用区复制所需的权限。 有关更多信息，请参阅 [使用 Amazon RDS on AWS Outposts 的多可用区部署](rds-on-outposts.maz.md)。 | 2022 年 4 月 19 日 |
| [AWS适用于 Amazon RDS 的 托管式策略](rds-security-iam-awsmanpol.md)：新策略 | Amazon RDS 添加了名为 `AmazonRDSPerformanceInsightsReadOnly` 的新托管式策略，以允许 Amazon RDS 代表数据库实例调用 AWS 服务。 有关为性能详情配置访问策略的更多信息，请参阅[为 Performance Insights 配置访问策略](USER_PerfInsights.access-control.md)。 | 2022 年 3 月 10 日 |
| [Amazon RDS 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新到现有策略 | Amazon RDS 向 `PutMetricData` 的 `AWSServiceRoleForRDS` 添加了新的 Amazon CloudWatch 命名空间。 要发布 CloudWatch 指标，Amazon DocumentDB（MongoDB 兼容）和 Amazon Neptune 需要这些命名空间。 有关更多信息，请参阅《Amazon CloudWatch 用户指南》中的[使用条件键限制对 CloudWatch 命名空间的访问](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html)**。 | 2022 年 3 月 4 日 |
| [Amazon RDS Custom 的服务相关角色权限](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)：新策略 | Amazon RDS 添加了名为 `AWSServiceRoleForRDSCustom` 的新服务相关角色，以允许 RDS Custom 代表数据库实例调用 AWS 服务。 | 2021 年 10 月 26 日 |
| Amazon RDS 开始跟踪更改 | Amazon RDS 为其 AWS 托管式策略开启了跟踪更改。 | 2021 年 10 月 26 日 |
# 防范跨服务混淆代理问题
*混淆代理问题*是一个安全问题，即没有执行操作权限的实体可能会迫使更具权限的实体执行该操作。在 AWS 中，跨服务模拟可能会导致混淆代理问题。
一个服务（*呼叫服务*）调用另一项服务（*所谓的服务*）时，可能会发生跨服务模拟。可以操纵调用服务来使用其权限，以不应该具有的访问权限对另一个客户的资源进行操作。为防止这种情况，AWS 提供可帮助您保护所有服务数据的工具，而这些服务中的服务主体有权限访问账户中的资源。有关更多信息，请参阅《IAM 用户指南》**中的[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)。
要限制 Amazon RDS 为其他服务提供对资源的权限，我们建议在资源策略中使用 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键。
在某些情况下，`aws:SourceArn` 值不包含账户 ID，例如将 Amazon Resource Name (ARN) 用于 Amazon S3 存储桶时。在这些情况下，请确保使用两个全局条件上下文键来限制权限。在某些情况下，您可以使用两个全局条件上下文键并让 `aws:SourceArn` 值包含账户 ID。在这些情况下，当 `aws:SourceAccount` 值和 `aws:SourceArn` 值中的账户使用相同策略语句时，确保二者使用相同的账户 ID。如果您只希望将一个资源与跨服务访问相关联，请使用 `aws:SourceArn`。如果您想允许指定 AWS 账户中的任何资源与跨服务使用相关联，请使用 `aws:SourceAccount`。
确保 `aws:SourceArn` 的值是 Amazon RDS 资源类型的 ARN。有关更多信息，请参阅 [Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)。
防范混淆代理问题最有效的方法是使用 `aws:SourceArn` 全局条件上下文键和资源的完整 ARN。在某些情况下，您可能不知道资源的完整 ARN，或者您可能正在指定多个资源。在这些情况下，请将带通配符 (`*`) 的 `aws:SourceArn` 全局上下文条件键用于 ARN 的未知部分。例如，`arn:aws:rds:*:123456789012:*`。
以下示例演示如何使用 Amazon RDS 中的 `aws:SourceArn` 和 `aws:SourceAccount` 全局条件上下文键来防范混淆代理问题。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "ConfusedDeputyPreventionExamplePolicy",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
}
```
------
有关使用 `aws:SourceArn` 和 `aws:SourceAccount` 全局条件上下文键的更多策略示例，请参阅以下部分：
+ [授予向 Amazon SNS 主题发布通知的权限。](USER_Events.GrantingPermissions.md)
+ [为本机备份和还原手动创建 IAM 角色](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [为 SQL Server 数据库实例设置 Windows 身份验证](USER_SQLServerWinAuth.SettingUp.md)
+ [将 RDS for SQL Server 与 S3 集成的先决条件](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [手动为 SQL Server Audit 创建 IAM 角色](Appendix.SQLServer.Options.Audit.IAM.md)
+ [为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md)
+ [设置 Amazon S3 存储桶的访问权限](USER_PostgreSQL.S3Import.AccessPermission.md)（PostgreSQL 导入）
+ [设置 Amazon S3 存储桶的访问权限](postgresql-s3-export-access-bucket.md)（PostgreSQL 导出）
# 适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证
您可以使用 AWS Identity and Access Management（IAM）数据库身份验证对数据库实例进行身份验证。IAM 数据库身份验证适用于 MariaDB、MySQL 和 PostgreSQL。利用此身份验证方法，您在连接到数据库实例时将无需使用密码。而是使用身份验证令牌。
*身份验证令牌* 是 Amazon RDS 根据请求生成的唯一字符串。身份验证令牌是使用 AWS 签名版本 4 生成的。每个令牌的使用期限为 15 分钟。您无需将用户凭证存储在数据库中，因为身份验证是使用 IAM 进行外部管理的。此外，您仍可使用标准数据库身份验证。令牌仅用于身份验证，建立后不会影响会话。
IAM 数据库身份验证具有以下优势：
+ 数据库的出站和进站网络流量是使用安全套接字层 (SSL) 或传输层安全性 (TLS) 加密的。有关将 SSL/TLS 与 Amazon RDS 一起使用的更多信息，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
+ 您可以使用 IAM 集中管理对数据库资源的访问，而不是单独管理对每个数据库实例的访问。
+ 对于在 Amazon EC2 上运行的应用程序，您可以使用 EC2 实例特定的配置文件凭证访问数据库以提高安全性，而不是使用密码。
一般来说，如果应用程序每秒创建的连接少于 200 个，而且您不想直接在应用程序代码中管理用户名和密码，请考虑使用 IAM 数据库身份验证。
Amazon Web Services（AWS）JDBC 驱动程序支持 IAM 数据库身份验证。有关更多信息，请参阅 [Amazon Web Services（AWS）JDBC 驱动程序 GitHub 存储库](https://github.com/aws/aws-advanced-jdbc-wrapper)中的 [AWS IAM 身份验证插件](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)。
Amazon Web Services（AWS）Python 驱动程序支持 IAM 数据库身份验证。有关更多信息，请参阅 [Amazon Web Services（AWS）Python 驱动程序 GitHub 存储库](https://github.com/aws/aws-advanced-python-wrapper)中的 [AWS IAM 身份验证插件](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)。
浏览以下主题，学习设置 IAM 用于数据库身份验证的过程：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [使用 IAM 身份验证连接到数据库实例](UsingWithRDS.IAMDBAuth.Connecting.md)
## 区域和版本可用性
功能可用性和支持因每个数据库引擎的特定版本而异。有关适用于 Amazon RDS 和 IAM 数据库身份验证的引擎、版本和区域可用性的更多信息，请参阅[支持 Amazon RDS 中 IAM 数据库身份验证功能的区域和数据库引擎](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md)。
## CLI 和开发工具包支持
IAM 数据库身份验证可用于 [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html) 以及以下特定于语言的 AWS 软件开发工具包：
+ [适用于 .NET 的 AWS SDK](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [适用于 C\$1\$1 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [适用于 Go 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [适用于 Java 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [适用于 JavaScript 的 AWS SDK](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [适用于 PHP 的 AWS SDK](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [适用于 Python (Boto3) 的 AWS SDK](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [适用于 Ruby 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## IAM 数据库身份验证的限制
使用 IAM 数据库身份验证时，以下限制适用：
+ 目前，IAM 数据库身份验证并不支持所有的全局条件上下文键。
有关全局条件上下文键的更多信息，请参阅《IAM 用户指南**》中的 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。
+ 对于 PostgreSQL，如果将 IAM 角色（`rds_iam`）添加到某个用户（包括 RDS 主用户），IAM 身份验证将优先于密码身份验证，因此该用户必须以 IAM 用户身份登录。
+ 对于 PostgreSQL，Amazon RDS 不支持同时启用 IAM 和 Kerberos 身份验证方法。
+ 对于 PostgreSQL，您不能使用 IAM 身份验证来建立复制连接。
+ 不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
+ CloudWatch 和 CloudTrail 不记录 IAM 身份验证。这些服务不会跟踪授权 IAM 角色启用数据库连接的 `generate-db-auth-token` API 调用。
+ IAM 数据库身份验证需要数据库实例上的计算资源。您的数据库上必须有 300 到 1000 MiB 的额外内存，才能实现可靠的连接。要查看工作负载所需的内存，请在启用 IAM 数据库身份验证之前和之后，比较增强型监控进程列表中 RDS 进程的 RES 列。请参阅[在 RDS 控制台中查看操作系统指标](USER_Monitoring.OS.Viewing.md)。
如果您使用的是可突增类实例，请通过将其它参数使用的内存（如缓冲区和缓存）减少相同的量，从而避免内存耗尽。
+ 对于任何引擎，RDS on Outposts 不支持 IAM 数据库身份验证。
## IAM 数据库身份验证建议
在使用 IAM 数据库身份验证时，建议使用以下方法：
+ 当您的应用程序每秒需要少于 200 个新的 IAM 数据库身份验证连接时，请使用 IAM 数据库身份验证。
使用 Amazon RDS 的数据库引擎不会对每秒的身份验证尝试次数施加任何限制。不过，在使用 IAM 数据库身份验证时，您的应用程序必须生成身份验证令牌。之后，您的应用程序将使用该令牌连接到数据库实例。如果超出每秒的最大新连接数限制，则 IAM 数据库身份验证的额外开销可能会导致连接受到限制。
考虑在应用程序中使用连接池来减少持续的连接创建。这可以减少 IAM 数据库身份验证的开销，并允许应用程序重用现有连接。或者，考虑对这些使用案例使用 RDS 代理。RDS 代理有额外费用。请参阅 [RDS 代理定价](https://aws.amazon.com/rds/proxy/pricing/)。
+ IAM 数据库身份验证令牌的大小取决于许多因素，包括 IAM 标签的数量、IAM 服务策略、ARN 长度以及其他 IAM 和数据库属性。此令牌的最小大小通常约为 1KB，但可以更大。由于使用 IAM 身份验证将此令牌用作数据库的连接字符串中的密码，因此，您应确保您的数据库驱动程序（例如 ODBC）和/或任何工具不会因其大小而限制或以其他方式截断该令牌。截断的令牌将导致数据库和 IAM 执行的身份验证失败。
+ 如果您在创建 IAM 数据库身份验证令牌时使用临时凭证，则在使用 IAM 数据库身份验证令牌发出连接请求时，临时凭证必须仍然有效。
## 不支持的 AWS 全局条件上下文键
IAM 数据库身份验证不支持 AWS 全局条件上下文键的以下子集。
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
有关更多信息，请参阅《IAM 用户指南》**中的 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。
# 启用和禁用 IAM 数据库身份验证
默认情况下，已对数据库实例禁用 IAM 数据库身份验证。您可以使用 AWS 管理控制台、AWS CLI 或 API 启用或禁用 IAM 数据库身份验证。
您可以在执行以下操作之一时启用 IAM 数据库身份验证：
+ 要创建启用 IAM 数据库身份验证的新数据库实例，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 要修改数据库实例以启用 IAM 数据库身份验证，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
+ 要从启用了 IAM 数据库身份验证的快照还原数据库实例，请参阅[还原到数据库实例](USER_RestoreFromSnapshot.md)。
+ 要将数据库实例还原到已启用 IAM 数据库身份验证的某个时间点，请参阅 [将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)。
## 控制台
每个创建或修改工作流程都有一个**数据库身份验证**部分，您可以在其中启用或禁用 IAM 数据库身份验证。在该部分中，选择**密码和 IAM 数据库身份验证**以启用 IAM 数据库身份验证。
**为现有数据库实例启用或禁用 IAM 数据库身份验证**
1. 通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择要修改的数据库实例。
**注意**
确保数据库实例与 IAM 身份验证兼容。在[区域和版本可用性](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability)中检查兼容性要求。
1. 选择**修改**。
1. 在**数据库身份验证**部分中，选择**密码和 IAM 数据库身份验证** ，启用 IAM 数据库身份验证。选择**密码身份验证**或**密码和 Kerberos 身份验证**以禁用 IAM 身份验证。
1. 也可以选择启用向 CloudWatch Logs 发布 IAM 数据库身份验证日志。在**日志导出**下，选择 **iam-db-auth-error log** 选项。将您的日志发布到 CloudWatch Logs 会消耗存储空间，并且您需要为该存储空间支付费用。请务必删除所有不再需要的 CloudWatch Logs。
1. 选择 **Continue (继续)**。
1. 要立即应用更改，请在**修改计划**部分中选择**立即**。
1. 选择**修改数据库实例** 。
## AWS CLI
要使用 AWS CLI 创建采用 IAM 身份验证的新数据库实例，请使用 [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) 命令。指定 `--enable-iam-database-authentication` 选项，如以下示例中所示。
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m3.medium \
--engine MySQL \
--allocated-storage 20 \
--master-username masterawsuser \
--manage-master-user-password \
--enable-iam-database-authentication
```
要更新现有的数据库实例以使用或不使用 IAM 身份验证，请使用 AWS CLI 命令 [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)。根据需要指定 `--enable-iam-database-authentication` 或 `--no-enable-iam-database-authentication` 选项。
**注意**
确保数据库实例与 IAM 身份验证兼容。在[区域和版本可用性](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability)中检查兼容性要求。
默认情况下，Amazon RDS 在下一个维护时段执行修改。如果您要覆盖该选项并尽快启用 IAM 数据库身份验证，请使用 `--apply-immediately` 参数。
以下示例说明了如何立即为现有数据库实例启用 IAM 身份验证。
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
如果您将还原数据库实例，请使用下列 AWS CLI 命令之一：
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
IAM 数据库身份验证设置默认为源快照的设置。要更改此设置，请根据需要设置 `--enable-iam-database-authentication` 或 `--no-enable-iam-database-authentication` 选项。
## RDS API
要使用 API 创建采用 IAM 身份验证的新数据库实例，请使用 API 操作 [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)。将 `EnableIAMDatabaseAuthentication` 参数设置为 `true`。
要更新现有的数据库实例以采用 IAM 身份验证，请使用 API 操作 [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)。将 `EnableIAMDatabaseAuthentication` 参数设置为 `true` 可启用 IAM 身份验证，将其设置为 `false` 可禁用 IAM 身份验证。
**注意**
确保数据库实例与 IAM 身份验证兼容。在[区域和版本可用性](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability)中检查兼容性要求。
如果您将还原数据库实例，请使用以下 API 操作之一：
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
IAM 数据库身份验证设置默认为源快照的设置。要更改此设置，请将 `EnableIAMDatabaseAuthentication` 参数设置为 `true` 以启用 IAM 身份验证，或将其设置为 `false` 以禁用 IAM 身份验证。
# 创建和使用适用于 IAM 数据库访问的 IAM 策略
要允许用户或角色连接到数据库实例，您必须创建 IAM policy。之后，将策略附加到权限集或角色。
**注意**
要了解有关 IAM 策略的更多信息，请参阅 [Amazon RDS 的 Identity and Access Management](UsingWithRDS.IAM.md)。
以下示例策略允许用户使用 IAM 数据库身份验证连接到数据库实例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**重要**
具有管理员权限的用户即使在 IAM policy 中没有显式权限，也可以访问数据库实例。如果您希望限制管理员访问数据库实例，您可以创建具有合适的较低权限的 IAM 角色，并将其分配给管理员。
**注意**
请不要将 `rds-db:` 前缀与以 `rds:` 开头的其他 RDS API 操作前缀混淆。仅在 IAM 数据库身份验证使用 `rds-db:` 前缀和 `rds-db:connect` 操作。它们在任何其他上下文中无效。
示例策略包含带以下元素的单个语句：
+ `Effect` – 指定 `Allow` 以授予数据库实例的访问权限。如果您没有显式允许访问，则默认情况下将拒绝访问。
+ `Action` – 指定 `rds-db:connect` 以允许连接到数据库实例。
+ `Resource` – 指定 Amazon Resource Name (ARN) 以描述一个数据库实例中的一个数据库账户。ARN 格式如下所示。
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
在此格式中，替换以下内容：
+ `region` 是数据库实例所在的 AWS 区域。在示例策略中，AWS 区域为 `us-east-2`。
+ `account-id` 是数据库实例的 AWS 账号。在示例策略中，账号为 `1234567890`。该用户必须位于与数据库实例的账户相同的账户中。
要执行跨账户存取，请在数据库实例的账户中使用上面显示的策略创建 IAM 角色，并允许其他账户代入该角色。
+ `DbiResourceId` 是数据库实例的标识符。此标识符对 AWS 区域是唯一的，并且绝不会更改。在示例策略中，标识符为 `db-ABCDEFGHIJKL01234`。
要在适用于 Amazon RDS 的 AWS 管理控制台中查找数据库实例资源 ID，请选择数据库实例来查看其详细信息。然后，选择**配置**选项卡。**Resource ID (资源 ID)** 将显示在 **Configuration (配置)** 部分中。
或者，您可以使用 AWS CLI 命令列出当前 AWS 区域中所有数据库实例的标识符和资源 ID，如下所示。
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
如果您使用的是 Amazon Aurora，请指定 `DbClusterResourceId` 而不是 `DbiResourceId`。有关更多信息，请参阅 *Amazon Aurora 用户指南*中的[创建和使用适用于 IAM 数据库访问的 IAM 策略](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html)。
**注意**
如果要通过 RDS 代理连接到数据库，请指定代理资源 ID，如 `prx-ABCDEFGHIJKL01234`。有关将 IAM 数据库身份验证与 RDS 代理结合使用的信息，请参阅 [使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
+ `db-user-name` 是与 IAM 身份验证关联的数据库账户的名称。在示例策略中，数据库账户为 `db_user`。
您可以构造其他 ARN 以支持多种访问模式。以下策略允许访问一个数据库实例中的两个不同的数据库账户。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
以下策略使用“\$1”字符匹配特定 AWS 账户和 AWS 区域的所有数据库实例和数据库账户。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
以下策略匹配特定 AWS 账户和 AWS 区域的所有数据库实例。不过，该策略仅允许访问具有 `jane_doe` 数据库账户的数据库实例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
用户或角色只能访问数据库用户有权访问的那些数据库。例如，假设数据库实例具有一个名为 *dev* 的数据库，以及另一个名为 *test* 的数据库。如果数据库用户 `jane_doe` 只能访问 *dev*，则与 `jane_doe` 用户一起访问数据库实例的任何用户或角色也只能访问 *dev*。此访问限制还适用于其他数据库对象 (如表、视图等)。
管理员必须创建 IAM policy，以便为实体授予权限，从而对其所需的指定资源执行特定的 API 操作。然后，管理员必须将这些策略附加到需要这些权限的权限集或角色。有关策略示例，请参阅“[Amazon RDS 的基于身份的策略示例](security_iam_id-based-policy-examples.md)”。
## 将 IAM policy 附加到权限集或角色
在创建允许数据库身份验证的 IAM policy 之后，您需要将该策略附加到权限集或角色。有关此主题的教程，请参阅 *IAM 用户指南* 中的[创建和附加您的第一个客户托管策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html)。
在演练此教程时，您可以使用此部分中显示的策略示例之一作为起点并根据您的需求进行定制。在教程结束时，您将有一个权限集，该权限集附加了一个可利用 `rds-db:connect` 操作的策略。
**注意**
您可以将多个权限集或角色映射到同一数据库用户账户。例如，假设您的 IAM 策略指定了以下资源 ARN。
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
如果将该策略附加到 *Jane*、*Bob* 和 *Diego*，则其中的每个用户都可以使用 `jane_doe` 数据库账户连接到指定的数据库实例。
# 使用 IAM 身份验证创建数据库账户
在使用 IAM 数据库身份验证时，您不需要为创建的用户账户分配数据库密码。如果删除映射到某个数据库账户的用户，则还应使用 `DROP USER` 语句删除该数据库账户。
**注意**
用于 IAM 身份验证的用户名必须与数据库中用户名的大小写相匹配。
**Topics**
+ [
## 对 MariaDB 和 MySQL 使用 IAM 身份验证
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## 对 PostgreSQL 使用 IAM 身份验证
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## 对 MariaDB 和 MySQL 使用 IAM 身份验证
对于 MariaDB 和 MySQL，身份验证由 `AWSAuthenticationPlugin` 处理，这是 AWS 提供的一个插件，可以与 IAM 无缝协作以验证您的用户的身份。以主用户或其他可以创建用户和授予权限的用户身份连接到数据库实例。连接后，发出 `CREATE USER` 语句，如以下示例中所示。
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
`IDENTIFIED WITH` 子句允许 MariaDB 和 MySQL 使用 `AWSAuthenticationPlugin` 对数据库账户 (`jane_doe`) 进行身份验证。`AS 'RDS'` 子句是指身份验证方法。确保指定的数据库用户名与 IAM 数据库访问策略中的资源相同。有关更多信息，请参阅“[创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)”。
**注意**
如果看到以下消息，则意味着 AWS 提供的插件对当前的数据库实例不可用。
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
要纠正该错误，请确认您使用支持的配置，并且在数据库实例上启用了 IAM 数据库身份验证。有关更多信息，请参阅“[区域和版本可用性](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability)”和“[启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)”。
在使用 `AWSAuthenticationPlugin` 创建一个账户后，可以像管理其他数据库账户一样管理此账户。例如，您可以使用 `GRANT` 语句和 `REVOKE` 语句修改账户权限，或使用 `ALTER USER` 语句修改各种账户属性。
使用 IAM 时，数据库网络流量使用 SSL/TLS 进行加密。要允许 SSL 连接，请使用以下命令修改用户账户。
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## 对 PostgreSQL 使用 IAM 身份验证
要在 PostgreSQL 中使用 IAM 身份验证，请以主用户或其他可以创建用户和授予权限的用户身份连接到数据库实例。连接后，创建数据库用户，然后向其授予 `rds_iam` 角色，如以下示例中所示。
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
确保指定的数据库用户名与 IAM 数据库访问策略中的资源相同。有关更多信息，请参阅 [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)。您必须授予 `rds_iam` 角色才能使用 IAM 身份验证。也可以使用该角色的嵌套成员资格或间接授权。
# 使用 IAM 身份验证连接到数据库实例
对于 IAM 数据库身份验证，您可以在连接到数据库实例时使用身份验证令牌。*身份验证令牌* 是您使用的一个字符串而不是密码。在生成身份验证令牌后，将在 15 分钟后失效。如果您尝试使用过期的令牌进行连接，则连接请求将被拒绝。
必须使用 AWS 签名版本 4 为每个身份验证令牌附带一个有效签名。（有关更多信息，请参阅《AWS 一般参考》**中的[签名版本 4 签名流程](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)。） AWS CLI 和 AWS 软件开发工具包（例如 适用于 Java 的 AWS SDK 或者 适用于 Python (Boto3) 的 AWS SDK）可以自动对您创建的每个令牌进行签名。
从其他AWS服务（如 AWS Lambda）连接到 Amazon RDS 时，您可以使用身份验证令牌。通过使用令牌，可以避免在代码中放置密码。或者，您可以使用 AWS 开发工具包以编程方式创建身份验证令牌并为其签名。
在获得签名的 IAM 身份验证令牌后，您可以连接到 Amazon RDS 数据库实例。在下文中，您可以了解如何使用命令行工具或 AWS 开发工具包（例如 适用于 Java 的 AWS SDK 或 适用于 Python (Boto3) 的 AWS SDK）执行该操作。
有关更多信息，请参阅以下博客文章：
+ [使用 IAM 身份验证通过 SQL Workbench/J 连接到 Aurora MySQL 或 Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [使用 IAM 身份验证通过 pgAdmin Amazon Aurora PostgreSQL 或 Amazon RDS for PostgreSQL 进行连接](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [
# 使用 IAM 身份验证和 AWS 驱动程序连接到数据库实例
](IAMDBAuth.Connecting.Drivers.md)
+ [
# 通过命令行 AWS CLI 和 mysql 客户端，使用 IAM 身份验证连接到数据库实例
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [
# 通过命令行使用 IAM 身份验证连接到数据库实例：AWS CLI 和 psql 客户端
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [
# 使用 IAM 身份验证和 适用于 .NET 的 AWS SDK 连接到数据库实例
](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [
# 使用 IAM 身份验证和 适用于 Go 的 AWS SDK 连接到数据库实例
](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [
# 使用 IAM 身份验证和 适用于 Java 的 AWS SDK 连接到数据库实例
](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [
# 使用 IAM 身份验证和 适用于 Python (Boto3) 的 AWS SDK 连接到数据库实例
](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# 使用 IAM 身份验证和 AWS 驱动程序连接到数据库实例
借助 AWS 驱动程序套件，可显著缩短切换和故障转移时间，并支持使用 AWS Secrets Manager、AWS Identity and Access Management（IAM）和联合身份进行身份验证。AWS 驱动程序依靠监控数据库实例状态以及了解实例拓扑，来确定新的写入器。这种方法将切换和故障转移时间缩短到几秒钟，而开源驱动程序的切换和故障转移时间则为几十秒。
有关 AWS 驱动程序的更多信息，请参阅 [RDS for MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver)、[RDS for MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) 或 [RDS for PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md) 数据库实例的相应语言驱动程序。
**注意**
RDS for MariaDB 支持的唯一功能是使用 AWS Secrets Manager、AWS Identity and Access Management（IAM）和联合身份进行身份验证。
# 通过命令行 AWS CLI 和 mysql 客户端，使用 IAM 身份验证连接到数据库实例
可以使用 AWS CLI 和 `mysql` 命令行工具从命令行连接到 Amazon RDS 数据库实例，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**注意**
有关使用具有 IAM 身份验证的 SQL WorkBench/J 连接到数据库的信息，请参阅博客文章[使用 IAM 身份验证通过 SQL WorkBench/J 连接到 Aurora MySQL 或 Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)。
**Topics**
+ [
## 生成 IAM 身份验证令牌
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [
## 连接到数据库实例
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## 生成 IAM 身份验证令牌
以下示例说明了如何使用 AWS CLI 获取签名的身份验证令牌。
```
aws rds generate-db-auth-token \
--hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-west-2 \
--username jane_doe
```
在该示例中，参数如下所示：
+ `--hostname` – 要访问的数据库实例的主机名
+ `--port` – 用于连接到数据库实例的端口号
+ `--region` – 在其中运行数据库实例的 AWS 区域
+ `--username` – 要访问的数据库账户
令牌的前几个字符与以下内容类似。
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
## 连接到数据库实例
通用连接格式如下所示。
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
参数如下所示：
+ `--host` – 要访问的数据库实例的主机名
+ `--port` – 用于连接到数据库实例的端口号
+ `--ssl-ca` – 包含公有密钥的 SSL 证书文件的完整路径
有关 MariaDB 的 SSL/TLS 支持的更多信息，请参阅 [Amazon RDS 上 MariaDB 数据库实例的 SSL/TLS 支持](MariaDB.Concepts.SSLSupport.md)。
有关 MySQL 的 SSL/TLS 支持的更多信息，请参阅 [Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)。
要下载 SSL 证书，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
+ `--enable-cleartext-plugin` – 一个指定 `AWSAuthenticationPlugin` 必须用于此连接的值
如果您使用 MariaDB 客户端，则无需 `--enable-cleartext-plugin` 选项。
+ `--user` – 要访问的数据库账户
+ `--password` – 已签名的 IAM 身份验证令牌
身份验证令牌包含几百个字符。很难使用命令行对其进行处理。该问题的解决方式是，将令牌保存到一个环境变量中，然后在连接时使用此变量。以下示例说明了一种执行此解决方法的方式。在该示例中，*/sample\$1dir/* 是包含公有密钥的 SSL 证书文件的完整路径。
```
RDSHOST="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"
mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```
在使用 `AWSAuthenticationPlugin` 进行连接时，将使用 SSL 保护连接。要进行验证，请在 `mysql>` 命令提示符处键入以下内容。
```
show status like 'Ssl%';
```
输出中的以下行显示了更多详细信息。
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 通过命令行使用 IAM 身份验证连接到数据库实例：AWS CLI 和 psql 客户端
可以使用 AWS CLI 和 psql 命令行工具从命令行连接到 Amazon RDS for PostgreSQL 数据库实例，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**注意**
有关使用具有 IAM 身份验证的 pgAdmin 连接到数据库的信息，请参阅博客文章[使用 IAM 身份验证通过 pgAdmin Amazon Aurora PostgreSQL 或 Amazon RDS for PostgreSQL 进行连接](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)。
**Topics**
+ [
## 生成 IAM 身份验证令牌
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [
## 连接到 Amazon RDS PostgreSQL 实例
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## 生成 IAM 身份验证令牌
身份验证令牌包含几百个字符，因此，很难使用命令行对其进行处理。该问题的解决方式是，将令牌保存到一个环境变量中，然后在连接时使用此变量。以下示例说明了如何使用 AWS CLI 通过 `generate-db-auth-token` 命令获取签名的身份验证令牌，并将其存储在 `PGPASSWORD` 环境变量中。
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```
在该示例中，`generate-db-auth-token` 命令的参数如下所示：
+ `--hostname` – 要访问的数据库实例（集群终端节点）的主机名。
+ `--port` – 用于连接到数据库实例的端口号
+ `--region` – 在其中运行数据库实例的 AWS 区域
+ `--username` – 要访问的数据库账户
生成的令牌的前几个字符与以下内容类似。
```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
## 连接到 Amazon RDS PostgreSQL 实例
使用 psql 进行连接的一般格式如下所示。
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
参数如下所示：
+ `host` – 要访问的数据库实例（集群终端节点）的主机名。
+ `port` – 用于连接到数据库实例的端口号
+ `sslmode` – 要使用的 SSL 模式
当您使用 `sslmode=verify-full` 时，SSL 连接将针对 SSL 证书中的终端节点验证数据库实例终端节点。
+ `sslrootcert` – 包含公有密钥的 SSL 证书文件的完整路径
有关更多信息，请参阅 [将 SSL 与 PostgreSQL 数据库实例结合使用](PostgreSQL.Concepts.General.SSL.md)。
要下载 SSL 证书，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
+ `dbname` – 要访问的数据库
+ `user` – 要访问的数据库账户
+ `password` – 已签名的 IAM 身份验证令牌
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
以下示例演示了使用 psql 进行连接。在该示例中，psql 将环境变量 `RDSHOST` 用于主机，将环境变量 `PGPASSWORD` 用于生产的令牌。*/sample\$1dir/* 则是包含公有密钥的 SSL 证书文件的完整路径。
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身份验证和 适用于 .NET 的 AWS SDK 连接到数据库实例
您可以使用 适用于 .NET 的 AWS SDK 连接到 RRDS for MariaDB、MySQL 或 PostgreSQL 数据库实例 ，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**示例**
以下代码示例演示如何生成身份验证令牌，然后使用该令牌连接到数据库实例。
要运行该代码示例，您需要使用 适用于 .NET 的 AWS SDK 网站上提供的 [AWS](https://aws.amazon.com/sdk-for-net/)。`AWSSDK.CORE` 和 `AWSSDK.RDS` 程序包是必需的。要连接到数据库实例，请使用用于数据库引擎的 .NET 数据库连接器，例如 MySqlConnector for MariaDB 或 MySQL，或 Npgsql for PostgreSQL。
此代码连接到 MariaDB 或 MySQL 数据库实例。根据需要修改以下变量的值：
+ `server` – 要访问的数据库实例的终端节点。
+ `user` – 要访问的数据库账户
+ `database` – 要访问的数据库
+ `port` – 用于连接到数据库实例的端口号
+ `SslMode` – 要使用的 SSL 模式
当您使用 `SslMode=Required` 时，SSL 连接将针对 SSL 证书中的终端节点验证数据库实例终端节点。
+ `SslCa` – Amazon RDS 的 SSL 证书的完整路径
要下载证书，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;
namespace ubuntu
{
class Program
{
static void Main(string[] args)
{
var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqldb.123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
MySqlConnection conn = new MySqlConnection($"server=mysqldb.123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
conn.Open();
// Define a query
MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);
// Execute a query
MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();
// Read all rows and output the first column in each row
while (mysqlDataRdr.Read())
Console.WriteLine(mysqlDataRdr[0]);
mysqlDataRdr.Close();
// Close connection
conn.Close();
}
}
}
```
此代码连接到 PostgreSQL 数据库实例。
根据需要修改以下变量的值：
+ `Server` – 要访问的数据库实例的终端节点。
+ `User ID` – 要访问的数据库账户
+ `Database` – 要访问的数据库
+ `Port` – 用于连接到数据库实例的端口号
+ `SSL Mode` – 要使用的 SSL 模式
当您使用 `SSL Mode=Required` 时，SSL 连接将针对 SSL 证书中的终端节点验证数据库实例终端节点。
+ `Root Certificate` – Amazon RDS 的 SSL 证书的完整路径
要下载证书，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
```
using System;
using Npgsql;
using Amazon.RDS.Util;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmydb.123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmydb.123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
conn.Open();
// Define a query
NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);
// Execute a query
NpgsqlDataReader dr = cmd.ExecuteReader();
// Read all rows and output the first column in each row
while (dr.Read())
Console.Write("{0}\n", dr[0]);
// Close connection
conn.Close();
}
}
}
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身份验证和 适用于 Go 的 AWS SDK 连接到数据库实例
您可以使用 适用于 Go 的 AWS SDK 连接到 RRDS for MariaDB、MySQL 或 PostgreSQL 数据库实例 ，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**示例**
要运行上述代码示例，您需要使用 适用于 Go 的 AWS SDK 网站上提供的 [AWS](https://aws.amazon.com/sdk-for-go/)。
根据需要修改以下变量的值：
+ `dbName` – 要访问的数据库
+ `dbUser` – 要访问的数据库账户
+ `dbHost` – 要访问的数据库实例的终端节点。
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
+ `dbPort` – 用于连接到数据库实例的端口号
+ `region` – 在其中运行数据库实例的 AWS 区域
此外，请确保示例代码中的导入库存在于您的系统中。
**重要**
本节中的示例使用以下代码提供从本地环境访问数据库的凭证：
`creds := credentials.NewEnvCredentials()`
如果要从AWS服务（如 Amazon EC2 或 Amazon ECS）访问数据库，则可以用以下代码替换：
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
如果您进行此更改，请确保添加以下导入：
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [
## 使用 IAM 身份验证和 适用于 Go 的 AWS SDK V2 进行连接
](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [
## 使用 IAM 身份验证和 适用于 Go 的 AWS SDK V1 进行连接
](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## 使用 IAM 身份验证和 适用于 Go 的 AWS SDK V2 进行连接
您可以使用 IAM 身份验证和 适用于 Go 的 AWS SDK V2 连接到数据库实例
以下代码示例演示如何生成身份验证令牌，然后使用该令牌连接到数据库实例。
此代码连接到 MariaDB 或 MySQL 数据库实例。
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 3306
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
此代码连接到 PostgreSQL 数据库实例。
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/lib/pq"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 5432
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authenticationToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
## 使用 IAM 身份验证和 适用于 Go 的 AWS SDK V1 进行连接
使用 IAM 身份验证和 适用于 Go 的 AWS SDK V1 连接到数据库实例
以下代码示例演示如何生成身份验证令牌，然后使用该令牌连接到数据库实例。
此代码连接到 MariaDB 或 MySQL 数据库实例。
```
package main
import (
"database/sql"
"fmt"
"log"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/go-sql-driver/mysql"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 3306
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
此代码连接到 PostgreSQL 数据库实例。
```
package main
import (
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/lib/pq"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 5432
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身份验证和 适用于 Java 的 AWS SDK 连接到数据库实例
您可以使用 适用于 Java 的 AWS SDK 连接到 RRDS for MariaDB、MySQL 或 PostgreSQL 数据库实例 ，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [设置适用于 Java 的AWS开发工具包](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
有关如何使用 SDK for Java 2.x 的示例，请参阅 [Amazon RDS examples using SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html)。也可以使用 AWS 高级 JDBC 包装器，请参阅 [AWS Advanced JDBC Wrapper documentation](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md)。
**Topics**
+ [
## 生成 IAM 身份验证令牌
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [
## 手动构造 IAM 身份验证令牌
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [
## 连接到数据库实例
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## 生成 IAM 身份验证令牌
如果您使用适用于 Java 的 AWS SDK编写程序，则可使用 `RdsIamAuthTokenGenerator` 类获取已签名的身份验证令牌。使用此类需要提供 AWS 凭证。为此，创建 `DefaultAWSCredentialsProviderChain` 类的实例。`DefaultAWSCredentialsProviderChain` 使用它在[默认凭证提供程序链](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)中找到的第一个 AWS 访问密钥和私有密钥。有关 AWS 访问密钥的更多信息，请参阅[管理用户的访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
在创建一个 `RdsIamAuthTokenGenerator` 实例后，您可调用 `getAuthToken` 方法以获取已签名的令牌。提供 AWS 区域、主机名、端口号和用户名。以下代码示例说明了如何执行该操作。
```
package com.amazonaws.codesamples;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
public class GenerateRDSAuthToken {
public static void main(String[] args) {
String region = "us-west-2";
String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
System.out.println(generateAuthToken(region, hostname, port, username));
}
static String generateAuthToken(String region, String hostName, String port, String username) {
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new DefaultAWSCredentialsProviderChain())
.region(region)
.build();
String authToken = generator.getAuthToken(
GetIamAuthTokenRequest.builder()
.hostname(hostName)
.port(Integer.parseInt(port))
.userName(username)
.build());
return authToken;
}
}
```
## 手动构造 IAM 身份验证令牌
在 Java 中，生成身份验证令牌的最简单方式是使用 `RdsIamAuthTokenGenerator`。此类将为您创建一个身份验证令牌，然后使用 AWS 签名版本 4 为该令牌签名。有关更多信息，请参阅《AWS 一般参考》**中的[签名版本 4 签名流程](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)。
不过，您也可以手动构造身份验证令牌并为之签名，如以下代码示例中所示。
```
package com.amazonaws.codesamples;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;
import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;
public class CreateRDSAuthTokenManually {
public static String httpMethod = "GET";
public static String action = "connect";
public static String canonicalURIParameter = "/";
public static SortedMap canonicalQueryParameters = new TreeMap();
public static String payload = StringUtils.EMPTY;
public static String signedHeader = "host";
public static String algorithm = "AWS4-HMAC-SHA256";
public static String serviceName = "rds-db";
public static String requestWithoutSignature;
public static void main(String[] args) throws Exception {
String region = "us-west-2";
String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
Date now = new Date();
String date = new SimpleDateFormat("yyyyMMdd").format(now);
String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
String awsSecretKey = creds.getCredentials().getAWSSecretKey();
String expiryMinutes = "900";
System.out.println("Step 1: Create a canonical request:");
String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
System.out.println(canonicalString);
System.out.println();
System.out.println("Step 2: Create a string to sign:");
String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
System.out.println(stringToSign);
System.out.println();
System.out.println("Step 3: Calculate the signature:");
String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
System.out.println(signature);
System.out.println();
System.out.println("Step 4: Add the signing info to the request");
System.out.println(appendSignature(signature));
System.out.println();
}
//Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
canonicalQueryParameters.put("Action", action);
canonicalQueryParameters.put("DBUser", user);
canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
canonicalQueryParameters.put("X-Amz-Date", dateTime);
canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
String canonicalQueryString = "";
while(!canonicalQueryParameters.isEmpty()) {
String currentQueryParameter = canonicalQueryParameters.firstKey();
String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
canonicalQueryString += "&";
}
}
String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;
String hashedPayload = BinaryUtils.toHex(hash(payload));
return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;
}
//Step 2: Create a string to sign using sig v4
public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));
}
//Step 3: Calculate signature
/**
* Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
* the signing key and computing the signature. Refer to
* http://docs.aws.amazon
* .com/general/latest/gr/sigv4-calculate-signature.html
*/
public static byte[] calculateSignature(String stringToSign,
byte[] signingKey) {
return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(byte[] data, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
Mac mac = algorithm.getMac();
mac.init(new SecretKeySpec(key, algorithm.toString()));
return mac.doFinal(data);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
public static byte[] newSigningKey(String secretKey,
String dateStamp, String regionName, String serviceName) {
byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
byte[] kService = sign(serviceName, kRegion,
SigningAlgorithm.HmacSHA256);
return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(String stringData, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
byte[] data = stringData.getBytes(UTF8);
return sign(data, key, algorithm);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
//Step 4: append the signature
public static String appendSignature(String signature) {
return requestWithoutSignature + "&X-Amz-Signature=" + signature;
}
public static byte[] hash(String s) throws Exception {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(s.getBytes(UTF8));
return md.digest();
} catch (Exception e) {
throw new SdkClientException(
"Unable to compute hash while signing request: "
+ e.getMessage(), e);
}
}
}
```
## 连接到数据库实例
以下代码示例演示如何生成一个身份验证令牌，然后使用该令牌连接到运行 MariaDB 或 MySQL 的实例。
要运行该代码示例，您需要使用 适用于 Java 的 AWS SDK 网站上提供的 [AWS](https://aws.amazon.com/sdk-for-java/)。此外，您需要：
+ MySQL Connector/J。此代码示例已使用 `mysql-connector-java-5.1.33-bin.jar` 进行测试。
+ 特定于AWS区域的 Amazon RDS 的中间证书。（有关更多信息，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。） 在运行时，类加载程序会在与此 Java 代码示例相同的目录中查找证书以便可以找到它。
+ 根据需要修改以下变量的值：
+ `RDS_INSTANCE_HOSTNAME` – 要访问的数据库实例的主机名。
+ `RDS_INSTANCE_PORT` – 用于连接到 PostgreSQL 数据库实例的端口号。
+ `REGION_NAME` – 在其中运行数据库实例的AWS区域。
+ `DB_USER` – 要访问的数据库账户
+ `SSL_CERTIFICATE` – 特定于AWS区域的 Amazon RDS 的中间证书。
要为AWS区域下载证书，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。将 SSL 证书放置在此 Java 程序文件所在的同一目录中，以便类加载程序可在运行时找到此证书。
此代码示例将从[默认凭证提供程序链](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)获取 AWS 凭证。
**注意**
作为安全最佳实践，请为 `DEFAULT_KEY_STORE_PASSWORD` 指定除此处所示提示以外的密码。
```
package com.amazonaws.samples;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.net.URL;
public class IAMDatabaseAuthenticationTester {
//&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();
//Configuration parameters for the generation of the IAM Database Authentication token
private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
private static final int RDS_INSTANCE_PORT = 3306;
private static final String REGION_NAME = "us-west-2";
private static final String DB_USER = "jane_doe";
private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;
private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";
private static final String KEY_STORE_TYPE = "JKS";
private static final String KEY_STORE_PROVIDER = "SUN";
private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
private static final String KEY_STORE_FILE_SUFFIX = ".jks";
private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";
public static void main(String[] args) throws Exception {
//get the connection
Connection connection = getDBConnectionUsingIam();
//verify the connection is successful
Statement stmt= connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
while (rs.next()) {
String id = rs.getString(1);
System.out.println(id); //Should print "Success!"
}
//close the connection
stmt.close();
connection.close();
clearSslProperties();
}
/**
* This method returns a connection to the db instance authenticated using IAM Database Authentication
* @return
* @throws Exception
*/
private static Connection getDBConnectionUsingIam() throws Exception {
setSslProperties();
return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
}
/**
* This method sets the mysql connection properties which includes the IAM Database Authentication token
* as the password. It also specifies that SSL verification is required.
* @return
*/
private static Properties setMySqlConnectionProperties() {
Properties mysqlConnectionProperties = new Properties();
mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
mysqlConnectionProperties.setProperty("useSSL", "true");
mysqlConnectionProperties.setProperty("user",DB_USER);
mysqlConnectionProperties.setProperty("password",generateAuthToken());
return mysqlConnectionProperties;
}
/**
* This method generates the IAM Auth Token.
* An example IAM Auth Token would look like follows:
* btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
* @return
*/
private static String generateAuthToken() {
BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
return generator.getAuthToken(GetIamAuthTokenRequest.builder()
.hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
}
/**
* This method sets the SSL properties which specify the key store file, its type and password:
* @throws Exception
*/
private static void setSslProperties() throws Exception {
System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
}
/**
* This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
* the db instance.
* @return
* @throws Exception
*/
private static String createKeyStoreFile() throws Exception {
return createKeyStoreFile(createCertificate()).getPath();
}
/**
* This method generates the SSL certificate
* @return
* @throws Exception
*/
private static X509Certificate createCertificate() throws Exception {
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
URL url = new File(SSL_CERTIFICATE).toURI().toURL();
if (url == null) {
throw new Exception();
}
try (InputStream certInputStream = url.openStream()) {
return (X509Certificate) certFactory.generateCertificate(certInputStream);
}
}
/**
* This method creates the Key Store File
* @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
* @return
* @throws Exception
*/
private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
ks.load(null);
ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
}
return keyStoreFile;
}
/**
* This method clears the SSL properties.
* @throws Exception
*/
private static void clearSslProperties() throws Exception {
System.clearProperty("javax.net.ssl.trustStore");
System.clearProperty("javax.net.ssl.trustStoreType");
System.clearProperty("javax.net.ssl.trustStorePassword");
}
}
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身份验证和 适用于 Python (Boto3) 的 AWS SDK 连接到数据库实例
您可以使用 适用于 Python (Boto3) 的 AWS SDK 连接到 RRDS for MariaDB、MySQL 或 PostgreSQL 数据库实例 ，如下所述。
**先决条件**
以下是使用 IAM 身份验证连接到数据库实例的先决条件：
+ [启用和禁用 IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [创建和使用适用于 IAM 数据库访问的 IAM 策略](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身份验证创建数据库账户](UsingWithRDS.IAMDBAuth.DBAccounts.md)
此外，请确保示例代码中的导入库存在于您的系统中。
**示例**
该代码示例将配置文件用于共享凭证。有关指定凭证的信息，请参阅 适用于 Python (Boto3) 的 AWS SDK 文档中的[凭证](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)。
以下代码示例演示如何生成身份验证令牌，然后使用该令牌连接到数据库实例。
要运行该代码示例，您需要使用 适用于 Python (Boto3) 的 AWS SDK 网站上提供的 [AWS](https://aws.amazon.com/sdk-for-python/)。
根据需要修改以下变量的值：
+ `ENDPOINT` – 要访问的数据库实例的终端节点。
+ `PORT` – 用于连接到数据库实例的端口号
+ `USER` – 要访问的数据库账户
+ `REGION` – 在其中运行数据库实例的 AWS 区域
+ `DBNAME` – 要访问的数据库
+ `SSLCERTIFICATE` – Amazon RDS 的 SSL 证书的完整路径
对于 `ssl_ca`，请指定 SSL 证书。要下载 SSL 证书，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
**注意**
不能使用自定义 Route 53 DNS 记录代替数据库实例端点来生成身份验证令牌。
此代码连接到 MariaDB 或 MySQL 数据库实例。
在运行此代码之前，请按照 [Python 包索引](https://pypi.org/project/PyMySQL/)中的说明安装 PyMySQL 驱动程序。
```
import pymysql
import sys
import boto3
import os
ENDPOINT="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
此代码连接到 PostgreSQL 数据库实例。
在运行此代码之前，请按照 [Psycopg 文档](https://pypi.org/project/psycopg2/)中的说明安装 `psycopg2`。
```
import psycopg2
import sys
import boto3
import os
ENDPOINT="postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
如果您想通过代理连接到数据库实例，请参阅[使用 IAM 身份验证连接到数据库](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# IAM 数据库身份验证故障排除
下面，您可以找到一些常见 IAM 数据库身份验证问题的故障排除思路，以及有关 IAM 数据库身份验证的 CloudWatch 日志和指标的信息。
## 将 IAM 数据库身份验证错误日志导出到 CloudWatch Logs
IAM 数据库身份验证错误日志存储在数据库主机上，您可以将这些日志导出到您的 CloudWatch Logs 账户。使用本页中的日志和补救方法来解决 IAM 数据库身份验证问题。
可以通过控制台、AWS CLI 和 RDS API 启用向 CloudWatch Logs 导出日志。有关控制台说明，请参阅 [将数据库日志发布到 Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md)。
要在从 AWS CLI 中创建数据库实例时将 IAM 数据库身份验证错误日志导出到 CloudWatch Logs，请使用以下命令：
```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
要在从 AWS CLI 中修改数据库实例时将 IAM 数据库身份验证错误日志导出到 CloudWatch Logs，请使用以下命令：
```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
要验证数据库实例是否正在将 IAM 数据库身份验证日志导出到 CloudWatch Logs，请检查 `describe-db-instances` 命令输出中的 `EnabledCloudwatchLogsExports` 参数是否设置为 `iam-db-auth-error`。
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## IAM 数据库身份验证 CloudWatch 指标
Amazon RDS 向您的 Amazon CloudWatch 账户提供有关 IAM 数据库身份验证的近乎实时的指标。下表列出了使用 CloudWatch 时可用的 IAM 数据库身份验证指标：
| 指标 | 描述 |
| --- | --- |
| `IamDbAuthConnectionRequests` | 使用 IAM 数据库身份验证发出的连接请求总数。 |
| `IamDbAuthConnectionSuccess` | 成功的 IAM 数据库身份验证请求总数。 |
| `IamDbAuthConnectionFailure` | 失败的 IAM 数据库身份验证请求总数。 |
| `IamDbAuthConnectionFailureInvalidToken` | 由于令牌无效而失败的 IAM 数据库身份验证请求总数。 |
| `IamDbAuthConnectionFailureInsufficientPermissions` | 由于策略或权限不正确而失败的 IAM 数据库身份验证请求总数。 |
| `IamDbAuthConnectionFailureThrottling` | 由于 IAM 数据库身份验证节流而失败的 IAM 数据库身份验证请求总数。 |
| `IamDbAuthConnectionFailureServerError` | 由于 IAM 数据库身份验证功能中的内部服务器错误而失败的 IAM 数据库身份验证请求总数。 |
## 常见问题和解决方案
使用 IAM 数据库身份验证时可能会遇到以下问题。使用表中的修复步骤来解决问题：
| 错误 | 指标 | 原因 | 解决方案 |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | 连接请求中的 IAM 数据库身份验证令牌要么不是有效的 SigV4a 令牌，要么格式不正确。 | 在应用程序中检查令牌生成策略。在某些情况下，请确保使用有效的格式传递令牌。截断令牌（或字符串格式不正确）将使令牌失效。 |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | IAM 数据库身份验证令牌已到期。令牌仅在 15 分钟内有效。 | 检查应用程序中的令牌缓存和/或令牌重用逻辑。您不应重用超过 15 分钟的令牌。 |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | 该错误可能是由于以下原因引起的： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | 验证您在应用程序中采用的 IAM 角色和/或策略。请务必采用与连接到数据库相同的策略来生成令牌。 |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | 您在短时间内向数据库发出的连接请求过多。IAM 数据库身份验证节流限制为每秒 200 个连接。 | 降低使用 IAM 身份验证建立新连接的速率。考虑使用 RDS 代理来实现连接池，以便在应用程序中重用已建立的连接。 |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | 使用 IAM 数据库身份验证授权数据库连接时出现内部错误。 | 请联系 https://aws.amazon.com/premiumsupport/ 以便调查此问题。 |
# 对 Amazon RDS 身份和访问权限问题进行故障排除
使用以下信息可帮助您诊断和修复在使用 Amazon RDS 和 IAM 时可能遇到的常见问题。
**Topics**
+ [
## 我无权在 Amazon RDS 中执行操作
](#security_iam_troubleshoot-no-permissions)
+ [
## 未授权我执行 iam:PassRole
](#security_iam_troubleshoot-passrole)
+ [
## 我希望允许我 AWS 账户以外的人访问我的 Amazon RDS 资源
](#security_iam_troubleshoot-cross-account-access)
## 我无权在 Amazon RDS 中执行操作
如果 AWS 管理控制台 告诉您，您无权执行某个操作，则必须联系您的管理员寻求帮助。管理员是向您提供登录凭证的人。
当 `mateojackson` 用户尝试使用控制台查看有关 *widget* 的详细信息但不具有 `rds:GetWidget` 权限时，会发生以下示例错误。
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: rds:GetWidget on resource: my-example-widget
```
在这种情况下，Mateo 请求他的管理员更新其策略，以允许他使用 `rds:GetWidget` 操作访问 `my-example-widget` 资源。
## 未授权我执行 iam:PassRole
如果您收到错误消息，提示您无权执行 `iam:PassRole` 操作，则必须联系您的管理员寻求帮助。管理员是向您提供登录凭证的人。请求该人员更新您的策略，以便允许您将角色传递给 Amazon RDS。
有些 AWS 服务允许您将现有角色传递到该服务，而不是创建新服务角色或服务相关角色。为此，您必须具有将角色传递到服务的权限。
当名为 `marymajor` 的用户尝试使用控制台在 Amazon RDS 中执行操作时，会发生以下示例错误。但是，服务必须具有服务角色所授予的权限才可执行操作。Mary 不具有将角色传递到服务的权限。
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
在这种情况下，Mary 请求她的管理员来更新其策略，以允许她执行 `iam:PassRole` 操作。
## 我希望允许我 AWS 账户以外的人访问我的 Amazon RDS 资源
您可以创建一个角色，以便其他账户中的用户或您组织外的人员可以使用该角色来访问您的资源。您可以指定谁值得信赖，可以代入角色。对于支持基于资源的策略或访问控制列表（ACL）的服务，您可以使用这些策略向人员授予对您的资源的访问权。
要了解更多信息，请参阅以下内容：
+ 要了解 Amazon RDS 是否支持这些功能，请参阅[Amazon RDS 如何与 IAM 协同工作](security_iam_service-with-iam.md)。
+ 要了解如何为您拥有的 AWS 账户中的资源提供访问权限，请参阅*IAM 用户指南中的[为您拥有的另一个 AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) 账户中的 IAM 用户提供访问权限*。
+ 要了解如何为第三方 AWS 账户提供您的资源的访问权限，请参阅*IAM 用户指南中的 [ 为第三方拥有的 AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) 账户提供访问权限*。
+ 要了解如何通过联合身份验证提供访问权限，请参阅 *IAM 用户指南*中的[为经过外部身份验证的用户（联合身份验证）提供访问权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html)。
+ 要了解使用角色和基于资源的策略进行跨账户访问之间的差别，请参阅《IAM 用户指南》**中的 [IAM 角色与基于资源的策略有何不同](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html)。
# Amazon RDS 中的日志记录和监控
对于保持 Amazon RDS 和您的 AWS 解决方案的可靠性、可用性和性能，监控发挥着非常重要的作用。您应该从 AWS 解决方案的各个部分收集监控数据，以便更轻松地调试多点故障（如果发生）。AWS 提供了多种工具来监控您的 Amazon RDS 资源并对潜在事件做出响应：
**Amazon CloudWatch 警报**
使用 Amazon CloudWatch 警报，您可以在指定时间段内监控某个指标。如果指标超过给定阈值，则会向 Amazon SNS 主题或 AWS Auto Scaling 策略发送通知。CloudWatch 警报将不会调用操作，因为这些操作处于特定状态。而是必须在状态已改变并在指定的若干个时间段内保持不变后才调用。
**AWS CloudTrail 日志**
CloudTrail 提供了用户、角色或 AWS 服务在 Amazon RDS 中所执行操作的记录。CloudTrail 将对 Amazon RDS 的所有 API 调用作为事件捕获，包括来自控制台的调用和代码对 Amazon RDS API 操作的调用。通过使用 CloudTrail 收集的信息，您可以确定向 Amazon RDS 发出了什么请求、发出请求的 IP 地址、何人发出的请求、请求的发出时间以及其他详细信息。有关更多信息，请参阅 [监控 AWS CloudTrail 中的 Amazon RDS API 调用](logging-using-cloudtrail.md)。
**增强监控**
Amazon RDS 针对运行数据库实例的操作系统（OS），实时提供操作系统的指标。您可以使用控制台查看数据库实例的指标，或者在您选择的监控系统中使用 Amazon CloudWatch Logs 的增强监控 JSON 输出。有关更多信息，请参阅 [使用增强监控来监控操作系统指标](USER_Monitoring.OS.md)。
**Amazon RDS Performance Insights**
Performance Insights 在现有 Amazon RDS 监控功能的基础上进行了扩展，以便说明您的数据库的性能并帮助您分析影响性能的任何问题。利用 Performance Insights 控制面板，您可以可视化数据库负载并按等待状态、SQL 语句、主机或用户来筛选负载。有关更多信息，请参阅 [在 Amazon RDS 上使用性能详情监控数据库负载](USER_PerfInsights.md)。
**数据库日志**
您可以使用 AWS 管理控制台、AWS CLI 或 RDS API 查看、下载和监控数据库日志。有关更多信息，请参阅 [监控 Amazon RDS 日志文件](USER_LogAccess.md)。
** Amazon RDS 建议**
Amazon RDS 可自动提供数据库资源建议。这些建议通过分析数据库实例配置、使用情况和性能数据来提供最佳实践准则。有关更多信息，请参阅 [来自 Amazon RDS 的建议](monitoring-recommendations.md)。
** Amazon RDS 事件通知**
Amazon RDS 使用 Amazon Simple Notification Service（Amazon SNS）在发生 Amazon RDS 事件时提供通知。这些通知可以采用AWS区域 Amazon SNS 支持的任何通知形式，例如电子邮件、文本消息或对 HTTP 终端节点的调用。有关更多信息，请参阅 [使用 Amazon RDS 事件通知](USER_Events.md)。
**AWS Trusted Advisor**
Trusted Advisor 凝聚了从为数十万 AWS 客户提供服务中总结的最佳实践。Trusted Advisor 可检查您的 AWS 环境，然后在有可能节省开支、提高系统可用性和性能或弥补安全漏洞时为您提供建议。所有 AWS 客户均有权访问五个 Trusted Advisor 检查。使用“商业”和“企业”支持计划的客户可以查看所有 Trusted Advisor 检查。
Trusted Advisor 提供与 Amazon RDS 相关的下列检查：
+ Amazon RDS 闲置数据库实例
+ Amazon RDS 安全组访问风险
+ Amazon RDS 备份
+ Amazon RDS 多可用区
有关这些检查的更多信息，请参阅 [Trusted Advisor 最佳实践（检查）](https://aws.amazon.com/premiumsupport/trustedadvisor/best-practices/)。
有关监控 Amazon RDS 的更多信息，请参阅[监控 Amazon RDS 实例中的指标](CHAP_Monitoring.md)。
# Amazon RDS 的合规性验证
作为多个AWS合规性计划的一部分，第三方审计员将评估 Amazon RDS 的安全性和合规性。其中包括 SOC、PCI、FedRAMP、HIPAA 及其他。
有关特定合规性计划范围内的 AWS 服务的列表，请参阅[合规性计划范围内的 AWS 服务](https://aws.amazon.com/compliance/services-in-scope/)。有关一般信息，请参阅 [AWS 合规性计划](https://aws.amazon.com/compliance/programs/)。
您可以使用 AWS Artifact 下载第三方审计报告。有关更多信息，请参阅[在 AWS Artifact 中下载报告](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html)。
您在使用 Amazon RDS 时的合规性责任由您的数据的敏感性、您组织的合规性目标以及适用的法律法规决定。AWS提供以下资源以帮助满足合规性要求：
+ [安全性与合规性快速入门指南](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) – 这些部署指南讨论了架构注意事项，并提供了在AWS上部署基于安全性和合规性的基准环境的步骤。
+ [Amazon Web Services 上的 HIPAA 安全性和合规性架构设计](https://docs.aws.amazon.com/pdfs/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/architecting-hipaa-security-and-compliance-on-aws.pdf) – 此白皮书介绍了公司如何使用 AWS 创建符合 HIPAA 标准的应用程序。
+ [AWS 合规性资源](https://aws.amazon.com/compliance/resources/) – 可能适用于您的行业和位置的业务手册和指南集合。
+ [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html) – 此AWS服务评估您的资源配置对内部实践、行业指南和法规的遵循情况。
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)：此 AWS 服务 向您提供 AWS 中安全状态的全面视图。Security Hub CSPM 通过安全控制措施评估您的 AWS 资源，并检查是否符合安全行业标准和最佳实践。有关受支持服务及控制措施的列表，请参阅 [Security Hub CSPM 控制措施参考](https://docs.aws.amazon.com/securityhub/latest/userguide/securityhub-controls-reference.html)。
# Amazon RDS 中的弹性
AWS全球基础设施围绕AWS区域和可用区构建。AWS区域提供多个在物理上独立且隔离的可用区，这些可用区通过延迟低、吞吐量高且冗余性高的网络连接在一起。利用可用区，您可以设计和操作在可用区之间无中断地自动实现故障转移的应用程序和数据库。与传统的单个或多个数据中心基础架构相比，可用区具有更高的可用性、容错性和可扩展性。
有关 AWS 区域和可用区的更多信息，请参阅 [AWS 全球基础设施](https://aws.amazon.com/about-aws/global-infrastructure/)。
除了AWS全球基础设施之外，Amazon RDS 还提供了相应功能来帮助支持您的数据弹性和备份需求。
## 备份与还原
Amazon RDS 创建并保存数据库实例的自动备份。Amazon RDS 创建数据库实例的存储卷快照，并备份整个数据库实例而不仅仅是单个数据库。
在数据库实例的备份时段中，Amazon RDS 创建数据库实例的自动备份。Amazon RDS 根据您指定的备份保留期保存数据库实例的自动备份。如果需要，您可以将数据库恢复到备份保留期中的任意时间点。您还可以通过手动创建数据库快照来手动备份数据库实例。
如果源数据库实例失败，则可以通过从该数据库快照还原为灾难恢复解决方案来创建数据库实例。
有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
## 复制
Amazon RDS 使用 MariaDB、MySQL、Oracle 和 PostgreSQL 数据库引擎的内置复制功能，从源数据库实例创建一个特殊类型的数据库实例，称为只读副本。对源数据库实例的更新将异步复制到只读副本。您可以将应用程序发出的读取查询路由到只读副本，以减轻源数据库实例上的负载。利用只读副本，可以实现弹性扩展并超越单个数据库实例的容量限制，以处理高读取量的数据库工作负载。如果源数据库实例出现故障，则将只读副本提升为独立的实例作为灾难恢复解决方案。对于一些数据库引擎，Amazon RDS 还支持其他复制选项。
有关更多信息，请参阅“[使用数据库实例只读副本](USER_ReadRepl.md)”。
## 故障转移
Amazon RDS 使用多可用区部署为数据库实例提供高可用性和故障转移支持。Amazon RDS 使用几种不同的技术来提供故障转移支持。用于 Oracle、PostgreSQL、MySQL 和 MariaDB 数据库实例的多可用区部署使用 Amazon 的故障转移技术。SQL Server 数据库实例使用 SQL Server 数据库镜像 (DBM)。
有关更多信息，请参阅“[配置和管理 Amazon RDS 的多可用区部署](Concepts.MultiAZ.md)”。
# Amazon RDS 中的基础设施安全性
作为一项托管式服务，Amazon Relational Database Service 受 AWS 全球网络安全保护。有关 AWS 安全服务以及 AWS 如何保护基础设施的信息，请参阅 [AWS 云安全性](https://aws.amazon.com/security/)。要按照基础设施安全最佳实践设计您的 AWS 环境，请参阅《安全性支柱 AWS Well‐Architected Framework》**中的[基础设施保护](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html)。
您可以使用 AWS 发布的 API 调用通过网络访问 Amazon RDS。客户端必须支持以下内容：
+ 传输层安全性协议（TLS）。我们要求使用 TLS 1.2，建议使用 TLS 1.3。
+ 具有完全向前保密（PFS）的密码套件，例如 DHE（临时 Diffie-Hellman）或 ECDHE（临时椭圆曲线 Diffie-Hellman）。大多数现代系统（如 Java 7 及更高版本）都支持这些模式。
此外，Amazon RDS 提供了相应功能来帮助支持基础设施安全性。
## 安全组
安全组控制着流量在数据库实例内外拥有的访问权限。原定设置情况下，将对您的数据库实例关闭网络访问。您可以在安全组中指定规则，允许从 IP 地址范围、端口或安全组进行访问。配置传入规则后，会向与该安全组关联的所有数据库实例应用相同的规则。
有关更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
## 公开可用性
在基于 Amazon VPC 服务的虚拟私有云（VPC）内启动数据库实例时，可以打开或关闭该数据库实例的公共可访问性。要指定您创建的数据库实例是否具有解析为公共 IP 地址的 DNS 名称，请使用*公共可用性* 参数。通过使用此参数，您可以指定是否可以公开访问数据库实例。您可以通过修改 *Public accessibility* 参数修改数据库实例以打开或关闭公开可用性。
有关更多信息，请参阅“[对互联网隐藏 VPC 中的数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md#USER_VPC.Hiding)”。
**注意**
如果您的数据库实例位于 VPC 中但不可公开访问，则您还可以使用AWS Site-to-Site VPN 连接或 Direct Connect 连接从专用网络访问该实例。有关更多信息，请参阅 [互联网络流量隐私](inter-network-traffic-privacy.md)。
# Amazon RDS API 和接口 VPC 终端节点 (AWS PrivateLink)
您可以通过创建*接口 VPC 终端节点* 在 VPC 和 Amazon RDS API 终端节点之间建立私有连接。接口终端节点由 提供支持[AWS PrivateLink](https://aws.amazon.com/privatelink)
AWS PrivateLink 使您可以私下访问 Amazon RDS API 操作，而无需互联网网关、NAT 设备、VPN 连接或 Direct Connect 连接。VPC 中的数据库实例不需要公有 IP 地址即可与 Amazon RDS API 端点进行通信，进而启动、修改或终止数据库实例。您的数据库实例也不需要公有 IP 地址即可使用任何可用的 RDS API 操作。您的 VPC 和 Amazon RDS 之间的流量不会脱离 Amazon 网络。
每个接口终端节点均由子网中的一个或多个弹性网络接口表示。有关弹性网络接口的更多信息，请参阅*《Amazon EC2 用户指南》*中的[弹性网络接口](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html)。
有关 VPC 终端节点的更多信息，请参阅 *Amazon VPC 用户指南*中的[接口 VPC 终端节点 (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html)。有关 RDS API 操作的信息，请参阅 [Amazon RDS API 参考](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/)。
您不需要接口 VPC 端点即可连接到数据库实例。有关更多信息，请参阅 [在 VPC 中访问数据库实例的场景](USER_VPC.Scenarios.md)。
## VPC 终端节点注意事项
在为 Amazon RDS API 终端节点设置接口 VPC 终端节点之前，请务必查看*Amazon VPC 用户指南* 中的[接口终端节点属性和限制](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#vpce-interface-limitations)。
可以从使用 AWS PrivateLink 的 VPC 中获取所有与管理 Amazon RDS 资源相关的 RDS API 操作。
RDS API 终端节点支持 VPC 终端节点策略。默认情况下，允许通过终端节点对 RDS API 操作进行完全访问。有关更多信息，请参阅 *Amazon VPC 用户指南*中的[使用 VPC 终端节点控制对服务的访问](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html)。
## 可用性
Amazon RDS API 当前在以下AWS区域中支持 VPC 终端节点：
+ US East (Ohio)
+ 美国东部（弗吉尼亚州北部）
+ 美国西部（北加利福尼亚）
+ 美国西部（俄勒冈州）
+ 非洲（开普敦）
+ 亚太地区（香港）
+ Asia Pacific (Mumbai)
+ 亚太地区（新西兰）
+ 亚太地区（大阪）
+ 亚太地区（首尔）
+ 亚太地区（新加坡）
+ 亚太地区（悉尼）
+ 亚太地区（台北）
+ 亚太地区（泰国）
+ 亚太地区（东京）
+ 加拿大（中部）
+ 加拿大西部（卡尔加里）
+ 中国（北京）
+ 中国（宁夏）
+ 欧洲地区（法兰克福）
+ 欧洲（苏黎世）
+ 欧洲地区（爱尔兰）
+ 欧洲地区（伦敦）
+ 欧洲地区（巴黎）
+ 欧洲地区（斯德哥尔摩）
+ 欧洲地区（米兰）
+ 以色列（特拉维夫）
+ 墨西哥（中部）
+ 中东（巴林）
+ 南美洲（圣保罗）
+ AWS GovCloud（美国东部）
+ AWS GovCloud（美国西部）
## 为 Amazon RDS API 创建接口 VPC 终端节点
您可以使用 Amazon VPC 控制台或 AWS Command Line Interface (AWS CLI) 为 EBS 直接 Amazon RDS API 服务创建 VPC 终端节点。有关更多信息，请参阅 *Amazon VPC 用户指南*中的[创建接口终端节点](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint)。
使用服务名称 `com.amazonaws.region.rds` 为 Amazon RDS API 创建 VPC 终端节点。
如果您为终端节点启用私有 DNS，则可以将其默认 DNS 名称用于AWS区域（例如 `rds.us-east-1.amazonaws.com`），从而通过 VPC 终端节点向 Amazon RDS 发出 API 请求（中国的AWS区域除外）。对于中国（北京）和中国（宁夏）AWS区域，您可以通过 VPC 终端节点分别使用 `rds-api---cn-north-1.amazonaws.com.rproxy.goskope.com.cn` 和 `rds-api---cn-northwest-1.amazonaws.com.rproxy.goskope.com.cn` 发出 API 请求。
有关更多信息，请参阅 *Amazon VPC 用户指南*中的[通过接口终端节点访问服务](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint)。
## 为 Amazon RDS API 创建 VPC 终端节点策略
您可以为 VPC 终端节点附加控制对 Amazon RDS API 的访问的终端节点策略。该策略指定以下信息：
+ 可执行操作的主体。
+ 可执行的操作。
+ 可对其执行操作的资源。
有关更多信息，请参阅 *Amazon VPC 用户指南*中的[使用 VPC 终端节点控制对服务的访问](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html)。
**示例：Amazon RDS API 操作的 VPC 终端节点策略**
下面是用于 Amazon RDS API 的终端节点策略示例。当附加到终端节点时，此策略会向所有委托人授予对列出的针对所有资源的 Amazon RDS API 操作的访问权限。
```
{
"Statement":[
{
"Principal":"*",
"Effect":"Allow",
"Action":[
"rds:CreateDBInstance",
"rds:ModifyDBInstance",
"rds:CreateDBSnapshot"
],
"Resource":"*"
}
]
}
```
**示例：拒绝来自指定 AWS 账户的所有访问的 VPC 终端节点策略**
以下 VPC 端点策略会拒绝 AWS 账户 `123456789012` 所有使用端点访问资源的权限。此策略允许来自其他账户的所有操作。
```
{
"Statement": [
{
"Action": "*",
"Effect": "Allow",
"Resource": "*",
"Principal": "*"
},
{
"Action": "*",
"Effect": "Deny",
"Resource": "*",
"Principal": { "AWS": [ "123456789012" ] }
}
]
}
```
# Amazon RDS 的安全最佳实践
使用 AWS Identity and Access Management（IAM）账户可控制对 Amazon RDS API 操作（特别是创建、修改或删除 Amazon RDS 资源的操作）的访问权限。此类资源包括数据库实例、安全组和参数组。此外，使用 IAM 可控制执行常见管理任务的操作，例如备份和还原数据库实例。
+ 为管理 Amazon RDS 资源的每个人（包括您自己）创建一个单独的用户。请勿使用 AWS 根凭证管理 Amazon RDS 资源。
+ 授予每位用户执行其职责所需的最低权限集。
+ 使用 IAM 组有效地管理适用于多个用户的权限。
+ 定期轮换您的 IAM 凭证。
+ 将 AWS Secrets Manager 配置为自动轮换 Amazon RDS 的密钥。有关更多信息，请参阅 *AWS Secrets Manager用户指南*中的[轮换 AWS Secrets Manager 密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html)。您也可以从 AWS Secrets Manager 中以编程方式检索凭证。有关更多信息，请参阅 *AWS Secrets Manager 用户指南* 中的[检索密钥值](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_retrieve-secret.html)。
有关 Amazon RDS 安全性的更多信息，请参阅 [Amazon RDS 中的安全性](UsingWithRDS.md)。有关 IAM 的更多信息，请参阅。[AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/Welcome.html)有关 IAM 最佳实践的信息，请参阅 [IAM 最佳实践](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html)。
AWS Security Hub CSPM 使用安全控件来评估资源配置和安全标准，以帮助您遵守各种合规框架。有关使用 Security Hub CSPM 评估 RDS 资源的更多信息，请参阅《AWS Security Hub 用户指南》中的 [Amazon Relational Database Service 控件](https://docs.aws.amazon.com/securityhub/latest/userguide/rds-controls.html)。
您可以监控 RDS 的使用情况，因为它与使用 Security Hub CSPM 的安全最佳实践有关。有关更多信息，请参阅[什么是 AWS Security Hub CSPM？](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)。
使用 AWS 管理控制台、AWS CLI 或 RDS API 更改主用户的密码。如果使用另一个工具（如 SQL 客户端）来更改主用户密码，则可能会无意中取消用户的权限。
# 使用安全组控制访问权限
VPC 安全组控制传入和传出数据库实例的流量拥有的访问权限。默认情况下，将为您的数据库实例关闭网络访问。您可以在安全组中指定规则，允许从 IP 地址范围、端口或安全组进行访问。配置传入规则后，会向与该安全组关联的所有数据库实例应用相同的规则。您最多可以在一个安全组中指定 20 个规则。
## VPC 安全组概述
每个 VPC 安全组规则都使特定的源能够访问 VPC 中与该 VPC 安全组关联的数据库实例。源可以是一个地址范围 (例如，203.0.113.0/24) 或另一个 VPC 安全组。指定作为源的 VPC 安全组后，就可以允许从使用此源 VPC 安全组的所有实例 (通常为应用程序服务器) 中传入流量。VPC 安全组可能具有管理入站和出站流量的规则。但是，出站流量规则通常不适用于数据库实例。仅在数据库实例充当客户端时，出站流量规则才适用。例如，出站流量规则适用于具有出站数据库链接的 Oracle 数据库实例。您必须使用 [Amazon EC2 API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Welcome.html) 或 VPC 控制台中的 **Security Group**（安全组）选项创建 VPC 安全组。
当您为 VPC 安全组创建允许访问 VPC 中的实例的规则时，必须为规则允许访问的每个地址范围指定一个端口。例如，如果您要对 VPC 中的实例开启 Secure Shell（SSH）访问，则为指定的地址范围创建一条允许访问 TCP 端口 22 的规则。
您可以为 VPC 中不同的实例配置允许访问不同端口的多个 VPC 安全组。例如，您可以创建一个允许访问您的 VPC 中的 Web 服务器的 TCP 端口 80 的 VPC 安全组。之后，您可以创建另一个 VPC 安全组，来允许访问您的 VPC 中的 RDS for MySQL 数据库实例的 TCP 端口 3306。
有关 VPC 安全组的更多信息，请参阅 *Amazon Virtual Private Cloud 用户指南* 中的[安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
**注意**
如果您的数据库实例位于 VPC 中但不可公开访问，则您还可以使用 AWS Site-to-Site VPN 连接或 Direct Connect 连接从专用网络访问它。有关更多信息，请参阅 [互联网络流量隐私](inter-network-traffic-privacy.md)。
## 安全组情况
VPC 中的数据库实例的一种常见用法是，与运行在相同 VPC 中 Amazon EC2 实例上的应用程序服务器分享数据，这些数据可通过 VPC 外的客户端应用程序进行访问。对于此情况，使用 AWS 管理控制台上的 RDS 和 VPC 页面或 RDS 和 EC2 API 操作来创建必要的实例和安全组：
1. 创建一个 VPC 安全组 (例如，`sg-0123ec2example`)，然后定义使用客户端应用程序 IP 地址作为源的入站规则。通过此安全组，客户端应用程序可连接到使用此安全组的 VPC 中的 EC2 实例。
1. 创建一个适用于该应用程序的 EC2 实例，然后将该 EC2 实例添加到上一步中创建的 VPC 安全组 (`sg-0123ec2example`)。
1. 创建第二个 VPC 安全组 (例如，`sg-6789rdsexample`)，然后通过将步骤 1 中创建的 VPC 安全组(`sg-0123ec2example`) 指定为源来创建一个新规则。
1. 创建一个新的数据库实例，然后将该数据库实例添加到在上一步骤中创建的 VPC 安全组（`sg-6789rdsexample`）。在创建数据库实例时，使用的端口号应与为您在步骤 3 中创建的 VPC 安全组（`sg-6789rdsexample`）规则指定的端口号相同。
下图说明了此情形。
![\[VPC 中的数据库实例和 EC2 实例\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/con-VPC-sec-grp.png)
有关针对此场景配置 VPC 的详细说明，请参阅[教程：创建 VPC 以用于数据库实例（仅限 IPv4）](CHAP_Tutorials.WebServerDB.CreateVPC.md)。有关使用 VPC 的更多信息，请参阅 [Amazon VPC 和 Amazon RDS](USER_VPC.md)。
## 创建 VPC 安全组
您可以使用 VPC 控制台为数据库实例创建 VPC 安全组。有关创建安全组的信息，请参阅 *Amazon Virtual Private Cloud 用户指南* 中的[通过创建安全组提供对 VPC 中的数据库实例的访问](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup)和[安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
## 将安全组与数据库实例关联
您可以使用 RDS 控制台的 **Modify (修改)** 选项、`ModifyDBInstance` Amazon RDS API 或 `modify-db-instance` AWS CLI 命令将安全组与数据库实例关联。
以下 CLI 示例关联特定 VPC 安全组并从数据库实例中移除数据库安全组
```
aws rds modify-db-instance --db-instance-identifier dbName --vpc-security-group-ids sg-ID
```
有关修改数据库实例的信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。有关从数据库快照还原数据库实例时的安全组注意事项，请参阅[安全组注意事项](USER_RestoreFromSnapshot.md#USER_RestoreFromSnapshot.Security)。
**注意**
如果将端口值配置为非原定设置值，RDS 控制台会显示数据库的不同安全组规则名称。
对于 RDS for Oracle 数据库实例，可以通过填充 Oracle Enterprise Manager Database Express（OEM）、适用于 Enterprise Manager Cloud Control 的 Oracle Management Agent（OEM 代理）和 Oracle 安全套接字层选项的安全组选项设置来关联其它安全组。在这种情况下，与数据库实例关联的安全组和选项设置都适用于该数据库实例。有关这些选项组的更多信息，请参阅 [Oracle Enterprise Manager](Oracle.Options.OEM.md)、[适用于 Enterprise Manager Cloud Control 的 Oracle Management Agent](Oracle.Options.OEMAgent.md) 和 [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)。
# 主用户账户权限
在创建一个新的数据库实例时，您使用的默认主用户将获得针对该数据库实例的特定权限。您无法在创建数据库实例之后更改主用户名。
**重要**
我们强烈建议不要直接在应用程序中使用主用户。请遵守使用数据库用户的最佳实践，按照您的应用程序所需的最少权限创建用户。
**注意**
如果您不小心删除了主用户的权限，要想恢复权限，您可以修改数据库实例并设置新的主用户密码。有关修改数据库实例的更多信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
下表显示了主用户为每个数据库引擎获取的权限和数据库角色。
| 数据库引擎 | 系统权限 | 数据库角色 |
| --- | --- | --- |
| RDS for Db2 | 主用户被分配到 `masterdba` 组并被分配 `master_user_role`。 `SYSMON`、具有 `DATAACCESS` 和 `ACCCESSCTRL` 的 `DBADM`、`BINDADD`、`CONNECT`、`CREATETAB`、`CREATE_SECURE_OBJECT`、`EXPLAIN`、`IMPLICIT_SCHEMA`、`LOAD`、`SQLADM`、`WLMADM` | `DBA`,`DBA_RESTRICTED`, `DEVELOPER`,`ROLE_NULLID_PACKAGES`, `ROLE_PROCEDURES`,`ROLE_TABLESPACES` 有关更多信息，请参阅 [Amazon RDS for Db2 默认角色](db2-default-roles.md)。 |
| RDS for MariaDB | `SELECT`,`INSERT`,`UPDATE`,`DELETE`, `CREATE`,`DROP`,`RELOAD`, `PROCESS`,`REFERENCES`,`INDEX`, `ALTER`,`SHOW DATABASES`,`CREATE TEMPORARY TABLES`,`LOCK TABLES`, `EXECUTE`,`REPLICATION CLIENT`,`CREATE VIEW`,`SHOW VIEW`,`CREATE ROUTINE`, `ALTER ROUTINE`,`CREATE USER`, `EVENT`,`TRIGGER`,`REPLICATION SLAVE` 从 RDS for MariaDB 版本 11.4 开始，主用户也将获得 `SHOW CREATE ROUTINE` 权限。 | — |
| RDS for MySQL 8.0.36 及更高版本 | `SELECT`,`INSERT`,`UPDATE`, `DELETE`,`CREATE`,`DROP`, `RELOAD`,`PROCESS`, `REFERENCES`,`INDEX`,`ALTER`, `SHOW DATABASES`,`CREATE TEMPORARY TABLES`,`LOCK TABLES`,`EXECUTE`, `REPLICATION SLAVE`,`REPLICATION CLIENT`, `CREATE VIEW`,`SHOW VIEW`,`CREATE ROUTINE`,`ALTER ROUTINE`,`CREATE USER`,`EVENT`,`TRIGGER`, `CREATE ROLE`,`DROP ROLE`, `APPLICATION_PASSWORD_ADMIN`, `ROLE_ADMIN`,`SET_USER_ID`, `XA_RECOVER_ADMIN` | `rds_superuser_role` 有关 `rds_superuser_role` 的更多信息，请参阅 [RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)。 |
| 低于 8.0.36 的 RDS for MySQL 版本 | `SELECT`,`INSERT`,`UPDATE`, `DELETE`,`CREATE`,`DROP`, `RELOAD`,`PROCESS`, `REFERENCES`,`INDEX`,`ALTER`, `SHOW DATABASES`,`CREATE TEMPORARY TABLES`,`LOCK TABLES`,`EXECUTE`, `REPLICATION CLIENT`,`CREATE VIEW`, `SHOW VIEW`,`CREATE ROUTINE`,`ALTER ROUTINE`,`CREATE USER`,`EVENT`, `TRIGGER`,`REPLICATION SLAVE` | — |
| RDS for PostgreSQL | `CREATE ROLE`,`CREATE DB`, `PASSWORD VALID UNTIL INFINITY`,`CREATE EXTENSION`,`ALTER EXTENSION`,`DROP EXTENSION`,`CREATE TABLESPACE`,`ALTER