Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# IAM-JSON-Richtlinienelemente: Condition
Mit dem Element `Condition` (oder dem `Condition`-*Block*) können Sie angeben, unter welchen Bedingungen eine Richtlinie wirksam ist. Das Element `Condition` ist optional. Im `Condition`-Element formulieren Sie Ausdrücke, in denen Sie [Bedingungsoperatoren](reference_policies_elements_condition_operators.md) (gleich, kleiner als usw.) verwenden, um die Kontextschlüssel und -werte in der Richtlinie mit Schlüsseln und Werten im Anforderungskontext abzugleichen. Weitere Informationen zum Anforderungskontext finden Sie unter [Bestandteile einer Anfrage](intro-structure.md#intro-structure-request).
```
"Condition" : { "{condition-operator}" : { "{condition-key}" : "{condition-value}" }}
```
Der Kontextschlüssel, den Sie in einer Richtlinienbedingung angeben, kann ein [globaler Bedingungskontextschlüssel](reference_policies_condition-keys.md) oder ein servicespezifischer Kontextschlüssel sein. Kontextschlüssel für globale Bedingungen verfügen über das Präfix `aws:`. Servicespezifische Kontextschlüssel verfügen über das Präfix des Services. Mit Amazon EC2 können Sie beispielsweise mithilfe des `ec2:InstanceType`-Kontextschlüssels eine Bedingung schreiben, die für diesen Service eindeutig ist. Informationen zum Anzeigen servicespezifischer IAM-Kontextschlüssel mit dem Präfix `iam:` finden Sie unter [IAM- und AWS STS Bedingungskontextschlüssel](reference_policies_iam-condition-keys.md).
Bei *Namen* von Kontextschlüsseln wird die Groß-/Kleinschreibung nicht beachtet. Das Einbeziehen des `aws:SourceIP`-Kontextschlüssels ist beispielsweise gleichbedeutend mit dem Testen auf `AWS:SourceIp`. Die Berücksichtigung der Groß- und Kleinschreibung bei *Werten* von Kontextschlüsseln hängt vom verwendeten [Bedingungsoperator](reference_policies_elements_condition_operators.md) ab. Die folgende Bedingung enthält beispielsweise den `StringEquals`-Operator, um sicherzustellen, dass nur von `john` gestellte Anfragen übereinstimmen. Benutzern mit dem Namen `John` wird der Zugriff verweigert.
```
"Condition" : { "StringEquals" : { "aws:username" : "john" }}
```
Die folgende Bedingung verwendet den [`StringEqualsIgnoreCase`](reference_policies_elements_condition_operators.md#Conditions_String)-Operator, damit Benutzer mit dem Namen `john` oder `John` gefunden werden.
```
"Condition" : { "StringEqualsIgnoreCase" : { "aws:username" : "john" }}
```
Einige Kontextschlüssel unterstützen Schlüssel-Wert-Paare, mit denen Sie einen Teil des Schlüsselnamens festlegen können. Beispiele hierfür sind der [`aws:RequestTag/tag-key`](reference_policies_condition-keys.md#condition-keys-requesttag)Kontextschlüssel 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), der und der [`ResourceTag/tag-key`](reference_policies_condition-keys.md#condition-keys-resourcetag)Kontextschlüssel, die von mehreren Diensten unterstützt werden.
+ Wenn Sie den `ResourceTag/tag-key`-Kontextschlüssel für einen Service wie etwa [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policy-structure.html#amazon-ec2-keys) verwenden, müssen Sie einen Schlüsselnamen für den `tag-key` angeben.
+ **Bei den Schlüsselnamen muss die Groß- und Kleinschreibung nicht berücksichtigt werden.** Dies bedeutet Folgendes: Wenn Sie `"aws:ResourceTag/TagKey1": "Value1"` im Bedingungselement Ihrer Richtlinie angeben, stimmt die Bedingung mit einem Ressourcen-Tag-Schlüssel mit dem Namen `TagKey1` oder `tagkey1` überein, aber nicht mit beiden.
+ AWS Dienste, die diese Attribute unterstützen, ermöglichen es Ihnen möglicherweise, mehrere Schlüsselnamen zu erstellen, die sich nur durch Groß- und Kleinschreibung unterscheiden. Ein Beispiel wäre hier das Tagging einer Amazon-EC2-Instance mit `ec2=test1` und `EC2=test2`. Wenn Sie eine Bedingung wie `"aws:ResourceTag/EC2": "test1"` verwenden, um den Zugriff auf diese Ressource zu erlauben, stimmt der Schlüsselname mit beiden Tags, jedoch nur mit einem Wert überein. Dies kann zu unerwarteten Bedingungsfehlern führen.
**Wichtig**
Als bewährte Methode stellen Sie sicher, dass Mitglieder Ihres Kontos eine konsistente Namenskonvention beim Benennen von Schlüssel-Wert-Paar-Attributen verfolgen. Beispiele hierfür sind Tags oder AWS KMS -Verschlüsselungskontexte. Sie können dies erzwingen, indem Sie den [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys)Kontextschlüssel für das Tagging oder den [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)für den AWS KMS Verschlüsselungskontext verwenden.
+ Eine Liste aller Bedingungsoperatoren und eine Beschreibung ihrer Funktionsweise finden Sie unter [Bedingungsoperatoren](reference_policies_elements_condition_operators.md).
+ Sofern nicht anders angegeben, können alle Kontextschlüssel mehrere Werte haben. Eine Beschreibung zum Umgang mit Kontextschlüsseln mit mehreren Werten finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ Eine Liste aller global verfügbaren Kontextschlüssel finden Sie unter [AWS Kontextschlüssel für globale Bedingungen](reference_policies_condition-keys.md).
+ Bedingungskontextschlüssel, die von jedem Dienst definiert werden, finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für AWS Dienste](reference_policies_actions-resources-contextkeys.html).
## Der Anforderungskontext
Wenn ein [Principal](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html?icmpid=docs_homepage_addtlrcs#principal) eine [Anfrage](intro-structure.md#intro-structure-request) an stellt AWS, fasst er AWS die Anforderungsinformationen in einem Anforderungskontext zusammen. Der Anforderungskontext umfasst Informationen über den Prinzipal, Ressourcen, Aktionen und andere Umgebungseigenschaften. Bei der Richtlinienbewertung werden die Eigenschaften in der Richtlinie mit den in der Anforderung gesendeten Eigenschaften abgeglichen, um die Aktionen zu bewerten und zu autorisieren, die Sie in AWS ausführen können.
Sie können das `Condition`-Element einer JSON-Richtlinie verwenden, um bestimmte Kontextschlüssel anhand des Anforderungskontexts zu testen. Sie können beispielsweise eine Richtlinie erstellen, die den CurrentTime Kontextschlüssel [aws:](reference_policies_condition-keys.md#condition-keys-currenttime) verwendet, um [es einem Benutzer zu ermöglichen, Aktionen nur innerhalb eines bestimmten Zeitraums durchzuführen.](reference_policies_examples_aws-dates.md)
Das folgende Beispiel zeigt eine Darstellung des Anforderungskontexts, wenn Martha Rivera eine Anfrage zur Deaktivierung ihres MFA-Geräts sendet.
```
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=...
```
Der Anforderungskontext wird mit einer Richtlinie abgeglichen, die es Benutzern erlaubt, ihr eigenes Gerät für die Multi-Faktor-Authentifizierung (MFA) zu entfernen, jedoch nur, wenn sie sich innerhalb der letzten Stunde (3600 Sekunden) mit MFA angemeldet haben.
------
#### [ 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"}
}
}
}
```
------
In diesem Beispiel stimmt die Richtlinie mit dem Anforderungskontext überein: Die Aktion ist dieselbe, die Ressource stimmt mit dem Platzhalter „\$1“ überein und der Wert für `aws:MultiFactorAuthAge` ist 2800, also kleiner als 3600, sodass die Richtlinie diese Autorisierungsanforderung zulässt.
AWS wertet jeden Kontextschlüssel in der Richtlinie aus und gibt den Wert *wahr* oder *falsch* zurück. Ein Kontextschlüssel, der in der Anfrage nicht vorhanden ist, wird als Nichtübereinstimmung betrachtet.
Der Anforderungskontext kann die folgenden Werte zurückgeben:
+ **True** – Wenn der Anforderer sich innerhalb der letzten Stunde per MFA angemeldet hat, gibt die Bedingung *true* zurück.
+ **False** – Wenn sich der Anforderer vor mehr als einer Stunde per MFA angemeldet hat, gibt die Bedingung *false* zurück.
+ **Nicht vorhanden** — Wenn der Anforderer eine Anfrage mit seinen IAM-Benutzerzugriffsschlüsseln in der AWS CLI AWS OR-API gestellt hat, ist der Schlüssel nicht vorhanden. In diesem Fall ist der Schlüssel nicht vorhanden und stimmt nicht überein.
**Anmerkung**
In einigen Fällen kann die Bedingung auch dann „true“ zurückgeben, wenn der Bedingungsschlüsselwert nicht vorhanden ist. Wenn Sie beispielsweise den `ForAllValues`-Qualifizierer hinzufügen, gibt die Anforderung „true“ zurück, wenn der Kontextschlüssel nicht in der Anforderung enthalten ist. Um zu verhindern, dass fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „true“ ausgewertet werden, können Sie den [Null-Bedingungsoperator](reference_policies_elements_condition_operators.md#Conditions_Null) mit einem `false`-Wert in Ihre Richtlinie aufnehmen, um zu überprüfen, ob der Kontextschlüssel vorhanden ist und sein Wert nicht null ist.
## Der Bedingungsblock
Das folgende Beispiel zeigt das grundlegende Format eines `Condition`-Elements:
```
"Condition": {"StringLike": {"s3:prefix": ["jane/*"]}}
```
Ein Wert aus der Anfrage wird durch einen Kontextschlüssel dargestellt, in diesem Fall `s3:prefix`. Der Kontextschlüsselwert wird mit einem Wert verglichen, den Sie als Literalwert angeben, z. B. `jane/*`. Der vorzunehmende Vergleich wird vom [Bedingungsoperator](reference_policies_elements_condition_operators.md) (hier `StringLike`) bestimmt. Sie können Bedingungen erstellen, die Zeichenketten, Datumsangaben, Zahlen und vieles mehr mit typischen booleschen Vergleichen wie "gleich", "größer als" und "kleiner als" vergleichen. Wenn Sie [Zeichenfolgen-Operatoren](reference_policies_elements_condition_operators.md#Conditions_String) oder [ARN-Operatoren](reference_policies_elements_condition_operators.md#Conditions_ARN) verwenden, können Sie auch eine [Richtlinienvariable](reference_policies_variables.md) im Kontextschlüsselwert verwenden. Das folgende Beispiel enthält die Variable `aws:username`.
```
"Condition": {"StringLike": {"s3:prefix": ["${aws:username}/*"]}}
```
Unter bestimmten Umständen können Kontextschlüssel mehrere Werte enthalten. Eine Anforderung an Amazon DynamoDB könnte beispielsweise darin bestehen, mehrere Attribute einer Tabelle zurückzugeben oder zu aktualisieren. Eine Richtlinie für den Zugriff auf DynamoDB-Tabellen kann den `dynamodb:Attributes`-Kontextschlüssel enthalten, der alle in der Anfrage aufgeführten Attribute enthält. Sie können diese Attribute mit einer Liste zulässiger Attribute in einer Richtlinie mithilfe von Mengenoperatoren im Element `Condition` vergleichen. Weitere Informationen finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
Wenn die Richtlinie während einer Anfrage evaluiert wird, wird der Schlüssel AWS durch den entsprechenden Wert aus der Anfrage ersetzt. (In diesem Beispiel AWS würden Datum und Uhrzeit der Anfrage verwendet.) Die Auswertung der Bedingung gibt "true" oder "false" zurück und das Ergebnis wird von der Richtlinie berücksichtigt, um die Anforderung zuzulassen oder zu verweigern.
### Mehrere Werte in einer Bedingung
Ein `Condition`-Element kann mehrere Bedingungsoperatoren enthalten, und jeder Bedingungsoperator kann mehrere Kontext-Schlüssel-Wert-Paare enthalten. Dies wird in folgender Abbildung veranschaulicht.
![\[Zwei Blockdiagramme für Bedingungs-Operatoren. Der erste Block enthält zwei Platzhalter für Kontextschlüssel mit jeweils mehreren Werten. Der zweite Bedingungsblock enthält einen Kontextschlüssel mit mehreren Werten.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block.diagram.png)
Weitere Informationen finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
# IAM-JSON-Richtlinienelemente: Bedingungsoperatoren
Verwenden Sie Bedingungsoperatoren im `Condition`-Element, um den Bedingungsschlüssel und -wert in der Richtlinie mit den Werten im Anforderungskontext abzugleichen. Weitere Informationen zum `Condition`-Element finden Sie unter [IAM-JSON-Richtlinienelemente: Condition](reference_policies_elements_condition.md).
Der Bedingungsoperator, den Sie in einer Richtlinie verwenden können, hängt vom ausgewählten Bedingungsschlüssel ab. Sie können einen globalen Bedingungsschlüssel oder einen servicespezifischen Bedingungsschlüssel auswählen. Informationen dazu, welchen Bedingungsoperator Sie für einen globalen Bedingungsschlüssel verwenden können, finden Sie unter [AWS Kontextschlüssel für globale Bedingungen](reference_policies_condition-keys.md). Informationen darüber, welchen Bedingungsoperator Sie für einen dienstspezifischen Bedingungsschlüssel verwenden können, finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für AWS Dienste](reference_policies_actions-resources-contextkeys.html) und wählen Sie den Service aus, den Sie anzeigen möchten.
**Wichtig**
Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein und die Bedingung ist *falsch*. Wenn die Richtlinienbedingung erfordert, dass der Schlüssel *nicht* abgestimmt ist, wie `StringNotLike` oder `ArnNotLike`, und der richtige Schlüssel ist nicht vorhanden, ist die Bedingung *wahr*. [Diese Logik gilt für alle Bedingungsoperatoren außer... IfExists](#Conditions_IfExists)und [Nullprüfung](#Conditions_Null). Diese Operatoren testen, ob der Schlüssel im Anforderungskontext vorhanden ist (existiert).
Die Bedingungsoperatoren können in folgende Kategorien gruppiert werden:
+ [Zeichenfolge](#Conditions_String)
+ [Numerischer Wert](#Conditions_Numeric)
+ [Datum und Uhrzeit](#Conditions_Date)
+ [Boolesch](#Conditions_Boolean)
+ [Binary](#Conditions_BinaryEquals)
+ [IP-Adresse](#Conditions_IPAddress)
+ [Amazon Ressourcenname (ARN)](#Conditions_ARN) (nur für bestimmte Services verfügbar.)
+ [... IfExists](#Conditions_IfExists)(prüft, ob der Schlüsselwert im Rahmen einer anderen Prüfung existiert)
+ [Null](#Conditions_Null)-Prüfung (überprüft als eigenständige Prüfung, ob der Schlüsselwert vorhanden ist)
## Bedingungsoperatoren für Zeichenfolgen
Mit String-Bedingungsoperatoren können Sie `Condition`-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem Zeichenfolgewert einschränken.
+ **Richtlinienvariablen**: [unterstützt](reference_policies_variables.md)
+ **Platzhalter**: [unterstützt](#Conditions_String-wildcard)
****
| Bedingungsoperator | Description |
| --- | --- |
| `StringEquals` | Exakte Übereinstimmung, Unterscheidung von Groß- und Kleinschreibung |
| `StringNotEquals` | Negierte Übereinstimmung |
| `StringEqualsIgnoreCase` | Exakte Übereinstimmung, keine Unterscheidung von Groß- und Kleinschreibung |
| `StringNotEqualsIgnoreCase` | Negierte Übereinstimmung, keine Unterscheidung von Groß- und Kleinschreibung |
| `StringLike` | Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung Die Werte können einen Mehrzeichen-Übereinstimmungs-Platzhalter (\$1) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) an einer beliebigen Stelle in der Zeichenfolge enthalten. Sie müssen Platzhalter angeben, um teilweise Zeichenfolgenübereinstimmungen zu erzielen. Wenn ein Schlüssel mehrere Werte enthält, kann `StringLike` mit den Set-Operatoren `ForAllValues:StringLike` und `ForAnyValue:StringLike` ausgewertet werden. Weitere Informationen finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys). |
| `StringNotLike` | Negierte Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung Die Werte können einen Mehrzeichen-Übereinstimmungs-Platzhalter (\$1) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) an einer beliebigen Stelle in der Zeichenfolge enthalten. |
**Example Bedingungsoperator für Zeichenfolge**
Zum Beispiel enthält die folgende Anweisung ein `Condition`-Element, das den [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)-Schlüssel verwendet, um anzugeben, dass der anfordernde Prinzipal mit der `iamuser-admin`-Aufgabenkategorie getaggt sein muss.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
}
}
}
}
```
Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. In diesem Beispiel ist der Schlüssel `aws:PrincipalTag/job-category` im Anforderungskontext vorhanden, wenn der Auftraggeber einen IAM-Benutzer mit angehängten Tags verwendet. Er ist auch für einen Auftraggeber enthalten, der eine IAM-Rolle mit angehängten Tags oder Sitzungstags verwendet. Wenn ein Benutzer ohne das Tag versucht, einen Zugriffsschlüssel anzuzeigen oder zu bearbeiten, gibt die Bedingung `false` zurück und die Anforderung wird durch diese Anweisung implizit abgelehnt.
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– iamuser-admin
| Match |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– dev-ops
| Keine Übereinstimmung |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | Kein `aws:PrincipalTag/job-category` im Anfragekontext. | Keine Übereinstimmung |
**Example Verwenden einer Richtlinienvariablen mit einem Bedingungsoperator für eine Zeichenfolge**
Im folgenden Beispiel wird der `StringLike`-Bedingungsoperator verwendet, um einen String-Abgleich mit einer [Richtlinienvariablen](reference_policies_variables.md) durchzuführen, um eine Richtlinie zu erstellen, die es einem IAM-Benutzer ermöglicht, die Amazon S3-Konsole zu verwenden, um sein eigenes "Heimatverzeichnis" in einem Amazon S3-Bucket zu verwalten. Die Richtlinie lässt die angegebenen Aktionen für ein S3-Bucket zu, solange `s3:prefix` einem angegebenen Muster entspricht.
****
```
{
"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}/*"
]
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie für verschiedene Benutzer auf der Grundlage des [aws:username](reference_policies_condition-keys.md#condition-keys-username) Werts im Anforderungskontext AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "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}/"
]
} | Kein `aws:username` im Anforderungskontext. | Keine Übereinstimmung |
Ein Beispiel für eine Richtlinie zur Verwendung des `Condition`-Elements, um den Zugriff auf Ressourcen basierend auf einer Anwendungs-ID und einer Benutzer-ID zum OIDC-Verbund einzuschränken, finden Sie unter [Amazon S3: Ermöglicht Amazon Cognito-Benutzern den Zugriff auf Objekte in ihrem Bucket](reference_policies_examples_s3_cognito-bucket.md).
### Mehrwertige Bedingungsoperatoren für Zeichenfolgen
Wenn ein Schlüssel in der Anforderung mehrere Werte enthält, können Zeichenfolgenoperatoren mit den Set-Operatoren `ForAllValues` und `ForAnyValue` qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Bedingungsoperator | Description |
| --- | --- |
| `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase` | Alle Werte für den Bedingungsschlüssel in der Anforderung müssen mit mindestens einem der Werte in Ihrer Richtlinie übereinstimmen. |
| `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase` | Mindestens ein Bedingungsschlüsselwert in der Anforderung muss mit einem der Werte in Ihrer Richtlinie übereinstimmen. |
| `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase` | Negierte Übereinstimmung. Keiner der Werte des Kontextschlüssels in der Anforderung stimmt mit einem der Kontextschlüsselwerte in Ihrer Richtlinie überein. |
| `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase` | Negierte Übereinstimmung. Mindestens ein Kontextschlüsselwert in der Anforderung darf mit KEINEM der Werte im Kontextschlüssel Ihrer Richtlinie übereinstimmen. |
| `ForAllValues:StringLike` | Alle Werte für den Bedingungsschlüssel in der Anforderung müssen mit mindestens einem der Werte in Ihrer Richtlinie übereinstimmen. |
| `ForAnyValue:StringLike` | Mindestens ein Bedingungsschlüsselwert in der Anforderung muss mit einem der Werte in Ihrer Richtlinie übereinstimmen. |
| `ForAllValues:StringNotLike` | Negierte Übereinstimmung. Keiner der Werte des Kontextschlüssels in der Anforderung stimmt mit einem der Kontextschlüsselwerte in Ihrer Richtlinie überein. |
| `ForAnyValue:StringNotLike` | Negierte Übereinstimmung. Mindestens ein Kontextschlüsselwert in der Anforderung darf mit KEINEM der Werte im Kontextschlüssel Ihrer Richtlinie übereinstimmen. |
**Example Verwenden von `ForAnyValue` mit einem Bedingungsoperator für eine Zeichenfolge**
Dieses Beispiel zeigt, wie Sie eine identitätsbasierte Richtlinie erstellen können, die es erlaubt, mithilfe der Amazon-EC2-Aktion `CreateTags` Tags an eine Instance anzuhängen. Wenn Sie `StringEqualsIgnoreCase` verwenden, können Sie Tags nur anhängen, wenn das Tag den `environment`-Schlüssel mit dem Wert `preprod` oder `storage` enthält. Wenn Sie `IgnoreCase` an den Operator anhängen, erlauben Sie, dass alle vorhandenen Tag-Werte, die großgeschrieben sind, wie `preprod`, `Preprod` und `PreProd`, als „true“ aufgelöst werden.
Wenn Sie den Modifikator `ForAnyValue` mit dem Bedingungsschlüssel [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) hinzufügen, muss mindestens ein Tag-Schlüsselwert in der Anfrage mit dem Wert `environment` übereinstimmen. Bei der `ForAnyValue`-Vergleichsfunktion wird zwischen Groß- und Kleinschreibung unterschieden, wodurch verhindert wird, dass Benutzer eine falsche Groß-/Kleinschreibung für den Tag-Schlüssel verwenden, z. B. `Environment` statt `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"
}
}
}
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
aws:RequestTag/environment:
– preprod
| Match |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
– costcenter
aws:RequestTag/environment:
– PreProd
| Match |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– Environment
aws:RequestTag/Environment:
– preprod
| Keine Übereinstimmung |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– costcenter
aws:RequestTag/environment:
– preprod
| Keine Übereinstimmung |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Kein `aws:TagKeys` im Anfragekontext. aws:RequestTag/environment:
– storage
| Keine Übereinstimmung |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
Kein `aws:RequestTag/environment` im Anfragekontext. | Keine Übereinstimmung |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Kein `aws:TagKeys` im Anfragekontext. Kein `aws:RequestTag/environment` im Anfragekontext. | Keine Übereinstimmung |
### Platzhalterabgleich
Operatoren für Zeichenfolgenbedingungen führen einen musterlosen Abgleich durch, der kein vordefiniertes Format erzwingt. Die Bedingungsoperatoren ARN und Datum sind eine Teilmenge von Zeichenfolgenoperatoren, die eine Struktur für den Bedingungsschlüsselwert erzwingen.
Wir empfehlen Ihnen, Bedingungsoperatoren zu verwenden, die den Werten entsprechen, mit denen Sie die Schlüssel vergleichen. Beispielsweise sollten Sie beim Vergleichen von Schlüsseln mit Zeichenfolgenwerten [Bedingungsoperatoren für Zeichenfolgen](#Conditions_String) verwenden. Ebenso sollten Sie [Bedingungsoperatoren für Amazon-Ressourcennamen (ARN)](#Conditions_ARN) verwenden, wenn Sie Schlüssel mit ARN-Werten vergleichen.
**Example**
Dieses Beispiel zeigt, wie Sie eine Grenze um Ressourcen in Ihrer Organisation erstellen können. Die Bedingung in dieser Richtlinie verweigert den Zugriff auf Amazon S3 S3-Aktionen, es sei denn, die Ressource, auf die zugegriffen wird, befindet sich in einer bestimmten Gruppe von Organisationseinheiten (OUs) in AWS Organizations. Ein AWS Organizations -Pfad ist eine textuelle Darstellung der Struktur einer Organisationseinheit.
Die Bedingung setzt voraus, dass `aws:ResourceOrgPaths` einen der aufgelisteten OU-Pfade enthält. Da `aws:ResourceOrgPaths` es sich um eine Bedingung mit mehreren Werten handelt, verwendet die Richtlinie den `ForAllValues:StringNotLike` Operator, um die Werte von mit der Liste OUs in der Richtlinie `aws:ResourceOrgPaths` zu vergleichen.
****
```
{
"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/*"
]
}
}
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "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/
| Match |
| "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/
| Keine Übereinstimmung |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | Kein `aws:ResourceOrgPaths:` in der Anforderung. | Keine Übereinstimmung |
## Numerische Bedingungsoperatoren
Mit numerischen Bedingungsoperatoren können Sie `Condition`-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem Ganzzahl- oder Dezimalzahlwert einschränken.
+ **Richtlinienvariablen**: nicht unterstützt
+ **Platzhalter**: nicht unterstützt
****
| Bedingungsoperator | Description |
| --- | --- |
| `NumericEquals` | Übereinstimmung |
| `NumericNotEquals` | Negierte Übereinstimmung |
| `NumericLessThan` | Übereinstimmung "Kleiner als" |
| `NumericLessThanEquals` | Übereinstimmung "Kleiner als oder gleich" |
| `NumericGreaterThan` | Übereinstimmung "Größer als" |
| `NumericGreaterThanEquals` | Übereinstimmung "Größer als oder gleich" |
Die folgende Anweisung enthält beispielsweise ein `Condition`-Element, das den Bedingungsoperator `NumericLessThanEquals` mit dem Schlüssel `s3:max-keys` enthält, um anzugeben, dass der Anforderer *bis zu* 10 Objekte gleichzeitig im `amzn-s3-demo-bucket` aufnehmen kann.
------
#### [ 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"}}
}
}
```
------
Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. In diesem Beispiel ist der `s3:max-keys`-Schlüssel immer in der Anforderung vorhanden, wenn Sie die Operation `ListBucket` ausführen. Wenn diese Richtlinie alle Amazon S3-Operationen zulässt, sind nur die Operationen zulässig, die den `max-keys`-Kontextschlüssel mit einem Wert von kleiner oder gleich 10 enthalten.
## Bedingungsoperatoren für Datum
Mit Operatoren für Datumsbedingungen können Sie `Condition` Elemente erstellen, die den Zugriff einschränken, indem Sie einen Schlüssel mit einem date/time Wert vergleichen. Diese Bedingungsoperatoren werden mit dem Schlüssel [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) oder [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) verwendet. Sie müssen date/time Werte mit einer der [W3C-Implementierungen der ISO-8601-Datumsformate](http://www.w3.org/TR/NOTE-datetime) oder in Epochenzeit (UNIX) angeben.
+ **Richtlinienvariablen**: nicht unterstützt
+ **Platzhalter**: nicht unterstützt
****
| Bedingungsoperator | Description |
| --- | --- |
| `DateEquals` | Übereinstimmung mit einem bestimmten Datum |
| `DateNotEquals` | Negierte Übereinstimmung |
| `DateLessThan` | Übereinstimmung vor einem bestimmten Datum und einer bestimmten Uhrzeit |
| `DateLessThanEquals` | Übereinstimmung an oder vor einem bestimmten Datum und oder einer bestimmten Uhrzeit |
| `DateGreaterThan` | Übereinstimmung nach einem bestimmten Datum und einer bestimmten Uhrzeit |
| `DateGreaterThanEquals` | Übereinstimmung an oder nach einem bestimmten Datum und einer bestimmten Uhrzeit |
Beispielsweise enthält die folgende Anweisung ein `Condition`-Element, das den Bedingungsoperator `DateGreaterThan` mit dem [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)-Schlüssel verwendet. Diese Bedingung gibt an, dass die temporären Sicherheitsanmeldeinformationen, die für die Anforderung verwendet wurden, im Jahr 2020 ausgegeben wurden. Diese Richtlinie kann täglich programmgesteuert aktualisiert werden, um sicherzustellen, dass Kontomitglieder neue Anmeldeinformationen verwenden.
------
#### [ 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"
}
}
}
}
```
------
Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. Der `aws:TokenIssueTime`-Schlüssel ist im Anforderungskontext nur dann vorhanden, wenn der Auftraggeber temporäre Anmeldeinformationen für die Anforderung verwendet. Der Schlüssel ist nicht in AWS CLI AWS API- oder AWS SDK-Anfragen enthalten, die mit Zugriffsschlüsseln gestellt werden. Wenn in diesem Beispiel ein IAM-Benutzer versucht, einen Zugriffsschlüssel anzuzeigen oder zu bearbeiten, wird die Anforderung verweigert.
## Boolesche Bedingungsoperatoren
Mit booleschen Bedingungsoperatoren können Sie `Condition`-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit `true` oder `false` einschränken.
Wenn ein Schlüssel mehrere Werte enthält, können boolesche Operatoren mit den Set-Operatoren `ForAllValues` und `ForAnyValue` qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ **Richtlinienvariablen**: [unterstützt](reference_policies_variables.md)
+ **Platzhalter**: nicht unterstützt
****
| Bedingungsoperator | Description |
| --- | --- |
| `Bool` | Boolesche Übereinstimmung |
| `ForAllValues:Bool` | Verwendung mit dem Datentyp „Array of Bool“. Alle Booleschen Werte in den Kontextschlüsselwerten müssen mit den Booleschen Werten in Ihrer Richtlinie übereinstimmen. Um zu verhindern, dass `ForAllValues`-Operatoren fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „Zulässig“ auswerten, können Sie den [Null-Bedingungsoperator](#Conditions_Null) in Ihre Richtlinie aufnehmen. |
| `ForAnyValue:Bool` | Verwendung mit dem Datentyp „Array of Bool“. Mindestens einer der Booleschen Werte in den Kontextschlüsselwerten müssen mit den Booleschen Werten in Ihrer Richtlinie übereinstimmen. |
**Example Boolescher Bedingungsoperator**
Die folgende identitätsbasierte Richtlinie verwendet den `Bool`-Bedingungsoperator mit dem [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)-Schlüssel, um die Replikation von Objekten und Objekt-Tags in den Ziel-Bucket und dessen Inhalt zu verweigern, wenn die Anforderung nicht über SSL erfolgt.
Diese Richtlinie lässt keine Aktionen zu. Verwenden Sie diese Richtlinie in Kombination mit anderen Richtlinien, die bestimmte Aktionen zulassen.
****
```
{
"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"
}
}
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– false
| Match |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– true
| Keine Übereinstimmung |
| "Bool": {
"aws:SecureTransport": "false"
} | Kein `aws:SecureTransport` im Anfragekontext. | Keine Übereinstimmung |
## Binäre Bedingungsoperatoren
Mit dem Bedingungsoperator `BinaryEquals` können Sie `Condition`-Elemente zum Prüfen von binären Schlüsselwerten erstellen. Er vergleicht den Wert des angegebenen Schlüssel Byte für Byte mit einer [base-64](https://en.wikipedia.org/wiki/Base64)-kodierten Darstellung des Binärwertes in der Richtlinie. Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein.
+ **Richtlinienvariablen**: nicht unterstützt
+ **Platzhalter**: nicht unterstützt
```
"Condition" : {
"BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
}
```
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– QmluYXJ5VmFsdWVJbkJhc2U2NA==
| Match |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– ASIAIOSFODNN7EXAMPLE
| Keine Übereinstimmung |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | Kein `key` im Anfragekontext. | Keine Übereinstimmung |
## Bedingungsoperatoren für IP-Adressen
Mit Operatoren für IP-Adressbedingungen können Sie `Condition` Elemente erstellen, die den Zugriff einschränken, indem Sie einen Schlüssel mit einer IPv4 oder einer IPv6 Adresse oder einem Bereich von IP-Adressen vergleichen. Verwenden Sie sie mit dem Schlüssel [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). Der Wert muss im CIDR-Standardformat vorliegen (z. B. 203.0.113.0/24 oder 2001:: 1234:5678: :/64). DB8 Wenn Sie eine IP-Adresse ohne das zugehörige Routing-Präfix zuweisen, verwendet IAM den Standard-Präfixwert `/32`.
Einige Dienste unterstützen die Verwendung von:: zur Darstellung eines Bereichs von Nullen. AWS IPv6 Informationen darüber, ob ein Dienst dies unterstützt IPv6, finden Sie in der Dokumentation zu diesem Dienst.
+ **Richtlinienvariablen**: nicht unterstützt
+ **Platzhalter**: nicht unterstützt
****
| Bedingungsoperator | Description |
| --- | --- |
| `IpAddress` | Die angegebene IP-Adresse oder der angegebene IP-Bereich |
| `NotIpAddress` | Alle IP-Adressen mit Ausnahme der angegebenen IP-Adresse oder des angegebenen IP-Bereichs. |
**Example Bedingungsoperator für IP-Adressen**
In der folgenden Anweisung wird der Bedingungsoperator `IpAddress` mit dem Schlüssel `aws:SourceIp` verwendet, um anzugeben, dass die Anforderung von einer IP-Adresse zwischen 203.0.113.0 und 203.0.113.255 kommen muss.
****
```
{
"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"
}
}
}
}
```
Der Bedingungsschlüssel `aws:SourceIp` wird auf die IP-Adresse aufgelöst, von der die Anforderung kommt. Wenn die Anforderungen aus einer Amazon EC2-Instance kommen, gibt `aws:SourceIp` die öffentliche IP-Adresse der Instance zurück.
Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. Der `aws:SourceIp`-Schlüssel ist immer im Anforderungskontext vorhanden, außer wenn der Anforderer einen VPC-Endpunkt für die Anforderung verwendet. In diesem Fall gibt die Bedingung `false` zurück und die Anforderung wird durch diese Anweisung implizit abgelehnt.
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 203.0.113.1
| Match |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 198.51.100.1
| Keine Übereinstimmung |
Das folgende Beispiel zeigt, wie Sie IPv6 Adressen kombinieren IPv4 können, um alle gültigen IP-Adressen Ihrer Organisation abzudecken. Wir empfehlen Ihnen, die Richtlinien Ihrer Organisation mit Ihren IPv6 Adressbereichen zu aktualisieren, zusätzlich zu den IPv4 Bereichen, die Sie bereits haben, um sicherzustellen, dass die Richtlinien auch bei der Umstellung weiterhin funktionieren 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"
]
}
}
}
}
```
Der Bedingungsschlüssel `aws:SourceIp` funktioniert in einer JSON-Richtlinie nur, wenn Sie die geprüfte API direkt als Benutzer aufrufen. Wenn Sie stattdessen einen Service verwenden, um den Zielservice in Ihrem Namen aufzurufen, erkennt der Zielservice die IP-Adresse des aufrufenden Services und nicht die IP-Adresse des verursachenden Benutzers. Das kann passieren, wenn Sie beispielsweise AWS CloudFormation zum Aufrufen von Amazon EC2 aufrufen, um in Ihrem Namen Instances zu erstellen. Derzeit gibt es keine Möglichkeit, die ursprüngliche IP-Adresse über einen Aufrufservice an den Zielservice zur Bewertung in einer JSON-Richtlinie zu übermitteln. Verwenden Sie für diese Art von Service-API-Aufrufen nicht den Bedingungsschlüssel `aws:SourceIp`.
## Bedingungsoperatoren für Amazon-Ressourcennamen (ARN)
Mit den Bedingungsoperatoren für Amazon-Ressourcennamen (ARN) können Sie `Condition`-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem ARN einschränken. Der ARN wird als Zeichenfolge interpretiert.
+ **Richtlinienvariablen**: [unterstützt](reference_policies_variables.md)
+ **Platzhalter**: [unterstützt](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)
****
| Bedingungsoperator | Description |
| --- | --- |
| `ArnEquals`, `ArnLike` | Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung des ARN Jede der sechs durch Doppelpunkt getrennten Komponenten der ARN wird separat überprüft und alle Komponenten können Mehrzeichen-Übereinstimmungs-Platzhalter (\$1) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) enthalten. Die `ArnEquals`- und `ArnLike`-Bedingungsoperatoren verhalten sich identisch. |
| `ArnNotEquals`, `ArnNotLike` | Negierte Übereinstimmung von ARN Die`ArnNotEquals`- und`ArnNotLike`-Bedingungsoperatoren verhalten sich identisch. |
**Example ARN-Bedingungsoperator**
Das folgende ressourcenbasierte Richtlinienbeispiel zeigt eine Richtlinie, die einer Amazon SQS-Warteschlange zugeordnet ist, an die Sie SNS-Nachrichten senden möchten. Es gibt Amazon SNS die Erlaubnis, Nachrichten an die Warteschlange (oder Warteschlangen) Ihrer Wahl zu senden, aber nur, wenn der Service die Nachrichten im Namen eines bestimmten Amazon SNS-Themas (oder Themen) sendet. Geben Sie die Warteschlange im Feld `Resource` und das Amazon SNS-Thema als Wert für den Schlüssel `SourceArn` an.
****
```
{
"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"
}
}
}
}
```
Der [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)-Schlüssel ist im Anforderungskontext nur dann vorhanden, wenn eine Ressource einen Service auslöst, um einen anderen Service im Namen des Ressourcenbesitzers aufzurufen. Wenn ein IAM-Benutzer versucht, diesen Vorgang direkt auszuführen, kehrt die Bedingung `false` zurück und die Anforderung wird implizit durch diese Anweisung abgelehnt.
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:123456789012:TOPIC-ID
| Match |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:777788889999:TOPIC-ID
| Keine Übereinstimmung |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | Kein `aws:SourceArn` im Anfragekontext. | Keine Übereinstimmung |
### Mehrwertige ARN-Bedingungsoperatoren
Wenn ein Schlüssel in der Anforderung mehrere Werte enthält, können ARN-Operatoren mit den Set-Operatoren `ForAllValues` und `ForAnyValue` qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter [Operatoren für mehrwertige Kontextschlüssel festlegen](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Bedingungsoperator | Description |
| --- | --- |
| `ForAllValues:ArnEquals` `ForAllValues:ArnLike` | Alle ARNs im Anforderungskontext müssen mit mindestens einem der ARN-Muster in Ihrer Richtlinie übereinstimmen. |
| `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike` | Mindestens ein ARN im Anforderungskontext muss mit einem der ARN-Muster in Ihrer Richtlinie übereinstimmen. |
| `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike` | Negierte Übereinstimmung. Keines der ARNs im Anforderungskontext enthaltenen ARN-Muster kann mit Zeichenketten-ARN-Mustern in Ihrer Richtlinie übereinstimmen. |
| `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike` | Negierte Übereinstimmung. Mindestens ein ARN im Anforderungskontext darf NICHT mit einem der ARN-Muster in Ihrer Richtlinie übereinstimmen. |
**Example Verwenden von `ForAllValues` mit einem ARN-Bedingungsoperator**
Das folgende Beispiel dient `ForAllValues:ArnLike` dazu, eine logische Zustellungsquelle für Amazon CloudWatch Logs-Protokolle zu erstellen oder zu aktualisieren. Der Bedingungsblock enthält den Bedingungsschlüssel [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)zum Filtern der in der Anfrage ARNs übergebenen Ressource zur Protokollgenerierung. Bei Verwendung dieses Bedingungsoperators müssen alle ARNs in der Anfrage enthaltenen Informationen mit mindestens einem ARN in der Richtlinie übereinstimmen.
****
```
{
"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*"
]
}
}
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
| Match |
| "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
| Match |
| "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
| Keine Übereinstimmung |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:777788889999:distribution/costcenter
| Keine Übereinstimmung |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | Kein `logs:LogGeneratingResourceArns` im Anforderungskontext. | Match |
Der Qualifizierer `ForAllValues` gibt „true“ zurück, wenn die Anforderung keine Kontextschlüssel enthält oder wenn der Wert des Kontextschlüssels zu einem Null-Datensatz aufgelöst wird, z. B. einer leeren Zeichenfolge. Um zu verhindern, dass fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „true“ ausgewertet werden, können Sie den [Null-Bedingungsoperator](#Conditions_Null) mit einem `false`-Wert in Ihre Richtlinie aufnehmen, um zu überprüfen, ob der Kontextschlüssel vorhanden ist und sein Wert nicht null ist.
## ... IfExists Bedingungsoperatoren
Sie können `IfExists` an das Ende jedes Bedingungsoperatornamens hinzufügen, abgesehen von der `Null`-Bedingung wie z. B. `StringLikeIfExists`. Damit geben Sie zum Ausdruck: „Wenn der Bedingungsschlüssel im Kontext der Anfrage vorhanden ist, verarbeiten Sie den Schlüssel wie in der Richtlinie angegeben.“ Wenn der Schlüssel nicht vorhanden ist, wird das Bedingungselement als "true" ausgewertet. Andere Bedingungselemente in der Anweisung können weiterhin zu einer Nichtübereinstimmung führen, nicht jedoch ein fehlender Schlüssel bei einer Prüfung mit `...IfExists`. Wenn Sie ein `"Effect": "Deny"`-Element mit einem negierten Bedingungsoperator wie `StringNotEqualsIfExists` verwenden, wird die Anfrage dennoch abgelehnt, auch wenn der Bedingungsschlüssel nicht vorhanden ist.
**Beispiel mit `IfExists`**
Viele Bedingungsschlüssel beschreiben einen bestimmten Ressourcentyp und existieren nur beim Zugriff auf diesen Ressourcentyp. Diese Bedingungsschlüssel sind bei anderen Ressourcentypen nicht vorhanden. Dies stellt kein Problem dar, wenn die Richtlinienanweisung nur für einen Ressourcentyp gültig ist. Es gibt jedoch Fälle, bei denen eine einzelne Anweisung auf mehrere Ressourcentypen zutrifft, wenn beispielsweise die Richtlinienanweisung auf Aktionen aus mehreren Services Bezug nimmt oder wenn eine bestimmte Aktion innerhalb eines Services auf mehrere verschiedene Ressourcentypen in demselben Service zugreift. In solchen Fällen kann ein nur für eine Ressource gültiger Bedingungsschlüssel in einer Richtlinienanweisung dazu führen, dass das Element `Condition` in der Richtlinienanweisung fehlschlägt, sodass der `"Effect"` der Anweisung nicht angewendet wird.
Betrachten Sie beispielsweise das folgende einfache Richtlinienbeispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "THISPOLICYDOESNOTWORK",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {"StringLike": {"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]}}
}
}
```
------
Der *Zweck* der vorangegangenen Richtlinie besteht darin, den Benutzer zum Starten einer beliebigen Instance vom Typ `t1`, `t2` oder `m3` zu befähigen. Zum Starten einer Instance ist jedoch auch der Zugriff auf viele Ressourcen zusätzlich zu der Instance selbst erforderlich, wie z. B. Images, Schlüsselpaare, Sicherheitsgruppen usw. Die gesamte Anweisung wird gegen alle Ressourcen geprüft, die zum Starten der Instance erforderlich sind. Diese zusätzlichen Ressourcen verfügen nicht über den Bedingungsschlüssel `ec2:InstanceType`, sodass die Prüfung `StringLike` fehlschlägt und der Benutzer nicht zum Starten eines *beliebigen* Instance-Typs befähigt wird.
Um dieses Problem zu beheben, verwenden Sie stattdessen den Bedingungsoperator `StringLikeIfExists`. Auf diese Weise findet die Prüfung nur dann statt, wenn der Bedingungsschlüssel existiert. Sie können nachstehende Richtlinie folgendermaßen interpretieren: „Wenn die zu prüfende Ressource den Bedingungsschlüssel „`ec2:InstanceType`„ enthält, wird die Aktion nur zugelassen, wenn der Schlüsselwert mit `t1.`, `t2.` oder `m3.` beginnt.“ Wenn die zu prüfende Ressource nicht über diesen Bedingungsschlüssel verfügt, ist dies belanglos." Das Sternchen (\$1) in den Bedingungsschlüsselwerten wird, wenn es mit dem `StringLikeIfExists`-Bedingungsoperator verwendet wird, als Platzhalter interpretiert, um teilweise übereinstimmende Zeichenfolgen zu erzielen. Die Anweisung `DescribeActions` enthält die Aktionen, die erforderlich sind, um die Instance in der Konsole anzeigen.
------
#### [ 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": "*"
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– t1.micro
| Match |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– m2.micro
| Keine Übereinstimmung |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | Kein `ec2:InstanceType` im Anforderungskontext. | Match |
## Bedingungsoperator zur Prüfung der Existenz von Bedingungsoperatoren
Verwenden Sie einen Bedingungsoperator `Null`, um zu prüfen, ob ein Bedingungsschlüssel zum Zeitpunkt der Autorisierung abwesend ist. Verwenden Sie in der Richtlinienanweisung entweder `true` (der Schlüssel ist nicht vorhanden – der Wert beträgt null) oder `false` (der Schlüssel ist vorhanden und sein Wert ist ungleich null).
Sie können eine [Richtlinienvariable](reference_policies_variables.md) mit dem `Null`Bedingungsoperator verwenden.
Beispielsweise können Sie diesen Bedingungsoperator verwenden, um festzustellen, ob ein Benutzer temporäre Anmeldeinformationen oder seine eigenen verwendet, um eine Anforderung zu stellen. Wenn der Benutzer temporäre Anmeldeinformationen benutzt, ist der Schlüssel `aws:TokenIssueTime` vorhanden und hat einen Wert. Das folgende Beispiel zeigt eine Bedingung, die besagt, dass der Benutzer temporäre Anmeldeinformationen verwenden muss (der Schlüssel darf nicht fehlen), damit er die Amazon-EC2-API verwenden kann.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":{
"Action":"ec2:*",
"Effect":"Allow",
"Resource":"*",
"Condition":{"Null":{"aws:TokenIssueTime":"false"}}
}
}
```
------
# Bedingungen mit mehreren Kontextschlüsseln oder -werten
Sie können das `Condition`-Element einer Richtlinie verwenden, um mehrere Kontextschlüssel oder mehrere Werte für einen einzelnen Kontextschlüssel in einer Anfrage zu testen. Wenn Sie eine Anfrage an stellen AWS, entweder programmgesteuert oder über die AWS-Managementkonsole, enthält Ihre Anfrage Informationen über Ihren Principal, Ihren Betrieb, Ihre Tags und mehr. Mithilfe von Kontextschlüsseln können Sie die Werte der übereinstimmenden Kontextschlüssel in der Anfrage anhand der in der Richtlinienbedingung angegebenen Kontextschlüssel testen. Weitere Informationen zu den in einer Anforderung enthaltenen Informationen und Daten finden Sie unter [Der Anforderungskontext](reference_policies_elements_condition.md#AccessPolicyLanguage_RequestContext).
**Topics**
+ [
## Auswertungslogik für mehrere Kontextschlüssel oder -werte
](#reference_policies_multiple-conditions-eval)
+ [
## Auswertungslogik für negierte übereinstimmende Bedingungsoperatoren
](#reference_policies_multiple-conditions-negated-matching-eval)
## Auswertungslogik für mehrere Kontextschlüssel oder -werte
Ein `Condition`-Element kann mehrere Bedingungsoperatoren enthalten, und jeder Bedingungsoperator kann mehrere Kontext-Schlüssel-Wert-Paare enthalten. Die meisten Kontextschlüssel unterstützen die Verwendung mehrerer Werte, sofern nicht anders angegeben.
+ Wenn Ihre Richtlinienanweisung mehrere [Bedingungsoperatoren](reference_policies_elements_condition_operators.md) enthält, werden die Bedingungsoperatoren anhand eines logischen `AND` ausgewertet.
+ Wenn Ihre Richtlinienanweisung mehrere Bedingungsoperatoren enthält oder einem Bedingungsoperator mehrere Schlüssel angefügt sind, werden die Bedingungen anhand eines logischen `AND` ausgewertet.
+ Wenn ein einzelner Bedingungsoperator mehrere Werte für einen Kontextschlüssel enthält, werden diese Werte anhand eines logischen `OR` ausgewertet.
+ Wenn ein einzelner negierter übereinstimmender Bedingungsoperator mehrere Werte für einen Kontextschlüssel enthält, werden diese Werte anhand eines logischen `NOR` ausgewertet.
Alle Kontextschlüssel in einem Bedingungselementblock müssen zu „wahr“ aufgelöst werden, um den gewünschten `Allow`- oder `Deny`-Effekt aufzurufen. Das folgende Image veranschaulicht die Auswertungslogik für eine Bedingung mit mehreren Bedingungsoperatoren und Kontextschlüssel-Wert-Paaren.
![\[Bedingungsblock zur Erläuterung der Verwendung von AND und OR mit mehreren Kontextschlüsseln und -werten\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_2.diagram.png)
Die folgende S3-Bucket-Richtlinie veranschaulicht beispielsweise, wie das vorherige Image in einer Richtlinie dargestellt wird. Der Bedingungsblock enthält die Bedingungsoperatoren `StringEquals` und `ArnLike` sowie die Kontextschlüssel `aws:PrincipalTag` und `aws:PrincipalArn`. Um den gewünschten `Allow`- oder `Deny`-Effekt aufzurufen, müssen alle Kontextschlüssel im Bedingungsblock zu „wahr“ aufgelöst werden. Der Benutzer, der die Anforderung stellt, muss beide Prinzipal-Tag-Schlüssel haben, *Abteilung* und *Rolle*, die einen der in der Richtlinie angegebenen Tag-Schlüsselwerte enthalten. Außerdem muss der Prinzipal-ARN, der die Anfrage stellt, mit einem der in der Richtlinie angegebenen `aws:PrincipalArn`-Werte übereinstimmen, damit er als wahr ausgewertet werden kann.
------
#### [ 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"
]
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "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
| **Abgleich** |
| "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
| **Kein Spiel** |
| "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
| **Kein Spiel** |
| "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"
]
} | Kein `aws:PrincipalTag/role` im Anfragekontext. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Kein Spiel** |
| "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"
]
} | Kein `aws:PrincipalTag` im Anfragekontext. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Kein Spiel** |
## Auswertungslogik für negierte übereinstimmende Bedingungsoperatoren
Einige [Bedingungsoperatoren](reference_policies_elements_condition_operators.md) wie `StringNotEquals` oder `ArnNotLike` verwenden negierte Übereinstimmung, um die Kontext-Schlüssel-Wert-Paare in Ihrer Richtlinie mit den Kontext-Schlüssel-Wert-Paaren in einer Anfrage zu vergleichen. Wenn in einer Richtlinie mit negierten übereinstimmenden Bedingungsoperatoren mehrere Werte für einen einzelnen Kontextschlüssel angegeben werden, funktionieren die effektiven Berechtigungen wie ein logisches `NOR`. Bei der negierten Übereinstimmung gibt ein logisches `NOR` oder `NOT OR` nur dann wahr zurück, wenn alle Werte als falsch ausgewertet werden.
Das folgende Image veranschaulicht die Auswertungslogik für eine Bedingung mit mehreren Bedingungsoperatoren und Kontextschlüssel-Wert-Paaren. Das Image enthält einen negierten übereinstimmenden Bedingungsoperator für Bedingungsschlüssel 3.
![\[Bedingungsblock zur Erläuterung der Verwendung von AND und OR mit mehreren Kontextschlüsseln und -werten bei Anwendung eines negierten übereinstimmenden Bedingungsoperators\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_Negated_NOR_2.diagram.png)
Die folgende S3-Bucket-Richtlinie veranschaulicht beispielsweise, wie das vorherige Image in einer Richtlinie dargestellt wird. Der Bedingungsblock enthält die Bedingungsoperatoren `StringEquals` und `ArnNotLike` sowie die Kontextschlüssel `aws:PrincipalTag` und `aws:PrincipalArn`. Um den gewünschten `Allow`- oder `Deny`-Effekt aufzurufen, müssen alle Kontextschlüssel im Bedingungsblock zu „wahr“ aufgelöst werden. Der Benutzer, der die Anforderung stellt, muss beide Prinzipal-Tag-Schlüssel haben, *Abteilung* und *Rolle*, die einen der in der Richtlinie angegebenen Tag-Schlüsselwerte enthalten. Da der `ArnNotLike`-Bedingungsoperator eine negierte Übereinstimmung verwendet, darf der Prinzipal-ARN des Benutzers, der die Anfrage stellt, mit keinem der in der Richtlinie angegebenen `aws:PrincipalArn`-Werte übereinstimmen, um als wahr ausgewertet zu werden.
------
#### [ 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"
]
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "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
| **Abgleich** |
| "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
| **Kein Spiel** |
| "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
| **Kein Spiel** |
| "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"
]
} | >Kein `aws:PrincipalTag/role` im Anfragekontext. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Kein Spiel** |
| "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"
]
} | Kein `aws:PrincipalTag` im Anfragekontext. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Kein Spiel** |
# Einwertige im Vergleich zu mehrwertige Kontextschlüssel
Der Unterschied zwischen einwertigen und mehrwertigen Kontextschlüsseln liegt in der Anzahl der Werte im [Anfragekontext](intro-structure.md#intro-structure-request), nicht in der Anzahl der Werte in der Richtlinienbedingung.
+ *Einwertige* Bedingungskontextschlüssel haben höchstens einen Wert im Anforderungskontext. Wenn Sie beispielsweise Ressourcen taggen AWS, wird jedes Ressourcen-Tag als Schlüssel-Wert-Paar gespeichert. Da ein Ressourcen-Tagschlüssel nur einen einzigen Tagwert haben kann, ist [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) ein einwertiger Kontextschlüssel. Verwenden Sie keinen Bedingungssatzoperator mit einem einwertigen Kontextschlüssel.
+ *Mehrwertige* Bedingungskontextschlüssel können im Anforderungskontext mehrere Werte enthalten. Wenn Sie beispielsweise Ressourcen taggen, können Sie mehrere Tag-Schlüssel-Wert-Paare in eine einzige Anfrage aufnehmen. AWS Daher handelt es sich bei [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) um einen mehrwertigen Kontextschlüssel. Mehrwertige Kontextschlüssel erfordern einen Bedingungssatz-Operator.
Beispielsweise kann eine Anfrage von höchstens einem VPC-Endpunkt stammen, weshalb es sich bei [aws:SourceVpce](reference_policies_condition-keys.md#condition-keys-sourcevpce) um einen einwertigen Kontextschlüssel handelt. Da ein Service über mehr als einen Prinzipal verfügen kann, der zum Service gehört, handelt es sich bei [aws:PrincipalServiceNamesList](reference_policies_condition-keys.md#condition-keys-principalservicenameslist) um einen mehrwertigen Kontextschlüssel.
**Wichtig**
Der Unterschied zwischen einwertigen und mehrwertigen Kontextschlüsseln hängt von der Anzahl der Werte im Anforderungskontext ab, nicht von der Anzahl der Werte in der Richtlinienbedingung.
## Wichtige Punkte
+ Die *einwertigen* und *mehrwertigen* Klassifizierungen sind in der Beschreibung jedes Bedingungskontextschlüssels als *Werttyp* im [AWS Kontextschlüssel für globale Bedingungen](reference_policies_condition-keys.md)-Thema enthalten.
+ Mehrwertige Kontextschlüssel in der [Service Authorization-Referenz](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) verwenden das Präfix „`ArrayOf`“, gefolgt vom Typ des Bedingungsoperators (z. B. „`ArrayOfString`“ oder „`ArrayOfARN`“). Dies gibt an, dass die Anfrage mehrere Werte für einen Bedingungskontextschlüssel enthalten kann.
+ Sie können jeden verfügbaren einwertigen Kontextschlüssel als Richtlinienvariable verwenden, aber Sie können keinen mehrwertigen Kontextschlüssel als Richtlinienvariable verwenden. Weitere Informationen zu Richtlinienvariablen finden Sie unter [IAM-Richtlinienelemente: Variablen und Tags](reference_policies_variables.md).
+ Bei der Verwendung von Kontextschlüsseln, die Schlüssel-Wert-Paare enthalten, ist es wichtig zu beachten, dass es zwar mehrere Tag-Schlüssel-Werte geben kann, jeder `tag-key` jedoch nur einen Wert haben kann.
+ „[aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag)“, „[aws:RequestTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-requesttag)“ und „[aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag)“ sind einwertige Kontextschlüssel.
+ „[aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys)“ definiert, welche Tag-Schlüssel in einer Anfrage zulässig sind, jedoch nicht deren Werte. Da Sie mehrere Tag-Schlüssel-Wert-Paare in eine Anfrage einfügen können, ist „`aws:TagKeys`“ ein mehrwertiger Kontextschlüssel.
+ Mehrwertige Kontextschlüssel erfordern einen Bedingungssatz-Operator. Verwenden Sie die Bedingungssatz-Operatoren `ForAllValues` oder `ForAnyValue` nicht mit einwertigen Kontextschlüsseln. Die Verwendung von Bedingungssatzoperatoren mit einwertigen Kontextschlüsseln kann zu übermäßig zulässigen Richtlinien führen.
## Operatoren für mehrwertige Kontextschlüssel festlegen
Um Ihren Bedingungskontextschlüssel mit einem [Anforderungskontext](intro-structure.md#intro-structure-request)-Schlüssel mit mehreren Werten zu vergleichen, müssen Sie die Satzoperatoren `ForAllValues` oder `ForAnyValue` verwenden. Diese Satzoperatoren werden verwendet, um zwei Sätze von Werten zu vergleichen, z. B. den Satz von Tags in einer Anfrage und den Satz von Tags in einer Richtlinienbedingung.
Die `ForAllValues`- und `ForAnyValue`-Qualifikatoren fügen dem Bedingungsoperator eine Funktionalität zum Festlegen von Operationen hinzu, sodass Sie in einer Richtlinie Anfragekontextschlüssel mit mehreren Werten anhand mehrerer Bedingungsschlüsselwerte testen können. Wenn Sie außerdem einen mehrwertigen Zeichenfolgen-Kontextschlüssel mit einem Platzhalter oder einer Variablen in Ihre Richtlinie einschließen, müssen Sie auch den `StringLike`-[Bedingungsoperator](reference_policies_elements_condition_operators.md#Conditions_String) verwenden. Mehrere Bedingungsschlüsselwerte müssen wie ein [Array](reference_policies_grammar.md#policies-grammar-json) in Klammern eingeschlossen werden, zum Beispiel `"Key2":["Value2A", "Value2B"]`.
### ForAllValues
Der Qualifizierer „`ForAllValues`“ prüft, ob der Wert jedes Elements des Anfragekontexts mit dem nachfolgenden Bedingungsoperator übereinstimmt. Die Bedingung gibt `true` zurück, wenn jeder Kontextschlüsselwert in der Anfrage mit einem Kontextschlüsselwert in der Richtlinie übereinstimmt. Sie gibt ebenfalls `true` zurück, wenn keine Kontextschlüssel in der Anfrage vorhanden sind.
**Wichtig**
Seien Sie vorsichtig, wenn Sie `ForAllValues` mit einem `Allow`-Effekt verwenden, da dies übermäßig zulässig sein kann, wenn das Vorhandensein fehlender Kontextschlüssel im Anfragekontext unerwartet ist. Sie sollten immer den [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null)-Bedingungsoperator mit einem `false`-Wert in Ihre Richtlinie einschließen, um zu prüfen, ob der Kontextschlüssel vorhanden ist und sein Wert nicht null ist. Ein Beispiel finden Sie unter [Zugriffssteuerung auf der Grundlage von Tag-Schlüsseln](access_tags.md#access_tags_control-tag-keys).
#### Beispiel für ForAllValues einen Set-Operator
Im folgenden Beispiel ForAllValues wird mit aws: verwendet, TagKeys um Benutzern das Löschen bestimmter Tags zu ermöglichen, die einer EC2-Instance zugewiesen wurden. Diese Richtlinie erlaubt Benutzern nur das Löschen der Tags `environment` und `cost-center`. Sie können diese einzeln oder zusammen löschen. Die Tag-Schlüssel in der Anfrage müssen exakt mit den in der Richtlinie angegebenen Schlüsseln übereinstimmen.
------
#### [ 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"
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
| **Abgleich** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– cost-center
| **Spiel** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– cost-center
| **Spiel** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– dept
| **Kein Spiel** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | Kein `aws:TagKeys` im Anfragekontext. | **Kein Spiel** |
Beachten Sie, dass im letzten Beispiel das Ergebnis „Keine Übereinstimmung“ lautet, da die Null-Bedingungsprüfung eine Übereinstimmung verhindert, wenn der Kontextschlüssel fehlt. Dies ist eine bewährte Methode, um zu permissive Richtlinien zu vermeiden.
### ForAnyValue
Der Qualifikator „`ForAnyValue`“ prüft, ob mindestens ein Element des Satzes von Bedingungskontextschlüssel-Werten mit mindestens einem Element des Satzes von Bedingungskontextschlüssel-Werten in Ihrer Richtlinie übereinstimmt. Die Bedingung gibt `true` zurück, wenn einer der Kontextschlüsselwerte in der Anfrage mit einem der Kontextschlüsselwerte in der Richtlinie übereinstimmt. Wenn kein übereinstimmender Kontextschlüssel vorhanden ist oder der Schlüssel nicht existiert, gibt die Bedingung „`false`“ zurück.
**Wichtig**
Bei Verwendung von `ForAnyValue` mit einem `Deny`-Effekt wird die Richtlinie als **Keine Übereinstimmung** ausgewertet, wenn der Kontextschlüssel in der Anfrage nicht vorhanden ist. Für ein konsistentes Verhalten fügen Sie Ihrer Richtlinie eine explizite [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null)-Bedingungsprüfung hinzu, um zu überprüfen, ob der Kontextschlüssel existiert. Details hierzu finden Sie unter [Bedingungsoperator zur Prüfung der Existenz von Bedingungsoperatoren](reference_policies_elements_condition_operators.md#Conditions_Null).
#### Beispiel für ForAnyValue einen Set-Operator
Im folgenden Beispiel ForAnyValue wird mit aws: verwendet, TagKeys um Benutzern das Löschen bestimmter Tags zu ermöglichen, die einer EC2-Instance zugewiesen wurden. Diese Richtlinie erlaubt Benutzern das Löschen von Tags für eine Instance, wenn die in der Anfrage angegebenen Tag-Schlüssel `environment` oder `cost-center` enthalten. Die Anfrage kann zusätzliche Tag-Schlüssel enthalten, die nicht in der Richtlinie angegeben sind, muss aber mindestens einen der angegebenen Schlüssel enthalten, um die Bedingung zu erfüllen.
------
#### [ 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"
]
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
| **Abgleich** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– cost-center
| **Spiel** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– cost-center
| **Spiel** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– dept
| **Spiel** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– dept
| **Kein Spiel** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | Kein `aws:TagKeys` im Anfragekontext. | **Kein Spiel** |
# Beispiele für Bedingungsrichtlinien
In IAM-Richtlinien können Sie mehrere Werte für einwertige und mehrwertige Kontextschlüssel für den Vergleich mit dem Anforderungskontext angeben. Die folgenden Richtlinienbeispiele veranschaulichen Richtlinienbedingungen mit mehreren Kontextschlüsseln und -werten.
**Anmerkung**
Wenn Sie eine Richtlinie zur Aufnahme in dieses Referenzhandbuch vorschlagen möchten, verwenden Sie die Schaltfläche **Feedback** unten auf der Seite. Beispiele für identitätsbasierte IAM-Richtlinien finden Sie unter [Beispiele für identitätsbasierte Richtlinien in IAM](access_policies_examples.md).
## Beispiele für Bedingungsrichtlinien: Einwertige Kontextschlüssel
+ Mehrere Bedingungsblöcke mit einwertigen Kontextschlüsseln. ([Dieses Beispiel ansehen](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-1).)
+ Ein Bedingungsblock mit mehreren einwertigen Kontextschlüsseln und -werten. ([Dieses Beispiel ansehen](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-2).)
## Beispiele für Bedingungsrichtlinien: Mehrwertige Kontextschlüssel
+ Richtlinie mit Bedingungssatzoperator `ForAllValues` verweigern. ([Dieses Beispiel ansehen](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-1).)
+ Richtlinie mit Bedingungssatzoperator `ForAnyValue` verweigern. ([Dieses Beispiel ansehen](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-2).)
# Schlüsselbeispiele für mehrwertige Kontexte
Die folgenden Richtlinienbeispiele veranschaulichen, wie Richtlinienbedingungen mit mehrwertigen Kontextschlüsseln erstellt werden.
## Beispiel: Richtlinie ablehnen mit Bedingungssatzoperator ForAllValues
Das folgende Beispiel zeigt, die Verwendung einer identitätsbasierten Richtlinie zum Verweigern der Verwendung von IAM-Tagging-Aktionen, wenn bestimmte Tag-Schlüsselpräfixe in der Anfrage enthalten sind. Die Werte für [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) enthalten einen Platzhalter (\$1) für eine teilweise übereinstimmende Zeichenfolge. Die Richtlinie enthält den `ForAllValues`-Satz-Operator mit Kontextschlüssel `aws:TagKeys`, da der Anforderungskontextschlüssel mehrere Werte enthalten kann. Damit der Kontextschlüssel `aws:TagKeys` übereinstimmt, muss jeder Wert im Anfragekontext mit mindestens einem Wert in der Richtlinie übereinstimmen.
Der `ForAllValues`-Satz-Operator gibt auch „true“ zurück, wenn die Anfrage keine Kontextschlüssel enthält.
Sie können verhindern, dass fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „true“ ausgewertet werden, indem Sie den `Null`-Bedingungsoperator mit dem Wert `false` in Ihre Richtlinie einschließen, um zu überprüfen, ob der Kontextschlüssel in der Anforderung vorhanden ist und sein Wert nicht null ist. Weitere Informationen finden Sie unter [Bedingungsoperator zur Prüfung der Existenz von Bedingungsoperatoren](reference_policies_elements_condition_operators.md#Conditions_Null).
**Wichtig**
Diese Richtlinie lässt keine Aktionen zu. Verwenden Sie diese Richtlinie in Kombination mit anderen Richtlinien, die bestimmte Aktionen zulassen.
**Example Einen einzelnen Richtlinienbedingungswert für einen mehrwertigen Kontextschlüssel verweigern**
Im folgenden Beispiel lehnt die Richtlinie Anfragen ab, bei denen die Werte für `aws:TagKeys` in der Anfrage das Präfix **key1** nicht enthalten. Der Anfragekontext kann mehrere Werte haben, aber aufgrund des -Bedingungssatzoperators müssen alle Tag-Schlüsselwerte im Anforderungskontext mit dem Präfix **key1** beginnen.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
}
}
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird. Bei einer Deny-Anweisung wird „Übereinstimmung“ verweigert und „Keine Übereinstimmung“ nicht verweigert, sodass dies durch eine andere Anweisung zugelassen werden kann.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:legal
| **Keine Übereinstimmung** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Kein Spiel** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key2:audit
| **Spiel** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | Kein `aws:TagKeys` im Anforderungskontext. | **Spiel** |
**Example Mehrere Richtlinienbedingungswerte für einen mehrwertigen Kontextschlüssel verweigern**
Im folgenden Beispiel lehnt die Richtlinie Anfragen ab, bei denen die Werte für `aws:TagKeys` in der Anfrage das Präfix **key1** oder **key2** nicht enthalten. Der Anfragekontext kann mehrere Werte haben, aber aufgrund des `ForAllValues`-Bedingungssatzoperators müssen alle Tag-Schlüsselwerte im Anforderungskontext mit dem Präfix **key1** oder **key2** beginnen.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
}
}
}
]
}
```
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird. Bei einer Deny-Anweisung wird „Übereinstimmung“ verweigert und „Keine Übereinstimmung“ nicht verweigert, sodass dies durch eine andere Anweisung zugelassen werden kann.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:legal
| **Keine Übereinstimmung** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Kein Spiel** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key2:audit
| **Kein Spiel** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key3:legal
| **Spiel** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | Kein `aws:TagKeys` im Anforderungskontext. | **Spiel** |
## Beispiel: Richtlinie mit Bedingungssatzoperator ablehnen ForAnyValue
Das folgende Beispiel für eine identitätsbasierte Richtlinie verweigert die Erstellung von Snapshots von EC2-Instance-Volumes, wenn Snapshots mit einem der in der Richtlinie angegebenen Tag-Schlüssel, `environment` oder `webserver`, gekennzeichnet sind. Die Richtlinie enthält den `ForAnyValue`-Satz-Operator mit Kontextschlüssel `aws:TagKeys`, da der Anforderungskontextschlüssel mehrere Werte enthalten kann. Wenn Ihre Tagging-Anfrage einen der in der Richtlinie angegebenen Tag-Schlüsselwerte enthält, gibt der `aws:TagKeys`-Kontextschlüssel den Wert wahr zurück und ruft den Effekt der Ablehnungsrichtlinie auf.
**Wichtig**
Diese Richtlinie lässt keine Aktionen zu. Verwenden Sie diese Richtlinie in Kombination mit anderen Richtlinien, die bestimmte Aktionen zulassen.
------
#### [ 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"
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird. Bei einer Deny-Anweisung wird „Übereinstimmung“ verweigert und „Keine Übereinstimmung“ nicht verweigert, sodass dies durch eine andere Anweisung zugelassen werden kann.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– webserver
| **Abgleich** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– webserver
– test
| **Spiel** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– test
| **Kein Spiel** Kann durch eine andere Anweisung zugelassen werden. |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | Kein `aws:TagKeys` im Anforderungskontext. | **Kein Spiel** Kann durch eine andere Anweisung zugelassen werden. |
# Beispiele für Richtlinien mit einwertigen Kontextschlüsseln
Die folgenden Richtlinienbeispiele veranschaulichen, wie Richtlinienbedingungen mit einwertigen Kontextschlüsseln erstellt werden.
## Beispiel: Mehrere Bedingungsblöcke mit einwertigen Kontextschlüsseln
Wenn ein Bedingungsblock mehrere Bedingungen mit jeweils einem einzelnen Kontextschlüssel enthält, müssen alle Kontextschlüssel zu „wahr“ aufgelöst werden, damit der gewünschte `Allow`- oder `Deny`-Effekt aufgerufen wird. Wenn Sie negierte übereinstimmende Bedingungsoperatoren verwenden, wird die Auswertungslogik des Bedingungswerts umgedreht.
Das folgende Beispiel ermöglicht es Benutzern, EC2-Volumes zu erstellen und während der Volume-Erstellung Tags auf die Volumes anzuwenden. Der Anforderungskontext muss einen Wert für den Kontextschlüssel `aws:RequestTag/project` enthalten. Der Wert für den Kontextschlüssel `aws:ResourceTag/environment` kann ein beliebiger Wert außer „Produktion“ sein.
------
#### [ 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"
}
}
}
]
}
```
------
Der Anforderungskontext muss einen Projekt-Tag-Wert enthalten und kann nicht für eine Produktionsressource zum Aufrufen des `Allow`-Effekts erstellt werden. Das folgende EC2-Volume wurde erfolgreich erstellt, da der Projektname `Feature3` mit einem `QA`-Ressourcen-Tag lautet.
```
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}]'
```
## Beispiel: Ein Bedingungsblock mit mehreren einwertigen Kontextschlüsseln und -werten
Wenn ein Bedingungsblock mehrere Kontextschlüssel enthält und jeder Kontextschlüssel über mehrere Werte verfügt, muss jeder Kontextschlüssel zu „wahr“ aufgelöst werden, damit mindestens ein Schlüsselwert für den gewünschten `Allow`- oder `Deny`-Effekt aufgerufen wird. Wenn Sie negierte übereinstimmende Bedingungsoperatoren verwenden, wird die Auswertungslogik des Wertes des Bedingungsschlüssels umgedreht.
Mit dem folgenden Beispiel können Benutzer Aufgaben in Clustern in Amazon Elastic Container Service starten und ausführen.
+ Der Anforderungskontext muss `production` **ODER** `prod-backup` für den `aws:RequestTag/environment`-Kontextschlüssel **UND** enthalten.
+ Der `ecs:cluster`-Kontextschlüssel stellt sicher, dass Aufgaben entweder auf den `default1` **ODER** `default2`-ARN-ECS-Clustern ausgeführt werden.
------
#### [ 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"
]
}
}
}
]
}
```
------
Die folgende Tabelle zeigt, wie diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anfrage AWS bewertet wird.
| Richtlinienbedingung | Kontext anfordern | Ergebnis |
| --- | --- | --- |
| "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
| Match |
| "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
| Match |
| "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
| Keine Übereinstimmung |
| "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"
]
} | Kein `aws:RequestTag` im Anfragekontext. ecs:cluster
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Keine Übereinstimmung |