本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 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)
+ [
# Amazon RDS 的 AWS 受管政策更新
](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 的基本概念。若要進一步了解您公司可搭配 Amazon RDS 使用 IAM 的方式，請參閱 [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 登入 使用者指南*》中的[如何登入您的 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 帳戶 *theroot 使用者的*登入身分開始，該身分可完整存取所有 AWS 服務 和 資源。強烈建議您不要以根使用者處理日常任務。有關需要根使用者憑證的任務，請參閱《*IAM 使用者指南*》中的[需要根使用者憑證的任務](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。
### 聯合身分
最佳實務是要求人類使用者使用聯合身分提供者，以 AWS 服務 使用臨時憑證存取 。
*聯合身分*是來自您的企業目錄、Web 身分提供者的使用者，或使用來自身分來源的 AWS 服務 憑證存取 Directory Service 的使用者。聯合身分會擔任提供臨時憑證的角色。
對於集中式存取權管理，我們建議使用 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 帳戶 的身分。它與使用者相似，但是不會與特定人員建立關聯。您可以切換角色，暫時在 中擔任 IAM AWS 管理主控台 [角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html)。您可以透過呼叫 AWS CLI 或 AWS API 操作或使用自訂 URL 來擔任角色。如需使用角色的方法詳細資訊，請參閱 *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 中執行應用程式或將物件儲存在 Amazon 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)。
## 使用政策管理存取權
您可以透過 AWS 建立政策並將其連接到 IAM 身分或 AWS 資源來控制 中的存取。政策是 中的物件， AWS 當與身分或資源建立關聯時， 會定義其許可。當實體 （根使用者、使用者或 IAM 角色） 發出請求時， 會 AWS 評估這些政策。政策中的許可決定是否允許或拒絕請求。大多數政策會以 JSON 文件 AWS 的形式存放在 中。如需 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、 或 API AWS 取得角色資訊。
### 身分型政策
身分類型政策是您可以連接到身分 (例如許可集或角色) 的 JSON 許可政策文件。這些政策可控制身分在何種條件下能對哪些資源執行哪些動作。若要了解如何建立身分類型政策，請參閱 *IAM 使用者指南*中的[建立 IAM 政策](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)。
+ **服務控制政策 SCPs)** – SCPs是 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 的存取權前，建議您先了解可搭配 Amazon RDS 使用的 IAM 功能有哪些。
下表列出您可以搭配 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 *使用者指南*》中的[AWS 與 IAM 搭配使用的 服務](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 標籤的以屬性為基礎存取控制 Attribute-based access control (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 Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html) 來指定資源。若動作不支援資源層級許可，使用萬用字元 (\$1) 表示該陳述式適用於所有資源。
```
"Resource": "*"
```
資料庫執行個體資源具有以下 Amazon Resource Name (ARN)。
```
arn:${Partition}:rds:${Region}:${Account}:{ResourceType}/${Resource}
```
如需 ARNs 格式的詳細資訊，請參閱 [Amazon Resource Name (ARNs 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 標籤的以屬性為基礎存取控制 Attribute-based access control (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)中，提供標籤資訊。
如果服務支援每個資源類型的全部三個條件金鑰，則對該服務而言，值為 **Yes**。如果服務僅支援某些資源類型的全部三個條件金鑰，則值為 **Partial**。
如需 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 管理員必須建立 IAM 政策，授予許可集和角色在指定資源上執行特定 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)** – 如果您的案例需要 IAM 使用者或 中的根使用者 AWS 帳戶，請開啟 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 主控台，您必須擁有最低的一組許可。這些許可必須允許您列出和檢視 中 Amazon RDS 資源的詳細資訊 AWS 帳戶。如果您建立比最基本必要許可更嚴格的身分型政策，則對於具有該政策的實體 (使用者或角色) 而言，主控台就無法如預期運作。
對於僅呼叫 AWS CLI 或 AWS API 的使用者，您不需要允許最低主控台許可。反之，只需允許存取符合您嘗試執行之 API 作業的動作就可以了。
為了確保這些實體仍然可以使用 Amazon RDS Aurora主控台，請將下列 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 為您的帳戶為 AWS 您的帳戶`123456789012`建立資料庫執行個體的範例政策。此政策需要新資料庫執行個體的名稱以 `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 Resource Name (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` 之所有動作的許可。這些動作會顯示 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 資料庫引擎，而不使用 MultiAZ 的資料庫執行個體。`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_tw/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 Resource Name (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：對資料庫執行個體上的動作授予許可，而此資料庫執行個體的執行個體名稱字首會加上使用者名稱
下列政策允許在資料庫執行個體上呼叫任何 API (但 `AddTagsToResource` 或 `RemoveTagsFromResource` 除外) 的許可，而此資料庫執行個體具有字首會加上使用者名稱的資料庫執行個體名稱，以及具有稱為 `stage` 等於 `devo` 的標籤，或沒有稱為 `stage` 的標籤。
政策中的 `Resource` 一行會依其 Amazon Resource Name (ARN) 識別資源。如需使用 ARN 與 Amazon RDS 資源的詳細資訊，請參閱[Amazon RDS 中的 Amazon Resource Name (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)。如需詳細資訊，請參閱[什麼是 ABAC AWS？](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 受管政策：AmazonRDSCustomInstanceProfileRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy)
+ [
## AWS 受管政策：AmazonRDSPreviewServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)
+ [
## AWS 受管政策：AmazonRDSBetaServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)
## AWS 受管政策：AmazonRDSReadOnlyAccess
此政策允許透過 對 Amazon RDS 進行唯讀存取 AWS 管理主控台。
**許可詳細資訊**
此政策包含以下許可：
+ `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
此政策透過 提供 Amazon RDS 的完整存取權 AWS 管理主控台。
**許可詳細資訊**
此政策包含以下許可：
+ `rds` – 允許主體完整存取 Amazon RDS。
+ `application-autoscaling` – 允許主體說明和管理 應用程式自動擴展擴展目標和政策。
+ `cloudwatch` – 允許主體取得 CloudWatch 指標靜態並管理 CloudWatch 警示。
+ `ec2` – 允許主體說明可用區域和聯網資源。
+ `logs` – 允許主體說明日誌群組的 CloudWatch Logs 日誌串流，並取得 CloudWatch Logs 事件。
+ `outposts` – 允許主體取得 AWS Outposts 執行個體類型。
+ `pi` – 允許主體取得績效詳情指標。
+ `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
此政策允許完整存取在特定 Aurora Serverless叢集上使用資料 API 和查詢編輯器 AWS 帳戶。此政策允許 從 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 資料庫執行個體和 Amazon Aurora 資料庫叢集的 Amazon RDS 績效詳情唯讀存取權限。
此政策現在包含 `Sid` (陳述式 ID) 作為政策陳述式的識別碼。
**許可詳細資訊**
此政策包含以下許可：
+ `rds` – 允許主體說明 Amazon RDS 資料庫執行個體和 Amazon Aurora 資料庫叢集。
+ `pi` – 允許主體呼叫 Amazon RDS 績效詳情 API 並存取績效詳情指標。
如需有關此政策的詳細資訊，包括 JSON 政策文件，請參閱《AWS 受管政策參考指南》**中的 [AmazonRDSPerformanceInsightsReadOnly](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsReadOnly.html)。
## AWS 受管政策：AmazonRDSPerformanceInsightsFullAccess
此政策提供對 Amazon RDS 資料庫執行個體和 Amazon Aurora 資料庫叢集的 Amazon RDS Performance Insights 完整存取權限。
此政策現在包含 `Sid` (陳述式 ID) 作為政策陳述式的識別符。
**許可詳細資訊**
此政策包含以下許可：
+ `rds` – 允許主體說明 Amazon RDS 資料庫執行個體和 Amazon Aurora 資料庫叢集。
+ `pi` – 允許主體呼叫 Amazon RDS Performance Insights 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 受管政策：AmazonRDSCustomInstanceProfileRolePolicy
您不應將 `AmazonRDSCustomInstanceProfileRolePolicy` 連接到 IAM 實體。它應該只連接到執行個體設定檔角色，該角色用於授予 Amazon RDS Custom 資料庫執行個體執行各種自動化動作和資料庫管理任務的許可。在 RDS Custom 執行個體建立期間，以 `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 受管政策參考指南》**中的 [AmazonRDSCustomInstanceProfileRolePolicy](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 受管政策參考指南》**中的 [AmazonRDSPreviewServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPreviewServiceRolePolicy.html)。
## AWS 受管政策：AmazonRDSBetaServiceRolePolicy
您不應將 `AmazonRDSBetaServiceRolePolicy` 連接到 IAM 實體。此政策會連接到服務連結角色，允許 Amazon RDS 代表 RDS 資料庫資源呼叫 AWS 服務。如需詳細資訊，請參閱[Amazon RDS Beta 的服務連結角色許可](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)。
# Amazon RDS 的 AWS 受管政策更新
檢視自此服務開始追蹤 Amazon RDS AWS 受管政策更新以來的變更詳細資訊。如需有關此頁面變更的自動提醒，請訂閱 Amazon RDS [Document history (文件歷程記錄)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/WhatsNew.html) 頁面上的 RSS 摘要。
| 變更 | 描述 | 日期 |
| --- | --- | --- |
| [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) – 更新現有政策 | Amazon RDS 已更新 `AWSServiceRoleForRDSCustom` 服務連結角色的 `AmazonRDSCustomServiceRolePolicy` 許可。更新會從一個陳述式中移除 `ec2:CopySnapshot`，並為來源和目的地快照許可新增兩個新陳述式。這些更新符合 [EBS CopySnapshot 授權行為的變更](https://aws.amazon.com/blogs/storage/enhancing-resource-level-permissions-for-copying-amazon-ebs-snapshots/)，同時保持有效許可不變。如需詳細資訊，請參閱 [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2025 年 8 月 7 日 |
| [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) – 更新現有政策 | Amazon RDS 已將新許可新增至 `AWSServiceRoleForRDSCustom` 服務連結角色的 `AmazonRDSCustomServiceRolePolicy`。這些許可允許 RDS Custom 管理 EC2 金鑰對，並允許 RDS Custom 與 Amazon SQS 整合。如需詳細資訊，請參閱 [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2025 年 3 月 25 日 |
| [AWS 受管政策：AmazonRDSCustomInstanceProfileRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy) – 更新現有政策 | Amazon RDS 新增了受管政策 `AmazonRDSCustomInstanceProfileRolePolicy` 的新許可，以允許在 RDS Custom 執行個體上使用 RDS Custom 受管秘密。如需詳細資訊，請參閱 [AWS 受管政策：AmazonRDSCustomInstanceProfileRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy)。 | 2025 年 3 月 20 日 |
| [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) – 更新現有政策 | Amazon RDS 已將新許可新增至 `AWSServiceRoleForRDSCustom` 服務連結角色的 `AmazonRDSCustomServiceRolePolicy`。這些新許可允許 RDS Custom 列出和還原 Secrets Manager 秘密。如需詳細資訊，請參閱 [Amazon RDS Custom 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom)。 | 2025 年 3 月 6 日 |
| [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 已將新陳述式 ID 新增至 `AWSServiceRoleForRDS` 服務連結角色的 `AmazonRDSServiceRolePolicy`。 如需詳細資訊，請參閱 [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、檢視分析結果及建議，以及刪除報告。 如需有關設定 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 將新的 Amazon CloudWatch 命名空間 `ListMetrics` 新增至 `AmazonRDSFullAccess` 和 `AmazonRDSReadOnlyAccess`。 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 調查結果。 如需詳細資訊，請參閱 [AWS 受管政策的 Amazon RDS 更新](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 整合。 SQL Server Reporting Services (SSRS) 電子郵件必須與 Secrets Manager 整合，才能在 RDS 上運作。SSRS 電子郵件會代表客戶建立一個秘密。密碼使用舊有的命名慣例並限制客戶更新。 如需詳細資訊，請參閱 [使用 SSRS 電子郵件傳送報告](SSRS.Email.md)。 | 2022 年 8 月 26 日 |
| [Amazon RDS 的服務連結角色許可](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions) – 更新現有政策 | Amazon RDS 為 `PutMetricData` 將新的 Amazon CloudWatch 命名空間新增至 `AmazonRDSPreviewServiceRolePolicy`。 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` 將新的 Amazon CloudWatch 命名空間新增至 `AmazonRDSBetaServiceRolePolicy`。 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` 將新的 Amazon CloudWatch 命名空間新增至 `AWSServiceRoleForRDS`。 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) 的許可。 Outpost 上的 RDS 需要這些許可權限，才可跨 Outpost 的本機網路執行多可用區域複寫。 如需詳細資訊，請參閱 [在 上使用 Amazon RDS 的異地同步備份部署 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 上的許可權限。 Outpost 上的 RDS 需要此許可權限，才可跨 Outpost 的本機網路執行多可用區域複寫。 如需詳細資訊，請參閱 [在 上使用 Amazon RDS 的異地同步備份部署 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` 將新的 Amazon CloudWatch 命名空間新增至 `AWSServiceRoleForRDS`。 這些命名空間是 Amazon DocumentDB (具備 MongoDB 相容性) 和 Amazon Neptune 發佈 CloudWatch 指標所必需的。 如需詳細資訊，請參閱 *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 S3 儲存貯體的 Amazon 資源名稱 (ARN) 時。在這些情況下，請務必同時使用兩個全域條件內容索引鍵來限制許可。在某些情況下，可以同時使用全域條件內容索引鍵和包含帳號 ID 的 `aws:SourceArn` 值。在這些情況下，當在相同政策陳述式中使用 `aws:SourceAccount` 值和 `aws:SourceArn` 裡的帳戶時，請確認兩者使用同樣的帳戶 ID。如果您想要僅允許一個資源與跨服務存取相關聯，請使用 `aws:SourceArn`。如果您想要允許指定AWS帳戶中的任何資源與跨服務使用相關聯，請使用 `aws:SourceAccount`。
請確定 `aws:SourceArn` 的值是 Amazon RDS 資源類型的 ARN。如需詳細資訊，請參閱[Amazon RDS 中的 Amazon Resource Name (ARN)](USER_Tagging.ARN.md)。
防範混淆代理人問題的最有效方法是使用 `aws:SourceArn` 全域條件內容索引鍵，以及資源的完整 ARN。在某些情況下，您可能不知道資源的完整 ARN，或者指定了多個資源。在這些情況下，請針對 ARN 的未知部分，使用含有萬用字元 (`*`) 的全域條件內容索引鍵 (`aws:SourceArn`)。例如，`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 稽核的IAM 角色](Appendix.SQLServer.Options.Audit.IAM.md)
+ [設定 IAM 許可權限以進行 RDS for Oracle 與 Amazon S3 的整合](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 Signature 第 4 版產生。每個字符的存留期為 15 分鐘。您不需要將使用者登入資料存放在資料庫，因為身分驗證是利用 IAM 在外部管理。您仍可使用標準資料庫身分驗證。字符僅用於身分驗證，並且在建立後不會影響工作階段。
IAM 資料庫身分驗證提供下列優點：
+ 使用 Secure Socket Layer (SSL) 或 Transport Layer Security (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 SDKs：
+ [適用於 .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 Proxy。RDS Proxy需額外收費。請參閱 [RDS Proxy 定價](https://aws.amazon.com/rds/proxy/pricing/)。
+ IAM 資料庫身分驗證字符的大小取決於許多因素，包括 IAM 標籤的數量、IAM 服務政策、ARN 長度，以及其他 IAM 和資料庫屬性。此字符的最小大小一般約為 1 KB，但可以更大。因為此字符用作連線字串中的密碼，以使用 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)。
## 主控台
每個建立或修改工作流程都有一個 **Database authentication (資料庫身分驗證)** 區段，您可以在其中啟用或停用 IAM 資料庫身分驗證。在該區段中，選擇 **Password and IAM database authentication (密碼和 IAM 資料庫身分驗證)** 以啟用 IAM 資料庫身分驗證。
**為現有資料庫執行個體啟用或停用 IAM 資料庫身分驗證**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇想要修改的資料庫執行個體。
**注意**
確認資料庫執行個體與 IAM 身分驗證相容。查看 [區域和版本可用性](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) 中的相容性要求。
1. 選擇 **Modify (修改)**。
1. 在**資料庫身分驗證**區段中，選擇**密碼和 IAM 資料庫身分驗證** 以啟用 IAM 資料庫身分驗證。選擇**密碼身分驗證**或**密碼和 Kerberos 身分驗證**以停用 IAM 身分驗證。
1. 您也可以選擇啟用將 IAM 資料庫身分驗證日誌發佈至 CloudWatch Logs。在**日誌匯出**下，選擇 **iam-db-auth-error 日誌**選項。將日誌發佈到 CloudWatch Logs 會消耗儲存空間，而且您需要支付該儲存空間的費用。請務必刪除您不再需要的任何 CloudWatch Logs。
1. 選擇 **Continue (繼續)**。
1. 若要立即套用變更，請在 **Scheduling of modifications (修改排程)** 區段中選擇 **Immediately (立即)**。
1. 選擇 **Modify DB instance** (修改資料庫執行個體) 。
## AWS CLI
若要使用 建立具有 IAM 身分驗證的新資料庫執行個體 AWS CLI，請使用 [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 身分驗證相容。查看 [區域和版本可用性](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 政策，請參閱[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 政策中的明確許可。如果您想要將管理員的存取權限制為資料庫執行個體，您可以建立具有適當、特殊權限較低的許可的 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，請選擇資料庫執行個體以查看其詳細資訊。然後選擇 **Configuration (組態)** 標籤。**Resource ID (資源 ID)** 顯示在 **Configuration (組態)** 區段中。
或者，您可以使用 AWS CLI 命令列出目前 AWS 區域中所有資料庫執行個體的識別符和資源 IDs，如下所示。
```
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 Proxy 連線至資料庫，請指定代理資源 ID，例如 `prx-ABCDEFGHIJKL01234`。如需搭配 RDS Proxy 使用 IAM 資料庫驗證的相關資訊，請參閱[使用 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 政策，授予實體在其所需的指定資源上執行特定 API 操作的許可。管理員接著必須將這些政策連接至需要這些許可的許可集或角色。如需政策範例，請參閱 [Amazon RDS 以身分為基礎的政策範例](security_iam_id-based-policy-examples.md)。
## 將政 IAM 政策連接到許可集或角色
在您建立 IAM 政策以允許資料庫身分驗證之後，您必須將該政策連接至許可集或角色。如需本主題的教學課程，請參閱《*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**
+ [
## 搭配 IAM 身分驗證使用 MariaDB and MySQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## 搭配 PostgreSQL 使用 IAM 身分驗證
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## 搭配 IAM 身分驗證使用 MariaDB and MySQL
使用 MariaDB 和 MySQL 時，身分驗證是由 AWS處理`AWSAuthenticationPlugin`，這是與 IAM 無縫搭配運作的外掛程式，可驗證您的使用者。以主要使用者身分或可以建立使用者並授予權限的不同使用者身分連線至資料庫執行個體。連線後，發出 `CREATE USER` 陳述式，如下列範例所示。
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
`IDENTIFIED WITH` 子句可讓 MariaDB and MySQL 使用 `AWSAuthenticationPlugin` 來驗證資料庫帳戶 (`jane_doe`)。`AS 'RDS'` 子句指的是身分驗證方法。確定指定的資料庫使用者名稱與 IAM 資料庫存取的 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 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)。您必須授予 `rds_iam` 角色才能使用 IAM 身分驗證。您也可以使用巢狀成員資格或角色的間接授予。
# 使用 IAM 身分驗證連接至資料庫執行個體
採用 IAM 資料庫身分驗證時，您會使用身分驗證字符來連接資料庫執行個體。*身分驗證字符*是可用來代替密碼的字元字串。產生身分驗證字符之後，過期之前的有效期限為 15 分鐘。如果您嘗試使用過期的字符來連接，則會拒絕連接請求。
每個身分驗證字符必須附帶有效的簽章，並使用 AWS 簽章第 4 版。(如需詳細資訊，請參閱 *AWS 一般參考* 中的 [Signature 第 4 版簽署程序](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)。) AWS CLI 及 AWS SDK (例如 適用於 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/)
+ [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or 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)
+ [
# 從命令列： AWS CLI 和 psql 用戶端使用 IAM 身分驗證連線至資料庫執行個體
](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)
**注意**
有關使用 SQL Workbench/J 與 IAM 身分驗證連接到您的資料庫的資訊，請參閱部落格文章 [使用 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 憑證檔案的完整路徑
如需 SSL/TLS 支援 MariaDB 的詳細資訊，請參閱 [Amazon RDS 支援在 MariaDB 資料庫執行個體上啟用 SSL/TLS 加密。](MariaDB.Concepts.SSLSupport.md)。
如需 SSL/TLS 支援 MySQL 的詳細資訊，請參閱 [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 |
| ... | ...
+-----------------------------+
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 IAM 身分驗證連線至資料庫](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 從命令列： AWS CLI 和 psql 用戶端使用 IAM 身分驗證連線至資料庫執行個體
您可以使用 AWS CLI 和 psql 命令列工具，從命令列連線至 Amazon RDS for PostgreSQL 資料庫執行個體，如下所述。
**先決條件**
以下是使用 IAM 身分驗證連線至資料庫執行個體的先決條件：
+ [啟用和停用 IAM 資料庫身分驗證](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [建立並使用 IAM 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身分驗證建立資料庫帳戶](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**注意**
如需有關使用 pgAdmin 搭配 IAM 身分驗證連線到資料庫的資訊，請參閱部落格文章 [使用 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"
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 IAM 身分驗證連線至資料庫](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身分驗證和 連線至資料庫執行個體 適用於 .NET 的 AWS SDK
您可以使用 連線到 RDS for MariaDB、MySQL 或 PostgreSQL 資料庫執行個體 適用於 .NET 的 AWS SDK ，如下所述。
**先決條件**
以下是使用 IAM 身分驗證連線至資料庫執行個體的先決條件：
+ [啟用和停用 IAM 資料庫身分驗證](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [建立並使用 IAM 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身分驗證建立資料庫帳戶](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**範例**
以下程式碼範例顯示如何產生身分驗證字符，然後用來連線至資料庫執行個體。
若要執行此程式碼範例，您需要在 AWS 網站上[適用於 .NET 的 AWS SDK](https://aws.amazon.com/sdk-for-net/)找到的 。`AWSSDK.CORE` 和 `AWSSDK.RDS` 套件是必需的。若要連接到資料庫執行個體，請使用資料庫引擎的 .NET 資料庫連接器，例如 MariaDB 或 MySQL 的 MySqlConnector 或 PostgreSQL 的 Npgsql。
此程式碼連接到 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();
}
}
}
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 IAM 身分驗證連線至資料庫](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身分驗證和 連線至資料庫執行個體 適用於 Go 的 AWS SDK
您可以使用 連線到 RDS for MariaDB、MySQL 或 PostgreSQL 資料庫執行個體 適用於 Go 的 AWS SDK ，如下所述。
**先決條件**
以下是使用 IAM 身分驗證連線至資料庫執行個體的先決條件：
+ [啟用和停用 IAM 資料庫身分驗證](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [建立並使用 IAM 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身分驗證建立資料庫帳戶](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**範例**
若要執行這些程式碼範例，您需要在 AWS 網站上[適用於 Go 的 AWS SDK](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)
}
}
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 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)
}
}
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 IAM 身分驗證連線至資料庫](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身分驗證和 連線至資料庫執行個體 適用於 Java 的 AWS SDK
您可以使用 連線到 RDS for MariaDB、MySQL 或 PostgreSQL 資料庫執行個體 適用於 Java 的 AWS SDK ，如下所述。
**先決條件**
以下是使用 IAM 身分驗證連線至資料庫執行個體的先決條件：
+ [啟用和停用 IAM 資料庫身分驗證](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [建立並使用 IAM 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [使用 IAM 身分驗證建立資料庫帳戶](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [設定適用於 Java 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
如需如何使用 SDK for Java 2.x 的範例，請參閱[使用 SDK for Java 2.x 的 Amazon RDS 範例](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html)。您也可以使用 AWS 進階 JDBC 包裝函式，請參閱[AWS 進階 JDBC 包裝函式文件](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 一般參考* 中的 [Signature 第 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 的執行個體。
若要執行此程式碼範例，您需要在 AWS 網站上[適用於 Java 的 AWS SDK](https://aws.amazon.com/sdk-for-java/)找到的 。此外，您還需要下列項目：
+ MySQL Connector/J。本程式碼範本經過 `mysql-connector-java-5.1.33-bin.jar` 的測試。
+ 區域特有的 Amazon RDS 中繼憑證 AWS 。(如需詳細資訊，請參閱「[使用 SSL/TLS 加密與資料庫執行個體或叢集的連線](UsingWithRDS.SSL.md)」。) 在執行時間，類別載入器會在此 Java 程式碼範例所在的同一個目錄中尋找憑證，因此類別載入器可以找到憑證。
+ 視需要修改下列變數的值：
+ `RDS_INSTANCE_HOSTNAME` – 您想要存取之資料庫執行個體的主機名稱。
+ `RDS_INSTANCE_PORT` – 用於連線至 PostgreSQL 資料庫執行個體的連接埠號碼。
+ `REGION_NAME` – 資料庫執行個體執行所在的 AWS 區域。
+ `DB_USER` – 您想要存取的資料庫帳戶。
+ `SSL_CERTIFICATE` – 特定於 AWS 區域的 Amazon RDS SSL 憑證。
若要下載適用於 AWS 區域的憑證，請參閱[使用 SSL/TLS 加密與資料庫執行個體或叢集的連線](UsingWithRDS.SSL.md)。將 SSL 憑證放入此 Java 程式檔案所在的同一個目錄中，讓類別載入器在執行時間可以找到憑證。
此程式碼範例會從預設 AWS 登入資料提供者鏈結取得登入資料。 [https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)
**注意**
為 `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");
}
}
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 IAM 身分驗證連線至資料庫](rds-proxy-connecting.md#rds-proxy-connecting-iam)。
# 使用 IAM 身分驗證和 連線至資料庫執行個體 適用於 Python (Boto3) 的 AWS SDK
您可以使用 連線到 RDS for MariaDB、MySQL 或 PostgreSQL 資料庫執行個體 適用於 Python (Boto3) 的 AWS SDK ，如下所述。
**先決條件**
以下是使用 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)資料。
以下程式碼範例顯示如何產生身分驗證字符，然後用來連線至資料庫執行個體。
若要執行此程式碼範例，您需要在 AWS 網站上[適用於 Python (Boto3) 的 AWS SDK](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))
```
如果要透過 Proxy 連線到資料庫執行個體，請參閱 [使用 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，請檢查 `EnabledCloudwatchLogsExports` 參數是否在 `describe-db-instances` 命令的輸出中設定為 `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_tw/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 Proxy 實作連線集區，以便在應用程式中重複使用已建立的連線。 |
| `[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 Aurora資源
](#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 會請求管理員更新他的政策，允許他使用 `my-example-widget` 動作存取 `rds:GetWidget` 資源。
## 我未獲授權執行 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 Aurora資源
您可以建立一個角色，讓其他帳戶中的使用者或您組織外部的人員存取您的資源。您可以指定要允許哪些信任物件取得該角色。針對支援基於資源的政策或存取控制清單 (ACL) 的服務，您可以使用那些政策來授予人員存取您的資源的許可。
若要進一步了解，請參閱以下內容：
+ 若要了解 Amazon RDS 是否支援這些功能，請參閱[Amazon RDS 如何搭配 IAM 運作](security_iam_service-with-iam.md)。
+ 若要了解如何在您擁有的 AWS 帳戶中提供資源的存取權，請參閱《[IAM 使用者指南》中的為您擁有的另一個 AWS 帳戶中的 IAM 使用者提供存取權](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)。 **
+ 若要了解如何將資源的存取權提供給第三方 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)。