# 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)。