# IAM JSON 策略元素参考
JSON 策略文档由元素组成。这些元素按照在策略中使用的大致顺度列出。元素的顺序并不重要，例如，`Resource` 元素可以在 `Action` 元素之前出现。您无需在策略中指定任何 `Condition` 元素。要详细了解 JSON 策略文档的一般结构和目的，请参阅 [JSON 策略概述](access_policies.md#access_policies-json)。
一些 JSON 策略元素相互排斥。这意味着，您不能创建同时使用两个元素的策略。例如，您不能在同一策略语句中同时使用 `Action` 和 `NotAction`。相互排斥的其他对包括 `Principal`/`NotPrincipal` 和 `Resource`/`NotResource`。
策略中所包含的具体内容因产品而异，其取决于产品所提供的操作、包含的资源类型等。当您针对特定产品编写策略时，参考该产品的示例将为您提供帮助。如需获取支持 IAM 的所有服务的列表，以及阐述这些服务的 IAM 和策略的文档链接，请参阅 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)。
当您创建或编辑 JSON 策略时，IAM 可以执行策略验证以帮助您创建有效的策略。IAM 可识别 JSON 语法错误，而 IAM Access Analyzer 将提供额外的策略检查和建议，以帮助您进一步优化策略。要了解策略验证的更多信息，请参阅 [IAM 策略验证](access_policies_policy-validator.md)。要了解有关 IAM Access Analyzer 策略检查和可执行建议的更多信息，请参阅 [IAM Access Analyzer 策略验证](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html)。
**Topics**
+ [Version](reference_policies_elements_version.md)
+ [Id](reference_policies_elements_id.md)
+ [Statement](reference_policies_elements_statement.md)
+ [Sid](reference_policies_elements_sid.md)
+ [Effect](reference_policies_elements_effect.md)
+ [Principal](reference_policies_elements_principal.md)
+ [NotPrincipal](reference_policies_elements_notprincipal.md)
+ [Action](reference_policies_elements_action.md)
+ [NotAction](reference_policies_elements_notaction.md)
+ [Resource](reference_policies_elements_resource.md)
+ [NotResource](reference_policies_elements_notresource.md)
+ [Condition](reference_policies_elements_condition.md)
+ [变量和标签](reference_policies_variables.md)
+ [支持的数据类型](reference_policies_elements_datatypes.md)
# IAM JSON 策略元素：Version
**消除歧义的说明**
此 `Version` JSON 策略元素与*策略版本* 不同。`Version` 策略元素用在策略之中，用于定义策略语言的版本。另一方面，当您对 IAM 中的客户托管策略进行更改时，将创建一个策略版本。已更改的策略不会覆盖现有策略。而是由 IAM 创建新的托管策略版本。如果您在寻找与托管策略适用的多版本支持相关的信息，请参阅[IAM policy 版本控制](access_policies_managed-versioning.md)。
`Version` 策略元素指定用于处理策略的语言语法规则。要使用所有可用策略功能，请将以下 `Version` 元素包含在所有策略中的 `Statement` 元素之**外**。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
IAM 支持以下 `Version` 元素值：
+ `2012-10-17`. 这是策略语言的当前版本，您应始终包含一个 `Version` 元素并将其设置为 `2012-10-17`。否则，您将无法使用此版本中引入的[策略变量](reference_policies_variables.md) 等功能。
+ `2008-10-17`. 这是策略语言的早期版本。您可能会在较旧的现有策略中看到此版本。请勿将此版本用于任何新策略或正在更新的任何现有策略。较新的功能（如策略变量）将不适用于您的策略。例如，系统不会将 `${aws:username}` 等变量识别为变量，而是将其视为策略中的文本字符串。
# IAM JSON 策略元素：Id
`Id` 元素指定策略的可选标识符。不同产品使用的 ID 也不尽相同。ID 可在基于资源的策略中使用，但不能在基于身份的策略中使用。
对于允许您设置 `ID` 元素的产品，我们建议您使用 UUID (GUID) 值，或将 UUID 与 ID 合并，以确保唯一性。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "cd3ad3d9-2776-4ef1-a904-4c229d1642ee",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
**注意**
某些 AWS 产品（例如，Amazon SQS 或 Amazon SNS）可能需要该元素并要求其具有唯一性。有关编写策略的特定于服务的信息，请参阅您使用的服务的文档。
# IAM JSON 策略元素：Statement
`Statement` 元素为策略的主要元素。该元素为必填项。`Statement` 元素可以包含一条语句或由单独语句组成的数组。每条单独的语句块必须用大括号 \$1 \$1 括起来。对于多条语句，数组必须用方括号 [ ] 括起来。
```
"Statement": [{...},{...},{...}]
```
在下列示例所列举的策略中，在单一 `Statement` 元素内包含一个有三份声明的数组。(该策略允许您在 Amazon S3 控制台中访问您自己的“主文件夹”。) 该策略包含 `aws:username` 变量，在策略评估期间它将被替换为请求中的用户名称。有关更多信息，请参阅 [简介](reference_policies_variables.md#policy-vars-intro)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {"StringLike": {"s3:prefix": [
"",
"home/",
"home/${aws:username}/"
]}}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
]
}
]
}
```
------
# IAM JSON 策略元素：Sid
您可以提供 `Sid`（语句 ID）作为策略语句的可选标识符。您可以为语句数组中的每个语句指定 `Sid` 值。您可以使用 `Sid` 值作为策略声明的描述。在允许您指定 `ID` 元素的产品中，例如 SQS 和 SNS，`Sid` 值正是策略文件 ID 的子 ID。在 IAM 中，`Sid` 值必须在 JSON 策略中是唯一的。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExampleStatementID",
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
`Sid` 元素支持 ASCII 大写字母 (A-Z)、小写字母 (a-z) 和数字 (0-9)。
IAM 不会公开在 IAM API 中的 `Sid`。您无法基于此 ID 检索特定声明。
**注意**
某些 AWS 产品（例如，Amazon SQS 或 Amazon SNS）可能需要该元素并要求其具有唯一性。有关编写策略的特定于服务的信息，请参阅您使用的服务的文档。
# IAM JSON 策略元素：Effect
`Effect` 元素是必需具备的元素，用于指定声明所产生的结果是“允许”还是“显式拒绝”。`Effect` 的有效值为 `Allow` 和 `Deny`。`Effect` 值区分大小写。
```
"Effect":"Allow"
```
在默认情况下，将拒绝访问资源。如要允许访问资源，您必须将 `Effect` 元素设置为 `Allow`。如要置换“允许”结果 (例如，置换否则会生效的“允许”结果)，您需要将 `Effect` 元素设置为 `Deny`。有关更多信息，请参阅 [策略评估逻辑](reference_policies_evaluation-logic.md)。
# AWS JSON 策略元素：Principal
在基于资源的 JSON 策略中使用 `Principal` 元素指定允许或拒绝访问资源的主体。
您必须使用[基于资源的策略](access_policies_identity-vs-resource.md)中的 `Principal` 元素。包括 IAM 在内的多项服务支持基于资源的策略。IAM 中唯一基于资源的策略类型是角色信任策略。在 IAM 角色中，在角色的信任策略中使用 `Principal` 元素来指定可担任该角色的对象。对于跨账户访问，您必须指定受信任账户的 12 位标识符。要了解您信任区域之外的账户（受信任的企业或账户）中的主体是否有权承担您的角色，请参阅[什么是 IAM Access Analyzer？](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html)。
**注意**
创建角色后，您可以将账户更改为 "\$1"，允许所有人担任该角色。如果执行此操作，我们强烈建议您通过其他方法 (如将访问只限定为特定 IP 地址的 `Condition` 元素) 限制能够访问该角色的用户。不要将角色的访问权限开放给所有人！
支持基于资源的策略的其他资源示例包括 Amazon S3 存储桶或 AWS KMS key。
无法在基于身份的策略中使用 `Principal` 元素。基于身份的策略是附加到 IAM 身份（用户、群体或角色）的权限策略。在这些策略中，附加了策略的身份即是主体的身份。
**Topics**
+ [如何指定主体](#Principal_specifying)
+ [AWS 账户 主体](#principal-accounts)
+ [IAM 角色主体](#principal-roles)
+ [角色会话主体](#principal-role-session)
+ [OIDC 联合身份验证主体](#principal-federated-web-identity)
+ [SAML 联合身份验证主体](#principal-saml)
+ [IAM 用户主体](#principal-users)
+ [IAM Identity Center 主体](#principal-identity-users)
+ [AWS STS 联合用户主体](#sts-session-principals)
+ [AWS 服务主体](#principal-services)
+ [选择加入区域的 AWS 服务主体](#principal-services-in-opt-in-regions)
+ [所有主体](#principal-anonymous)
+ [更多信息](#Principal_more-info)
## 如何指定主体
您可以在基于资源的策略的 `Principal` 元素中或在支持主体的条件密钥中指定主体。
您可以在策略中指定以下任意主体：
+ AWS 账户 和根用户
+ IAM 角色
+ 角色会话
+ IAM 用户
+ 联合用户主体
+ AWS 服务
+ 所有主体
您无法在策略（例如基于资源的策略）中将用户组标识为主体，因为组与权限相关，与身份验证无关，并且主体是经过身份验证的 IAM 实体。
您可以使用数组在以下部分中为每个主体类型指定多个主体。数组可以采用一个或多个值。如果您在该元素中指定多个主体，则表示您向每个主体授予权限。这是逻辑 `OR` 而不是逻辑 `AND`，因为您一次被认证为一个主体。如果包含多个值，请使用方括号（`[` 和 `]`）并用逗号分隔数组的每个条目。以下示例策略定义了 123456789012 账户或 555555555555 账户的权限。
```
"Principal" : {
"AWS": [
"123456789012",
"555555555555"
]
}
```
**注意**
您不能使用通配符匹配一部分主体名称或 ARN。
## AWS 账户 主体
您可以在基于资源策略的 `Principal` 元素中或支持主体的条件键中指定 AWS 账户 标识符。这将权限委派给账户。当您允许访问其他账户时，该账户中的管理员必须为该账户中身份（IAM 用户或角色）授予访问权限。在指定 AWS 账户 时，您可以使用账户 ARN (arn:aws:iam::*account-ID*:root) 或 `"AWS":` 前缀后加账户 ID 构成的简略格式。
例如，给定账户 ID 为 `123456789012` 的情况下，您可以使用以下任一方法来在 `Principal` 元素中指定账户：
```
"Principal": { "AWS": "arn:aws:iam::123456789012:root" }
```
```
"Principal": { "AWS": "123456789012" }
```
账户 ARN 和缩短的账户 ID 的行为方式相同。两者都向账户委派权限。在 `Principal` 元素中使用账户 ARN 并不会将权限限制为该账户的根用户。
**注意**
当您保存包含缩短账户 ID 的基于资源的策略时，服务可能会将其转换为主体 ARN。这不会更改策略的功能。
某些 AWS 服务支持其他用于指定账户主体的选项。例如，Amazon S3 允许您使用以下格式指定[规范用户 ID](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId)：
```
"Principal": { "CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be" }
```
您还可以指定多个 AWS 账户（或规范用户 ID）作为使用数组的主体。例如，您可以使用所有三种方法在存储桶策略中指定主体。
```
"Principal": {
"AWS": [
"arn:aws:iam::123456789012:root",
"999999999999"
],
"CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be"
}
```
## IAM 角色主体
您可以在支持主体的基于资源的策略或条件密钥的 `Principal` 元素中指定 IAM 角色主体 ARN。IAM 角色是身份。在 IAM 中，身份是您可以向其分配权限的资源。角色信任另一个身份验证来担任该角色。这包含 AWS 中的主体或来自外部身份提供程序 (IdP) 的用户。当主体或身份代入角色时，他们会收到具有代入角色权限的临时安全凭证。当他们使用这些凭证在 AWS 中执行操作时，将变为*角色会话主体*。
当您在基于资源的策略中指定角色主体时，主体的有效权限受限制该角色权限的任何策略类型的限制。这包括会话策略和权限边界。有关如何评估角色会话的有效权限的更多信息，请参阅 [策略评估逻辑](reference_policies_evaluation-logic.md)。
要指定 `Principal` 元素中的角色 ARN，请采用以下格式：
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:role/role-name" }
```
**重要**
如果角色信任策略的 `Principal` 元素中包含指向特定 IAM 角色的 ARN，在保存策略时该 ARN 将转换为该角色的唯一主体 ID。如果有人希望通过删除并重新创建角色来提升特权，这样有助于减轻此类风险。您通常不会在控制台中看到这个 ID，因为 IAM 在显示信任策略时使用反向转换回角色 ARN。但是，如果您删除角色，这种关系即被打破。即使您重新创建角色，策略也不再适用。因为新角色拥有新的主体 ID，与信任策略中存储的 ID 不匹配。发生这种情况时，主体 ID 会出现在基于资源的策略中，因为 AWS 无法将其映射回有效的 ARN。最终结果是，如果您删除并重新创建了信任策略的 `Principal` 元素所引用的角色，您必须编辑策略中的角色，用正确的 ARN 替换主体 ID。当您保存策略时，ARN 会再次转换为该角色新的主体 ID。有关更多信息，请参阅[了解 AWS 的对已删除 IAM 角色的处理策略](https://repost.aws/articles/ARSqFcxvd7R9u-gcFD9nmA5g/understanding-aws-s-handling-of-deleted-iam-roles-in-policies)。
[IAM 联合身份用户](#principal-anonymous) — IAM 用户使用 `aws:PrincipalArn` 操作联合身份，为 IAM 用户生成联合身份用户会话主体。当您使用此密钥时，角色会话主体将根据所担任的角色的 ARN 而不是所生成的会话的 ARN 授予权限。由于 AWS 不将条件密钥 ARN 转换为 ID，如果您删除该角色，然后创建一个具有相同名称的新角色，则授予该角色 ARN 的权限将继续存在。基于身份的策略类型，例如权限边界或会话策略，不限制在 `Principal` 元素中使用带通配符（\$1）的 `aws:PrincipalArn` 条件键授予权限，除非基于身份的策略包含显式拒绝。
## 角色会话主体
您可以在支持主体的基于资源的策略或条件密钥的 `Principal` 元素中指定角色会话。当主体或身份代入角色时，他们会收到具有代入角色权限的临时安全凭证。当他们使用这些凭证，在 AWS 中执行操作时，将变为*角色会话主体*。
您用于角色会话主体的格式取决于用来代入角色的 AWS STS 操作。
**重要**
AWS 建议尽可能在策略中使用 [IAM 角色主体](#principal-roles)而不是角色会话主体。必要时使用 `Condition` 语句和条件键进一步缩小访问范围。
要在 `Principal` 元素中指定角色会话主体 ARN，请采用以下格式：
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:assumed-role/role-name/role-session-name" }
```
此外，管理员可以设计一个流程来控制角色会话的发放方式。例如，他们可以为用户提供一键式解决方案，以创建可预测的会话名称。如果管理员执行此操作，则您可以在策略或条件密钥中使用角色会话主体。否则，您可以在 `aws:PrincipalArn` 条件键中将角色 ARN 指定为主体。如何将角色指定为主体可以更改所生成的会话的有效权限。有关更多信息，请参阅 [IAM 角色主体](#principal-roles)。
## OIDC 联合身份验证主体
OIDC 联合身份验证主体是指使用符合 OIDC 标准的 IDP（也称为 OpenID Provider (OP)）提供的 JSON 网络令牌 (JWT) 调用 AWS STS `AssumeRoleWithWebIdentity` API 以请求临时 AWS 凭证时使用的主体。OIDC 联合身份验证主体可以代表 AWS 账户中的 OIDC IDP，也可以代表 4 个内置身份提供商：Login with Amazon、Google、Facebook 和 [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/role-based-access-control.html)。
已从 OIDC IDP 签发 JWT 的用户、工作负载或系统可使用 JWT 来调用 `AssumeRoleWithWebIdentity`，以请求 IAM 角色的临时 AWS 安全凭证，该 IAM 角色已配置为信任“签发 JWT 的 OIDC IDP”。只要[符合 AWS STS 列出的要求](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-prerequisites)，JWT 可以是 ID 令牌、访问令牌，也可以是通过任何其他方法交付的 JWT 令牌。有关更多信息，请参阅[常见场景](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_federation_common_scenarios.html)以及[通过 OIDC 提供商请求凭证](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity)。
在您的角色信任策略中使用此主体类型，以允许或拒绝使用 AWS 账户 中存在的 OIDC IDP 或四个内置 IDP 中的一个来调用 `AssumeRoleWIthWebIdentity` 的权限。要在角色信任策略的 `Principal` 元素中指定 OIDC 联合身份验证主体 ARN，请使用以下四种内置 OIDC IDP 的格式之一：
```
"Principal": { "Federated": "cognito-identity.amazonaws.com" }
```
```
"Principal": { "Federated": "www.amazon.com" }
```
```
"Principal": { "Federated": "graph.facebook.com" }
```
```
"Principal": { "Federated": "accounts.google.com" }
```
在使用您添加到账户的 OIDC 提供商（如 GitHub）时，您需要在角色的信任策略中指定提供商的 ARN。通过此配置，您可以编写 IAM 策略，专门控制通过自定义身份提供商验证的用户的访问。
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/full-OIDC-identity-provider-URL" }
```
例如，如果 GitHub 是受信任的网络身份提供商，则角色信任策略 `Principal` 元素中的 OIDC 角色会话 ARN 使用以下格式：
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/tokens.actions.githubusercontent.com" }
```
有关更多信息，请参阅[在 Amazon Web Services 中配置 OpenID Connect](https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services)。
角色信任策略以外的策略类型不支持 OIDC 联合身份验证主体。
## SAML 联合身份验证主体
*SAML 联合身份验证主体*是指在调用 AWS STS `AssumeRoleWithSAML` API 时使用 SAML 断言来请求临时 AWS 凭证的主体。您可以使用您的 SAML 身份提供程序 (IdP) 登录，然后使用此操作来代入 IAM 角色。与 `AssumeRoleWithWebIdentity` 类似，`AssumeRoleWithSAML` 也不需要 AWS 凭证进行身份验证。相反，用户首先通过其 SAML 身份提供程序进行身份验证，然后使用其 SAML 断言进行 `AssumeRoleWithSAML` API 调用，或被重定向至 AWS 登录/SAML 页面以登录 AWS 管理控制台。有关哪些主体可以使用此操作代入角色的更多信息，请参阅 [比较 AWS STS 凭证](id_credentials_sts-comparison.md)。
在您的角色信任策略中使用此主体类型，可基于受信任的 SAML 身份提供程序来允许或拒绝权限。要指定角色信任策略 `Principal` 元素中 SAML 身份角色会话的 ARN，请采用以下格式：
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:saml-provider/provider-name" }
```
## IAM 用户主体
您可以在支持主体的基于资源的策略或条件键的 `Principal` 元素中指定 IAM 用户。
**注意**
在 `Principal` 元素中，[*Amazon Resource Name* (ARN)](reference_identifiers.md#identifiers-arns) 的用户名部分区分大小写。
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:user/user-name" }
```
```
"Principal": {
"AWS": [
"arn:aws:iam::AWS-account-ID:user/user-name-1",
"arn:aws:iam::AWS-account-ID:user/user-name-2"
]
}
```
当在 `Principal` 元素中指定用户时，不能使用通配符 (`*`) 表示“所有用户”。主体必须始终指明特定用户。
**重要**
如果角色信任策略的 `Principal` 元素中包含指向特定 IAM 用户的 ARN，则在保存策略时该 IAM 将 ARN 转换为该用户的唯一主体 ID。如果有人希望通过删除并重新创建用户来提升特权，这样有助于减轻此类风险。您通常不会在控制台中看到这个 ID，因为显示信任策略时它还会反向转换为用户的 ARN。但是，如果您删除角色，这种关系即被打破。即使您重新创建用户，策略也不再适用。这是因为：新用户拥有新的主体 ID，该 ID 与信任策略中存储的 ID 不匹配。发生这种情况时，主体 ID 会出现在基于资源的策略中，因为 AWS 无法将其映射回有效的 ARN。结果是，如果您删除并重新创建了信任策略的 `Principal` 元素所引用的用户，您必须编辑角色，用正确的 ARN 替换目前不正确的主体 ID。当您保存策略时，IAM 会再次将 ARN 转换为该用户新的主体 ID。
## IAM Identity Center 主体
在 IAM Identity Center 中，必须将基于资源的策略中的主体定义为 AWS 账户 主体。要指定访问权限，请引用条件块中设置的权限的角色 ARN。有关详细信息，请参阅《IAM Identity Center 用户指南》**中的[引用资源策略、Amazon EKS 和 AWS KMS 中的权限集](https://docs.aws.amazon.com/singlesignon/latest/userguide/referencingpermissionsets.html)。
## AWS STS 联合用户主体
您可以在支持主体的基于资源的策略或条件密钥的 `Principal` 元素中指定 *federated user sessions*（联合身份用户会话）。
**重要**
AWS 建议您限制 AWS STS 联合用户会话的使用。而应使用 [IAM 角色](IAM/latest/UserGuide/tutorial_cross-account-with-roles.html)。
AWS STS 联合用户主体是通过调用长期 IAM 凭证的 `GetFederationToken` 操作创建的。联合用户权限是调用 `GetFederationToken` 的主体与作为参数传递给 `GetFederationToken` API 的会话策略的交集。
在 AWS 中，IAM 用户或 AWS 账户根用户 可以使用长期访问密钥进行身份验证。有关哪些主体可以使用此操作联合身份的更多信息，请参阅 [比较 AWS STS 凭证](id_credentials_sts-comparison.md)。
+ **IAM 联合用户** – IAM 用户使用 `GetFederationToken` 操作联合身份，为该 IAM 用户生成联合用户会话。
+ **联合根用户** – 根用户使用 `GetFederationToken` 操作联合身份，为该根用户生成联合用户会话。
当 IAM 用户或根用户通过使用此操作的 AWS STS 请求临时凭证时，他们开启临时的联合身份会话。本会话的 ARN 基于联合身份的原始身份。
要指定 `Principal` 元素中联合身份用户会话的 ARN，请采用以下格式：
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:federated-user/user-name" }
```
## AWS 服务主体
您可以在支持主体的基于资源的策略或条件密钥的 `Principal` 元素中指定 AWS 服务。一个*服务主体*是服务的标识符。
可以由 AWS 服务担任的 IAM 角色称为*[服务角色](id_roles.md#iam-term-service-role)*。服务角色必须包括信任策略。*信任策略*是附加到角色的基于资源的策略，这些策略定义了可担任该角色的主体。某些服务角色具有预定义的信任策略。但有些情况下，您必须在信任策略中指定服务主体。IAM policy 中的服务主体不能是 `"Service": "*"`。
**重要**
服务主体的标识符包括服务名称，通常采用以下格式：
`service-name.amazonaws.com`
服务主体由服务定义。可以通过以下方式找到某些服务的服务主体：打开 [使用 IAM 的 AWS 服务](reference_aws-services-that-work-with-iam.md)，检查服务在 **Service-linked role**（服务相关角色）列中是否具有 **Yes**，然后打开 **Yes**（是）链接以查看该服务的服务相关角色文档。查找该服务的**服务相关角色权限**部分，查看服务主体。
以下示例显示了一个可以附加到服务角色的策略。该策略可启用两个服务（Amazon ECS 和 Elastic Load Balancing）以担任该角色。然后，这些服务可执行由分配给该角色 (未显示) 的权限策略授权执行的任何任务。要指定多个服务主体，不用指定两个 `Service` 元素；您可以只使用一个该元素。实际上，您可以将一组多个服务主体作为单个 `Service` 元素的值。
```
"Principal": {
"Service": [
"ecs.amazonaws.com",
"elasticloadbalancing.amazonaws.com"
]
}
```
## 选择加入区域的 AWS 服务主体
您可以在多个 AWS 区域以及您必须选择加入的其中一些区域启动资源。有关您必须选择加入的区域的完整列表，请参阅 *AWS 一般参考* 指南中的[管理 AWS 区域](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html)。
当选择加入区域中的 AWS 服务在同一区域内提出请求时，服务主体名称格式被标识为其服务主体名称的非区域化版本：
`service-name.amazonaws.com`
当选择加入区域中的 AWS 服务向另一个区域内提出跨区域请求时，服务主体名称格式被标识为其服务主体名称的区域化版本：
`service-name.{region}.amazonaws.com`
例如，您有一个 Amazon SNS 主题位于区域 `ap-southeast-1`，一个 Amazon S3 桶位于选择加入区域 `ap-east-1`。您想要配置 S3 桶通知以向 SNS 主题发布消息。要允许 S3 服务向 SNS 主题发布消息，您必须通过该主题的基于资源的访问策略授予 S3 服务主体 `sns:Publish` 权限。
如果您在主题访问策略中指定了 S3 服务主体的非区域化版本 `s3.amazonaws.com`，则从桶向主题发出的 `sns:Publish` 请求将失败。以下示例在 SNS 主题访问策略的 `Principal` 策略元素中指定了非区域化 S3 服务主体。
```
"Principal": { "Service": "s3.amazonaws.com" }
```
由于桶位于选择加入区域，并且请求是在同一区域之外发出的，因此 S3 服务主体显示为区域化服务主体名称 `s3.ap-east-1.amazonaws.com`。当选择加入区域中的 AWS 服务向另一个区域发出请求时，您必须使用区域化服务主体名称。指定区域化服务主体名称后，如果桶向位于另一个区域的 SNS 主题发出 `sns:Publish` 请求，则请求将成功。以下示例在 SNS 主题访问策略的 `Principal` 策略元素中指定了区域化 S3 服务主体。
```
"Principal": { "Service": "s3.ap-east-1.amazonaws.com" }
```
只有指定了区域化服务主体名称，资源策略或基于服务主体的允许列表才能成功处理从一个选择加入区域到另一个区域的跨区域请求。
**注意**
对于 IAM 角色信任策略，我们建议使用非区域化服务主体名称。IAM 资源是全局性的，因此可以在任何区域使用相同的角色。
## 所有主体
您可以在基于资源的策略的 `Principal` 元素或在支持主体的条件键中使用通配符（\$1）指定所有主体。使用 [基于资源的策略](access_policies.md#policies_resource-based) *授予*权限和[条件键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)来限制策略语句的条件。
**重要**
我们强烈建议不要在带有 `Allow` 效果的基于资源的策略的 `Principal` 元素中使用通配符（\$1），除非您打算授予公共或匿名访问权限。否则，请在 `Principal` 元素中指定预期的主体、服务或 AWS 账户，然后进一步将访问权限限制在 `Condition` 元素内。对于 IAM 角色信任策略尤其如此，因为它们允许其他主体成为您账户中的主体。
对于基于资源的策略，使用带 `Allow` 效果的通配符（\$1）向所有用户（包括匿名用户）授予访问权限（公共访问权限）。对于账户中的 IAM 用户和角色主体，不需要其他权限。对于其他账户中的主体，他们还必须在其账户中拥有基于身份的权限，以允许他们访问您的资源。这称为 [cross-account access](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html)（跨账户访问）。
对于匿名用户，以下元素是等效的：
```
"Principal": "*"
```
```
"Principal" : { "AWS" : "*" }
```
您不能使用通配符匹配一部分主体名称或 ARN。
以下示例说明了基于资源的策略（而非 [AWS JSON 策略元素：NotPrincipal](reference_policies_elements_notprincipal.md)）可用于显式拒绝*除* `Condition` 元素中指定的主体之外的所有主体。应将此策略[添加至 Amazon S3 存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/add-bucket-policy.html)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "UsePrincipalArnInsteadOfNotPrincipalWithDeny",
"Effect": "Deny",
"Action": "s3:*",
"Principal": "*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:user/user-name"
}
}
}
]
}
```
------
## 更多信息
有关更多信息，请参阅下列内容：
+ 《Amazon Simple Storage Service 用户指南》**中的 [存储桶策略示例](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html)
+ 《Amazon Simple Notification Service 开发人员指南》中的 [Amazon SNS 示例策略](https://docs.aws.amazon.com/sns/latest/dg/UsingIAMwithSNS.html#ExamplePolicies_SNS)**
+ 《Amazon Simple Queue Service 开发商指南》中的 [Amazon SQS 策略示例](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSExamples.html)**
+ 《AWS Key Management Service 开发人员指南》中的 [密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)**
+ 《AWS 一般参考》中的 [账户标识符](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html)**
+ [OIDC 联合身份验证](id_roles_providers_oidc.md)
# AWS JSON 策略元素：NotPrincipal
`NotPrincipal` 元素使用 `"Effect":"Deny"` 拒绝所有主体的访问权限（`NotPrincipal` 元素中指定的主体***除外***）。主体可以是 IAM 用户、AWS STS 联合用户主体、IAM 角色、所担任的角色会话、AWS 账户、AWS 服务或其他主体类型。有关主体的更多信息，请参阅 [AWS JSON 策略元素：Principal](reference_policies_elements_principal.md)。
`NotPrincipal` 必须与 `"Effect":"Deny"` 一起使用。不支持将其与 `"Effect":"Allow"` 一起使用。
**重要**
我们不建议在基于资源的新策略中使用 `NotPrincipal` 作为安全和授权策略的一部分。如果您使用 `NotPrincipal`，则可能难以排查多策略类型的影响。我们建议改用带 ARN 条件运算符的 `aws:PrincipalArn` 上下文键。
## 关键点
+ 对于部分 AWS 服务（包括 VPC 端点），基于资源的策略也支持 `NotPrincipal` 元素。基于资源的策略是直接嵌入资源中的策略。您不能在基于 IAM 身份的策略或 IAM 角色信任策略中使用 `NotPrincipal` 元素。
+ 如果基于资源的策略语句包含对附加了权限边界策略的 IAM 用户或角色具有 `Deny` 效果的 `NotPrincipal` 策略元素，则不要使用这种策略语句。具有 `Deny` 效果的 `NotPrincipal` 元素将始终拒绝任何附加了权限边界策略的 IAM 主体，无论 `NotPrincipal` 元素中指定的值为何。这会导致本来可以访问该资源的某些 IAM 用户或角色失去访问权限。我们建议更改基于资源的策略语句，以将 [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN) 条件运算符和 [`aws:PrincipalArn`](reference_policies_condition-keys.md#condition-keys-principalarn) 上下文键结合使用来限制访问权限，而不是使用 `NotPrincipal` 元素。有关权限边界的信息，请参阅 [IAM 实体的权限边界](access_policies_boundaries.md)。
+ 当您使用 `NotPrincipal` 时，还必须指定未被拒绝主体的账户 ARN。否则，策略可能会拒绝对包含主体的整个账户的访问。根据您的策略中包括的服务，AWS 可能会先验证账户，然后验证用户。如果评估一个担任角色的用户（使用角色的某个人），AWS 会相继验证账户、角色，最后才是担任角色的用户。担任角色的用户是由他们担任角色时指定的角色会话名称标识的。因此，我们强烈建议您明确包括用户账户的 ARN，或者包括角色的 ARN 以及包含角色的账户的 ARN。
+ 服务控制策略（SCP）和资源控制策略（RCP）不支持 `NotPrincipal` 元素。
## `NotPrincipal` 元素的替代方案
在 AWS 中管理访问控制时，可能会遇到需要显式拒绝所有主体对某个资源的访问权限的情况，但您指定的一个或多个主体除外。AWS 建议使用带有全局条件上下文键的 Deny 语句，以实现更精确的控制和更轻松的故障排除。以下示例显示了使用条件运算符（如 `StringNotEquals` 或 `ArnNotEquals`）拒绝所有主体的访问权限（条件元素中指定的主体除外）的其他方法。
## 使用 IAM 角色的示例场景
您可以使用带有 Deny 语句的基于资源的策略来防止所有 IAM 角色（条件元素中指定的角色除外）访问或操作您的资源。这种方法遵循 AWS 安全原则，即显式拒绝始终优先于任何 allow 语句，并且有助于在整个 AWS 基础设施中维护最低权限原则。
我们建议不要使用 `NotPrincipal`，而是使用带有全局条件上下文键和条件运算符（如 [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN)）的 Deny 语句，来显式允许 IAM 角色访问您的资源。以下示例使用 [aws:PrincipalArn](reference_policies_condition-keys.md#condition-keys-principalarn) 显式允许 `read-only-role` 角色访问 `Bucket_Account_Audit` 文件夹中的 Amazon S3 存储桶。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyCrossAuditAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::Bucket_Account_Audit",
"arn:aws:s3:::Bucket_Account_Audit/*"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:role/read-only-role"
}
}
}
]
}
```
------
## 使用服务主体的示例场景
您可以使用 Deny 语句来防止所有服务主体（`Condition` 元素中指定的主体除外）访问或操作您的资源。当您需要在 AWS 环境中实施精细访问控制或在不同服务和应用程序之间建立安全边界时，这种方法特别有用。
我们建议不要使用 `NotPrincipal`，而是使用带有全局条件上下文键和条件运算符（如 [`StringNotEquals`](reference_policies_elements_condition_operators.md#Conditions_String)）的 Deny 语句，来显式允许服务主体访问您的资源。以下示例使用 `aws:PrincipalServiceName` 显式允许 AWS CodeBuild 服务主体访问 `BUCKETNAME` 文件夹中的 Amazon S3 存储桶。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyNotCodeBuildAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::BUCKETNAME",
"arn:aws:s3:::BUCKETNAME/*"
],
"Condition": {
"StringNotEqualsIfExists": {
"aws:PrincipalServiceName": "codebuild.amazonaws.com"
}
}
}
]
}
```
------
# IAM JSON 策略元素：Action
`Action` 元素描述将允许或拒绝的特定操作。声明必须包含 `Action` 或 `NotAction` 元素。每款 AWS 服务各自拥有一套描述任务的操作，您可使用相应服务来执行所描述的任务。例如，Amazon S3 的操作列表可以在 *Amazon Simple Storage Service 用户指南*中的[在策略中指定权限](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-with-s3-actions.html)找到，Amazon EC2 操作列表可以在[Amazon EC2 API 参考](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-apis.html)中找到，而适用于 AWS Identity and Access Management 的操作列表可以在 [IAM API 参考](https://docs.aws.amazon.com/IAM/latest/APIReference/API_Operations.html)中找到。要查找其他服务的操作列表，请参阅 API 参考[文档](https://aws.amazon.com/documentation)了解相关服务。
此外，AWS 以 JSON 格式提供服务参考信息，以简化策略管理工作流程的自动化。借助服务参考信息，您可以从机器可读文件中跨 AWS 服务访问可用操作、资源和条件键。有关更多信息，请参阅《服务授权参考》中的[用于编程访问的简化 AWS 服务信息](https://docs.aws.amazon.com/service-authorization/latest/reference/service-reference.html)。
通过将服务命名空间用作操作前缀（`iam`、`ec2`、`sqs`、`sns`、`s3` 等）并后跟允许或拒绝的操作名称来指定值。该名称必须与产品支持的操作相匹配。前缀和操作名称不区分大小写。例如，`iam:ListAccessKeys` 与 `IAM:listaccesskeys` 相同。以下示例显示用于不同服务的 `Action` 元素。
**Amazon SQS 操作**
```
"Action": "sqs:SendMessage"
```
**Amazon EC2 操作**
```
"Action": "ec2:StartInstances"
```
**IAM 操作**
```
"Action": "iam:ChangePassword"
```
**Amazon S3 操作**
```
"Action": "s3:GetObject"
```
您可以为 `Action` 元素指定多个值。
```
"Action": [ "sqs:SendMessage", "sqs:ReceiveMessage", "ec2:StartInstances", "iam:ChangePassword", "s3:GetObject" ]
```
可以使用多字符匹配通配符 (`*`) 和单字符匹配通配符 (`?`)，来授予对特定 AWS 产品所提供所有操作的访问权限。例如，以下 `Action` 元素适用于所有 S3 操作。
```
"Action": "s3:*"
```
还可以将通配符（`*` 或 `?`）作为操作名称的一部分使用。例如，下列 `Action` 元素适用于所有包含字符串 `AccessKey` 的 IAM 操作，包括 `CreateAccessKey`、`DeleteAccessKey`、`ListAccessKeys` 及 `UpdateAccessKey`。
```
"Action": "iam:*AccessKey*"
```
某些产品允许您限制可用的操作。例如，Amazon SQS 允许您只提供所有可能的 Amazon SQS 操作的一部分。在这种情况下，`*` 通配符不允许完全控制队列；而是仅允许控制您已共享的操作子集。有关更多信息，请参阅 *Amazon Simple Storage Service 开发人员指南*中的[了解权限](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html#PermissionTypes)。
# IAM JSON 策略元素：NotAction
`NotAction` 是与指定的操作列表*之外* 的所有内容显式匹配的高级策略元素。使用 `NotAction` 时只列出不应匹配的一些操作，而不是包括将匹配的长操作列表，因此生成的策略较短。`NotAction` 中指定的操作不受策略语句中 `Allow` 或 `Deny` 效果影响。这也就意味着，如果使用 `Allow` 效果，则允许未列出的所有适用操作或服务。此外，如果使用 `Deny` 效果，则拒绝此类未列出的操作或服务。将 `NotAction` 与 `Resource` 元素结合使用时，您需要提供策略的范围。这是 AWS 确定哪些操作或服务适用的方式。有关更多信息，请参阅以下策略示例。
**NotAction 与 Allow**
可在包含 `"Effect": "Allow"` 的语句中使用 `NotAction` 元素来提供对 AWS 服务中所有操作（在 `NotAction` 中指定的操作除外）的访问权限。您可以将它与 `Resource` 元素结合使用以提供策略的范围，从而将允许的操作限制为那些可在指定资源上执行的操作。
以下示例允许用户访问可在任何 S3 资源上执行的所有 Amazon S3 操作，但删除存储桶的操作*除外*。此策略也不允许其他服务中的操作，因为其他服务操作不适用于 S3 资源。
```
"Effect": "Allow",
"NotAction": "s3:DeleteBucket",
"Resource": "arn:aws:s3:::*",
```
有时您可能需要允许访问大量操作。使用 `NotAction` 元素可有效地修改语句，生成更短的操作列表。例如，由于 AWS 提供了如此多的服务，您可能需要创建一个策略，以允许用户执行除访问 IAM 操作之外的所有操作。
下面的示例允许用户访问除 IAM 之外的 AWS 服务中的所有操作。
```
"Effect": "Allow",
"NotAction": "iam:*",
"Resource": "*"
```
在同一语句或一个策略内的不同语句中使用 `NotAction` 元素和 `"Effect": "Allow"` 时要谨慎。`NotAction` 匹配未显式列出或适用指定资源的所有服务和操作，并且可能导致向用户授予超出您意图的更多权限。
**NotAction 与 Deny**
可在一个语句中将 `NotAction` 元素与 `"Effect": "Deny"` 结合使用，以拒绝访问列出的所有资源，在 `NotAction` 元素中指定的操作除外。此组合不允许列出的项目，而是显式拒绝未列出的操作。您仍必须允许您要允许的操作。
下面的条件示例在用户未使用 MFA 登录时拒绝其访问非 IAM 操作。如果用户已使用 MFA 登录，则 `"Condition"` 测试失败，最后的 `"Deny"` 语句将无效。但请注意，这不会向用户授予对任何操作的访问权限，只会明确拒绝除 IAM 操作之外的所有其他操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyAllUsersNotUsingMFA",
"Effect": "Deny",
"NotAction": "iam:*",
"Resource": "*",
"Condition": {"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}}
}]
}
```
------
有关拒绝访问特定区域以外的操作（来自特定服务的操作除外）的示例策略，请参阅[AWS：根据请求的区域拒绝访问 AWS](reference_policies_examples_aws_deny-requested-region.md)。
# IAM JSON 策略元素：Resource
IAM 策略语句中的 `Resource` 元素指定了该语句适用的一个或多个对象。语句必须包含 `Resource` 或 `NotResource` 元素。
使用 Amazon 资源名称（ARN）指定资源。ARN 的格式取决于 AWS 服务 和所引用的特定资源。尽管 ARN 格式各不相同，但您始终使用 ARN 来标识资源。有关 ARN 格式的更多信息，请参见 [IAM ARN](reference_identifiers.md#identifiers-arns)。有关如何指定资源的信息，请参阅您编写的资源声明所对应的产品文档。
**注意**
有些 AWS 服务 不允许您为单个资源指定操作。在这些情况下，您在 `Action` 或 `NotAction` 元素中列出的任何操作都适用于该服务中的所有资源。如果是这种情况，则可以在 `Resource` 元素中使用通配符（`*`）。
下列示例适用于特定的 Amazon SQS 队列。
```
"Resource": "arn:aws:sqs:us-east-2:account-ID-without-hyphens:queue1"
```
以下示例引用了 AWS 账户 中名为 `Bob` 的 IAM 用户。
**注意**
在 `Resource` 元素中，IAM 用户名区分大小写。
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/Bob"
```
## 在资源 ARN 中使用通配符
您可在 ARN（用冒号分隔的部分）的各分段中使用通配符（`*` 和 `?`）来表示：
+ 字符的任意组合（`*`）
+ 任何单个字符（`?`）
您可以在每个分段中使用多个 `*` 或 `?` 字符。如果 `*` 通配符是资源 ARN 分段的最后一个字符，则它可以扩展以匹配冒号边界以外的内容。我们建议您在 ARN 分段内使用通配符（`*` 和 `?`），用冒号隔开。
**注意**
不得在服务分段中使用可识别 AWS 产品的通配符。有关 ARN 分段的更多信息，请参阅 [使用 Amazon 资源名称（ARN）标识 AWS 资源](reference-arns.md)
以下示例引用了其路径为 `/accounting` 的所有 IAM 用户。
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/accounting/*"
```
下列示例适用于特定 Amazon S3 存储桶内的所有项目。
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
```
星号（`*`）字符可以展开以替换分段中的所有内容，包括像正斜杠（`/`）这样的字符，否则这些字符可能在给定服务命名空间中显示为分隔符。例如，请考虑以下 Amazon S3 ARN，因为相同的通配符扩展逻辑适用于所有服务。
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*/test/*"
```
ARN 中的通配符适用于存储桶中的以下所有对象，而不仅仅是列出的第一个对象。
```
amzn-s3-demo-bucket/1/test/object.jpg
amzn-s3-demo-bucket/1/2/test/object.jpg
amzn-s3-demo-bucket/1/2/test/3/object.jpg
amzn-s3-demo-bucket/1/2/3/test/4/object.jpg
amzn-s3-demo-bucket/1///test///object.jpg
amzn-s3-demo-bucket/1/test/.jpg
amzn-s3-demo-bucket//test/object.jpg
amzn-s3-demo-bucket/1/test/
```
考虑前一个列表中的最后两个对象。Amazon S3 对象名称可以常规分隔符正斜杠（`/`）字符开头或结尾。虽然 `/` 可作为分隔符，但在资源 ARN 中使用此字符时没有特定意义。它将被视为与任何其他有效字符相同。ARN 将不与以下对象匹配：
```
amzn-s3-demo-bucket/1-test/object.jpg
amzn-s3-demo-bucket/test/object.jpg
amzn-s3-demo-bucket/1/2/test.jpg
```
## 指定多个资源
您可以使用 ARN 数组在 `Resource` 元素中指定多个资源。下列示例适用于两个 DynamoDB 表。
```
"Resource": [
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/books_table",
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/magazines_table"
]
```
## 在资源 ARN 中使用策略变量
在 `Resource` 元素中，您可以在标识特定资源的 ARN 部分 (即，ARN 尾部) 中使用 JSON [策略变量](reference_policies_variables.md)。例如，您可以使用键 `{aws:username}` 作为资源 ARN 的一部分，以表示应包含当前用户的名称作为资源名称的一部分。下列示例显示如何在 `{aws:username}` 元素中使用 `Resource` 键。该策略允许访问匹配当前用户名称的 Amazon DynamoDB 表。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "arn:aws:dynamodb:us-east-2:111122223333:table/${aws:username}"
}
}
```
------
有关 JSON 策略变量的更多信息，请参阅[IAM policy 元素：变量和标签](reference_policies_variables.md)。
# IAM JSON 策略元素：NotResource
`NotResource` 是高级策略元素，可明确匹配除指定资源以外的所有资源。使用 `NotResource` 时只列出不应匹配的一些资源，而不是包括将匹配的长资源列表，因此生成的策略较短。这对于在单个 AWS 服务中应用的策略特别有用。
例如，假设您有名为 `HRPayroll` 的组。不应允许 `HRPayroll` 的成员访问除 `HRBucket` 存储桶中的 Amazon S3 文件夹之外的任何 `Payroll` 资源。以下策略显式拒绝访问除所列资源外的所有 Amazon S3 资源。但请注意，该策略不向用户授予对任何资源的访问权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Deny",
"Action": "s3:*",
"NotResource": [
"arn:aws:s3:::HRBucket/Payroll",
"arn:aws:s3:::HRBucket/Payroll/*"
]
}
}
```
------
通常，为了显式拒绝对某一资源的访问，可以编写一条策略，其中使用 `"Effect":"Deny"`，而且包含一个单独列出每个文件夹的 `Resource` 元素。但是，在这种情况下，每次向 `HRBucket` 添加文件夹或向 Amazon S3 添加不应访问的资源时，都必须将其名称添加到 `Resource` 元素中的列表中。如果改用 `NotResource` 元素，除非将文件夹名称添加到 `NotResource` 元素，否则会自动拒绝用户访问新文件夹。
使用 `NotResource` 时应注意，在此元素中指定的资源是不受限的*唯一*资源。反过来，这限制了将应用于该操作的所有资源。在上述示例中，该策略只影响 Amazon S3 操作，因此只影响 Amazon S3 资源。如果 `Action` 元素还包含 Amazon EC2 操作，则该策略将拒绝访问 `NotResource` 元素中未指定的任何 EC2 资源。要了解服务中的哪些操作允许指定资源的 ARN，请参阅 [AWS 服务的操作、资源和条件键](reference_policies_actions-resources-contextkeys.html)。
## 具有其他元素的 NotResource
您应**从不**将 `"Effect": "Allow"`、`"Action": "*"` 和 `"NotResource": "arn:aws:s3:::HRBucket"` 元素一起使用。此语句非常危险，因为它允许对在 `HRBucket` S3 存储桶之外的所有资源执行 AWS 中的所有操作。这甚至允许用户向自己添加策略，从而允许他们访问 `HRBucket`。请勿执行此操作。
在同一语句或一个策略内的不同语句中使用 `NotResource` 元素和 `"Effect": "Allow"` 时要谨慎。`NotResource` 允许未显式列出的所有服务和资源，并且可能导致向用户授予超出您意图的更多权限。在同一语句中使用 `NotResource` 元素和 `"Effect": "Deny"` 将拒绝未显式列出的服务和资源。
# IAM JSON 策略元素：Condition
`Condition` 元素（或 `Condition`* 块*）允许您指定策略生效的条件。`Condition` 元素是可选的。在 `Condition` 元素中，您可构建表达式并使用[条件运算符](reference_policies_elements_condition_operators.md)（等于、小于和其他）将策略中的上下文键和值与请求上下文中的键和值进行匹配。要了解有关请求上下文的更多信息，请参阅[请求的组成部分](intro-structure.md#intro-structure-request)。
```
"Condition" : { "{condition-operator}" : { "{condition-key}" : "{condition-value}" }}
```
您在策略条件中指定的上下文键可以是[全局条件上下文键](reference_policies_condition-keys.md)或特定于服务的上下文键。全局条件上下文键具有 `aws:` 前缀。特定于服务的上下文键具有服务的前缀。例如，Amazon EC2 允许您使用服务独有的 `ec2:InstanceType` 上下文键来编写条件。要查看带 `iam:` 前缀的特定于服务的 IAM 上下文键，请参阅 [IAM 和 AWS STS 条件上下文密钥](reference_policies_iam-condition-keys.md)。
上下文键*名称*不区分大小写。例如，包含 `aws:SourceIP` 上下文键等效于测试 `AWS:SourceIp`。上下文键*值* 是否区分大小写取决于您使用的[条件运算符](reference_policies_elements_condition_operators.md)。例如，以下条件包含 `StringEquals` 运算符，以确保只有 `john` 提出的请求才符合条件。名为 `John` 的用户会被拒绝访问。
```
"Condition" : { "StringEquals" : { "aws:username" : "john" }}
```
以下条件使用 [`StringEqualsIgnoreCase`](reference_policies_elements_condition_operators.md#Conditions_String) 运算符来匹配名为 `john` 或 `John` 的用户。
```
"Condition" : { "StringEqualsIgnoreCase" : { "aws:username" : "john" }}
```
某些上下文键支持允许您指定键名称的一部分的键/值对。示例包括 [`aws:RequestTag/tag-key`](reference_policies_condition-keys.md#condition-keys-requesttag) 上下文键、AWS KMS [https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context) 和多个服务支持的 [`ResourceTag/tag-key`](reference_policies_condition-keys.md#condition-keys-resourcetag) 上下文键。
+ 如果您对 [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policy-structure.html#amazon-ec2-keys) 等服务使用 `ResourceTag/tag-key` 上下文键，则必须指定 `tag-key` 的键名称。
+ **键名称不区分大小写。**这意味着，如果您在策略的条件元素中指定 `"aws:ResourceTag/TagKey1": "Value1"`，则条件将匹配名为 `TagKey1` 或 `tagkey1` 的资源标签键，但不会同时匹配两者。
+ 支持这些属性的 AWS 服务可能允许您创建多个仅大小写不同的键名称。例如，您可能需要通过 `ec2=test1` 和 `EC2=test2` 标记 Amazon EC2 实例。在使用 `"aws:ResourceTag/EC2": "test1"` 等条件以允许访问该资源时，键名称匹配两个标签，但仅一个值匹配。这可能会导致意外的条件失败。
**重要**
最佳实践是，在命名键-值对属性时，请确保您的账户成员遵循一致的命名约定。示例包括标签或 AWS KMS 加密上下文。您可以使用 [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) 上下文键（用于标记）或 [https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context-keys](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context-keys)（用于 AWS KMS 加密上下文）强制实现此目的。
+ 有关所有条件运算符及其工作原理描述的列表，请参阅[条件运算符](reference_policies_elements_condition_operators.md)。
+ 除非另行指定，否则所有上下文键均可有多个值。有关如何处理具有多个值的上下文键，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
+ 有关所有全局可用的上下文键的列表，请参阅 [AWS 全局条件上下文密钥](reference_policies_condition-keys.md)。
+ 有关每个服务定义的条件上下文键，请参阅 [AWS 服务的操作、资源和条件键](reference_policies_actions-resources-contextkeys.html)。
## 请求上下文
当[主体](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html?icmpid=docs_homepage_addtlrcs#principal)向 AWS 发出[请求](intro-structure.md#intro-structure-request)时，AWS 会将请求信息收集到请求上下文中。请求上下文包括有关主体、资源、操作和其他环境属性的信息。策略评估将策略中的属性与请求中发送的属性进行匹配，以评估和授权您可以在 AWS 中执行的操作。
您可以使用 JSON 策略的 `Condition` 元素来针对请求上下文测试特定上下文键。例如，您可以创建一个策略，该策略使用 [aws:CurrentTime](reference_policies_condition-keys.md#condition-keys-currenttime) 上下文键以[允许用户仅在特定的日期范围内执行操作](reference_policies_examples_aws-dates.md)。
以下示例显示了 Martha Rivera 发送停用其 MFA 设备的请求时的请求上下文表示。
```
Principal: AROA123456789EXAMPLE
Action: iam:DeactivateMFADevice
Resource: arn:aws:iam::user/martha
Context:
– aws:UserId=AROA123456789EXAMPLE:martha
– aws:PrincipalAccount=1123456789012
– aws:PrincipalOrgId=o-example
– aws:PrincipalARN=arn:aws:iam::1123456789012:assumed-role/TestAR
– aws:MultiFactorAuthPresent=true
– aws:MultiFactorAuthAge=2800
– aws:CurrentTime=...
– aws:EpochTime=...
– aws:SourceIp=...
```
请求上下文与允许用户删除自己的多重身份验证 (MFA) 设备的策略进行匹配，但前提是他们在过去一小时（3,600 秒）内使用 MFA 登录。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowRemoveMfaOnlyIfRecentMfa",
"Effect": "Allow",
"Action": [
"iam:DeactivateMFADevice"
],
"Resource": "arn:aws:iam::*:user/${aws:username}",
"Condition": {
"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "3600"}
}
}
}
```
------
在此示例中，该策略与请求上下文匹配：操作相同，资源与“\$1”通配符匹配，并且 `aws:MultiFactorAuthAge` 的值为 2800，小于 3600，因此该策略允许此授权请求。
AWS 会评估策略中的每个上下文键，并返回 *true* 或 *false* 值。请求中不存在的上下文键会视为不匹配。
请求上下文可返回以下值：
+ **True** - 如果请求者在过去 1 小时或更短时间内已使用 MFA 进行登录，则条件返回 *true*。
+ **False** - 如果请求者在 1 小时前已使用 MFA 进行登录，则条件返回 *false*。
+ **Not present**（不存在）- 如果请求者已使用其 IAM 用户访问密钥在 AWS CLI 或 AWS API 中发出请求，则键不存在。在此情况下，键不存在，并且它不匹配。
**注意**
在某些情况下，当条件键值不存在时，条件仍然可以返回 true。例如，如果您添加 `ForAllValues` 限定符，则当请求中不存在上下文键时，请求将返回 true。为了防止缺失的上下文键或具有空值的上下文键评估为 true，您可以在策略中包含具有 `false` 值的 [Null 条件运算符](reference_policies_elements_condition_operators.md#Conditions_Null)，以检查上下文键是否存在且其值不为空。
## 条件块
以下示例显示 `Condition` 元素的基本格式：
```
"Condition": {"StringLike": {"s3:prefix": ["jane/*"]}}
```
请求中的值由上下文键表示，在此示例中为 `s3:prefix`。将上下文密钥值与您指定为文本值的值进行比较，例如 `jane/*`。要进行的比较类型由[条件运算符](reference_policies_elements_condition_operators.md)指定（此处为 `StringLike`）。您可以使用典型的布尔比较（例如等于、大于和小于）来创建比较字符串、日期、数字等的条件。使用[字符串运算符](reference_policies_elements_condition_operators.md#Conditions_String)或 [ARN 运算符](reference_policies_elements_condition_operators.md#Conditions_ARN)时，还可以在上下文键值中使用[策略变量](reference_policies_variables.md)。以下示例包括 `aws:username` 变量。
```
"Condition": {"StringLike": {"s3:prefix": ["${aws:username}/*"]}}
```
在某些情况下，上下文键可能包含多个值。例如，对 Amazon DynamoDB 的请求可能需要从表返回或更新多个属性。访问 DynamoDB 表的策略可能包含 `dynamodb:Attributes` 上下文键，此键包含请求中列出的所有属性。您可以使用 `Condition` 元素中的集合运算符，根据策略中的允许属性列表测试请求中的多个属性。有关更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
在请求期间评估策略时，AWS 会将键替换为请求中的相应值。(在此示例中，AWS 将使用请求的日期和时间。) 将对条件进行评估以返回 true 或 false，然后再整体考虑策略是允许还是拒绝请求。
### 一个条件中包含多个值
一个 `Condition` 元素可以包含多个条件运算符，而每个条件运算符又可以包含多个上下文键值对。下图对此进行了说明。
![\[两个条件运算符方框图。第一个块包含两个上下文键占位符，每个占位符都有多个值。第二个条件块包含一个具有多个值的上下文键。\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block.diagram.png)
有关更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
# IAM JSON 策略元素：条件运算符
在 `Condition` 元素中使用条件运算符来将策略中的条件键和值与请求上下文中的值进行匹配。有关 `Condition` 元素的更多信息，请参阅 [IAM JSON 策略元素：Condition](reference_policies_elements_condition.md)。
您可以在策略中使用的条件运算符取决于您选择的条件键。您可以选择全局条件键或特定于服务的条件键。要了解可用于全局条件键的条件运算符，请参阅[AWS 全局条件上下文密钥](reference_policies_condition-keys.md)。要了解可用于特定于服务的条件键的条件运算符，请参阅 [AWS 服务的操作、资源和条件键](reference_policies_actions-resources-contextkeys.html)并选择要查看的服务。
**重要**
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配，并且条件为 *false*。如果策略条件要求该键为*不*匹配，如 `StringNotLike` 或 `ArnNotLike`，并且右键不存在，则条件为 *true*。此逻辑适用于所有条件运算符，但 [...IfExists](#Conditions_IfExists) 和 [Null check](#Conditions_Null) 除外。这些运算符测试请求上下文中是否存在 (exists) 键。
条件运算符可分为以下类别：
+ [String](#Conditions_String)
+ [数值](#Conditions_Numeric)
+ [日期和时间](#Conditions_Date)
+ [布尔值](#Conditions_Boolean)
+ [二进制](#Conditions_BinaryEquals)
+ [IP 地址](#Conditions_IPAddress)
+ [Amazon Resource Name (ARN)](#Conditions_ARN)（仅适用于某些服务。）
+ [… IfExists](#Conditions_IfExists)（检查密钥值是否作为另一检查的一部分存在）
+ [空检查](#Conditions_Null)（检查密钥值是否作为独立检查存在）
## 字符串条件运算符
利用字符串条件运算符，您可以构建基于键与字符串值的对比来限制访问的 `Condition` 元素。
+ **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - [支持](#Conditions_String-wildcard)
****
| 条件运算符 | 说明 |
| --- | --- |
| `StringEquals` | 精确匹配，区分大小写 |
| `StringNotEquals` | 否定匹配 |
| `StringEqualsIgnoreCase` | 精确匹配，忽略大小写 |
| `StringNotEqualsIgnoreCase` | 否定匹配，忽略大小写 |
| `StringLike` | 区分大小写的匹配。值可以在字符串中的任何位置包括多字符匹配的通配符（\$1）和单字符匹配的通配符（?）。您必须指定通配符才能实现部分字符串匹配。 如果一个键包含多个值，则 `StringLike` 可以用集合运算符（`ForAllValues:StringLike` 和 `ForAnyValue:StringLike`）来限定。有关更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。 |
| `StringNotLike` | 不区分大小写的无效匹配。值可以在字符串中的任何位置包括多字符匹配的通配符（\$1）或单字符匹配的通配符（?）。 |
**Example 字符串条件运算符**
例如，以下语句包含一个 `Condition` 元素，该元素使用 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) 键来指定必须将发出请求的主体为 `iamuser-admin` 作业类别。
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
}
}
}
}
```
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。在此示例中，当主体使用附加了标签的 IAM 用户时，请求上下文中才会存在 `aws:PrincipalTag/job-category` 键。对于主体，如果使用附加了标签或会话标签的 IAM 角色，则也会包括它。如果没有标签的用户尝试查看或编辑访问键，则该条件返回 `false`，并且此语句将隐式拒绝请求。
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– iamuser-admin
| 匹配 |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– dev-ops
| 不匹配 |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | 请求上下文中没有 `aws:PrincipalTag/job-category`。 | 不匹配 |
**Example 使用带有字符串运算符的策略变量**
以下示例使用 `StringLike` 条件运算符执行与[策略变量](reference_policies_variables.md)的字符串匹配来创建策略，该策略允许 IAM 用户使用 Amazon S3 控制台管理其 Amazon S3 存储桶中的“主目录”。该策略允许对 S3 存储桶执行指定操作，前提是 `s3:prefix` 与任一指定模式相匹配。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringLike": {
"s3:prefix": [
"",
"home/",
"home/${aws:username}/"
]
}
}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
]
}
]
}
```
下表显示了 AWS 如何根据请求上下文中的 [aws:username](reference_policies_condition-keys.md#condition-keys-username) 值，并针对不同用户评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– martha_rivera
| "StringLike": {
"s3:prefix": [
"home/",
"home/martha_rivera/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– nikki_wolf
| "StringLike": {
"s3:prefix": [
"home/",
"home/nikki_wolf/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | 请求上下文中没有 `aws:username`。 | 不匹配 |
有关说明如何使用 `Condition` 元素基于应用程序 ID 和用户 ID 限制资源的访问权限，以用于 OIDC 联合身份验证的策略示例，请参阅 [Amazon S3：允许 Amazon Cognito 用户访问其存储桶中的对象](reference_policies_examples_s3_cognito-bucket.md)。
### 多值字符串条件运算符
如果请求中的一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定字符串运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
| 条件运算符 | 说明 |
| --- | --- |
| `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase` | 请求中条件键的所有值均须与策略中的至少一个值相匹配。 |
| `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase` | 请求中至少有一个条件键值须与策略中的一个值相匹配。 |
| `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase` | 否定匹配。 请求中任何上下文键值均无法与策略中的任何上下文键值相匹配。 |
| `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase` | 否定匹配。 请求中至少有一个上下文键值不得与策略中的任何上下文键值相匹配。 |
| `ForAllValues:StringLike` | 请求中条件键的所有值均须与策略中的至少一个值相匹配。 |
| `ForAnyValue:StringLike` | 请求中至少有一个条件键值须与策略中的一个值相匹配。 |
| `ForAllValues:StringNotLike` | 否定匹配。 请求中任何上下文键值均无法与策略中的任何上下文键值相匹配。 |
| `ForAnyValue:StringNotLike` | 否定匹配。 请求中至少有一个上下文键值不得与策略中的任何上下文键值相匹配。 |
**Example 使用带有字符串条件运算符的 `ForAnyValue`**
此示例说明如何创建允许使用 Amazon EC2 `CreateTags` 操作将标签附加到实例的基于身份的策略。在使用 `StringEqualsIgnoreCase` 的情况下，只有在标签包含值为 `preprod` 或 `storage` 的 `environment` 键时，才能附加标签。向运算符追加 `IgnoreCase` 时，允许任何现有标签值的大写（例如 `preprod`、`Preprod` 和 `PreProd`）解析为 true。
当添加带有 [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) 条件键的 `ForAnyValue` 修饰符时，请求中至少有一个标签键值须与 `environment` 值相匹配。`ForAnyValue` 比较区分大小写，这可以防止用户为标签键使用不正确的大小写，例如使用 `Environment` 而不是 `environment`。
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
}
}
}
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
aws:RequestTag/environment:
– preprod
| 匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
– costcenter
aws:RequestTag/environment:
– PreProd
| 匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– Environment
aws:RequestTag/Environment:
– preprod
| 不匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– costcenter
aws:RequestTag/environment:
– preprod
| 不匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | 请求上下文中没有 `aws:TagKeys`。 aws:RequestTag/environment:
– storage
| 不匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
请求上下文中没有 `aws:RequestTag/environment`。 | 不匹配 |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | 请求上下文中没有 `aws:TagKeys`。 请求上下文中没有 `aws:RequestTag/environment`。 | 不匹配 |
### 通配符匹配
字符串条件运算符执行不强制使用预定义格式的无模式匹配。ARN 和 Date 条件运算符是字符串运算符的子集，用于强制执行条件键值的结构。
我们建议您使用与要比较键的值对应的条件运算符。例如，在将键与字符串值进行比较时，应使用[字符串条件运算符](#Conditions_String)。同样，在将键与 ARN 值进行比较时，应使用 [Amazon Resource Name (ARN) 条件运算符](#Conditions_ARN)。
**Example**
此示例演示了如何为组织的资源创建边界。该策略中的条件拒绝访问 Amazon S3 操作，除非当前访问的资源位于 AWS Organizations 中的特定组织单位 (OU) 中。AWS Organizations 路径是 Organizations 实体结构的文本表示形式。
条件的要求是 `aws:ResourceOrgPaths` 包含列出的任何 OU 路径。由于 `aws:ResourceOrgPaths` 为多值条件，因此该策略使用 `ForAllValues:StringNotLike` 运算符来比较 `aws:ResourceOrgPaths` 的值和策略中的 OU 列表。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyS3AccessOutsideMyBoundary",
"Effect": "Deny",
"Action": [
"s3:*"
],
"Resource": "*",
"Condition": {
"ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
}
}
}
]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | aws:ResourceOrgPaths:
– o-acorg/r-acroot/ou-acroot-sportsou/costcenter/
| 匹配 |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | aws:ResourceOrgPaths:
– o-acorg/r-acroot/ou-acroot-mediaou/costcenter/
| 不匹配 |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | 请求中没有 `aws:ResourceOrgPaths:`。 | 不匹配 |
## 数字条件运算符
利用数字条件运算符，您可以构建基于键与整数或小数值的对比来限制访问的 `Condition` 元素。
+ **策略变量** – 不支持
+ **通配符** - 不支持
****
| 条件运算符 | 说明 |
| --- | --- |
| `NumericEquals` | Matching |
| `NumericNotEquals` | 否定匹配 |
| `NumericLessThan` | “小于”匹配 |
| `NumericLessThanEquals` | “小于或等于”匹配 |
| `NumericGreaterThan` | “大于”匹配 |
| `NumericGreaterThanEquals` | “大于或等于”匹配 |
例如，以下语句包含一个 `Condition` 元素，该元素使用 `NumericLessThanEquals` 条件运算符与 `s3:max-keys` 密钥来指定请求者一次*最多*可在 `amzn-s3-demo-bucket` 内列出 10 个对象。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {"NumericLessThanEquals": {"s3:max-keys": "10"}}
}
}
```
------
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。在此示例中，当您执行 `ListBucket` 操作时，`s3:max-keys` 键始终存在于请求中。如果此策略允许所有 Amazon S3 操作，则只允许包含值小于或等于 10 的 `max-keys` 上下文密钥的操作。
## 日期条件运算符
利用日期条件运算符，您可以构建基于键与日期/时间值的对比来限制访问的 `Condition` 元素。您可以将这些条件运算符与 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) 键或 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime) 键配合使用。您必须指定日期/时间值，且其中一个 [W3C 实现要采用 ISO 8601 日期格式或新纪元 (UNIX) 时间格式](http://www.w3.org/TR/NOTE-datetime)。
+ **策略变量** – 不支持
+ **通配符** - 不支持
****
| 条件运算符 | 说明 |
| --- | --- |
| `DateEquals` | 匹配特定日期 |
| `DateNotEquals` | 否定匹配 |
| `DateLessThan` | 在特定日期和时间之前匹配。 |
| `DateLessThanEquals` | 在特定日期和时间或之前匹配 |
| `DateGreaterThan` | 在特定日期和时间之后匹配 |
| `DateGreaterThanEquals` | 在特定日期和时间或之后匹配 |
例如，以下语句包含一个 `Condition` 元素，该元素使用 `DateGreaterThan` 条件运算符与 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime) 键。此条件指定用于发出请求的临时安全凭证在 2020 年签发。此策略可以通过编程方式每天更新，以确保账户成员使用最新的凭证。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"DateGreaterThan": {
"aws:TokenIssueTime": "2020-01-01T00:00:01Z"
}
}
}
}
```
------
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。只有在主体使用临时凭证发出请求时，才会在请求上下文中包含 `aws:TokenIssueTime` 键。使用访问密钥发出的 AWS CLI、AWS API 或 AWS 开发工具包请求中未提供此键。在此示例中，如果 IAM 用户尝试查看或编辑访问键，请求将被拒绝。
## 布尔值条件运算符
利用布尔值条件，您可以构建基于键与 `true` 或 `false` 的对比来限制访问的 `Condition` 元素。
如果一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定布尔运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
+ **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - 不支持
****
| 条件运算符 | 说明 |
| --- | --- |
| `Bool` | 布尔值匹配 |
| `ForAllValues:Bool` | 与布尔数组数据类型一起使用。上下文键值中所有布尔值均须与策略中的布尔值相匹配。 为防止 `ForAllValues` 运算符将缺失的上下文键或带有空值的上下文键评估为“允许”，可以在策略中包含 [Null 条件运算符](#Conditions_Null)。 |
| `ForAnyValue:Bool` | 与布尔数组数据类型一起使用。上下文键值中至少有一个布尔值须与策略中的布尔值相匹配。 |
**Example 布尔值条件运算符**
以下基于身份的策略使用 `Bool` 条件运算符搭配 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) 键拒绝将对象和对象标签复制到目标存储桶及其内容（如果请求不是通过 SSL 进行的）。
该策略不允许进行任何操作。可将此策略与允许特定操作的其他策略结合使用。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BooleanExample",
"Action": "s3:ReplicateObject",
"Effect": "Deny",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Condition": {
"Bool": {
"aws:SecureTransport": "false"
}
}
}
]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– false
| 匹配 |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– true
| 不匹配 |
| "Bool": {
"aws:SecureTransport": "false"
} | 请求上下文中没有 `aws:SecureTransport`。 | 不匹配 |
## 二进制条件运算符
利用 `BinaryEquals` 条件运算符，您可以构建测试二进制格式键值的 `Condition` 元素。它会比较指定密钥字节的值和策略中 [base-64](https://en.wikipedia.org/wiki/Base64) 编码表示的二进制值。如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。
+ **策略变量** – 不支持
+ **通配符** - 不支持
```
"Condition" : {
"BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
}
```
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– QmluYXJ5VmFsdWVJbkJhc2U2NA==
| 匹配 |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– ASIAIOSFODNN7EXAMPLE
| 不匹配 |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | 请求上下文中没有 `key`。 | 不匹配 |
## IP 地址条件运算符
利用 IP 地址条件运算符，您可以构建 `Condition` 元素，它们会基于键与 IPv4 或 IPv6 地址或 IP 地址范围的对比来限制访问。可以通过 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip) 键来使用它们。该值必须采用标准的 CIDR 格式 (例如 203.0.113.0/24 或 2001:DB8:1234:5678::/64)。如果您指定的 IP 地址没有关联的路由前缀，IAM 将使用 `/32` 作为默认前缀值。
某些 AWS 服务支持 IPv6，使用 :: 表示一系列 0。要了解某项服务是否支持 IPv6，请参阅该服务的文档。
+ **策略变量** – 不支持
+ **通配符** - 不支持
****
| 条件运算符 | 说明 |
| --- | --- |
| `IpAddress` | 指定的 IP 地址或范围 |
| `NotIpAddress` | 除指定 IP 地址或范围外的所有 IP 地址 |
**Example IP 地址条件运算符**
下列语句使用 `IpAddress` 条件运算符与 `aws:SourceIp` 键来指定必须从 IP 范围 203.0.113.0 至 203.0.113.255 发出请求。
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}
}
}
```
`aws:SourceIp` 条件键解析为发出请求的 IP 地址。如果请求源自 Amazon EC2 实例，则 `aws:SourceIp` 计算为实例的公有 IP 地址。
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。`aws:SourceIp` 键始终存在于请求上下文中，但请求者使用 VPC 终端节点发出请求时除外。在这种情况下，条件返回 `false`，并且此语句隐式拒绝请求。
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 203.0.113.1
| 匹配 |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 198.51.100.1
| 不匹配 |
下面的示例说明如何结合使用 IPv4 和 IPv6 地址来覆盖组织的所有有效 IP 地址。建议您使用您的 IPv6 地址范围以及已拥有的 IPv4 范围来更新组织的策略，以确保策略在您过渡到 IPv6 时继续有效。
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "someservice:*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:SourceIp": [
"203.0.113.0/24",
"2001:DB8:1234:5678::/64"
]
}
}
}
}
```
如果以用户身份直接调用测试的 API，`aws:SourceIp` 条件键仅在 JSON 策略中有效。如果改为使用服务代表您调用目标服务，则目标服务看到的是进行调用的服务的 IP 地址而不是源用户的 IP 地址。举例来说，如果使用 AWS CloudFormation 调用 Amazon EC2 来构建实例，则会发生这种情况。目前，无法通过进行调用的服务将源 IP 地址传递给目标服务以在 JSON 策略中进行评估。对于这些服务 API 调用类型，请勿使用 `aws:SourceIp` 条件键。
## Amazon Resource Name (ARN) 条件运算符
利用 Amazon Resource Name (ARN) 条件运算符，您可以构建基于键与 ARN 的对比来限制访问的 `Condition` 元素。ARN 被视为一个字符串。
+ **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - [支持](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)
****
| 条件运算符 | 说明 |
| --- | --- |
| `ArnEquals`, `ArnLike` | 区分大小写的 ARN 匹配。ARN 的六个由冒号分隔开的部分都要单独检查，每一个部分都可包括一个多字符匹配通配符（\$1）或一个单字符匹配通配符（?）。`ArnEquals` 和 `ArnLike` 条件运算符的行为相同。 |
| `ArnNotEquals`, `ArnNotLike` | ARN 无效匹配。`ArnNotEquals` 和 `ArnNotLike` 条件运算符的行为相同。 |
**Example ARN 条件运算符**
以下基于资源的策略示例显示附加到 Amazon SQS 队列（您希望向其发送 SNS 消息的队列）的策略。它授予 Amazon SNS 将消息发送到所选队列的权限，但仅在该服务代表特定 Amazon SNS 主题发送这些消息时才授予此权限。您在 `Resource` 字段中指定队列，Amazon SNS 主题则作为 `SourceArn` 密钥的值。
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "SQS:SendMessage",
"Resource": "arn:aws:sqs:us-east-1:123456789012:QUEUE-ID",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-east-1:123456789012:TOPIC-ID"
}
}
}
}
```
仅在资源触发一项服务以代表资源拥有者调用另一项服务时，[https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 键存在于请求上下文中。如果 IAM 用户尝试直接执行此操作，则条件返回 `false`，并且此语句隐式拒绝请求。
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:123456789012:TOPIC-ID
| 匹配 |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:777788889999:TOPIC-ID
| 不匹配 |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | 请求上下文中没有 `aws:SourceArn`。 | 不匹配 |
### 多值 ARN 条件运算符
如果请求中的一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定 ARN 运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
| 条件运算符 | 说明 |
| --- | --- |
| `ForAllValues:ArnEquals` `ForAllValues:ArnLike` | 请求上下文中所有 ARN 均须与策略中的至少一个 ARN 模式相匹配。 |
| `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike` | 请求上下文中至少有一个 ARN 须与策略中的一个 ARN 模式相匹配。 |
| `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike` | 否定匹配。 请求上下文中任何 ARN 都无法与策略中的任何字符串 ARN 模式匹配。 |
| `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike` | 否定匹配。 请求上下文中至少有一个 ARN 不得与策略中的任何 ARN 模式相匹配。 |
**Example 使用带有 ARN 条件运算符的 `ForAllValues`**
以下示例使用 `ForAllValues:ArnLike` 创建或更新 Amazon CloudWatch Logs 日志的逻辑传输源。条件块中包含条件键 [https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys)，可筛选请求中传递的日志生成资源 ARN。使用此条件运算符，请求中的所有 ARN 均须与策略中的至少一个 ARN 相匹配。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "logs:PutDeliverySource",
"Resource": "arn:aws:logs:us-east-1:123456789012:delivery-source:*",
"Condition": {
"ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws:cloudfront::123456789012:distribution/*",
"arn:aws:cloudfront::123456789012:distribution/support*"
]
}
}
}
]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
| 匹配 |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
– arn:aws::cloudfront:123456789012:distribution/support2025
| 匹配 |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
– arn:aws::cloudfront:123456789012:distribution/admin
| 不匹配 |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:777788889999:distribution/costcenter
| 不匹配 |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | 请求上下文中没有 `logs:LogGeneratingResourceArns`。 | 匹配 |
如果请求中没有上下文键或者上下文键值解析为空数据集（如空字符串），则 `ForAllValues` 限定符也会返回 true。为了防止缺失的上下文键或具有空值的上下文键评估为 true，您可以在策略中包含具有 `false` 值的 [Null 条件运算符](#Conditions_Null)，以检查上下文键是否存在且其值不为空。
## ...IfExists 条件运算符
除 `Null` 条件外，您可在任何条件运算符名称的末尾添加 `IfExists`，例如，`StringLikeIfExists`。如果您是指“如果请求的内容中存在条件键，则依照策略所述来处理键。如果该键不存在，则条件元素的计算结果将为 true。” 语句中其他条件因素仍然可以导致不匹配，但使用 `...IfExists` 检查时没有缺失键。如果您使用带有否定条件运算符（如 `StringNotEqualsIfExists`）的 `"Effect": "Deny"` 元素，则即使条件键不存在，请求仍会被拒绝。
**使用 `IfExists` 的示例**
许多条件键描述有关特定类型的资源的信息，仅当访问该类型的资源时才存在。这些条件键在其他类型的资源上不存在。当策略语句仅适用于一种类型的资源时，这不会导致问题。但是，有时单个语句可以适用于多种类型的资源，例如当策略语句从多个服务引用操作时，或是当服务中的给定操作访问同一服务中的多种不同资源类型时。在这种情况下，在策略语句中包含仅适用于一种资源的条件键可能会导致策略语句中的 `Condition` 元素失败，从而使语句的 `"Effect"` 不适用。
例如，请考虑以下策略示例：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "THISPOLICYDOESNOTWORK",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {"StringLike": {"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]}}
}
}
```
------
上述策略的*意图*是使用户能够启动类型为 `t1`、`t2` 或 `m3` 的任何实例。但是，启动实例要求访问除了实例本身之外的许多资源；例如映像、密钥对、安全组等。会针对启动实例所需的每个资源来评估整个语句。这些其他资源没有 `ec2:InstanceType` 条件键，因此 `StringLike` 检查会失败，并且不会向用户授予启动*任何* 实例类型的能力。
要解决此问题，请改用 `StringLikeIfExists` 条件运算符。这样，仅当条件键存在时才会进行测试。您会读到以下策略内容：If the resource being checked has an "`ec2:InstanceType`" condition key, then allow the action only if the key value begins with `t1.`, `t2.`, or `m3.`. 如果所检查的资源没有改条件键，则无需担心。” 条件键值中的星号 (\$1) 与 `StringLikeIfExists` 条件运算符一起使用时，会被解释为通配符以实现部分字符串匹配。`DescribeActions` 语句包含在控制台中查看实例所需的操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RunInstance",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {
"StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
}
}
},
{
"Sid": "DescribeActions",
"Effect": "Allow",
"Action": [
"ec2:DescribeImages",
"ec2:DescribeInstances",
"ec2:DescribeVpcs",
"ec2:DescribeKeyPairs",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups"
],
"Resource": "*"
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– t1.micro
| 匹配 |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– m2.micro
| 不匹配 |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | 请求上下文中没有 `ec2:InstanceType`。 | 匹配 |
## 用于检查条件键是否存在的条件运算符
使用 `Null` 条件运算符检查授权时是否缺少条件键。在策略语句中使用 `true`（密钥不存在 - 为 null）或 `false`（密钥存在且值不为 null）。
您不能对[策略变量](reference_policies_variables.md)使用 `Null` 条件运算符。
例如，您可以使用此条件运算符来确定用户是使用临时凭证还是自己的凭证发出请求。如果用户使用的是临时凭证，则键 `aws:TokenIssueTime` 存在并具有一个值。以下示例显示了一个条件，该条件规定用户必须使用临时凭证（键不能缺失）才能使用 Amazon EC2 API。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":{
"Action":"ec2:*",
"Effect":"Allow",
"Resource":"*",
"Condition":{"Null":{"aws:TokenIssueTime":"false"}}
}
}
```
------
# 具有多个上下文键或值的条件
您可以使用策略的 `Condition` 元素测试请求中的多个上下文键或单个上下文键的多个值。在以编程方式或通过 AWS向 AWS 管理控制台 发出请求时，请求包含有关您的主体、操作和标签等的信息。您可以使用上下文键测试请求中匹配的上下文键的值，并在策略条件中指定上下文键。要了解请求中包含的信息和数据，请参阅[请求上下文](reference_policies_elements_condition.md#AccessPolicyLanguage_RequestContext)。
**Topics**
+ [多个上下文键或值的评估逻辑](#reference_policies_multiple-conditions-eval)
+ [否定匹配条件运算符的评估逻辑](#reference_policies_multiple-conditions-negated-matching-eval)
## 多个上下文键或值的评估逻辑
一个 `Condition` 元素可以包含多个条件运算符，而每个条件运算符又可以包含多个上下文键值对。除非另行指定，否则大多数上下文键都支持使用多个值。
+ 如果您的策略语句具有多个[条件运算符](reference_policies_elements_condition_operators.md)，则使用逻辑 `AND` 评估条件运算符。
+ 如果您的策略语句将多个上下文键附加到单个条件运算符，则使用逻辑 `AND` 评估上下文键。
+ 如果单个条件运算符包含一个上下文键的多个值，则使用逻辑 `OR` 评估这些值。
+ 如果单个否定匹配条件运算符包含一个上下文键的多个值，则使用逻辑 `NOR` 评估这些值。
条件元素块中的所有上下文键都必须解析为 true 才能调用所需的 `Allow` 或 `Deny` 效果。下图说明了具有多个条件运算符和上下文键值对的条件的评估逻辑。
![\[条件块显示了如何将 AND 和 OR 应用于多个上下文键和值\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_2.diagram.png)
例如，以下 S3 存储桶策略说明了上图在策略中的表示方式。此条件块包含条件运算符 `StringEquals` 和 `ArnLike`，以及上下文键 `aws:PrincipalTag` 和 `aws:PrincipalArn`。要调用所需的 `Allow` 或 `Deny` 效果，条件元素块中的所有上下文键都必须解析为 true。提出请求的用户必须同时拥有 *department* 和 *role* 这两个主体标签键，包括策略中指定的一个标签键值。此外，发出请求的用户的主体 ARN 必须与策略中指定的 `aws:PrincipalArn` 值之一匹配才能评估为 true。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: legal
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: payroll
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | 请求上下文中没有 `aws:PrincipalTag/role`。 aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | 请求上下文中没有 `aws:PrincipalTag`。 aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **不匹配** |
## 否定匹配条件运算符的评估逻辑
一些[条件运算符](reference_policies_elements_condition_operators.md)（如 `StringNotEquals` 或 `ArnNotLike`），使用否定匹配将策略中的上下文键值对与请求中的上下文键值对进行比较。当使用否定匹配条件运算符为策略中的单个上下文键指定多个值时，有效权限的工作方式类似于逻辑 `NOR`。在否定匹配中，仅当所有值都计算为 false 时，逻辑 `NOR` 或 `NOT OR` 才会返回 true。
下图说明了具有多个条件运算符和上下文键值对的条件的评估逻辑。此图包括上下文键 3 的否定匹配条件运算符。
![\[条件块显示了使用否定匹配条件运算符时，如何将 AND 和 OR 应用于多个上下文键和值\]](http://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_Negated_NOR_2.diagram.png)
例如，以下 S3 存储桶策略说明了上图在策略中的表示方式。此条件块包含条件运算符 `StringEquals` 和 `ArnNotLike`，以及上下文键 `aws:PrincipalTag` 和 `aws:PrincipalArn`。要调用所需的 `Allow` 或 `Deny` 效果，条件元素块中的所有上下文键都必须解析为 true。提出请求的用户必须同时拥有 *department* 和 *role* 这两个主体标签键，包括策略中指定的一个标签键值。由于 `ArnNotLike` 条件运算符使用否定匹配，发出请求的用户的主体 ARN 不得与策略中指定的任何 `aws:PrincipalArn` 值匹配才能评估为 true。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: legal
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: payroll
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | >请求上下文中没有 `aws:PrincipalTag/role`。 aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **不匹配** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | 请求上下文中没有 `aws:PrincipalTag`。 aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **不匹配** |
# 单值和多值上下文键
单值键和多值上下文键之间的差异取决于[请求上下文](intro-structure.md#intro-structure-request)中的值数量，而不是策略条件中的值数量。
+ *单值*上下文键在请求上下文中最多有一个值。例如，当您在 AWS 中标记资源时，每个资源标签都存储为键值对。由于资源标签键只能具有单个标签值，因此 [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) 为单值上下文键。请勿将条件集合运算符用于单值上下文键。
+ *多值*上下文键在请求上下文中可以有多个值。例如，当您在 AWS 中标记资源时，您可以在请求中包含多个标签键值对。因此，[aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) 是多值上下文键。多值上下文键需要条件条件集合运算符。
例如，一个请求最多可以来自一个 VPC 端点，因此 [aws:SourceVpce](reference_policies_condition-keys.md#condition-keys-sourcevpce) 是单值上下文键。由于服务可以有多个属于该服务的服务主体名称，因此 [aws:PrincipalServiceNamesList](reference_policies_condition-keys.md#condition-keys-principalservicenameslist) 是多值上下文键。
**重要**
单值键和多值上下文键之间的差异取决于请求上下文中的值数量，而不是策略条件中的值数量。
## 关键点
+ *单值*和*多值*分类作为*值类型*包含在 [AWS 全局条件上下文密钥](reference_policies_condition-keys.md) 主题每个条件上下文键的描述中。
+ [服务授权参考](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html)中的多值上下文键使用 `ArrayOf` 前缀，后跟条件运算符类别类型，例如 `ArrayOfString` 或 `ArrayOfARN`，表示请求可能包含条件上下文键的多个值。
+ 您可以使用任何可用的单值上下文键作为策略变量，但不能使用多值上下文键作为策略变量。有关策略变量的更多信息，请参阅 [IAM policy 元素：变量和标签](reference_policies_variables.md)。
+ 使用包含键值对的上下文键时，请务必注意，尽管可以有多个标签键值，但每个 `tag-key` 只能有一个值。
+ [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag)、[aws:RequestTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-requesttag) 和 [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) 是单值上下文键。
+ [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) 定义请求中允许使用的标签键，但不包含标签键值。由于您可以在一个请求中包含多个标签键值对，因此 `aws:TagKeys` 是一个多值上下文键。
+ 多值上下文键需要条件条件集合运算符。请勿将条件集合运算符 `ForAllValues` 或 `ForAnyValue` 用于单值上下文键。使用带有单值上下文键的条件集合运算符可能会导致过于宽容的策略。
## 多值上下文键的集合运算符
要将条件上下文键与具有多个键值的[请求上下文](intro-structure.md#intro-structure-request)键进行比较，必须使用 `ForAllValues` 或 `ForAnyValue` 集合运算符。这些集合运算符用于比较两组值，例如请求中的标签集和策略条件中的标签集。
限定词 `ForAllValues` 和 `ForAnyValue` 为条件运算符添加了集合运算功能，从而使您可以针对策略条件中的多个上下文键值测试具有多个值的请求上下文键。此外，如果在策略中包含带有通配符或变量的多值字符串上下文键，则还必须使用 `StringLike` [条件运算符](reference_policies_elements_condition_operators.md#Conditions_String)。如果有多个条件键值，则必须像[数组](reference_policies_grammar.md#policies-grammar-json)一样用方括号括起来，例如 `"Key2":["Value2A", "Value2B"]`。
### ForAllValues
`ForAllValues` 限定符测试请求上下文中每个成员的值是否与其后跟的条件运算符匹配。如果请求中的每个上下文键值均与策略中的一个上下文键值匹配，则条件返回 `true`。如果请求中没有上下文键，则它也会返回 `true`。
**重要**
如果将 `ForAllValues` 与 `Allow` 效果一起使用，请小心谨慎，因为如果请求上下文中意外出现缺失的上下文键，则策略可能会过于宽松。您应始终在策略中包含具有 `false` 值的 [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) 条件运算符，以检查上下文键是否存在且其值不为空。有关示例，请参阅[根据标签键控制访问](access_tags.md#access_tags_control-tag-keys)。
#### ForallValues 集合运算符示例
在以下示例中，ForAllValues 与 aws:TagKeys 一起使用，允许用户删除分配给 EC2 实例的特定标签。此策略仅允许用户删除 `environment` 和 `cost-center` 标签。您可以单独删除它们，也可以将其一起删除。请求中的标签键必须与策略中指定的键完全匹配。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DeleteTags",
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
| **匹配** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– cost-center
| **匹配** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– cost-center
| **匹配** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– dept
| **不匹配** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | 请求上下文中没有 `aws:TagKeys`。 | **不匹配** |
请注意，在最后一个示例中，结果为“无匹配”，因为当上下文键缺失时，空条件检查会阻止匹配。这是避免过于宽松的策略的最佳实践。
### ForAnyValue
`ForAnyValue` 限定符测试请求上下文键值集中的至少一个成员是否与策略条件中上下文键值集中的至少一个成员匹配。如果请求中的任何一个上下文键值与策略中的任何一个上下文键值匹配，则条件返回 `true`。如果没有匹配的上下文键或者键不存在，则条件返回 `false`。
**重要**
当使用具有 `Deny` 效果的 `ForAnyValue` 时，如果上下文键不存在于请求中，则策略的评估结果为**不匹配**。为了确保行为一致，请在策略中添加显式 [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) 条件检查，以验证上下文键是否存在。有关更多信息，请参阅 [用于检查条件键是否存在的条件运算符](reference_policies_elements_condition_operators.md#Conditions_Null)。
#### AnyValue 集合运算符示例
在以下示例中，ForAnyValue 与 aws:TagKeys 一起使用，允许用户删除分配给 EC2 实例的特定标签。如果请求中指定的标签键包括 `environment` 或 `cost-center`，则此策略允许用户删除实例的标签。请求可以包含策略中指定的标签键以外的其他标签键，但必须至少包含一个指定的键才能匹配条件。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DeleteTags",
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– cost-center
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– cost-center
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– dept
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– dept
| **不匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | 请求上下文中没有 `aws:TagKeys`。 | **不匹配** |
# 条件策略示例
在 IAM policy 中，您可以为单值和多值上下文键指定多个值，以便与请求上下文进行比较。以下一组策略示例演示了具有多个上下文键和值的策略条件。
**注意**
如果您愿意提交策略供本参考指南采用，请使用该页面底部的 **Feedback** 按钮。有关 IAM 基于身份的策略的示例，请参阅 [IAM 基于身份的策略示例](access_policies_examples.md)。
## 条件策略示例：单值上下文键
+ 具有单值上下文键的多个条件块。（[查看此示例](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-1)。）
+ 具有多个单值上下文键和值的一个条件块。（[查看此示例](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-2)。）
## 条件策略示例：多值上下文键
+ 使用条件集合运算符 `ForAllValues` 的拒绝策略。（[查看此示例](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-1)。）
+ 使用条件集合运算符 `ForAnyValue` 的拒绝策略。（[查看此示例](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-2)。）
# 多值上下文键示例
以下一组策略示例演示了如何使用多值上下文键创建策略条件。
## 示例：使用条件集合运算符 ForAllValues 的拒绝策略
以下示例显示了当请求中包含特定标签键前缀时，如何使用基于身份的策略拒绝使用 IAM 标记操作。[`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) 的值包括用于部分字符串匹配的通配符 (\$1)。此策略包括具有上下文键 `aws:TagKeys` 的 `ForAllValues` 集合运算符，因为请求上下文键可以包含多个值。为了使上下文键 `aws:TagKeys` 匹配，请求上下文中的每个值必须与策略中的至少一个值匹配。
如果请求中没有上下文键，`ForAllValues` 集合运算符也会返回 true。
您可以在策略中包含一个值为 `false` 的 `Null` 条件运算符来检查请求中的上下文键是否存在且其值不为空，从而防止缺失的上下文键或具有空值的上下文键评估为 true。有关更多信息，请参阅 [用于检查条件键是否存在的条件运算符](reference_policies_elements_condition_operators.md#Conditions_Null)。
**重要**
该策略不允许进行任何操作。可将此策略与允许特定操作的其他策略结合使用。
**Example 拒绝多值上下文键的单个策略条件值**
在以下示例中，策略拒绝请求中 `aws:TagKeys` 的值不包含前缀 **key1** 的请求。请求上下文可以有多个值，但由于 `ForAllValues` 条件集合运算符，请求上下文中的所有标签键值都必须以前缀 **key1** 开头。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
}
}
}
]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。对于 Deny 语句，匹配表示被拒绝，不匹配表示不拒绝，因此它可能被另一个语句允许。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:legal
| **不匹配** 可能被另一个语句允许。 |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **不匹配** 可能被另一个语句允许。 |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key2:audit
| **匹配** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | 请求上下文中没有 `aws:TagKeys`。 | **匹配** |
**Example 拒绝多值上下文键的多个策略条件值**
在以下示例中，策略拒绝请求中 `aws:TagKeys` 的值不包含前缀 **key1** 或 **key2** 的请求。请求上下文可以有多个值，但由于 `ForAllValues` 条件集合运算符，请求上下文中的所有标签键值都必须以前缀 **key1** 或 **key2** 开头。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
}
}
}
]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。对于 Deny 语句，匹配表示被拒绝，不匹配表示不拒绝，因此它可能被另一个语句允许。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:legal
| **不匹配** 可能被另一个语句允许。 |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **不匹配** 可能被另一个语句允许。 |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key2:audit
| **不匹配** 可能被另一个语句允许。 |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key3:legal
| **匹配** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | 请求上下文中没有 `aws:TagKeys`。 | **匹配** |
## 示例：使用条件集合运算符 ForAnyValue 的拒绝策略
如果任何快照使用策略中指定的标签键之一（`environment` 或 `webserver`）进行标记，则以下基于身份的策略示例拒绝创建 EC2 实例卷的快照。此策略包括具有上下文键 `aws:TagKeys` 的 `ForAnyValue` 集合运算符，因为请求上下文键可以包含多个值。如果您的标记请求包含策略中指定的任何一个标签键值，则 `aws:TagKeys` 上下文键返回 true，以调用拒绝策略效果。
**重要**
该策略不允许进行任何操作。可将此策略与允许特定操作的其他策略结合使用。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateSnapshot",
"ec2:CreateSnapshots"
],
"Resource": "arn:aws:ec2:us-west-2::snapshot/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。对于 Deny 语句，匹配表示被拒绝，不匹配表示不拒绝，因此它可能被另一个语句允许。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– webserver
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– webserver
– test
| **匹配** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– test
| **不匹配** 可能被另一个语句允许。 |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | 请求上下文中没有 `aws:TagKeys`。 | **不匹配** 可能被另一个语句允许。 |
# 单值上下文键策略示例
以下一组策略示例演示了如何使用单值上下文键创建策略条件。
## 示例：具有单值上下文键的多个条件块
条件块有多个条件时，每个条件都有一个上下文键，所有上下文键必须解析为 true 才能调用所需的 `Allow` 或 `Deny` 效果。使用否定匹配条件运算符时，条件值的评估逻辑是相反的。
以下示例允许用户创建 EC2 卷并在创建卷期间将标签应用到卷。请求上下文必须包含上下文键 `aws:RequestTag/project` 的值，以及上下文键 `aws:ResourceTag/environment` 的值可以是除生产之外的任何内容。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:CreateVolume",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:us-east-1:123456789012:volume/*",
"Condition": {
"StringLike": {
"aws:RequestTag/project": "*"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:us-east-1:123456789012:*/*",
"Condition": {
"StringNotEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
]
}
```
------
请求上下文必须包含项目标签值，并且不能为生产资源创建以调用 `Allow` 效果。以下 EC2 卷已成功创建，因为项目名称为 `Feature3`，资源标签为 `QA`。
```
aws ec2 create-volume \
--availability-zone us-east-1a \
--volume-type gp2 \
--size 80 \
--tag-specifications 'ResourceType=volume,Tags=[{Key=project,Value=Feature3},{Key=environment,Value=QA}]'
```
## 示例：具有多个单值上下文键和值的一个条件块
条件块包含多个上下文键并且每个上下文键具有多个值时，每个上下文键必须解析为 true，以便至少有一个键值能够调用所需的 `Allow` 或 `Deny` 效果。使用否定匹配条件运算符时，上下文键值的评估逻辑是相反的。
以下示例允许用户在 Amazon Elastic Container Service 集群上启动和运行任务。
+ 对于 `aws:RequestTag/environment` 上下文键 **AND**，请求上下文必须包含 `production` **或** `prod-backup`。
+ `ecs:cluster` 上下文键可确保在 `default1` **或** `default2` ARN ECS 集群上运行任务。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecs:RunTask",
"ecs:StartTask"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
}
}
}
]
}
```
------
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。
| 策略条件 | 请求上下文 | 结果 |
| --- | --- | --- |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: environment:production
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default1
| 匹配 |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: environment:prod-backup
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| 匹配 |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: webserver:production
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| 不匹配 |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | 请求上下文中没有 `aws:RequestTag`。 ecs:cluster
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| 不匹配 |
# IAM policy 元素：变量和标签
在编写策略时，如果您不知道资源或条件键的精确值，可以使用 AWS Identity and Access Management (IAM) policy 变量作为占位符。
**注意**
如果 AWS 无法解析变量，这可能会导致整个语句无效。例如，如果您使用 `aws:TokenIssueTime` 变量，只有在请求者（IAM 角色）使用临时凭证进行身份验证时，该变量才会解析为一个值。要防止变量导致无效的语句，请使用 [...IfExists 条件运算符](reference_policies_elements_condition_operators.md#Conditions_IfExists)。
**Topics**
+ [简介](#policy-vars-intro)
+ [在策略中使用变量](#policy-vars-using-variables)
+ [作为策略变量的标签](#policy-vars-tags)
+ [您可以使用策略变量的位置](#policy-vars-wheretouse)
+ [无值的策略变量](#policy-vars-no-value)
+ [可以用于策略变量的请求信息](#policy-vars-infotouse)
+ [指定默认值](#policy-vars-default-values)
+ [有关更多信息](#policy-vars-formoreinfo)
## 简介
在 IAM policy 中，您可通过很多操作为要控制其访问权限的特定资源指定名称。例如，以下策略允许用户为 `marketing` 项目列出、读取 S3 存储桶 `amzn-s3-demo-bucket` 中的对象以及将对象写入该存储桶。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["marketing/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/marketing/*"]
}
]
}
```
------
在某些情况下，您在编写策略时可能不知道资源的精确名称。您可能需要概括策略，这样无需为每个用户制作策略的唯一副本即可将该策略用于很多用户。我们建议您创建一个适用于该组中所有用户的单个组策略，而不是为每个用户创建一个单独的策略。
## 在策略中使用变量
您可以使用*策略变量*在策略中设置占位符，从而在策略中定义动态值。
变量使用 **`$`** 前缀标记，后面跟一对大括号 (**`{ }`**)，其中包含请求中值的变量名称。
评估策略时，策略变量将替换为来自请求中传递的条件上下文键的值。变量可用于[基于身份的策略、资源策略、服务控制策略、会话策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)和 [VPC 端点策略](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)。用作权限边界的基于身份的策略也支持策略变量。
全局条件上下文键可用作跨 AWS 服务的请求中的变量。在与 AWS 资源交互时，服务特定条件键也可以用作变量，但仅在针对支持它们的资源发出请求时才可用。有关每种 AWS 服务和资源的可用上下文键列表，请参阅《[https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html](https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html)》。某些情况下，您无法使用值填充全局条件上下文键。要了解有关每个键的更多信息，请参阅 [AWS 全局条件上下文键](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)。
**重要**
密钥名称不区分大小写。例如，`aws:CurrentTime` 等同于 `AWS:currenttime`。
您可以使用任何可用的单值条件密钥作为变量。您不能使用多值条件键作为变量。
以下示例显示了 IAM 角色或用户的策略，该策略用策略变量来替代特定资源名称。您可以利用 `aws:PrincipalTag` 条件键来重复使用此策略。完成策略评估后，仅当存储桶名称以 `team` 主体标签中的团队名称结尾时，`${aws:PrincipalTag/team}` 才允许操作。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["${aws:PrincipalTag/team}/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/team}/*"]
}
]
}
```
------
该变量使用 `$` 前缀标记，后跟一对大括号 (`{ }`)。在 `${ }` 字符内，可以包含想要在策略中使用的请求中的值名称。本页稍后将讨论您可以使用的值。
有关此全局条件键的详细信息，请参阅全局条件键列表中的 [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag)。
**注意**
为了使用策略变量，您必须在语句中包含 `Version` 元素，而且版本必须设置为支持策略变量的版本。变量是在 `2012-10-17` 版本中引入的。较早版本的策略语言不支持策略变量。如果您未添加 `Version` 元素，且没有将它设为相应的版本日期，则系统会将变量 (如 `${aws:username}`) 视为策略中的文字字符串。
`Version` 策略元素与策略版本不同。`Version` 策略元素用在策略之中，用于定义策略语言的版本。另一方面，当您更改 IAM 中的客户托管策略时，将创建一个策略版本。已更改的策略不会覆盖现有策略。而是由 IAM 创建新的托管策略版本。要了解 `Version` 策略元素的更多信息，请参阅[IAM JSON 策略元素：Version](reference_policies_elements_version.md)。要了解策略版本的更多信息，请参阅[IAM policy 版本控制](access_policies_managed-versioning.md)。
允许主体从 S3 存储桶中的 /David 路径获取对象的策略如下所示：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/David/*"
]
}
]
}
```
------
如果将此策略附加到用户 `David`，则该用户将获取自己 S3 存储桶中的对象，但您必须为每个用户创建包含该用户名称的单独策略，然后将每个策略附加到各个用户。
通过使用策略变量，您可以创建可重复使用的策略。以下策略允许用户在 `aws:PrincipalTag` 的标签键值与请求中传递的标签键 `owner` 值一致时，获取 Amazon S3 存储桶中的对象。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "AllowUnlessOwnedBySomeoneElse",
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": ["*"],
"Condition": {
"StringEquals": {
"s3:ExistingObjectTag/owner": "${aws:PrincipalTag/owner}"
}
}
}
]
}
```
------
如果您使用策略变量，而不是与此类似的用户名称，则无需为每个单独的用户创建单独的策略。在以下示例中，该策略被附加到一个将由产品经理使用临时安全凭证代入的 IAM 角色。当用户发出添加 Amazon S3 对象的请求时，IAM 将使用当前请求中的 `dept` 标签值替换 `${aws:PrincipalTag}` 变量，然后评估策略。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowOnlyDeptS3Prefix",
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/dept}/*"
]
}
]
}
```
------
## 作为策略变量的标签
在某些 AWS 服务中，您可以将自己的自定义属性附加到这些服务创建的资源。例如，您可以将标签应用于 Amazon S3 存储桶或者 IAM 用户。这些标签是键值对。您要定义标签键名称以及与该键名称关联的值。例如，您可以创建一个具有 **department** 键和 **Human Resources** 值的标签。有关标记 IAM 实体的更多信息，请参阅 [AWS Identity and Access Management 资源的标签](id_tags.md)。有关标记其他 AWS 服务创建的资源的信息，请参阅该服务的文档。有关使用标签编辑器的信息，请参阅《AWS 管理控制台 用户指南》**中的[使用标签编辑器](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/tag-editor.html)。
您可以标记 IAM 资源来简化对您的 IAM 资源的发现、组织和跟踪。您也可以标记 IAM 身份以控制对资源或标记本身的访问。要了解有关使用标签控制访问的更多信息，请参阅 [使用标签控制对 IAM 用户和角色的访问以及他们进行的访问](access_iam-tags.md)。
## 您可以使用策略变量的位置
您可以在 `Resource` 元素中和 `Condition` 元素的字符串比较中使用策略变量。
### 资源元素
您可以在 `Resource` 元素中使用策略变量，但只能在 ARN 的资源部分中使用策略变量。ARN 的这一部分出现在第五个冒号 (:) 之后。不能使用变量来替换 ARN 中第五个冒号之前的部分，例如服务或账户。有关 ARN 格式的更多信息，请参见[IAM ARN](reference_identifiers.md#identifiers-arns)。
要将 ARN 的一部分替换为标签值，请用 `${ }` 将前缀和键名称括起来。例如，以下 Resource 元素将仅指向名称等于请求用户的 department 标签中的值的存储桶。
`"Resource": ["arn:aws::s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/department}"]`
许多 AWS 资源使用包含用户创建的名称的 ARN。以下 IAM policy 确保只有 access-project、access-application 和 access-environment 标签值匹配的目标用户才能修改其资源。此外，使用 [\$1 通配符匹配](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html)，将可以允许自定义资源名称后缀。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessBasedOnArnMatching",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:DeleteTopic"],
"Resource": ["arn:aws:sns:*:*:${aws:PrincipalTag/access-project}-${aws:PrincipalTag/access-application}-${aws:PrincipalTag/access-environment}-*"
]
}
]
}
```
------
### 条件元素
您可以在任何涉及字符串运算符或 ARN 运算符的条件下对 `Condition` 值使用策略变量。字符串运算符包括 `StringEquals`、`StringLike` 和 `StringNotLike`。ARN 运算符包括 `ArnEquals` 和 `ArnLike`。不能将策略变量与其他运算符（如`Numeric`、`Date`、`Boolean`、`Binary`、`IP Address` 或 `Null` 运算符）一起使用。有关条件运算符的更多信息，请参阅[IAM JSON 策略元素：条件运算符](reference_policies_elements_condition_operators.md)。
当引用 `Condition` 元素表达式中的标签时，请将相关的前缀和标签键用作条件键。然后，使用要在条件值中测试的值。
例如，以下示例策略仅在将标签 `costCenter` 附加到用户时才允许用户拥有完全访问权限。该标签还必须具有值 `12345` 或 `67890`。如果该标签没有值或具有任何其他值，则请求会失败。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:*user*"
],
"Resource": "*",
"Condition": {
"StringLike": {
"iam:ResourceTag/costCenter": [ "12345", "67890" ]
}
}
}
]
}
```
------
## 无值的策略变量
当策略变量引用的条件上下文键没有值或不存在于请求的授权上下文中时，该值实际上为空。没有相等或相似的值。在以下情况下，条件上下文键可能不存在于授权上下文中：
+ 您在对不支持该条件键的资源的请求中使用服务特定条件上下文键。
+ IAM 主体、会话、资源或请求上的标签不存在。
+ 为 [AWS 全局条件上下文密钥](reference_policies_condition-keys.md) 中的每个全局条件上下文键列出的其他情况。
当您在 IAM policy 的条件元素中使用没有值的变量时，[IAM JSON 策略元素：条件运算符](reference_policies_elements_condition_operators.md)（如 `StringEquals` 或 `StringLike`）不匹配，并且策略声明不生效。
反向条件运算符（如 `StringNotEquals` 或 `StringNotLike`）确实与空值相匹配，因为它们测试的条件键的值不等于或不类似于实际空值。
在下例中，`aws:principaltag/Team` 必须等于 `s3:ExistingObjectTag/Team` 才能允许访问。未设置 `aws:principaltag/Team` 时会被显式拒绝访问。如果将授权上下文中没有值的变量用作策略的 `Resource` 或 `NotResource` 元素的一部分，则包含无值的策略变量的资源与任何资源都不匹配。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:ExistingObjectTag/Team": "${aws:PrincipalTag/Team}"
}
}
}
]
}
```
------
## 可以用于策略变量的请求信息
您可以使用 JSON 策略的 `Condition` 元素将[请求上下文](reference_policies_evaluation-logic_policy-eval-reqcontext.md)中的键与您在策略中指定的键值进行比较。当您使用策略变量时，AWS 使用请求上下文密钥中的值替换策略中的变量。
### 主体键值
`aws:username`、`aws:userid` 和 `aws:PrincipalType` 的值取决于发起请求的主体的类型。例如，可能使用 IAM 用户、IAM 角色或 AWS 账户根用户 的凭证发出请求。以下表为不同类型的主体显示这些键的值。
****
| 主体 | `aws:username` | `aws:userid` | `aws:PrincipalType` |
| --- | --- | --- | --- |
| AWS 账户根用户 | (不存在) | AWS 账户 ID | Account |
| IAM 用户 | IAM 用户名称 | [唯一 ID](reference_identifiers.md#identifiers-unique-ids) | User |
| AWS STS 联合用户主体 | (不存在) | 账户:调用者指定的名称 | FederatedUser |
| OIDC 联合主体 有关在使用 Web 联合身份验证时可用的策略键的信息，请参阅[AWS OIDC 联合身份验证的可用键](reference_policies_iam-condition-keys.md#condition-keys-wif)。 | (不存在) | *角色 ID*：*调用方指定的角色名称* 其中，`role-id` 是[角色的唯一 ID](reference_identifiers.md#identifiers-unique-ids)，调用方指定的角色名称由传递给 AssumeRoleWithWebIdentity 请求的 [RoleSessionName parameter](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AssumeRole.html#API_AssumeRoleWithWebIdentity_RequestParameters) 指定。 | AssumedRole |
| SAML 联合主体 有关在使用 SAML 联合身份验证时可用的策略键的信息，请参阅[唯一标识基于 SAML 的联合中的用户](id_roles_providers_saml.md#CreatingSAML-userid)。 | (不存在) | *角色 ID*：*调用方指定的角色名称* 其中，`role-id` 是[角色的唯一 ID](reference_identifiers.md#identifiers-unique-ids)，调用方指定的角色名称由 [Name 属性](id_roles_providers_create_saml_assertions.md)设置为 https://aws.amazon.com/SAML/attributes/RoleSessionName 的 Attribute 元素指定。 | AssumedRole |
| 担任的角色 | (不存在) | *角色 ID*：*调用方指定的角色名称* 其中，`role-id` 是[角色的唯一 ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids)，调用方指定的角色名称由传递给 AssumeRole 请求的 [RoleSessionName 参数](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters)指定。 | AssumedRole |
| 分配给 Amazon EC2 实例的角色 | (不存在) | *角色 ID*:*EC2 实例 ID* 其中 `role-id` 是[角色的唯一 ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids)，EC2 实例 ID 是 [EC2 实例的唯一标识符](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)。 | AssumedRole |
| 匿名调用者（仅限 Amazon SQS、Amazon SNS 和 Amazon S3） | (不存在) | anonymous | Anonymous |
对于此表中的项目请注意以下事项：
+ *不存在* 表示值在当前请求信息中不存在，并且匹配该值的任何尝试都失败并导致语句无效。
+ *角色 ID* 是在创建时分配给每个角色的唯一标识符。可以使用 AWS CLI 命令显示角色 ID：`aws iam get-role --role-name rolename`
+ *调用者指定的名称*和*调用者指定的角色名称* 是进行调用以获取临时凭证时调用进程 (例如应用程序或服务) 传递的名称。
+ *ec2-instance-id* 是在实例启动时分配给它的值，显示在 Amazon EC2 控制台的 **Instances**（实例）页面上。您还可以通过运行 AWS CLI 命令来显示实例 ID：`aws ec2 describe-instances`
### 联合主体的请求中的可用信息
联合主体是使用系统而不是 IAM 验证的用户。例如，公司可能拥有调用 AWS 的供内部使用的应用程序。为使用该应用程序的每位公司用户都提供 IAM 身份可能不现实。相反，该公司可能使用具有单一 IAM 身份的代理 (中间层) 应用程序，或该公司可能使用 SAML 身份提供程序 (IdP)。代理应用程序或 SAML IdP 会使用企业网络对单个用户进行身份验证。然后，代理应用程序可使用其 IAM 身份获取单个用户的临时安全凭证。实际上，SAML IdP 可以将身份信息交换为 AWS 临时安全凭证。然后，临时凭证即可用于访问 AWS 资源。
类似地，您可以创建用于移动设备的应用程序，该应用程序需要访问 AWS 资源。在这种情况下，您可以使用 *OIDC 联合身份验证*，其中应用程序使用知名身份提供者（如 Login with Amazon、Amazon Cognito、Facebook 或 Google）对用户进行身份验证。随后，应用程序可以使用这些提供商提供的用户身份验证信息来获取访问 AWS 资源的临时安全凭证。
使用 OIDC 联合身份验证的推荐方法是利用 Amazon Cognito 和 AWS 移动 SDK。有关更多信息，请参阅下列内容：
+ [Amazon Cognito 用户指南](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html)
+ [临时凭证的常见情形](id_credentials_temp.md#sts-introduction)
### 特殊字符
有几个特殊预定义策略变量具有固定值，可用于表示字符 (这些字符本身有特殊的含义)。如果这些特殊字符是您尝试匹配的字符串的一部分，而您原样插入这些字符，则不能正确进行解释。例如，在字符串中插入 \$1 星号会解释为与任何字符匹配的通配符 (而不是解释为文本 \$1)。这种情况下，可以使用以下预定义策略变量：
+ **\$1\$1\$1\$1** - 在需要 \$1（星号）字符的位置使用。
+ **\$1\$1?\$1** - 在需要 ?（问号）字符的位置使用。
+ **\$1\$1\$1\$1** - 在需要 \$1（美元符号）字符的位置使用。
在任何可以使用常规策略变量的字符串中，都可以使用这些预定义策略变量。
## 指定默认值
要向变量添加默认值，请用单引号 (`' '`) 括起默认值，并用逗号和空格 (`, `) 分隔变量文本和默认值。
例如，如果使用主体标记 `team=yellow`，他们可以访问名为 `amzn-s3-demo-bucket-yellow` 的 `ExampleCorp's` Amazon S3 存储桶。使用此资源的策略可能允许团队成员访问自己的团队存储桶，但不能访问其他团队的存储桶。对于没有团队标签的用户，它将原定设置值设为 `company-wide` 存储桶名称。这些用户只能访问 `amzn-s3-demo-bucket-company-wide` 存储桶，他们可以在其中查看广泛的信息，例如加入团队的说明。
```
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket-${aws:PrincipalTag/team, 'company-wide'}"
```
## 有关更多信息
欲了解更多有关策略的信息，请参阅：
+ [AWS Identity and Access Management 中的策略和权限](access_policies.md)
+ [IAM 基于身份的策略示例](access_policies_examples.md)
+ [IAM JSON 策略元素参考](reference_policies_elements.md)
+ [策略评估逻辑](reference_policies_evaluation-logic.md)
+ [OIDC 联合身份验证](id_roles_providers_oidc.md)
# IAM JSON 策略元素：支持的数据类型
本节列出了在 JSON 策略中指定值时支持的数据类型。策略语言并不针对每个策略元素支持所有类型；有关各个元素的信息，请参阅前面各部分。
+ 字符串
+ 数字 (整数和浮动值)
+ 布尔值
+ Null
+ Lists
+ 地图
+ 结构 (仅为嵌套映射)
以下图表将各个数据类型映射至串行化。注意所有策略必须为 UTF-8。有关 JSON 数据类型的信息，请转到 [RFC 4627](https://datatracker.ietf.org/doc/html/rfc4627)。
****
| Type | JSON |
| --- | --- |
| 字符串 | 字符串 |
| 整数 | 数字 |
| 浮点型 | 数字 |
| 布尔值 | 真假 |
| Null | null |
| 日期 | 字符串，符合 [W3C Profile of ISO 8601](http://www.w3.org/TR/NOTE-datetime) |
| IpAddress | 字符串，符合 [RFC 4632](https://datatracker.ietf.org/doc/html/rfc4632) |
| 列表 | 数组 |
| 对象 | 对象 |