Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Elementi delle policy JSON IAM: Condition
L'elemento `Condition` (o *blocco* `Condition`) consente di specificare le condizioni di attivazione di una policy. L’elemento `Condition` è facoltativo. Nell'elemento `Condition` è possibile creare espressioni in cui utilizzare [operatori condizionali](reference_policies_elements_condition_operators.md) (uguale a, meno di, e altri) per confrontare le chiavi di contesto e i valori della policy rispetto alle chiavi e ai valori del contesto della richiesta. Per ulteriori informazioni sul contesto della richiesta, consultare [Componenti di una richiesta](intro-structure.md#intro-structure-request).
```
"Condition" : { "{condition-operator}" : { "{condition-key}" : "{condition-value}" }}
```
La chiave di contesto specificata in una condizione della policy può essere una [chiave di contesto della condizione globale](reference_policies_condition-keys.md) o una chiave di condizione specifica del servizio. Le chiavi di contesto della condizione globale presentano il prefisso `aws:`. Le chiavi di contesto specifiche del servizio presentano il prefisso del servizio. Ad esempio, Amazon EC2 consente di scrivere una condizione utilizzando la chiave di contesto `ec2:InstanceType`, univoca per quel servizio. Per visualizzare le chiavi di contesto IAM specifiche del servizio con il prefisso `iam:`, consulta [chiavi contestuali IAM e AWS STS condition](reference_policies_iam-condition-keys.md).
I *nomi* delle chiavi di contesto non fanno distinzione tra maiuscole e minuscole. Ad esempio, se si include la chiave di contesto `aws:SourceIP` è identico al test per la chiave `AWS:SourceIp`. La distinzione tra maiuscole e minuscole dei *valori* delle chiavi di contesto dipende dall'[operatore di condizione](reference_policies_elements_condition_operators.md) utilizzato. Ad esempio, la seguente condizione include l'operatore `StringEquals` per rendere possibile la corrispondenza solo delle richieste effettuate da `john`. Agli utenti denominati `John` viene negato l'accesso.
```
"Condition" : { "StringEquals" : { "aws:username" : "john" }}
```
Le seguenti condizione utilizza l'operatore [`StringEqualsIgnoreCase`](reference_policies_elements_condition_operators.md#Conditions_String) per corrispondere agli utenti denominati `john` o `John`.
```
"Condition" : { "StringEqualsIgnoreCase" : { "aws:username" : "john" }}
```
Alcune chiavi di contesto supportano le coppie chiave-valore che consentono di specificare parte del nome della chiave. Gli esempi includono la chiave di [`aws:RequestTag/tag-key`](reference_policies_condition-keys.md#condition-keys-requesttag)contesto 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), la e la chiave di [`ResourceTag/tag-key`](reference_policies_condition-keys.md#condition-keys-resourcetag)contesto supportate da più servizi.
+ Se utilizzi la chiave di contesto `ResourceTag/tag-key` per un servizio come [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policy-structure.html#amazon-ec2-keys), devi specificare un nome di chiave per la `tag-key`.
+ **I nomi delle chiavi non fanno distinzione tra maiuscole e minuscole.** Questo significa che se specifichi `"aws:ResourceTag/TagKey1": "Value1"` nell'elemento condizione della policy, la condizione corrisponderà a una chiave di tag della risorsa denominata `TagKey1` o `tagkey1`, ma non a entrambe.
+ AWS i servizi che supportano questi attributi potrebbero consentire di creare più nomi di chiavi che differiscono solo in base alle maiuscole e alle minuscole. Ad esempio, è possibile applicare un tag a un'istanza Amazon EC2 con `ec2=test1` e `EC2=test2`. Quando utilizzi una condizione come `"aws:ResourceTag/EC2": "test1"` per consentire l'accesso alla risorsa, il nome della chiave corrisponde a entrambi i tag, ma solo a un valore. Questo può causare errori di condizione imprevisti.
**Importante**
Come best practice, verifica che i membri del tuo account seguano una convenzione di denominazione coerente quando assegnano nomi agli attributi di coppie chiave- valore. Alcuni esempi includono tag o contesti di crittografia AWS KMS . È possibile imporlo utilizzando la chiave di [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys)contesto per l'etichettatura o la [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)per il contesto di AWS KMS crittografia.
+ Per un elenco di tutti gli operatori di condizione e per una descrizione del funzionamento di ciascun operatore, consulta [Operatori di condizione](reference_policies_elements_condition_operators.md)
+ Se non è diversamente specificato, tutte le chiavi di contesto possono avere valori multipli. Per ulteriori informazioni sulla gestione delle chiavi di contesto che dispongono di più valori, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)
+ Per un elenco di tutte le chiavi di contesto disponibili a livello globale, consulta [AWS chiavi di contesto della condizione globale](reference_policies_condition-keys.md).
+ Per le chiavi di contesto delle condizioni definite da ciascun servizio, consulta [Azioni, risorse e chiavi di condizione per i AWS](reference_policies_actions-resources-contextkeys.html) servizi.
## Il contesto della richiesta
Quando un [principale](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html?icmpid=docs_homepage_addtlrcs#principal) effettua una [richiesta](intro-structure.md#intro-structure-request) a AWS, AWS raccoglie le informazioni sulla richiesta in un contesto di richiesta. Il contesto della richiesta include informazioni sul principale, sulle risorse, sulle operazioni e su altre proprietà dell’ambiente. La valutazione delle policy confronta le proprietà nella policy con le proprietà inviate nella richiesta per valutare e autorizzare le operazioni che è possibile eseguire in AWS.
È possibile utilizzare l'elemento `Condition` di una policy JSON per testare chiavi di contesto specifiche rispetto al contesto della richiesta. Ad esempio, puoi creare una policy che utilizzi la chiave [aws: CurrentTime](reference_policies_condition-keys.md#condition-keys-currenttime) context per [consentire a un utente di eseguire azioni solo entro un intervallo di date specifico](reference_policies_examples_aws-dates.md).
L’esempio seguente mostra una rappresentazione del contesto della richiesta quando Martha Rivera invia una richiesta per disattivare il suo dispositivo MFA.
```
Principal: AROA123456789EXAMPLE
Action: iam:DeactivateMFADevice
Resource: arn:aws:iam::user/martha
Context:
– aws:UserId=AROA123456789EXAMPLE:martha
– aws:PrincipalAccount=1123456789012
– aws:PrincipalOrgId=o-example
– aws:PrincipalARN=arn:aws:iam::1123456789012:assumed-role/TestAR
– aws:MultiFactorAuthPresent=true
– aws:MultiFactorAuthAge=2800
– aws:CurrentTime=...
– aws:EpochTime=...
– aws:SourceIp=...
```
Il contesto della richiesta viene confrontato con una policy che consente agli utenti di rimuovere il proprio dispositivo di autenticazione a più fattori (MFA), ma solo se è stato effettuato l’accesso utilizzando l’MFA nell’ultima ora (3600 secondi).
------
#### [ 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 questo esempio, la policy corrisponde al contesto della richiesta: l’operazione è la stessa, la risorsa corrisponde al carattere jolly “\$1” e il valore per `aws:MultiFactorAuthAge` è 2800, che è inferiore a 3600, quindi la policy consente questa richiesta di autorizzazione.
AWS valuta ogni chiave di contesto nella policy e restituisce un valore *vero* o *falso*. Una chiave di contesto che non è presente nella richiesta è considerata una mancata corrispondenza.
Il contesto della richiesta può restituire i seguenti valori:
+ **True**: se il richiedente ha effettuato l'accesso utilizzando MFA nell'ultima ora o meno, la condizione restituisce *true*.
+ **False**: se il richiedente ha effettuato l'accesso utilizzando MFA più di un'ora fa, la condizione restituisce *false*.
+ **Non presente**: se il richiedente ha effettuato una richiesta utilizzando le proprie chiavi di accesso utente IAM nell' AWS API AWS CLI or, la chiave non è presente. In questo caso, la chiave non è presente e non viene restituita la corrispondenza.
**Nota**
In alcuni casi, quando il valore della chiave della condizione non è presente, la condizione può comunque restituire True. Ad esempio, se si aggiunge il qualificatore `ForAllValues`, la richiesta restituisce True se la chiave di contesto non è inclusa nella richiesta. Per evitare che le chiavi di contesto mancanti o con valori vuoti vengano valutate come True, puoi includere l’[Operatore di condizione Null](reference_policies_elements_condition_operators.md#Conditions_Null) nella tua policy con un valore `false` per verificare che la chiave di contesto esista e che il suo valore non sia Null.
## Il blocco condizione
L'esempio seguente mostra il formato di base di un elemento `Condition`:
```
"Condition": {"StringLike": {"s3:prefix": ["jane/*"]}}
```
Un valore dalla richiesta è rappresentato da una chiave di contesto, in questo caso `s3:prefix`. Il valore della chiave di contesto viene confrontato con un valore specificato come valore letterale, ad esempio `jane/*`. Il tipo di confronto da eseguire viene specificato dall'[operatore di condizione](reference_policies_elements_condition_operators.md) (in questo caso, `StringLike`). Puoi creare condizioni che confrontano stringhe, date, numeri e altro ancora, utilizzando tipiche comparazioni booleane come ad esempio "uguale a", "maggiore di" e "minore di". Se utilizzi [operatori stringa](reference_policies_elements_condition_operators.md#Conditions_String) o [operatori ARN](reference_policies_elements_condition_operators.md#Conditions_ARN), puoi utilizzare una [variabile di policy](reference_policies_variables.md) nel valore della chiave di contesto. L'esempio seguente include la variabile `aws:username`.
```
"Condition": {"StringLike": {"s3:prefix": ["${aws:username}/*"]}}
```
In alcuni casi, le chiavi di contesto possono contenere più valori. Ad esempio, una richiesta ad Amazon DynamoDB potrebbe richiedere la restituzione o l'aggiornamento di più attributi di una tabella. Una policy per l'accesso alle tabelle di DynamoDB può includere la chiave `dynamodb:Attributes` che contiene tutti gli attributi elencati nella richiesta. Puoi testare i vari attributi nella richiesta a fronte di un elenco di attributi consentiti in una policy, utilizzando operatori predefiniti nell'elemento `Condition`. Per ulteriori informazioni, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
Quando la policy viene valutata durante una richiesta, AWS sostituisce la chiave con il valore corrispondente della richiesta. (In questo esempio, AWS utilizzerebbe la data e l'ora della richiesta.) Dopo la valutazione della condizione, viene restituito un risultato True o False, che viene poi utilizzato per decidere se la policy nel suo complesso deve consentire o rifiutare la richiesta.
### Valori multipli in una condizione
Un elemento `Condition` può contenere più operatori di condizioni, ciascuno delle quali può includere a sua volta più coppie chiave-valore. L'immagine seguente illustra questo scenario.
![\[diagrammi a blocchi dell'operatore a due condizioni. Il primo blocco include due segnaposto con chiavi di contesto, ciascuno con più valori. Il secondo blocco di condizione include una chiave di contesto con più valori.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block.diagram.png)
Per ulteriori informazioni, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
# Elementi della policy JSON IAM: operatori di condizione
Utilizzare gli operatori di condizione nell'elemento `Condition` per confrontare chiave e valore nella policy con i valori nel contesto della richiesta. Per ulteriori informazioni sull'elemento `Condition`, consultare [Elementi delle policy JSON IAM: Condition](reference_policies_elements_condition.md).
L'operatore di condizione che è possibile utilizzare in una policy dipende dalla chiave di condizione scelta. È possibile scegliere una chiave di condizione globale o una chiave di condizione specifica del servizio. Per informazioni su quale operatore di condizione è possibile utilizzare per una chiave di condizione globale, consultare [AWS chiavi di contesto della condizione globale](reference_policies_condition-keys.md). Per sapere quale operatore di condizione è possibile utilizzare per una chiave di condizione specifica del servizio, consulta [Azioni, risorse e chiavi di condizione per AWS i servizi](reference_policies_actions-resources-contextkeys.html) e scegli il servizio che desideri visualizzare.
**Importante**
Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono e la condizione è *false*. Se la condizione di policy richiede che la chiave sia *non* abbinata, ad esempio `StringNotLike` o `ArnNotLike` e la chiave giusta non è presente, la condizione è *true*. [Questa logica si applica a tutti gli operatori di condizione tranne... IfExists](#Conditions_IfExists)e [Null check](#Conditions_Null). Questi operatori testano se la chiave è presente (esiste) nel contesto della richiesta.
Gli operatori di condizione possono essere raggruppati nelle seguenti categorie:
+ [Stringa](#Conditions_String)
+ [Numerici](#Conditions_Numeric)
+ [Data e ora](#Conditions_Date)
+ [Booleano](#Conditions_Boolean)
+ [Binary](#Conditions_BinaryEquals)
+ [IP address (Indirizzo IP)](#Conditions_IPAddress)
+ [Amazon Resource Name (ARN)](#Conditions_ARN) (disponibile solo per alcuni servizi)
+ [... IfExists](#Conditions_IfExists)(verifica se il valore della chiave esiste come parte di un altro controllo)
+ [Verifica Null](#Conditions_Null) (controlla se il valore della chiave esiste come controllo autonomo)
## Operatori di condizione stringa
Gli operatori di condizioni stringa consentono di creare elementi `Condition` che limitano l'accesso in base al confronto con una chiave con un valore di stringa.
+ **Variabili di policy**: [supportate](reference_policies_variables.md)
+ **Caratteri jolly**: [supportati](#Conditions_String-wildcard)
****
| Operatore di condizione | Description |
| --- | --- |
| `StringEquals` | Corrispondenza esatta, con distinzione maiuscole/minuscole |
| `StringNotEquals` | Corrispondenza negativa |
| `StringEqualsIgnoreCase` | Corrispondenza esatta, senza distinzione maiuscole/minuscole |
| `StringNotEqualsIgnoreCase` | Corrispondenza negativa, senza distinzione maiuscole/minuscole |
| `StringLike` | Corrispondenza con distinzione maiuscole/minuscole. I valori possono includere una corrispondenza con più caratteri jolly (\$1) e un singolo carattere jolly (?) in qualsiasi punto della stringa. Per ottenere corrispondenze di stringhe parziali devi specificare caratteri jolly. Se una chiave contiene più valori, `StringLike` può essere qualificato con gli operatori su set: `ForAllValues:StringLike` e `ForAnyValue:StringLike`. Per ulteriori informazioni, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys). |
| `StringNotLike` | Corrispondenza negativa, con distinzione maiuscole/minuscole. I valori possono includere una corrispondenza con più caratteri jolly (\$1) o un singolo carattere jolly (?) in qualsiasi punto della stringa. |
**Example operatore di condizione stringa**
Ad esempio, l'istruzione seguente contiene un elemento `Condition` che utilizza la chiave [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) per specificare che il principale che effettua la richiesta deve essere contrassegnato con la categoria di processo `iamuser-admin`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
}
}
}
}
```
Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. In questo esempio, la chiave `aws:PrincipalTag/job-category` è presente nel contesto della richiesta se il principale utilizza un utente IAM con tag collegati. È inclusa anche per un principale che utilizza un ruolo IAM con tag collegati o tag di sessione. Se un utente senza il tag tenta di visualizzare o modificare una chiave di accesso, la condizione restituisce `false` e la richiesta viene negata implicitamente da questa istruzione.
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | `aws:PrincipalTag/job-category` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
**Example utilizzo di una variabile di policy con un operatore di condizione stringa**
Nell'esempio seguente viene utilizzato l'operatore di condizione `StringLike` per eseguire il confronto con una [variabile di policy](reference_policies_variables.md) per creare una policy che consente a un utente IAM di utilizzare la console Amazon S3 per gestire la propria "directory principale" in un bucket Amazon S3. La policy consente le operazioni specificate in un bucket S3 a condizione che `s3:prefix` corrisponda a uno qualsiasi dei modelli specificati.
****
```
{
"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}/*"
]
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica per diversi utenti in base al [aws:username](reference_policies_condition-keys.md#condition-keys-username) valore nel contesto della richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– martha_rivera
| "StringLike": {
"s3:prefix": [
"home/",
"home/martha_rivera/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– nikki_wolf
| "StringLike": {
"s3:prefix": [
"home/",
"home/nikki_wolf/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | `aws:username` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
Per un esempio di una policy che mostra come usare l'elemento `Condition` per limitare l'accesso alle risorse in base a un ID applicazione e un ID utente per la federazione OIDC, consulta [Amazon S3: consente agli utenti di Amazon Cognito di accedere a oggetti nel relativo bucket](reference_policies_examples_s3_cognito-bucket.md).
### Operatori di condizione stringa multivalore
Se una chiave nella richiesta contiene più valori, gli operatori di stringa possono essere qualificati con gli operatori dell’insieme `ForAllValues` e `ForAnyValue`. Per ulteriori informazioni sulla logica di valutazione di più chiavi o valori di contesto, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Operatore di condizione | Description |
| --- | --- |
| `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase` | Tutti i valori per la chiave di condizione nella richiesta devono corrispondere ad almeno uno dei valori della policy. |
| `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase` | Almeno un valore per la chiave di condizione nella richiesta deve corrispondere a uno dei valori della policy. |
| `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase` | Corrispondenza negativa. Nessuno dei valori per la chiave di contesto nella richiesta può corrispondere a nessuno dei valori della chiave di contesto della policy. |
| `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase` | Corrispondenza negativa. Almeno un valore per la chiave di contesto nella richiesta NON deve corrispondere a uno dei valori nella chiave di contesto della policy. |
| `ForAllValues:StringLike` | Tutti i valori per la chiave di condizione nella richiesta devono corrispondere ad almeno uno dei valori della policy. |
| `ForAnyValue:StringLike` | Almeno un valore per la chiave di condizione nella richiesta deve corrispondere a uno dei valori della policy. |
| `ForAllValues:StringNotLike` | Corrispondenza negativa. Nessuno dei valori per la chiave di contesto nella richiesta può corrispondere a nessuno dei valori della chiave di contesto della policy. |
| `ForAnyValue:StringNotLike` | Corrispondenza negativa. Almeno un valore per la chiave di contesto nella richiesta NON deve corrispondere a uno dei valori nella chiave di contesto della policy. |
**Example utilizzo di `ForAnyValue` con un operatore di condizione stringa**
Questo esempio mostra come creare una policy basata sull'identità che consenta di utilizzare l'operazione `CreateTags` di Amazon EC2 per assegnare tag a un'istanza. Quando utilizzi `StringEqualsIgnoreCase`, puoi collegare i tag solo se il tag contiene la chiave `environment` con i valori `preprod` o `storage`. Quando aggiungi `IgnoreCase` all’operatore, consenti a qualsiasi utilizzo delle maiuscole del valore del tag esistente, ad esempio `preprod`, `Preprod` e `PreProd`, di risultare True.
Quando aggiungi il modificatore `ForAnyValue` con la chiave di condizione [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys), almeno un valore della chiave di tag nella richiesta deve corrispondere al valore `environment`. Il confronto `ForAnyValue` fa distinzione tra maiuscole e minuscole, il che impedisce agli utenti di utilizzare le maiuscole e minuscole errate per la chiave del tag, ad esempio utilizzare `Environment` invece che `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"
}
}
}
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– costcenter
aws:RequestTag/environment:
– preprod
| Nessuna corrispondenza |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | `aws:TagKeys` non è presente nel contesto della richiesta. aws:RequestTag/environment:
– storage
| Nessuna corrispondenza |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
`aws:RequestTag/environment` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | `aws:TagKeys` non è presente nel contesto della richiesta. `aws:RequestTag/environment` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
### Corrispondenza dei caratteri jolly
Gli operatori di condizioni di stringa eseguono una corrispondenza senza modello che non impone un formato predefinito. Gli operatori di condizione ARN e Date sono un sottoinsieme di operatori di stringa che impongono una struttura al valore della chiave della condizione.
Ti consigliamo di utilizzare operatori di condizione che corrispondono ai valori con cui stai confrontando le chiavi. Ad esempio, è necessario utilizzare [Operatori di condizione stringa](#Conditions_String) quando si confrontano le chiavi con i valori delle stringhe. Allo stesso modo, è necessario utilizzare [Operatori di condizione con Amazon Resource Name (ARN)](#Conditions_ARN) quando si confrontano le chiavi con i valori ARN.
**Example**
In questo esempio viene illustrato come creare un limite intorno alle risorse nell’organizzazione. La condizione di questa policy nega l'accesso alle azioni di Amazon S3 a meno che la risorsa a cui si accede non si trovi in un insieme specifico di unità organizzative OUs () in. AWS Organizations Un percorso AWS Organizations è una rappresentazione testuale della struttura dell’entità di un’organizzazione.
La condizione richiede che `aws:ResourceOrgPaths` contenga uno dei percorsi di unità organizzative elencati. Poiché `aws:ResourceOrgPaths` si tratta di una condizione multivalore, la politica utilizza l'`ForAllValues:StringNotLike`operatore per confrontare i valori di con `aws:ResourceOrgPaths` l'elenco contenuto OUs nella politica.
****
```
{
"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/*"
]
}
}
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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/
| Nessuna corrispondenza |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | Nessun `aws:ResourceOrgPaths:` nella richiesta. | Nessuna corrispondenza |
## Operatori di condizione numerici
Gli operatori di condizione numerici consentono di creare elementi `Condition` che limitano l'accesso in base al confronto di una chiave con un valore intero o decimale.
+ **Variabili di policy**: non supportate
+ **Caratteri jolly**: non supportati
****
| Operatore di condizione | Description |
| --- | --- |
| `NumericEquals` | Corrispondenza |
| `NumericNotEquals` | Corrispondenza negativa |
| `NumericLessThan` | Corrispondenza "Minore di" |
| `NumericLessThanEquals` | Corrispondenza "Minore di o uguale a" |
| `NumericGreaterThan` | Corrispondenza "Maggiore di" |
| `NumericGreaterThanEquals` | Corrispondenza "Maggiore di o uguale a" |
Ad esempio, la seguente istruzione contiene un elemento `Condition` che utilizza l'operatore di condizione `NumericLessThanEquals` con la chiave `s3:max-keys` per specificare che il richiedente può elencare *fino a* oggetti in `amzn-s3-demo-bucket` alla volta.
------
#### [ 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"}}
}
}
```
------
Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. In questo esempio, la chiave `s3:max-keys` è sempre presente nella richiesta quando si esegue l'operazione `ListBucket`. Se questa policy consentiva tutte le operazioni Amazon S3, saranno consentite solo le operazioni che includono la chiave di contesto `max-keys` con un valore minore o uguale a 10.
## Operatori di condizione data
Gli operatori Date Condition consentono di creare `Condition` elementi che limitano l'accesso in base al confronto di una chiave con un date/time valore. Utilizza questi operatori di condizione con la chiave [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) o la chiave [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). È necessario specificare date/time i valori con una delle [implementazioni W3C dei formati di data ISO 8601 o in base all'](http://www.w3.org/TR/NOTE-datetime)ora epoch (UNIX).
+ **Variabili di policy**: non supportate
+ **Caratteri jolly**: non supportati
****
| Operatore di condizione | Description |
| --- | --- |
| `DateEquals` | Corrispondenza con una data specifica |
| `DateNotEquals` | Corrispondenza negativa |
| `DateLessThan` | Corrispondenza prima di una determinata data e ora |
| `DateLessThanEquals` | Corrispondenza a una determinata data e ora |
| `DateGreaterThan` | Corrispondenza dopo una determinata data e ora |
| `DateGreaterThanEquals` | Corrispondenza a una determinata data e ora o successiva |
Ad esempio, l’istruzione seguente contiene un elemento `Condition` che utilizza l’operatore di condizione `DateGreaterThan` con la chiave [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). Questa condizione specifica che le credenziali di sicurezza temporanee utilizzate per effettuare la richiesta sono state emesse nel 2020. Questa policy può essere aggiornata ogni giorno a livello di codice per garantire che i membri dell'account utilizzino nuove credenziali.
------
#### [ 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"
}
}
}
}
```
------
Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. La chiave `aws:TokenIssueTime` è presente nel contesto della richiesta solo quando il principale utilizza le credenziali temporanee per effettuare la richiesta. La chiave non è presente nelle AWS CLI richieste AWS API o AWS SDK effettuate utilizzando le chiavi di accesso. In questo esempio, se un utente IAM prova a visualizzare o modificare una chiave di accesso, la richiesta viene rifiutata.
## Operatori di condizione booleani
Le condizioni booleane consentono di creare elementi `Condition` che limitano l’accesso in base al confronto con una chiave con valore `true` o `false`.
Se una chiave contiene più valori, gli operatori booleani possono essere qualificati con gli operatori dell’insieme `ForAllValues` e `ForAnyValue`. Per ulteriori informazioni sulla logica di valutazione di più chiavi o valori di contesto, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ **Variabili di policy**: [supportate](reference_policies_variables.md)
+ **Caratteri jolly**: non supportati
****
| Operatore di condizione | Description |
| --- | --- |
| `Bool` | Corrispondenza booleana |
| `ForAllValues:Bool` | Da utilizzare con il tipo di dati array di valori booleani. Tutti i valori booleani inclusi nei valori chiave di contesto devono corrispondere ai valori booleani della policy. Per evitare che gli operatori `ForAllValues` valutino come Consentita una chiave di contesto mancante o con valore vuoto, puoi includere nella policy l’[Operatore di condizione Null](#Conditions_Null). |
| `ForAnyValue:Bool` | Da utilizzare con il tipo di dati array di valori booleani. Almeno uno dei valori booleani nella chiave di contesto deve corrispondere ai valori booleani della policy. |
**Example operatore di condizione booleana**
La seguente policy basata sull’identità utilizza l’operatore di condizione `Bool` con la chiave [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) per negare la replica degli oggetti e dei tag degli oggetti nel bucket di destinazione e i rispettivi contenuti se la richiesta non è su SSL.
Questa policy non consente alcuna operazione. Utilizza questa policy in combinazione con altre policy che consentono operazioni specifiche.
****
```
{
"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"
}
}
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– false
| Match |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– true
| Nessuna corrispondenza |
| "Bool": {
"aws:SecureTransport": "false"
} | `aws:SecureTransport` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
## Operatori di condizione binari
L’operatore di condizione `BinaryEquals` consente di creare elementi `Condition` che testano i valori di chiave in formato binario. Viene effettuato un confronto del valore del byte di chiave specificato per il byte con una rappresentazione codificata in [base 64](https://en.wikipedia.org/wiki/Base64) nella policy. Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono.
+ **Variabili di policy**: non supportate
+ **Caratteri jolly**: non supportati
```
"Condition" : {
"BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
}
```
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– QmluYXJ5VmFsdWVJbkJhc2U2NA==
| Match |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– ASIAIOSFODNN7EXAMPLE
| Nessuna corrispondenza |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | `key` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
## Operatori di condizione con indirizzo IP
Gli operatori di condizione degli indirizzi IP consentono di creare `Condition` elementi che limitano l'accesso in base al confronto di una chiave con un IPv6 indirizzo IPv4 o o un intervallo di indirizzi IP. È possibile utilizzare questi operatori con la chiave [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). Il valore deve essere nel formato CIDR standard (ad esempio, 203.0.113.0/24 o 2001:: 1234:5678: :/64). DB8 Se si specifica un indirizzo IP senza il prefisso di instradamento associato, IAM utilizza il valore predefinito di prefisso `/32`.
Alcuni AWS servizi supportano l'utilizzo di:: per rappresentare un intervallo di 0. IPv6 Per sapere se un servizio supporta IPv6, consulta la documentazione relativa a quel servizio.
+ **Variabili di policy**: non supportate
+ **Caratteri jolly**: non supportati
****
| Operatore di condizione | Description |
| --- | --- |
| `IpAddress` | L'indirizzo o l'intervallo IP specificato |
| `NotIpAddress` | Tutti gli indirizzi IP tranne l'indirizzo o l'intervallo IP specificato |
**Example Operatore di condizione con indirizzo IP**
La seguente istruzione utilizza l’operatore di condizione `IpAddress` con la chiave `aws:SourceIp` per specificare che la richiesta deve provenire dall’intervallo IP da 203.0.113.0 a 203.0.113.255.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}
}
}
```
La chiave di condizione `aws:SourceIp` risolve l'indirizzo IP da cui ha origine la richiesta. Se le richieste provengono da un'istanza Amazon EC2, `aws:SourceIp` viene valutato con l'indirizzo IP pubblico dell'istanza.
Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. La chiave `aws:SourceIp` è sempre presente nel contesto della richiesta, tranne quando il richiedente utilizza un endpoint VPC per effettuare la richiesta. In questo caso, la condizione restituisce `false` e la richiesta è implicitamente rifiutata da questa istruzione.
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
L'esempio seguente mostra come combinare IPv4 più IPv6 indirizzi per coprire tutti gli indirizzi IP validi dell'organizzazione. Ti consigliamo di aggiornare le politiche della tua organizzazione con gli intervalli di IPv6 indirizzi in aggiunta agli IPv4 intervalli di indirizzi già disponibili per garantire che i criteri continuino a funzionare durante la transizione 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"
]
}
}
}
}
```
La chiave di condizione `aws:SourceIp` funziona solo in una policy JSON se si chiama l'API testata direttamente come utente. Se si utilizza invece un servizio per chiamare il servizio di destinazione per conto dell'utente, il servizio di destinazione visualizza l'indirizzo IP del servizio chiamante anziché l'indirizzo IP dell'utente originario. Ciò può accadere, ad esempio, se si utilizza AWS CloudFormation per chiamare Amazon EC2 per creare istanze per tuo conto. Attualmente non è disponibile alcun modo per passare l'indirizzo IP di origine tramite un servizio di chiamata al servizio di destinazione per la valutazione in una policy JSON. Per questi tipi di chiamate API di servizi, non utilizzare la chiave di condizione `aws:SourceIp`.
## Operatori di condizione con Amazon Resource Name (ARN)
Gli operatori di condizione con ARN (Amazon Resource Name) consentono di creare elementi `Condition` che limitano l'accesso in base al confronto di una chiave con un ARN. L'ARN è considerato una stringa.
+ **Variabili di policy**: [supportate](reference_policies_variables.md)
+ **Caratteri jolly**: [supportati](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)
****
| Operatore di condizione | Description |
| --- | --- |
| `ArnEquals`, `ArnLike` | Corrispondenza con distinzione maiuscole/minuscole dell'ARN. Ciascuno dei sei componenti delimitati da due punti dell'ARN viene verificato separatamente e ognuno di essi può includere più caratteri jolly (\$1) o un singolo carattere jolly (?) corrispondenti. Gli operatori di condizione `ArnEquals` e `ArnLike` si comportano allo stesso modo. |
| `ArnNotEquals`, `ArnNotLike` | Corrispondenza negativa per l'ARN. Gli operatori di condizione `ArnNotEquals` e `ArnNotLike` si comportano allo stesso modo. |
**Example Operatore di condizione ARN**
Nell'esempio di policy basata sulle risorse riportato di seguito viene illustrata una policy collegata a una coda Amazon SQS a cui si desidera inviare messaggi SNS. La policy autorizza Amazon SNS a inviare messaggi alla coda (o alle code) di propria scelta, ma solo se il servizio invia i messaggi per conto di un determinato argomento (o argomenti) di Amazon SNS. È possibile specificare la coda nel campo `Resource` e l'argomento Amazon SNS come valore per la chiave `SourceArn`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "SQS:SendMessage",
"Resource": "arn:aws:sqs:us-east-1:123456789012:QUEUE-ID",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-east-1:123456789012:TOPIC-ID"
}
}
}
}
```
La chiave [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) è presente nel contesto della richiesta solo se una risorsa attiva un servizio per chiamare un altro servizio per conto del proprietario della risorsa. Se un utente IAM prova a eseguire direttamente questa operazione, la condizione restituisce `false` e la richiesta viene rifiutata implicitamente da questa istruzione.
La tabella seguente mostra come AWS valuta questa politica in base ai valori chiave della condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | `aws:SourceArn` non è presente nel contesto della richiesta. | Nessuna corrispondenza |
### Operatori di condizione ARN multivalore
Se una chiave nella richiesta contiene più valori, gli operatori ARN possono essere qualificati con gli operatori dell’insieme `ForAllValues` e `ForAnyValue`. Per ulteriori informazioni sulla logica di valutazione di più chiavi o valori di contesto, consulta [Operatori dell’insieme per le chiavi di contesto multivalore](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Operatore di condizione | Description |
| --- | --- |
| `ForAllValues:ArnEquals` `ForAllValues:ArnLike` | Tutti gli elementi ARNs presenti nel contesto della richiesta devono corrispondere ad almeno uno dei modelli ARN della policy. |
| `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike` | Almeno un ARN nel contesto della richiesta deve corrispondere a uno dei modelli ARN della policy. |
| `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike` | Corrispondenza negativa. Nessuno di quelli ARNs presenti nel contesto della richiesta può corrispondere a nessun pattern ARN di stringhe nella tua policy. |
| `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike` | Corrispondenza negativa. Almeno un ARN nel contesto della richiesta NON deve corrispondere a nessuno dei modelli ARN della policy. |
**Example utilizzo di `ForAllValues` con un operatore di condizione ARN**
L'esempio seguente utilizza `ForAllValues:ArnLike` per creare o aggiornare una fonte di consegna logica per i log di Amazon CloudWatch Logs. Il blocco condition include la chiave condition [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)per filtrare la risorsa generatrice di log ARNs passata nella richiesta. Utilizzando questo operatore di condizione, tutti gli ARNs elementi della richiesta devono corrispondere ad almeno un ARN nella policy.
****
```
{
"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*"
]
}
}
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:777788889999:distribution/costcenter
| Nessuna corrispondenza |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | `logs:LogGeneratingResourceArns` non è presente nel contesto della richiesta. | Match |
Il qualificatore `ForAllValues` restituisce True se non ci sono chiavi di contesto nella richiesta o se i valori delle chiavi si riducono a un set di dati Null, ad esempio una stringa vuota. Per evitare che le chiavi di contesto mancanti o con valori vuoti vengano valutate come True, puoi includere l’[Operatore di condizione Null](#Conditions_Null) nella tua policy con un valore `false` per verificare che la chiave di contesto esista e che il suo valore non sia Null.
## ... IfExists operatori di condizionamento
È possibile aggiungere `IfExists` alla fine di qualsiasi nome operatore di condizione ad eccezione della condizione `Null`, ad esempio `StringLikeIfExists`. Questa aggiunta ha lo scopo di dichiarare che "se la chiave di policy è presente nel contesto della richiesta, la chiave deve essere elaborata come specificato nella policy". Se la chiave non è presente, l'elemento della condizione viene valutato come "true". Altri elementi di condizione nell'istruzione possono comunque risultare in una mancata corrispondenza, ma non una chiave mancante se verificata tramite `...IfExists`. Se stai utilizzando un elemento `"Effect": "Deny"` con un operatore di condizione negato come `StringNotEqualsIfExists`, la richiesta viene comunque negata anche se manca la chiave di condizione.
**Esempio di utilizzo di `IfExists`**
Molte chiavi di condizione descrivono informazioni su un determinato tipo di risorsa e sono presenti solo quando si accede a tale tipo di risorsa. Queste chiavi di condizione non sono presenti in altri tipi di risorse. Questo non causa problemi se l'istruzione della policy si applica a un solo tipo di risorsa. Tuttavia, esistono casi in cui una singola istruzione può essere applicata a più tipi di risorse, ad esempio quando l'istruzione della policy fa riferimento a operazioni di più servizi o quando una determinata operazione all'interno di un servizio accede a diversi tipi di risorse all'interno dello stesso servizio. In questi casi, l'inclusione di una chiave di condizione che si applica solo a una delle risorse nell'istruzione della policy può causare un errore dell'elemento `Condition` nell'istruzione della policy in modo tale che l'elemento `"Effect"` dell'istruzione non si applichi.
Ad esempio, considerare il seguente esempio di policy:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "THISPOLICYDOESNOTWORK",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {"StringLike": {"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]}}
}
}
```
------
Lo *scopo* della policy precedente è di consentire all'utente di avviare qualsiasi istanza di tipo `t1`, `t2` o `m3`. Tuttavia, l'avvio di un'istanza richiede l'accesso a molte risorse oltre all'istanza stessa; ad esempio, immagini, coppie di chiavi, gruppi di sicurezza e così via. L'intera istruzione viene valutata rispetto a ogni risorsa necessaria per avviare l'istanza. Queste risorse aggiuntive non includono la chiave di condizione `ec2:InstanceType`, pertanto il controllo `StringLike` ha esito negativo e all'utente non è concessa la possibilità di avviare *nessun* tipo di istanza.
Per risolvere questo problema, utilizzare l'operatore di condizione `StringLikeIfExists`. In questo modo, il test viene effettuato solo se la chiave di condizione esiste. È possibile leggere la policy seguente come: "Se la risorsa da verificare include una chiave di condizione "`ec2:InstanceType`", permettere l'operazione solo se il valore della chiave inizia con `t1.`, `t2.` o `m3.`. Se la risorsa verificata non include quella chiave di condizione, non preoccuparti". L'asterisco (\$1) nei valori della chiave della condizione, se utilizzato con l'operatore di condizione `StringLikeIfExists`, viene interpretato come un jolly per ottenere corrispondenze parziali tra le stringhe. L'istruzione `DescribeActions` include le azioni necessarie per visualizzare l'istanza nella console.
------
#### [ 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": "*"
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– t1.micro
| Match |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– m2.micro
| Nessuna corrispondenza |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | `ec2:InstanceType` non è presente nel contesto della richiesta. | Match |
## Operatore di condizione per verificare la presenza di chiavi di condizione
Utilizza un operatore di condizione `Null` per verificare se una chiave di condizione è presente o meno al momento dell'autorizzazione. Nell'istruzione della policy, utilizza `true` (la chiave non esiste, è null) o `false` (la chiave esiste e il suo valore non è null).
Puoi utilizzare una [variabile di policy](reference_policies_variables.md) con l'operatore di condizione `Null`.
Ad esempio, è possibile utilizzare questo operatore di condizione per determinare se un utente sta utilizzando credenziali temporanee oppure le proprie credenziali per effettuare una richiesta. Se l'utente utilizza credenziali temporanee, la chiave `aws:TokenIssueTime` è presente e ha un valore. L’esempio seguente mostra una condizione che indica che l’utente deve utilizzare credenziali temporanee (la chiave non può essere assente) affinché l’utente possa utilizzare l’API Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":{
"Action":"ec2:*",
"Effect":"Allow",
"Resource":"*",
"Condition":{"Null":{"aws:TokenIssueTime":"false"}}
}
}
```
------
# Condizioni con più chiavi di contesto o valori
Puoi utilizzare l'elemento `Condition` di una policy per testare più chiavi di contesto o valori per una singola chiave di contesto in una richiesta. Quando effettui una richiesta a AWS, a livello di codice o tramite Console di gestione AWS, la richiesta include informazioni sul tuo principale, sull'operazione, sui tag e altro ancora. Puoi utilizzare le chiavi di contesto per testare i valori delle chiavi di contesto corrispondenti nella richiesta, con le chiavi di contesto specificate nella condizione della policy. Per ulteriori informazioni e i dati inclusi in una richiesta, consulta [Il contesto della richiesta](reference_policies_elements_condition.md#AccessPolicyLanguage_RequestContext).
**Topics**
+ [Logica di valutazione per condizioni con più chiavi di contesto o valori](#reference_policies_multiple-conditions-eval)
+ [Logica di valutazione per gli operatori di negazione della condizione di corrispondenza](#reference_policies_multiple-conditions-negated-matching-eval)
## Logica di valutazione per condizioni con più chiavi di contesto o valori
Un elemento `Condition` può contenere più operatori di condizione e ciascun operatore di condizione può includere a sua volta più coppie chiave-valore. La maggior parte delle chiavi di contesto supporta l'utilizzo di più valori, se non diversamente specificato.
+ Se la tua policy contiene più [operatori di condizione](reference_policies_elements_condition_operators.md), questi vengono valutati utilizzando un `AND` logico.
+ Se la policy contiene più chiavi di contesto collegate a un singolo operatore di condizione, le chiavi di contesto vengono valutate utilizzando un `AND` logico.
+ Se un singolo operatore di condizione include valori multipli per una chiave di contesto, questi valori sono valutato con un `OR` logico.
+ Se un singolo operatore di condizione di corrispondenza negata include valori multipli per una chiave di contesto, questi valori vengono valutati con un `NOR` logico.
Tutte le chiavi di contesto in un blocco di elementi condizionali devono essere risolte in true per richiamare il `Allow` desiderato o l’effetto `Deny`. La figura seguente illustra la logica di valutazione per una condizione con più operatori di condizione e coppie chiave-valore di contesto.
![\[Blocco condizione che mostra in che modo AND e OR vengono applicati a più chiavi di contesto e valori\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_2.diagram.png)
Ad esempio, la seguente policy del bucket S3 illustra come la figura precedente è rappresentata in una policy. Il blocco condizione utilizza operatori di condizione `StringEquals` e `ArnLike` e chiavi di contesto `aws:PrincipalTag` e`aws:PrincipalArn`. Per richiamare l'effetto `Allow` o `Deny` desiderato, tutte le chiavi di contesto nel blocco di condizione devono restituire il valore true. L'utente che effettua la richiesta deve avere entrambe le chiavi tag principali, *dipartimento* e *ruolo*, che includono uno dei valori chiave dei tag specificati nella policy. Inoltre, l'ARN principale dell'utente che effettua la richiesta deve corrispondere a uno dei valori `aws:PrincipalArn` specificati nella policy da valutare come true.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| **Partita** |
| "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
| **Nessuna corrispondenza** |
| "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
| **Nessuna corrispondenza** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | `aws:PrincipalTag/role` non è presente nel contesto della richiesta. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Nessuna corrispondenza** |
| "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` non è presente nel contesto della richiesta. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Nessuna corrispondenza** |
## Logica di valutazione per gli operatori di negazione della condizione di corrispondenza
Alcuni [operatori di condizione,](reference_policies_elements_condition_operators.md) ad esempio `StringNotEquals` o `ArnNotLike`, usano la corrispondenza negata per confrontare le coppie chiave-valore di contesto nella tua policy con le coppie chiave-valore di contesto in una richiesta. Quando più valori sono elencati in una singola chiave di contesto in una policy con operatori di negazione della condizione di corrispondenza le autorizzazioni efficaci funzionano come un `NOR` logico. Nella corrispondenza negata, un `NOR` o `NOT OR` restituisce true solo se tutti i valori restituiscono false.
La figura seguente illustra la logica di valutazione per una condizione con più operatori di condizione e coppie chiave-valore di contesto. La figura include un operatore di negazione della condizione di corrispondenza per la chiave di contesto 3.
![\[Blocco di condizioni che mostra come AND e OR vengono applicati a più chiavi e valori di contesto quando viene utilizzato un operatore di negazione della condizione di corrispondenza.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_Negated_NOR_2.diagram.png)
Ad esempio, la seguente policy del bucket S3 illustra come la figura precedente è rappresentata in una policy. Il blocco condizione utilizza operatori di condizione `StringEquals` e `ArnNotLike` e chiavi di contesto `aws:PrincipalTag` e`aws:PrincipalArn`. Per richiamare l'effetto `Allow` o `Deny` desiderato, tutte le chiavi di contesto nel blocco di condizione devono restituire il valore true. L'utente che effettua la richiesta deve avere entrambe le chiavi tag principali, *dipartimento* e *ruolo*, che includono uno dei valori chiave dei tag specificati nella policy. Poiché l’operatore di condizione `ArnNotLike` utilizza la corrispondenza negata, l’ARN principale dell’utente che effettua la richiesta deve corrispondere a uno dei valori `aws:PrincipalArn` specificati nella policy da valutare come true.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| **Partita** |
| "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
| **Nessuna corrispondenza** |
| "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
| **Nessuna corrispondenza** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | >`aws:PrincipalTag/role` non è presente nel contesto della richiesta. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Nessuna corrispondenza** |
| "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` non è presente nel contesto della richiesta. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Nessuna corrispondenza** |
# Chiavi di contesto a valore singolo vs multivalore
La differenza tra le chiavi di contesto a valore singolo e multivalore dipende dal numero di valori nel [contesto della richiesta](intro-structure.md#intro-structure-request) e non dal numero di valori nella condizione della policy.
+ Le chiavi del contesto con condizione *a valore singolo* hanno al massimo un valore nel contesto della richiesta. Ad esempio, quando si etichettano le risorse AWS, ogni tag di risorsa viene memorizzato come coppia chiave-valore. Poiché una chiave di tag di risorsa può avere un solo valore di tag, [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) è una chiave di contesto a valore singolo. Non utilizzare operatori con una chiave di contesto a valore singolo.
+ Le chiavi di contesto con condizione *multivalore* possono avere più di un valore nel contesto della richiesta. Ad esempio, quando tagghi le risorse AWS, puoi includere più coppie chiave-valore di tag in un'unica richiesta. Pertanto, [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) è una chiave di contesto multivalore. Le chiavi di contesto multivalore richiedono un operatore di condizione.
Ad esempio, una richiesta può provenire al massimo da un endpoint VPC, quindi [aws:SourceVpce](reference_policies_condition-keys.md#condition-keys-sourcevpce) è una chiave di contesto a valore singolo. Poiché un servizio può avere più di un nome del principale di servizio appartenente al servizio, [aws:PrincipalServiceNamesList](reference_policies_condition-keys.md#condition-keys-principalservicenameslist) è una chiave di contesto multivalore.
**Importante**
La differenza tra le chiavi di contesto della condizione a valore singolo e multivalore dipende dal numero di valori nel contesto della richiesta e non dal numero di valori nella condizione della policy.
## Punti chiave
+ Le classificazione *valore singolo* e *multivalore* sono incluse nella descrizione di ciascuna chiave di contesto della condizione come *tipo di valore* nell'[AWS chiavi di contesto della condizione globale](reference_policies_condition-keys.md)argomento.
+ Le chiavi di contesto multivalore nella [documentazione di riferimento per l’autorizzazione del servizio](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) utilizzano un prefisso `ArrayOf` seguito dal tipo di categoria dell’operatore di condizione, come `ArrayOfString` o`ArrayOfARN`, che indica che la richiesta può includere più valori per una chiave di contesto della condizione.
+ Puoi utilizzare qualsiasi chiave di contesto a valore singolo disponibile come variabile di policy, ma non è possibile utilizzare una chiave di contesto multivalore come variabile di policy. Per ulteriori informazioni sulle variabili di policy, consultare [Elementi delle policy IAM: variabili e tag](reference_policies_variables.md).
+ Quando si utilizzano chiavi di contesto che includono coppie chiave-valore, è importante notare che anche se possono esserci più valori tag-chiave, ogni `tag-key` può avere un solo valore.
+ [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag), [aws:RequestTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-requesttag) e [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) sono chiavi di contesto a valore singolo.
+ [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) definisce quali tag-chiavi sono consentiti in una richiesta ma non include i valori tag-chiave. Poiché è possibile includere più coppie chiave-valore dei tag in una richiesta, `aws:TagKeys` è una chiave di contesto multivalore.
+ Le chiavi di contesto multivalore richiedono un operatore di condizione. Non utilizzare operatori di condizione `ForAllValues` o `ForAnyValue` chiavi di contesto a valore singolo. L'utilizzo di operatori di set di condizioni con chiavi di contesto a valore singolo può portare a policy eccessivamente permissive.
## Operatori dell’insieme per le chiavi di contesto multivalore
Per confrontare la chiave di contesto della condizione con una chiave di [contesto di richiesta](intro-structure.md#intro-structure-request) con più valori chiave, devi utilizzare gli operatori di insiemi `ForAllValues` o `ForAnyValue`. Questi operatori di insieme sono usati per paragonare due insiemi di valori, ad esempio il set di tag in una richiesta e il set di tag in una condizione della policy.
I qualificatori `ForAllValues` e `ForAnyValue` aggiungono funzionalità di operazione di insieme all'operatore di condizione, in modo che tu possa testare chiavi di contesto della richiesta multivalore con più chiavi di contesto multiple in una condizione della policy. Inoltre, se includi una chiave di contesto di stringa multivalore nella policy con un carattere jolly o una variabile, devi utilizzare anche l'[operatore di condizione](reference_policies_elements_condition_operators.md#Conditions_String) `StringLike`. I valori multipli delle chiavi di condizione devono essere racchiusi tra parentesi quadre come in un [array](reference_policies_grammar.md#policies-grammar-json), ad esempio `"Key2":["Value2A", "Value2B"]`.
### ForAllValues
Il qualificatore `ForAllValues` verifica se il valore di ogni membro del contesto della richiesta è corrispondente all’operatore di condizione che segue il qualificatore. La condizione restituisce `true` se ogni valore della chiave di contesto nella richiesta corrisponde a un valore della chiave di contesto nella policy. Restituisce `true` anche se non ci sono chiavi di contesto nella richiesta.
**Importante**
Fai attenzione se usi `ForAllValues` con un effetto `Allow` perché ciò può essere eccessivamente permissivo se la presenza di chiavi di contesto mancanti nel contesto della richiesta è imprevista. Dovresti sempre includere l’operatore di condizione [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) nella tua policy con un valore `false` per verificare se la chiave di contesto esiste e il suo valore non è Null. Per vedere un esempio, consulta [Controllo dell'accesso in base alle chiavi di tag](access_tags.md#access_tags_control-tag-keys).
#### Esempio ForAllValues di operatore set
Nell'esempio seguente, ForAllValues viene utilizzato con aws: TagKeys per consentire agli utenti di eliminare tag specifici assegnati a un'istanza EC2. Questa policy consente agli utenti di eliminare solo i tag `environment` e `cost-center`. Puoi eliminarli separatamente o insieme. I tag-chiavi nella richiesta devono corrispondere esattamente alle chiavi specificate nella policy.
------
#### [ 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"
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
| **Partita** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– cost-center
| **Incontro** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– cost-center
| **Incontro** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– dept
| **Nessuna corrispondenza** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | `aws:TagKeys` non è presente nel contesto della richiesta. | **Nessuna corrispondenza** |
Nota che nell’ultimo esempio, il risultato è “No Match” perché il controllo della condizione Null impedisce la corrispondenza quando manca la chiave di contesto. Questa è una best practice per evitare policy eccessivamente permissive.
### ForAnyValue
Il qualificatore `ForAnyValue` verifica se almeno un membro del set di valori di richiesta è corrispondente ad almeno un membro del set di valori delle chiavi di condizione della policy. La condizione restituisce `true` se uno qualsiasi dei valori della chiave di contesto nella richiesta corrisponde a un valore qualsiasi della chiave di contesto nella policy. Se non esiste alcuna chiave di contesto corrispondente o se la chiave non esiste, la condizione restituisce `false`.
**Importante**
Quando si usa `ForAnyValue` con un effetto `Deny`, se la chiave di contesto non è presente nella richiesta, la policy viene valutata come **Nessuna corrispondenza**. Per un comportamento coerente, aggiungi un controllo esplicito [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) delle condizioni nella tua policy per verificare se la chiave di contesto esiste. Per informazioni dettagliate, vedi [Operatore di condizione per verificare la presenza di chiavi di condizione](reference_policies_elements_condition_operators.md#Conditions_Null).
#### Esempio ForAnyValue di operatore di set
Nell'esempio seguente, ForAnyValue viene utilizzato con aws: TagKeys per consentire agli utenti di eliminare tag specifici assegnati a un'istanza EC2. Questa policy consente agli utenti di eliminare i tag di un’istanza se le chiavi di tag specificate nella richiesta includono `environment` o `cost-center`. La richiesta può includere chiavi di tag aggiuntive oltre a quelle specificate nella policy, ma deve includere almeno una delle chiavi specificate per soddisfare la condizione.
------
#### [ 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"
]
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
| **Partita** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– cost-center
| **Incontro** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– cost-center
| **Incontro** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– dept
| **Incontro** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– dept
| **Nessuna corrispondenza** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | `aws:TagKeys` non è presente nel contesto della richiesta. | **Nessuna corrispondenza** |
# Esempi di policy delle condizioni
Nelle policy IAM, puoi specificare più valori per chiavi di contesto sia a valore singolo che multivalore per il confronto con il contesto della richiesta. La seguente serie di esempi di policy mostra le condizioni delle policy con più chiavi e valori di contesto.
**Nota**
Per inviare una policy e includerla in questa guida di riferimento, utilizza il pulsante **Feedback** in fondo a questa pagina. Per esempi di policy basate su identità IAM, consulta [Esempi di policy basate su identità IAM](access_policies_examples.md).
## Esempi di policy relativi alle condizioni: chiavi di contesto a valore singolo
+ Più blocchi di condizioni con chiavi di contesto a valore singolo. ([Visualizza questo esempio](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-1).)
+ Un blocco di condizioni con più chiavi e valori di contesto a valore singolo. ([Visualizza questo esempio](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-2).)
## Esempi di policy relativi alle condizioni: chiavi di contesto multivalore
+ Policy di negazione con operatore del set di condizione `ForAllValues`. ([Visualizza questo esempio](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-1).)
+ Policy di negazione con operatore del set di condizione `ForAnyValue`. ([Visualizza questo esempio](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-2).)
# Esempi chiave di contesto multivalore
La seguente serie di esempi di policy mostra come creare condizioni politicy con chiavi di contesto multivalore.
## Esempio: politica di rifiuto con operatore di set di condizioni ForAllValues
Gli esempi seguenti mostrano come utilizzare una policy basata sull’identità per negare l’uso di operazioni di tagging IAM quando nella richiesta sono inclusi prefissi specifici della chiave di tag. I valori per [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) includono un carattere jolly (\$1) per la corrispondenza parziale delle stringhe. La policy include l’operatore dell’insieme `ForAllValues` con la chiave di contesto `aws:TagKeys` perché la chiave di contesto della richiesta può includere più valori. Affinché la chiave di contesto `aws:TagKeys` corrisponda, ogni valore nel contesto della richiesta deve corrispondere ad almeno un valore presente nella policy.
L’operatore dell’insieme `ForAllValues` restituisce True anche se non ci sono chiavi di contesto nella richiesta.
Puoi evitare che le chiavi di contesto mancanti o le chiavi di contesto con valori vuoti vengano valutate come True includendo un operatore di condizione `Null` nella tua policy con un valore `false` per verificare se la chiave di contesto nella richiesta esiste e il suo valore non è Null. Per ulteriori informazioni, consulta [Operatore di condizione per verificare la presenza di chiavi di condizione](reference_policies_elements_condition_operators.md#Conditions_Null).
**Importante**
Questa policy non consente alcuna operazione. Utilizza questa policy in combinazione con altre policy che consentono operazioni specifiche.
**Example Negazione di un singolo valore di condizione della policy per una chiave di contesto multivalore**
Nel seguente esempio, la policy nega le richieste in cui i valori di `aws:TagKeys` nella richiesta non includono il prefisso **key1**. Il contesto della richiesta può avere più valori, ma a causa dell’operatore dell’insieme di condizioni `ForAllValues`, tutti i valori chiave del tag nel contesto della richiesta devono iniziare con il prefisso **key1**.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
}
}
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta. Per un’istruzione Nega, una Corrispondenza è Negata e una Mancata corrispondenza è Non negata, quindi può essere consentita da un’altra istruzione.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:legal
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key2:audit
| **Partita** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | `aws:TagKeys` non è presente nel contesto della richiesta. | **Incontro** |
**Example Negazione di più valori di condizione della policy per una chiave di contesto multivalore**
Nell’esempio seguente, la policy nega le richieste in cui i valori `aws:TagKeys` della richiesta non includono il prefisso **key1** o **key2** Il contesto della richiesta può avere più valori, ma a causa dell’operatore dell’insieme di condizioni `ForAllValues`, tutti i valori chiave del tag nel contesto della richiesta devono iniziare con il prefisso **key1** o **key2**.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
}
}
}
]
}
```
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta. Per un’istruzione Nega, una Corrispondenza è Negata e una Mancata corrispondenza è Non negata, quindi può essere consentita da un’altra istruzione.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:legal
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key2:audit
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key3:legal
| **Partita** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | `aws:TagKeys` non è presente nel contesto della richiesta. | **Incontro** |
## Esempio: politica di rifiuto con operatore di set di condizioni ForAnyValue
Il seguente esempio di policy basata sull'identità nega la creazione di istantanee dei volumi di istanza EC2 se alcune istantanee sono contrassegnate con una delle chiavi di tag specificate nella policy,`environment`o`webserver`. La policy include l’operatore dell’insieme `ForAnyValue` con la chiave di contesto `aws:TagKeys` perché la chiave di contesto della richiesta può includere più valori. Se la richiesta di etichettatura include uno dei valori chiave dei tag specificati nella policy, la `aws:TagKeys` chiave di contesto restituisce true richiamando l'effetto della policy di negazione.
**Importante**
Questa policy non consente alcuna operazione. Utilizza questa policy in combinazione con altre policy che consentono operazioni specifiche.
------
#### [ 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"
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta. Per un’istruzione Nega, una Corrispondenza è Negata e una Mancata corrispondenza è Non negata, quindi può essere consentita da un’altra istruzione.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– webserver
| **Partita** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– webserver
– test
| **Incontro** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– test
| **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | `aws:TagKeys` non è presente nel contesto della richiesta. | **Nessuna corrispondenza** Può essere consentito da un’altra istruzione. |
# Esempi di policy della chiave di contesto a valore singolo
La seguente serie di esempi di policy mostra come creare condizioni nella policy con chiavi di contesto a valore singolo.
## Esempio: più blocchi di condizioni con chiavi di contesto a valore singolo
Quando un blocco di condizioni contiene più condizioni, ognuna con una singola chiave di contesto, tutte le chiavi di contesto devono risolversi in true per l’effetto `Allow` o `Deny` che si desidera richiamare. Quando si utilizzano operatori per la condizione di corrispondenza negata, la logica di valutazione del valore della condizione viene invertita.
Il seguente esempio consente agli utenti di creare volumi EC2 e applicare tag a tali volumi durante la creazione del volume. Il contesto della richiesta deve includere un valore per la chiave di contesto `aws:RequestTag/project` e il valore della chiave di contesto `aws:ResourceTag/environment` può essere qualsiasi cosa tranne la produzione.
------
#### [ 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"
}
}
}
]
}
```
------
Il contesto della richiesta deve includere un tag-valore del progetto e non può essere creato affinché una risorsa di produzione richiami l’effetto `Allow`. Il seguente volume EC2 è stato creato correttamente perché il nome del progetto è `Feature3` con un tag della risorsa `QA`.
```
aws ec2 create-volume \
--availability-zone us-east-1a \
--volume-type gp2 \
--size 80 \
--tag-specifications 'ResourceType=volume,Tags=[{Key=project,Value=Feature3},{Key=environment,Value=QA}]'
```
## Esempio: un blocco di condizioni con più chiavi di contesto a valore singolo
Quando un blocco di condizioni contiene più chiavi di contesto e ogni chiave di contesto ha valori multipli, ogni chiave di contesto deve risolversi in true in almeno un valore chiave per l’effetto `Allow` o `Deny` che si desidera richiamare. Quando si utilizzano operatori per la condizione di corrispondenza negata, la logica di valutazione del valore della chiave di contesto viene invertita.
L'esempio seguente consente agli utenti di avviare ed eseguire attività sui cluster Amazon Elastic Container Service.
+ Il contesto della richiesta deve includere`production` **O** `prod-backup` per la `aws:RequestTag/environment` chiave di contesto **E**.
+ La chiave di contesto `ecs:cluster` assicura che le attività vengano eseguite su entrambi i cluster `default1` **O** `default2` ARN ECS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecs:RunTask",
"ecs:StartTask"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
}
}
}
]
}
```
------
La tabella seguente mostra come AWS valuta questa politica in base ai valori della chiave di condizione nella richiesta.
| Condizione della policy | Contesto della richiesta | Risultato |
| --- | --- | --- |
| "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
| Nessuna corrispondenza |
| "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` non è presente nel contesto della richiesta. ecs:cluster
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Nessuna corrispondenza |