# 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
| 不匹配 |