# IAM 角色 IAM *角色*是可在账户中创建的一种具有特定权限的 IAM 身份。IAM 角色类似于 IAM 用户，因为它是一个 AWS 身份，具有确定其在 AWS 中可执行和不可执行的操作的权限策略。但是，角色旨在让需要它的任何人代入，而不是唯一地与某个人员关联。此外，角色没有关联的标准长期凭证（如密码或访问密钥）。相反，当您代入角色时，它会为您提供角色会话的临时安全凭证。您可以使用角色向通常无权访问您的 AWS 资源的用户、应用程序或服务提供访问权限。例如，您可能需要向您 AWS 账户中的用户授予对其通常不拥有的资源的访问权限，或是向一个 AWS 账户中的用户授予对其他账户中的资源的访问权限。或者，您可能需要允许移动应用程序使用 AWS 资源，但是不希望在应用程序中嵌入 AWS 密钥（因为难以更新密钥，而且用户有可能提取到密钥）。有时，您需要向已经具有在 AWS 外部（例如，在您的公司目录中）定义的身份的用户提供对 AWS 的访问权限。或者，您可能需要向第三方授予对您账户的访问权限，使他们可以对您的资源执行审核。对于这些情况，您可以使用 *IAM 角色*委派对 AWS 资源的访问权限。本节介绍各种角色和它们的不同使用方式，何时及如何选择方法，如何创建、管理、切换到（或担任）和删除角色。 **注意** 首次创建您的 AWS 账户时，默认情况下不会创建任何角色。当您向账户添加服务时，这些服务可能会添加服务相关角色以支持其使用案例。服务关联角色是一种与 AWS 服务关联的服务角色。服务可以代入代表您执行操作的角色。服务关联角色显示在您的 AWS 账户中，并由该服务拥有。IAM 管理员可以查看但不能编辑服务关联角色的权限。您必须先删除角色的相关资源，之后才能删除服务相关角色。这可以保护您的资源，因为您不会无意中删除对资源的访问权限。有关哪些服务支持使用服务相关角色的信息，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md) 并查找其在**服务相关角色**列中为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。 **Topics** + [何时创建 IAM 用户（而不是角色）](#id_which-to-choose) + [角色术语和概念](#id_roles_terms-and-concepts) + [其他资源](#id_roles_additional-resources) + [混淆代理人问题](confused-deputy.md) + [IAM 角色的常见场景](id_roles_common-scenarios.md) + [IAM 角色创建](id_roles_create.md) + [IAM 角色管理](id_roles_manage.md) + [担任角色的方法](id_roles_manage-assume.md) ## 何时创建 IAM 用户（而不是角色）我们建议您仅在身份联合验证不支持的使用案例中使用 IAM 用户。部分使用场景包括： + **无法使用 IAM 角色的工作负载** – 您可以从需要访问 AWS 的位置运行工作负载。在某些应用场景中，您无法使用 IAM 角色提供临时凭证，例如 WordPress 插件。在这些情况下，请使用该工作负载的 IAM 用户长期访问密钥对 AWS 进行身份验证。 + **第三方 AWS 客户端**：如果您使用的工具不支持访问 IAM Identity Center，例如不在 AWS 上托管的第三方 AWS 客户端或供应商，请使用 IAM 用户长期访问密钥。 + **AWS CodeCommit 访问** – 如果您正在使用 CodeCommit 来存储您的代码，则可以使用具有 SSH 密钥或服务特定凭证的 IAM 用户对 CodeCommit 进行存储库身份验证。我们建议您除了使用 IAM Identity Center 中的用户进行普通身份验证之外，再执行此操作。IAM Identity Center 中的用户是您的员工队伍中需要访问您的 AWS 账户或云应用程序的人员。要在不配置 IAM 用户的情况下授予用户访问您 CodeCommit 存储库的权限，您可以配置 **git-remote-codecommit** 实用工具。有关 IAM 和 CodeCommit 的更多信息，请参阅 [CodeCommit 的 IAM 凭证：Git 凭证、SSH 密钥和 AWS 访问密钥](id_credentials_ssh-keys.md)。有关配置 **git-remote-codecommit** 实用工具的更多信息，请参阅《AWS CodeCommit 用户指南》中的[连接到具有轮换凭证的 AWS CodeCommit 存储库](https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html#temporary-access-configure-credentials)。 + **Amazon Keyspaces (for Apache Cassandra) access**（Amazon Keyspaces（Apache Cassandra 兼容）访问）– 在您无法使用 IAM Identity Center 中的用户的情况下，如出于测试 Cassandra 兼容性的目的，您可以使用具有服务特定凭证的 IAM 用户向 Amazon Keyspaces 进行身份验证。IAM Identity Center 中的用户是您的员工队伍中需要访问您的 AWS 账户或云应用程序的人员。您还可以使用临时凭证连接到 Amazon Keyspaces。有关更多信息，请参阅《Amazon Keyspaces（Apache Cassandra 兼容）开发人员指南》中的[使用临时凭证连接到使用 IAM 角色和 SigV4 插件的 Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/access.credentials.html#temporary.credentials.IAM)。 + **紧急访问**：无法访问身份提供者，且必须在 AWS 账户中执行操作的情况。创建紧急访问 IAM 用户可以是您弹性计划的一部分。我们建议使用多重身份验证（MFA）严格控制和保护紧急用户凭证。 ## 角色术语和概念以下是可帮助您开始使用角色的一些基本术语。 **** 角色**** 可在账户中创建的具有特定权限的 IAM 身份。IAM 角色与 IAM 用户有一些相似之处。角色和用户都是具有权限策略的 AWS 身份，该策略可确定身份在 AWS 中可执行和不可执行的操作。但是，角色旨在让需要它的任何人代入，而不是唯一地与某个人员关联。此外，角色没有关联的标准长期凭证（如密码或访问密钥）。相反，当您代入角色时，它会为您提供角色会话的临时安全凭证。角色可由以下用户代入： + 相同 AWS 账户或另一个 AWS 账户中的 IAM 用户 + 同一账户中的 IAM 角色 + 服务主体，用于 AWS 服务和功能，例如： + 允许您在计算服务上运行代码的服务，如 Amazon EC2 或 AWS Lambda + 代表您对资源执行操作的功能，如 Amazon S3 对象复制 + 为在 AWS 外部运行的应用程序提供临时安全凭证的服务，如 IAM Roles Anywhere 或 Amazon ECS Anywhere + 由与 SAML 2.0 或 OpenID Connect 兼容的外部身份提供者（IdP）服务进行身份验证的外部用户 ****AWS 服务 ** 角色** 服务角色是由一项服务担任、代表您执行操作的 [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 服务关联的服务角色。服务可以代入代表您执行操作的角色。服务关联角色显示在您的 AWS 账户中，并由该服务拥有。IAM 管理员可以查看但不能编辑服务关联角色的权限。如果在某项服务开始支持服务相关角色时您已使用该服务，您可能会收到一封电子邮件，告知您账户中的新角色。在这种情况下，该服务已自动在您的账户中创建服务相关角色。您无需执行任何操作来支持该角色，并且您不应手动删除它。有关更多信息，请参阅 [我的 AWS 账户中出现新角色](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared)。有关哪些服务支持使用服务相关角色的信息，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md) 并查找其在**服务相关角色**列中为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。有关更多信息，请参阅 [创建服务相关角色](id_roles_create-service-linked-role.md)。 ****角色链**** 角色链是指使用一个角色代入另一个角色。您可以使用 AWS 管理控制台通过切换角色、AWS CLI 或 API 来执行角色链。例如，`RoleA` 有权代入 `RoleB`。您可以在 AssumeRole API 操作中使用其长期用户凭证以允许 User1 代入 `RoleA`。该操作会返回 `RoleA` 短期凭证。借助角色链，您可以使用 `RoleA` 的短期凭证允许 User1 代入 `RoleB`。当您在代入某个角色的同时，您可以传递会话标签并将键设置为可传递。可传递会话标签将传递给角色链中的所有后续会话。要了解会话标签的更多信息，请参阅 [在 AWS STS 中传递会话标签](id_session-tags.md)。角色链将您的 AWS 管理控制台、AWS CLI 或 AWS API 角色会话限制为最长 1 小时。无论为各个角色配置的最长会话持续时间如何，此限制均适用。在使用 [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作代入角色时，您可以使用 `DurationSeconds` 参数指定角色会话的持续时间。您可以指定最多为 43200 秒 (12 小时) 的参数值，具体取决于您的角色的[最大会话持续时间设置](id_roles_update-role-settings.md#id_roles_update-session-duration)。不过，如果您使用角色链代入角色并提供大于 1 小时的 `DurationSeconds` 参数值，则操作将失败。有关在 AWS 管理控制台中切换到某个角色的信息，请参阅 [从用户切换到 IAM 角色（控制台）](id_roles_use_switch-role-console.md)。 ****委托**** 为某人授予权限以允许访问您控制的资源。委派涉及在两个账户之间建立信任。第一个是拥有资源的账户（信任账户）。第二个是包含需要访问资源的用户的账户（可信账户）。可信账户和信托账户可为以下任一账户： + 同一账户。 + 受您的组织控制的两个单独账户。 + 由不同组织拥有的两个账户。要委派权限以访问资源，请在附加了两个策略的信任账户中[创建 IAM 角色](id_roles_create_for-user.md)。*权限策略*授予角色的用户所需权限对资源执行预期任务。*信任策略*指定允许哪些受信任账户成员担任角色。创建信任策略时，不能在主体元素中指定通配符 (\$1) 作为 ARN 的一部分。信任策略附加到信任账户中的角色，并且是权限的一半。另一半是附加到[允许用户切换到或担任角色](id_roles_use_permissions-to-switch.md)的受信任账户中的用户的权限策略。临时担任一个角色的用户将放弃自己的权限而接过该角色的权限。用户退出或停止使用角色时，恢复原始用户权限。另一个名为[外部 ID](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) 的参数有助于确保在不受同一企业控制的账户之间安全使用角色。 ****信任策略**** 在 [JSON 策略文档](reference_policies_grammar.md)中，您可以定义您*信任*代入该角色的主体。角色信任策略是必需的[基于资源的策略](access_policies.md#policies_resource-based)（将附加到 IAM 中的角色）。您可以在信任策略中指定的[主体](reference_policies_elements_principal.md)包括用户、角色、账户和服务。有关更多信息，请参阅 *AWS 安全博客*中的[如何在 IAM 角色中使用信任策略](https://aws.amazon.com/blogs//security/how-to-use-trust-policies-with-iam-roles/)。 ****用于跨账户访问的角色**** 将一个账户中的资源的访问权限授予另一个账户中的受信任主体的账户。角色是授予跨账户访问权限的主要方式。但是，某些 AWS 服务允许您将策略直接附加到资源（而不是使用角色作为代理）。这些策略称为基于资源的策略，您可以使用它们向其他 AWS 账户中的主体授予对资源的访问权限。其中一些资源包括 Amazon Simple Storage Service (S3) 存储桶、Amazon Glacier 文件库、Amazon Simple Notification Service (SNS) 主题和 Amazon Simple Queue Service (SQS) 队列。要了解哪些服务支持基于资源的策略，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)。有关基于资源的策略的更多信息，请参阅 [IAM 中的跨账户资源访问](access_policies-cross-account-resource-access.md)。 ## 其他资源以下资源可帮助您了解与 IAM 角色相关的 IAM 术语的更多信息。 + **主体**是 AWS 中可执行操作并访问资源的实体。主体可以是 AWS 账户根用户、IAM 用户或角色。代表 AWS 服务身份的主体就是[服务主体](reference_policies_elements_principal.md#principal-services)。使用角色信任策略中的 Principal 元素来定义您信任的可以代入该角色的主体。有关您可以允许代入角色的主体的更多信息和示例，请参阅 [AWS JSON 策略元素：Principal](reference_policies_elements_principal.md)。 + **身份联合验证**会创建外部身份提供商与 AWS 之间的信任关系。您可以使用现有的 OpenID Connect（OIDC）或安全断言标记语言（SAML）2.0 提供程序来管理谁可以访问 AWS 资源。当您使用 OIDC 和 SAML 2.0 在这些外部身份提供者与 AWS 之间配置信任关系时，会将用户分配到 IAM 角色。用户还会获得允许该用户访问您的 AWS 资源的临时凭证。有关联合主体的更多信息，请参阅 [身份提供程序和 AWS 中的联合身份验证](id_roles_providers.md)。 + **联合主体**是来自 Directory Service、您的企业用户目录或 OIDC 提供者的现有身份。AWS 在通过[身份提供者](id_roles_providers.md)请求访问权限时，将为联合主体分配角色。有关 SAML 和 OIDC 联合主体的更多信息，请参阅 [联合用户会话和角色](introduction_access-management.md#intro-access-roles)。 + **权限策略**是基于身份的策略，用于定义角色可使用的操作和资源。该文档是根据 IAM policy 语言的规则编写的。有关更多信息，请参阅 [IAM JSON 策略参考](reference_policies.md)。 + **权限边界**是一项高级功能，利用该功能，可以使用策略来限制基于身份的策略可以授予角色的最大权限。无法将权限边界应用于服务相关角色。有关更多信息，请参阅 [IAM 实体的权限边界](access_policies_boundaries.md)。 # 混淆代理人问题混淆代理问题是一个安全问题，即没有执行操作权限的实体可能会迫使更具权限的实体执行该操作。为了防止这种情况，如果您为账户中的资源提供第三方（称为*跨账户*）或其他 AWS 服务（称为*跨服务*）的访问权限，则 AWS 会提供用于保护您账户的工具。有时，您需要向第三方提供对您的 AWS 资源的访问权 (提供访问权)。举例来说，您决定聘请一家名为 Example Corp 的第三方公司来监控您的 AWS 账户并帮助优化成本。为跟踪您的日常开支，Example Corp 需要访问您的 AWS 资源。Example Corp 也可监控其他客户的很多其他 AWS 账户。您可使用 IAM 角色在您的 AWS 账户和 Example Corp 账户之间建立信任关系。此方案的一个重要方面是*外部 ID*，外部 ID 是一个可选标识符，您可在 IAM 角色信任策略中使用该信息来指定谁能代入该角色。外部 ID 的主要功能是解决并防止混淆代理人问题。某些 AWS 服务（呼叫服务）使用其 AWS 服务主体从其他 AWS 服务（被叫服务）访问 AWS 资源。在其中一些服务交互中，您可以将呼叫服务配置为与来自其他 AWS 账户中的被叫服务的资源进行通信。例如，配置 AWS CloudTrail 以写入位于不同 AWS 账户的中央 Amazon S3 存储桶。通过为 `cloudtrail.amazonaws.com` 添加允许声明，调用服务 CloudTrail 可以使用 S3 存储桶的策略访问您的 S3 存储桶。当来自呼叫服务的 AWS 服务主体访问来自被叫服务的资源时，来自被叫服务的资源策略仅授权 AWS 服务主体，而不是配置呼叫服务的角色。例如，不附带任何条件地信任 CloudTrail 服务主体的 S3 存储桶可以从受信任的管理员配置的 AWS 账户接收 CloudTrail 日志，但如果他们知道 S3 存储桶的名称，也可以从其 AWS 账户中的未经授权角色那里接收 CloudTrail 日志。当某个角色利用 AWS 服务主体的信任来获得对他们本来不打算访问的资源的访问权限时，就会出现混淆的代理问题。 ## 跨账户混淆代理人预防下图阐明了跨账户混淆代理人问题。 ![\[混淆代理人问题的描述。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/confuseddeputyproblem2.png) 此场景假定： + **AWS1** 是您的 AWS 账户。 + **AWS1:ExampleRole** 是您账户中的一个角色。该角色的信任策略通过将 Example Corp 的 AWS 账户指定为可担任该角色的账户来信任 Example Corp。将发生以下情况： 1. 在您开始使用 Example Corp 的服务时，您将向 Example Corp 提供 **AWS1:ExampleRole** 的 ARN。 1. Example Corp 使用该角色 ARN 获取临时安全凭证以访问您的 AWS 账户中的资源。这样一来，您将信任 Example Corp 作为可代表您执行操作的“代理人”。 1. 另一个 AWS 客户也开始使用 Example Corp 的服务，而且此客户还为 Example Corp 提供了 **AWS1:ExampleRole** 的 ARN 以供其使用。另一个客户可能已了解或猜到已不是机密信息的 **AWS1:ExampleRole**。 1. 当另一个客户要求 Example Corp 访问（它声称的）其账户中的 AWS 资源时，Example Corp 使用 **AWS1:ExampleRole** 访问您的账户中的资源。这就是其他客户可对您的资源进行未授权访问的方式。由于此客户能够诱使 Example Corp 无意中操作您的资源，因此 Example Corp 现在是一个“混淆代理人”。 Example Corp 可以通过在角色信任策略中加入 `ExternalId` 条件检查来解决混淆的代理问题。Example Corp 为每个客户生成唯一的 `ExternalId` 值，并在其请求中使用该值来承担该角色。在 Example Corp 的客户中，`ExternalId` 值必须是独一无二的，并由 Example Corp 而不是其客户控制。这就是您从 Example Corp 获取该 ID 且不能自行提供该 ID 的原因。这可以防止 Example Corp 成为一个混淆代理人，以及授予对另一个账户的 AWS 资源的访问权。在我们的方案中，假设 Example Corp 为您提供的唯一标识符是 12345，而为另一个客户提供的标识符是 67890。这些标识符已针对此方案进行简化。通常，这些标识符为 GUID。假定这些标识符在 Example Corp 的客户之间是唯一的，它们将是用于外部 ID 的有意义的值。 Example Corp 将向您提供外部 ID 值 12345。然后，您必须将一个 `Condition` 元素添加到角色的信任策略，该策略要求 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts) 值为 12345，如下所示： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": { "AWS": "Example Corp's AWS Account ID" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals": { "sts:ExternalId": "12345" } } } } ``` ------ 此策略中的 Condition 元素允许 Example Corp 仅在 AssumeRole API 调用包括外部 ID 值 12345 时代入该角色。Example Corp 确保，只要它代表客户担任角色，就会始终在 AssumeRole 调用中包括客户的外部 ID。即使另一个客户向 Example Corp 提供您的 ARN，也无法控制 Example Corp 包括在其发送给 AWS 的请求中的外部 ID。这有助于防止未经授权的客户获取对您的资源的访问权限。下图阐明了此过程。 ![\[如何缓解混淆代理人问题。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/confuseddeputymitigation2.png) 1. 和之前一样，在您开始使用 Example Corp 的服务时，您将向 Example Corp 提供 **AWS1:ExampleRole** 的 ARN。 1. 在 Example Corp 使用该角色 ARN 来代入角色 **AWS1:ExampleRole** 时，Example Corp 将在 AssumeRole API 调用中包含您的外部 ID（12345）。该外部 ID 与角色的信任策略匹配，因此 AssumeRole API 调用将成功，并且 Example Corp 将获取用于访问您的 AWS 账户中的资源的临时安全凭证。 1. 另一个 AWS 客户也开始使用 Example Corp 的服务，而且如之前一样，此客户还为 Example Corp 提供了 **AWS1:ExampleRole** 的 ARN 以供其使用。 1. 但这一次，在 Example Corp 尝试代入角色 **AWS1:ExampleRole** 时，它提供了与另一个客户关联的外部 ID（67890）。另一个客户无法更改此外部 ID。Example Corp 这样做是因为另一个客户请求使用该角色，因此 67890 表示 Example Corp 正在其中操作的环境。由于您已将具有您自己的外部 ID（12345）的条件添加到 **AWS1:ExampleRole** 的信任策略，因此 AssumeRole API 调用将失败。而且将阻止另一个客户对您账户中的资源进行未经授权的访问（由图中的红色“X”表示）。外部 ID 有助于防止任何其他客户欺骗 Example Corp 不知不觉地访问您的资源。 ## 防止跨服务混淆代理下图使用 CloudTrail 和 Amazon S3 交互示例演示了跨服务的混淆代理问题，其中未经授权的角色将 CloudTrail 日志写入他们无权访问的 Amazon S3 存储桶。 ![\[授予未经授权的角色使用 CloudTrail 服务主体访问另一个账户中的 Amazon S3 存储桶。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/cross-service-confused-deputy1.png) 为了帮助防止未经授权的角色利用 AWS 主体的信任来访问您的资源，AWS 服务主体会提供有关他们所代表的 AWS 资源、AWS 账户和 AWS 组织的信息。此信息以全局条件键值的形式提供，这些键值可用于资源策略或 AWS 服务主体发出的请求的资源控制策略。建议在您的资源策略中使用 [aws:SourceArn](reference_policies_condition-keys.md#condition-keys-sourcearn)、[aws:SourceAccount](reference_policies_condition-keys.md#condition-keys-sourceaccount)、[aws:SourceOrgID](reference_policies_condition-keys.md#condition-keys-sourceorgid) 或 [aws:SourceOrgPaths](reference_policies_condition-keys.md#condition-keys-sourceorgpaths)，只要 AWS 服务主体被授予访问您其中一个资源的权限。这些条件键使您能够在资源策略或资源控制策略中测试访问您资源的 AWS 服务主体是否在代表您期望的 AWS 资源、AWS 账户或 AWS Organizations 这样做。 + 使用 `aws:SourceArn` 允许 AWS 服务主体代表特定资源（例如特定 AWS CloudTrail 跟踪或 AppStream 实例集）访问您的资源。 + 使用 `aws:SourceAccount` 允许 AWS 服务主体代表特定 AWS 账户访问您的资源。 + 使用 `aws:SourceOrgID` 允许 AWS 服务主体代表特定 AWS Organizations 访问您的资源。 + 使用 `aws:SourceOrgPaths` 允许 AWS 服务主体代表特定 AWS Organizations 路径访问您的资源。下图演示了跨服务的混淆代理场景，即使用 `aws:SourceAccount` 全局条件上下文键配置资源，而来自另一个账户的未经授权的角色试图访问他们本来不打算访问的 AWS 资源。 ![\[拒绝未经授权的角色使用 CloudTrail 服务主体访问另一个账户中的 Amazon S3 存储桶。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/cross-service-confused-deputy2.png) 在策略中使用 `aws:SourceArn`、`aws:SourceAccount`、`aws:SourceOrgID` 和 `aws:SourceOrgPaths` 全局条件键可帮助您确保服务主体代表您访问您的资源。建议每当向 AWS 服务主体授予对其中一个资源的访问权限时，都使用这些条件键。 **注意** 某些 AWS 服务交互具有额外的控件，可帮助防止测试用户对资源访问的跨服务混淆代理问题。例如，当向 AWS 服务发放 KMS 密钥授予时，AWS KMS 会使用与资源关联的加密上下文以及密钥授予来帮助防止跨服务的混淆代理问题。有关帮助避免跨服务的混淆代理风险的更多信息，以及是否支持 `aws:SourceArn`、`aws:SourceAccount`、`aws:SourceOrgID` 和 `aws:SourceOrgPaths`，请参阅您使用是服务的文档。 ## 使用基于资源的策略进行跨服务混淆代理保护仅当服务主体代表 AWS 账户 111122223333 行事时，以下示例策略授予服务主体 `cloudtrail.amazonaws.com` 访问 Amazon S3 存储桶，arn:aws:s3:::amzn-s3-demo-bucket1 的权限。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "CloudTrailAclCheck", "Effect": "Allow", "Principal": {"Service": "cloudtrail.amazonaws.com"}, "Action": "s3:GetBucketAcl", "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" } } }, { "Sid": "AWSCloudTrailWrite", "Effect": "Allow", "Principal": {"Service": "cloudtrail.amazonaws.com"}, "Action": "s3:PutObject", "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1/[optionalPrefix]/Logs/myAccountID/*", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" } } } ] } ``` ------ 此示例存储桶策略仅在服务主体 `appstream.amazonaws.com` 通过使用 `aws:SourceArn` 指定实例集 ARN 来代表指定的 Amazon AppStream 实例集行事时，才授予服务主体访问 s3://amzn-s3-demo-bucket2 中的 powershell 脚本 examplefile.psh 的权限。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "appstream.amazonaws.com" ] }, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::amzn-s3-demo-bucket2/examplefile.psh", "Condition": { "ArnEquals": { "aws:SourceArn": "arn:aws:appstream:us-east-1:111122223333:fleet/ExampleFleetName" } } } ] } ``` ------ ## 使用资源控制策略进行跨服务混淆代理保护您可以使用资源控制策略（RCP）将跨服务的混淆代理控制应用于支持的 AWS 服务的资源。RCP 允许您对资源集中应用跨服务的混淆代理控制。您可以将条件键（如 `aws:SourceOrgId` 和 `aws:SourceOrgPaths`）与附加到您的 AWS Organizations 的 RCP、组织单位（OU）或组织中的 AWS 账户一起使用，而无需在基于资源的特定策略中添加声明。有关 RCP 和支持的服务更多信息，请参阅《AWS Organizations 用户指南》**中的[资源控制策略（RCP）](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html)。以下示例 RCP 拒绝 AWS 服务主体在 `aws:SourceOrgID` 不等于 o-ExampleOrg 时访问您的成员账户中的 Amazon S3 存储桶。S3 存储桶的基于资源的策略中必须存在相应的允许，以允许 `SourceOrgID` 等于 o-ExampleOrg 的 AWS 服务主体。此策略仅对存在 `aws:SourceAccount` 密钥（`"Null": {"aws:SourceAccount": "false"}`）的服务主体（`"Bool": {"aws:PrincipalIsAWSService": "true"}`）进行的请求应用控制，因此不需要使用此条件键的服务集成和主体的调用不会受到影响。如果 `aws:SourceAccount` 条件键存在于请求上下文中，则 Null 条件将评估为 true，从而强制执行 `aws:SourceOrgID`。我们在 Null 条件运算符中使用 `aws:SourceAccount` 而不是 `aws:SourceOrgID`，因此，如果请求来自不属于组织的账户，则控制仍然适用。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "RCPEnforceConfusedDeputyProtectionForS3", "Effect": "Deny", "Principal": "*", "Action": [ "s3:*" ], "Resource": "*", "Condition": { "StringNotEqualsIfExists": { "aws:SourceOrgID": "o-ExampleOrg" }, "Null": { "aws:SourceAccount": "false" }, "Bool": { "aws:PrincipalIsAWSService": "true" } } } ] } ``` ------ # IAM 角色的常见场景与大多数 AWS 功能一样，您通常可按照两种方式来使用角色：在 IAM 控制台中以交互方式使用角色，或通过 AWS CLI、Tools for Windows PowerShell 或 API 以编程方式使用角色。 + 您账户中的使用 IAM 控制台的 IAM 用户可*切换为*某个角色，以临时使用该控制台中的角色的权限。该用户放弃自己的原始权限，采用分配给该角色的权限。用户退出角色时，将恢复其原始权限。 + 应用程序或 AWS 提供的服务（如 Amazon EC2）可以通过请求供角色用来向 AWS 进行编程请求的临时安全凭证来*代入*角色。您可以按这种方式使用角色，以便不必为需要访问资源的每个实体共享或维护长期安全凭证 (例如，通过创建 IAM 用户)。 **注意** 本指南以可互换方式使用了*切换到角色*和*代入角色*这两个短语。最简单的角色使用方式是向 IAM 用户授予权限，以便切换为您在自己或其他 AWS 账户中创建的角色。他们可以使用 IAM 控制台轻松地切换角色以使用通常您不希望他们拥有的权限，然后退出角色以交出这些权限。这样有助于防止对敏感资源进行*意外* 访问或修改。若要对角色进行更复杂的使用 (如向应用程序和服务或联合身份外部用户授予访问权限)，可以调用 `AssumeRole` API。该 API 调用返回应用程序可在后续 API 调用中使用的一组临时凭证。使用临时凭证执行的操作只拥有相关联的角色所授予的权限。应用程序不必像控制台中的用户那样“退出”角色；而是应用程序直接停止使用临时凭证并使用原始凭证继续调用。联合身份用户使用身份提供程序 (IdP) 提供的凭证登录。AWS 随后向可信 IdP 提供临时证书以传递给用户，以便包含在后续 AWS 资源请求中。这些证书提供向分配的角色授予的权限。本部分提供了以下方案的概述： + [为您拥有的一个 AWS 账户中的 IAM 用户提供对您拥有的其他账户中的资源的访问权限](id_roles_common-scenarios_aws-accounts.md) + [提供对非 AWS 工作负载的访问权限](id_roles_common-scenarios_non-aws.md) + [为第三方拥有的 AWS 账户中的 IAM 用户提供访问权限](id_roles_common-scenarios_third-party.md) + [为 AWS 提供的服务提供对 AWS 资源的访问权限](id_roles_common-scenarios_services.md) + [为经过外部身份验证的用户（联合身份验证）提供访问权限](id_roles_common-scenarios_federated-users.md) # 在您拥有的其他 AWS 账户中 IAM 用户的访问权限您可以向 IAM 用户授予权限，以便切换至您 AWS 账户中的角色，或切换至您拥有的其他 AWS 账户中定义的角色。 **注意** 如果要授予对您未拥有或无法控制的账户的访问权限，请参阅本主题后面的[访问第三方拥有的 AWS 账户](id_roles_common-scenarios_third-party.md)。假设您拥有一个企业关键型 Amazon EC2 实例。您可以创建具有这些权限的角色，而不是直接向用户授予终止实例的权限。然后，允许管理员在需要终止实例时切换为该角色。这样，可向实例添加以下几层保护： + 您必须向用户显式授予担任该角色的权限。 + 用户必须使用 AWS 管理控制台主动切换为该角色，或使用 AWS CLI 或 AWS API 担任角色。 + 您可以向该角色添加多重身份验证 (MFA) 保护，以便只有登录 MFA 设备的用户才能担任该角色。要了解如何配置角色以使担任角色的用户必须先使用多重身份验证 (MFA) 进行身份验证，请参阅[使用 MFA 保护 API 访问](id_credentials_mfa_configure-api-require.md)。我们建议使用该方法以实施*最小权限原则*。这意味着，仅限特定任务需要时，才能使用提升的权限。借助角色，您可以帮助防止对敏感环境进行意外更改，如果您将它们与[审核](cloudtrail-integration.md)合并以帮助确保仅在需要时才使用角色，这尤其适用。在您出于此目的创建角色时，可在该角色的信任策略的 `Principal` 元素中按 ID 指定其用户需要访问权限的账户。随后可以向这些其他账户中的特定用户授予切换到角色的权限。要了解您信任区域之外的账户（受信任的企业或账户）中的主体是否有权承担您的角色，请参阅[什么是 IAM Access Analyzer？](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html)。一个账户中的用户可以切换为相同或不同账户中的角色。使用角色过程中，用户只能执行角色允许的操作并且只能访问角色允许的资源；其原始用户权限处于暂停状态。用户退出角色时，恢复原始用户权限。 ## 使用不同的开发和生产账户的示例方案假设您的组织拥有多个 AWS 账户以将开发环境与生产环境隔离。开发账户中的用户有时可能需要访问生产账户中的资源。例如，在促进从开发环境到生产环境的更新时，您可能需要进行跨账户访问。尽管您可以为在两个账户中工作的用户创建单独的身份 (和密码)，多个账户的凭证管理还是会为身份管理带来难题。在以下图表中，所有用户都通过开发账户进行管理，但一些开发人员需要对生产账户进行有限访问。开发账户有两个组：测试人员和开发人员，每个组有其自身的策略。 ![\[使用角色向不同账户中的用户委托权限\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/roles-usingroletodelegate.png) 1. 在生产账户中，管理员使用 IAM 在该账户中创建 `UpdateApp` 角色。在角色中，管理员定义信任策略，该策略将开发账户指定为 `Principal`，这意味着开发账户中的授权用户可以使用 `UpdateApp` 角色。管理员还为角色定义权限策略，以指定对名为 `productionapp` 的 Amazon S3 存储桶的读取和写入权限。然后，管理员相应信息与需要担任角色的所有人共享。该信息是角色的账号和名称（对于 AWS 控制台用户）或 Amazon Resource Name (ARN)（用于 AWS CLI 或 AWS API 访问）。角色 ARN 类似于 `arn:aws:iam::123456789012:role/UpdateApp`，其中角色名为 `UpdateApp`，角色采用账号 123456789012 进行创建。 **注意** 管理员可以选择配置角色，以便担任角色的用户必须先使用多重身份验证 (MFA) 进行身份验证。有关更多信息，请参阅 [使用 MFA 保护 API 访问](id_credentials_mfa_configure-api-require.md)。 1. 在开发账户中，管理员向开发人员组的成员授予切换为角色的权限。执行此操作的方法是向开发人员组授予针对 `UpdateApp` 角色调用 AWS Security Token Service (AWS STS) `AssumeRole` API 的权限。开发账户中开发人员组的所有 IAM 用户现在都可以切换为生产账户中的 `UpdateApp` 角色。不在开发人员组中的其他用户无权切换为该角色，因此无法访问生产账户中的 S3 存储桶。 1. 用户请求切换为角色： + AWS 控制台：用户选择导航栏上的账户名并选择 **Switch Role (切换角色)**。用户指定账户 ID (或别名) 和角色名称。或者，用户可以单击管理员在电子邮件中发送的链接。通过该链接，用户可以转到已填写详细信息的 **Switch Role** 页面。 + AWS API/AWS CLI：开发账户中开发人员组的用户调用 `AssumeRole` 函数以获取 `UpdateApp` 角色的凭证。用户将 `UpdateApp` 角色的 ARN 指定为调用的一部分。如果测试人员组中的用户发出相同请求，请求将失败，因为测试人员没有针对 `UpdateApp` 角色 ARN 调用 `AssumeRole` 的权限。 1. AWS STS 返回临时凭证： + AWS 控制台：AWS STS 使用角色的信任策略来验证请求，以确保请求来自受信任实体（即开发账户）。验证完成后，AWS STS 向 AWS 控制台返回[临时安全凭证](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html)。 + API/CLI：AWS STS 根据角色的信任策略来验证请求，以确保请求来自受信任实体 (即开发账户)。验证完成后，AWS STS 向应用程序返回[临时安全凭证](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html)。 1. 临时凭证允许访问 AWS 资源： + AWS 控制台：AWS 控制台在所有后续控制台操作中代表用户使用临时凭证，在本例中是用于读取和写入 `productionapp` 存储桶。该控制台无法访问生产账户中的任何其他资源。用户退出角色时，用户的权限恢复为切换为角色之前所拥有的原始权限。 + API/CLI：应用程序使用临时安全凭证更新 `productionapp` 存储桶。应用程序只能使用临时安全凭证读取和写入 `productionapp` 存储桶，无法访问生产账户的任何其他资源。应用程序不必退出角色，只需在后续 API 调用中停止使用临时凭证并使用原始凭证。 ## 其他资源有关更多信息，请参阅下列内容： + [IAM 教程：使用 IAM 角色委托跨 AWS 账户的访问权限](tutorial_cross-account-with-roles.md) # 非 AWS 工作负载的访问权限 [IAM 角色](id_roles.md)是 AWS Identity and Access Management（IAM）中分配[权限](access_policies.md)的对象。当您[担任的角色](id_roles_manage-assume.md)使用 IAM 身份或来自 AWS 外部的身份时，它会为您提供角色会话的临时安全凭证。您的工作负载可能在数据中心或其他 AWS 外部必须访问您 AWS 资源的基础设施中运行。除了创建、分发和管理长期访问密钥之外，您可以使用 AWS Identity and Access Management Roles Anywhere（IAM Roles Anywhere）来验证您的非 AWS 工作负载。IAM Roles Anywhere 使用您的证书颁发机构（CA）颁发的 X.509 证书对身份进行验证，并安全地使用 IAM 角色提供的临时证书提供对 AWS 服务的访问权限。 **使用 IAM Roles Anywhere** 1. 设置使用 [AWS 私有证书颁发机构](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html) 的 CA 或者使用来自您自己的 PKI 基础设施的 CA。 1. 设置 CA 后，您可以在 IAM Roles Anywhere 中创建一个称为*信任锚*的对象。此锚点在 IAM Roles Anywhere 和您的 CA 之间建立信任以进行身份验证。 1. 然后，您可以配置现有的 IAM 角色，或者创建信任 IAM Roles Anywhere 服务的新角色。 1. 使用信任锚点通过 IAM Roles Anywhere 对非 AWS 工作负载进行身份验证。AWS 将非 AWS 工作负载临时凭证授予有权访问您的 AWS 资源的 IAM 角色。 ## 其他资源以下资源可以帮助您了解有关提供非 AWS 工作负载访问权限的更多信息。 + 有关配置 IAM Roles Anywhere 的更多信息，请参阅《IAM Roles Anywhere 用户指南》中的[什么是 AWS Identity and Access Management Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html)。 + 要了解如何设置 IAM Roles Anywhere 的公有密钥基础设施（PKI），请参阅*AWS安全博客*中的 [IAM Roles Anywhere with an external certificate authority](https://aws.amazon.com/blogs/)。 # 访问第三方拥有的 AWS 账户当第三方请求访问您的组织的 AWS 资源时，您可以使用角色向他们委派访问权限。例如，第三方可能某种服务来管理您的 AWS 资源。您可以通过 IAM 角色授予第三方访问您的 AWS 资源的权限，而无需共享您的 AWS 安全凭证。而第三方则可以通过代入您在 AWS 账户中创建的角色来访问您的 AWS 资源。要了解您信任区域之外的账户（受信任的企业或账户）中的主体是否有权承担您的角色，请参阅[什么是 IAM Access Analyzer？](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html)。为了创建他们可以代入的角色，第三方必须为您提供以下信息： + **第三方的 AWS 账户 ID**。为角色定义信任策略时，可将其 AWS 账户 ID 指定为主体。 + **与角色唯一关联的外部 ID**。外部 ID 可以是仅您和第三方已知的任何标识符。例如，您可以使用您与该第三方之间的发票 ID，但不要使用能被猜到的内容，如第三方的名称或电话号码。为角色定义信任策略时，必须指定该 ID。第三方在代入角色时必须提供该 ID。 + **第三方使用您的 AWS 资源所需的权限。**在定义角色的权限策略时，您必须指定这些权限。这个策略定义了他们可以执行哪些操作以及可以访问哪些资源。创建完角色后，您必须向第三方提供该角色的 Amazon Resource Name (ARN)。他们需要使用您的角色的 ARN 来代入该角色。 **重要** 当您授予第三方访问 AWS 资源的权限时，他们可以访问您在该策略中指定的任何资源。系统会为您发送他们使用资源的记录。请确保适当限制他们对资源的使用。 ## 用于第三方访问的外部 ID 外部 ID 允许正担任该角色的用户断言其运行的环境。它还为账户所有者提供一种方法来允许仅在特定情况下担任该角色。外部 ID 的主要功能是解决并防止 [混淆代理人问题](confused-deputy.md)。 **重要** AWS 不会将该外部 ID 作为秘密信息。您在 AWS 中创建访问密钥对或密码这类秘密信息后，您无法再次查看它们。有权查看角色的任何人都可以看到该角色的外部 ID。 ## 我何时应使用外部 ID？在以下情况下使用外部 ID： + 您是 AWS 账户所有者并且已为将访问其他 AWS 账户以及您的账户的第三方配置角色。您应要求第三方提供其在担任您的角色时包含的外部 ID。然后，在您角色的信任策略中检查该外部 ID。这样做可确保外部方仅在代表您执行操作时才能担任您的角色。 + 在前述情况下，您代表不同客户 (如 Example Corp) 担任角色。您应该为每个客户分配一个唯一的外部 ID 并指导他们将该外部 ID 添加到其角色的信任策略。然后，您必须确保在担任角色的请求中始终包含正确的外部 ID。您可能已为您的每个客户提供一个唯一标识符，而且此唯一 ID 足以用作外部 ID。该外部 ID 不是您要明确创建或分别跟踪所需的特殊值 (仅用于此目的)。您应始终在您的 `AssumeRole` API 调用中指定外部 ID。此外，在客户为您提供角色 ARN 时，请测试是否能在带有/不带正确外部 ID 的情况下担任该角色。如果可在没有正确外部 ID 的情况下担任角色，则不要在您的系统中存储该客户的角色 ARN。等待该客户将角色信任策略更新为要求提供正确的外部 ID。这样一来，您帮助您的客户执行了正确的操作，并帮助您和客户避免了混淆代理人问题。 ## 使用外部 ID 的示例场景例如，假设您决定聘请一家名为 Example Corp 的第三方公司来监控您的 AWS 账户并帮助优化成本。为跟踪您的日常开支，Example Corp 需要访问您的 AWS 资源。Example Corp 也可监控其他客户的很多其他 AWS 账户。请勿向 Example Corp 提供对您的 AWS 账户中的 IAM 用户及其长期凭证的访问权限。请使用 IAM 角色角色及其临时安全凭证。IAM 角色提供了一种机制，可允许第三方访问您的 AWS 资源而无需共享长期凭证（例如，IAM 用户的访问密钥）。您可使用 IAM 角色在您的 AWS 账户和 Example Corp 账户之间建立信任关系。建立这种关系后，Example Corp 账户的成员可以调用 AWS Security Token Service [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 以获取临时安全凭证。然后，Example Corp 成员可以使用这些凭证访问您的账户中的 AWS 资源。 **注意** 有关可调用来获取临时安全凭证的 AssumeRole 和其他 AWS API 操作的更多信息，请参阅[比较 AWS STS 凭证](id_credentials_sts-comparison.md)。以下是此方案的更多详细信息： 1. 您聘请了 Example Corp，此公司将为您创建唯一客户标识符。他们为您提供此唯一客户 ID 及其 AWS 账户账号。您需要此信息来在下一步中创建 IAM 角色。 **注意** Example Corp 可使用其想用于 ExternalId 的任何字符串值，只要该值对于每个客户来说都是唯一的。该值可以是客户账号，甚至可以是一个随机字符串，只要没有两个客户拥有相同的值即可。该值不是“机密的”。Example Corp 必须向每个客户提供 ExternalId 值。关键的一点是，该值必须由 Example Corp 生成，而***不是***其客户生成，从而确保每个外部 ID 是唯一的。 1. 您登录到 AWS 并创建 IAM 角色，该角色可向 Example Corp 提供对您的资源的访问权。与任何 IAM 角色类似，该角色具有两个策略：权限策略和信任策略。该角色的信任策略规定谁可担任该角色。在我们的示例方案中，该策略将 Example Corp 的 AWS 账户账号指定为 `Principal`。这允许来自此账户的身份担任该角色。此外，将 `[Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition)` 元素添加到信任策略。此 `Condition` 测试 `ExternalId` 上下文密钥，以确保它与 Example Corp 的唯一客户 ID 一致。例如： ``` "Principal": {"AWS": "Example Corp's AWS 账户 ID"}, "Condition": {"StringEquals": {"sts:ExternalId": "Unique ID Assigned by Example Corp"}} ``` 1. 该角色的权限策略指定该角色允许某个人执行哪些操作。例如，您可以规定该角色允许某人仅管理您的 Amazon EC2 和 Amazon RDS 资源，但不能管理您的 IAM 用户或组。在我们的示例方案中，您使用权限策略为 Example Corp 授予您的账户中的所有资源的只读访问权限。 1. 创建完角色后，您向 Example Corp 提供该角色的 Amazon Resource Name (ARN)。 1. 当 Example Corp 需要访问您的 AWS 资源时，该公司的某人可调用 AWS `sts:AssumeRole` API。该调用包括要担任的角色的 ARN 以及与其客户 ID 对应的 ExternalId 参数。如果发出请求的人使用的是 Example Corp 的 AWS 账户，并且角色 ARN 和外部 ID 是正确的，则请求成功。然后，该请求提供临时安全凭证，Example Corp 可使用这些凭证访问您的角色允许访问的 AWS 资源。换句话说，当角色策略包括外部 ID 时，任何需要担任该角色的人都必须是该角色中的主体，还必须包括正确的外部 ID。 ## 外部 ID 的要点 + 在您支持多个客户拥有不同 AWS 账户的多租户环境中，我们建议每个 AWS 账户使用一个外部 ID。此 ID 应该是第三方生成的随机字符串。 + 要在代入角色时需要提供外部 ID 的第三方，请使用您选择的外部 ID 来更新角色的信任策略。 + 要在代入角色时提供外部 ID，请使用 AWS CLI 或 AWS API 来代入该角色。有关更多信息，请参阅 STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作或 STS [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) CLI 操作。 + `ExternalId` 值的长度必须最少为 2 个字符，最多为 1224 个字符。该值必须是字母数字，没有空格。它还可以包含以下符号：加号 (\$1)、等号 (=)、逗号 (,)、句点 (.)、@ 符号、冒号 (:)、正斜杠 (/) 和连字符 (-)。 ## 其他资源以下资源可帮助您了解有关向第三方拥有的 AWS 账户提供访问权限的更多信息。 + 要了解如何允许其他人在您的 AWS 账户中执行操作，请参阅 [使用自定义信任策略创建角色](id_roles_create_for-custom.md)。 + 要了解如何授予切换到角色的权限，请参阅 [向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md) + 要了解如何创建并向受信任的用户提供临时安全凭证，请参阅 [临时安全凭证的权限](id_credentials_temp_control-access.md)。 # 访问 AWS 服务很多 AWS 服务要求您利用角色控制该服务可以访问的内容。由一项服务担任、代表您执行操作的角色称为[服务角色](id_roles.md#iam-term-service-role)。当某角色为某项服务提供专门用途时，可以将其归类为[服务相关角色](id_roles.md#iam-term-service-linked-role)。请参阅每种服务的 [AWS 文档](https://docs.aws.amazon.com/)，以了解它是否使用角色以及如何分配角色以供服务使用。有关创建角色以向 AWS 提供的服务委派访问权限的详细信息，请参阅[创建向 AWS 服务委派权限的角色](id_roles_create_for-service.md)。 # 访问经过外部身份验证的用户（身份联合验证）您的用户可能已具有 AWS 外部的身份，如在公司目录中。如果这些用户需要使用 AWS 资源（或使用访问这些资源的应用程序），则这些用户也需要 AWS 安全凭证。您可以使用 IAM 角色为身份通过您的企业或第三方身份提供程序 (IdP) 进行联合证明的用户指定权限。 **注意** 作为安全最佳实践，我们建议您使用身份联合验证在 [IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/what-is.html) 中管理用户访问权限，而不是创建 IAM 用户。要了解需要使用 IAM 用户的特定情况，请参阅 [何时创建 IAM 用户（而非角色）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose)。 ## 通过 Amazon Cognito 联合移动或基于 Web 的应用程序的用户如果创建访问 AWS 资源的移动或基于 Web 的应用程序，则应用程序需要安全凭证才能向 AWS 进行编程请求。对于大多数移动应用程序情况，我们建议您使用 [Amazon Cognito](https://aws.amazon.com/cognito/)。您可以将此服务与 [AWS Mobile SDK for iOS](https://aws.amazon.com/sdkforios/) 和 [AWS Mobile SDK for Android and Fire OS](https://aws.amazon.com/sdkforandroid/) 搭配使用，为用户创建唯一的身份，并对其进行身份验证，以使其安全地访问您的 AWS 资源。Amazon Cognito 支持与下一个部分中所列的那些提供商相同的身份提供程序，而且还支持已经过[开发人员验证的身份](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities)和未经身份验证的（来宾）访问。Amazon Cognito 还提供用于同步用户数据的 API 操作，因此，无论用户在设备间怎样转移，其数据总能得以保留。有关更多信息，请参阅 [用于移动应用程序的 Amazon Cognito](id_federation_common_scenarios.md#id_roles_providers_oidc_cognito)。 ## 使用公共身份服务提供商或 OpenID Connect 联合身份用户在移动和基于 Web 的场景下尽可能使用 Amazon Cognito。Amazon Cognito 为您提供公共身份提供程序服务的大部分幕后工作。它与相同的第三方服务协作，也支持匿名登录。不过，对于更高级的方案，您可以直接使用第三方服务，例如 Login with Amazon、Facebook、Google 或任何与 OpenID Connect (OIDC) 兼容的 IdP。有关通过这些服务之一使用 OIDC 联合身份验证的更多信息，请参阅 [OIDC 联合身份验证](id_roles_providers_oidc.md)。 ## 通过 SAML 2.0 联合身份用户如果您的组织已使用支持 SAML 2.0 (安全断言标记语言 2.0) 的身份提供程序软件包，您可以在作为身份提供程序 (IdP) 的您的组织和作为服务提供商的 AWS 之间建立信任。随后可以使用 SAML 为您的用户提供对 AWS 管理控制台的联合单一登录 (SSO)，或是用于调用 AWS API 操作的联合访问。例如，如果您的公司使用 Microsoft Active Directory 和 Active Directory 联合身份验证服务，则您可以使用 SAML 2.0 进行联合。有关使用 SAML 2.0 对用户进行联合身份验证的更多信息，请参阅[SAML 2.0 联合身份验证](id_roles_providers_saml.md)。 ## 通过创建自定义身份代理应用程序来联合身份用户如果您的身份存储与 SAML 2.0 不兼容，则可构建自定义身份代理应用程序来执行类似功能。代理应用程序将对用户进行身份验证，从 AWS 为用户请求临时安全凭证，然后将凭证提供给用户以便访问 AWS 资源。例如，Example Corp. 有很多员工需要运行访问公司 AWS 资源的内部应用程序。这些员工在公司的身份与验证系统中已有身份，并且 Example Corp. 不希望为每位公司员工都创建一个单独的 IAM 用户。 Bob 是 Example Corp. 的一名开发人员。为使 Example Corp. 的内部应用程序可访问公司的 AWS 资源，Bob 开发了一个自定义身份代理应用程序。该应用程序确认员工登录到现有的 Example Corp. 身份与验证系统，而该系统可能使用 LDAP、Active Directory 或其他系统。然后，身份代理应用程序获取员工的临时安全凭证。此场景与以前的某个场景（一个使用自定义身份验证系统的移动应用程序）类似，但需要访问 AWS 资源的应用程序全都运行在企业网络中，并且公司现有一个身份验证系统。为了获取临时安全凭证，该身份代理应用程序调用 `AssumeRole` 或 `GetFederationToken` 以获取临时安全凭证，具体取决于 Bob 要如何管理用户的策略以及临时凭证应何时到期。(有关这些 API 操作之间的差异的更多信息，请参阅[IAM 临时安全凭证](id_credentials_temp.md)和[临时安全凭证的权限](id_credentials_temp_control-access.md)。) 该调用返回由 AWS 访问密钥 ID、秘密访问密钥和会话令牌组成的临时安全凭证。该身份代理应用程序向内部公司应用程序提供这些临时安全凭证。然后，该应用程序可使用这些临时凭证直接调用 AWS。该应用程序将证书缓存至其到期，然后请求新的一组临时证书。下图举例说明此场景。 ![\[使用自定义身份代理应用程序的示例工作流\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/enterprise-authentication-with-identity-broker-application.diagram.png) 此方案有以下属性： + 该身份代理应用程序具有访问 IAM 的令牌服务 (STS) API 以创建临时安全凭证的权限。 + 该身份代理应用程序可确认员工在现有的身份验证系统中经过身份验证。 + 用户可获得一个临时 URL，通过它可访问 AWS 管理控制台 (称为单点登录)。有关创建临时安全凭证的信息，请参阅[比较 AWS STS 凭证](id_credentials_sts-comparison.md)。有关获取对 AWS 管理控制台的访问权限的 SAML 联合主体的更多信息，请参阅 [使 SAML 2.0 联合主体能够访问 AWS 管理控制台](id_roles_providers_enable-console-saml.md)。 # IAM 角色创建要创建角色，可以使用 AWS 管理控制台、AWS CLI、Tools for Windows PowerShell 或 IAM API。如果使用的是 AWS 管理控制台，则可使用向导来完成创建角色的步骤。向导的步骤可能稍有不同，具体取决于您是为 AWS 服务、AWS 账户还是 SAML 或 OIDC 联合主体创建角色。 **IAM 用户的角色** 创建此角色，以在您的 AWS 账户内或向您拥有的其他 AWS 账户中定义的角色委派权限。一个账户中的用户可以切换为相同或不同账户中的角色。使用角色过程中，用户只能执行角色允许的操作并且只能访问角色允许的资源；其原始用户权限处于暂停状态。用户退出角色时，恢复原始用户权限。有关更多信息，请参阅 [创建角色，向 IAM 用户授予权限](id_roles_create_for-user.md)。有关创建跨账户访问角色的更多信息，请参阅 [使用自定义信任策略创建角色](id_roles_create_for-custom.md)。 **AWS 服务的角色** 创建此角色以将权限委派给可以代表您执行操作的服务。您传递给服务的[服务角色](id_roles.md#iam-term-service-role)必须具有 IAM 策略，该策略具有允许服务执行与该服务关联的操作的权限。每项 AWS 服务都需要不同的权限。有关创建服务角色的更多信息，请参阅 [创建向 AWS 服务委派权限的角色](id_roles_create_for-service.md)。有关创建服务相关角色的更多信息，请参阅 [创建服务相关角色](id_roles_create-service-linked-role.md)。 **身份联合验证的角色** 创建此角色可将权限委派给已在 AWS 外部拥有身份的用户。使用身份提供商时，您不必创建自定义登录代码或管理自己的用户身份。您的外部用户通过 IdP 登录，您可以向这些外部身份授予使用您的账户中的 AWS 资源的权限。身份提供商可帮助您确保 AWS 账户的安全，因为您不必在应用程序中分配或嵌入长期安全凭证（如访问密钥）。有关更多信息，请参阅 [为第三方身份提供者创建角色](id_roles_create_for-idp.md)。 # 创建角色，向 IAM 用户授予权限您可以使用 IAM 角色提供对 AWS 资源的访问权限。利用 IAM 角色，您可以在您的*信任*账户和其他 AWS *受信任*账户之间建立信任关系。信任账户拥有要访问的资源，受信任账户包含需要资源访问权限的用户。但是，其他账户可以拥有您的账户中的资源。例如，信任账户可能允许受信任账户创建新资源，例如在 Amazon S3 存储桶中创建新对象。在这种情况下，创建资源的账户拥有资源并控制谁可以访问该资源。创建信任关系后，来自受信任账户的 IAM 用户或应用程序可以使用 AWS Security Token Service (AWS STS) [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作。此操作提供临时安全凭证，可用于访问您账户中的 AWS 资源。账户可由您进行控制，或者具有用户的账户可由第三方进行控制。如果其他具有用户的账户是您无法控制的 AWS 账户，则可使用 `externalId` 属性。外部 ID 可以是您和第三方账户管理员之间达成一致的任何字词或数字。此选项会在信任策略中自动添加一个条件，即仅当请求包括正确的 `sts:ExternalID` 时，该用户才担任该角色。有关更多信息，请参阅 [访问第三方拥有的 AWS 账户](id_roles_common-scenarios_third-party.md)。有关如何使用角色委派权限的信息，请参阅[角色术语和概念](id_roles.md#id_roles_terms-and-concepts)。有关使用服务角色以允许服务访问账户中的资源的信息，请参阅[创建向 AWS 服务委派权限的角色](id_roles_create_for-service.md)。 ## 创建 IAM 角色（控制台）您可以使用 AWS 管理控制台创建 IAM 用户可担任的角色。例如，假设贵组织拥有多个 AWS 账户以便将开发环境与生产环境隔离。有关创建角色（该角色允许开发账户中的用户访问生产账户中的资源）的概述信息，请参阅 [使用不同的开发和生产账户的示例方案](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example)。 **最小权限** 要执行下列步骤，您必须至少具有以下 IAM 权限： `access-analyzer:ValidatePolicy` `iam:AttachRolePolicy` `iam:CreatePolicy` `iam:CreateRole` `iam:GetAccountSummary` `iam:GetPolicy` `iam:GetPolicyVersion` `iam:GetRole` `iam:ListAccountAliases` `iam:ListAttachedRolePolicies` `iam:ListOpenIDConnectProviders` `iam:ListPolicies` `iam:ListRolePolicies` `iam:ListRoles` `iam:ListRoleTags` `iam:ListSAMLProviders` ------ #### [ Console ] 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在控制台的导航窗格中，选择 **Roles**，然后选择 **Create role**。 1. 选择 **AWS 账户** 角色类型。 1. 要为您的账户创建角色，请选择 **This account**（此账户）。要为其他账户创建角色，请选择**其他 AWS 账户**，然后输入要向其授予资源访问权限的**账户 ID**。指定账户的管理员可向该账户中的任何 IAM 用户授予担任该角色的权限。为此，管理员需要将策略附加到用户或组来授予 `sts:AssumeRole` 操作的权限。该策略必须指定角色的 ARN 作为 `Resource`。 1. 如果您向不受您控制的账户的用户授予权限，并且用户将以编程方式代入此角色，请选择 **Require external ID**（需要外部 ID）。外部 ID 可以是您和第三方账户管理员之间达成一致的任意字词或数字。此选项会在信任策略中自动添加一个条件，即仅当请求包括正确的 `sts:ExternalID` 时，该用户才担任该角色。有关更多信息，请参阅 [访问第三方拥有的 AWS 账户](id_roles_common-scenarios_third-party.md)。 **重要** 选择此选项将仅允许通过 AWS CLI、Tools for Windows PowerShell 或 AWS API 访问该角色。这是因为，您不能使用 AWS 控制台切换到其信任策略中有 `externalId` 条件的角色。但您可以通过使用相关开发工具包编写脚本或应用程序，以编程方式创建此类访问。有关更多信息和示例脚本，请参阅 AWS 安全博客中的[如何启用对 AWS 管理控制台的跨账户存取](https://aws.amazon.com/blogs/security/how-to-enable-cross-account-access-to-the-aws-management-console)。 1. 如果需要将该角色限制为使用多重身份验证 (MFA) 进行登录的用户，请选择 **Require MFA**。这将向角色的信任策略中添加用于检查 MFA 登录的条件。需要担任角色的用户必须使用配置的 MFA 设备中的临时一次性密码进行登录。没有经过 MFA 身份验证的用户无法担任该角色。有关 MFA 的更多信息，请参阅[IAM 中的 AWS 多重身份验证](id_credentials_mfa.md) 1. 选择**下一步**。 1. IAM 包括您的账户中的 AWS 托管策略和客户托管策略的列表。选择要用于权限策略的策略，或选择**创建策略**以打开新的浏览器选项卡并从头开始创建新策略。有关更多信息，请参阅 [创建 IAM 策略](access_policies_create-console.md#access_policies_create-start)。在您创建策略后，关闭该选项卡并返回到您的原始选项卡。选中您希望担任角色的任何人具有的权限策略旁边的复选框。如果您愿意，此时可以不选择任何策略，稍后将策略附加到角色。默认情况下，角色没有权限。 1. （可选）设置[权限边界](access_policies_boundaries.md)。这是一项高级功能。打开**设置权限边界**部分，然后选择**使用权限边界控制最大角色权限**。选择要用于权限边界的策略。 1. 选择**下一步**。 1. 对于**角色名称**，请为您的角色输入一个名称。角色名称在您的 AWS 账户内必须是唯一的。在策略中使用角色名称或将其作为 ARN 的一部分时，角色名称区分大小写。在控制台中向客户显示角色名称时（例如在登录过程中），角色名称不区分大小写。由于多个实体可能引用该角色，因此，角色创建完毕后，您将无法编辑角色名称。 1. （可选）对于 **Description**（描述），输入新角色的描述。 1. 在 **Step 1: Select trusted entities**（步骤 1：选择可信实体）或 **Step 2: Add permissions**（步骤 2：添加权限）部分中的 **Edit**（编辑），以编辑角色的用户案例和权限。您将返回之前的页面进行编辑。 1. （可选）通过以键值对的形式附加标签来向角色添加元数据。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。 **重要** 请注意，这只是所需配置的前半部分。您还必须向受信任账户中的各个用户授予在控制台中切换到此角色或以编程方式担任此角色的权限。有关这一步骤的更多信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 ------ ## 创建 IAM 角色 (AWS CLI) 从 AWS CLI 创建角色涉及几个步骤。当您使用控制台创建角色时，很多步骤会自动完成，但是使用 AWS CLI 时，您必须自行完成每一个步骤。您必须创建角色，然后为角色分配权限策略。（可选）您还可以为您的角色设置[权限边界](access_policies_boundaries.md)。 **创建用于跨账户存取的角色（AWS CLI）** 1. 创建角色：[aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) 1. 将托管权限策略附加到角色：[aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html) 或者为角色创建内联权限策略：[aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) 1. （可选）通过附加标签来向角色添加自定义属性：[aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html) 有关更多信息，请参阅 [管理 IAM 角色（AWS CLI 或 AWS API）的标签](id_tags_roles.md#id_tags_roles_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。以下示例演示了在简单环境中创建跨账户角色的前两个最常见的步骤。此示例允许 `123456789012` 账户中的任何用户担任角色并查看 `example_bucket` Amazon S3 存储桶。该示例还假设您使用运行 Windows 的客户端计算机，并且已使用您的账户凭证和区域配置了命令行界面。有关更多信息，请参阅[配置 AWS 命令行界面](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)。在此示例中，在您创建角色时，在第一个命令中包括以下信任策略。此信任策略允许 `123456789012` 账户中的用户使用 `AssumeRole` 操作担任角色，但前提是用户使用 `SerialNumber` 和 `TokenCode` 参数提供 MFA 身份验证。有关 MFA 的更多信息，请参阅 [IAM 中的 AWS 多重身份验证](id_credentials_mfa.md)。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:root" }, "Action": "sts:AssumeRole", "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } } } ] } ``` ------ **重要** 如果 `Principal` 元素中包含特定 IAM 角色或用户的 ARN，在保存策略时该 ARN 将转换为唯一的主体 ID。如果有人希望通过删除并重新创建角色或用户来提升权限，这样有助于减轻此类风险。您通常不会在控制台中看到这个 ID，因为显示信任策略时它还会反向转换为 ARN。但是，如果您删除角色或用户，则主体 ID 会显示在控制台中，因为 AWS 无法再将其映射回 ARN。因此，如果您删除并重新创建了信任策略的 `Principal` 元素所引用的用户或角色，您必须编辑角色以替换 ARN。当您使用第二个命令时，您必须将现有托管策略附加到角色。下面的权限策略仅允许担任角色的任何人对 `example_bucket` Amazon S3 存储桶执行 `ListBucket` 操作。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::example_bucket" } ] } ``` ------ 要创建此 `Test-UserAccess-Role` 角色，您必须先将名为 `trustpolicyforacct123456789012.json` 的上述信任策略保存到本地 `policies` 驱动器中的 `C:` 文件夹。然后，使用名称 `PolicyForRole` 将上述权限策略保存为您的 AWS 账户中的客户管理型策略。然后您可以使用以下命令来创建角色并附加托管策略。 ``` # Create the role and attach the trust policy file that allows users in the specified account to assume the role. $ aws iam create-role --role-name Test-UserAccess-Role --assume-role-policy-document file://C:\policies\trustpolicyforacct123456789012.json # Attach the permissions policy (in this example a managed policy) to the role to specify what it is allowed to do. $ aws iam attach-role-policy --role-name Test-UserAccess-Role --policy-arn arn:aws:iam::123456789012:policy/PolicyForRole ``` **重要** 请注意，这只是所需配置的前半部分。您还必须对受信任账户中的各个用户授予切换角色的权限。有关这一步骤的更多信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。在创建角色并向该角色授予执行 AWS 任务或访问 AWS 资源的权限后，`123456789012` 账户中的任何用户都可以担任该角色。有关更多信息，请参阅 [切换到 IAM 角色（AWS CLI）](id_roles_use_switch-role-cli.md)。 ## 创建 IAM 角色 (AWS API) 从 AWS API 创建角色涉及几个步骤。当您使用控制台创建角色时，很多步骤会自动完成，但是使用 API 时，您必须自行完成每一个步骤。您必须创建角色，然后为角色分配权限策略。（可选）您还可以为您的角色设置[权限边界](access_policies_boundaries.md)。 **在代码中创建角色 (AWS API)** 1. 创建角色：[CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html) 您可以指定一个文件位置作为角色的信任策略。 1. 将托管权限策略附加到角色：[AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html) 或者为角色创建内联权限策略：[PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html) **重要** 请注意，这只是所需配置的前半部分。您还必须对受信任账户中的各个用户授予切换角色的权限。有关这一步骤的更多信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. （可选）通过附加标签来向用户添加自定义属性：[TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html) 有关更多信息，请参阅 [管理 IAM 用户（AWS CLI 或 AWS API）的标签](id_tags_users.md#id_tags_users_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。在创建角色并向该角色授予执行 AWS 任务或访问 AWS 资源的权限后，您必须向账户中的用户授予允许他们担任该角色的权限。有关担任角色的更多信息，请参阅 [切换到 IAM 角色（AWS API）](id_roles_use_switch-role-api.md)。 ## 创建 IAM 角色 (AWS CloudFormation) 有关在 AWS CloudFormation 中创建 IAM 角色的信息，请参阅 *AWS CloudFormation 用户指南*中的[资源和属性参考](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)和[示例](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#aws-resource-iam-role--examples)。有关 AWS CloudFormation 中的 IAM 模板的更多信息，请参阅*AWS CloudFormation用户指南*中的 [AWS Identity and Access Management 模板代码段](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-iam.html)。 # 创建向 AWS 服务委派权限的角色许多 AWS 服务要求您使用角色来允许该服务代表您访问其他服务中的资源。由一项服务担任、代表您执行操作的角色称为[服务角色](id_roles.md#iam-term-service-role)。当某角色为某项服务提供专门用途时，它会被归类为[服务相关角色](id_roles.md#iam-term-service-linked-role)。要查看哪些服务支持使用服务相关角色，或服务是否支持任何形式的临时凭证，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)。要了解单个服务如何使用角色，请选择表格中的服务名称以查看该服务对应的文档。设置 `PassRole` 权限时，应确保用户所传递角色的权限不会超过您希望该用户拥有的权限。例如，可能不允许 Alice 执行任何 Amazon S3 操作。如果 Alice 可以将角色传递给允许 Amazon S3 操作的服务，则该服务可以在执行作业时代表 Alice 执行 Amazon S3 操作。有关如何通过角色委派权限的信息，请参阅[角色术语和概念](id_roles.md#id_roles_terms-and-concepts)。 ## 服务角色权限您必须配置权限以允许 IAM 实体（用户或角色）创建或编辑服务角色。 **注意** 服务相关角色的 ARN 包括服务主体，它在以下策略中显示为 `SERVICE-NAME.amazonaws.com`。请勿尝试猜测服务主体，因为它区分大小写，并且格式会因 AWS 服务而异。要查看服务的服务主体，请参阅其服务相关角色文档。 **允许 IAM 实体创建特定服务角色** 将以下策略添加到需要创建服务角色的 IAM 实体中。此策略允许您为指定服务创建具有特定名称的服务角色。然后，可将托管或内联策略附加到该角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:AttachRolePolicy", "iam:CreateRole", "iam:PutRolePolicy" ], "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME" } ] } ``` ------ **允许 IAM 实体创建任何服务角色** AWS 建议您只允许管理用户创建任何服务角色。拥有创建角色和附加任何策略权限的人员可以升级自己的权限。相反，应创建一个策略，允许他们仅创建他们所需的角色，或者让管理员代表他们创建服务角色。要附加允许管理员访问您整个 AWS 账户的策略，请使用 [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS 托管策略。 **允许 IAM 实体编辑服务角色** 将以下策略添加到需要编辑服务角色的 IAM 实体中。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EditSpecificServiceRole", "Effect": "Allow", "Action": [ "iam:AttachRolePolicy", "iam:DeleteRolePolicy", "iam:DetachRolePolicy", "iam:GetRole", "iam:GetRolePolicy", "iam:ListAttachedRolePolicies", "iam:ListRolePolicies", "iam:PutRolePolicy", "iam:UpdateRole", "iam:UpdateRoleDescription" ], "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME" }, { "Sid": "ViewRolesAndPolicies", "Effect": "Allow", "Action": [ "iam:GetPolicy", "iam:ListRoles" ], "Resource": "*" } ] } ``` ------ **允许 IAM 实体删除特定服务角色** 将以下语句添加到需要删除指定服务角色的 IAM 实体的权限策略。 ``` { "Effect": "Allow", "Action": "iam:DeleteRole", "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME" } ``` **允许 IAM 实体删除任何服务相关角色** AWS 建议您只允许管理用户删除任何服务角色。相反，应创建一个策略，允许他们仅删除他们所需的角色，或者让管理员代表他们删除服务角色。要附加到允许管理员访问您整个 AWS 账户的策略，请使用 [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS 托管策略。 ## 创建用于 AWS 服务的角色（控制台）您可使用 AWS 管理控制台创建用于服务的角色。由于某些服务支持多个服务角色，请参阅您的服务的 [AWS 文档](https://docs.aws.amazon.com/)以查看要选择的使用案例。您可以了解如何为角色分配必要的信任策略和权限策略，以便服务能够代表您担任角色。可用于控制您的角色的权限的步骤可能会有所不同，具体取决于服务如何定义使用案例，以及您是否创建了服务相关角色。 ------ #### [ Console ] **创建用于 AWS 服务的角色（IAM 控制台）** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，选择**角色**，然后选择**创建角色**。 1. 对于 **Trusted entity type**（可信实体类型），选择 **AWS 服务**。 1. 对于**服务或使用案例**，请选择服务，然后选择使用案例。用例由服务定义以包含服务要求的信任策略。 1. 选择**下一步**。 1. 对于**权限策略**，选项取决于您选择的使用案例： + 如果服务定义了角色的权限，则您无法选择权限策略。 + 从一组有限的权限策略中进行选择。 + 从所有权限策略中进行选择。 + 不选择任何权限策略，创建角色后创建策略，然后将这些策略附加到该角色。 1. （可选）设置[权限边界](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)。这是一项高级功能，可用于服务角色，但不可用于服务相关角色。 1. 打开**设置权限边界**部分，然后选择**使用权限边界控制最大角色权限**。 IAM 包括您的账户中的 AWS 托管式策略和客户管理型策略的列表。 1. 选择要用于权限边界的策略。 1. 选择**下一步**。 1. 对于**角色名称**，选项取决于服务： + 如果服务定义角色名称，则您无法编辑角色名称。 + 如果服务定义角色名称的前缀，您可以输入可选的后缀。 + 如果服务未定义角色名称，您可以为该角色命名。 **重要** 命名角色时，请注意以下事项：角色名称在您的 AWS 账户中必须是唯一的，且不能因大小写而变得唯一。例如，不要同时创建名为 **PRODROLE** 和 **prodrole** 的角色。当角色名称在策略中使用或者作为 ARN 的一部分时，角色名称区分大小写，但是当角色名称在控制台中向客户显示时（例如，在登录期间），角色名称不区分大小写。创建角色后，您无法编辑该角色的名称，因为其他实体可能会引用该角色。 1. （可选）对于**描述**，输入角色的描述。 1. （可选）要编辑角色的使用案例和权限，请在**步骤 1：选择可信实体**或**步骤 2：添加权限**部分中选择**编辑**。 1. （可选）为了帮助识别、组织或搜索角色，请以键值对形式添加标签。有关在 IAM 中使用标签的更多信息，请参阅《IAM 用户指南》**中的 [AWS Identity and Access Management 资源的标签](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)。 1. 检查该角色，然后选择**创建角色**。 ------ ## 创建用于服务的角色 (AWS CLI) 从 AWS CLI 创建角色涉及几个步骤。当您使用控制台创建角色时，很多步骤会自动完成，但是使用 AWS CLI 时，您必须自行完成每一个步骤。您必须创建角色，然后为角色分配权限策略。如果您使用的服务是 Amazon EC2，则还必须创建实例配置文件并向其添加角色。（可选）您还可以为您的角色设置[权限边界](access_policies_boundaries.md)。 **从 AWS CLI 为 AWS 服务创建角色** 1. 以下 `[create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)` 命令创建了一个名为 *Test-Role* 的角色并向其附加了信任策略： `aws iam create-role --role-name Test-Role --assume-role-policy-document file://Test-Role-Trust-Policy.json` 1. 将托管权限策略附加到角色：[aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)。例如，以下内容 `attach-role-policy` 命令将名为 `ReadOnlyAccess` 的附加 AWS 托管策略附加到了名为 `ReadOnlyRole` 的 IAM 角色： `aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess --role-name ReadOnlyRole` 或者为角色创建内联权限策略：[aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) 要添加内联权限策略，请参阅以下示例： `aws iam put-role-policy --role-name Test-Role --policy-name ExamplePolicy --policy-document file://AdminPolicy.json` 1. （可选）通过附加标签来向角色添加自定义属性：[aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html) 有关更多信息，请参阅 [管理 IAM 角色（AWS CLI 或 AWS API）的标签](id_tags_roles.md#id_tags_roles_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。如果要将角色与 Amazon EC2 或使用 Amazon EC2 的其他 AWS 服务结合使用，则必须将角色存储在实例配置文件中。实例配置文件是一个角色容器，可在启动时附加到 Amazon EC2 实例。一个实例配置文件只能包含一个角色，不能提高该限制。如果使用 AWS 管理控制台创建角色，则会为您创建具有与角色相同的名称的实例配置文件。有关实例配置文件的更多信息，请参阅[使用实例配置文件](id_roles_use_switch-role-ec2_instance-profiles.md)。有关如何通过角色启动 EC2 实例的信息，请参阅《*Amazon EC2 用户指南*》中的[控制对 Amazon EC2 资源的访问](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances)。 **创建实例配置文件并在其中存储角色 (AWS CLI)** 1. 创建实例配置文件：[aws iam create-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html) 1. 向实例配置文件添加角色：[aws iam add-role-to-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) 以下 AWS CLI 示例命令集演示了创建角色并附加权限的前两个步骤。它还演示了创建实例配置文件并将角色添加到该配置文件中的两个步骤。此示例信任策略允许 Amazon EC2 服务担任角色并查看 `example_bucket` Amazon S3 存储桶。该示例还假设您使用运行 Windows 的客户端计算机，并且已使用您的账户凭证和区域配置了命令行界面。有关更多信息，请参阅[配置 AWS 命令行界面](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)。在此示例中，在您创建角色时，在第一个命令中包括以下信任策略。此信任策略允许 Amazon EC2 服务代入角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": {"Service": "ec2.amazonaws.com"}, "Action": "sts:AssumeRole" } } ``` ------ 当您使用第二个命令时，您必须将权限策略附加到角色。下面的示例权限策略仅允许角色对 `example_bucket` Amazon S3 存储桶执行 `ListBucket` 操作。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::example_bucket" } } ``` ------ 要创建此 `Test-Role-for-EC2` 角色，您必须先将上述名为 `trustpolicyforec2.json` 的信任策略和上述名为 `permissionspolicyforec2.json` 的权限策略保存到您的本地 `C:` 驱动器中的 `policies` 目录。然后，您可以使用以下命令来创建角色，附加策略，创建实例配置文件，并将角色添加到实例配置文件中。 ``` # Create the role and attach the trust policy that allows EC2 to assume this role. $ aws iam create-role --role-name Test-Role-for-EC2 --assume-role-policy-document file://C:\policies\trustpolicyforec2.json # Embed the permissions policy (in this example an inline policy) to the role to specify what it is allowed to do. $ aws iam put-role-policy --role-name Test-Role-for-EC2 --policy-name Permissions-Policy-For-Ec2 --policy-document file://C:\policies\permissionspolicyforec2.json # Create the instance profile required by EC2 to contain the role $ aws iam create-instance-profile --instance-profile-name EC2-ListBucket-S3 # Finally, add the role to the instance profile $ aws iam add-role-to-instance-profile --instance-profile-name EC2-ListBucket-S3 --role-name Test-Role-for-EC2 ``` 启动 EC2 实例时，如果您使用 AWS 控制台，请在 **Configure Instance Details (配置实例详细信息)** 页面中指定实例配置文件名称。如果使用 `aws ec2 run-instances` CLI 命令，请指定 `--iam-instance-profile` 参数。 ## 创建用于服务的角色 (AWS API) 从 AWS API 创建角色涉及几个步骤。当您使用控制台创建角色时，很多步骤会自动完成，但是使用 API 时，您必须自行完成每一个步骤。您必须创建角色，然后为角色分配权限策略。如果您使用的服务是 Amazon EC2，则还必须创建实例配置文件并向其添加角色。（可选）您还可以为您的角色设置[权限边界](access_policies_boundaries.md)。 **为 AWS 服务创建角色 (AWS API)** 1. 创建角色：[CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html) 您可以指定一个文件位置作为角色的信任策略。 1. 将托管权限策略附加到角色：[AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html) 或者为角色创建内联权限策略：[PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html) 1. （可选）通过附加标签来向用户添加自定义属性：[TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html) 有关更多信息，请参阅 [管理 IAM 用户（AWS CLI 或 AWS API）的标签](id_tags_users.md#id_tags_users_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。如果要将角色与 Amazon EC2 或使用 Amazon EC2 的其他 AWS 服务结合使用，则必须将角色存储在实例配置文件中。实例配置文件是角色的容器。每个实例配置文件只能包含一个角色，不能提高该限制。如果在 AWS 管理控制台中创建角色，则为您创建具有与角色相同的名称的实例配置文件。有关实例配置文件的更多信息，请参阅[使用实例配置文件](id_roles_use_switch-role-ec2_instance-profiles.md)。有关如何通过角色启动 Amazon EC2 实例的信息，请参阅《*Amazon EC2 用户指南*》中的[控制对 Amazon EC2 资源的访问](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances)。 **创建实例配置文件并在其中存储角色 (AWS API)** 1. 创建实例配置文件：[CreateInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) 1. 向实例配置文件添加角色：[AddRoleToInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) # 创建服务相关角色服务相关角色是一种独特类型的 IAM 角色，它与AWS服务直接相关。服务相关角色由服务预定义，具有服务代表您调用其他 AWS 服务所需的所有权限。相关的服务还定义了创建、修改和删除服务相关角色的方式。服务可以自动创建或删除角色。它可能允许您在服务的向导或流程中创建、修改或删除角色。或者，它可能需要您使用 IAM 创建或删除角色。无论使用哪种方法，服务相关角色都可让您简化服务的设置流程，因为您不必手动添加服务代表您完成操作所需的权限。 **注意** 请记住，服务角色不同于服务相关角色。服务角色是由一项服务担任、代表您执行操作的 [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 管理员可以查看但不能编辑服务关联角色的权限。链接服务会定义其服务相关角色的权限，除非另外定义，否则仅该服务可以担任角色。定义的权限包括信任策略和权限策略，而且权限策略不能附加到任何其他 IAM 实体。您必须先删除角色的相关资源，之后才能删除角色。这有助于防止您无意中删除访问这些资源的权限。 **提示** 有关哪些服务支持使用服务相关角色的信息，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md) 并查找其在**服务相关角色**列中为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。 ## 服务相关角色权限您必须为 IAM 实体（用户、组或角色）配置权限，以允许用户或角色创建或编辑服务相关角色。 **注意** 服务相关角色的 ARN 包括服务主体，它在以下策略中显示为 `SERVICE-NAME.amazonaws.com`。请勿尝试猜测服务主体，因为它区分大小写，并且格式会因 AWS 服务而异。要查看服务的服务主体，请参阅其服务相关角色文档。 **允许 IAM 实体创建特定服务相关角色** 将以下策略添加到需要创建服务相关角色的 IAM 实体中。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "iam:CreateServiceLinkedRole", "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*", "Condition": {"StringLike": {"iam:AWSServiceName": "SERVICE-NAME.amazonaws.com"}} }, { "Effect": "Allow", "Action": [ "iam:AttachRolePolicy", "iam:PutRolePolicy" ], "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*" } ] } ``` ------ **允许 IAM 实体创建任何服务相关角色** 将以下语句添加到 IAM 实体的权限策略，该实体需要创建服务相关角色或任何包含所需策略的服务角色。此策略语句不允许 IAM 实体将策略附加到该角色。 ``` { "Effect": "Allow", "Action": "iam:CreateServiceLinkedRole", "Resource": "arn:aws:iam::*:role/aws-service-role/*" } ``` **允许 IAM 实体编辑任何服务角色的描述** 将以下语句添加到 IAM 实体的权限策略，该实体需要编辑服务相关角色或任何服务角色的描述。 ``` { "Effect": "Allow", "Action": "iam:UpdateRoleDescription", "Resource": "arn:aws:iam::*:role/aws-service-role/*" } ``` **允许 IAM 实体删除特定服务相关角色** 将以下语句添加到需要删除服务相关角色的 IAM 实体的权限策略。 ``` { "Effect": "Allow", "Action": [ "iam:DeleteServiceLinkedRole", "iam:GetServiceLinkedRoleDeletionStatus" ], "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*" } ``` **允许 IAM 实体删除任何服务相关角色** 将以下语句添加到 IAM 实体的权限策略，该实体需要删除服务相关角色，而不需要删除服务角色。 ``` { "Effect": "Allow", "Action": [ "iam:DeleteServiceLinkedRole", "iam:GetServiceLinkedRoleDeletionStatus" ], "Resource": "arn:aws:iam::*:role/aws-service-role/*" } ``` **允许 IAM 实体将现有角色传递给服务** 有些 AWS 服务允许您将现有角色传递给服务，而不是创建新的服务相关角色。为此，用户必须具有*将角色传递*给服务的权限。将以下语句添加到需要传递角色的 IAM 实体的权限策略。此策略语句还允许实体查看可从中选择要传递的角色的角色列表。有关更多信息，请参阅 [向用户授予权限以将角色传递给 AWS 服务](id_roles_use_passrole.md)。 ``` { "Sid": "PolicyStatementToAllowUserToListRoles", "Effect": "Allow", "Action": ["iam:ListRoles"], "Resource": "*" }, { "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole", "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": "arn:aws:iam::account-id:role/my-role-for-XYZ" } ``` ## 使用服务相关角色的间接权限服务相关角色授予的权限可以间接转让给其他用户和角色。AWS 服务使用某个服务相关角色时，该服务相关角色可以使用自己的权限调用其他 AWS 服务。这意味着，如果用户和角色有权调用使用某个服务相关角色的服务，将能够间接访问该服务相关角色可以访问的服务。例如，在创建 Amazon RDS 数据库实例时，[RDS 的服务相关角色](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.ServiceLinkedRoles.html)如果尚不存在，则会自动创建。借助该服务相关角色，RDS 将可以代表您调用 Amazon EC2、Amazon SNS、Amazon CloudWatch Logs 和 Amazon Kinesis 等服务。如果您允许账户中的用户和角色修改或创建 RDS 数据库，则这些用户和角色将可以通过调用 RDS，从而与 Amazon EC2、Amazon SNS、Amazon CloudWatch Logs 日志和 Amazon Kinesis 资源进行间接交互，因为 RDS 会使用其服务相关角色来访问这些资源。 ### 创建服务相关角色的方法您用来创建服务相关角色的方法取决于服务。在某些情况下，无需手动创建服务相关角色。例如，在服务中完成特定操作 (如创建资源) 时，服务可能为您创建服务相关角色。或者，如果您在某项服务开始支持服务相关角色之前已在使用该服务，则该服务可能自动在您的账户中创建角色。要了解更多信息，请参阅[我的 AWS 账户中出现新角色](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared)。在其他情况下，服务可能支持使用服务控制台、API 或 CLI 手动创建服务相关角色。有关哪些服务支持使用服务相关角色的信息，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md) 并查找其在**服务相关角色**列中为**是**的服务。要了解服务是否支持创建服务相关角色，请选择 **Yes** 链接以查看该服务的服务相关角色文档。如果服务不支持创建角色，则可以使用 IAM 创建服务相关角色。 **重要** 服务相关角色将计入您的 [AWS 账户中的 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entities)限制，但如果您已达到限制，仍可以在账户中创建服务相关角色。只有服务相关角色可以超过此限制。 ### 创建服务相关角色（控制台）在 IAM 中创建服务相关角色之前，请查明链接服务是否已自动创建服务相关角色。此外，需了解您是否能从该服务的控制台、API 或 CLI 创建角色。 **创建服务相关角色（控制台）** 1. 登录 AWS 管理控制台，打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，选择**角色**。然后，选择**创建角色**。 1. 选择**AWS 服务**角色类型。 1. 选择用于您的服务的用例。使用案例由服务定义以包含服务所需的信任策略。然后选择**下一步**。 1. 选择一个或多个要附加到角色的权限策略。根据您选择的使用案例，服务可能执行以下任意操作： + 定义角色所使用的权限。 + 允许您从一组有限的权限中进行选择。 + 允许您从任意权限中进行选择。 + 允许您此时不选择策略，稍后创建策略，然后将这些策略附加到角色。选中分配您希望角色具有的权限的策略旁边的复选框，然后选择**下一步**。 **注意** 使用角色的任何实体都可以使用您指定的权限。默认情况下，角色没有权限。 1. 对于**角色名称**，角色名称自定义的程度由服务定义。如果服务定义角色的名称，则此选项不可编辑。在其他情况下，服务可能定义角色的前缀并让您输入可选的后缀。如果可能，请输入要添加到默认名称的角色名称后缀。该后缀可帮助您确定角色的用途。角色名称在您的 AWS 账户内必须是唯一的。名称不区分大小写。例如，您无法同时创建名为 **\$1SAMPLE** 和 **\$1sample** 的角色。由于多个单位可能引用该角色，角色创建完毕后无法编辑角色名称。 1. （可选）对于 **Description**（描述），编辑新服务相关角色的描述。 1. 您无法在创建过程中将标签附加到服务相关角色。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。 ### 创建服务相关角色(AWS CLI) 在 IAM 中创建服务相关角色之前，请查明链接服务是否已自动创建服务相关角色，以及您是否能从该服务的 CLI 创建角色。如果服务 CLI 不受支持，您可以使用 IAM 命令创建具有服务担任角色时所需的信任策略和内联策略的服务相关角色。 **创建服务相关角色 (AWS CLI)** 运行如下命令： ``` aws iam [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) --aws-service-name SERVICE-NAME.amazonaws.com ``` ### 创建服务相关角色 (AWS API) 在 IAM 中创建服务相关角色之前，请查明链接服务是否已自动创建服务相关角色，以及您是否能从该服务的 API 创建角色。如果服务 API 不受支持，您可以使用 AWS API 创建具有服务代入角色时所需的信任策略和内联策略的服务相关角色。 **创建服务相关角色 (AWS API)** 使用 [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html) API 调用。在请求中，指定 `SERVICE_NAME_URL.amazonaws.com` 的服务名称。例如，要创建 **Lex Bots** 服务相关角色，请使用 `lex.amazonaws.com`。 # 为第三方身份提供者创建角色您可以使用身份提供程序而不必在 AWS 账户中创建 IAM 用户。利用身份提供程序 (IdP)，您可以管理 AWS 外部的用户身份，并向这些外部用户身份授予访问您账户中的 AWS 资源的权限。有关联合和身份提供程序的更多信息，请参阅[身份提供程序和 AWS 中的联合身份验证](id_roles_providers.md)。 ## 为 OIDC 和 SAML 联合主体创建角色（控制台）创建角色的过程取决于您选择的第三方提供商： + 有关 OpenID Connect（OIDC），请参阅 [创建用于 OpenID Connect 联合身份验证（控制台）的角色](id_roles_create_for-idp_oidc.md)。 + 有关 SAML 2.0，请参阅[创建用于 SAML 2.0 联合身份验证的角色（控制台）](id_roles_create_for-idp_saml.md)。 ## 为联合访问创建角色 (AWS CLI) 从 AWS CLI 中为支持的身份提供程序（OIDC 或 SAML）创建角色的步骤是相同的。区别在于，您在先决条件步骤中创建的信任策略的内容不同。首先，按照**先决条件**部分中针对您正在使用的提供商类型的步骤操作： + 有关 OIDC 提供商，请参阅[创建用于 OIDC 的角色的先决条件](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites)。 + 有关 SAML 提供商，请参阅[创建用于 SAML 的角色的先决条件](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites)。从 AWS CLI 创建角色涉及几个步骤。当您使用控制台创建角色时，很多步骤会自动完成，但是使用 AWS CLI 时，您必须自行完成每一个步骤。您必须创建角色，然后为角色分配权限策略。（可选）您还可以为您的角色设置[权限边界](access_policies_boundaries.md)。 **创建角色 (AWS CLI)** 1. 创建角色：[aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) 1. 将权限策略附加到角色：[aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html) 或者为角色创建内联权限策略：[aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) 1. （可选）通过附加标签来向角色添加自定义属性：[aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html) 有关更多信息，请参阅 [管理 IAM 角色（AWS CLI 或 AWS API）的标签](id_tags_roles.md#id_tags_roles_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。以下示例演示了在简单环境中创建身份提供程序角色的前两个最常见的步骤。此示例允许 `123456789012` 账户中的任何用户担任角色并查看 `example_bucket` Amazon S3 存储桶。该示例还假设您在运行 Windows 的计算机上运行 AWS CLI，并且已使用您的凭证配置了 AWS CLI。有关更多信息，请参阅[配置 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)。以下示例信任策略是为用户使用 Amazon Cognito 登录时的移动应用程序设计的。在此示例中，*us-east:12345678-ffff-ffff-ffff-123456* 表示由 Amazon Cognito 分配的身份池 ID。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Sid": "RoleForCognito", "Effect": "Allow", "Principal": {"Federated": "cognito-identity.amazonaws.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}} } } ``` ------ 下面的权限策略仅允许担任角色的任何人对 `example_bucket` Amazon S3 存储桶执行 `ListBucket` 操作。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::example_bucket" } } ``` ------ 要创建此 `Test-Cognito-Role` 角色，您必须首先将上述名为 `trustpolicyforcognitofederation.json` 的信任策略和上述名为 `permspolicyforcognitofederation.json` 的权限策略保存到您的本地 `policies` 驱动器中的 `C:` 文件夹。然后您可以使用以下命令来创建角色并附加内联策略。 ``` # Create the role and attach the trust policy that enables users in an account to assume the role. $ aws iam create-role --role-name Test-Cognito-Role --assume-role-policy-document file://C:\policies\trustpolicyforcognitofederation.json # Attach the permissions policy to the role to specify what it is allowed to do. aws iam put-role-policy --role-name Test-Cognito-Role --policy-name Perms-Policy-For-CognitoFederation --policy-document file://C:\policies\permspolicyforcognitofederation.json ``` ## 为联合访问创建角色 (AWS API) 从 AWS CLI 中为支持的身份提供程序（OIDC 或 SAML）创建角色的步骤是相同的。区别在于，您在先决条件步骤中创建的信任策略的内容不同。首先，按照**先决条件**部分中针对您正在使用的提供商类型的步骤操作： + 有关 OIDC 提供商，请参阅[创建用于 OIDC 的角色的先决条件](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites)。 + 有关 SAML 提供商，请参阅[创建用于 SAML 的角色的先决条件](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites)。 **要创建角色（AWS API）** 1. 创建角色：[CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html) 1. 将权限策略附加到角色：[AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html) 或者为角色创建内联权限策略：[PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html) 1. （可选）通过附加标签来向用户添加自定义属性：[TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html) 有关更多信息，请参阅 [管理 IAM 用户（AWS CLI 或 AWS API）的标签](id_tags_users.md#id_tags_users_procs-cli-api)。 1. （可选）为角色设置[权限边界](access_policies_boundaries.md)：[PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html) 权限边界控制角色可以具有的最大权限。权限边界是一项高级 AWS 功能。 # 创建用于 OpenID Connect 联合身份验证（控制台）的角色您可以使用 OpenID Connect (OIDC) 联合身份验证身份提供者，而不必在 AWS 账户中创建 AWS Identity and Access Management 用户。利用身份提供程序 (IdP)，您可以管理 AWS 外部的用户身份，并向这些外部用户身份授予访问您账户中的 AWS 资源的权限。有关联合身份验证和 IdP 的更多信息，请参阅 [身份提供程序和 AWS 中的联合身份验证](id_roles_providers.md)。 ## 创建用于 OIDC 的角色的先决条件您必须先完成以下先决条件步骤，然后才能创建用于 OIDC 联合身份验证的角色。 **准备创建用于 OIDC 联合身份验证的角色** 1. 注册一项或多项提供 OIDC 联合身份的服务。如果创建需要访问 AWS 资源的应用程序，则还需要使用提供商信息来配置应用程序。当您执行此操作时，提供程序会为您提供一个应用程序 ID 或受众 ID，该 ID 在您的应用程序中具有唯一性。（不同的提供程序使用不同的术语表示此过程。此指南使用*配置*一词表示通过提供程序标识应用程序的过程。）可以对每个提供商配置多个应用程序，也可以对单个应用程序配置多个提供商。查看有关使用身份提供程序的信息，如下所示： + [Login with Amazon 开发人员中心](https://login.amazon.com/) + 在 Facebook 开发人员网站上，[将 Facebook 登录名添加到您的应用程序或网站](https://developers.facebook.com/docs/facebook-login/v2.1)。 + 在 Google 开发人员网站上，[使用 OAuth 2.0 进行登录 (OpenID Connect)](https://developers.google.com/accounts/docs/OAuth2Login)。 1. 从 IdP 接收必要信息后，在 IAM 中创建 IdP。有关更多信息，请参阅 [在 IAM 中创建 OpenID Connect（OIDC）身份提供者](id_roles_providers_create_oidc.md)。 **重要** 如果您使用的是 Google、Facebook 或 Amazon Cognito 的 OIDC IdP，请勿在 AWS 管理控制台中创建单独的 IAM IdP。这些 OIDC 身份提供程序已内置到 AWS，并可供您使用。跳过此步骤并在以下步骤中使用 IdP 创建新角色。 1. 为已进行 IdP 身份验证的用户要担任的角色准备策略。正如任何角色一样，移动应用程序的角色包含两个策略。一个是指定谁可以担任角色的信任策略。另一个是指定允许或拒绝移动应用程序访问的 AWS 操作和资源的权限策略。对于 web IdP，我们建议您使用 [Amazon Cognito](https://aws.amazon.com/cognito/) 来管理身份。在这种情况下，请使用类似于以下示例的信任策略。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": {"Federated": "cognito-identity.amazonaws.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": { "StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east-2:12345678-abcd-abcd-abcd-123456"}, "ForAnyValue:StringLike": {"cognito-identity.amazonaws.com:amr": "unauthenticated"} } } } ``` ------ 将 `us-east-2:12345678-abcd-abcd-abcd-123456` 替换为由 Amazon Cognito 分配给您的身份池 ID。如果您手动配置 OIDC IdP，则在创建信任策略时，必须使用三个值来确保只有您的应用程序可以担任此角色： + 对于 `Action` 元素，使用 `sts:AssumeRoleWithWebIdentity` 操作。 + 对于 `Principal` 元素，使用字符串 `{"Federated":providerUrl/providerArn}`。 + 对于一些常见的 OIDC IdP，`providerUrl` 是 URL。以下示例包括为一些常见 IdP 指定主体的方法： `"Principal":{"Federated":"cognito-identity.amazonaws.com"}` `"Principal":{"Federated":"www.amazon.com"}` `"Principal":{"Federated":"graph.facebook.com"}` `"Principal":{"Federated":"accounts.google.com"}` + 对于其他的 OIDC 提供程序，请使用您在 [Step 2](#idpoidcstep2) 中创建的 OIDC IdP 的 Amazon 资源名称（ARN），如下例所示： `"Principal":{"Federated":"arn:aws:iam::123456789012:oidc-provider/server.example.com"}` + 对于 `Condition` 元素，使用 `StringEquals` 条件来限制权限。测试身份池 ID（对于 Amazon Cognito）或应用程序 ID（对于其他提供商）。身份池 ID 应与您通过 IdP 配置应用程序时获得的应用程序 ID 一致。ID 一致可确保请求来自您的应用程序。 **注意** Amazon Cognito 身份池的 IAM 角色信任服务主体 `cognito-identity.amazonaws.com` 担任该角色。此类角色必须包含至少一个条件键来限制可以担任该角色的主体。其他注意事项适用于承担[跨账户 IAM 角色](access_policies-cross-account-resource-access.md)的 Amazon Cognito 身份池。这些角色的信任策略必须接受 `cognito-identity.amazonaws.com` 服务主体，并且必须包含 `aud` 条件键，以限制预期身份池中的用户担任角色。如果不满足此条件，则信任 Amazon Cognito 身份池的策略会带来风险，即来自非预期身份池的用户可能担任该角色。有关更多信息，请参阅《*Amazon Cognito 开发人员指南*》中的[基本（经典）身份验证中的 IAM 角色的信任策略](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#trust-policies)。根据您所使用的 IdP 创建类似于以下示例之一的条件元素： `"Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}` `"Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}` `"Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}` `"Condition": {"StringEquals": {"accounts.google.com:aud": "66677788899900pro0"}}` 对于 OIDC 提供商，请将 OIDC IdP 的完全限定 URL 与 `aud` 上下文密钥一起使用，如以下示例所示： `"Condition": {"StringEquals": {"server.example.com:aud": "appid_from_oidc_idp"}}` **注意** 角色的信任策略中的主体的值将因 IdP 而异。用于 OIDC 的角色只能指定一个主体。因此，如果移动应用程序允许用户从多个 IdP 登录，请为您想要支持的每个 IdP 创建单独角色。为每个 IdP 创建单独的信任策略。如果用户使用移动应用程序从 Login with Amazon 登录，则将应用以下示例信任策略。在示例中，*amzn1.application-oa2-123456* 表示使用 Login with Amazon 配置应用程序时由 Amazon 分配的应用程序 ID。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Sid": "RoleForLoginWithAmazon", "Effect": "Allow", "Principal": {"Federated": "www.amazon.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}} }] } ``` ------ 如果用户使用移动应用程序从 Facebook 登录，则将应用以下示例信任策略。在此示例中，*111222333444555* 表示由 Facebook 分配的应用程序 ID。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Sid": "RoleForFacebook", "Effect": "Allow", "Principal": {"Federated": "graph.facebook.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}} }] } ``` ------ 如果用户使用移动应用程序从 Google 登录，则将应用以下示例信任策略。在此示例中，*666777888999000* 表示由 Google 分配的应用程序 ID。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Sid": "RoleForGoogle", "Effect": "Allow", "Principal": {"Federated": "accounts.google.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": {"StringEquals": {"accounts.google.com:aud": "666777888999000"}} }] } ``` ------ 如果用户使用移动应用程序从 Amazon Cognito 登录，则将应用以下示例信任策略。在此示例中，*us-east:12345678-ffff-ffff-ffff-123456* 表示由 Amazon Cognito 分配的身份池 ID。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Sid": "RoleForCognito", "Effect": "Allow", "Principal": {"Federated": "cognito-identity.amazonaws.com"}, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}} }] } ``` ------ ## 创建用于 OIDC 的角色完成先决条件后，您可在 IAM 中创建角色。对于公认的共享 OpenID Connect（OIDC）身份提供者（IdP），IAM 要求对名为*身份提供者控制*的 JSON Web 令牌（JWT）中的特定声明进行明确评估。有关哪些 OIDC IdP 拥有*身份提供者控制*的更多信息，请参阅 [适用于共享 OIDC 提供者的身份提供者控制](id_roles_providers_oidc_secure-by-default.md)。以下过程介绍了如何在 AWS 管理控制台中创建用于 OIDC 联合身份验证的角色。要从 AWS CLI 或 AWS API 创建角色，请参阅[为第三方身份提供者创建角色](id_roles_create_for-idp.md)中的过程。 **重要** 如果您使用的是 Amazon Cognito，则使用 Amazon Cognito 控制台来设置角色。否则，请使用 IAM 控制台来创建用于 OIDC 联合身份验证的角色。 **创建用于 OIDC 联合身份验证的 IAM 角色** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在导航窗格中，选择**角色**，然后选择**创建角色**。 1. 选择 **Web 身份**作为可信实体类型，然后选择**下一步**。 1. 对于 **Identity provider**（身份提供程序），请为您的角色选择 IdP： + 如果要为单个 web IdP 创建角色，请选择 **Login with Amazon**、**Facebook** 或 **Google**。 **注意** 您必须为想要支持的每个 IdP 创建单独的角色。 + 如果要为 Amazon Cognito 创建高级方案角色，请选择 **Amazon Cognito**。 **注意** 您仅在处理高级方案时需要手动创建与 Amazon Cognito 一起使用的角色。否则，Amazon Cognito 可以为您创建角色。有关 Amazon Cognito 的更多信息，请参阅《*Amazon Cognito 开发人员指南*》中的[身份池（联合身份）外部身份提供商](https://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html)。 + 要为 GitHub 操作创建角色，您需要首先将 GitHub OIDC 提供者添加到 IAM。将 GitHub OIDC 提供商添加到 IAM 后，选择 **token.actions.githubusercont.com**。 **注意** 有关如何将 AWS 配置为联合身份以信任 GitHub 的 OIDC 提供商的信息，请参阅 [GitHub 文档 – 在 Amazon Web Services 中配置 OpenID Connect](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services)。有关限制与 GitHub IAM IdP 相关的角色访问权限的最佳做法的信息，请参阅此页面上的[为 GitHub OIDC 身份提供程序配置角色](#idp_oidc_Create_GitHub)。 + 要为 HashiCorp Cloud Platform（HCP）Terraform 创建角色，您首先必须将 Terraform OIDC 提供商添加到 IAM。将 Terraform OIDC 提供商添加到 IAM 后，选择 **app.terraform.io**。 **重要** HashiCorp Cloud Platform（HCP）Terraform OIDC 提供商的 IAM 角色必须评估角色信任策略中的 IAM 条件键 `app.terraform.io:sub`。此条件键对哪些 HCP Terraform 组织、项目、工作区或运行阶段能够担任该角色作出限制。如果没有此条件键，则您的信任策略将根据组织外部的身份授予对您的角色和 AWS 资源的访问权限，这不符合最低权限原则。如果您为 AWS 账户中与 HCP Terraform OIDC 提供商关联的角色设置或修改角色信任策略，但未评估 IAM 条件键 `app.terraform.io:sub`，则会收到错误。此外，如果您的角色信任策略未评估此条件键，则 AWS STS 会拒绝授权请求。 1. 所请求的信息因您选择的 OIDC 提供者而异。 + 输入您的应用程序标识符。标识符的标签会根据所选提供程序发生变化： + 如果要为 Login with Amazon 创建角色，请在 **Application ID**（应用程序 ID）框中输入应用程序 ID。 + 如果要为 Facebook 创建角色，请在 **Application ID**（应用程序 ID）框中输入应用程序 ID。 + 如果要为 Google 创建角色，请在 **Audience**（受众）框中输入受众名称。 + 如果要为 Amazon Cognito 创建角色，请在 **Identity Pool ID**（身份池 ID）框中输入您为 Amazon Cognito 应用程序创建的身份池的 ID。 + 如果您想为 GitHub Actions 创建角色，请输入以下详细信息： + 对于 **Audience (受众)**，请选择 `sts.amazonaws.com`。 + 对于 **GitHub 组织**，输入 GitHub 组织名称。GitHub 组织名称为必填项，必须为包含短划线（-）的字母数字。您不能在 GitHub 组织名称中使用通配符（\$1 和？）。 + （可选）对于 **GitHub 存储库**，输入 GitHub 存储库名称。如果不指定值，则默认为通配符（`*`）。 + （可选）对于 **GitHub 分支**，输入 GitHub 分支名称。如果不指定值，则默认为通配符（`*`）。 + 如果您想为 HashiCorp Cloud Platform（HCP）Terraform 创建角色，则请输入以下详细信息： + 对于 **Audience (受众)**，请选择 `aws.workload.identity`。 + 对于**组织**，输入组织名称。您可以为所有组织指定通配符（`*`）。 + 对于**项目**，输入项目名称。您可以为所有项目指定通配符（`*`）。 + 对于**工作区**，输入工作区名称。您可以为所有工作区指定通配符（`*`）。 + 对于**运行阶段**，输入运行阶段名称。您可以为所有运行阶段指定通配符（`*`）。 1. （可选）对于**条件（可选）**，选择**添加条件**以创建在应用程序的用户可以使用角色授予的权限之前必须满足的其他条件。例如，您可以添加一个条件，仅授权特定 IAM 用户 ID 访问 AWS 资源。创建角色后，您还可以在信任策略中添加条件。有关更多信息，请参阅 [更新角色信任策略](id_roles_update-role-trust-policy.md)。 1. 查看您的 OIDC 信息，然后选择**下一步**。 1. IAM 包括您的账户中的 AWS 托管策略和客户托管策略的列表。选择要用于权限策略的策略，或者选择 **Create policy**（创建策略）以打开新的浏览器选项卡并从头开始创建新策略。有关更多信息，请参阅 [创建 IAM 策略](access_policies_create-console.md#access_policies_create-start)。在您创建策略后，关闭该选项卡并返回到您的原始选项卡。选中您希望 OIDC 用户具有的权限策略旁边的复选框。如果您愿意，此时可以不选择任何策略，稍后将策略附加到角色。默认情况下，角色没有权限。 1. （可选）设置[权限边界](access_policies_boundaries.md)。这是一项高级功能。打开 **Permissions boundary**（权限边界）部分，然后选择 **Use a permissions boundary to control the maximum role permissions**（使用权限边界控制最大角色权限）。选择要用于权限边界的策略。 1. 选择**下一步**。 1. 对于 **Role name**（角色名称），输入一个角色名称。角色名称在您的 AWS 账户内必须是唯一的。不区分大小写。例如，您无法同时创建名为 **PRODROLE** 和 **prodrole** 的角色。由于其他 AWS 资源可能会引用此角色，因此您无法在创建角色后编辑角色名称。 1. （可选）对于 **Description**（描述），输入新角色的描述。 1. 要编辑角色的使用案例和权限，在 **Step 1: Select trusted entities**（步骤 1：选择可信实体）或 **Step 2: Add permissions**（步骤 2：添加权限）部分中选择 **Edit**（编辑）。 1. （可选）要向角色添加元数据，请以键值对的形式附加标签。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。 ## 为 GitHub OIDC 身份提供程序配置角色如果将 GitHub 用作 OpenID Connect（OIDC）身份提供者（IdP），则最佳实践是限制可以代入与该 IAM IdP 关联的角色的实体。如果信任策略中包含条件语句，则可将角色限制为特定的 GitHub 组织、存储库或分支。可以使用条件键 `token.actions.githubusercontent.com:sub` 和字符串条件运算符来限制访问权限。我们建议将条件限制为您 GitHub 组织中的一组特定存储库或分支。有关如何将 AWS 配置为联合身份以信任 GitHub 的 OIDC 的信息，请参阅 [GitHub 文档 – 在 Amazon Web Services 中配置 OpenID Connect](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services)。如果您在操作工作流或 OIDC 策略中使用 GitHub 环境，我们强烈建议您在环境中添加保护规则以提高安全性。使用部署分支和标签来限制可以部署到环境中的具体分支和标签。有关使用保护规则配置环境的更多信息，请参阅 GitHub 文章“使用环境进行部署”中的 [部署分支和标签](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-branches-and-tags)**。如果 GitHub 的 OIDC IdP 是角色的可信主体，IAM 会检查角色信任策略条件，以验证条件键 `token.actions.githubusercontent.com:sub` 是否存在并且其值并非单纯的通配符（\$1 和 ?）或者为空。创建或更新信任策略时，IAM 会执行此检查。如果条件键 `token.actions.githubusercontent.com:sub` 不存在，或者键值不符合上述值标准，则请求将会失败并返回错误。 **重要** 如果未将条件键 `token.actions.githubusercontent.com:sub` 限制为特定的组织或存储库，则来自您控制范围之外的组织或存储库的 GitHub 操作可代入与您 AWS 账户中的 GitHub IAM IdP 关联的角色。以下示例信任策略限制对定义的 GitHub 组织、存储库和分支的访问。以下示例中的条件键 `token.actions.githubusercontent.com:sub` 的值是 GitHub 记录的默认主题值格式。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Federated": "arn:aws:iam::012345678910:oidc-provider/token.actions.githubusercontent.com" }, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": { "StringEquals": { "token.actions.githubusercontent.com:aud": "sts.amazonaws.com", "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:ref:refs/heads/GitHubBranch" } } } ] } ``` ------ 以下示例条件限制对定义的 GitHub 组织和存储库的访问，但授予对存储库内任何分支的访问权限。 ``` "Condition": { "StringEquals": { "token.actions.githubusercontent.com:aud": "sts.amazonaws.com" }, "StringLike": { "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:*" } } ``` 以下示例条件限制对定义的 GitHub 组织内任何存储库或分支的访问。我们建议将条件键 `token.actions.githubusercontent.com:sub` 限制为一个特定的值，从而确保只能从 GitHub 组织内访问 GitHub 操作。 ``` "Condition": { "StringEquals": { "token.actions.githubusercontent.com:aud": "sts.amazonaws.com" }, "StringLike": { "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/*" } } ``` 有关可用于策略中的条件检查的 OIDC 联合身份验证密钥的更多信息，请参阅 [AWS OIDC 联合身份验证的可用键](reference_policies_iam-condition-keys.md#condition-keys-wif)。 # 创建用于 SAML 2.0 联合身份验证的角色（控制台）您可以使用 SAML 2.0 联合身份验证而不必在 AWS 账户中创建 IAM 用户。利用身份提供程序 (IdP)，您可以管理 AWS 外部的用户身份，并向这些外部用户身份授予访问您账户中的 AWS 资源的权限。有关联合和身份提供程序的更多信息，请参阅[身份提供程序和 AWS 中的联合身份验证](id_roles_providers.md)。 **注意** 为了提高联合身份验证弹性，我们建议您将 IdP 和AWS联合身份验证配置为支持多个 SAML 登录端点。有关详细信息，请参阅 AWS 安全博客文章[如何使用区域性 SAML 端点进行失效转移](https://aws.amazon.com/blogs//security/how-to-use-regional-saml-endpoints-for-failover)。 ## 创建用于 SAML 的角色的先决条件您必须先完成以下先决条件步骤，然后才能创建用于 SAML 2.0 联合身份验证的角色。 **准备创建用于 SAML 2.0 联合的角色** 1. 在创建用于 SAML 联合的角色之前，必须在 IAM 中创建 SAML 提供商。有关更多信息，请参阅 [在 IAM 中创建 SAML 身份提供者](id_roles_providers_create_saml.md)。 1. 为已进行 SAML 2.0 身份验证的用户要担任的角色准备策略。正如任何角色一样，用于 SAML 联合的角色包含两个策略。一个是指定谁可以代入角色的角色信任策略。另一个是指定允许或拒绝 SAML 联合主体访问的 AWS 操作和资源的 IAM 权限策略。在为角色创建信任策略时，必须使用三个值来确保只有您的应用程序可以代入此角色： + 对于 `Action` 元素，使用 `sts:AssumeRoleWithSAML` 操作。 + 对于 `Principal` 元素，使用字符串 `{"Federated":ARNofIdentityProvider}`。将 `ARNofIdentityProvider` 替换为您在[Step 1](#idpsamlstep1) 中创建的 [SAML 身份提供程序](id_roles_providers_saml.md)的 ARN。 + 对于 `Condition` 元素，使用 `StringEquals` 条件测试 SAML 响应中的 `saml:aud` 属性是否匹配登录控制台时浏览器显示的 URL。此登录端点 URL 是您的身份提供者的 SAML 收件人属性。您可以添加特定区域内的登录 URL。AWS 建议使用区域端点而不是全局端点，以提高联合身份验证的韧性。有关可能的 *region-code* 值的列表，请参阅 [AWS 登录端点](https://docs.aws.amazon.com/general/latest/gr/signin-service.html)中的 **Region**（区域）列。如果需要 SAML 加密，则登录 URL 必须包含 AWS 分配给您的 SAML 提供商的唯一标识符。您可以通过在 IAM 控制台中选择身份提供者并显示详细信息页面来查看唯一标识符。 `https://region-code.signin.aws.amazon.com/saml/acs/IdP-ID` 以下示例信任策略是为 SAML 联合身份用户设计的： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRoleWithSAML", "Principal": { "Federated": "arn:aws:iam::111122223333:saml-provider/PROVIDER-NAME" }, "Condition": { "StringEquals": { "SAML:aud": "https://region-code.signin.aws.amazon.com/saml" } } } } ``` ------ 将主体 ARN 替换为您在 IAM 中创建的 SAML 提供商的实际 ARN。它会具备您自己的账户 ID 和提供商名称。 ## 创建用于 SAML 的角色在完成先决条件步骤后，您可以创建用于基于 SAML 的联合身份验证的角色。 **要创建用于基于 SAML 的联合的角色，请执行以下操作** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，依次选择**角色**和**创建角色**。 1. 选择 **SAML 2.0 federation** 角色类型。 1. 对于 **Select a SAML provider**（选择 SAML 提供商），请为您的角色选择提供商。 1. 选择 SAML 2.0 访问级别方法。 + 选择 **Allow programmatic access only (只允许编程访问)** 以创建可从 AWS API 或 AWS CLI 以编程方式担任的角色。 + 选择**允许编程访问和 AWS 管理控制台访问**以创建可以编程方式和从 AWS 管理控制台中担任的角色。通过这两种方法创建的角色类似，但也可从控制台担任的角色包括包含带特定条件的信任策略。该条件可以显式的方式确保将 SAML 受众（`SAML:aud` 属性）设置为 SAML 提供商的 AWS 登录端点。 1. 定义属性的过程因访问权限类型而异。 + 如果创建用于编程访问的角色，请从**属性**列表中选择一个属性。然后在 **Value**（值）框中，键入一个将包含在角色中的值。这样可仅限来自其 SAML 身份验证响应 (断言) 包括您指定的属性的身份提供程序的用户可访问该角色。必须指定至少一个属性，以确保您的角色限于您所在组织中的一部分用户。 + 如果您要为编程和 AWS 管理控制台访问权限创建角色，则**登录端点**部分会定义在登录控制台时浏览器显示的 URL。此端点是您的身份提供者的 SAML 收件人属性，它映射到 [`saml:aud`](reference_policies_iam-condition-keys.md#condition-keys-saml) 上下文键。有关更多信息，请参阅 [为身份验证响应配置 SAML 断言。](id_roles_providers_create_saml_assertions.md)。 1. 选择**区域端点**或**非区域端点**。我们建议使用多个区域 SAML 登录端点来提高联合身份验证的韧性。 1. 对于**区域**，请选择您的 SAML 提供商支持 AWS 登录的区域。 1. 要使**登录 URL 包含唯一标识符**，请选择登录端点是否包含 AWS 分配给 SAML 身份提供者的唯一标识符。对于加密的 SAML 断言，此选项为必选项。有关更多信息，请参阅 [SAML 2.0 联合身份验证](id_roles_providers_saml.md)。 1. 要将更多与属性相关的条件添加到信任策略，请选择 **Condition (optional)** [条件（可选）]，选择其他条件，然后指定值。 **注意** 列表包括最常用的 SAML 属性。IAM 支持其他可用于创建条件的属性。有关支持的属性的列表，请参阅 [SAML 联合身份验证的可用键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-saml)。如果需要不在列表中的支持的 SAML 属性的条件，可以手动添加此条件。为此，请在创建角色后编辑信任策略。 1. 检查 SAML 2.0 信任信息，然后选择 **Next**（下一步）。 1. IAM 包括您的账户中的 AWS 托管策略和客户托管策略的列表。选择要用于权限策略的策略，或者选择 **Create policy**（创建策略）以打开新的浏览器选项卡并从头开始创建新策略。有关更多信息，请参阅 [创建 IAM 策略](access_policies_create-console.md#access_policies_create-start)。在您创建策略后，关闭该选项卡并返回到您的原始选项卡。选择您希望 SAML 联合用户具有的权限策略旁边的复选框。如果您愿意，此时可以不选择任何策略，稍后将策略附加到角色。默认情况下，角色没有权限。 1. （可选）设置[权限边界](access_policies_boundaries.md)。这是一项高级功能。打开 **Permissions boundary**（权限边界）部分，然后选择 **Use a permissions boundary to control the maximum role permissions**（使用权限边界控制最大角色权限）。选择要用于权限边界的策略。 1. 选择**下一步**。 1. 选择**下一步：审核**。 1. 对于 **Role name**（角色名称），输入一个角色名称。角色名称在您的 AWS 账户内必须是唯一的。名称不区分大小写。例如，您无法同时创建名为 **PRODROLE** 和 **prodrole** 的角色。由于其他 AWS 资源可能引用该角色，角色创建完毕后无法编辑角色名称。 1. （可选）对于 **Description**（描述），输入新角色的描述。 1. 在 **Step 1: Select trusted entities**（步骤 1：选择可信实体）或 **Step 2: Add permissions**（步骤 2：添加权限）部分中的 **Edit**（编辑），以编辑角色的用户案例和权限。 1. （可选）通过以键值对的形式附加标签来向角色添加元数据。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。创建角色后，通过使用有关 AWS 的信息来配置您的身份提供程序软件，以完成 SAML 信任。此类信息包括您希望 SAML 联合用户使用的角色。这称为在 IdP 和 AWS 之间配置信赖方信任。有关更多信息，请参阅 [配置具有依赖方信任的 SAML 2.0 IdP 并添加陈述](id_roles_providers_create_saml_relying-party.md)。 # 使用自定义信任策略创建角色您可以创建自定义信任策略来委派访问权限并允许其他人在您的 AWS 账户中执行操作。有关更多信息，请参阅 [创建 IAM 策略](access_policies_create-console.md#access_policies_create-start)。有关如何使用角色委派权限的信息，请参阅[角色术语和概念](id_roles.md#id_roles_terms-and-concepts)。 ## 使用自定义信任策略创建 IAM 角色（控制台）您可以使用 AWS 管理控制台创建 IAM 用户可担任的角色。例如，假设贵组织拥有多个 AWS 账户以便将开发环境与生产环境隔离。有关创建角色（该角色允许开发账户中的用户访问生产账户中的资源）的概述信息，请参阅 [使用不同的开发和生产账户的示例方案](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example)。 **使用自定义信任策略创建角色（控制台）** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在控制台的导航窗格中，选择 **Roles**，然后选择 **Create role**。 1. 选择 **Custom trust policy**（自定义信任策略）角色类型。 1. 在 **Custom trust policy**（自定义信任策略）部分，输入或粘贴角色的自定义信任策略。有关更多信息，请参阅 [创建 IAM 策略](access_policies_create-console.md#access_policies_create-start)。 1. 解决[策略验证](access_policies_policy-validator.md)过程中生成的任何安全警告、错误或常规警告，然后选择 **Next**（下一步）。 1. （可选）设置[权限边界](access_policies_boundaries.md)。这是一项高级功能，可用于服务角色，但不可用于服务相关角色。打开 **Permissions boundary**（权限边界）部分，然后选择 **Use a permissions boundary to control the maximum role permissions**（使用权限边界控制最大角色权限）。IAM 包括您的账户中的 AWS 托管策略和客户托管策略的列表。选择要用于权限边界的策略。 1. 选择**下一步**。 1. 对于**角色名称**，角色名称自定义的程度由服务定义。如果服务定义角色的名称，则此选项不可编辑。在其他情况下，服务可能定义角色的前缀并允许您键入可选的后缀。某些服务允许您指定角色的整个名称。如果可能，输入角色名称或角色名称后缀。角色名称在您的 AWS 账户内必须是唯一的。名称不区分大小写。例如，您无法同时创建名为 **PRODROLE** 和 **prodrole** 的角色。由于其他 AWS 资源可能引用该角色，角色创建完毕后无法编辑角色名称。 1. （可选）对于 **Description**（描述），输入新角色的描述。 1. （可选）在**步骤 1：选择受信任的实体**或**步骤 2：添加权限**部分中选择**编辑**，以编辑角色的自定义策略和权限。 1. （可选）通过以键值对的形式附加标签来向角色添加元数据。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。 # 委派访问权限的策略示例以下示例演示了如何允许或授权 AWS 账户访问其他 AWS 账户中的资源。要了解如何使用这些示例 JSON 策略文档创建 IAM policy，请参阅。[使用 JSON 编辑器创建策略](access_policies_create-console.md#access_policies_create-json-editor) **Topics** + [使用角色委托针对其他 AWS 账户资源的访问权限](#example-delegate-xaccount-rolesapi) + [使用策略将访问权限委托给服务](#id_roles_create_policy-examples-access-to-services) + [使用基于资源的策略委托访问另一个账户的 Amazon S3 存储桶](#example-delegate-xaccount-S3) + [使用基于资源的策略委托针对另一个账户中的 Amazon SQS 队列的访问权限](#example-delegate-xaccount-SQS) + [当拒绝访问账户时，不得委托访问](#example-delegate-xaccount-SQS-denied) ## 使用角色委托针对其他 AWS 账户资源的访问权限有关介绍如何使用 IAM 角色对一个账户中的用户授权以访问另一个账户中 AWS 资源的教程，请参阅 [IAM 教程：使用 IAM 角色委托跨 AWS 账户的访问权限](tutorial_cross-account-with-roles.md)。 **重要** 您可以在角色信任策略的 `Principal` 元素中包含特定角色或用户的 ARN。保存策略时，AWS 将该 ARN 转换为唯一主体 ID。如果有人希望通过删除并重新创建角色或用户来提升特权，这样有助于减轻此类风险。您通常不会在控制台中看到这个 ID，因为显示信任策略时它还会反向转换为 ARN。但是，如果您删除角色或用户，这种关系即被打破。即使您重新创建用户或角色，策略也不再适用。因为与信任策略中存储的 ID 不匹配。在这种情况下，主体 ID 会显示在控制台中，因为 AWS 无法将其映射回 ARN。结果是，如果您删除并重新创建了信任策略的 `Principal` 元素所引用的用户或角色，您必须编辑角色，替换 ARN。当您保存策略时，它会转换为新的主体 ID。 ## 使用策略将访问权限委托给服务以下示例显示了一个可以附加到角色的策略。该策略可使两个服务 Amazon EMR 和 AWS Data Pipeline 担任此角色。然后，这些服务可执行由分配给该角色 (未显示) 的权限策略授权执行的任何任务。要指定多个服务主体，不用指定两个 `Service` 元素；您可以只使用一个该元素。实际上，您可以将一组多个服务主体作为单个 `Service` 元素的值。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "elasticmapreduce.amazonaws.com", "datapipeline.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ ## 使用基于资源的策略委托访问另一个账户的 Amazon S3 存储桶在此示例中，账户 A 使用基于资源的策略（一个 Amazon S3 [存储桶策略](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucketPolicies.html)）授权账户 B 针对账户 A 的 S3 存储桶的完全访问权限。然后，账户 B 创建一个 IAM 用户策略，向账户 B 中的一个用户授予针对账户 A 的存储桶的访问权限。账户 A 中的 S3 存储桶策略可能与以下策略类似。在此示例中，账户 A 的 S3 存储桶名为 *amzn-s3-demo-bucket*，账户 B 的账号为 111122223333。它在账户 B 中未指定任何单个用户或组，仅指定账户本身。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Sid": "AccountBAccess1", "Effect": "Allow", "Principal": {"AWS": "111122223333"}, "Action": "s3:*", "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } } ``` ------ 或者，账户 A 可使用 Amazon S3 [访问控制列表 (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3_ACLs_UsingACLs.html) 来授权账户 B 访问 S3 存储桶或某个存储桶内的单个对象。在这种情况下，唯一改变的是账户 A 授权访问账户 B 的方式。如此示例的下一个部分所述，账户 B 仍使用一个策略委托针对账户 B 中的 IAM 组的访问权限。有关控制对 S3 存储桶和对象访问的更多信息，请转到 *Amazon Simple Storage Service 用户指南*中的[访问控制](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html)。账户 B 的管理员可能创建以下策略示例。该策略向账户 B 中的组或用户授予读取访问权限。前一策略向账户 B 授予访问权限。但是，除非组或用户策略显式授予资源访问权限，否则账户 B 中的单个组和用户不能访问资源。此策略中的权限只能是上述跨账户策略中的权限的一个子集。相比于账户 A 在第一个策略中授予账户 B 的权限，账户 B 无法向其组和用户授予更多权限。在该策略中，将显式定义 `Action` 元素以仅允许 `List` 操作，而且该策略的 `Resource` 元素与由账户 A 执行的存储桶策略的 `Resource` 匹配。为执行该策略，账户 B 使用 IAM 将它附加到账户 B 中的相应用户（或组）。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "s3:List*", "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } } ``` ------ ## 使用基于资源的策略委托针对另一个账户中的 Amazon SQS 队列的访问权限在以下示例中，账户 A 有一个 Amazon SQS 队列，该队列使用附加到该队列的基于资源的策略向账户 B 授权队列访问权限。然后，账户 B 使用 IAM 组策略委托针对账户 B 中的组的访问权限。以下示例队列策略授予账户 B 对名为执行 *queue1* 的账户 A 的队列执行 `SendMessage`和 `ReceiveMessage` 操作的权限，但只在 2014 年 11 月 30 日中午至下午 3:00 之间可行。Account B 的账号为 1111-2222-3333。账户 A 使用 Amazon SQS 执行该策略。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": {"AWS": "111122223333"}, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": ["arn:aws:sqs:*:123456789012:queue1"], "Condition": { "DateGreaterThan": {"aws:CurrentTime": "2014-11-30T12:00Z"}, "DateLessThan": {"aws:CurrentTime": "2014-11-30T15:00Z"} } } } ``` ------ 账户 B 向账户 B 中的组委托访问权限的策略可能类似于以下示例。账户 B 使用 IAM 将此策略附加到组（或用户）。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:123456789012:queue1" } } ``` ------ 在前述 IAM 用户策略示例中，账户 B 使用通配符授权其用户访问针对账户 A 的队列的所有 Amazon SQS 操作。但是账户 B 可委托的范围仅限于账户 B 被授权访问的范围。拥有第二个策略的账户 B 组只能在 2014 年 11 月 30 日中午至下午 3:00 之间访问该队列。根据账户 A 的 Amazon SQS 队列策略的定义，用户只能执行 `SendMessage` 和 `ReceiveMessage` 操作。 ## 当拒绝访问账户时，不得委托访问如果其他账户已显式拒绝访问用户的父账户，则 AWS 账户不得委托针对该账户的资源的访问权限。此“拒绝”将传播到该账户内的所有用户，无论用户的现有策略是否授予这些用户访问权限。例如，账户 A 编写了一个针对其账户中 S3 存储桶的存储桶策略，其中显式拒绝了账户 B 访问账户 A 的存储桶。但账户 B 编写了一个 IAM 用户策略，其中对账户 B 中的一个用户授予了对账户 A 的存储桶的访问权限。应用于账户 A 的 S3 存储桶的“显式拒绝”将传播到账户 B 中的用户。它会覆盖用于对账户 B 中用户授予访问权限的 IAM 用户策略。(有关如何计算权限的详细信息，请参阅 [策略评估逻辑](reference_policies_evaluation-logic.md)。) Account A 的存储段策略可能与下列策略类似。在此示例中，账户 A 的 S3 存储桶名为 *amzn-s3-demo-bucket*，账户 B 的账号为 1111-2222-3333。账户 A 使用 Amazon S3 执行该策略。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Sid": "AccountBDeny", "Effect": "Deny", "Principal": {"AWS": "111122223333"}, "Action": "s3:*", "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } } ``` ------ 此“显式拒绝”将覆盖账户 B 中所有提供账户 A 中 S3 存储桶访问权限的策略。 # IAM 角色管理您必须先对用户授予切换到您创建的角色的权限，然后用户、应用程序或服务才能使用该角色。您可使用附加到组或用户的任何策略授予所需权限。本部分描述如何授予用户使用角色的权限。它还解释了用户如何从 AWS 管理控制台、Tools for Windows PowerShell、AWS Command Line Interface (AWS CLI) 和 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 切换到角色。 **重要** 当您以编程方式而不是在 IAM 控制台中创建角色，则除最长可达 64 个字符的 `RoleName` 外，您还可以选择添加最长 512 个字符的 `Path`。不过，如果您打算通过 AWS 管理控制台中的 **Switch Role**（切换角色）功能使用角色，则组合的 `Path` 和 `RoleName` 不能超过 64 个字符。 **Topics** + [查看角色访问](#roles-modify_prerequisites) + [基于访问信息生成策略](#roles-modify_gen-policy) + [向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md) + [向用户授予权限以将角色传递给 AWS 服务](id_roles_use_passrole.md) + [撤销 IAM 角色临时安全凭证](id_roles_use_revoke-sessions.md) + [更新服务相关角色](id_roles_update-service-linked-role.md) + [更新角色信任策略](id_roles_update-role-trust-policy.md) + [更新角色的权限](id_roles_update-role-permissions.md) + [更新角色的设置](id_roles_update-role-settings.md) + [删除角色或实例配置文件](id_roles_manage_delete.md) ## 查看角色访问在更改角色的权限之前，您应查看其最近的服务级别活动。这非常重要，因为您不想删除使用它的主体（个人或应用程序）的访问权限。有关查看上次访问的信息的更多信息，请参阅 [使用上次访问的信息优化 AWS 中的权限](access_policies_last-accessed.md)。 ## 基于访问信息生成策略有时，您可能会向 IAM 实体（用户或角色）授予超出其需要的权限。为帮助您优化授予的权限，您可以根据实体的访问活动生成 IAM policy。IAM 访问分析器会查看您的 AWS CloudTrail 日志并生成一个策略模板，其中包含实体在指定日期范围内使用的权限。您可以使用模板创建具有精细权限的托管策略，然后将其附加到 IAM 实体。这样，您仅需授予用户或角色与特定使用案例中的 AWS 资源进行交互所需的权限。要了解更多信息，请参阅 [IAM Acess Analyzer 策略生成](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html)。 # 向用户授予切换角色的权限当管理员[创建用于跨账户存取的角色](id_roles_create_for-user.md)时，您在拥有角色和资源的账户（信任账户）和包含用户的账户（可信账户）之间建立了信任。为此，信任账户的管理员指定可信账号为角色的信任策略中的 `Principal`。这*可能*会允许可信账户中的任何用户担任该角色。要完成配置，可信账户的管理员必须为该账户中的特定组或用户提供切换到该角色的权限。 **要授予切换到角色的权限** 1. 作为可信账户的管理员，请为用户创建新策略，或编辑现有策略以添加所需元素。有关更多信息，请参阅 [创建或编辑策略](#roles-usingrole-createpolicy)。 1. 然后，选择您希望如何分享角色信息： + 角色链接：****向用户发送链接，以使用户进入已填写所有详细信息的 **Switch Role**（切换角色）页面。 + 账户 ID 或别名：****为每位用户提供角色名称以及账户 ID 号或账户别名。用户随后转到 **Switch Role** 页面，然后手动添加详细信息。有关更多信息，请参阅 [向用户提供信息](#roles-usingrole-giveuser)。请注意，仅当您以 IAM 用户、SAML 联合角色或 web 身份联合角色登录时才能切换角色。如果您以 AWS 账户根用户身份登录，则无法切换角色。 **重要** 您无法将 AWS 管理控制台中的角色切换到需要 [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) 值的角色。您只能通过调用支持 `ExternalId` 参数的 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 来切换到此类角色。 **备注** 本主题讨论了用户**的策略，因为您最终会向用户授予完成任务的权限。但是，我们建议您不要向单个用户直接授予权限。当用户担任某个角色时，系统会为他们分配与该角色相关的权限。当您在 AWS 管理控制台中切换角色时，控制台总是使用您的原始凭证对切换操作进行授权。无论您作为 IAM 用户、SAML 联合角色还是 Web 联合身份角色登录，上述情形均适用。例如，如果您切换到角色 A，则 IAM 使用您的原始用户或联合角色凭证确定是否允许您担任角色 A。如果您在*使用 RoleA 时*尝试切换到 RoleB，则会使用您的**原始**用户或联合角色凭证对您的尝试进行授权。RoleA 凭证不用于此操作。 **Topics** + [创建或编辑策略](#roles-usingrole-createpolicy) + [向用户提供信息](#roles-usingrole-giveuser) ## 创建或编辑策略向用户授予担任角色权限的策略必须包括一个语句，该语句对以下项具有 `Allow` 影响： + `sts:AssumeRole` 操作 + `Resource` 元素中该角色的 Amazon Resource Name (ARN) 获得了该策略（通过组成员资格或直接附加）的用户可以切换所列资源上的角色。 **注意** 如果将 `Resource` 设置为 `*`，则用户可在信任用户账户的任何账户中担任何角色。（换言之，角色的信任策略将用户的账户指定为 `Principal`）。作为最佳实践，我们建议您遵循[最低权限原则](http://en.wikipedia.org/wiki/Principle_of_least_privilege)并仅为用户所需的角色指定完整的 ARN。以下示例所显示的策略允许用户仅在一个账户中担任角色。此外，该策略使用通配符 (\$1) 来指定用户仅在角色名称以字母 `Test` 开头时才能切换到该角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/Test*" } } ``` ------ **注意** 角色向用户授予的权限不会添加到用户已获得的权限。当用户切换到某个角色时，用户可临时放弃其原始权限以换取由该角色授予的权限。用户退出该角色时，将自动恢复原始用户权限。例如，假如用户的权限允许使用 Amazon EC2 实例，但是角色的权限策略未授予这些权限。在这种情况下，使用角色时，用户无法在控制台中使用 Amazon EC2 实例。此外，通过 `AssumeRole` 获取的临时凭证无法以编程方式使用 Amazon EC2 实例。 ## 向用户提供信息创建角色并向用户授予切换为该角色的权限后，您必须为用户提供以下信息： + 角色的名称。 + 包含该角色的 ID 或账户别名通过向用户发送使用账户 ID 和角色名称预配置的链接，可为用户简化访问。完成**创建角色**向导后，您可以选择**查看角色**横幅，或在任何已启用跨账户角色的**角色摘要**页面上查看角色链接。您还可使用以下格式手动构建链接。请用您的账户 ID 或别名及角色名称替换以下示例中的两个参数： `https://signin.aws.amazon.com/switchrole?account=your_account_ID_or_alias&roleName=optional_path/role_name` 我们建议您将用户定向到 [从用户切换到 IAM 角色（控制台）](id_roles_use_switch-role-console.md) 以指导他们完成该过程。要排除您在担任角色时可能遇到的常见问题，请参阅 [我无法代入角色](troubleshoot_roles.md#troubleshoot_roles_cant-assume-role)。 **注意事项** + 如果您以编程方式创建角色，则可使用路径以及名称创建角色。如果执行此操作，则必须向用户提供完整的路径和角色名称，以便他们可以在 AWS 管理控制台的 **Switch Role**（切换角色）页面输入该角色。例如：`division_abc/subdivision_efg/role_XYZ`。 + 如果您以编程方式创建角色，则您可以添加最长 512 个字符的 `Path` 以及 `RoleName`。角色名称最多可以有 64 个字符。但是，要通过 AWS 管理控制台中的**切换角色**功能使用角色，则组合的 `Path` 和 `RoleName` 不能超过 64 个字符。 + 为了安全起见，您可以[查看 AWS CloudTrail 日志](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds)以了解已在 AWS 中执行操作的人员。您可以在角色信任策略中使用 `sts:SourceIdentity` 条件键，以要求用户在代入角色时指定身份。例如，您可以要求 IAM 用户指定自己的用户名作为其源身份。这可以帮助您确定哪个用户在 AWS 中执行了具体的操作。有关更多信息，请参阅 [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity)。您可以使用 [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname)，以要求用户在代入角色时指定会话名称。这可以帮助您在不同主体使用角色时区分角色会话。 # 向用户授予权限以将角色传递给 AWS 服务要配置多项 AWS 服务，您必须将 IAM 角色*传递*给相应服务。这允许该服务稍后代入该角色并代表您执行操作。对于大多数服务，您只需在设置期间（而不是服务每次代入角色时）将角色传递给服务。例如，假定您的一款应用程序在 Amazon EC2 实例上运行。该应用程序需要临时凭证来进行身份验证，以及授权应用程序在 AWS 中执行操作的权限。在设置该应用程序时，您必须将角色传递给 Amazon EC2，以便与提供这些凭证的实例一起使用。通过向角色附加 IAM policy，您为在实例上运行的应用程序定义权限。该应用程序每次需要执行角色允许的操作时都会担任该角色。要将角色（及其权限）传递至 AWS 服务，用户必须具有*传递角色* 至服务的权限。这有助于管理员确保仅批准的用户可配置具有能够授予权限的角色的服务。要允许用户将角色传递至 AWS 服务，您必须向用户的 IAM 用户、角色或组授予 `PassRole` 权限。 **警告** 只能使用 `PassRole` 权限将 IAM 角色传递给使用同一 AWS 账户的服务。要将账户 A 中的角色传递给账户 B 中的服务，必须首先在账户 B 中创建一个可以代入账户 A 中角色的 IAM 角色，然后才能将账户 B 中的角色传递给该服务。有关更多信息，请参阅 [IAM 中的跨账户资源访问](access_policies-cross-account-resource-access.md)。请勿试图通过标记角色然后在带有 `iam:PassRole` 操作的策略中使用 `ResourceTag` 条件键来控制谁可以传递角色。这种方法没有可靠的结果。设置 `PassRole` 权限时，应确保用户所传递角色的权限不会超过您希望该用户拥有的权限。例如，可能不允许 Alice 执行任何 Amazon S3 操作。如果 Alice 可以将角色传递给允许 Amazon S3 操作的服务，则该服务可以在执行作业时代表 Alice 执行 Amazon S3 操作。在指定服务相关角色时，您还必须拥有将该角色传递给服务的权限。在某些服务中执行操作时，该服务自动在您的账户中创建一个服务相关角色。例如，在首次创建自动扩缩组时，Amazon EC2 Auto Scaling 会为您创建 `AWSServiceRoleForAutoScaling` 服务相关角色。如果您在创建自动扩缩组时尝试指定服务相关角色，但您没有 `iam:PassRole` 权限，则会收到错误。如果您没有明确指定角色，则不需要 `iam:PassRole` 权限，默认情况下，对该组执行的所有操作都使用 `AWSServiceRoleForAutoScaling` 角色。要了解哪些服务支持服务相关角色，请参阅[使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)。要了解在哪些服务中执行操作时自动创建服务相关角色，请选择**是**链接并查看该服务的服务相关角色文档。在任何使用角色分配服务权限的 API 操作中，用户都可以将角色 ARN 作为参数进行传递。该服务随后检查该用户是否拥有 `iam:PassRole` 权限。要限制用户只传递批准的角色，您可以使用 IAM policy 语句的 `iam:PassRole` 元素筛选 `Resources` 权限。您可以在 JSON 策略中使用 `Condition` 元素来测试所有 AWS 请求的请求上下文中所包含键的值。要了解有关在策略中使用条件键的更多信息，请参阅 [IAM JSON 策略元素：Condition](reference_policies_elements_condition.md)。`iam:PassedToService` 条件键可用于指定可将角色传递到的服务的服务主体。要了解有关在策略中使用 `iam:PassedToService` 条件键的更多信息，请参阅 [iam:PassedToService](reference_policies_iam-condition-keys.md#ck_PassedToService)。 **示例 1** 假设您要授予用户在启动实例时能够将任意批准角色组传递至 Amazon EC2 服务的能力。您需要三个部分： + IAM *权限策略*附加到确定角色可执行哪些任务的角色。将权限范围限定为仅角色必须执行的操作，以及角色进行这些操作所需的资源。您可以使用 AWS 托管的或客户创建的 IAM 权限策略。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": [ "A list of the permissions the role is allowed to use" ], "Resource": [ "A list of the resources the role is allowed to access" ] } } ``` ------ + 允许服务担任角色的*信任策略*。例如，您可以将以下信任策略与具有 `UpdateAssumeRolePolicy` 操作的角色进行附加。该信任策略允许 Amazon EC2 使用角色和附加在角色上的权限。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Sid": "TrustPolicyStatementThatAllowsEC2ServiceToAssumeTheAttachedRole", "Effect": "Allow", "Principal": { "Service": "ec2.amazonaws.com" }, "Action": "sts:AssumeRole" } } ``` ------ + 附加至 IAM 用户的 IAM *permissions policy*（权限策略），允许该用户仅传递已获批准的那些策略。您通常将 `iam:GetRole` 添加至 `iam:PassRole`，使用户能够获取准备进行传递的角色的详细信息。在此示例中，用户只能传递位于指定账户中并且名称以 `EC2-roles-for-XYZ-` 开头的角色： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:GetRole", "iam:PassRole" ], "Resource": "arn:aws:iam::111122223333:role/EC2-roles-for-XYZ-*" } ] } ``` ------ 现在用户可以启动具有所分配角色的 Amazon EC2 实例。实例上运行的应用程序可以通过实例配置文件元数据访问角色的临时许可。附加到角色的许可策略确定实例可以执行的任务。 **示例 2** Amazon Relational Database Service (Amazon RDS) 支持名为 **Enhanced Monitoring**（增强监控）的功能。此功能使 Amazon RDS 能够使用代理监控数据库实例。它还允许 Amazon RDS 将指标记录到 Amazon CloudWatch Logs 中。要启用此功能，您必须创建一个服务角色，以便为 Amazon RDS 提供监控指标和将指标写入日志的权限。 **为 Amazon RDS 增强监控创建角色** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 选择 **角色**，然后选择 **创建角色**。 1. 选择 **AWS 服务**角色类型，然后在**适用于其他 AWS 服务的使用案例**中，选择 **RDS** 服务。选择 **RDS - Enhanced Monitoring**（RDS - 增强监控），然后选择 **Next**（下一步）。 1. 选择 **AmazonRDSEnhancedMonitoringRole** 权限策略。 1. 选择**下一步**。 1. 对于 **Role name**（角色名称），键入有助于标识此角色作用的角色名称。角色名称在您的 AWS 账户内必须是唯一的。在策略中使用角色名称或将其作为 ARN 的一部分时，角色名称区分大小写。在控制台中向客户显示角色名称时（例如在登录过程中），角色名称不区分大小写。由于多个实体可能引用该角色，因此，角色创建完毕后，您将无法编辑角色名称。 1. （可选）对于 **Description**（描述），输入新角色的描述。 1. （可选）通过以键值对的形式附加标签来向用户添加元数据。有关在 IAM 中使用标签的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。 1. 检查角色，然后选择**创建角色**。角色自动获得授予 `monitoring.rds.amazonaws.com` 服务担任角色权限的信任策略。在此之后，Amazon RDS 可执行 `AmazonRDSEnhancedMonitoringRole` 策略允许的所有操作。您希望使用增强监控的用户需要包括允许用户列出 RDS 角色的语句和允许用户传递角色的语句的策略，如下所示。使用您的账号，然后使用您在步骤 6 中提供的名称替换角色名称。 ``` { "Sid": "PolicyStatementToAllowUserToListRoles", "Effect": "Allow", "Action": ["iam:ListRoles"], "Resource": "*" }, { "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole", "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": "arn:aws:iam::account-id:role/RDS-Monitoring-Role" } ``` 您可以将该语句与另一策略中的语句进行合并，或将此语句放在其自身策略中。如要指定用户可传递以 `RDS-` 开始的任何角色，您可以在资源 ARN 中使用通配符替换角色名称，如下所示。 ``` "Resource": "arn:aws:iam::account-id:role/RDS-*" ``` ## AWS CloudTrail 日志中的 `iam:PassRole` 操作 `PassRole` 不是 API 调用。`PassRole` 是一种权限，意味着不会为 IAM `PassRole` 生成 CloudTrail 日志。要查看向 CloudTrail 中的哪个 AWS 服务传递了哪些角色，您必须查看创建或修改接收相应角色的 AWS 资源的 CloudTrail 日志。例如，角色在创建时会传递给 AWS Lambda 函数。`CreateFunction` 操作的日志显示了传递给该函数的角色记录。 # 撤销 IAM 角色临时安全凭证 **警告** 如果您执行此页面上的步骤，则通过担任角色创建的具有当前会话的所有用户对所有 AWS 操作和资源的访问将被拒绝。这会导致用户丢失未保存的工作。在允许用户访问具有较长的会话持续时间（例如 12 小时）的 AWS 管理控制台时，用户的临时凭证不会很快过期。如果用户无意中向未授权第三方公开其凭证，则第三方在会话的持续时间内将具有访问权限。不过，如果需要，可以撤销对某个特定时间点之前发布的角色凭证的所有权限。指定时间之前发布的该角色的所有临时凭证将变得无效。这将强制所有用户重新进行身份验证并请求新的凭证。 **注意** 您无法撤销*[服务相关角色](id_roles.md#iam-term-service-linked-role)*对会话的权限。在使用本主题中的过程撤消角色的权限时，AWS 会向角色附加新的内联策略来拒绝对所有操作的所有权限。它包括仅当用户在撤销权限时的某个时间点*之前* 代入角色的情况下应用限制的情况。如果用户在您撤销权限*之后* 代入角色，则拒绝策略不适用于该用户。有关拒绝访问的更多信息，请参阅 [禁用临时安全凭证的权限](id_credentials_temp_control-access_disable-perms.md)。 **重要** 此拒绝策略适用于指定角色的所有用户，而不只是适用于具有持续时间更长的控制台会话的用户。 ## 从角色撤消会话权限所需的最低权限要从角色成功撤消会话权限，您必须具有该角色的 `PutRolePolicy` 权限。这允许您将 `AWSRevokeOlderSessions` 内联策略附加到该角色。 ## 撤消会话权限您可以撤消某个角色的会话权限，以拒绝代入该角色的任何用户的所有权限。 **注意** 您不能编辑 IAM 中根据 IAM Identity Center 权限集创建的角色。您必须在 IAM Identity Center 中撤消用户的活动权限集会话。有关更多信息，请参阅《*IAM Identity Center 用户指南*》中的[撤消由权限集创建的活动 IAM 角色会话](https://docs.aws.amazon.com/singlesignon/latest/userguide/useraccess.html#revoke-user-permissions)。 **立即拒绝对角色凭证的任何当前用户的所有权限** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在导航窗格中，选择**角色**，然后选择要撤消其权限的角色的名称（而不是复选框）。 1. 在所选角色的 **Summary** 页面上，选择 **Revoke sessions** 选项卡。 1. 在 **Revoke sessions** 选项卡上，选择 **Revoke active sessions**。 1. AWS 要求您确认此操作。选择**我确认我正在撤消此角色的所有活动会话。**复选框，然后在对话框中选择**撤消活动会话**。然后 IAM 会将名为 `AWSRevokeOlderSessions` 的策略附加到角色。选择**撤消活动会话**后，此策略将拒绝在过去已经以及未来大约 30 秒钟将会代入该角色的用户的所有访问权限。此未来时间选项考虑了策略的传播延迟，以便处理在更新后的策略在给定区域生效之前获得或续订的新会话。任何在您选择“撤消活动会话”之后超过大约 30 秒代入角色的用户均不受影响。要了解为什么更改并非始终立即可见，请参阅 [我所做的更改可能不会立即可见](troubleshoot.md#troubleshoot_general_eventual-consistency)。 **注意** 如果您稍后再次选择**撤消活动会话**，则将刷新策略中的日期和时间戳，并将再次拒绝在新的指定时间之前代入角色的任何用户的所有访问权限。以这种方式调用会话的有效用户必须获得临时凭证，新会话才能继续工作。在凭证过期前，AWS CLI 会缓存凭证。要强制 CLI 删除并刷新已失效的缓存证书，请运行以下命令之一： **Linux、macOS 或 Unix** ``` $ rm -r ~/.aws/cli/cache ``` **Windows** ``` C:\> del /s /q %UserProfile%\.aws\cli\cache ``` ## 在指定时间之前撤消会话权限您也可以使用 AWS CLI 或 SDK 在策略的 Condition 元素中指定 `aws:TokenIssueTime` 键的值，随时撤消会话权限。当 `aws:TokenIssueTime` 的值早于指定的日期和时间时，该策略会拒绝所有权限。`aws:TokenIssueTime` 的值对应于临时安全凭证的确切创建时间。`aws:TokenIssueTime` 值仅存在于使用临时安全凭证签署的 AWS 请求的上下文中，因此，该策略中的 Deny 语句不会影响使用该 IAM 用户的长期凭证签署的请求。该策略还可以附加到角色。在这种情况下，该策略只会影响由该角色在指定日期和时间之前创建的临时安全凭证。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Deny", "Action": "*", "Resource": "*", "Condition": { "DateLessThan": {"aws:TokenIssueTime": "2014-05-07T23:47:00Z"} } } } ``` ------ 以这种方式调用会话的有效用户必须获得临时凭证，新会话才能继续工作。在凭证过期前，AWS CLI 会缓存凭证。要强制 CLI 删除并刷新已失效的缓存证书，请运行以下命令之一： **Linux、macOS 或 Unix** ``` $ rm -r ~/.aws/cli/cache ``` **Windows** ``` C:\> del /s /q %UserProfile%\.aws\cli\cache ``` # 更新服务相关角色您用来编辑服务相关角色的方法取决于服务。某些服务可能允许您从服务控制台、API 或 CLI 编辑服务相关角色的权限。但是，创建服务相关角色后，您将无法更改角色的名称，因为可能有多种实体引用该角色。您可以从 IAM 控制台、API 或 CLI 编辑任何角色的描述。有关哪些服务支持使用服务相关角色的信息，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md) 并查找其在**服务相关角色**列中为**是**的服务。要了解服务是否支持编辑服务相关角色，请选择 **Yes** 链接以查看该服务的服务相关角色文档。 ## 编辑服务相关角色描述（控制台）您可以使用 IAM 控制台编辑服务相关角色的描述。 **编辑服务相关角色的描述（控制台）** 1. 在 IAM 控制台的导航窗格中，选择**角色**。 1. 以下代码示例显示如何将 IAM 策略附加到用户。 1. 在 **Role description** 的最右侧，选择 **Edit**。 1. 在框中输入新描述，然后选择 **Save（保存）**。 ## 编辑服务相关角色描述 (AWS CLI) 您可以从 AWS CLI 使用 IAM 命令编辑服务相关角色的描述。 **更改服务相关角色描述 (AWS CLI)** 1. （可选）要查看角色的当前描述，请运行以下命令： ``` aws iam [get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) --role-name ROLE-NAME ``` 通过 CLI 命令使用角色名称（并非 ARN）指向角色。例如，如果某个角色的 ARN 为 `arn:aws:iam::123456789012:role/myrole`，则将该角色称为 **myrole**。 1. 要更新服务相关角色的描述，请运行以下命令： ``` aws iam [update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) --role-name ROLE-NAME --description OPTIONAL-DESCRIPTION ``` ## 编辑服务相关角色描述 (AWS API) 您可以使用 AWS API 编辑服务相关角色的描述。 **更改服务相关角色的描述 (AWS API)** 1. （可选）要查看角色的当前描述，请调用以下操作，并指定角色的名称： AWS API：[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 1. 要更新角色的描述，请调用以下操作，并指定角色的名称（和可选描述）： AWS API：[UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) # 更新角色信任策略要更改可担任角色的人员，您必须修改角色的信任策略。您无法修改*[服务相关角色](id_roles.md#iam-term-service-linked-role)*的信任策略。 **备注** 如果用户被列为角色的信任策略中的主体，但无法担任该角色，请检查用户的[权限边界](access_policies_boundaries.md)。如果为用户设置了权限边界，则它必须允许该 `sts:AssumeRole` 操作。要允许用户在角色会话中重新代入当前角色，请将角色 ARN 或 AWS 账户 ARN 指定为角色信任策略中的主体。提供计算资源（例如 Amazon EC2、Amazon ECS、Amazon EKS 和 Lambda）的 AWS 服务会提供临时凭证并自动更新这些凭证。这样可以确保您始终拥有一组有效的凭证。对于这些服务，无需重新代入当前角色即可获得临时凭证。但是，如果您需要传递 [会话标签](id_session-tags.md) 或者 [会话策略](access_policies.md#policies_session)，则需要重新代入当前角色。 ## 更新角色信任策略（控制台） **更改 AWS 管理控制台中的角色信任策略** 1. 登录 AWS 管理控制台，打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，选择**角色**。 1. 在您的账户的角色列表中，选择要修改的角色的名称。 1. 选择 **Trust relationships**（信任关系）选项卡，然后选择 **Edit trust policy**（编辑信任策略）。 1. 根据需要编辑信任策略。要添加其他可担任角色的主体，请在 `Principal` 元素中指定他们。例如，以下策略代码段演示如何在 `Principal` 元素中引用两个 AWS 账户： ``` "Principal": { "AWS": [ "arn:aws:iam::111122223333:root", "arn:aws:iam::444455556666:root" ] }, ``` 如果您指定其他账户中的主体，将账户添加到角色的信任策略只是建立跨账户信任关系工作的一半而已。默认情况下，受信任账户中的任何用户均无法担任角色。新的受信任账户的管理员必须授予用户担任角色的权限。为此，管理员必须创建或编辑附加到用户以允许该用户访问 `sts:AssumeRole` 操作的策略。有关更多信息，请参阅以下过程或[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。以下策略代码段演示如何在 `Principal` 元素中引用两个 AWS 服务： ``` "Principal": { "Service": [ "opsworks.amazonaws.com", "ec2.amazonaws.com" ] }, ``` 1. 在编辑完信任策略后，请选择 **Update policy**（更新策略）以保存所做更改。有关策略结构和语法的更多信息，请参阅[AWS Identity and Access Management 中的策略和权限](access_policies.md)和[IAM JSON 策略元素参考](reference_policies_elements.md)。 **允许可信外部账户中的用户使用角色（控制台）** 有关此过程的更多详细信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. 登录受信任外部 AWS 账户。 1. 确定将权限附加到用户还是附加到组。在 IAM 控制台的导航窗格中，相应选择 **Users**（用户）或 **User Groups**（用户组）。 1. 选择您要向其授予访问权限的用户或组的名称，然后选择 **Permissions** 选项卡。 1. 请执行以下操作之一： + 要编辑某个客户托管策略，请选择该策略的名称，选择**编辑策略**，然后选择 **JSON** 选项卡。您不能编辑 AWS 托管策略。AWS 托管策略随 AWS 图标 (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/policy_icon.png)) 一起显示。有关 AWS 托管策略与客户托管策略之间的差别的更多信息，请参阅[托管策略与内联策略](access_policies_managed-vs-inline.md)。 + 要编辑某个内联策略，请选择该策略名称旁边的箭头，然后选择 **Edit policy**。 1. 在策略编辑器中，添加一个新的 `Statement` 元素，指定以下内容： ``` { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::ACCOUNT-ID:role/ROLE-NAME" } ``` 将语句中的 ARN 替换为用户可担任的角色的 ARN。 1. 按照屏幕上的提示完成策略的编辑。 ## 更新角色信任策略（AWS CLI）您可以使用 AWS CLI 更改可担任角色的人员。 **修改角色信任策略 (AWS CLI)** 1. （可选）如果不知道要修改的角色的名称，请运行以下命令以列出账户中的角色： + [aws iam list-roles](https://docs.aws.amazon.com/cli/latest/reference/iam/list-roles.html) 1. （可选）要查看角色当前的信任策略，请运行以下命令： + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) 1. 要修改可访问角色的受信任主体，请创建带有已更新信任策略的文本文件。您可以使用任何文本编辑器构件策略。例如，以下信任策略说明了如何在 `Principal` 元素中引用两个 AWS 账户。这允许两个单独的 AWS 账户中的用户代入此角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::111122223333:root", "arn:aws:iam::444455556666:root" ]}, "Action": "sts:AssumeRole" } } ``` ------ 如果您指定其他账户中的主体，将账户添加到角色的信任策略只是建立跨账户信任关系工作的一半而已。默认情况下，受信任账户中的任何用户均无法担任角色。新的受信任账户的管理员必须授予用户担任角色的权限。为此，管理员必须创建或编辑附加到用户以允许该用户访问 `sts:AssumeRole` 操作的策略。有关更多信息，请参阅以下过程或[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. 要使用您刚刚创建的文件来更新信任策略，请运行以下命令： + [aws iam update-assume-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/update-assume-role-policy.html) **允许受信任外部账户中的用户使用角色 (AWS CLI)** 有关此过程的更多详细信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. 创建一个 JSON 文件，其中包含授予担任角色的权限的权限策略。例如，下面的策略包含最低必需权限： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME" } } ``` ------ 将语句中的 ARN 替换为用户可担任的角色的 ARN。 1. 运行以下命令来将包含信任策略的 JSON 文件上传到 IAM： + [aws iam create-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html) 此命令的输出包含策略的 ARN。请记录此 ARN，因为您在后面的步骤中需要它。 1. 决定要将策略附加到哪个用户或组。如果不知道目标用户或组的名称，请使用下列命令之一列出账户中的用户或组： + [aws iam list-users](https://docs.aws.amazon.com/cli/latest/reference/iam/list-users.html) + [aws iam list-groups](https://docs.aws.amazon.com/cli/latest/reference/iam/list-groups.html) 1. 使用以下命令之一，将您在上一步中创建的策略附加到用户或组： + [aws iam attach-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html) + [aws iam attach-group-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-group-policy.html) ## 更新角色信任策略（AWS API）您可以使用 AWS API 更改可担任角色的人员。 **修改角色信任策略 (AWS API)** 1. （可选）如果不知道要修改的角色的名称，请调用以下操作以列出账户中的角色： + [ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html) 1. （可选）要查看角色当前的信任策略，请调用以下操作： + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 1. 要修改可访问角色的受信任主体，请创建带有已更新信任策略的文本文件。您可以使用任何文本编辑器构件策略。例如，以下信任策略说明了如何在 `Principal` 元素中引用两个 AWS 账户。这允许两个单独的 AWS 账户中的用户代入此角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Principal": {"AWS": [ "arn:aws:iam::111122223333:root", "arn:aws:iam::444455556666:root" ]}, "Action": "sts:AssumeRole" } } ``` ------ 如果您指定其他账户中的主体，将账户添加到角色的信任策略只是建立跨账户信任关系工作的一半而已。默认情况下，受信任账户中的任何用户均无法担任角色。新的受信任账户的管理员必须授予用户担任角色的权限。为此，管理员必须创建或编辑附加到用户以允许该用户访问 `sts:AssumeRole` 操作的策略。有关更多信息，请参阅以下过程或[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. 要使用您刚刚创建的文件来更新信任策略，请调用以下操作： + [UpdateAssumeRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html) **允许可信外部账户中的用户使用角色 (AWS API)** 有关此过程的更多详细信息，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 1. 创建一个 JSON 文件，其中包含授予担任角色的权限的权限策略。例如，下面的策略包含最低必需权限： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME" } } ``` ------ 将语句中的 ARN 替换为用户可担任的角色的 ARN。 1. 调用以下操作来将包含信任策略的 JSON 文件上传到 IAM： + [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html) 此操作的输出包含策略的 ARN。请记录此 ARN，因为您在后面的步骤中需要它。 1. 决定要将策略附加到哪个用户或组。如果不知道目标用户或组的名称，请调用下列操作之一列出账户中的用户或组： + [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html) + [ListGroups](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroups.html) 1. 调用以下操作之一，将您在上一步中创建的策略附加到用户或组： + API：[AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html) + [AttachGroupPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html) # 更新角色的权限使用以下过程更新角色的权限策略和权限边界。 ## 先决条件：查看角色访问权限在更改角色的权限之前，您应查看其最近的服务级别活动。这非常重要，因为您不想删除使用它的主体（个人或应用程序）的访问权限。有关查看上次访问的信息的更多信息，请参阅 [使用上次访问的信息优化 AWS 中的权限](access_policies_last-accessed.md)。 ## 更新角色的权限策略要更改该角色允许的权限，请修改该角色的权限策略。您无法修改 IAM 中的*[服务相关角色](id_roles.md#iam-term-service-linked-role)*的权限策略。您可能能够修改依赖角色的服务中的权限策略。要检查服务是否支持此功能，请参阅[使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)并查找**服务相关角色**中列为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。 ### 更新角色权限策略（控制台） **更改角色允许的权限 (控制台)** 1. 通过 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。 1. 在 IAM 控制台的导航窗格中，选择**角色**。 1. 选择要修改的角色的名称，然后选择**权限**选项卡。 1. 请执行以下操作之一： + 要编辑某个现有客户托管策略，请选择该策略的名称，然后选择 **Edit policy**。 **注意** 您不能编辑 AWS 托管策略。AWS 托管策略随 AWS 图标 (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/policy_icon.png)) 一起显示。有关 AWS 托管策略与客户托管策略之间的差别的更多信息，请参阅[托管策略与内联策略](access_policies_managed-vs-inline.md)。 + 要将现有的托管策略附加到角色，请选择 **Add permissions**（添加权限），然后选择 **Attach policies**（附加策略）。 + 要编辑现有内联策略，请展开策略并选择 **Edit**（编辑）。 + 要嵌入新的内联策略，请选择 **Add permissions**（添加权限），然后选择 **Create inline policy**（创建内联策略）。 + 若要从角色中移除现有策略，请选中策略名称旁边的复选框，然后选择**删除**。 ### 更新角色权限策略（AWS CLI）要更改该角色允许的权限，请修改该角色的权限策略。您无法修改 IAM 中的*[服务相关角色](id_roles.md#iam-term-service-linked-role)*的权限策略。您可能能够修改依赖角色的服务中的权限策略。要检查服务是否支持此功能，请参阅[使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)并查找**服务相关角色**中列为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。 **更改角色允许的权限 (AWS CLI)** 1. （可选）如需查看当前与角色关联的权限，请运行以下命令： 1. [aws iam list-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-role-policies.html)（用于列出内联策略） 1. [aws iam list-attached-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-role-policies.html)（用于列出托管策略） 1. 对于更新角色的权限所使用的命令，根据您是在更新托管策略还是内联策略而有所不同。要更新托管策略，请运行以下命令以创建托管策略的新版本： + [aws iam create-policy-version](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy-version.html) 要更新内联策略，请运行以下命令： + [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) ### 更新角色权限策略（AWS API）要更改该角色允许的权限，请修改该角色的权限策略。您无法修改 IAM 中的*[服务相关角色](id_roles.md#iam-term-service-linked-role)*的权限策略。您可能能够修改依赖角色的服务中的权限策略。要检查服务是否支持此功能，请参阅[使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)并查找**服务相关角色**中列为**是**的服务。请选择**是**与查看该服务的服务关联角色文档的链接。 **更改角色允许的权限 (AWS API)** 1. （可选）如需查看当前与角色关联的权限，请调用以下操作： 1. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)（用于列出内联策略） 1. [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)（用于列出托管策略） 1. 对于更新角色的权限所使用的操作，根据您是在更新托管策略还是内联策略而有所不同。要更新托管策略，请调用以下操作以创建托管策略的新版本： + [CreatePolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicyVersion.html) 要更新内联策略，请调用以下操作： + [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html) ## 更新角色的权限边界要更改对某角色允许的最大权限，请修改角色的[权限边界](access_policies_boundaries.md)。 ### 更新角色权限边界（控制台） **更改用于设置角色的权限边界的策略** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在导航窗格中，选择**角色**。 1. 选择具有您要更改的 [权限边界](access_policies_boundaries.md) 的角色名称。 1. 选择**权限**选项卡。如有必要，打开 **Permissions boundary**（权限边界）部分，然后选择 **Change boundary**（更改边界）。 1. 选择要用于权限边界的策略。 1. 选择 **Change boundary**（更改边界）。在某个人下次担任该角色后，您所做的更改才会生效。 ### 更新角色权限边界（AWS CLI） **更改用于设置角色的权限边界的托管策略 (AWS CLI)** 1. （可选）要查看角色的当前[权限边界](access_policies_boundaries.md)，请运行以下命令： + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) 1. 要使用不同的托管策略来更新角色的权限边界，请运行以下命令： + [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) 角色只能具有一个设置为权限边界的托管策略。如果您更改权限边界，则会更改允许的角色的最大权限。 ### 更新角色权限边界（AWS API） **更改用于设置角色的权限边界的托管策略 (AWS API)** 1. （可选）要查看角色的当前[权限边界](access_policies_boundaries.md)，请调用以下操作： + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 1. 要使用不同的托管策略来更新角色的权限边界，请调用以下操作： + [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html) 角色只能具有一个设置为权限边界的托管策略。如果您更改权限边界，则会更改允许的角色的最大权限。 # 更新角色的设置使用以下过程更新角色的描述或更改角色的最长会话持续时间。 ## 更新角色描述要更改角色的描述，请修改描述文本。 ### 更新角色描述（控制台） **更改角色的描述 (控制台)** 1. 登录 AWS 管理控制台，打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，选择**角色**。 1. 以下代码示例显示如何将 IAM 策略附加到用户。 1. 在 **Summary**（摘要）部分中，选择 **Edit**（编辑）。 1. 在框中键入新描述，然后选择 **Save changes (保存更改)**。 ### 更新角色描述（AWS CLI） **更改角色的描述 (AWS CLI)** 1. （可选）要查看角色的当前描述，请运行以下命令： + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) 1. 要更新角色的描述，请带描述参数运行以下命令： + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) ### 更新角色描述（AWS API） **更改角色的描述 (AWS API)** 1. （可选）要查看角色当前的描述，请调用以下操作： + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 1. 要更新角色的描述，请带描述参数调用以下操作： + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) ## 更新角色的最长会话持续时间要为使用控制台、AWS CLI 或 AWS API 代入的角色指定最大会话持续时间设置，请修改最大会话持续时间设置值。该设置可以具有 1 小时到 12 小时之间的值。如果未指定值，则应用默认最大值 (1 小时)。该设置不限制 AWS 服务建立的会话。 ### 更新最长角色会话持续时间（控制台） **更改使用控制台、AWS CLI 或 AWS API 担任的角色的最大会话持续时间设置（控制台）** 1. 登录 AWS 管理控制台，打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在 IAM 控制台的导航窗格中，选择**角色**。 1. 以下代码示例显示如何将 IAM 策略附加到用户。 1. 在 **Summary**（摘要）部分中，选择 **Edit**（编辑）。 1. 对于 **Maximum session duration**（最大会话持续时间），请选择一个值。您还可以选择 **Custom duration**（自定义持续时间）并输入一个值（以秒为单位）。 1. 选择**保存更改**。在某个人下次担任该角色后，您所做的更改才会生效。要了解如何撤销该角色的现有会话，请参阅[撤销 IAM 角色临时安全凭证](id_roles_use_revoke-sessions.md)。在预设情况下，在 AWS 管理控制台中的 IAM 用户会话为 12 小时。在控制台内切换角色的 IAM 用户被授予角色最大会话持续时间或用户会话中的剩余时间（以较少者为准）。从 AWS CLI 或 AWS API 代入角色的任何人都可以请求更长的会话，最多达到这个最大值。`MaxSessionDuration` 设置确定可请求的最大角色会话的持续时间。 + 要使用 AWS CLI 指定会话持续时间，请使用 `duration-seconds` 参数。要了解更多信息，请参阅[切换到 IAM 角色（AWS CLI）](id_roles_use_switch-role-cli.md)。 + 要使用 AWS API 指定会话持续时间，请使用 `DurationSeconds` 参数。要了解更多信息，请参阅[切换到 IAM 角色（AWS API）](id_roles_use_switch-role-api.md)。 ### 更新最长角色会话持续时间（AWS CLI） **注意** 从 AWS CLI 或 API 中担任角色的任何人都可以使用 `duration-seconds` CLI 参数或 `DurationSeconds` API 参数请求更长的会话。`MaxSessionDuration` 设置确定可使用 `DurationSeconds` 参数请求的最大角色会话持续时间。如果用户未指定 `DurationSeconds` 参数值，其安全凭证的有效期为 1 小时。 **使用 AWS CLI (AWS CLI) 更改担任的角色的最大会话持续时间设置** 1. （可选）要查看角色的当前最大会话持续时间设置，请运行以下命令： + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) 1. 要更新角色的最大会话持续时间设置，请带 `max-session-duration` CLI 参数或 `MaxSessionDuration` API 参数运行以下命令： + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) 在某个人下次担任该角色后，您所做的更改才会生效。要了解如何撤销该角色的现有会话，请参阅[撤销 IAM 角色临时安全凭证](id_roles_use_revoke-sessions.md)。 ### 更新最长角色会话持续时间（AWS API） **注意** 从 AWS CLI 或 API 中担任角色的任何人都可以使用 `duration-seconds` CLI 参数或 `DurationSeconds` API 参数请求更长的会话。`MaxSessionDuration` 设置确定可使用 `DurationSeconds` 参数请求的最大角色会话持续时间。如果用户未指定 `DurationSeconds` 参数值，其安全凭证的有效期为 1 小时。 **使用 API 更改担任的角色的最大会话持续时间设置 (AWS API)** 1. （可选）要查看角色的当前最大会话持续时间设置，请调用以下操作： + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 1. 要更新角色的最大会话持续时间设置，请带 `max-sessionduration` CLI 参数或 `MaxSessionDuration` API 参数调用以下操作： + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) 在某个人下次担任该角色后，您所做的更改才会生效。要了解如何撤销该角色的现有会话，请参阅[撤销 IAM 角色临时安全凭证](id_roles_use_revoke-sessions.md)。 # 删除角色或实例配置文件如果您不再需要某个角色，我们建议您删除该角色及其关联的权限。这样您就没有未被主动监控或维护的未使用实体。如果该角色与 EC2 实例关联，您还可以从实例配置文件中删除角色，然后删除实例配置文件。 **警告** 确保您没有使用要删除的角色或实例配置文件运行任何 Amazon EC2 实例。删除与正在运行的实例关联的角色或实例配置文件将中断该实例上正在运行的所有应用程序。如果您不希望永久删除角色，则可以禁用角色。为此，请更改角色的策略，然后撤消所有当前会话。例如，您可以将策略添加到拒绝访问所有 AWS 的角色。您还可以编辑信任策略，以拒绝任何试图代入此角色的用户的访问。有关撤消会话的更多信息，请参阅 [撤销 IAM 角色临时安全凭证](id_roles_use_revoke-sessions.md)。 **Topics** + [查看角色访问权限](#roles-delete_prerequisites) + [删除服务相关角色](#id_roles_manage_delete_slr) + [删除 IAM 角色（控制台）](#roles-managingrole-deleting-console) + [创建 IAM 角色 (AWS CLI)](#roles-managingrole-deleting-cli) + [删除 IAM 角色 (AWS API)](#roles-managingrole-deleting-api) + [相关信息](#roles-managingrole-deleting-related-info) ## 查看角色访问权限在删除角色之前，建议您查看上次使用角色的时间。可使用 AWS 管理控制台、AWS CLI 或 AWS API 完成此操作。如果您不希望从使用该角色的用户处删除访问权限，则应查看此信息。角色的上次活动日期可能与**上次访问时间**选项卡中报告的上次日期不相符。[**上次访问时间**](access_policies_last-accessed-view-data.md)选项卡仅报告角色的权限策略所允许服务的活动。角色的上次活动日期包括访问最后一次尝试 AWS 中的任何服务。 **注意** 角色上次活动和上次访问数据的跟踪周期为 400 天。如果您的地区在一年内开始支持这些功能，则此时间段可能会缩短。角色可能在 400 天之前使用过。有关跟踪周期的更多信息，请参阅[AWS 跟踪上次访问信息的位置](access_policies_last-accessed.md#last-accessed_tracking-period)。 **查看上次使用角色的时间（控制台）** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在导航窗格中，选择**角色**。 1. 查找要查看其活动的角色的行。您可以使用搜索字段缩小结果范围。查看**上一个活动**列以查看距离上次使用角色的天数。如果在跟踪周期内未使用该角色，则表将显示**无**。 1. 选择角色的名称可查看更多信息。角色的**摘要**页面还包括**上一个活动**，显示上次使用角色的日期。如果在过去 400 天内未使用该角色，则**上一个活动**中显示**在跟踪期间未被访问**。 **查看上次使用角色的时间 (AWS CLI)** `[aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)` – 运行此命令返回有关角色的信息，包括 `RoleLastUsed` 对象。此对象包含上次使用角色的 `Region` 和 `LastUsedDate`。如果存在 `RoleLastUsed` 但不包含值，则在跟踪周期内未使用该角色。 **查看上次使用角色的时间 (AWS API)** `[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/GetRole.html)` – 调用此操作以返回有关角色的信息，包括 `RoleLastUsed` 对象。此对象包含上次使用角色的 `Region` 和 `LastUsedDate`。如果存在 `RoleLastUsed` 但不包含值，则在跟踪周期内未使用该角色。 ## 删除服务相关角色您用来删除服务相关角色的方法取决于服务。在某些情况下，无需手动删除服务相关角色。例如，在服务中完成特定操作 (如删除资源) 时，服务可能为您删除服务相关角色。在其他情况下，服务可能支持从服务控制台、API 或 AWS CLI 中手动删除服务相关角色。查看链接服务中*[服务相关角色](id_roles.md#iam-term-service-linked-role)*的文档以了解如何删除该角色。您可以转至控制台中的 IAM **Roles**（角色）页面来查看您的账户中的服务相关角色。服务相关角色在表的 **Trusted entities**（可信实体）列中随 **(Service-linked role)** [（服务相关角色）] 一起显示。角色的 **Summary**（摘要）页面上的横幅也指示角色是服务相关角色。如果服务不包括有关删除服务相关角色的文档，您可以使用 IAM 控制台、AWS CLI 或 API 来删除角色。 ## 删除 IAM 角色（控制台）当您使用 AWS 管理控制台删除角色时，IAM 会自动分离与该角色关联的托管式策略。此外，它还会自动删除任何与该角色关联的内联策略，以及包含该角色的任何 Amazon EC2 实例配置文件。 **重要** 在某些情况下，某个角色可能与 Amazon EC2 实例配置文件关联，并且该角色和实例配置文件可能同名。在这种情况下，您可以使用 AWS 管理控制台删除角色和实例配置文件。对于您在控制台中创建的角色和实例配置文件，会自动建立这种关联。如果您从 AWS CLI、Tools for Windows PowerShell 或 AWS API 创建角色，则角色和实例配置文件可能具有不同的名称。在这种情况下，您无法使用控制台删除它们。而是必须使用 AWS CLI、Tools for Windows PowerShell 或 AWS API 首先从实例配置文件中删除该角色。然后必须采取单独的步骤删除该角色。 **删除角色 (控制台)** 1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。 1. 在导航窗格中，选择**角色**，然后选中要删除的角色旁的复选框。 1. 在页面的顶部，选择 **Delete**（移除）。 1. 在确认对话框中，查看上次访问的信息，该信息显示每个选定角色上次访问 AWS 服务的时间。这样可帮助您确认角色当前是否处于活动状态。如果要继续操作，请在文本输入字段中输入角色的名称，然后选择 **Delete**（删除）。如果确定，您就可以继续执行删除操作，即使仍在加载上次访问的信息。 **注意** 您不能使用控制台删除实例配置文件，除非它与角色同名。实例配置文件在删除角色的过程中被删除，如上述步骤所述。要在不删除角色的情况下删除实例配置文件，必须使用 AWS CLI 或 AWS API。有关更多信息，请参阅以下部分。 ## 创建 IAM 角色 (AWS CLI) 当您使用 AWS CLI 删除角色时，必须先删除与角色关联的内联策略。您还必须分离与该角色关联的托管式策略。如果您想要删除包含角色的关联实例配置文件，必须分别删除。 **删除角色 (AWS CLI)** 1. 如果您不知道要删除的角色的名称，请输入以下命令列出账户中的角色： ``` aws iam list-roles ``` 该列表包括各个角色的 Amazon Resource Name (ARN)。通过 CLI 命令使用角色名称（并非 ARN）指向角色。例如，如果某个角色的 ARN 为 `arn:aws:iam::123456789012:role/myrole`，则将该角色称为 **myrole**。 1. 从该角色所关联的全部实例配置文件中删除该角色。 1. 要列出与角色关联的所有实例配置文件，请输入以下命令： ``` aws iam list-instance-profiles-for-role --role-name role-name ``` 1. 要从某个实例配置文件中删除该角色，请为每个实例配置文件输入以下命令： ``` aws iam remove-role-from-instance-profile --instance-profile-name instance-profile-name --role-name role-name ``` 1. 删除与角色相关的全部策略。 1. 要列出角色中的所有内联策略，请输入以下命令： ``` aws iam list-role-policies --role-name role-name ``` 1. 要删除角色中的每个内联策略，请为每个策略输入以下命令： ``` aws iam delete-role-policy --role-name role-name --policy-name policy-name ``` 1. 要列出附加到角色的所有托管策略，请输入以下命令： ``` aws iam list-attached-role-policies --role-name role-name ``` 1. 要从角色中分离每个托管策略，请为每个策略输入以下命令： ``` aws iam detach-role-policy --role-name role-name --policy-arn policy-arn ``` 1. 输入以下命令可删除角色： ``` aws iam delete-role --role-name role-name ``` 1. 如果您没有计划重新使用与角色相关联的实例配置文件，则可以输入以下命令来删除它们： ``` aws iam delete-instance-profile --instance-profile-name instance-profile-name ``` ## 删除 IAM 角色 (AWS API) 当您使用 IAM API 删除角色时，必须先删除与角色关联的内联策略。您还必须分离与该角色关联的托管式策略。如果您想要删除包含角色的关联实例配置文件，必须分别删除。 **删除角色 (AWS API)** 1. 要列出角色所关联的所有实例配置文件，请调用 [ListInstanceProfilesForRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html)。要从实例配置文件删除该角色，请调用 [RemoveRoleFromInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html)。必须提交角色名称和实例配置文件名称。如果您不会重用与角色相关联的实例配置文件，请调用 [DeleteInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 来删除它。 1. 要列出一个角色的所有内联策略，请调用 [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)。要删除该角色所关联的所有内联策略，请调用 [DeleteRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html)。必须提交角色名称和内联策略名称。 1. 要列出附加到角色的所有托管式策略，请调用 [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)。要分离附加到角色的托管式策略，请调用 [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html)。必须提交角色名称和托管策略 ARN。 1. 调用 [DeleteRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRole.html) 删除角色。 ## 相关信息有关实例配置文件的基本信息，请参阅 [使用实例配置文件](id_roles_use_switch-role-ec2_instance-profiles.md)。有关服务相关角色的一般信息，请参阅[创建服务相关角色](id_roles_create-service-linked-role.md)。 # 担任角色的方法您必须先对用户[授予切换到您创建的角色的权限](id_roles_use_permissions-to-switch.md)，然后用户、应用程序或服务才能使用该角色。您可使用附加到组或用户的任何策略授予所需权限。授予权限后，用户可以从 AWS 管理控制台、适用于 Windows PowerShell 的工具、AWS Command Line Interface（AWS CLI）和 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 中代入角色。 **重要** 当您以编程方式而不是在 IAM 控制台中创建角色，则除最长可达 64 个字符的 `RoleName` 外，您还可以选择添加最长 512 个字符的 `Path`。不过，如果您打算通过 AWS 管理控制台中的 **Switch Role**（切换角色）功能使用角色，则组合的 `Path` 和 `RoleName` 不能超过 64 个字符。用于代入角色的方法决定了谁可以代入该角色，以及角色会话可以持续多长时间。使用 `AssumeRole*` API 操作时，您所担任的 IAM 角色为资源。调用 `AssumeRole*` API 操作的用户或角色是主体。下表比较了代入角色的方法。 | 担任角色的方法 | **谁可以担任角色** | **用于指定凭证生命周期的方法** | **凭证生命周期 (最小值 \$1 最大值 \$1 默认值)** | | --- | --- | --- | --- | | AWS 管理控制台 | 用户或角色¹（通过[切换角色](id_roles_use_switch-role-console.md)） | Role（角色）“Summary（摘要）”页面上的 Maximum session duration（最长会话持续时间） | 15 分 \$1 最大会话持续时间设置² \$1 1 小时 | | [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) CLI 或 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作 | 用户或角色¹ | duration-seconds CLI 或 DurationSeconds API 参数 | 15 分 \$1 最大会话持续时间设置² \$1 1 小时 | | [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html) CLI 或 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) API 操作 | 使用 SAML 验证的任何用户 | duration-seconds CLI 或 DurationSeconds API 参数 | 15 分 \$1 最大会话持续时间设置² \$1 1 小时 | | [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html) CLI 或 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) API 操作 | 使用 OIDC 提供者验证身份的任何用户 | duration-seconds CLI 或 DurationSeconds API 参数 | 15 分 \$1 最大会话持续时间设置² \$1 1 小时 | | 使用 [ 构造的](id_roles_providers_enable-console-custom-url.md)控制台 URLAssumeRole | 用户或角色 | URL 中的 SessionDuration HTML 参数 | 15 分钟 \$1 12 小时 \$1 1 小时 | | 使用 [ 构造的](id_roles_providers_enable-console-custom-url.md)控制台 URLAssumeRoleWithSAML | 使用 SAML 验证的任何用户 | URL 中的 SessionDuration HTML 参数 | 15 分钟 \$1 12 小时 \$1 1 小时 | | 使用 [ 构造的](id_roles_providers_enable-console-custom-url.md)控制台 URLAssumeRoleWithWebIdentity | 使用 OIDC 提供者验证身份的任何用户 | URL 中的 SessionDuration HTML 参数 | 15 分钟 \$1 12 小时 \$1 1 小时 | ¹ 使用一个角色的凭证代入其他角色称为[角色链](id_roles.md#iam-term-role-chaining)。使用角色链时，角色的会话持续时间限制为 1 小时。这适用于 AWS 管理控制台角色切换、AWS CLI 和 API 操作。此限制不适用于最初通过用户凭证代入角色的人，也不适用于使用实例配置文件在 Amazon EC2 实例上运行的应用程序。 ² 该设置可以具有 1 小时到 12 小时之间的值。有关修改最大会话持续时间设置的详细信息，请参阅 [IAM 角色管理](id_roles_manage.md)。该设置确定在获取角色凭证时可请求的最大会话持续时间。例如，在使用 [AssumeRole\$1](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作担任角色时，您可以使用 `DurationSeconds` 参数指定会话长度。可以使用该参数指定 900 秒（15 分钟）到角色的最大会话持续时间设置之间的角色会话长度。在控制台内切换角色的 IAM 用户被授予最大会话持续时间或其用户会话中的剩余时间（以较少者为准）。假定您在角色上设置 5 小时的最大持续时间。已登录到控制台 10 小时（默认最多 12 小时）的 IAM 用户切换到该角色。可用角色会话持续时间为 2 小时。要了解如何查看您的角色的最大值，请参阅本页后面的[更新角色的最长会话持续时间](id_roles_update-role-settings.md#id_roles_update-session-duration)。 **备注** 最大会话持续时间设置不限制 AWS 服务建立的会话。 Amazon EC2 IAM 角色凭证不受角色中配置的最长会话持续时间的限制。要允许用户在角色会话中重新代入当前角色，请将角色 ARN 或 AWS 账户 ARN 指定为角色信任策略中的主体。提供计算资源（例如 Amazon EC2、Amazon ECS、Amazon EKS 和 Lambda）的 AWS 服务会提供临时凭证并自动更新这些凭证。这样可以确保您始终拥有一组有效的凭证。对于这些服务，无需重新代入当前角色即可获得临时凭证。但是，如果您需要传递 [会话标签](id_session-tags.md) 或者 [会话策略](access_policies.md#policies_session)，则需要重新代入当前角色。要了解如何修改角色信任策略以添加主体角色 ARN 或 AWS 账户 ARN，请参阅 [更新角色信任策略](id_roles_update-role-trust-policy.md)。 **Topics** + [从用户切换到 IAM 角色（控制台）](id_roles_use_switch-role-console.md) + [切换到 IAM 角色（AWS CLI）](id_roles_use_switch-role-cli.md) + [切换到 IAM 角色（Tools for Windows PowerShell）](id_roles_use_switch-role-twp.md) + [切换到 IAM 角色（AWS API）](id_roles_use_switch-role-api.md) + [使用 IAM 角色向在 Amazon EC2 实例上运行的应用程序授予权限](id_roles_use_switch-role-ec2.md) + [使用实例配置文件](id_roles_use_switch-role-ec2_instance-profiles.md) # 从用户切换到 IAM 角色（控制台）以 IAM 用户、IAM Identity Center 中的用户、SAML 联合角色或 Web 联合身份角色登录时，您可以切换角色。*角色* 指定可用于访问所需的 AWS 资源的一组权限。但是，您没有登录到角色，不过一旦以 IAM 用户身份登录，您就可以切换为 IAM 角色。这会临时搁置原始用户权限，而向您提供分配给角色的权限。角色可以在您自己的账户中或任何其他 AWS 账户中。有关角色、其权益以及如何创建角色的更多信息，请参阅[IAM 角色](id_roles.md)和[IAM 角色创建](id_roles_create.md)。您的用户权限和切换为的角色的权限不会累积。一次只有一组权限处于活动状态。切换到一个角色后，您将临时放弃用户权限并使用分配给该角色的权限。退出该角色后，您的用户权限将自动恢复。当您在 AWS 管理控制台中切换角色时，控制台总是使用您的原始凭证对切换操作进行授权。例如，如果您切换到角色 A，则 IAM 使用您的原始凭证确定是否允许您担任角色 A。如果随后*在使用角色 A* 时尝试切换到角色 B，AWS 仍会使用您的**原始**凭证对切换进行授权，而不是使用角色 A 的凭证。 **注意** 当您以 IAM Identity Center 的用户、SAML 联合角色或 Web 身份联合角色登录时，您将在开始会话时代入 IAM 角色。例如，当 IAM Identity Center 中的用户登录 AWS 访问门户时，他们必须选择与角色相关的权限集，然后才能访问 AWS 资源。 ## 角色会话当您切换角色时，AWS 管理控制台会话默认持续 1 小时。IAM 用户会话默认为 12 小时，其他用户可能会定义不同的会话持续时间。在控制台内切换角色时，您将被授予角色最长会话持续时间或您的用户会话中的剩余时间（以较短者为准）。您不能通过代入角色来延长会话持续时间。例如，假定角色的最长会话持续时间为 10 小时。当您决定切换到该角色时，您已登录控制台 8 小时。您的用户会话还剩 4 小时，因此允许的角色会话持续时间为 4 小时，而不是最长会话持续时间 10 小时。。下表显示了如何在控制台中切换角色时确定 IAM 用户的会话持续时间。 | IAM 用户会话剩余时间... | 角色会话持续时间... | | --- | --- | | 小于角色最长会话持续时间 | 用户会话中的剩余时间 | | 大于角色最长会话持续时间 | 等于最长会话持续时间值 | | 等于角色最长会话持续时间 | 等于最长会话持续时间值（近似值） | 使用一个角色的凭证代入其他角色称为[角色链](id_roles.md#iam-term-role-chaining)。使用角色链时，无论为各个角色配置的最长会话持续时间设置如何，会话持续时间都限制为 1 小时。这适用于 AWS 管理控制台角色切换、AWS CLI 和 API 操作。 **注意** 某些 AWS 服务控制台可以在角色会话过期时自动续订角色会话，而无需您执行任何操作。有些可能会提示您重新加载浏览器页面以重新验证您的会话。 ## 注意事项 + 如果您以 AWS 账户根用户身份登录，则无法切换角色。 + 必须向用户授予通过策略切换角色的权限。有关说明，请参阅[向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md)。 + 您无法将 AWS 管理控制台中的角色切换到需要 [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) 值的角色。您只能通过调用支持 `ExternalId` 参数的 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 来切换到此类角色。 ## 要切换为角色 1. 按照《*AWS 登录用户指南*》中的 [Sign in to the AWS 管理控制台](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) 所述，根据用户类型选择相应的登录过程。 1. 在 AWS 管理控制台中，在右上角的导航栏上选择您的用户名。它通常类似于：***username*@*account\$1ID\$1number\$1or\$1alias***。 1. 选择以下方法之一来切换角色： + 选择**切换角色**。 + 如果选择启用多会话支持，请选择**添加会话**，然后选择**切换角色**。 **注意** 在 AWS 管理控制台中的单个 Web 浏览器中，您最多可以同时登录五个不同的身份。有关详细信息，请参阅《AWS 管理控制台入门指南》**中的[登录多个账户](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/multisession.html)。 1. 在 **Switch Role** 页面上，键入账户 ID 号或账户别名以及管理员提供的角色的名称。 **注意** 如果您的管理员创建了包含路径的角色（如 `division_abc/subdivision_efg/roleToDoX`），则必须在 **Role** 框中键入完整路径和名称。如果您仅键入角色名称，或组合的 `Path` 和 `RoleName` 超过 64 个字符，角色切换将失败。这是存储角色名称的浏览器 Cookie 的限制。如果发生这种情况，请与您的管理员联系，并要求他们减小路径和角色名称大小。 1. （可选）您可以输入显示名称，并选择在控制台导航栏中突出显示该角色的显示颜色。 + 对于**显示名称**，键入您希望在此角色处于活动状态时将在导航栏上显示，以替代您的用户名的文本。系统会基于账户和角色信息提供建议名称，但是您可以将它更改为对您有意义的任何名称。 + 在**显示颜色**中，选择用于突出显示名称的颜色。名称和颜色可帮助提醒您此角色处于活动状态的时间，这将更改您的权限。例如，对于向您提供对测试环境的访问权限的角色，您可以将 **Display name**（显示名称）指定为 **Test**，并选择绿色的 **Color**（颜色）。对于向您授予对生产环境的访问权限的角色，您可以将 **Display name**（显示名称）指定为 **Production**，并选择红色作为 **Color**（颜色）。 1. 选择**切换角色**。显示名称和颜色会在导航栏上替换您的用户名，您可以开始使用角色向您授予的权限。 1. 完成需要 IAM 角色的任务之后，您可以切换回原始会话。这将移除该角色提供的其他权限，并使您恢复到标准权限。 1. 在 IAM 控制台中，在右上角的导航栏中选择角色的 **Display Name**（显示名称）。 1. 选择**切换回**。例如，假设您使用用户名 `123456789012` 登录账号 `Richard`。在使用 `admin-role` 角色后，您要停止使用该角色并返回到您的原始权限。要停止使用该角色，请选择 **admin-role @ 123456789012**，然后选择**切换回**。 ![\[平面定位“切换回”功能以停止使用 IAM 角色并返回原始用户。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/role-stop-using.png) **提示** 您使用的最后几个角色将显示在菜单上。下次想要切换到其中的一个角色时，您可以直接选择所需的角色。只有在菜单上未显示角色时，您才需要手动键入账户和角色信息。 ## 其他资源 + [向用户授予切换角色的权限](id_roles_use_permissions-to-switch.md) + [向用户授予权限以将角色传递给 AWS 服务](id_roles_use_passrole.md) + [创建角色，向 IAM 用户授予权限](id_roles_create_for-user.md) + [创建向 AWS 服务委派权限的角色](id_roles_create_for-service.md) + [排查 IAM 角色问题](troubleshoot_roles.md) # 切换到 IAM 角色（AWS CLI） *角色* 指定可用于访问所需的 AWS 资源的一组权限。在这种意义上，它类似于 [AWS Identity and Access Management 中的用户](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM)。作为用户登录时，您会获取一组特定权限。不过，您不会登录到角色，但在以用户身份登录后，您可以切换到角色。这会临时搁置原始用户权限，而向您提供分配给角色的权限。角色可以在您自己的账户中或任何其他 AWS 账户中。有关角色、其权益以及如何创建和配置角色的更多信息，请参阅[IAM 角色](id_roles.md)和[IAM 角色创建](id_roles_create.md)。要了解在担任角色时使用的各种方法，请参阅[担任角色的方法](id_roles_manage-assume.md)。 **重要** 不会累积您的 IAM 用户和担任的任何角色的权限。一次只有一组权限处于活动状态。在担任某个角色时，您将临时放弃以前的用户或角色权限并使用为该角色分配的权限。退出该角色后，您的用户权限将自动恢复。在以 IAM 用户身份登录后，您可以使用角色来运行 AWS CLI 命令。在以已使用角色的 [externally authenticated user](id_roles_providers.md)（外部验证的用户）（[SAML](id_roles_providers_saml.md) 或 [OIDC](id_roles_providers_oidc.md)）身份登录后，您也可以使用角色来运行 AWS CLI 命令。此外，您还可以使用角色从通过实例配置文件附加到角色的 Amazon EC2 实例中运行 AWS CLI 命令。在以 AWS 账户根用户身份登录时，您无法担任角色。 [**角色链**](id_roles.md#iam-term-role-chaining) — 您还可以使用角色链，这将使用来自一个角色的权限访问另一个角色。默认情况下，您的角色会话持续 1 小时。在使用 `assume-role*` CLI 操作担任该角色时，您可以为 `duration-seconds` 参数指定一个值。该值的范围在 900 秒 (15 分钟) 到角色的最大会话持续时间设置之间。如果您在控制台中切换角色，则会话持续时间最长为一小时。要了解如何查看您的角色的最大值，请参阅[更新角色的最长会话持续时间](id_roles_update-role-settings.md#id_roles_update-session-duration)。如果使用角色链，您的会话持续时间限制为最多 1 小时。如果您随后使用 `duration-seconds` 参数提供大于 1 小时的值，操作将失败。 ## 示例方案：切换到生产角色假设您是一名在开发环境中工作的 IAM 用户。在此场景中，您有时需要使用 [AWS CLI](https://aws.amazon.com/cli/) 通过命令行来使用生产环境。您已经有一组可用的访问密钥凭证。这可能是分配给您的标准 IAM 用户的访问密钥对。或者，如果您以 SAML 或 OIDC 联合主体身份登录，则它可能是最初为您分配的角色的访问密钥对。如果您的当前权限授予您担任特定 IAM 角色的能力，则可以在 AWS CLI 配置文件的“配置文件”中标识该角色。然后，将使用指定 IAM 角色而非原始身份的权限运行该命令。请注意，通过 AWS CLI 命令指定该配置文件时，您使用的是新角色。在这种情况下，您无法同时使用开发账户中的原始权限。原因是，一次仅一组权限能够生效。 **注意** 为了安全起见，管理员可以[查看 AWS CloudTrail 日志](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds)以了解已在 AWS 中执行操作的人员。您的管理员可能会要求您在代入角色时指定源身份或角色会话名称。有关更多信息，请参阅[`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity)和[`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname)。 **切换到生产角色 (AWS CLI)** 1. 如果您从未使用过 AWS CLI，则您必须先配置默认的 CLI 配置文件。打开命令提示符并将您的 AWS CLI 安装设置为使用来自 IAM 用户或联合角色的访问密钥。有关更多信息，请参阅《AWS Command Line Interface 用户指南》**中的[配置 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration)。运行 [aws configure](https://docs.aws.amazon.com/cli/latest/reference/configure/) 命令，如下所述： ``` aws configure ``` 当系统提示时，请提供以下信息： ``` AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY Default region name [None]: us-east-2 Default output format [None]: json ``` 1. 在 Unix 或 Linux 上的 `.aws/config` 文件或 Windows 上的 `C:\Users\USERNAME\.aws\config` 文件中，为角色创建新的配置文件。以下示例创建一个名为 `prodaccess` 的配置文件，它切换到 `123456789012` 账户中的 `ProductionAccessRole` 角色。您从创建该角色的账户管理员处获取角色 ARN。在调用此配置文件时，AWS CLI 使用 `source_profile` 的凭证请求该角色的凭证。因此，引用为 `source_profile` 的身份必须具有 `role_arn` 中指定的角色的 `sts:AssumeRole` 权限。 ``` [profile prodaccess] role_arn = arn:aws:iam::123456789012:role/ProductionAccessRole source_profile = default ``` 1. 在创建新的配置文件后，将使用附加到 IAM 角色 `ProductionAccessRole`（而不是默认用户）的权限运行指定 `--profile prodaccess` 参数的任何 AWS CLI 命令。 ``` aws iam list-users --profile prodaccess ``` 如果分配给 `ProductionAccessRole` 的权限允许列出当前 AWS 账户中的用户，则此命令有效。 1. 要返回到原始凭证授予的权限，请运行不带 `--profile` 参数的命令。AWS CLI 将恢复使用您在[Step 1](#step-configure-default)中配置的默认配置文件中的凭证。有关更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[代入角色](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html)。 ## 示例场景：允许实例配置文件角色切换到另一个账户中的角色假设您使用两个 AWS 账户，并希望允许 Amazon EC2 实例上运行的应用程序在两个账户中运行 [AWS CLI](https://aws.amazon.com/cli/) 命令。假设 EC2 实例位于 `111111111111` 账户中。该实例包含 `abcd` 实例配置文件角色，以允许应用程序对同一 `111111111111` 账户中的 `amzn-s3-demo-bucket1` 存储桶执行只读 Amazon S3 任务。不过，还必须允许应用程序担任 `efgh` 跨账户角色以在账户 `222222222222` 中执行任务。为此，`abcd` EC2 实例配置文件角色必须具有以下权限策略： ***账户 111111111111 `abcd` 角色权限策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccountLevelS3Actions", "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetAccountPublicAccessBlock", "s3:ListAccessPoints", "s3:ListAllMyBuckets" ], "Resource": "arn:aws:s3:::*" }, { "Sid": "AllowListAndReadS3ActionOnMyBucket", "Effect": "Allow", "Action": [ "s3:Get*", "s3:List*" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket1/*", "arn:aws:s3:::amzn-s3-demo-bucket1" ] }, { "Sid": "AllowIPToAssumeCrossAccountRole", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::222222222222:role/efgh" } ] } ``` ------ 假设 `efgh` 跨账户角色允许对同一 `222222222222` 账户中的 `amzn-s3-demo-bucket2` 存储桶执行只读 Amazon S3 任务。为此，`efgh` 跨账户角色必须具有以下权限策略： ***账户 222222222222 `efgh` 角色权限策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccountLevelS3Actions", "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetAccountPublicAccessBlock", "s3:ListAccessPoints", "s3:ListAllMyBuckets" ], "Resource": "arn:aws:s3:::*" }, { "Sid": "AllowListAndReadS3ActionOnMyBucket", "Effect": "Allow", "Action": [ "s3:Get*", "s3:List*" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket2/*", "arn:aws:s3:::amzn-s3-demo-bucket2" ] } ] } ``` ------ `efgh` 角色必须允许 `abcd` 实例配置文件角色担任该角色。为此，`efgh` 角色必须具有以下信任策略： ***账户 222222222222 `efgh` 角色信任策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "efghTrustPolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"} } ] } ``` ------ 要在 `222222222222` 账户中运行 AWS CLI 命令，您必须更新 CLI 配置文件。在 AWS CLI 配置文件中将 `efgh` 角色指定为“配置文件”，并将 `abcd` EC2 实例配置文件角色指定为“凭证源”。然后，将使用 `efgh` 角色的权限运行 CLI 命令，而不是使用原始 `abcd` 角色。 **注意** 出于安全原因，您可以使用 AWS CloudTrail 审核角色在账户中的使用。要在 CloudTrail 日志中由不同主体使用角色时区分角色会话，可以借助角色会话名称。在 AWS CLI 按照本主题所述代表用户担任某个角色时，将自动创建一个 `AWS-CLI-session-nnnnnnnn` 形式的角色会话名称。其中，*nnnnnnnn* 是一个表示 [Unix 纪元时间](http://wikipedia.org/wiki/Unix_time) (自 1970 年 1 月 1 日午夜 UTC 算起的秒数) 的整数。有关更多信息，请参阅 *AWS CloudTrail 用户指南*中的 [CloudTrail 事件引用](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/eventreference.html)。 **允许 EC2 实例配置文件角色切换到跨账户角色 (AWS CLI)** 1. 您不必配置默认 CLI 配置文件。相反，您可以从 EC2 实例配置文件元数据中加载凭证。在 `.aws/config` 文件中为角色创建新的配置文件。以下示例创建一个 `instancecrossaccount` 配置文件，它切换到 `222222222222` 账户中的 `efgh` 角色。在调用该配置文件时，AWS CLI 使用 EC2 实例配置文件元数据的凭证请求该角色的凭证。因此，EC2 实例配置文件角色必须具有 `role_arn` 中指定的角色的 `sts:AssumeRole` 权限。 ``` [profile instancecrossaccount] role_arn = arn:aws:iam::222222222222:role/efgh credential_source = Ec2InstanceMetadata ``` 1. 在创建新的配置文件后，将使用附加到 `222222222222` 账户中的 `efgh` 角色的权限运行指定 `--profile instancecrossaccount` 参数的任何 AWS CLI 命令。 ``` aws s3 ls amzn-s3-demo-bucket2 --profile instancecrossaccount ``` 如果分配给 `efgh` 角色的权限允许列出当前 AWS 账户中的用户，则该命令有效。 1. 要恢复为 `111111111111` 账户中的原始 EC2 实例配置文件权限，请不要使用 `--profile` 参数运行 CLI 命令。有关更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[代入角色](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html)。 # 切换到 IAM 角色（Tools for Windows PowerShell） *角色* 指定可用于访问所需的 AWS 资源的一组权限。在这种意义上，它类似于 [AWS Identity and Access Management 中的用户](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM)。作为用户登录时，您会获取一组特定权限。但是，您没有登录到角色，不过一旦登录，您就可以切换为角色。这会临时搁置原始用户权限，而向您提供分配给角色的权限。角色可以在您自己的账户中或任何其他 AWS 账户中。有关角色、其权益以及如何创建和配置角色的更多信息，请参阅[IAM 角色](id_roles.md)和[IAM 角色创建](id_roles_create.md)。 **重要** 您的 IAM 用户权限和切换为的角色的权限不会累积。一次只有一组权限处于活动状态。切换到一个角色后，您将临时放弃用户权限并使用分配给该角色的权限。退出该角色后，您的用户权限将自动恢复。本部分介绍如何在通过 AWS Tools for Windows PowerShell 在命令行上工作时切换角色。假设您在开发环境中有一个账户，并且您有时需要使用 [Tools for Windows PowerShell](https://aws.amazon.com/powershell/) 在命令行上操作生产环境。您已经有一组可用的访问密钥凭证。这些凭证可以是分配给您的标准 IAM 用户的访问密钥对。或者，如果您以 SAML 或 OIDC 联合主体身份登录，则其可以是最初分配给您的角色的访问密钥对。您可以使用这些凭证运行 `Use-STSRole` cmdlet，这会将新角色的 ARN 作为参数传递。该命令将返回请求的角色的临时安全凭证。然后可利用该角色的权限在后续 PowerShell 命令中使用那些凭证来使用访问生产中的资源。在使用角色时，您不能使用开发账户中的用户权限，因为一次只有一组权限有效。 **注意** 为了安全起见，管理员可以[查看 AWS CloudTrail 日志](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds)以了解已在 AWS 中执行操作的人员。您的管理员可能会要求您在代入角色时指定源身份或角色会话名称。有关更多信息，请参阅[`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity)和[`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname)。请注意，所有访问密钥和令牌都只是示例，不能原样照用。请用您的实际环境的适当值替换。 **要切换到某个角色 (Tools for Windows PowerShell)** 1. 打开 PowerShell 命令提示符并将您的默认配置文件配置为使用来自您的当前 IAM 用户或联合角色的访问密钥。如果您以前使用过 Tools for Windows PowerShell，则可能已完成此设置。请注意，您只能在以 IAM 用户身份（而非 AWS 账户根用户身份）登录时切换角色。 ``` PS C:\> Set-AWSCredentials -AccessKey AKIAIOSFODNN7EXAMPLE -SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY -StoreAs MyMainUserProfile PS C:\> Initialize-AWSDefaults -ProfileName MyMainUserProfile -Region us-east-2 ``` 有关更多信息，请参阅 *AWS Tools for PowerShell 用户指南*中的[使用 AWS 凭证](https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html)。 1. 要检索新角色的凭证，请运行以下命令切换到 123456789012 账户中的 `RoleName` 角色。您从创建该角色的账户管理员处获取角色 ARN。该命令还需要您提供会话名称。您可以选择该名称的任何文本。以下命令请求凭证，然后从返回的结果对象中捕获 `Credentials` 属性对象并将其存储在 `$Creds` 变量中。 ``` PS C:\> $Creds = (Use-STSRole -RoleArn "arn:aws:iam::123456789012:role/RoleName" -RoleSessionName "MyRoleSessionName").Credentials ``` `$Creds` 是一个对象，现在包含您在后续步骤中所需的 `AccessKeyId`、`SecretAccessKey` 和 `SessionToken` 元素。以下示例命令说明典型值： ``` PS C:\> $Creds.AccessKeyId AKIAIOSFODNN7EXAMPLE PS C:\> $Creds.SecretAccessKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY PS C:\> $Creds.SessionToken AQoDYXdzEGcaEXAMPLE2gsYULo+Im5ZEXAMPLEeYjs1M2FUIgIJx9tQqNMBEXAMPLECvSRyh0FW7jEXAMPLEW+vE/7s1HRp XviG7b+qYf4nD00EXAMPLEmj4wxS04L/uZEXAMPLECihzFB5lTYLto9dyBgSDyEXAMPLE9/g7QRUhZp4bqbEXAMPLENwGPy Oj59pFA4lNKCIkVgkREXAMPLEjlzxQ7y52gekeVEXAMPLEDiB9ST3UuysgsKdEXAMPLE1TVastU1A0SKFEXAMPLEiywCC/C s8EXAMPLEpZgOs+6hz4AP4KEXAMPLERbASP+4eZScEXAMPLEsnf87eNhyDHq6ikBQ== PS C:\> $Creds.Expiration Thursday, June 18, 2018 2:28:31 PM ``` 1. 要在任何后续命令中使用这些凭证，应使用 `-Credential` 参数来包含它们。例如，以下命令使用来自角色的凭证，并只有在角色被授予 `iam:ListRoles` 权限时，命令才会起作用并可以因此运行 `Get-IAMRoles` cmdlet： ``` PS C:\> get-iamroles -Credential $Creds ``` 1. 要返回到您的原始凭证，只需停止使用 `-Credentials $Creds` 参数并允许 PowerShell 恢复为在默认配置文件中存储的凭证。 # 切换到 IAM 角色（AWS API） *角色* 指定可用于访问 AWS 资源的一组权限。在这种意义上，它类似于 [IAM 用户](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html)。主体（用户或应用程序）将担任角色以获得临时权限，从而执行所需任务并与 AWS 资源交互。角色可以在您自己的账户中或任何其他 AWS 账户中。有关角色、其权益以及如何创建和配置角色的更多信息，请参阅[IAM 角色](id_roles.md)和[IAM 角色创建](id_roles_create.md)。要了解在担任角色时使用的各种方法，请参阅[担任角色的方法](id_roles_manage-assume.md)。 **重要** 不会累积您的 IAM 用户和担任的任何角色的权限。一次只有一组权限处于活动状态。在担任某个角色时，您将临时放弃以前的用户或角色权限并使用为该角色分配的权限。退出该角色后，您的原始权限将自动恢复。要担任角色，应用程序需调用 AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作并传递角色的 ARN 以供使用。该操作将使用临时凭证创建一个新会话。此会话与用于该角色的基于身份的策略具有相同的权限。在调用 [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) 时，您可以选择传递内联或托管[会话策略](access_policies.md#policies_session)。会话策略是高级策略，在以编程方式为角色或联合用户会话创建临时凭证会话时，这些策略将作为参数进行传递。您可以使用 `Policy` 参数传递单个 JSON 内联会话策略文档。您可以使用 `PolicyArns` 参数指定最多 10 个托管会话策略。生成的会话的权限是实体的基于身份的策略与会话策略的交集。如果需要为其他人提供角色的临时凭证，会话策略是非常有用的。他们可以在后续的 AWS API 调用中使用角色的临时凭证来访问拥有该角色的账户中的资源。您使用会话策略授予的权限不能超过基于身份的策略允许的权限。要了解有关 AWS 如何确定角色的有效权限的更多信息，请参阅[策略评估逻辑](reference_policies_evaluation-logic.md)。 ![\[PermissionsWhenPassingRoles_Diagram\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/role_passed_policy_permissions.png) 在以 IAM 用户或已使用角色的 [externally authenticated user](id_roles_providers.md)（外部验证的用户（[SAML](id_roles_providers_saml.md) 或 [OIDC](id_roles_providers_oidc.md)）身份登录后，您可以调用 `AssumeRole`。您还可以使用[*角色链*](id_roles.md#iam-term-role-chaining)，它使用一个角色担任另一个角色。在以 AWS 账户根用户身份登录时，您无法担任角色。默认情况下，您的角色会话持续 1 小时。在使用 AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API 操作担任该角色时，您可以为 `DurationSeconds` 参数指定一个值。该值的范围在 900 秒 (15 分钟) 到角色的最大会话持续时间设置之间。要了解如何查看您的角色的最大值，请参阅[更新角色的最长会话持续时间](id_roles_update-role-settings.md#id_roles_update-session-duration)。如果使用角色链，您的会话限制为最多 1 小时。如果您随后使用 `DurationSeconds` 参数提供大于 1 小时的值，操作将失败。 **注意** 为了安全起见，管理员可以[查看 AWS CloudTrail 日志](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds)以了解已在 AWS 中执行操作的人员。您的管理员可能会要求您在代入角色时指定源身份或角色会话名称。有关更多信息，请参阅[`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity)和[`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname)。以下代码示例演示了如何创建用户并代入角色。 **警告** 为了避免安全风险，在开发专用软件或处理真实数据时，请勿使用 IAM 用户进行身份验证。而是使用与身份提供商的联合身份验证，例如 [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)。 + 创建没有权限的用户。 + 创建授予列出账户的 Amazon S3 存储桶的权限的角色 + 添加策略以允许用户代入该角色。 + 代入角色并使用临时凭证列出 S3 存储桶，然后清除资源。 ------ #### [ .NET ] **适用于 .NET 的 SDK** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples) 中查找完整示例，了解如何进行设置和运行。 ``` global using Amazon.IdentityManagement; global using Amazon.S3; global using Amazon.SecurityToken; global using IAMActions; global using IamScenariosCommon; global using Microsoft.Extensions.DependencyInjection; global using Microsoft.Extensions.Hosting; global using Microsoft.Extensions.Logging; global using Microsoft.Extensions.Logging.Console; global using Microsoft.Extensions.Logging.Debug; namespace IAMActions; public class IAMWrapper { private readonly IAmazonIdentityManagementService _IAMService; ///

/// Constructor for the IAMWrapper class. ///

/// An IAM client object. public IAMWrapper(IAmazonIdentityManagementService IAMService) { _IAMService = IAMService; } ///

/// Attach an IAM policy to a role. ///

/// The policy to attach. /// The role that the policy will be attached to. /// A Boolean value indicating the success of the action. public async Task AttachRolePolicyAsync(string policyArn, string roleName) { var response = await _IAMService.AttachRolePolicyAsync(new AttachRolePolicyRequest { PolicyArn = policyArn, RoleName = roleName, }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Create an IAM access key for a user. ///

/// The username for which to create the IAM access /// key. /// The AccessKey. public async Task CreateAccessKeyAsync(string userName) { var response = await _IAMService.CreateAccessKeyAsync(new CreateAccessKeyRequest { UserName = userName, }); return response.AccessKey; } ///

/// Create an IAM policy. ///

/// The name to give the new IAM policy. /// The policy document for the new policy. /// The new IAM policy object. public async Task CreatePolicyAsync(string policyName, string policyDocument) { var response = await _IAMService.CreatePolicyAsync(new CreatePolicyRequest { PolicyDocument = policyDocument, PolicyName = policyName, }); return response.Policy; } ///

/// Create a new IAM role. ///

/// The name of the IAM role. /// The name of the IAM policy document /// for the new role. /// The Amazon Resource Name (ARN) of the role. public async Task CreateRoleAsync(string roleName, string rolePolicyDocument) { var request = new CreateRoleRequest { RoleName = roleName, AssumeRolePolicyDocument = rolePolicyDocument, }; var response = await _IAMService.CreateRoleAsync(request); return response.Role.Arn; } ///

/// Create an IAM service-linked role. ///

/// The name of the AWS Service. /// A description of the IAM service-linked role. /// The IAM role that was created. public async Task CreateServiceLinkedRoleAsync(string serviceName, string description) { var request = new CreateServiceLinkedRoleRequest { AWSServiceName = serviceName, Description = description }; var response = await _IAMService.CreateServiceLinkedRoleAsync(request); return response.Role; } ///

/// Create an IAM user. ///

/// The username for the new IAM user. /// The IAM user that was created. public async Task CreateUserAsync(string userName) { var response = await _IAMService.CreateUserAsync(new CreateUserRequest { UserName = userName }); return response.User; } ///

/// Delete an IAM user's access key. ///

/// The Id for the IAM access key. /// The username of the user that owns the IAM /// access key. /// A Boolean value indicating the success of the action. public async Task DeleteAccessKeyAsync(string accessKeyId, string userName) { var response = await _IAMService.DeleteAccessKeyAsync(new DeleteAccessKeyRequest { AccessKeyId = accessKeyId, UserName = userName, }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Delete an IAM policy. ///

/// The Amazon Resource Name (ARN) of the policy to /// delete. /// A Boolean value indicating the success of the action. public async Task DeletePolicyAsync(string policyArn) { var response = await _IAMService.DeletePolicyAsync(new DeletePolicyRequest { PolicyArn = policyArn }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Delete an IAM role. ///

/// The name of the IAM role to delete. /// A Boolean value indicating the success of the action. public async Task DeleteRoleAsync(string roleName) { var response = await _IAMService.DeleteRoleAsync(new DeleteRoleRequest { RoleName = roleName }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Delete an IAM role policy. ///

/// The name of the IAM role. /// The name of the IAM role policy to delete. /// A Boolean value indicating the success of the action. public async Task DeleteRolePolicyAsync(string roleName, string policyName) { var response = await _IAMService.DeleteRolePolicyAsync(new DeleteRolePolicyRequest { PolicyName = policyName, RoleName = roleName, }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Delete an IAM user. ///

/// The username of the IAM user to delete. /// A Boolean value indicating the success of the action. public async Task DeleteUserAsync(string userName) { var response = await _IAMService.DeleteUserAsync(new DeleteUserRequest { UserName = userName }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Delete an IAM user policy. ///

/// The name of the IAM policy to delete. /// The username of the IAM user. /// A Boolean value indicating the success of the action. public async Task DeleteUserPolicyAsync(string policyName, string userName) { var response = await _IAMService.DeleteUserPolicyAsync(new DeleteUserPolicyRequest { PolicyName = policyName, UserName = userName }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Detach an IAM policy from an IAM role. ///

/// The Amazon Resource Name (ARN) of the IAM policy. /// The name of the IAM role. /// A Boolean value indicating the success of the action. public async Task DetachRolePolicyAsync(string policyArn, string roleName) { var response = await _IAMService.DetachRolePolicyAsync(new DetachRolePolicyRequest { PolicyArn = policyArn, RoleName = roleName, }); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Gets the IAM password policy for an AWS account. ///

/// The PasswordPolicy for the AWS account. public async Task GetAccountPasswordPolicyAsync() { var response = await _IAMService.GetAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest()); return response.PasswordPolicy; } ///

/// Get information about an IAM policy. ///

/// The IAM policy to retrieve information for. /// The IAM policy. public async Task GetPolicyAsync(string policyArn) { var response = await _IAMService.GetPolicyAsync(new GetPolicyRequest { PolicyArn = policyArn }); return response.Policy; } ///

/// Get information about an IAM role. ///

/// The name of the IAM role to retrieve information /// for. /// The IAM role that was retrieved. public async Task GetRoleAsync(string roleName) { var response = await _IAMService.GetRoleAsync(new GetRoleRequest { RoleName = roleName, }); return response.Role; } ///

/// Get information about an IAM user. ///

/// The username of the user. /// An IAM user object. public async Task GetUserAsync(string userName) { var response = await _IAMService.GetUserAsync(new GetUserRequest { UserName = userName }); return response.User; } ///

/// List the IAM role policies that are attached to an IAM role. ///

/// The IAM role to list IAM policies for. /// A list of the IAM policies attached to the IAM role. public async Task> ListAttachedRolePoliciesAsync(string roleName) { var attachedPolicies = new List(); var attachedRolePoliciesPaginator = _IAMService.Paginators.ListAttachedRolePolicies(new ListAttachedRolePoliciesRequest { RoleName = roleName }); await foreach (var response in attachedRolePoliciesPaginator.Responses) { attachedPolicies.AddRange(response.AttachedPolicies); } return attachedPolicies; } ///

/// List IAM groups. ///

/// A list of IAM groups. public async Task> ListGroupsAsync() { var groupsPaginator = _IAMService.Paginators.ListGroups(new ListGroupsRequest()); var groups = new List(); await foreach (var response in groupsPaginator.Responses) { groups.AddRange(response.Groups); } return groups; } ///

/// List IAM policies. ///

/// A list of the IAM policies. public async Task> ListPoliciesAsync() { var listPoliciesPaginator = _IAMService.Paginators.ListPolicies(new ListPoliciesRequest()); var policies = new List(); await foreach (var response in listPoliciesPaginator.Responses) { policies.AddRange(response.Policies); } return policies; } ///

/// List IAM role policies. ///

/// The IAM role for which to list IAM policies. /// A list of IAM policy names. public async Task> ListRolePoliciesAsync(string roleName) { var listRolePoliciesPaginator = _IAMService.Paginators.ListRolePolicies(new ListRolePoliciesRequest { RoleName = roleName }); var policyNames = new List(); await foreach (var response in listRolePoliciesPaginator.Responses) { policyNames.AddRange(response.PolicyNames); } return policyNames; } ///

/// List IAM roles. ///

/// A list of IAM roles. public async Task> ListRolesAsync() { var listRolesPaginator = _IAMService.Paginators.ListRoles(new ListRolesRequest()); var roles = new List(); await foreach (var response in listRolesPaginator.Responses) { roles.AddRange(response.Roles); } return roles; } ///

/// List SAML authentication providers. ///

/// A list of SAML providers. public async Task> ListSAMLProvidersAsync() { var response = await _IAMService.ListSAMLProvidersAsync(new ListSAMLProvidersRequest()); return response.SAMLProviderList; } ///

/// List IAM users. ///

/// A list of IAM users. public async Task> ListUsersAsync() { var listUsersPaginator = _IAMService.Paginators.ListUsers(new ListUsersRequest()); var users = new List(); await foreach (var response in listUsersPaginator.Responses) { users.AddRange(response.Users); } return users; } ///

/// Update the inline policy document embedded in a role. ///

/// The name of the policy to embed. /// The name of the role to update. /// The policy document that defines the role. /// A Boolean value indicating the success of the action. public async Task PutRolePolicyAsync(string policyName, string roleName, string policyDocument) { var request = new PutRolePolicyRequest { PolicyName = policyName, RoleName = roleName, PolicyDocument = policyDocument }; var response = await _IAMService.PutRolePolicyAsync(request); return response.HttpStatusCode == HttpStatusCode.OK; } ///

/// Add or update an inline policy document that is embedded in an IAM user. ///

/// The name of the IAM user. /// The name of the IAM policy. /// The policy document defining the IAM policy. /// A Boolean value indicating the success of the action. public async Task PutUserPolicyAsync(string userName, string policyName, string policyDocument) { var request = new PutUserPolicyRequest { UserName = userName, PolicyName = policyName, PolicyDocument = policyDocument }; var response = await _IAMService.PutUserPolicyAsync(request); return response.HttpStatusCode == System.Net.HttpStatusCode.OK; } ///

/// Wait for a new access key to be ready to use. ///

/// The Id of the access key. /// A boolean value indicating the success of the action. public async Task WaitUntilAccessKeyIsReady(string accessKeyId) { var keyReady = false; do { try { var response = await _IAMService.GetAccessKeyLastUsedAsync( new GetAccessKeyLastUsedRequest { AccessKeyId = accessKeyId }); if (response.UserName is not null) { keyReady = true; } } catch (NoSuchEntityException) { keyReady = false; } } while (!keyReady); return keyReady; } } using Microsoft.Extensions.Configuration; namespace IAMBasics; public class IAMBasics { private static ILogger logger = null!; static async Task Main(string[] args) { // Set up dependency injection for the AWS service. using var host = Host.CreateDefaultBuilder(args) .ConfigureLogging(logging => logging.AddFilter("System", LogLevel.Debug) .AddFilter("Microsoft", LogLevel.Information) .AddFilter("Microsoft", LogLevel.Trace)) .ConfigureServices((_, services) => services.AddAWSService() .AddTransient() .AddTransient() ) .Build(); logger = LoggerFactory.Create(builder => { builder.AddConsole(); }) .CreateLogger(); IConfiguration configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("settings.json") // Load test settings from .json file. .AddJsonFile("settings.local.json", true) // Optionally load local settings. .Build(); // Values needed for user, role, and policies. string userName = configuration["UserName"]!; string s3PolicyName = configuration["S3PolicyName"]!; string roleName = configuration["RoleName"]!; var iamWrapper = host.Services.GetRequiredService(); var uiWrapper = host.Services.GetRequiredService(); uiWrapper.DisplayBasicsOverview(); uiWrapper.PressEnter(); // First create a user. By default, the new user has // no permissions. uiWrapper.DisplayTitle("Create User"); Console.WriteLine($"Creating a new user with user name: {userName}."); var user = await iamWrapper.CreateUserAsync(userName); var userArn = user.Arn; Console.WriteLine($"Successfully created user: {userName} with ARN: {userArn}."); uiWrapper.WaitABit(15, "Now let's wait for the user to be ready for use."); // Define a role policy document that allows the new user // to assume the role. string assumeRolePolicyDocument = "{" + "\"Version\": \"2012-10-17\"," + "\"Statement\": [{" + "\"Effect\": \"Allow\"," + "\"Principal\": {" + $" \"AWS\": \"{userArn}\"" + "}," + "\"Action\": \"sts:AssumeRole\"" + "}]" + "}"; // Permissions to list all buckets. string policyDocument = "{" + "\"Version\": \"2012-10-17\"," + " \"Statement\" : [{" + " \"Action\" : [\"s3:ListAllMyBuckets\"]," + " \"Effect\" : \"Allow\"," + " \"Resource\" : \"*\"" + "}]" + "}"; // Create an AccessKey for the user. uiWrapper.DisplayTitle("Create access key"); Console.WriteLine("Now let's create an access key for the new user."); var accessKey = await iamWrapper.CreateAccessKeyAsync(userName); var accessKeyId = accessKey.AccessKeyId; var secretAccessKey = accessKey.SecretAccessKey; Console.WriteLine($"We have created the access key with Access key id: {accessKeyId}."); Console.WriteLine("Now let's wait until the IAM access key is ready to use."); var keyReady = await iamWrapper.WaitUntilAccessKeyIsReady(accessKeyId); // Now try listing the Amazon Simple Storage Service (Amazon S3) // buckets. This should fail at this point because the user doesn't // have permissions to perform this task. uiWrapper.DisplayTitle("Try to display Amazon S3 buckets"); Console.WriteLine("Now let's try to display a list of the user's Amazon S3 buckets."); var s3Client1 = new AmazonS3Client(accessKeyId, secretAccessKey); var stsClient1 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey); var s3Wrapper = new S3Wrapper(s3Client1, stsClient1); var buckets = await s3Wrapper.ListMyBucketsAsync(); Console.WriteLine(buckets is null ? "As expected, the call to list the buckets has returned a null list." : "Something went wrong. This shouldn't have worked."); uiWrapper.PressEnter(); uiWrapper.DisplayTitle("Create IAM role"); Console.WriteLine($"Creating the role: {roleName}"); // Creating an IAM role to allow listing the S3 buckets. A role name // is not case sensitive and must be unique to the account for which it // is created. var roleArn = await iamWrapper.CreateRoleAsync(roleName, assumeRolePolicyDocument); uiWrapper.PressEnter(); // Create a policy with permissions to list S3 buckets. uiWrapper.DisplayTitle("Create IAM policy"); Console.WriteLine($"Creating the policy: {s3PolicyName}"); Console.WriteLine("with permissions to list the Amazon S3 buckets for the account."); var policy = await iamWrapper.CreatePolicyAsync(s3PolicyName, policyDocument); // Wait 15 seconds for the IAM policy to be available. uiWrapper.WaitABit(15, "Waiting for the policy to be available."); // Attach the policy to the role you created earlier. uiWrapper.DisplayTitle("Attach new IAM policy"); Console.WriteLine("Now let's attach the policy to the role."); await iamWrapper.AttachRolePolicyAsync(policy.Arn, roleName); // Wait 15 seconds for the role to be updated. Console.WriteLine(); uiWrapper.WaitABit(15, "Waiting for the policy to be attached."); // Use the AWS Security Token Service (AWS STS) to have the user // assume the role we created. var stsClient2 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey); // Wait for the new credentials to become valid. uiWrapper.WaitABit(10, "Waiting for the credentials to be valid."); var assumedRoleCredentials = await s3Wrapper.AssumeS3RoleAsync("temporary-session", roleArn); // Try again to list the buckets using the client created with // the new user's credentials. This time, it should work. var s3Client2 = new AmazonS3Client(assumedRoleCredentials); s3Wrapper.UpdateClients(s3Client2, stsClient2); buckets = await s3Wrapper.ListMyBucketsAsync(); uiWrapper.DisplayTitle("List Amazon S3 buckets"); Console.WriteLine("This time we should have buckets to list."); if (buckets is not null) { buckets.ForEach(bucket => { Console.WriteLine($"{bucket.BucketName} created: {bucket.CreationDate}"); }); } uiWrapper.PressEnter(); // Now clean up all the resources used in the example. uiWrapper.DisplayTitle("Clean up resources"); Console.WriteLine("Thank you for watching. The IAM Basics demo is complete."); Console.WriteLine("Please wait while we clean up the resources we created."); await iamWrapper.DetachRolePolicyAsync(policy.Arn, roleName); await iamWrapper.DeletePolicyAsync(policy.Arn); await iamWrapper.DeleteRoleAsync(roleName); await iamWrapper.DeleteAccessKeyAsync(accessKeyId, userName); await iamWrapper.DeleteUserAsync(userName); uiWrapper.PressEnter(); Console.WriteLine("All done cleaning up our resources. Thank you for your patience."); } } namespace IamScenariosCommon; using System.Net; ///

/// A class to perform Amazon Simple Storage Service (Amazon S3) actions for /// the IAM Basics scenario. ///

public class S3Wrapper { private IAmazonS3 _s3Service; private IAmazonSecurityTokenService _stsService; ///

/// Constructor for the S3Wrapper class. ///

/// An Amazon S3 client object. /// An AWS Security Token Service (AWS STS) /// client object. public S3Wrapper(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService) { _s3Service = s3Service; _stsService = stsService; } ///

/// Assumes an AWS Identity and Access Management (IAM) role that allows /// Amazon S3 access for the current session. ///

/// A string representing the current session. /// The name of the IAM role to assume. /// Credentials for the newly assumed IAM role. public async Task AssumeS3RoleAsync(string roleSession, string roleToAssume) { // Create the request to use with the AssumeRoleAsync call. var request = new AssumeRoleRequest() { RoleSessionName = roleSession, RoleArn = roleToAssume, }; var response = await _stsService.AssumeRoleAsync(request); return response.Credentials; } ///

/// Delete an S3 bucket. ///

/// Name of the S3 bucket to delete. /// A Boolean value indicating the success of the action. public async Task DeleteBucketAsync(string bucketName) { var result = await _s3Service.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName }); return result.HttpStatusCode == HttpStatusCode.OK; } ///

/// List the buckets that are owned by the user's account. ///

/// Async Task. public async Task?> ListMyBucketsAsync() { try { // Get the list of buckets accessible by the new user. var response = await _s3Service.ListBucketsAsync(); return response.Buckets; } catch (AmazonS3Exception ex) { // Something else went wrong. Display the error message. Console.WriteLine($"Error: {ex.Message}"); return null; } } ///

/// Create a new S3 bucket. ///

/// The name for the new bucket. /// A Boolean value indicating whether the action completed /// successfully. public async Task PutBucketAsync(string bucketName) { var response = await _s3Service.PutBucketAsync(new PutBucketRequest { BucketName = bucketName }); return response.HttpStatusCode == HttpStatusCode.OK; } ///

/// Update the client objects with new client objects. This is available /// because the scenario uses the methods of this class without and then /// with the proper permissions to list S3 buckets. ///

/// The Amazon S3 client object. /// The AWS STS client object. public void UpdateClients(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService) { _s3Service = s3Service; _stsService = stsService; } } namespace IamScenariosCommon; public class UIWrapper { public readonly string SepBar = new('-', Console.WindowWidth); ///

/// Show information about the IAM Groups scenario. ///

public void DisplayGroupsOverview() { Console.Clear(); DisplayTitle("Welcome to the IAM Groups Demo"); Console.WriteLine("This example application does the following:"); Console.WriteLine("\t1. Creates an Amazon Identity and Access Management (IAM) group."); Console.WriteLine("\t2. Adds an IAM policy to the IAM group giving it full access to Amazon S3."); Console.WriteLine("\t3. Creates a new IAM user."); Console.WriteLine("\t4. Creates an IAM access key for the user."); Console.WriteLine("\t5. Adds the user to the IAM group."); Console.WriteLine("\t6. Lists the buckets on the account."); Console.WriteLine("\t7. Proves that the user has full Amazon S3 access by creating a bucket."); Console.WriteLine("\t8. List the buckets again to show the new bucket."); Console.WriteLine("\t9. Cleans up all the resources created."); } ///

/// Show information about the IAM Basics scenario. ///

public void DisplayBasicsOverview() { Console.Clear(); DisplayTitle("Welcome to IAM Basics"); Console.WriteLine("This example application does the following:"); Console.WriteLine("\t1. Creates a user with no permissions."); Console.WriteLine("\t2. Creates a role and policy that grant s3:ListAllMyBuckets permission."); Console.WriteLine("\t3. Grants the user permission to assume the role."); Console.WriteLine("\t4. Creates an S3 client object as the user and tries to list buckets (this will fail)."); Console.WriteLine("\t5. Gets temporary credentials by assuming the role."); Console.WriteLine("\t6. Creates a new S3 client object with the temporary credentials and lists the buckets (this will succeed)."); Console.WriteLine("\t7. Deletes all the resources."); } ///

/// Display a message and wait until the user presses enter. ///

public void PressEnter() { Console.Write("\nPress to continue. "); _ = Console.ReadLine(); Console.WriteLine(); } ///

/// Pad a string with spaces to center it on the console display. ///

/// The string to be centered. /// The padded string. public string CenterString(string strToCenter) { var padAmount = (Console.WindowWidth - strToCenter.Length) / 2; var leftPad = new string(' ', padAmount); return $"{leftPad}{strToCenter}"; } ///

/// Display a line of hyphens, the centered text of the title, and another /// line of hyphens. ///

/// The string to be displayed. public void DisplayTitle(string strTitle) { Console.WriteLine(SepBar); Console.WriteLine(CenterString(strTitle)); Console.WriteLine(SepBar); } ///

/// Display a countdown and wait for a number of seconds. ///

/// The number of seconds to wait. public void WaitABit(int numSeconds, string msg) { Console.WriteLine(msg); // Wait for the requested number of seconds. for (int i = numSeconds; i > 0; i--) { System.Threading.Thread.Sleep(1000); Console.Write($"{i}..."); } PressEnter(); } } ``` + 有关 API 的详细信息，请参阅 *适用于 .NET 的 AWS SDK API 参考*中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/PutUserPolicy) ------ #### [ Bash ] **AWS CLI 及 Bash 脚本** 查看 GitHub，了解更多信息。查找完整示例，了解如何在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples)中进行设置和运行。 ``` ############################################################################### # function iam_create_user_assume_role # # Scenario to create an IAM user, create an IAM role, and apply the role to the user. # # "IAM access" permissions are needed to run this code. # "STS assume role" permissions are needed to run this code. (Note: It might be necessary to # create a custom policy). # # Returns: # 0 - If successful. # 1 - If an error occurred. ############################################################################### function iam_create_user_assume_role() { { if [ "$IAM_OPERATIONS_SOURCED" != "True" ]; then source ./iam_operations.sh fi } echo_repeat "*" 88 echo "Welcome to the IAM create user and assume role demo." echo echo "This demo will create an IAM user, create an IAM role, and apply the role to the user." echo_repeat "*" 88 echo echo -n "Enter a name for a new IAM user: " get_input user_name=$get_input_result local user_arn user_arn=$(iam_create_user -u "$user_name") # shellcheck disable=SC2181 if [[ ${?} == 0 ]]; then echo "Created demo IAM user named $user_name" else errecho "$user_arn" errecho "The user failed to create. This demo will exit." return 1 fi local access_key_response access_key_response=$(iam_create_user_access_key -u "$user_name") # shellcheck disable=SC2181 if [[ ${?} != 0 ]]; then errecho "The access key failed to create. This demo will exit." clean_up "$user_name" return 1 fi IFS=$'\t ' read -r -a access_key_values <<<"$access_key_response" local key_name=${access_key_values[0]} local key_secret=${access_key_values[1]} echo "Created access key named $key_name" echo "Wait 10 seconds for the user to be ready." sleep 10 echo_repeat "*" 88 echo local iam_role_name iam_role_name=$(generate_random_name "test-role") echo "Creating a role named $iam_role_name with user $user_name as the principal." local assume_role_policy_document="{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Principal\": {\"AWS\": \"$user_arn\"}, \"Action\": \"sts:AssumeRole\" }] }" local role_arn role_arn=$(iam_create_role -n "$iam_role_name" -p "$assume_role_policy_document") # shellcheck disable=SC2181 if [ ${?} == 0 ]; then echo "Created IAM role named $iam_role_name" else errecho "The role failed to create. This demo will exit." clean_up "$user_name" "$key_name" return 1 fi local policy_name policy_name=$(generate_random_name "test-policy") local policy_document="{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"s3:ListAllMyBuckets\", \"Resource\": \"arn:aws:s3:::*\"}]}" local policy_arn policy_arn=$(iam_create_policy -n "$policy_name" -p "$policy_document") # shellcheck disable=SC2181 if [[ ${?} == 0 ]]; then echo "Created IAM policy named $policy_name" else errecho "The policy failed to create." clean_up "$user_name" "$key_name" "$iam_role_name" return 1 fi if (iam_attach_role_policy -n "$iam_role_name" -p "$policy_arn"); then echo "Attached policy $policy_arn to role $iam_role_name" else errecho "The policy failed to attach." clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" return 1 fi local assume_role_policy_document="{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"$role_arn\"}]}" local assume_role_policy_name assume_role_policy_name=$(generate_random_name "test-assume-role-") # shellcheck disable=SC2181 local assume_role_policy_arn assume_role_policy_arn=$(iam_create_policy -n "$assume_role_policy_name" -p "$assume_role_policy_document") # shellcheck disable=SC2181 if [ ${?} == 0 ]; then echo "Created IAM policy named $assume_role_policy_name for sts assume role" else errecho "The policy failed to create." clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" return 1 fi echo "Wait 10 seconds to give AWS time to propagate these new resources and connections." sleep 10 echo_repeat "*" 88 echo echo "Try to list buckets without the new user assuming the role." echo_repeat "*" 88 echo # Set the environment variables for the created user. # bashsupport disable=BP2001 export AWS_ACCESS_KEY_ID=$key_name # bashsupport disable=BP2001 export AWS_SECRET_ACCESS_KEY=$key_secret local buckets buckets=$(s3_list_buckets) # shellcheck disable=SC2181 if [ ${?} == 0 ]; then local bucket_count bucket_count=$(echo "$buckets" | wc -w | xargs) echo "There are $bucket_count buckets in the account. This should not have happened." else errecho "Because the role with permissions has not been assumed, listing buckets failed." fi echo echo_repeat "*" 88 echo "Now assume the role $iam_role_name and list the buckets." echo_repeat "*" 88 echo local credentials credentials=$(sts_assume_role -r "$role_arn" -n "AssumeRoleDemoSession") # shellcheck disable=SC2181 if [ ${?} == 0 ]; then echo "Assumed role $iam_role_name" else errecho "Failed to assume role." export AWS_ACCESS_KEY_ID="" export AWS_SECRET_ACCESS_KEY="" clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn" return 1 fi IFS=$'\t ' read -r -a credentials <<<"$credentials" export AWS_ACCESS_KEY_ID=${credentials[0]} export AWS_SECRET_ACCESS_KEY=${credentials[1]} # bashsupport disable=BP2001 export AWS_SESSION_TOKEN=${credentials[2]} buckets=$(s3_list_buckets) # shellcheck disable=SC2181 if [ ${?} == 0 ]; then local bucket_count bucket_count=$(echo "$buckets" | wc -w | xargs) echo "There are $bucket_count buckets in the account. Listing buckets succeeded because of " echo "the assumed role." else errecho "Failed to list buckets. This should not happen." export AWS_ACCESS_KEY_ID="" export AWS_SECRET_ACCESS_KEY="" export AWS_SESSION_TOKEN="" clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn" return 1 fi local result=0 export AWS_ACCESS_KEY_ID="" export AWS_SECRET_ACCESS_KEY="" echo echo_repeat "*" 88 echo "The created resources will now be deleted." echo_repeat "*" 88 echo clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn" # shellcheck disable=SC2181 if [[ ${?} -ne 0 ]]; then result=1 fi return $result } ``` 此场景中使用的 IAM 函数。 ``` ############################################################################### # function iam_user_exists # # This function checks to see if the specified AWS Identity and Access Management (IAM) user already exists. # # Parameters: # $1 - The name of the IAM user to check. # # Returns: # 0 - If the user already exists. # 1 - If the user doesn't exist. ############################################################################### function iam_user_exists() { local user_name user_name=$1 # Check whether the IAM user already exists. # We suppress all output - we're interested only in the return code. local errors errors=$(aws iam get-user \ --user-name "$user_name" 2>&1 >/dev/null) local error_code=${?} if [[ $error_code -eq 0 ]]; then return 0 # 0 in Bash script means true. else if [[ $errors != *"error"*"(NoSuchEntity)"* ]]; then aws_cli_error_log $error_code errecho "Error calling iam get-user $errors" fi return 1 # 1 in Bash script means false. fi } ############################################################################### # function iam_create_user # # This function creates the specified IAM user, unless # it already exists. # # Parameters: # -u user_name -- The name of the user to create. # # Returns: # The ARN of the user. # And: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_create_user() { local user_name response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_create_user" echo "Creates an AWS Identity and Access Management (IAM) user. You must supply a username:" echo " -u user_name The name of the user. It must be unique within the account." echo "" } # Retrieve the calling parameters. while getopts "u:h" option; do case "${option}" in u) user_name="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$user_name" ]]; then errecho "ERROR: You must provide a username with the -u parameter." usage return 1 fi iecho "Parameters:\n" iecho " User name: $user_name" iecho "" # If the user already exists, we don't want to try to create it. if (iam_user_exists "$user_name"); then errecho "ERROR: A user with that name already exists in the account." return 1 fi response=$(aws iam create-user --user-name "$user_name" \ --output text \ --query 'User.Arn') local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports create-user operation failed.$response" return 1 fi echo "$response" return 0 } ############################################################################### # function iam_create_user_access_key # # This function creates an IAM access key for the specified user. # # Parameters: # -u user_name -- The name of the IAM user. # [-f file_name] -- The optional file name for the access key output. # # Returns: # [access_key_id access_key_secret] # And: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_create_user_access_key() { local user_name file_name response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_create_user_access_key" echo "Creates an AWS Identity and Access Management (IAM) key pair." echo " -u user_name The name of the IAM user." echo " [-f file_name] Optional file name for the access key output." echo "" } # Retrieve the calling parameters. while getopts "u:f:h" option; do case "${option}" in u) user_name="${OPTARG}" ;; f) file_name="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$user_name" ]]; then errecho "ERROR: You must provide a username with the -u parameter." usage return 1 fi response=$(aws iam create-access-key \ --user-name "$user_name" \ --output text) local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports create-access-key operation failed.$response" return 1 fi if [[ -n "$file_name" ]]; then echo "$response" >"$file_name" fi local key_id key_secret # shellcheck disable=SC2086 key_id=$(echo $response | cut -f 2 -d ' ') # shellcheck disable=SC2086 key_secret=$(echo $response | cut -f 4 -d ' ') echo "$key_id $key_secret" return 0 } ############################################################################### # function iam_create_role # # This function creates an IAM role. # # Parameters: # -n role_name -- The name of the IAM role. # -p policy_json -- The assume role policy document. # # Returns: # The ARN of the role. # And: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_create_role() { local role_name policy_document response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_create_user_access_key" echo "Creates an AWS Identity and Access Management (IAM) role." echo " -n role_name The name of the IAM role." echo " -p policy_json -- The assume role policy document." echo "" } # Retrieve the calling parameters. while getopts "n:p:h" option; do case "${option}" in n) role_name="${OPTARG}" ;; p) policy_document="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$role_name" ]]; then errecho "ERROR: You must provide a role name with the -n parameter." usage return 1 fi if [[ -z "$policy_document" ]]; then errecho "ERROR: You must provide a policy document with the -p parameter." usage return 1 fi response=$(aws iam create-role \ --role-name "$role_name" \ --assume-role-policy-document "$policy_document" \ --output text \ --query Role.Arn) local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports create-role operation failed.\n$response" return 1 fi echo "$response" return 0 } ############################################################################### # function iam_create_policy # # This function creates an IAM policy. # # Parameters: # -n policy_name -- The name of the IAM policy. # -p policy_json -- The policy document. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_create_policy() { local policy_name policy_document response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_create_policy" echo "Creates an AWS Identity and Access Management (IAM) policy." echo " -n policy_name The name of the IAM policy." echo " -p policy_json -- The policy document." echo "" } # Retrieve the calling parameters. while getopts "n:p:h" option; do case "${option}" in n) policy_name="${OPTARG}" ;; p) policy_document="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$policy_name" ]]; then errecho "ERROR: You must provide a policy name with the -n parameter." usage return 1 fi if [[ -z "$policy_document" ]]; then errecho "ERROR: You must provide a policy document with the -p parameter." usage return 1 fi response=$(aws iam create-policy \ --policy-name "$policy_name" \ --policy-document "$policy_document" \ --output text \ --query Policy.Arn) local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports create-policy operation failed.\n$response" return 1 fi echo "$response" } ############################################################################### # function iam_attach_role_policy # # This function attaches an IAM policy to a tole. # # Parameters: # -n role_name -- The name of the IAM role. # -p policy_ARN -- The IAM policy document ARN.. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_attach_role_policy() { local role_name policy_arn response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_attach_role_policy" echo "Attaches an AWS Identity and Access Management (IAM) policy to an IAM role." echo " -n role_name The name of the IAM role." echo " -p policy_ARN -- The IAM policy document ARN." echo "" } # Retrieve the calling parameters. while getopts "n:p:h" option; do case "${option}" in n) role_name="${OPTARG}" ;; p) policy_arn="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$role_name" ]]; then errecho "ERROR: You must provide a role name with the -n parameter." usage return 1 fi if [[ -z "$policy_arn" ]]; then errecho "ERROR: You must provide a policy ARN with the -p parameter." usage return 1 fi response=$(aws iam attach-role-policy \ --role-name "$role_name" \ --policy-arn "$policy_arn") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports attach-role-policy operation failed.\n$response" return 1 fi echo "$response" return 0 } ############################################################################### # function iam_detach_role_policy # # This function detaches an IAM policy to a tole. # # Parameters: # -n role_name -- The name of the IAM role. # -p policy_ARN -- The IAM policy document ARN.. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_detach_role_policy() { local role_name policy_arn response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_detach_role_policy" echo "Detaches an AWS Identity and Access Management (IAM) policy to an IAM role." echo " -n role_name The name of the IAM role." echo " -p policy_ARN -- The IAM policy document ARN." echo "" } # Retrieve the calling parameters. while getopts "n:p:h" option; do case "${option}" in n) role_name="${OPTARG}" ;; p) policy_arn="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$role_name" ]]; then errecho "ERROR: You must provide a role name with the -n parameter." usage return 1 fi if [[ -z "$policy_arn" ]]; then errecho "ERROR: You must provide a policy ARN with the -p parameter." usage return 1 fi response=$(aws iam detach-role-policy \ --role-name "$role_name" \ --policy-arn "$policy_arn") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports detach-role-policy operation failed.\n$response" return 1 fi echo "$response" return 0 } ############################################################################### # function iam_delete_policy # # This function deletes an IAM policy. # # Parameters: # -n policy_arn -- The name of the IAM policy arn. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_delete_policy() { local policy_arn response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_delete_policy" echo "Deletes an AWS Identity and Access Management (IAM) policy" echo " -n policy_arn -- The name of the IAM policy arn." echo "" } # Retrieve the calling parameters. while getopts "n:h" option; do case "${option}" in n) policy_arn="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$policy_arn" ]]; then errecho "ERROR: You must provide a policy arn with the -n parameter." usage return 1 fi iecho "Parameters:\n" iecho " Policy arn: $policy_arn" iecho "" response=$(aws iam delete-policy \ --policy-arn "$policy_arn") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports delete-policy operation failed.\n$response" return 1 fi iecho "delete-policy response:$response" iecho return 0 } ############################################################################### # function iam_delete_role # # This function deletes an IAM role. # # Parameters: # -n role_name -- The name of the IAM role. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_delete_role() { local role_name response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_delete_role" echo "Deletes an AWS Identity and Access Management (IAM) role" echo " -n role_name -- The name of the IAM role." echo "" } # Retrieve the calling parameters. while getopts "n:h" option; do case "${option}" in n) role_name="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 echo "role_name:$role_name" if [[ -z "$role_name" ]]; then errecho "ERROR: You must provide a role name with the -n parameter." usage return 1 fi iecho "Parameters:\n" iecho " Role name: $role_name" iecho "" response=$(aws iam delete-role \ --role-name "$role_name") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports delete-role operation failed.\n$response" return 1 fi iecho "delete-role response:$response" iecho return 0 } ############################################################################### # function iam_delete_access_key # # This function deletes an IAM access key for the specified IAM user. # # Parameters: # -u user_name -- The name of the user. # -k access_key -- The access key to delete. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_delete_access_key() { local user_name access_key response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_delete_access_key" echo "Deletes an AWS Identity and Access Management (IAM) access key for the specified IAM user" echo " -u user_name The name of the user." echo " -k access_key The access key to delete." echo "" } # Retrieve the calling parameters. while getopts "u:k:h" option; do case "${option}" in u) user_name="${OPTARG}" ;; k) access_key="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$user_name" ]]; then errecho "ERROR: You must provide a username with the -u parameter." usage return 1 fi if [[ -z "$access_key" ]]; then errecho "ERROR: You must provide an access key with the -k parameter." usage return 1 fi iecho "Parameters:\n" iecho " Username: $user_name" iecho " Access key: $access_key" iecho "" response=$(aws iam delete-access-key \ --user-name "$user_name" \ --access-key-id "$access_key") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports delete-access-key operation failed.\n$response" return 1 fi iecho "delete-access-key response:$response" iecho return 0 } ############################################################################### # function iam_delete_user # # This function deletes the specified IAM user. # # Parameters: # -u user_name -- The name of the user to create. # # Returns: # 0 - If successful. # 1 - If it fails. ############################################################################### function iam_delete_user() { local user_name response local option OPTARG # Required to use getopts command in a function. # bashsupport disable=BP5008 function usage() { echo "function iam_delete_user" echo "Deletes an AWS Identity and Access Management (IAM) user. You must supply a username:" echo " -u user_name The name of the user." echo "" } # Retrieve the calling parameters. while getopts "u:h" option; do case "${option}" in u) user_name="${OPTARG}" ;; h) usage return 0 ;; \?) echo "Invalid parameter" usage return 1 ;; esac done export OPTIND=1 if [[ -z "$user_name" ]]; then errecho "ERROR: You must provide a username with the -u parameter." usage return 1 fi iecho "Parameters:\n" iecho " User name: $user_name" iecho "" # If the user does not exist, we don't want to try to delete it. if (! iam_user_exists "$user_name"); then errecho "ERROR: A user with that name does not exist in the account." return 1 fi response=$(aws iam delete-user \ --user-name "$user_name") local error_code=${?} if [[ $error_code -ne 0 ]]; then aws_cli_error_log $error_code errecho "ERROR: AWS reports delete-user operation failed.$response" return 1 fi iecho "delete-user response:$response" iecho return 0 } ``` + 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/PutUserPolicy) ------ #### [ C\$1\$1 ] **SDK for C\$1\$1** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples) 中查找完整示例，了解如何进行设置和运行。 ``` namespace AwsDoc { namespace IAM { //! Cleanup by deleting created entities. /*! \sa DeleteCreatedEntities \param client: IAM client. \param role: IAM role. \param user: IAM user. \param policy: IAM policy. */ static bool DeleteCreatedEntities(const Aws::IAM::IAMClient &client, const Aws::IAM::Model::Role &role, const Aws::IAM::Model::User &user, const Aws::IAM::Model::Policy &policy); } static const int LIST_BUCKETS_WAIT_SEC = 20; static const char ALLOCATION_TAG[] = "example_code"; } //! Scenario to create an IAM user, create an IAM role, and apply the role to the user. // "IAM access" permissions are needed to run this code. // "STS assume role" permissions are needed to run this code. (Note: It might be necessary to // create a custom policy). /*! \sa iamCreateUserAssumeRoleScenario \param clientConfig: Aws client configuration. \return bool: Successful completion. */ bool AwsDoc::IAM::iamCreateUserAssumeRoleScenario( const Aws::Client::ClientConfiguration &clientConfig) { Aws::IAM::IAMClient client(clientConfig); Aws::IAM::Model::User user; Aws::IAM::Model::Role role; Aws::IAM::Model::Policy policy; // 1. Create a user. { Aws::IAM::Model::CreateUserRequest request; Aws::String uuid = Aws::Utils::UUID::RandomUUID(); Aws::String userName = "iam-demo-user-" + Aws::Utils::StringUtils::ToLower(uuid.c_str()); request.SetUserName(userName); Aws::IAM::Model::CreateUserOutcome outcome = client.CreateUser(request); if (!outcome.IsSuccess()) { std::cout << "Error creating IAM user " << userName << ":" << outcome.GetError().GetMessage() << std::endl; return false; } else { std::cout << "Successfully created IAM user " << userName << std::endl; } user = outcome.GetResult().GetUser(); } // 2. Create a role. { // Get the IAM user for the current client in order to access its ARN. Aws::String iamUserArn; { Aws::IAM::Model::GetUserRequest request; Aws::IAM::Model::GetUserOutcome outcome = client.GetUser(request); if (!outcome.IsSuccess()) { std::cerr << "Error getting Iam user. " << outcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } else { std::cout << "Successfully retrieved Iam user " << outcome.GetResult().GetUser().GetUserName() << std::endl; } iamUserArn = outcome.GetResult().GetUser().GetArn(); } Aws::IAM::Model::CreateRoleRequest request; Aws::String uuid = Aws::Utils::UUID::RandomUUID(); Aws::String roleName = "iam-demo-role-" + Aws::Utils::StringUtils::ToLower(uuid.c_str()); request.SetRoleName(roleName); // Build policy document for role. Aws::Utils::Document jsonStatement; jsonStatement.WithString("Effect", "Allow"); Aws::Utils::Document jsonPrincipal; jsonPrincipal.WithString("AWS", iamUserArn); jsonStatement.WithObject("Principal", jsonPrincipal); jsonStatement.WithString("Action", "sts:AssumeRole"); jsonStatement.WithObject("Condition", Aws::Utils::Document()); Aws::Utils::Document policyDocument; policyDocument.WithString("Version", "2012-10-17"); Aws::Utils::Array statements(1); statements[0] = jsonStatement; policyDocument.WithArray("Statement", statements); std::cout << "Setting policy for role\n " << policyDocument.View().WriteCompact() << std::endl; // Set role policy document as JSON string. request.SetAssumeRolePolicyDocument(policyDocument.View().WriteCompact()); Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request); if (!outcome.IsSuccess()) { std::cerr << "Error creating role. " << outcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } else { std::cout << "Successfully created a role with name " << roleName << std::endl; } role = outcome.GetResult().GetRole(); } // 3. Create an IAM policy. { Aws::IAM::Model::CreatePolicyRequest request; Aws::String uuid = Aws::Utils::UUID::RandomUUID(); Aws::String policyName = "iam-demo-policy-" + Aws::Utils::StringUtils::ToLower(uuid.c_str()); request.SetPolicyName(policyName); // Build IAM policy document. Aws::Utils::Document jsonStatement; jsonStatement.WithString("Effect", "Allow"); jsonStatement.WithString("Action", "s3:ListAllMyBuckets"); jsonStatement.WithString("Resource", "arn:aws:s3:::*"); Aws::Utils::Document policyDocument; policyDocument.WithString("Version", "2012-10-17"); Aws::Utils::Array statements(1); statements[0] = jsonStatement; policyDocument.WithArray("Statement", statements); std::cout << "Creating a policy.\n " << policyDocument.View().WriteCompact() << std::endl; // Set IAM policy document as JSON string. request.SetPolicyDocument(policyDocument.View().WriteCompact()); Aws::IAM::Model::CreatePolicyOutcome outcome = client.CreatePolicy(request); if (!outcome.IsSuccess()) { std::cerr << "Error creating policy. " << outcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } else { std::cout << "Successfully created a policy with name, " << policyName << "." << std::endl; } policy = outcome.GetResult().GetPolicy(); } // 4. Assume the new role using the AWS Security Token Service (STS). Aws::STS::Model::Credentials credentials; { Aws::STS::STSClient stsClient(clientConfig); Aws::STS::Model::AssumeRoleRequest request; request.SetRoleArn(role.GetArn()); Aws::String uuid = Aws::Utils::UUID::RandomUUID(); Aws::String roleSessionName = "iam-demo-role-session-" + Aws::Utils::StringUtils::ToLower(uuid.c_str()); request.SetRoleSessionName(roleSessionName); Aws::STS::Model::AssumeRoleOutcome assumeRoleOutcome; // Repeatedly call AssumeRole, because there is often a delay // before the role is available to be assumed. // Repeat at most 20 times when access is denied. int count = 0; while (true) { assumeRoleOutcome = stsClient.AssumeRole(request); if (!assumeRoleOutcome.IsSuccess()) { if (count > 20 || assumeRoleOutcome.GetError().GetErrorType() != Aws::STS::STSErrors::ACCESS_DENIED) { std::cerr << "Error assuming role after 20 tries. " << assumeRoleOutcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } std::this_thread::sleep_for(std::chrono::seconds(1)); } else { std::cout << "Successfully assumed the role after " << count << " seconds." << std::endl; break; } count++; } credentials = assumeRoleOutcome.GetResult().GetCredentials(); } // 5. List objects in the bucket (This should fail). { Aws::S3::S3Client s3Client( Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(), credentials.GetSecretAccessKey(), credentials.GetSessionToken()), Aws::MakeShared(ALLOCATION_TAG), clientConfig); Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets(); if (!listBucketsOutcome.IsSuccess()) { if (listBucketsOutcome.GetError().GetErrorType() != Aws::S3::S3Errors::ACCESS_DENIED) { std::cerr << "Could not lists buckets. " << listBucketsOutcome.GetError().GetMessage() << std::endl; } else { std::cout << "Access to list buckets denied because privileges have not been applied." << std::endl; } } else { std::cerr << "Successfully retrieved bucket lists when this should not happen." << std::endl; } } // 6. Attach the policy to the role. { Aws::IAM::Model::AttachRolePolicyRequest request; request.SetRoleName(role.GetRoleName()); request.WithPolicyArn(policy.GetArn()); Aws::IAM::Model::AttachRolePolicyOutcome outcome = client.AttachRolePolicy( request); if (!outcome.IsSuccess()) { std::cerr << "Error creating policy. " << outcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } else { std::cout << "Successfully attached the policy with name, " << policy.GetPolicyName() << ", to the role, " << role.GetRoleName() << "." << std::endl; } } int count = 0; // 7. List objects in the bucket (this should succeed). // Repeatedly call ListBuckets, because there is often a delay // before the policy with ListBucket permissions has been applied to the role. // Repeat at most LIST_BUCKETS_WAIT_SEC times when access is denied. while (true) { Aws::S3::S3Client s3Client( Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(), credentials.GetSecretAccessKey(), credentials.GetSessionToken()), Aws::MakeShared(ALLOCATION_TAG), clientConfig); Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets(); if (!listBucketsOutcome.IsSuccess()) { if ((count > LIST_BUCKETS_WAIT_SEC) || listBucketsOutcome.GetError().GetErrorType() != Aws::S3::S3Errors::ACCESS_DENIED) { std::cerr << "Could not lists buckets after " << LIST_BUCKETS_WAIT_SEC << " seconds. " << listBucketsOutcome.GetError().GetMessage() << std::endl; DeleteCreatedEntities(client, role, user, policy); return false; } std::this_thread::sleep_for(std::chrono::seconds(1)); } else { std::cout << "Successfully retrieved bucket lists after " << count << " seconds." << std::endl; break; } count++; } // 8. Delete all the created resources. return DeleteCreatedEntities(client, role, user, policy); } bool AwsDoc::IAM::DeleteCreatedEntities(const Aws::IAM::IAMClient &client, const Aws::IAM::Model::Role &role, const Aws::IAM::Model::User &user, const Aws::IAM::Model::Policy &policy) { bool result = true; if (policy.ArnHasBeenSet()) { // Detach the policy from the role. { Aws::IAM::Model::DetachRolePolicyRequest request; request.SetPolicyArn(policy.GetArn()); request.SetRoleName(role.GetRoleName()); Aws::IAM::Model::DetachRolePolicyOutcome outcome = client.DetachRolePolicy( request); if (!outcome.IsSuccess()) { std::cerr << "Error Detaching policy from roles. " << outcome.GetError().GetMessage() << std::endl; result = false; } else { std::cout << "Successfully detached the policy with arn " << policy.GetArn() << " from role " << role.GetRoleName() << "." << std::endl; } } // Delete the policy. { Aws::IAM::Model::DeletePolicyRequest request; request.WithPolicyArn(policy.GetArn()); Aws::IAM::Model::DeletePolicyOutcome outcome = client.DeletePolicy(request); if (!outcome.IsSuccess()) { std::cerr << "Error deleting policy. " << outcome.GetError().GetMessage() << std::endl; result = false; } else { std::cout << "Successfully deleted the policy with arn " << policy.GetArn() << std::endl; } } } if (role.RoleIdHasBeenSet()) { // Delete the role. Aws::IAM::Model::DeleteRoleRequest request; request.SetRoleName(role.GetRoleName()); Aws::IAM::Model::DeleteRoleOutcome outcome = client.DeleteRole(request); if (!outcome.IsSuccess()) { std::cerr << "Error deleting role. " << outcome.GetError().GetMessage() << std::endl; result = false; } else { std::cout << "Successfully deleted the role with name " << role.GetRoleName() << std::endl; } } if (user.ArnHasBeenSet()) { // Delete the user. Aws::IAM::Model::DeleteUserRequest request; request.WithUserName(user.GetUserName()); Aws::IAM::Model::DeleteUserOutcome outcome = client.DeleteUser(request); if (!outcome.IsSuccess()) { std::cerr << "Error deleting user. " << outcome.GetError().GetMessage() << std::endl; result = false; } else { std::cout << "Successfully deleted the user with name " << user.GetUserName() << std::endl; } } return result; } ``` + 有关 API 的详细信息，请参阅 *适用于 C\$1\$1 的 AWS SDK API 参考*中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/PutUserPolicy) ------ #### [ Go ] **适用于 Go 的 SDK V2** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples)中查找完整示例，了解如何进行设置和运行。在命令提示符中运行交互式场景。 ``` import ( "context" "errors" "fmt" "log" "math/rand" "strings" "time" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/iam/types" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/sts" "github.com/aws/smithy-go" "github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools" "github.com/awsdocs/aws-doc-sdk-examples/gov2/iam/actions" ) // AssumeRoleScenario shows you how to use the AWS Identity and Access Management (IAM) // service to perform the following actions: // // 1. Create a user who has no permissions. // 2. Create a role that grants permission to list Amazon Simple Storage Service // (Amazon S3) buckets for the account. // 3. Add a policy to let the user assume the role. // 4. Try and fail to list buckets without permissions. // 5. Assume the role and list S3 buckets using temporary credentials. // 6. Delete the policy, role, and user. type AssumeRoleScenario struct { sdkConfig aws.Config accountWrapper actions.AccountWrapper policyWrapper actions.PolicyWrapper roleWrapper actions.RoleWrapper userWrapper actions.UserWrapper questioner demotools.IQuestioner helper IScenarioHelper isTestRun bool } // NewAssumeRoleScenario constructs an AssumeRoleScenario instance from a configuration. // It uses the specified config to get an IAM client and create wrappers for the actions // used in the scenario. func NewAssumeRoleScenario(sdkConfig aws.Config, questioner demotools.IQuestioner, helper IScenarioHelper) AssumeRoleScenario { iamClient := iam.NewFromConfig(sdkConfig) return AssumeRoleScenario{ sdkConfig: sdkConfig, accountWrapper: actions.AccountWrapper{IamClient: iamClient}, policyWrapper: actions.PolicyWrapper{IamClient: iamClient}, roleWrapper: actions.RoleWrapper{IamClient: iamClient}, userWrapper: actions.UserWrapper{IamClient: iamClient}, questioner: questioner, helper: helper, } } // addTestOptions appends the API options specified in the original configuration to // another configuration. This is used to attach the middleware stubber to clients // that are constructed during the scenario, which is needed for unit testing. func (scenario AssumeRoleScenario) addTestOptions(scenarioConfig *aws.Config) { if scenario.isTestRun { scenarioConfig.APIOptions = append(scenarioConfig.APIOptions, scenario.sdkConfig.APIOptions...) } } // Run runs the interactive scenario. func (scenario AssumeRoleScenario) Run(ctx context.Context) { defer func() { if r := recover(); r != nil { log.Printf("Something went wrong with the demo.\n") log.Println(r) } }() log.Println(strings.Repeat("-", 88)) log.Println("Welcome to the AWS Identity and Access Management (IAM) assume role demo.") log.Println(strings.Repeat("-", 88)) user := scenario.CreateUser(ctx) accessKey := scenario.CreateAccessKey(ctx, user) role := scenario.CreateRoleAndPolicies(ctx, user) noPermsConfig := scenario.ListBucketsWithoutPermissions(ctx, accessKey) scenario.ListBucketsWithAssumedRole(ctx, noPermsConfig, role) scenario.Cleanup(ctx, user, role) log.Println(strings.Repeat("-", 88)) log.Println("Thanks for watching!") log.Println(strings.Repeat("-", 88)) } // CreateUser creates a new IAM user. This user has no permissions. func (scenario AssumeRoleScenario) CreateUser(ctx context.Context) *types.User { log.Println("Let's create an example user with no permissions.") userName := scenario.questioner.Ask("Enter a name for the example user:", demotools.NotEmpty{}) user, err := scenario.userWrapper.GetUser(ctx, userName) if err != nil { panic(err) } if user == nil { user, err = scenario.userWrapper.CreateUser(ctx, userName) if err != nil { panic(err) } log.Printf("Created user %v.\n", *user.UserName) } else { log.Printf("User %v already exists.\n", *user.UserName) } log.Println(strings.Repeat("-", 88)) return user } // CreateAccessKey creates an access key for the user. func (scenario AssumeRoleScenario) CreateAccessKey(ctx context.Context, user *types.User) *types.AccessKey { accessKey, err := scenario.userWrapper.CreateAccessKeyPair(ctx, *user.UserName) if err != nil { panic(err) } log.Printf("Created access key %v for your user.", *accessKey.AccessKeyId) log.Println("Waiting a few seconds for your user to be ready...") scenario.helper.Pause(10) log.Println(strings.Repeat("-", 88)) return accessKey } // CreateRoleAndPolicies creates a policy that grants permission to list S3 buckets for // the current account and attaches the policy to a newly created role. It also adds an // inline policy to the specified user that grants the user permission to assume the role. func (scenario AssumeRoleScenario) CreateRoleAndPolicies(ctx context.Context, user *types.User) *types.Role { log.Println("Let's create a role and policy that grant permission to list S3 buckets.") scenario.questioner.Ask("Press Enter when you're ready.") listBucketsRole, err := scenario.roleWrapper.CreateRole(ctx, scenario.helper.GetName(), *user.Arn) if err != nil { panic(err) } log.Printf("Created role %v.\n", *listBucketsRole.RoleName) listBucketsPolicy, err := scenario.policyWrapper.CreatePolicy( ctx, scenario.helper.GetName(), []string{"s3:ListAllMyBuckets"}, "arn:aws:s3:::*") if err != nil { panic(err) } log.Printf("Created policy %v.\n", *listBucketsPolicy.PolicyName) err = scenario.roleWrapper.AttachRolePolicy(ctx, *listBucketsPolicy.Arn, *listBucketsRole.RoleName) if err != nil { panic(err) } log.Printf("Attached policy %v to role %v.\n", *listBucketsPolicy.PolicyName, *listBucketsRole.RoleName) err = scenario.userWrapper.CreateUserPolicy(ctx, *user.UserName, scenario.helper.GetName(), []string{"sts:AssumeRole"}, *listBucketsRole.Arn) if err != nil { panic(err) } log.Printf("Created an inline policy for user %v that lets the user assume the role.\n", *user.UserName) log.Println("Let's give AWS a few seconds to propagate these new resources and connections...") scenario.helper.Pause(10) log.Println(strings.Repeat("-", 88)) return listBucketsRole } // ListBucketsWithoutPermissions creates an Amazon S3 client from the user's access key // credentials and tries to list buckets for the account. Because the user does not have // permission to perform this action, the action fails. func (scenario AssumeRoleScenario) ListBucketsWithoutPermissions(ctx context.Context, accessKey *types.AccessKey) *aws.Config { log.Println("Let's try to list buckets without permissions. This should return an AccessDenied error.") scenario.questioner.Ask("Press Enter when you're ready.") noPermsConfig, err := config.LoadDefaultConfig(ctx, config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider( *accessKey.AccessKeyId, *accessKey.SecretAccessKey, ""), )) if err != nil { panic(err) } // Add test options if this is a test run. This is needed only for testing purposes. scenario.addTestOptions(&noPermsConfig) s3Client := s3.NewFromConfig(noPermsConfig) _, err = s3Client.ListBuckets(ctx, &s3.ListBucketsInput{}) if err != nil { // The SDK for Go does not model the AccessDenied error, so check ErrorCode directly. var ae smithy.APIError if errors.As(err, &ae) { switch ae.ErrorCode() { case "AccessDenied": log.Println("Got AccessDenied error, which is the expected result because\n" + "the ListBuckets call was made without permissions.") default: log.Println("Expected AccessDenied, got something else.") panic(err) } } } else { log.Println("Expected AccessDenied error when calling ListBuckets without permissions,\n" + "but the call succeeded. Continuing the example anyway...") } log.Println(strings.Repeat("-", 88)) return &noPermsConfig } // ListBucketsWithAssumedRole performs the following actions: // // 1. Creates an AWS Security Token Service (AWS STS) client from the config created from // the user's access key credentials. // 2. Gets temporary credentials by assuming the role that grants permission to list the // buckets. // 3. Creates an Amazon S3 client from the temporary credentials. // 4. Lists buckets for the account. Because the temporary credentials are generated by // assuming the role that grants permission, the action succeeds. func (scenario AssumeRoleScenario) ListBucketsWithAssumedRole(ctx context.Context, noPermsConfig *aws.Config, role *types.Role) { log.Println("Let's assume the role that grants permission to list buckets and try again.") scenario.questioner.Ask("Press Enter when you're ready.") stsClient := sts.NewFromConfig(*noPermsConfig) tempCredentials, err := stsClient.AssumeRole(ctx, &sts.AssumeRoleInput{ RoleArn: role.Arn, RoleSessionName: aws.String("AssumeRoleExampleSession"), DurationSeconds: aws.Int32(900), }) if err != nil { log.Printf("Couldn't assume role %v.\n", *role.RoleName) panic(err) } log.Printf("Assumed role %v, got temporary credentials.\n", *role.RoleName) assumeRoleConfig, err := config.LoadDefaultConfig(ctx, config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider( *tempCredentials.Credentials.AccessKeyId, *tempCredentials.Credentials.SecretAccessKey, *tempCredentials.Credentials.SessionToken), ), ) if err != nil { panic(err) } // Add test options if this is a test run. This is needed only for testing purposes. scenario.addTestOptions(&assumeRoleConfig) s3Client := s3.NewFromConfig(assumeRoleConfig) result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{}) if err != nil { log.Println("Couldn't list buckets with assumed role credentials.") panic(err) } log.Println("Successfully called ListBuckets with assumed role credentials, \n" + "here are some of them:") for i := 0; i < len(result.Buckets) && i < 5; i++ { log.Printf("\t%v\n", *result.Buckets[i].Name) } log.Println(strings.Repeat("-", 88)) } // Cleanup deletes all resources created for the scenario. func (scenario AssumeRoleScenario) Cleanup(ctx context.Context, user *types.User, role *types.Role) { if scenario.questioner.AskBool( "Do you want to delete the resources created for this example? (y/n)", "y", ) { policies, err := scenario.roleWrapper.ListAttachedRolePolicies(ctx, *role.RoleName) if err != nil { panic(err) } for _, policy := range policies { err = scenario.roleWrapper.DetachRolePolicy(ctx, *role.RoleName, *policy.PolicyArn) if err != nil { panic(err) } err = scenario.policyWrapper.DeletePolicy(ctx, *policy.PolicyArn) if err != nil { panic(err) } log.Printf("Detached policy %v from role %v and deleted the policy.\n", *policy.PolicyName, *role.RoleName) } err = scenario.roleWrapper.DeleteRole(ctx, *role.RoleName) if err != nil { panic(err) } log.Printf("Deleted role %v.\n", *role.RoleName) userPols, err := scenario.userWrapper.ListUserPolicies(ctx, *user.UserName) if err != nil { panic(err) } for _, userPol := range userPols { err = scenario.userWrapper.DeleteUserPolicy(ctx, *user.UserName, userPol) if err != nil { panic(err) } log.Printf("Deleted policy %v from user %v.\n", userPol, *user.UserName) } keys, err := scenario.userWrapper.ListAccessKeys(ctx, *user.UserName) if err != nil { panic(err) } for _, key := range keys { err = scenario.userWrapper.DeleteAccessKey(ctx, *user.UserName, *key.AccessKeyId) if err != nil { panic(err) } log.Printf("Deleted access key %v from user %v.\n", *key.AccessKeyId, *user.UserName) } err = scenario.userWrapper.DeleteUser(ctx, *user.UserName) if err != nil { panic(err) } log.Printf("Deleted user %v.\n", *user.UserName) log.Println(strings.Repeat("-", 88)) } } // IScenarioHelper abstracts input and wait functions from a scenario so that they // can be mocked for unit testing. type IScenarioHelper interface { GetName() string Pause(secs int) } const rMax = 100000 type ScenarioHelper struct { Prefix string Random *rand.Rand } // GetName returns a unique name formed of a prefix and a random number. func (helper *ScenarioHelper) GetName() string { return fmt.Sprintf("%v%v", helper.Prefix, helper.Random.Intn(rMax)) } // Pause waits for the specified number of seconds. func (helper ScenarioHelper) Pause(secs int) { time.Sleep(time.Duration(secs) * time.Second) } ``` 定义一个封装账户操作的结构。 ``` import ( "context" "log" "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/iam/types" ) // AccountWrapper encapsulates AWS Identity and Access Management (IAM) account actions // used in the examples. // It contains an IAM service client that is used to perform account actions. type AccountWrapper struct { IamClient *iam.Client } // GetAccountPasswordPolicy gets the account password policy for the current account. // If no policy has been set, a NoSuchEntityException is error is returned. func (wrapper AccountWrapper) GetAccountPasswordPolicy(ctx context.Context) (*types.PasswordPolicy, error) { var pwPolicy *types.PasswordPolicy result, err := wrapper.IamClient.GetAccountPasswordPolicy(ctx, &iam.GetAccountPasswordPolicyInput{}) if err != nil { log.Printf("Couldn't get account password policy. Here's why: %v\n", err) } else { pwPolicy = result.PasswordPolicy } return pwPolicy, err } // ListSAMLProviders gets the SAML providers for the account. func (wrapper AccountWrapper) ListSAMLProviders(ctx context.Context) ([]types.SAMLProviderListEntry, error) { var providers []types.SAMLProviderListEntry result, err := wrapper.IamClient.ListSAMLProviders(ctx, &iam.ListSAMLProvidersInput{}) if err != nil { log.Printf("Couldn't list SAML providers. Here's why: %v\n", err) } else { providers = result.SAMLProviderList } return providers, err } ``` 定义一个封装策略操作的结构。 ``` import ( "context" "encoding/json" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/iam/types" ) // PolicyWrapper encapsulates AWS Identity and Access Management (IAM) policy actions // used in the examples. // It contains an IAM service client that is used to perform policy actions. type PolicyWrapper struct { IamClient *iam.Client } // ListPolicies gets up to maxPolicies policies. func (wrapper PolicyWrapper) ListPolicies(ctx context.Context, maxPolicies int32) ([]types.Policy, error) { var policies []types.Policy result, err := wrapper.IamClient.ListPolicies(ctx, &iam.ListPoliciesInput{ MaxItems: aws.Int32(maxPolicies), }) if err != nil { log.Printf("Couldn't list policies. Here's why: %v\n", err) } else { policies = result.Policies } return policies, err } // PolicyDocument defines a policy document as a Go struct that can be serialized // to JSON. type PolicyDocument struct { Version string Statement []PolicyStatement } // PolicyStatement defines a statement in a policy document. type PolicyStatement struct { Effect string Action []string Principal map[string]string `json:",omitempty"` Resource *string `json:",omitempty"` } // CreatePolicy creates a policy that grants a list of actions to the specified resource. // PolicyDocument shows how to work with a policy document as a data structure and // serialize it to JSON by using Go's JSON marshaler. func (wrapper PolicyWrapper) CreatePolicy(ctx context.Context, policyName string, actions []string, resourceArn string) (*types.Policy, error) { var policy *types.Policy policyDoc := PolicyDocument{ Version: "2012-10-17", Statement: []PolicyStatement{{ Effect: "Allow", Action: actions, Resource: aws.String(resourceArn), }}, } policyBytes, err := json.Marshal(policyDoc) if err != nil { log.Printf("Couldn't create policy document for %v. Here's why: %v\n", resourceArn, err) return nil, err } result, err := wrapper.IamClient.CreatePolicy(ctx, &iam.CreatePolicyInput{ PolicyDocument: aws.String(string(policyBytes)), PolicyName: aws.String(policyName), }) if err != nil { log.Printf("Couldn't create policy %v. Here's why: %v\n", policyName, err) } else { policy = result.Policy } return policy, err } // GetPolicy gets data about a policy. func (wrapper PolicyWrapper) GetPolicy(ctx context.Context, policyArn string) (*types.Policy, error) { var policy *types.Policy result, err := wrapper.IamClient.GetPolicy(ctx, &iam.GetPolicyInput{ PolicyArn: aws.String(policyArn), }) if err != nil { log.Printf("Couldn't get policy %v. Here's why: %v\n", policyArn, err) } else { policy = result.Policy } return policy, err } // DeletePolicy deletes a policy. func (wrapper PolicyWrapper) DeletePolicy(ctx context.Context, policyArn string) error { _, err := wrapper.IamClient.DeletePolicy(ctx, &iam.DeletePolicyInput{ PolicyArn: aws.String(policyArn), }) if err != nil { log.Printf("Couldn't delete policy %v. Here's why: %v\n", policyArn, err) } return err } ``` 定义一个封装角色操作的结构。 ``` import ( "context" "encoding/json" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/iam/types" ) // RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions // used in the examples. // It contains an IAM service client that is used to perform role actions. type RoleWrapper struct { IamClient *iam.Client } // ListRoles gets up to maxRoles roles. func (wrapper RoleWrapper) ListRoles(ctx context.Context, maxRoles int32) ([]types.Role, error) { var roles []types.Role result, err := wrapper.IamClient.ListRoles(ctx, &iam.ListRolesInput{MaxItems: aws.Int32(maxRoles)}, ) if err != nil { log.Printf("Couldn't list roles. Here's why: %v\n", err) } else { roles = result.Roles } return roles, err } // CreateRole creates a role that trusts a specified user. The trusted user can assume // the role to acquire its permissions. // PolicyDocument shows how to work with a policy document as a data structure and // serialize it to JSON by using Go's JSON marshaler. func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) { var role *types.Role trustPolicy := PolicyDocument{ Version: "2012-10-17", Statement: []PolicyStatement{{ Effect: "Allow", Principal: map[string]string{"AWS": trustedUserArn}, Action: []string{"sts:AssumeRole"}, }}, } policyBytes, err := json.Marshal(trustPolicy) if err != nil { log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err) return nil, err } result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{ AssumeRolePolicyDocument: aws.String(string(policyBytes)), RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err) } else { role = result.Role } return role, err } // GetRole gets data about a role. func (wrapper RoleWrapper) GetRole(ctx context.Context, roleName string) (*types.Role, error) { var role *types.Role result, err := wrapper.IamClient.GetRole(ctx, &iam.GetRoleInput{RoleName: aws.String(roleName)}) if err != nil { log.Printf("Couldn't get role %v. Here's why: %v\n", roleName, err) } else { role = result.Role } return role, err } // CreateServiceLinkedRole creates a service-linked role that is owned by the specified service. func (wrapper RoleWrapper) CreateServiceLinkedRole(ctx context.Context, serviceName string, description string) ( *types.Role, error) { var role *types.Role result, err := wrapper.IamClient.CreateServiceLinkedRole(ctx, &iam.CreateServiceLinkedRoleInput{ AWSServiceName: aws.String(serviceName), Description: aws.String(description), }) if err != nil { log.Printf("Couldn't create service-linked role %v. Here's why: %v\n", serviceName, err) } else { role = result.Role } return role, err } // DeleteServiceLinkedRole deletes a service-linked role. func (wrapper RoleWrapper) DeleteServiceLinkedRole(ctx context.Context, roleName string) error { _, err := wrapper.IamClient.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{ RoleName: aws.String(roleName)}, ) if err != nil { log.Printf("Couldn't delete service-linked role %v. Here's why: %v\n", roleName, err) } return err } // AttachRolePolicy attaches a policy to a role. func (wrapper RoleWrapper) AttachRolePolicy(ctx context.Context, policyArn string, roleName string) error { _, err := wrapper.IamClient.AttachRolePolicy(ctx, &iam.AttachRolePolicyInput{ PolicyArn: aws.String(policyArn), RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't attach policy %v to role %v. Here's why: %v\n", policyArn, roleName, err) } return err } // ListAttachedRolePolicies lists the policies that are attached to the specified role. func (wrapper RoleWrapper) ListAttachedRolePolicies(ctx context.Context, roleName string) ([]types.AttachedPolicy, error) { var policies []types.AttachedPolicy result, err := wrapper.IamClient.ListAttachedRolePolicies(ctx, &iam.ListAttachedRolePoliciesInput{ RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't list attached policies for role %v. Here's why: %v\n", roleName, err) } else { policies = result.AttachedPolicies } return policies, err } // DetachRolePolicy detaches a policy from a role. func (wrapper RoleWrapper) DetachRolePolicy(ctx context.Context, roleName string, policyArn string) error { _, err := wrapper.IamClient.DetachRolePolicy(ctx, &iam.DetachRolePolicyInput{ PolicyArn: aws.String(policyArn), RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't detach policy from role %v. Here's why: %v\n", roleName, err) } return err } // ListRolePolicies lists the inline policies for a role. func (wrapper RoleWrapper) ListRolePolicies(ctx context.Context, roleName string) ([]string, error) { var policies []string result, err := wrapper.IamClient.ListRolePolicies(ctx, &iam.ListRolePoliciesInput{ RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't list policies for role %v. Here's why: %v\n", roleName, err) } else { policies = result.PolicyNames } return policies, err } // DeleteRole deletes a role. All attached policies must be detached before a // role can be deleted. func (wrapper RoleWrapper) DeleteRole(ctx context.Context, roleName string) error { _, err := wrapper.IamClient.DeleteRole(ctx, &iam.DeleteRoleInput{ RoleName: aws.String(roleName), }) if err != nil { log.Printf("Couldn't delete role %v. Here's why: %v\n", roleName, err) } return err } ``` 定义一个封装用户操作的结构。 ``` import ( "context" "encoding/json" "errors" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/iam/types" "github.com/aws/smithy-go" ) // UserWrapper encapsulates user actions used in the examples. // It contains an IAM service client that is used to perform user actions. type UserWrapper struct { IamClient *iam.Client } // ListUsers gets up to maxUsers number of users. func (wrapper UserWrapper) ListUsers(ctx context.Context, maxUsers int32) ([]types.User, error) { var users []types.User result, err := wrapper.IamClient.ListUsers(ctx, &iam.ListUsersInput{ MaxItems: aws.Int32(maxUsers), }) if err != nil { log.Printf("Couldn't list users. Here's why: %v\n", err) } else { users = result.Users } return users, err } // GetUser gets data about a user. func (wrapper UserWrapper) GetUser(ctx context.Context, userName string) (*types.User, error) { var user *types.User result, err := wrapper.IamClient.GetUser(ctx, &iam.GetUserInput{ UserName: aws.String(userName), }) if err != nil { var apiError smithy.APIError if errors.As(err, &apiError) { switch apiError.(type) { case *types.NoSuchEntityException: log.Printf("User %v does not exist.\n", userName) err = nil default: log.Printf("Couldn't get user %v. Here's why: %v\n", userName, err) } } } else { user = result.User } return user, err } // CreateUser creates a new user with the specified name. func (wrapper UserWrapper) CreateUser(ctx context.Context, userName string) (*types.User, error) { var user *types.User result, err := wrapper.IamClient.CreateUser(ctx, &iam.CreateUserInput{ UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't create user %v. Here's why: %v\n", userName, err) } else { user = result.User } return user, err } // CreateUserPolicy adds an inline policy to a user. This example creates a policy that // grants a list of actions on a specified role. // PolicyDocument shows how to work with a policy document as a data structure and // serialize it to JSON by using Go's JSON marshaler. func (wrapper UserWrapper) CreateUserPolicy(ctx context.Context, userName string, policyName string, actions []string, roleArn string) error { policyDoc := PolicyDocument{ Version: "2012-10-17", Statement: []PolicyStatement{{ Effect: "Allow", Action: actions, Resource: aws.String(roleArn), }}, } policyBytes, err := json.Marshal(policyDoc) if err != nil { log.Printf("Couldn't create policy document for %v. Here's why: %v\n", roleArn, err) return err } _, err = wrapper.IamClient.PutUserPolicy(ctx, &iam.PutUserPolicyInput{ PolicyDocument: aws.String(string(policyBytes)), PolicyName: aws.String(policyName), UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't create policy for user %v. Here's why: %v\n", userName, err) } return err } // ListUserPolicies lists the inline policies for the specified user. func (wrapper UserWrapper) ListUserPolicies(ctx context.Context, userName string) ([]string, error) { var policies []string result, err := wrapper.IamClient.ListUserPolicies(ctx, &iam.ListUserPoliciesInput{ UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't list policies for user %v. Here's why: %v\n", userName, err) } else { policies = result.PolicyNames } return policies, err } // DeleteUserPolicy deletes an inline policy from a user. func (wrapper UserWrapper) DeleteUserPolicy(ctx context.Context, userName string, policyName string) error { _, err := wrapper.IamClient.DeleteUserPolicy(ctx, &iam.DeleteUserPolicyInput{ PolicyName: aws.String(policyName), UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't delete policy from user %v. Here's why: %v\n", userName, err) } return err } // DeleteUser deletes a user. func (wrapper UserWrapper) DeleteUser(ctx context.Context, userName string) error { _, err := wrapper.IamClient.DeleteUser(ctx, &iam.DeleteUserInput{ UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't delete user %v. Here's why: %v\n", userName, err) } return err } // CreateAccessKeyPair creates an access key for a user. The returned access key contains // the ID and secret credentials needed to use the key. func (wrapper UserWrapper) CreateAccessKeyPair(ctx context.Context, userName string) (*types.AccessKey, error) { var key *types.AccessKey result, err := wrapper.IamClient.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{ UserName: aws.String(userName)}) if err != nil { log.Printf("Couldn't create access key pair for user %v. Here's why: %v\n", userName, err) } else { key = result.AccessKey } return key, err } // DeleteAccessKey deletes an access key from a user. func (wrapper UserWrapper) DeleteAccessKey(ctx context.Context, userName string, keyId string) error { _, err := wrapper.IamClient.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{ AccessKeyId: aws.String(keyId), UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't delete access key %v. Here's why: %v\n", keyId, err) } return err } // ListAccessKeys lists the access keys for the specified user. func (wrapper UserWrapper) ListAccessKeys(ctx context.Context, userName string) ([]types.AccessKeyMetadata, error) { var keys []types.AccessKeyMetadata result, err := wrapper.IamClient.ListAccessKeys(ctx, &iam.ListAccessKeysInput{ UserName: aws.String(userName), }) if err != nil { log.Printf("Couldn't list access keys for user %v. Here's why: %v\n", userName, err) } else { keys = result.AccessKeyMetadata } return keys, err } ``` + 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的以下主题。 + [AttachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.AttachRolePolicy) + [CreateAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateAccessKey) + [CreatePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreatePolicy) + [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole) + [CreateUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateUser) + [DeleteAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteAccessKey) + [DeletePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeletePolicy) + [DeleteRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteRole) + [DeleteUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUser) + [DeleteUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUserPolicy) + [DetachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DetachRolePolicy) + [PutUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.PutUserPolicy) ------ #### [ Java ] **适用于 Java 的 SDK 2.x** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples)中查找完整示例，了解如何进行设置和运行。创建包装 IAM 用户操作的函数。 ``` /* To run this Java V2 code example, set up your development environment, including your credentials. For information, see this documentation topic: https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html This example performs these operations: 1. Creates a user that has no permissions. 2. Creates a role and policy that grants Amazon S3 permissions. 3. Creates a role. 4. Grants the user permissions. 5. Gets temporary credentials by assuming the role. Creates an Amazon S3 Service client object with the temporary credentials. 6. Deletes the resources. */ public class IAMScenario { public static final String DASHES = new String(new char[80]).replace("\0", "-"); public static final String PolicyDocument = "{" + " \"Version\": \"2012-10-17\"," + " \"Statement\": [" + " {" + " \"Effect\": \"Allow\"," + " \"Action\": [" + " \"s3:*\"" + " ]," + " \"Resource\": \"*\"" + " }" + " ]" + "}"; public static String userArn; public static void main(String[] args) throws Exception { final String usage = """ Usage: \s Where: username - The name of the IAM user to create.\s policyName - The name of the policy to create.\s roleName - The name of the role to create.\s roleSessionName - The name of the session required for the assumeRole operation.\s bucketName - The name of the Amazon S3 bucket from which objects are read.\s """; if (args.length != 5) { System.out.println(usage); System.exit(1); } String userName = args[0]; String policyName = args[1]; String roleName = args[2]; String roleSessionName = args[3]; String bucketName = args[4]; Region region = Region.AWS_GLOBAL; IamClient iam = IamClient.builder() .region(region) .build(); System.out.println(DASHES); System.out.println("Welcome to the AWS IAM example scenario."); System.out.println(DASHES); System.out.println(DASHES); System.out.println(" 1. Create the IAM user."); User createUser = createIAMUser(iam, userName); System.out.println(DASHES); userArn = createUser.arn(); AccessKey myKey = createIAMAccessKey(iam, userName); String accessKey = myKey.accessKeyId(); String secretKey = myKey.secretAccessKey(); String assumeRolePolicyDocument = "{" + "\"Version\": \"2012-10-17\"," + "\"Statement\": [{" + "\"Effect\": \"Allow\"," + "\"Principal\": {" + " \"AWS\": \"" + userArn + "\"" + "}," + "\"Action\": \"sts:AssumeRole\"" + "}]" + "}"; System.out.println(assumeRolePolicyDocument); System.out.println(userName + " was successfully created."); System.out.println(DASHES); System.out.println("2. Creates a policy."); String polArn = createIAMPolicy(iam, policyName); System.out.println("The policy " + polArn + " was successfully created."); System.out.println(DASHES); System.out.println(DASHES); System.out.println("3. Creates a role."); TimeUnit.SECONDS.sleep(30); String roleArn = createIAMRole(iam, roleName, assumeRolePolicyDocument); System.out.println(roleArn + " was successfully created."); System.out.println(DASHES); System.out.println(DASHES); System.out.println("4. Grants the user permissions."); attachIAMRolePolicy(iam, roleName, polArn); System.out.println(DASHES); System.out.println(DASHES); System.out.println("*** Wait for 30 secs so the resource is available"); TimeUnit.SECONDS.sleep(30); System.out.println("5. Gets temporary credentials by assuming the role."); System.out.println("Perform an Amazon S3 Service operation using the temporary credentials."); assumeRole(roleArn, roleSessionName, bucketName, accessKey, secretKey); System.out.println(DASHES); System.out.println(DASHES); System.out.println("6 Getting ready to delete the AWS resources"); deleteKey(iam, userName, accessKey); deleteRole(iam, roleName, polArn); deleteIAMUser(iam, userName); System.out.println(DASHES); System.out.println(DASHES); System.out.println("This IAM Scenario has successfully completed"); System.out.println(DASHES); } public static AccessKey createIAMAccessKey(IamClient iam, String user) { try { CreateAccessKeyRequest request = CreateAccessKeyRequest.builder() .userName(user) .build(); CreateAccessKeyResponse response = iam.createAccessKey(request); return response.accessKey(); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return null; } public static User createIAMUser(IamClient iam, String username) { try { // Create an IamWaiter object IamWaiter iamWaiter = iam.waiter(); CreateUserRequest request = CreateUserRequest.builder() .userName(username) .build(); // Wait until the user is created. CreateUserResponse response = iam.createUser(request); GetUserRequest userRequest = GetUserRequest.builder() .userName(response.user().userName()) .build(); WaiterResponse waitUntilUserExists = iamWaiter.waitUntilUserExists(userRequest); waitUntilUserExists.matched().response().ifPresent(System.out::println); return response.user(); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return null; } public static String createIAMRole(IamClient iam, String rolename, String json) { try { CreateRoleRequest request = CreateRoleRequest.builder() .roleName(rolename) .assumeRolePolicyDocument(json) .description("Created using the AWS SDK for Java") .build(); CreateRoleResponse response = iam.createRole(request); System.out.println("The ARN of the role is " + response.role().arn()); return response.role().arn(); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return ""; } public static String createIAMPolicy(IamClient iam, String policyName) { try { // Create an IamWaiter object. IamWaiter iamWaiter = iam.waiter(); CreatePolicyRequest request = CreatePolicyRequest.builder() .policyName(policyName) .policyDocument(PolicyDocument).build(); CreatePolicyResponse response = iam.createPolicy(request); GetPolicyRequest polRequest = GetPolicyRequest.builder() .policyArn(response.policy().arn()) .build(); WaiterResponse waitUntilPolicyExists = iamWaiter.waitUntilPolicyExists(polRequest); waitUntilPolicyExists.matched().response().ifPresent(System.out::println); return response.policy().arn(); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return ""; } public static void attachIAMRolePolicy(IamClient iam, String roleName, String policyArn) { try { ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder() .roleName(roleName) .build(); ListAttachedRolePoliciesResponse response = iam.listAttachedRolePolicies(request); List attachedPolicies = response.attachedPolicies(); String polArn; for (AttachedPolicy policy : attachedPolicies) { polArn = policy.policyArn(); if (polArn.compareTo(policyArn) == 0) { System.out.println(roleName + " policy is already attached to this role."); return; } } AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder() .roleName(roleName) .policyArn(policyArn) .build(); iam.attachRolePolicy(attachRequest); System.out.println("Successfully attached policy " + policyArn + " to role " + roleName); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } // Invoke an Amazon S3 operation using the Assumed Role. public static void assumeRole(String roleArn, String roleSessionName, String bucketName, String keyVal, String keySecret) { // Use the creds of the new IAM user that was created in this code example. AwsBasicCredentials credentials = AwsBasicCredentials.create(keyVal, keySecret); StsClient stsClient = StsClient.builder() .region(Region.US_EAST_1) .credentialsProvider(StaticCredentialsProvider.create(credentials)) .build(); try { AssumeRoleRequest roleRequest = AssumeRoleRequest.builder() .roleArn(roleArn) .roleSessionName(roleSessionName) .build(); AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest); Credentials myCreds = roleResponse.credentials(); String key = myCreds.accessKeyId(); String secKey = myCreds.secretAccessKey(); String secToken = myCreds.sessionToken(); // List all objects in an Amazon S3 bucket using the temp creds retrieved by // invoking assumeRole. Region region = Region.US_EAST_1; S3Client s3 = S3Client.builder() .credentialsProvider( StaticCredentialsProvider.create(AwsSessionCredentials.create(key, secKey, secToken))) .region(region) .build(); System.out.println("Created a S3Client using temp credentials."); System.out.println("Listing objects in " + bucketName); ListObjectsRequest listObjects = ListObjectsRequest.builder() .bucket(bucketName) .build(); ListObjectsResponse res = s3.listObjects(listObjects); List objects = res.contents(); for (S3Object myValue : objects) { System.out.println("The name of the key is " + myValue.key()); System.out.println("The owner is " + myValue.owner()); } } catch (StsException e) { System.err.println(e.getMessage()); System.exit(1); } } public static void deleteRole(IamClient iam, String roleName, String polArn) { try { // First the policy needs to be detached. DetachRolePolicyRequest rolePolicyRequest = DetachRolePolicyRequest.builder() .policyArn(polArn) .roleName(roleName) .build(); iam.detachRolePolicy(rolePolicyRequest); // Delete the policy. DeletePolicyRequest request = DeletePolicyRequest.builder() .policyArn(polArn) .build(); iam.deletePolicy(request); System.out.println("*** Successfully deleted " + polArn); // Delete the role. DeleteRoleRequest roleRequest = DeleteRoleRequest.builder() .roleName(roleName) .build(); iam.deleteRole(roleRequest); System.out.println("*** Successfully deleted " + roleName); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void deleteKey(IamClient iam, String username, String accessKey) { try { DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder() .accessKeyId(accessKey) .userName(username) .build(); iam.deleteAccessKey(request); System.out.println("Successfully deleted access key " + accessKey + " from user " + username); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void deleteIAMUser(IamClient iam, String userName) { try { DeleteUserRequest request = DeleteUserRequest.builder() .userName(userName) .build(); iam.deleteUser(request); System.out.println("*** Successfully deleted " + userName); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } } ``` + 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/PutUserPolicy) ------ #### [ JavaScript ] **SDK for JavaScript (v3)** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples)中查找完整示例，了解如何进行设置和运行。创建 IAM 用户和授予列出 Amazon S3 存储桶的权限的角色。用户仅具有代入该角色的权限。代入该角色后，使用临时凭证列出该账户的存储桶。 ``` import { CreateUserCommand, GetUserCommand, CreateAccessKeyCommand, CreatePolicyCommand, CreateRoleCommand, AttachRolePolicyCommand, DeleteAccessKeyCommand, DeleteUserCommand, DeleteRoleCommand, DeletePolicyCommand, DetachRolePolicyCommand, IAMClient, } from "@aws-sdk/client-iam"; import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3"; import { AssumeRoleCommand, STSClient } from "@aws-sdk/client-sts"; import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js"; import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario/index.js"; // Set the parameters. const iamClient = new IAMClient({}); const userName = "iam_basic_test_username"; const policyName = "iam_basic_test_policy"; const roleName = "iam_basic_test_role"; /** * Create a new IAM user. If the user already exists, give * the option to delete and re-create it. * @param {string} name */ export const createUser = async (name, confirmAll = false) => { try { const { User } = await iamClient.send( new GetUserCommand({ UserName: name }), ); const input = new ScenarioInput( "deleteUser", "Do you want to delete and remake this user?", { type: "confirm" }, ); const deleteUser = await input.handle({}, { confirmAll }); // If the user exists, and you want to delete it, delete the user // and then create it again. if (deleteUser) { await iamClient.send(new DeleteUserCommand({ UserName: User.UserName })); await iamClient.send(new CreateUserCommand({ UserName: name })); } else { console.warn( `${name} already exists. The scenario may not work as expected.`, ); return User; } } catch (caught) { // If there is no user by that name, create one. if (caught instanceof Error && caught.name === "NoSuchEntityException") { const { User } = await iamClient.send( new CreateUserCommand({ UserName: name }), ); return User; } throw caught; } }; export const main = async (confirmAll = false) => { // Create a user. The user has no permissions by default. const User = await createUser(userName, confirmAll); if (!User) { throw new Error("User not created"); } // Create an access key. This key is used to authenticate the new user to // Amazon Simple Storage Service (Amazon S3) and AWS Security Token Service (AWS STS). // It's not best practice to use access keys. For more information, see https://aws.amazon.com/iam/resources/best-practices/. const createAccessKeyResponse = await iamClient.send( new CreateAccessKeyCommand({ UserName: userName }), ); if ( !createAccessKeyResponse.AccessKey?.AccessKeyId || !createAccessKeyResponse.AccessKey?.SecretAccessKey ) { throw new Error("Access key not created"); } const { AccessKey: { AccessKeyId, SecretAccessKey }, } = createAccessKeyResponse; let s3Client = new S3Client({ credentials: { accessKeyId: AccessKeyId, secretAccessKey: SecretAccessKey, }, }); // Retry the list buckets operation until it succeeds. InvalidAccessKeyId is // thrown while the user and access keys are still stabilizing. await retry({ intervalInMs: 1000, maxRetries: 300 }, async () => { try { return await listBuckets(s3Client); } catch (err) { if (err instanceof Error && err.name === "InvalidAccessKeyId") { throw err; } } }); // Retry the create role operation until it succeeds. A MalformedPolicyDocument error // is thrown while the user and access keys are still stabilizing. const { Role } = await retry( { intervalInMs: 2000, maxRetries: 60, }, () => iamClient.send( new CreateRoleCommand({ AssumeRolePolicyDocument: JSON.stringify({ Version: "2012-10-17", Statement: [ { Effect: "Allow", Principal: { // Allow the previously created user to assume this role. AWS: User.Arn, }, Action: "sts:AssumeRole", }, ], }), RoleName: roleName, }), ), ); if (!Role) { throw new Error("Role not created"); } // Create a policy that allows the user to list S3 buckets. const { Policy: listBucketPolicy } = await iamClient.send( new CreatePolicyCommand({ PolicyDocument: JSON.stringify({ Version: "2012-10-17", Statement: [ { Effect: "Allow", Action: ["s3:ListAllMyBuckets"], Resource: "*", }, ], }), PolicyName: policyName, }), ); if (!listBucketPolicy) { throw new Error("Policy not created"); } // Attach the policy granting the 's3:ListAllMyBuckets' action to the role. await iamClient.send( new AttachRolePolicyCommand({ PolicyArn: listBucketPolicy.Arn, RoleName: Role.RoleName, }), ); // Assume the role. const stsClient = new STSClient({ credentials: { accessKeyId: AccessKeyId, secretAccessKey: SecretAccessKey, }, }); // Retry the assume role operation until it succeeds. const { Credentials } = await retry( { intervalInMs: 2000, maxRetries: 60 }, () => stsClient.send( new AssumeRoleCommand({ RoleArn: Role.Arn, RoleSessionName: `iamBasicScenarioSession-${Math.floor( Math.random() * 1000000, )}`, DurationSeconds: 900, }), ), ); if (!Credentials?.AccessKeyId || !Credentials?.SecretAccessKey) { throw new Error("Credentials not created"); } s3Client = new S3Client({ credentials: { accessKeyId: Credentials.AccessKeyId, secretAccessKey: Credentials.SecretAccessKey, sessionToken: Credentials.SessionToken, }, }); // List the S3 buckets again. // Retry the list buckets operation until it succeeds. AccessDenied might // be thrown while the role policy is still stabilizing. await retry({ intervalInMs: 2000, maxRetries: 120 }, () => listBuckets(s3Client), ); // Clean up. await iamClient.send( new DetachRolePolicyCommand({ PolicyArn: listBucketPolicy.Arn, RoleName: Role.RoleName, }), ); await iamClient.send( new DeletePolicyCommand({ PolicyArn: listBucketPolicy.Arn, }), ); await iamClient.send( new DeleteRoleCommand({ RoleName: Role.RoleName, }), ); await iamClient.send( new DeleteAccessKeyCommand({ UserName: userName, AccessKeyId, }), ); await iamClient.send( new DeleteUserCommand({ UserName: userName, }), ); }; /** * * @param {S3Client} s3Client */ const listBuckets = async (s3Client) => { const { Buckets } = await s3Client.send(new ListBucketsCommand({})); if (!Buckets) { throw new Error("Buckets not listed"); } console.log(Buckets.map((bucket) => bucket.Name).join("\n")); }; ``` + 有关 API 详细信息，请参阅《适用于 JavaScript 的 AWS SDK API Reference》**中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/AttachRolePolicyCommand) + [CreateAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateAccessKeyCommand) + [CreatePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreatePolicyCommand) + [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand) + [CreateUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateUserCommand) + [DeleteAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteAccessKeyCommand) + [DeletePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeletePolicyCommand) + [DeleteRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteRoleCommand) + [DeleteUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserCommand) + [DeleteUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserPolicyCommand) + [DetachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DetachRolePolicyCommand) + [PutUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/PutUserPolicyCommand) ------ #### [ Kotlin ] **适用于 Kotlin 的 SDK** 查看 GitHub，了解更多信息。查找完整示例，学习如何在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/iam#code-examples)中进行设置和运行。创建包装 IAM 用户操作的函数。 ``` suspend fun main(args: Array) { val usage = """ Usage: Where: username - The name of the IAM user to create. policyName - The name of the policy to create. roleName - The name of the role to create. roleSessionName - The name of the session required for the assumeRole operation. fileLocation - The file location to the JSON required to create the role (see Readme). bucketName - The name of the Amazon S3 bucket from which objects are read. """ if (args.size != 6) { println(usage) exitProcess(1) } val userName = args[0] val policyName = args[1] val roleName = args[2] val roleSessionName = args[3] val fileLocation = args[4] val bucketName = args[5] createUser(userName) println("$userName was successfully created.") val polArn = createPolicy(policyName) println("The policy $polArn was successfully created.") val roleArn = createRole(roleName, fileLocation) println("$roleArn was successfully created.") attachRolePolicy(roleName, polArn) println("*** Wait for 1 MIN so the resource is available.") delay(60000) assumeGivenRole(roleArn, roleSessionName, bucketName) println("*** Getting ready to delete the AWS resources.") deleteRole(roleName, polArn) deleteUser(userName) println("This IAM Scenario has successfully completed.") } suspend fun createUser(usernameVal: String?): String? { val request = CreateUserRequest { userName = usernameVal } IamClient { region = "AWS_GLOBAL" }.use { iamClient -> val response = iamClient.createUser(request) return response.user?.userName } } suspend fun createPolicy(policyNameVal: String?): String { val policyDocumentValue = """ { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:*" ], "Resource": "*" } ] } """.trimIndent() val request = CreatePolicyRequest { policyName = policyNameVal policyDocument = policyDocumentValue } IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient -> val response = iamClient.createPolicy(request) return response.policy?.arn.toString() } } suspend fun createRole( rolenameVal: String?, fileLocation: String?, ): String? { val jsonObject = fileLocation?.let { readJsonSimpleDemo(it) } as JSONObject val request = CreateRoleRequest { roleName = rolenameVal assumeRolePolicyDocument = jsonObject.toJSONString() description = "Created using the AWS SDK for Kotlin" } IamClient { region = "AWS_GLOBAL" }.use { iamClient -> val response = iamClient.createRole(request) return response.role?.arn } } suspend fun attachRolePolicy( roleNameVal: String, policyArnVal: String, ) { val request = ListAttachedRolePoliciesRequest { roleName = roleNameVal } IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient -> val response = iamClient.listAttachedRolePolicies(request) val attachedPolicies = response.attachedPolicies // Ensure that the policy is not attached to this role. val checkStatus: Int if (attachedPolicies != null) { checkStatus = checkMyList(attachedPolicies, policyArnVal) if (checkStatus == -1) { return } } val policyRequest = AttachRolePolicyRequest { roleName = roleNameVal policyArn = policyArnVal } iamClient.attachRolePolicy(policyRequest) println("Successfully attached policy $policyArnVal to role $roleNameVal") } } fun checkMyList( attachedPolicies: List, policyArnVal: String, ): Int { for (policy in attachedPolicies) { val polArn = policy.policyArn.toString() if (polArn.compareTo(policyArnVal) == 0) { println("The policy is already attached to this role.") return -1 } } return 0 } suspend fun assumeGivenRole( roleArnVal: String?, roleSessionNameVal: String?, bucketName: String, ) { val stsClient = StsClient.fromEnvironment { region = "us-east-1" } val roleRequest = AssumeRoleRequest { roleArn = roleArnVal roleSessionName = roleSessionNameVal } val roleResponse = stsClient.assumeRole(roleRequest) val myCreds = roleResponse.credentials val key = myCreds?.accessKeyId val secKey = myCreds?.secretAccessKey val secToken = myCreds?.sessionToken val staticCredentials = StaticCredentialsProvider { accessKeyId = key secretAccessKey = secKey sessionToken = secToken } // List all objects in an Amazon S3 bucket using the temp creds. val s3 = S3Client.fromEnvironment { region = "us-east-1" credentialsProvider = staticCredentials } println("Created a S3Client using temp credentials.") println("Listing objects in $bucketName") val listObjects = ListObjectsRequest { bucket = bucketName } val response = s3.listObjects(listObjects) response.contents?.forEach { myObject -> println("The name of the key is ${myObject.key}") println("The owner is ${myObject.owner}") } } suspend fun deleteRole( roleNameVal: String, polArn: String, ) { val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" } // First the policy needs to be detached. val rolePolicyRequest = DetachRolePolicyRequest { policyArn = polArn roleName = roleNameVal } iam.detachRolePolicy(rolePolicyRequest) // Delete the policy. val request = DeletePolicyRequest { policyArn = polArn } iam.deletePolicy(request) println("*** Successfully deleted $polArn") // Delete the role. val roleRequest = DeleteRoleRequest { roleName = roleNameVal } iam.deleteRole(roleRequest) println("*** Successfully deleted $roleNameVal") } suspend fun deleteUser(userNameVal: String) { val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" } val request = DeleteUserRequest { userName = userNameVal } iam.deleteUser(request) println("*** Successfully deleted $userNameVal") } @Throws(java.lang.Exception::class) fun readJsonSimpleDemo(filename: String): Any? { val reader = FileReader(filename) val jsonParser = JSONParser() return jsonParser.parse(reader) } ``` + 有关 API 详细信息，请参阅《AWS SDK for Kotlin API Reference》**中的以下主题。 + [AttachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [CreateAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [CreatePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [CreateRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [CreateUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DeleteAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DeletePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DeleteRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DeleteUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DeleteUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [DetachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) + [PutUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html) ------ #### [ PHP ] **适用于 PHP 的 SDK** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples) 中查找完整示例，了解如何进行设置和运行。 ``` namespace Iam\Basics; require 'vendor/autoload.php'; use Aws\Credentials\Credentials; use Aws\S3\Exception\S3Exception; use Aws\S3\S3Client; use Aws\Sts\StsClient; use Iam\IAMService; echo("\n"); echo("--------------------------------------\n"); print("Welcome to the IAM getting started demo using PHP!\n"); echo("--------------------------------------\n"); $uuid = uniqid(); $service = new IAMService(); $user = $service->createUser("iam_demo_user_$uuid"); echo "Created user with the arn: {$user['Arn']}\n"; $key = $service->createAccessKey($user['UserName']); $assumeRolePolicyDocument = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Principal\": {\"AWS\": \"{$user['Arn']}\"}, \"Action\": \"sts:AssumeRole\" }] }"; $assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument); echo "Created role: {$assumeRoleRole['RoleName']}\n"; $listAllBucketsPolicyDocument = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"s3:ListAllMyBuckets\", \"Resource\": \"arn:aws:s3:::*\"}] }"; $listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument); echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n"; $service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']); $inlinePolicyDocument = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"{$assumeRoleRole['Arn']}\"}] }"; $inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']); //First, fail to list the buckets with the user $credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']); $s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]); try { $s3Client->listBuckets([ ]); echo "this should not run"; } catch (S3Exception $exception) { echo "successfully failed!\n"; } $stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]); sleep(10); $assumedRole = $stsClient->assumeRole([ 'RoleArn' => $assumeRoleRole['Arn'], 'RoleSessionName' => "DemoAssumeRoleSession_$uuid", ]); $assumedCredentials = [ 'key' => $assumedRole['Credentials']['AccessKeyId'], 'secret' => $assumedRole['Credentials']['SecretAccessKey'], 'token' => $assumedRole['Credentials']['SessionToken'], ]; $s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]); try { $s3Client->listBuckets([]); echo "this should now run!\n"; } catch (S3Exception $exception) { echo "this should now not fail\n"; } $service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']); $deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']); echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n"; $deletedRole = $service->deleteRole($assumeRoleRole['Arn']); echo "Deleted role: {$assumeRoleRole['RoleName']}\n"; $deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']); $deletedUser = $service->deleteUser($user['UserName']); echo "Delete user: {$user['UserName']}\n"; ``` + 有关 API 的详细信息，请参阅 *适用于 PHP 的 AWS SDK API 参考*中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy) ------ #### [ Python ] **适用于 Python 的 SDK（Boto3）** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples)中查找完整示例，了解如何进行设置和运行。创建 IAM 用户和授予列出 Amazon S3 存储桶的权限的角色。用户仅具有代入该角色的权限。代入该角色后，使用临时凭证列出该账户的存储桶。 ``` import json import sys import time from uuid import uuid4 import boto3 from botocore.exceptions import ClientError def progress_bar(seconds): """Shows a simple progress bar in the command window.""" for _ in range(seconds): time.sleep(1) print(".", end="") sys.stdout.flush() print() def setup(iam_resource): """ Creates a new user with no permissions. Creates an access key pair for the user. Creates a role with a policy that lets the user assume the role. Creates a policy that allows listing Amazon S3 buckets. Attaches the policy to the role. Creates an inline policy for the user that lets the user assume the role. :param iam_resource: A Boto3 AWS Identity and Access Management (IAM) resource that has permissions to create users, roles, and policies in the account. :return: The newly created user, user key, and role. """ try: user = iam_resource.create_user(UserName=f"demo-user-{uuid4()}") print(f"Created user {user.name}.") except ClientError as error: print( f"Couldn't create a user for the demo. Here's why: " f"{error.response['Error']['Message']}" ) raise try: user_key = user.create_access_key_pair() print(f"Created access key pair for user.") except ClientError as error: print( f"Couldn't create access keys for user {user.name}. Here's why: " f"{error.response['Error']['Message']}" ) raise print(f"Wait for user to be ready.", end="") progress_bar(10) try: role = iam_resource.create_role( RoleName=f"demo-role-{uuid4()}", AssumeRolePolicyDocument=json.dumps( { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": {"AWS": user.arn}, "Action": "sts:AssumeRole", } ], } ), ) print(f"Created role {role.name}.") except ClientError as error: print( f"Couldn't create a role for the demo. Here's why: " f"{error.response['Error']['Message']}" ) raise try: policy = iam_resource.create_policy( PolicyName=f"demo-policy-{uuid4()}", PolicyDocument=json.dumps( { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "s3:ListAllMyBuckets", "Resource": "arn:aws:s3:::*", } ], } ), ) role.attach_policy(PolicyArn=policy.arn) print(f"Created policy {policy.policy_name} and attached it to the role.") except ClientError as error: print( f"Couldn't create a policy and attach it to role {role.name}. Here's why: " f"{error.response['Error']['Message']}" ) raise try: user.create_policy( PolicyName=f"demo-user-policy-{uuid4()}", PolicyDocument=json.dumps( { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": role.arn, } ], } ), ) print( f"Created an inline policy for {user.name} that lets the user assume " f"the role." ) except ClientError as error: print( f"Couldn't create an inline policy for user {user.name}. Here's why: " f"{error.response['Error']['Message']}" ) raise print("Give AWS time to propagate these new resources and connections.", end="") progress_bar(10) return user, user_key, role def show_access_denied_without_role(user_key): """ Shows that listing buckets without first assuming the role is not allowed. :param user_key: The key of the user created during setup. This user does not have permission to list buckets in the account. """ print(f"Try to list buckets without first assuming the role.") s3_denied_resource = boto3.resource( "s3", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret ) try: for bucket in s3_denied_resource.buckets.all(): print(bucket.name) raise RuntimeError("Expected to get AccessDenied error when listing buckets!") except ClientError as error: if error.response["Error"]["Code"] == "AccessDenied": print("Attempt to list buckets with no permissions: AccessDenied.") else: raise def list_buckets_from_assumed_role(user_key, assume_role_arn, session_name): """ Assumes a role that grants permission to list the Amazon S3 buckets in the account. Uses the temporary credentials from the role to list the buckets that are owned by the assumed role's account. :param user_key: The access key of a user that has permission to assume the role. :param assume_role_arn: The Amazon Resource Name (ARN) of the role that grants access to list the other account's buckets. :param session_name: The name of the STS session. """ sts_client = boto3.client( "sts", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret ) try: response = sts_client.assume_role( RoleArn=assume_role_arn, RoleSessionName=session_name ) temp_credentials = response["Credentials"] print(f"Assumed role {assume_role_arn} and got temporary credentials.") except ClientError as error: print( f"Couldn't assume role {assume_role_arn}. Here's why: " f"{error.response['Error']['Message']}" ) raise # Create an S3 resource that can access the account with the temporary credentials. s3_resource = boto3.resource( "s3", aws_access_key_id=temp_credentials["AccessKeyId"], aws_secret_access_key=temp_credentials["SecretAccessKey"], aws_session_token=temp_credentials["SessionToken"], ) print(f"Listing buckets for the assumed role's account:") try: for bucket in s3_resource.buckets.all(): print(bucket.name) except ClientError as error: print( f"Couldn't list buckets for the account. Here's why: " f"{error.response['Error']['Message']}" ) raise def teardown(user, role): """ Removes all resources created during setup. :param user: The demo user. :param role: The demo role. """ try: for attached in role.attached_policies.all(): policy_name = attached.policy_name role.detach_policy(PolicyArn=attached.arn) attached.delete() print(f"Detached and deleted {policy_name}.") role.delete() print(f"Deleted {role.name}.") except ClientError as error: print( "Couldn't detach policy, delete policy, or delete role. Here's why: " f"{error.response['Error']['Message']}" ) raise try: for user_pol in user.policies.all(): user_pol.delete() print("Deleted inline user policy.") for key in user.access_keys.all(): key.delete() print("Deleted user's access key.") user.delete() print(f"Deleted {user.name}.") except ClientError as error: print( "Couldn't delete user policy or delete user. Here's why: " f"{error.response['Error']['Message']}" ) def usage_demo(): """Drives the demonstration.""" print("-" * 88) print(f"Welcome to the IAM create user and assume role demo.") print("-" * 88) iam_resource = boto3.resource("iam") user = None role = None try: user, user_key, role = setup(iam_resource) print(f"Created {user.name} and {role.name}.") show_access_denied_without_role(user_key) list_buckets_from_assumed_role(user_key, role.arn, "AssumeRoleDemoSession") except Exception: print("Something went wrong!") finally: if user is not None and role is not None: teardown(user, role) print("Thanks for watching!") if __name__ == "__main__": usage_demo() ``` + 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/PutUserPolicy) ------ #### [ Ruby ] **适用于 Ruby 的 SDK** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples)中查找完整示例，了解如何进行设置和运行。创建 IAM 用户和授予列出 Amazon S3 存储桶的权限的角色。用户仅具有代入该角色的权限。代入该角色后，使用临时凭证列出该账户的存储桶。 ``` # Wraps the scenario actions. class ScenarioCreateUserAssumeRole attr_reader :iam_client # @param [Aws::IAM::Client] iam_client: The AWS IAM client. def initialize(iam_client, logger: Logger.new($stdout)) @iam_client = iam_client @logger = logger end # Waits for the specified number of seconds. # # @param duration [Integer] The number of seconds to wait. def wait(duration) puts('Give AWS time to propagate resources...') sleep(duration) end # Creates a user. # # @param user_name [String] The name to give the user. # @return [Aws::IAM::User] The newly created user. def create_user(user_name) user = @iam_client.create_user(user_name: user_name).user @logger.info("Created demo user named #{user.user_name}.") rescue Aws::Errors::ServiceError => e @logger.info('Tried and failed to create demo user.') @logger.info("\t#{e.code}: #{e.message}") @logger.info("\nCan't continue the demo without a user!") raise else user end # Creates an access key for a user. # # @param user [Aws::IAM::User] The user that owns the key. # @return [Aws::IAM::AccessKeyPair] The newly created access key. def create_access_key_pair(user) user_key = @iam_client.create_access_key(user_name: user.user_name).access_key @logger.info("Created accesskey pair for user #{user.user_name}.") rescue Aws::Errors::ServiceError => e @logger.info("Couldn't create access keys for user #{user.user_name}.") @logger.info("\t#{e.code}: #{e.message}") raise else user_key end # Creates a role that can be assumed by a user. # # @param role_name [String] The name to give the role. # @param user [Aws::IAM::User] The user who is granted permission to assume the role. # @return [Aws::IAM::Role] The newly created role. def create_role(role_name, user) trust_policy = { Version: '2012-10-17', Statement: [{ Effect: 'Allow', Principal: { 'AWS': user.arn }, Action: 'sts:AssumeRole' }] }.to_json role = @iam_client.create_role( role_name: role_name, assume_role_policy_document: trust_policy ).role @logger.info("Created role #{role.role_name}.") rescue Aws::Errors::ServiceError => e @logger.info("Couldn't create a role for the demo. Here's why: ") @logger.info("\t#{e.code}: #{e.message}") raise else role end # Creates a policy that grants permission to list S3 buckets in the account, and # then attaches the policy to a role. # # @param policy_name [String] The name to give the policy. # @param role [Aws::IAM::Role] The role that the policy is attached to. # @return [Aws::IAM::Policy] The newly created policy. def create_and_attach_role_policy(policy_name, role) policy_document = { Version: '2012-10-17', Statement: [{ Effect: 'Allow', Action: 's3:ListAllMyBuckets', Resource: 'arn:aws:s3:::*' }] }.to_json policy = @iam_client.create_policy( policy_name: policy_name, policy_document: policy_document ).policy @iam_client.attach_role_policy( role_name: role.role_name, policy_arn: policy.arn ) @logger.info("Created policy #{policy.policy_name} and attached it to role #{role.role_name}.") rescue Aws::Errors::ServiceError => e @logger.info("Couldn't create a policy and attach it to role #{role.role_name}. Here's why: ") @logger.info("\t#{e.code}: #{e.message}") raise end # Creates an inline policy for a user that lets the user assume a role. # # @param policy_name [String] The name to give the policy. # @param user [Aws::IAM::User] The user that owns the policy. # @param role [Aws::IAM::Role] The role that can be assumed. # @return [Aws::IAM::UserPolicy] The newly created policy. def create_user_policy(policy_name, user, role) policy_document = { Version: '2012-10-17', Statement: [{ Effect: 'Allow', Action: 'sts:AssumeRole', Resource: role.arn }] }.to_json @iam_client.put_user_policy( user_name: user.user_name, policy_name: policy_name, policy_document: policy_document ) puts("Created an inline policy for #{user.user_name} that lets the user assume role #{role.role_name}.") rescue Aws::Errors::ServiceError => e @logger.info("Couldn't create an inline policy for user #{user.user_name}. Here's why: ") @logger.info("\t#{e.code}: #{e.message}") raise end # Creates an Amazon S3 resource with specified credentials. This is separated into a # factory function so that it can be mocked for unit testing. # # @param credentials [Aws::Credentials] The credentials used by the Amazon S3 resource. def create_s3_resource(credentials) Aws::S3::Resource.new(client: Aws::S3::Client.new(credentials: credentials)) end # Lists the S3 buckets for the account, using the specified Amazon S3 resource. # Because the resource uses credentials with limited access, it may not be able to # list the S3 buckets. # # @param s3_resource [Aws::S3::Resource] An Amazon S3 resource. def list_buckets(s3_resource) count = 10 s3_resource.buckets.each do |bucket| @logger.info "\t#{bucket.name}" count -= 1 break if count.zero? end rescue Aws::Errors::ServiceError => e if e.code == 'AccessDenied' puts('Attempt to list buckets with no permissions: AccessDenied.') else @logger.info("Couldn't list buckets for the account. Here's why: ") @logger.info("\t#{e.code}: #{e.message}") raise end end # Creates an AWS Security Token Service (AWS STS) client with specified credentials. # This is separated into a factory function so that it can be mocked for unit testing. # # @param key_id [String] The ID of the access key used by the STS client. # @param key_secret [String] The secret part of the access key used by the STS client. def create_sts_client(key_id, key_secret) Aws::STS::Client.new(access_key_id: key_id, secret_access_key: key_secret) end # Gets temporary credentials that can be used to assume a role. # # @param role_arn [String] The ARN of the role that is assumed when these credentials # are used. # @param sts_client [AWS::STS::Client] An AWS STS client. # @return [Aws::AssumeRoleCredentials] The credentials that can be used to assume the role. def assume_role(role_arn, sts_client) credentials = Aws::AssumeRoleCredentials.new( client: sts_client, role_arn: role_arn, role_session_name: 'create-use-assume-role-scenario' ) @logger.info("Assumed role '#{role_arn}', got temporary credentials.") credentials end # Deletes a role. If the role has policies attached, they are detached and # deleted before the role is deleted. # # @param role_name [String] The name of the role to delete. def delete_role(role_name) @iam_client.list_attached_role_policies(role_name: role_name).attached_policies.each do |policy| @iam_client.detach_role_policy(role_name: role_name, policy_arn: policy.policy_arn) @iam_client.delete_policy(policy_arn: policy.policy_arn) @logger.info("Detached and deleted policy #{policy.policy_name}.") end @iam_client.delete_role({ role_name: role_name }) @logger.info("Role deleted: #{role_name}.") rescue Aws::Errors::ServiceError => e @logger.info("Couldn't detach policies and delete role #{role.name}. Here's why:") @logger.info("\t#{e.code}: #{e.message}") raise end # Deletes a user. If the user has inline policies or access keys, they are deleted # before the user is deleted. # # @param user [Aws::IAM::User] The user to delete. def delete_user(user_name) user = @iam_client.list_access_keys(user_name: user_name).access_key_metadata user.each do |key| @iam_client.delete_access_key({ access_key_id: key.access_key_id, user_name: user_name }) @logger.info("Deleted access key #{key.access_key_id} for user '#{user_name}'.") end @iam_client.delete_user(user_name: user_name) @logger.info("Deleted user '#{user_name}'.") rescue Aws::IAM::Errors::ServiceError => e @logger.error("Error deleting user '#{user_name}': #{e.message}") end end # Runs the IAM create a user and assume a role scenario. def run_scenario(scenario) puts('-' * 88) puts('Welcome to the IAM create a user and assume a role demo!') puts('-' * 88) user = scenario.create_user("doc-example-user-#{Random.uuid}") user_key = scenario.create_access_key_pair(user) scenario.wait(10) role = scenario.create_role("doc-example-role-#{Random.uuid}", user) scenario.create_and_attach_role_policy("doc-example-role-policy-#{Random.uuid}", role) scenario.create_user_policy("doc-example-user-policy-#{Random.uuid}", user, role) scenario.wait(10) puts('Try to list buckets with credentials for a user who has no permissions.') puts('Expect AccessDenied from this call.') scenario.list_buckets( scenario.create_s3_resource(Aws::Credentials.new(user_key.access_key_id, user_key.secret_access_key)) ) puts('Now, assume the role that grants permission.') temp_credentials = scenario.assume_role( role.arn, scenario.create_sts_client(user_key.access_key_id, user_key.secret_access_key) ) puts('Here are your buckets:') scenario.list_buckets(scenario.create_s3_resource(temp_credentials)) puts("Deleting role '#{role.role_name}' and attached policies.") scenario.delete_role(role.role_name) puts("Deleting user '#{user.user_name}', policies, and keys.") scenario.delete_user(user.user_name) puts('Thanks for watching!') puts('-' * 88) rescue Aws::Errors::ServiceError => e puts('Something went wrong with the demo.') puts("\t#{e.code}: #{e.message}") end run_scenario(ScenarioCreateUserAssumeRole.new(Aws::IAM::Client.new)) if $PROGRAM_NAME == __FILE__ ``` + 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的以下主题。 + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/AttachRolePolicy) + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateAccessKey) + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreatePolicy) + [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole) + [CreateUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateUser) + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteAccessKey) + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeletePolicy) + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteRole) + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUser) + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUserPolicy) + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DetachRolePolicy) + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/PutUserPolicy) ------ #### [ Rust ] **适用于 Rust 的 SDK** 查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples)中查找完整示例，了解如何进行设置和运行。 ``` use aws_config::meta::region::RegionProviderChain; use aws_sdk_iam::Error as iamError; use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient}; use aws_sdk_s3::Client as s3Client; use aws_sdk_sts::Client as stsClient; use tokio::time::{sleep, Duration}; use uuid::Uuid; #[tokio::main] async fn main() -> Result<(), iamError> { let (client, uuid, list_all_buckets_policy_document, inline_policy_document) = initialize_variables().await; if let Err(e) = run_iam_operations( client, uuid, list_all_buckets_policy_document, inline_policy_document, ) .await { println!("{:?}", e); }; Ok(()) } async fn initialize_variables() -> (iamClient, String, String, String) { let region_provider = RegionProviderChain::first_try(Region::new("us-west-2")); let shared_config = aws_config::from_env().region(region_provider).load().await; let client = iamClient::new(&shared_config); let uuid = Uuid::new_v4().to_string(); let list_all_buckets_policy_document = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"s3:ListAllMyBuckets\", \"Resource\": \"arn:aws:s3:::*\"}] }" .to_string(); let inline_policy_document = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"{}\"}] }" .to_string(); ( client, uuid, list_all_buckets_policy_document, inline_policy_document, ) } async fn run_iam_operations( client: iamClient, uuid: String, list_all_buckets_policy_document: String, inline_policy_document: String, ) -> Result<(), iamError> { let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?; println!("Created the user with the name: {}", user.user_name()); let key = iam_service::create_access_key(&client, user.user_name()).await?; let assume_role_policy_document = "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Principal\": {\"AWS\": \"{}\"}, \"Action\": \"sts:AssumeRole\" }] }" .to_string() .replace("{}", user.arn()); let assume_role_role = iam_service::create_role( &client, &format!("{}{}", "iam_demo_role_", uuid), &assume_role_policy_document, ) .await?; println!("Created the role with the ARN: {}", assume_role_role.arn()); let list_all_buckets_policy = iam_service::create_policy( &client, &format!("{}{}", "iam_demo_policy_", uuid), &list_all_buckets_policy_document, ) .await?; println!( "Created policy: {}", list_all_buckets_policy.policy_name.as_ref().unwrap() ); let attach_role_policy_result = iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy) .await?; println!( "Attached the policy to the role: {:?}", attach_role_policy_result ); let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid); let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn()); iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document) .await?; println!("Created inline policy."); //First, fail to list the buckets with the user. let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None); let fail_config = aws_config::from_env() .credentials_provider(creds.clone()) .load() .await; println!("Fail config: {:?}", fail_config); let fail_client: s3Client = s3Client::new(&fail_config); match fail_client.list_buckets().send().await { Ok(e) => { println!("This should not run. {:?}", e); } Err(e) => { println!("Successfully failed with error: {:?}", e) } } let sts_config = aws_config::from_env() .credentials_provider(creds.clone()) .load() .await; let sts_client: stsClient = stsClient::new(&sts_config); sleep(Duration::from_secs(10)).await; let assumed_role = sts_client .assume_role() .role_arn(assume_role_role.arn()) .role_session_name(format!("iam_demo_assumerole_session_{uuid}")) .send() .await; println!("Assumed role: {:?}", assumed_role); sleep(Duration::from_secs(10)).await; let assumed_credentials = iamCredentials::from_keys( assumed_role .as_ref() .unwrap() .credentials .as_ref() .unwrap() .access_key_id(), assumed_role .as_ref() .unwrap() .credentials .as_ref() .unwrap() .secret_access_key(), Some( assumed_role .as_ref() .unwrap() .credentials .as_ref() .unwrap() .session_token .clone(), ), ); let succeed_config = aws_config::from_env() .credentials_provider(assumed_credentials) .load() .await; println!("succeed config: {:?}", succeed_config); let succeed_client: s3Client = s3Client::new(&succeed_config); sleep(Duration::from_secs(10)).await; match succeed_client.list_buckets().send().await { Ok(_) => { println!("This should now run successfully.") } Err(e) => { println!("This should not run. {:?}", e); panic!() } } //Clean up. iam_service::detach_role_policy( &client, assume_role_role.role_name(), list_all_buckets_policy.arn().unwrap_or_default(), ) .await?; iam_service::delete_policy(&client, list_all_buckets_policy).await?; iam_service::delete_role(&client, &assume_role_role).await?; println!("Deleted role {}", assume_role_role.role_name()); iam_service::delete_access_key(&client, &user, &key).await?; println!("Deleted key for {}", key.user_name()); iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?; println!("Deleted inline user policy: {}", inline_policy_name); iam_service::delete_user(&client, &user).await?; println!("Deleted user {}", user.user_name()); Ok(()) } ``` + 有关 API 详细信息，请参阅《AWS SDK for Rust API Reference》**中的以下主题。 + [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy) + [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key) + [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy) + [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role) + [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user) + [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key) + [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy) + [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role) + [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user) + [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy) + [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy) + [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy) ------ # 使用 IAM 角色向在 Amazon EC2 实例上运行的应用程序授予权限在 Amazon EC2 实例上运行的应用程序必须将 AWS 凭证包含在其 AWS API 请求中。您可以让开发人员将 AWS 凭证直接存储在 Amazon EC2 实例中，并允许该实例中的应用程序使用这些凭证。但之后开发人员必须管理凭证，确保能安全地将凭证传递给每个实例，并在需要更新凭证时更新每个 Amazon EC2 实例。这需要进行大量的额外工作。相反，您可以且应使用 IAM 角色管理在 Amazon EC2 实例上运行的应用程序的*临时*凭证。在使用角色时，您不需要将长期凭证（如登录凭证或访问密钥）分配给 Amazon EC2 实例。相反，角色可提供临时权限供应用程序在调用其他 AWS 资源时使用。当您启动 Amazon EC2 实例时，可指定要与实例关联的 IAM 角色。然后，实例上运行的应用程序可使用角色提供的临时凭证对 API 请求进行签名。若要使用角色向 Amazon EC2 实例上运行的应用程序授予权限，需要进行一点额外配置。Amazon EC2 实例上运行的应用程序由虚拟化操作系统从 AWS 中提取。因为存在这一额外分离操作，所以需要执行一个附加步骤将 AWS 角色及其关联权限分配给 Amazon EC2 实例，并使这些权限对其应用程序可用。此额外步骤是创建要附加到实例的*[实例配置文件](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)*。实例配置文件包含角色，并且可以为实例上运行的应用程序提供角色的临时凭证。然后，可以在应用程序的 API 调用中使用这些临时凭证访问资源，以及将访问限制为仅角色指定的那些资源。 **注意** 一次只能将一个角色分配给一个 Amazon EC2 实例，实例上的所有应用程序都具有相同的角色和权限。使用 Amazon ECS 来管理 Amazon EC2 实例时，您可以向 Amazon ECS 任务分配角色，这些角色可以与其运行的 Amazon EC2 实例的角色不同。为每项任务分配角色符合最低权限访问的原则，并有利于对操作和资源进行更精细的控制。有关更多信息，请参阅《Amazon Elastic Container Service 最佳实践指南》中的 [Using IAM roles with Amazon ECS tasks](https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/security-iam-roles.html)**。以这种方式使用该角色拥有多种优势。因为角色凭证是临时性的，并且会自动更新，所以无需管理凭证，也不必担心长期安全风险。此外，如果您对多个实例使用单个角色，则可以对该角色进行更改，而此更改会自动传播到所有实例。 **注意** 通常会在您启动 Amazon EC2 实例时向它分配角色，不过也可以向已在运行的 Amazon EC2 实例附加角色。要了解如何将角色附加到运行的实例，请参阅[适用于 Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role)。 **Topics** + [Amazon EC2 实例的角色的工作方式？](#roles-usingrole-ec2instance-roles) + [在 Amazon EC2 中使用角色所需的权限](#roles-usingrole-ec2instance-permissions) + [怎样入门？](#roles-usingrole-ec2instance-get-started) + [相关信息](#roles-usingrole-ec2instance-related-info) ## Amazon EC2 实例的角色的工作方式？在下图中，一名开发人员在 Amazon EC2 实例上运行一个应用程序，该应用程序要求访问名为 `amzn-s3-demo-bucket-photos` 的 S3 存储桶。管理员创建 `Get-pics` 服务角色并将该角色附加到 Amazon EC2 实例。该角色包括一个权限策略，该策略授予对指定 S3 存储桶的只读访问权限。它还包括一个信任策略，该策略允许 Amazon EC2 实例担任该角色并检索临时凭证。在该实例上运行应用程序时，应用程序可以使用该角色的临时凭证访问照片存储桶。管理员不必向开发人员授予访问照片存储桶的权限，开发人员完全不必共享或管理凭证。 ![\[访问 AWS 资源的 Amazon EC2 实例上的应用程序\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/roles-usingrole-ec2roleinstance.png) 1. 管理员使用 IAM 创建 **Get-pics** 角色。在角色的信任策略中，管理员指定仅 Amazon EC2 实例能够担任该角色。在角色的权限策略中，管理员为 `amzn-s3-demo-bucket-photos` 存储桶指定只读权限。 1. 开发人员启动 Amazon EC2 实例，并向该实例分配 `Get-pics` 角色。 **注意** 如果您使用 IAM 控制台，则会为您管理实例配置文件，该配置文件大部分对您是透明的。但是，如果您使用 AWS CLI 或 API 创建和管理角色和 Amazon EC2 实例，则必须创建实例配置文件并采用单独步骤将角色分配给它。随后在启动实例时，您必须指定实例配置文件名称而不是角色名称。 1. 应用程序在运行时会从 Amazon EC2 [实例元数据](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)获取临时安全凭证，如[从实例元数据检索安全凭证](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials)中所述。这些是[临时安全凭证](id_credentials_temp.md)，用于表示角色，在有限时间段内有效。使用某些 [AWS 开发工具包](https://aws.amazon.com/tools/)，开发人员可以使用提供程序以透明方式管理临时安全凭证。（各 AWS 开发工具包的文档介绍该软件开发工具包支持的凭证管理功能。）应用程序也可以直接从 Amazon EC2 实例的实例元数据中获取临时凭证。凭证和相关值可从元数据的 `iam/security-credentials/role-name` 类别（在本例中为 `iam/security-credentials/Get-pics`）获得。如果应用程序从实例元数据获取凭证，则它可对凭证进行缓存。 1. 通过使用检索到的临时凭证，应用程序可以访问照片存储桶。由于附加到 **Get-pics** 角色的策略，应用程序具有只读权限。实例上提供的临时安全凭证会在过期之前自动更新，因此始终具有有效的凭证集。应用程序只需要确保在当前凭证过期之前从实例元数据获取新的凭证集。可以使用 AWS 开发工具包管理凭证，这样应用程序就不需要包含额外的逻辑来刷新凭证。例如，使用实例配置文件凭证提供程序实例化客户端。但是，如果应用程序从实例元数据获取临时安全凭证并对它们进行缓存，则它应在当前凭证集过期之前，每隔一小时 (或至少每隔 15 分钟) 获取刷新的凭证集。在 `iam/security-credentials/role-name` 类别中返回的信息中包含过期时间。 ## 在 Amazon EC2 中使用角色所需的权限要启动具有角色的实例，开发人员必须有启动 Amazon EC2 实例的权限和传递 IAM 角色的权限。以下示例策略可以实现使用 AWS 管理控制台发布引用角色的实例。策略包含通配符 (`*`) 以允许用户传递任意角色并执行所有列出的 Amazon EC2 操作。用户可以通过 `ListInstanceProfiles` 操作浏览 AWS 账户中的所有角色。 **Example 授权用户使用 Amazon EC2 控制台启动具有任何角色的实例的示例策略** **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "IamPassRole", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*", "Condition": { "StringEquals": { "iam:PassedToService": "ec2.amazonaws.com" } } }, { "Sid": "ListEc2AndListInstanceProfiles", "Effect": "Allow", "Action": [ "iam:ListInstanceProfiles", "ec2:Describe*", "ec2:Search*", "ec2:Get*" ], "Resource": "*" } ] } ``` ### 限制哪些角色能够传递到 Amazon EC2 实例（使用 PassRole）您可以使用 `PassRole` 权限来限制用户启动实例时可以传递给 Amazon EC2 实例的角色。这有助于防止用户运行具有超出用户获授权限的应用程序即防止用户获取提升的权限。例如，假设用户 Alice 仅有权启动 Amazon EC2 实例并使用 Amazon S3 存储桶，但是她传递给 Amazon EC2 实例的角色有权使用 IAM 和 Amazon DynamoDB。在这种情况下，Alice 或许能够启动实例，登录它，获取临时安全凭证，然后执行未向她授权的 IAM 或 DynamoDB 操作。要限制用户可以传递给 Amazon EC2 实例的角色，您可创建一个允许执行 `PassRole` 操作的策略。然后，将策略附加到将启动 Amazon EC2 实例的用户（或该用户所属的 IAM 组）。在策略的 `Resource` 元素中，列出允许用户传递给 Amazon EC2 实例的角色。用户启动一个实例并将角色与该实例关联时，Amazon EC2 会检查是否允许用户传递该角色。当然，您还应确保用户可传递的角色不包含用户不应拥有的权限。 **注意** 就像 `PassRole` 或 `RunInstances` 那样，`ListInstanceProfiles` 不是 API 操作。相反，它是只要有角色 ARN 作为参数传递给 API 时，AWS 便会检查的权限 (或者控制台代表用户这么做)。它帮助管理员控制哪些角色可以由哪些用户传递。在这种情况下，它可确保用户可以将特定角色附加到 Amazon EC2 实例。 **Example 通过特定角色向用户授予启动 Amazon EC2 实例的权限的示例策略** 通过以下示例策略，用户可以使用 Amazon EC2 API，通过角色来启动实例。`Resource` 元素指定角色的 Amazon Resource Name (ARN)。通过指定 ARN，该策略授予用户仅传递 `Get-pics` 角色的权限。如果在启动实例时用户尝试指定其他角色，则该操作会失败。用户拥有运行任何实例的权限，无论他们是否传递角色。 **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "ec2:RunInstances", "Resource": "*" }, { "Effect": "Allow", "Action": "iam:PassRole", "Resource": "arn:aws:iam::111122223333:role/Get-pics" } ] } ``` ### 允许实例配置文件角色切换到另一个账户中的角色您可以允许 Amazon EC2 实例上运行的应用程序在另一个账户中运行命令。为此，您必须允许第一个账户中的 Amazon EC2 实例角色切换到第二个账户中的角色。假设您使用两个 AWS 账户，并希望允许 Amazon EC2 实例上运行的应用程序在两个账户中运行 [AWS CLI](https://aws.amazon.com/cli/) 命令。假设 Amazon EC2 实例位于 `111111111111` 账户中。该实例包含 `abcd` 实例配置文件角色，以允许应用程序对同一 `111111111111` 账户中的 `amzn-s3-demo-bucket1` 存储桶执行只读 Amazon S3 任务。不过，还必须允许应用程序担任 `efgh` 跨账户角色以访问 `222222222222` 账户中的 `amzn-s3-demo-bucket2` Amazon S3 存储桶。 ![\[该图显示开发人员如何启动具有该角色的 Amazon EC2 实例以获取 Amazon S3 存储桶中照片的访问权限。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/roles-instance-profile-cross-account.png) `abcd` Amazon EC2 实例配置文件角色必须具有以下权限策略，以允许应用程序访问 `amzn-s3-demo-bucket1` Amazon S3 存储桶： ***账户 111111111111 `abcd` 角色权限策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccountLevelS3Actions", "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetAccountPublicAccessBlock", "s3:ListAccessPoints", "s3:ListAllMyBuckets" ], "Resource": "arn:aws:s3:::*" }, { "Sid": "AllowListAndReadS3ActionOnMyBucket", "Effect": "Allow", "Action": [ "s3:Get*", "s3:List*" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket1/*", "arn:aws:s3:::amzn-s3-demo-bucket1" ] }, { "Sid": "AllowIPToAssumeCrossAccountRole", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::222222222222:role/efgh" } ] } ``` ------ `abcd` 角色必须信任 Amazon EC2 服务以担任该角色。为此，`abcd` 角色必须具有以下信任策略： ***账户 111111111111 `abcd` 角色信任策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "abcdTrustPolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": {"Service": "ec2.amazonaws.com"} } ] } ``` ------ 假设 `efgh` 跨账户角色允许对同一 `222222222222` 账户中的 `amzn-s3-demo-bucket2` 存储桶执行只读 Amazon S3 任务。为此，`efgh` 跨账户角色必须具有以下权限策略： ***账户 222222222222 `efgh` 角色权限策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccountLevelS3Actions", "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetAccountPublicAccessBlock", "s3:ListAccessPoints", "s3:ListAllMyBuckets" ], "Resource": "arn:aws:s3:::*" }, { "Sid": "AllowListAndReadS3ActionOnMyBucket", "Effect": "Allow", "Action": [ "s3:Get*", "s3:List*" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket2/*", "arn:aws:s3:::amzn-s3-demo-bucket2" ] } ] } ``` ------ `efgh` 角色必须信任 `abcd` 实例配置文件角色以担任该角色。为此，`efgh` 角色必须具有以下信任策略： ***账户 222222222222 `efgh` 角色信任策略*** ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "efghTrustPolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"} } ] } ``` ------ ## 怎样入门？为了理解角色如何在 Amazon EC2 实例中起作用，您需要使用 IAM 控制台创建一个角色，启动使用该角色的 Amazon EC2 实例，然后检查正在运行的实例。您可以检查[实例元数据](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)，以了解如何为实例提供角色的临时凭证。也可以了解实例上运行的应用程序如何使用角色。使用以下资源了解更多信息。 + [Amazon EC2 实例上的 IAM 角色教程](https://www.youtube.com/watch?v=TlCuOjviOhk)。链接的视频说明如何将 IAM 角色与 Amazon EC2 实例搭配使用，以控制应用程序在实例上运行时可执行的操作。该视频说明了应用程序（在 AWS 开发工具包中编写）如何通过角色获取临时安全凭证。 + SDK 演示。AWS 开发工具包文档包含一些演示，这些演示说明了在 Amazon EC2 实例上运行的应用程序使用角色的临时凭证读取 Amazon S3 存储桶。以下每个演示都采用了不同的编程语言来呈现类似的步骤： + *适用于 Java 的 AWS SDK 开发人员指南*中的[使用 SDK for Java 为 Amazon EC2 配置 IAM 角色](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-roles.html) + 《适用于 .NET 的 AWS SDK 开发人员指南》**中的[使用 SDK for .NET 启动 Amazon EC2 实例](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/run-instance.html) + *适用于 Ruby 的 AWS SDK 开发人员指南*中的[使用 SDK for Ruby 创建 Amazon EC2 实例](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/ec2-example-create-instance.html) ## 相关信息有关创建角色或适用于 Amazon EC2 实例的角色的更多信息，请参阅以下信息： + 有关[将 IAM 角色与 Amazon EC2 实例结合使用](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)的更多信息，请转至《*Amazon EC2 用户指南*》。 + 如需创建角色，请参阅[IAM 角色创建](id_roles_create.md) + 有关使用临时安全凭证的更多信息，请参阅[IAM 临时安全凭证](id_credentials_temp.md)。 + 如果您操作 IAM API 或 CLI，必须创建并管理 IAM 实例配置文件。有关实例配置文件的更多信息，请参阅[使用实例配置文件](id_roles_use_switch-role-ec2_instance-profiles.md)。 + 有关实例元数据中的角色临时安全凭证的更多信息，请参阅《*Amazon EC2 用户指南*》中的[通过实例元数据检索安全凭证](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials)。 # 使用实例配置文件使用实例配置文件将 IAM 角色传递给 EC2 实例。有关更多信息，请参阅《Amazon EC2 用户指南》**中的[适用于 Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)。 ## 管理实例配置文件（控制台）如果使用 AWS 管理控制台创建 Amazon EC2 的角色，则控制台自动创建实例配置文件，将其命名为与角色相同的名称。当您随后通过 IAM 角色使用 Amazon EC2 控制台启动实例时，可以选择一个角色与该实例关联。在控制台中，显示的列表实际上是实例配置文件名称的列表。控制台不会为不与 Amazon EC2 关联的角色创建实例配置文件。如果该角色和实例配置文件的名称相同，则您可以使用 AWS 管理控制台删除 Amazon EC2 的 IAM 角色和实例配置文件。要了解删除实例配置文件的更多信息，请参阅 [删除角色或实例配置文件](id_roles_manage_delete.md)。 **注意** 要更新实例的权限，请替换其实例配置文件。我们不建议从实例配置文件中移除角色，因为此更改最长需要一小时才会生效。 ## 管理实例配置文件（AWS CLI 或 AWS API）如果您从 AWS CLI 或 AWS API 管理角色，则需要使用单独的操作创建角色和实例配置文件。由于角色和实例配置文件可能具有不同名称，则您必须知道实例配置文件的名称及其包含的角色名称。这样，您才能在启动 EC2 实例时选择正确的实例配置文件。您可以将标签附加到 IAM 资源（包括实例配置文件），以识别、组织和控制对这些资源的访问。只有在使用 AWS CLI 或 AWS API 时，才能标记实例配置文件。 **注意** 一个实例配置文件只能包含一个 IAM 角色，不过一个角色可以包含在多个实例配置文件中。不能提高每个实例配置文件一个角色这一限制。您可以删除实例配置文件中的现有角色，然后添加另一角色。由于[最终一致性](https://en.wikipedia.org/wiki/Eventual_consistency)，您必须等待此更改在整个 AWS 中出现。要强制进行更改，您必须[取消关联实例配置文件](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)，然后再次[关联实例配置文件](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html)；您也可以停止并重新启动实例。 ### 管理实例配置文件 (AWS CLI) 您可以使用以下 AWS CLI 命令在 AWS 账户中处理实例配置文件。 + 创建实例配置文件: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html) + 标记实例配置文件：[https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html) + 列出实例配置文件的标签：[https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html) + 取消标记实例配置文件：[https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html) + 向实例配置文件添加角色: [https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) + 列出实例配置文件: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html), [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html) + 获取有关实例配置文件的信息: [https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html) + 从实例配置文件中删除角色: [https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html) + 删除实例配置文件: [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html) 您还可以使用以下命令，将角色附加到已在运行的 EC2 实例。有关更多信息，请参阅 [Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role)。 + 将实例配置文件随角色附加到已停止或正在运行的 EC2 实例: [https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) + 获取 EC2 实例附加的实例配置文件信息: [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) + 将角色的实例配置文件与已停止或正在运行的 EC2 实例分离: [https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html) ### 管理实例配置文件 (AWS API) 您可以调用以下 AWS API 操作在 AWS 账户中处理实例配置文件。 + 创建实例配置文件: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) + 标记实例配置文件：[https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) + 列出实例配置文件上的的标签：[https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) + 取消标记实例配置文件：[https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) + 向实例配置文件添加角色: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) + 列出实例配置文件: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html), [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html) + 获取有关实例配置文件的信息: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html) + 从实例配置文件中删除角色: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html) + 删除实例配置文件: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 您还可以调用以下操作，将角色附加到已在运行的 EC2 实例。有关更多信息，请参阅 [Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role)。 + 将实例配置文件随角色附加到已停止或正在运行的 EC2 实例: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) + 获取 EC2 实例附加的实例配置文件信息: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html) + 将角色的实例配置文件与已停止或正在运行的 EC2 实例分离: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)