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à.
# Documentazione di riferimento degli elementi delle policy JSON IAM
I documenti delle policy JSON sono costituiti da elementi. Gli elementi vengono elencati qui nell'ordine generale in cui vengono utilizzati in una policy. L'ordine degli elementi non ha importanza, ad esempio l'elemento `Resource` può venire prima dell'elemento `Action`. Non devi specificare alcun elemento `Condition` nella policy. Per ulteriori informazioni sulla struttura generale e lo scopo di un documento di policy JSON, consulta la pagina [Panoramica delle policy JSON](access_policies.md#access_policies-json).
Alcuni elementi della policy JSON sono reciprocamente esclusivi. Questo significa che non puoi creare una policy che utilizza entrambi. Ad esempio, non è possibile utilizzare `Action` e `NotAction` nella stessa dichiarazione di policy. Altre coppie che si escludono reciprocamente sono `Principal`/`NotPrincipal` e `Resource`/`NotResource`.
I dettagli di ciò che va a comporre una policy variano per ciascun servizio, a seconda di quali operazioni il servizio rende disponibili, quali tipi di risorse contiene e così via. Quando stai scrivendo delle policy per un servizio specifico, è utile consultare esempi di policy per quel servizio. Per un elenco di tutti i servizi che supportano IAM e per i collegamenti alla documentazione di quei servizi che illustrano IAM e le policy, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md).
Quando crei o modifichi una policy JSON, IAM può eseguire la convalida delle policy per facilitare la creazione di una policy efficace. IAM identificherà gli errori di sintassi JSON, mentre IAM Access Analyzer fornisce ulteriori controlli delle policy con suggerimenti che consentono di perfezionare ulteriormente le policy. Per ulteriori informazioni sulla convalida delle policy, consulta [Convalida delle policy IAM](access_policies_policy-validator.md). Per ulteriori informazioni cui controlli delle policy di IAM Access Analyzer e sui suggerimenti utili, consulta [Convalida delle policy di IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html).
**Topics**
+ [Version](reference_policies_elements_version.md)
+ [Id](reference_policies_elements_id.md)
+ [Statement](reference_policies_elements_statement.md)
+ [Sid](reference_policies_elements_sid.md)
+ [Effect](reference_policies_elements_effect.md)
+ [Principal](reference_policies_elements_principal.md)
+ [NotPrincipal](reference_policies_elements_notprincipal.md)
+ [Action](reference_policies_elements_action.md)
+ [NotAction](reference_policies_elements_notaction.md)
+ [Resource](reference_policies_elements_resource.md)
+ [NotResource](reference_policies_elements_notresource.md)
+ [Condition](reference_policies_elements_condition.md)
+ [Variabili e tag](reference_policies_variables.md)
+ [Tipi di dati supportati](reference_policies_elements_datatypes.md)
# Elementi delle policy JSON IAM: Version
**Chiarimento**
Questo elemento della policy JSON `Version` è diverso da una *versione della policy*. L'elemento di policy `Version` viene utilizzato all'interno di una policy e definisce la versione del linguaggio di policy. Diversamente, una versione della policy viene creata quando si apportano modifiche alla policy gestita dal cliente in IAM. La policy modificata non viene sovrascritta a quella precedente. IAM crea invece una nuova versione della policy gestita. Per informazioni sul supporto per versioni multiple disponibile per le policy gestite, consultare [Controllo delle versioni delle policy IAM](access_policies_managed-versioning.md).
L'elemento della policy `Version` specifica le regole sintattiche di linguaggio che devono essere utilizzate per elaborare una policy. Per utilizzare tutte le funzionalità disponibili della policy, includi il seguente elemento `Version` **all'esterno** dell'elemento `Statement` in tutte le policy.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
IAM supporta i seguenti valori degli elementi `Version`:
+ `2012-10-17`. Questa è la versione corrente del linguaggio della policy e deve sempre includere un elemento `Version` ed essere impostato su `2012-10-17`. In caso contrario, non è possibile utilizzare caratteristiche come [variabili di policy](reference_policies_variables.md) introdotte con questa versione.
+ `2008-10-17`. Questa è una versione precedente del linguaggio della policy. Potresti vedere questa versione su policy esistenti meno recenti. Non utilizzare questa versione per le nuove policy o quando si aggiornano policy esistenti. Le caratteristiche più recenti, come variabili di policy, non funzioneranno con la tua policy. Ad esempio, le variabili tipo `${aws:username}` non saranno riconosciute come variabili e verranno trattate come stringhe letterali nella policy.
# Elementi delle policy JSON IAM: Id
L'elemento `Id` specifica un identificatore opzionale per la policy. L'ID viene utilizzato in modo diverso in servizi diversi. L'ID è consentito nelle policy basate su risorse, ma non nelle policy basate sulle identità.
Per i servizi che consentono di impostare un elemento `ID`, consigliamo di utilizzare un UUID (GUID) per il valore o incorporare un UUID come parte dell'ID per garantire l'univocità.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "cd3ad3d9-2776-4ef1-a904-4c229d1642ee",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
**Nota**
Alcuni AWS servizi (ad esempio Amazon SQS o Amazon SNS) potrebbero richiedere questo elemento e avere requisiti di unicità per esso. Per informazioni specifiche per servizio sulla scrittura di policy, consultare la documentazione per il servizio in uso.
# Elementi delle policy JSON IAM: Statement
L'elemento `Statement` è l'elemento principale per una policy. Questa elemento è obbligatorio. L'elemento `Statement` può contenere una singola istruzione o una matrice di singole istruzioni. Ogni singolo blocco di istruzioni deve essere racchiuso tra parentesi graffe \$1 \$1. In caso di istruzioni multiple, l'array deve essere racchiuso tra parentesi quadre [ ].
```
"Statement": [{...},{...},{...}]
```
L'esempio seguente mostra una policy che contiene una serie di tre istruzioni all'interno di un singolo elemento `Statement`. La policy consente di accedere alla propria "cartella home" nella console Amazon S3. La policy include la variabile `aws:username`, che viene sostituita durante la valutazione della policy con il nome utente dalla richiesta. Per ulteriori informazioni, consulta [Introduzione](reference_policies_variables.md#policy-vars-intro).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {"StringLike": {"s3:prefix": [
"",
"home/",
"home/${aws:username}/"
]}}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
]
}
]
}
```
------
# Elementi delle policy JSON IAM: Sid
Puoi fornire un `Sid` (ID istruzione) come identificativo facoltativo per l'istruzione della policy. Puoi assegnare un valore `Sid` a ogni istruzione in una matrice di istruzioni. È possibile utilizzare il valore `Sid` come descrizione per l'istruzione della policy. In servizi che consentono di specificare un elemento `ID`, ad esempio SQS e SNS, il valore `Sid` è semplicemente un ID secondario dell'ID del documento di policy. In IAM, il valore `Sid` deve essere univoco all'interno di una policy JSON.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExampleStatementID",
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
L'elemento `Sid` supporta lettere maiuscole ASCII (A-Z), lettere minuscole (a-z) e numeri (0-9).
IAM non utilizza il `Sid` nell'API IAM. Non puoi recuperare una determinata istruzione in base a questo ID.
**Nota**
Alcuni AWS servizi (ad esempio Amazon SQS o Amazon SNS) potrebbero richiedere questo elemento e avere requisiti di unicità per esso. Per informazioni specifiche del servizio sulla scrittura di policy, consulta la documentazione per il servizio in uso.
# Elementi delle policy JSON IAM: Effect
L'elemento `Effect` è obbligatorio e specifica se l'istruzione determina un consenso o un rifiuto esplicito. I valori validi di `Effect` sono `Allow` e `Deny`. Il valore `Effect` prevede la distinzione tra lettere maiuscole e minuscole.
```
"Effect":"Allow"
```
Come impostazione predefinita, l'accesso alle risorse è negato. Per consentire l'accesso a una risorsa, è necessario impostare l'elemento `Effect` su `Allow`. Per ignorare un consenso (ad esempio, per ignorare un consenso altrimenti valido), è necessario impostare l'elemento `Effect` su `Deny`. Per ulteriori informazioni, consulta [Logica di valutazione delle policy](reference_policies_evaluation-logic.md).
# AWS Elementi della policy JSON: Principal
Utilizzare l'elemento `Principal` in una policy JSON basata sulle risorse per specificare il principale a cui è consentito o negato l'accesso a una risorsa.
Nelle [policy basate sulle risorse](access_policies_identity-vs-resource.md) devi utilizzare l'elemento `Principal`. Diversi servizi supportano le policy basate sulle risorse, tra cui IAM. Il tipo di policy basata sulle risorse IAM è una policy di attendibilità del ruolo. Nei ruoli IAM, utilizza l'elemento `Principal` nella policy di attendibilità del ruolo per specificare chi può assumere il ruolo. Per l'accesso tra account, è necessario specificare l'identificatore a 12 cifre dell'account affidabile. Per capire se i principali negli account esterni alla zona di attendibilità (organizzazione o account attendibile) dispongono dell'accesso per assumere i ruoli, consulta [Cos'è IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).
**Nota**
Dopo aver creato il ruolo, è possibile modificare l'account in "\$1" per consentire a tutti di assumere il ruolo. In questo caso, è consigliabile limitare gli utenti che possono accedere al ruolo attraverso altri mezzi, ad esempio un elemento `Condition` che limita l'accesso solo a determinati indirizzi IP. Non permettere che il ruolo sia accessibile a tutti.
Altri esempi di risorse che supportano le policy basate sulle risorse includono un bucket Amazon S3 o AWS KMS key.
Non puoi usare l'elemento `Principal` in una policy basata su identità Le policy basate su identità sono policy di autorizzazione che si collegano a identità IAM (utenti, gruppi o ruoli). In questi casi, il principale è implicito nell'identità dove è collegata la policy.
**Topics**
+ [
## Come specificare un principale
](#Principal_specifying)
+ [
## Account AWS presidi
](#principal-accounts)
+ [
## Principali ruolo IAM
](#principal-roles)
+ [
## Principali della sessione come ruolo
](#principal-role-session)
+ [
## Principali federati OIDC
](#principal-federated-web-identity)
+ [
## Principali federati SAML
](#principal-saml)
+ [
## Principali dell'utente IAM
](#principal-users)
+ [
## Principi fondamentali di Centro identità IAM
](#principal-identity-users)
+ [
## AWS STS principi utente federati
](#sts-session-principals)
+ [
## AWS presidi del servizio
](#principal-services)
+ [
## AWS principali di servizio nelle regioni che accettano l'adesione
](#principal-services-in-opt-in-regions)
+ [
## Tutti i principali
](#principal-anonymous)
+ [
## Ulteriori informazioni
](#Principal_more-info)
## Come specificare un principale
È possibile specificare un principale nell'elemento `Principal` di una policy basata sulle risorse o in chiavi di condizione che supportano i principali.
In una policy è possibile specificare una delle seguenti entità:
+ Account AWS e utente root
+ Ruoli IAM
+ Sessioni come ruolo
+ Utenti IAM
+ Principali utente federato
+ AWS servizi
+ Tutti i principali
Non è possibile identificare un gruppo di utenti come principale in una policy (ad esempio una policy basata sulle risorse) perché i gruppi si riferiscono alle autorizzazioni, non all'autenticazione, e i principali sono entità IAM autenticate.
È possibile specificare più di un principale per ciascuno dei tipi di entità nelle sezioni seguenti utilizzando un array. Gli array possono richiedere uno o più valori. Quando si specifica più di un principale in un elemento, si concedono le autorizzazioni a ciascun principale. Questo è un `OR` logico e non un `AND` logico, perché si viene autenticati come un principale alla volta. Se includi più di un valore, utilizza parentesi quadre (`[` e `]`) e delimita con le virgole ogni voce per l'array. La seguente policy di esempio definisce le autorizzazioni per l'account 123456789012 o per l'account 555555555555.
```
"Principal" : {
"AWS": [
"123456789012",
"555555555555"
]
}
```
**Nota**
Non è possibile utilizzare un carattere jolly per associare parte di un nome di un principale o di un ARN.
## Account AWS presidi
È possibile specificare Account AWS gli identificatori nell'`Principal`elemento di una politica basata sulle risorse o nelle chiavi di condizione che supportano i principali. In questo modo l'autorità viene delegata all'account. Quando consenti l'accesso a un altro account, un amministratore di tale account deve concedere l'accesso a un'identità (utente o ruolo IAM) in tale account. Quando si specifica un Account AWS, è possibile utilizzare l'account ARN (arn:aws:iam: :root*account-ID*) o un modulo abbreviato costituito dal prefisso seguito dall'ID dell'account. `"AWS":`
Ad esempio, fornendo un account ID di `123456789012`, è possibile utilizzare uno dei seguenti metodi per specificare l'account nell'elemento `Principal`:
```
"Principal": { "AWS": "arn:aws:iam::123456789012:root" }
```
```
"Principal": { "AWS": "123456789012" }
```
L'ARN dell'account e l'ID dell'account abbreviato si comportano allo stesso modo: entrambi delegano le autorizzazioni all'account. L'utilizzo dell'ARN dell'account nell'elemento `Principal` non limita le autorizzazioni solo per l'utente root dell'account.
**Nota**
Quando salvi una policy basata sulle risorse che include l'ID dell'account abbreviato, il servizio potrebbe convertirlo nell'ARN del principale. Ciò non modifica la funzionalità della policy.
Alcuni AWS servizi supportano opzioni aggiuntive per specificare l'intestazione di un account. Ad esempio, Amazon S3 ti consente di specificare un [ID utente canonico](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId) utilizzando il formato seguente:
```
"Principal": { "CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be" }
```
È inoltre possibile specificarne più di uno Account AWS(o un ID utente canonico) come principale utilizzando un array. Ad esempio, è possibile specificare un principale in una policy del bucket utilizzando tutti e tre i metodi.
```
"Principal": {
"AWS": [
"arn:aws:iam::123456789012:root",
"999999999999"
],
"CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be"
}
```
## Principali ruolo IAM
È possibile specificare il ruolo principale IAM ARNs nell'`Principal`elemento di una policy basata sulle risorse o nelle chiavi di condizione che supportano i principali. I ruoli IAM sono identità. In IAM, le identità sono risorse a cui è possibile assegnare autorizzazioni. I ruoli si affidano a un'altra identità autenticata per assumere tale ruolo. Ciò include un principale in AWS o un utente di un provider di identità esterno (IdP). Quando un principal o un'identità assume un ruolo, ricevono credenziali di sicurezza temporanee con le autorizzazioni del ruolo assunto. *Quando utilizzano tali credenziali di sessione per eseguire operazioni in AWS, diventano responsabili della sessione di ruolo.*
Quando si specifica un principale del ruolo in una policy basata sulle risorse, le autorizzazioni effettive per il principale sono limitate da qualsiasi tipo di policy che limita le autorizzazioni per il ruolo. Ciò include le policy di sessione e i limiti delle autorizzazioni. Per ulteriori informazioni su come vengono valutate le autorizzazioni effettive per una sessione come ruolo, consulta [Logica di valutazione delle policy](reference_policies_evaluation-logic.md).
Per specificare l'ARN del ruolo nell'elemento `Principal`, utilizza questo formato:
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:role/role-name" }
```
**Importante**
Se l’elemento `Principal` in una policy di attendibilità del ruolo contiene un ARN che punta a un determinato ruolo IAM, allora l’ARN si trasforma nell’ID principale univoco del ruolo quando si salva la policy. Ciò aiuta a mitigare il rischio che qualcuno aumenti i propri privilegi rimuovendo e ricreando il ruolo. Questa ID nella console non è normalmente presente, in quanto IAM usa una trasformazione inversa verso l'ARN del ruolo quando la policy di affidabilità viene visualizzata. Tuttavia, se si elimina il ruolo, la relazione viene interrotta. La policy non è più applicabile, anche se si ricrea il ruolo perché il nuovo ruolo ha un nuovo ID principale che non corrisponde all'ID principale archiviato nella policy di affidabilità. Quando ciò accade, l'ID principale viene visualizzato nelle politiche basate sulle risorse perché non è più AWS possibile mapparlo su un ARN valido. Il risultato finale è che se si elimina e si ricrea un ruolo referenziato in un elemento `Principal` della policy di attendibilità, è necessario modificare il ruolo nella policy per sostituire l'ID principale con il nome ARN corretto. L'ARN si trasforma nuovamente nel nuovo ID principale del ruolo quando si salva la policy. Per ulteriori informazioni, consulta [Understanding sulla gestione AWS dei ruoli IAM eliminati](https://repost.aws/articles/ARSqFcxvd7R9u-gcFD9nmA5g/understanding-aws-s-handling-of-deleted-iam-roles-in-policies) nelle politiche.
In alternativa, è possibile specificare il principale del ruolo come principale in una policy basata sulle risorse oppure [creare una policy di ampia autorizzazione](#principal-anonymous) che usa la chiave di condizione `aws:PrincipalArn`. Quando si utilizza questa chiave, al principale della sessione come ruolo vengono concesse le autorizzazioni in base all'ARN del ruolo assunto e non all'ARN della sessione risultante. Poiché AWS non converte la chiave ARNs di condizione in IDs, le autorizzazioni concesse al ruolo ARN persistono se si elimina il ruolo e quindi si crea un nuovo ruolo con lo stesso nome. I tipi di policy basati su identità, come i limiti delle autorizzazioni o le policy di sessione, non limitano le autorizzazioni concesse tramite la chiave di condizione `aws:PrincipalArn` con un carattere jolly (\$1) nell'elemento `Principal`, a meno che le policy basate su identità non contengano un rifiuto esplicito.
## Principali della sessione come ruolo
È possibile specificare le sessioni come ruolo nell'elemento `Principal` di una policy basata sulle risorse o in chiavi in condizione che supportano i principali. Quando un principal o un'identità assume un ruolo, ricevono credenziali di sicurezza temporanee con le autorizzazioni del ruolo assunto. *Quando utilizzano tali credenziali di sessione per eseguire operazioni AWS, diventano responsabili della sessione di ruolo.*
Il formato utilizzato per un responsabile della sessione di ruolo dipende dall' AWS STS operazione utilizzata per assumere il ruolo.
**Importante**
AWS consiglia di utilizzare i [role principal IAM](#principal-roles) nelle policy anziché quelli delle sessioni di ruolo, laddove possibile. Se necessario, utilizza `Condition` istruzioni e chiavi di condizione per definire ulteriormente l'accesso.
Per specificare l'ARN principale della sessione di ruolo nell'`Principal`elemento, utilizzate il seguente formato:
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:assumed-role/role-name/role-session-name" }
```
Inoltre, gli amministratori possono progettare un processo per controllare il modo di emissione delle sessioni come ruolo. Ad esempio, possono fornire una soluzione con un clic per gli utenti che creano un nome della sessione prevedibile. Se l'amministratore compie questa operazione, è possibile utilizzare i principali della sessione come ruolo nelle policy o nelle chiavi di condizione. In caso contrario, è possibile specificare l'ARN del ruolo come principale nella chiave di condizione `aws:PrincipalArn`. Il modo in cui si specifica il ruolo come principale può modificare le autorizzazioni effettive per la sessione risultante. Per ulteriori informazioni, consulta [Principali ruolo IAM](#principal-roles).
## Principali federati OIDC
Un principal federato OIDC è il principale utilizzato quando si chiama l' AWS STS `AssumeRoleWithWebIdentity`API con un token web JSON (JWT) da un IDP conforme a OIDC, noto anche come OpenID Provider (OP), per richiedere credenziali temporanee. AWS [Un principal federato OIDC può rappresentare un IDP OIDC nel tuo AWS account o i 4 provider di identità integrati:Login with Amazon,, e Amazon Cognito. GoogleFacebook](https://docs.aws.amazon.com/cognito/latest/developerguide/role-based-access-control.html)
Gli utenti, i carichi di lavoro o i sistemi a cui è stato rilasciato un JWT dal proprio IDP OIDC possono effettuare chiamate `AssumeRoleWithWebIdentity` utilizzando JWT per richiedere credenziali di AWS sicurezza temporanee per un ruolo IAM configurato per considerare attendibile l'IDP OIDC che ha emesso il JWT. Il JWT può essere un ID token, un token di accesso o un token JWT fornito con qualsiasi altro metodo purché soddisfi i [requisiti elencati da AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-prerequisites). Per ulteriori informazioni, consulta [Scenari comuni](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_federation_common_scenarios.html) e [Richiesta di credenziali tramite un provider OIDC](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).
Utilizza questo tipo principale nella tua policy di affidabilità dei ruoli per consentire o negare le autorizzazioni alle chiamate `AssumeRoleWIthWebIdentity` utilizzando un IDP OIDC esistente nel tuo o uno dei quattro integrati. Account AWS IDPs Per specificare l'ARN principale federato OIDC nell'`Principal`elemento di una policy di trust dei ruoli, utilizza uno dei seguenti quattro formati per l'OIDC integrato: IDPs
```
"Principal": { "Federated": "cognito-identity.amazonaws.com" }
```
```
"Principal": { "Federated": "www.amazon.com" }
```
```
"Principal": { "Federated": "graph.facebook.com" }
```
```
"Principal": { "Federated": "accounts.google.com" }
```
Quando utilizzi un provider OIDC che aggiungi al tuo account, ad esempio, specifichi l'ARN del provider nella politica di fiducia del tuo ruolo. GitHub Questa configurazione ti consente di scrivere policy IAM che controllano l’accesso in modo specifico per gli utenti autenticati tramite il tuo provider di identità personalizzato.
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/full-OIDC-identity-provider-URL" }
```
Ad esempio, se GitHub è il provider di identità web attendibile, l’ARN della sessione del ruolo OIDC nell’elemento `Principal` di una policy di attendibilità dei ruoli utilizza il seguente formato:
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/tokens.actions.githubusercontent.com" }
```
Per ulteriori informazioni, consulta [Configuring OpenID Connect in Amazon Web Services](https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services).
I principali federati OIDC non sono supportati in tipi di policy diversi dalle policy di attendibilità dei ruoli.
## Principali federati SAML
Un principale *federato SAML è un principale* utilizzato quando si chiama l' AWS STS `AssumeRoleWithSAML`API per richiedere AWS credenziali temporanee utilizzando un'asserzione SAML. È possibile utilizzare un gestore dell’identità digitale (IdP) SAML esterno per accedere e quindi assumere un ruolo IAM utilizzando questa operazione. Simile a`AssumeRoleWithWebIdentity`, `AssumeRoleWithSAML` non richiede credenziali per l'autenticazione. AWS Invece, gli utenti si autenticano prima con il proprio provider di identità SAML, quindi effettuano la chiamata `AssumeRoleWithSAML` API utilizzando la loro asserzione SAML o vengono reindirizzati alla pagina di accesso/SAML per AWS accedere a. Console di gestione AWS Per ulteriori informazioni su quali principali possono assumere un ruolo utilizzando questa operazione, consulta [Confronta le AWS STS credenziali](id_credentials_sts-comparison.md).
Utilizza questo tipo di principale nella policy di attendibilità del ruolo per consentire o negare l’autorizzazione in base al provider di identità SAML attendibile. Per specificare l'ARN della sessione del ruolo dell'identità Web nell'elemento `Principal` di una policy di attendibilità dei ruoli, utilizza questo formato:
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:saml-provider/provider-name" }
```
## Principali dell'utente IAM
Puoi specificare gli utenti IAM nell'elemento `Principal` di una policy basata sulle risorse o nelle chiavi della condizione che supportano i principali.
**Nota**
In un elemento `Principal`, la parte del nome utente dell'[*Amazon Resource Name*(ARN)](reference_identifiers.md#identifiers-arns) fa distinzione tra maiuscole e minuscole.
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:user/user-name" }
```
```
"Principal": {
"AWS": [
"arn:aws:iam::AWS-account-ID:user/user-name-1",
"arn:aws:iam::AWS-account-ID:user/user-name-2"
]
}
```
Quando si specificano gli utenti in un elemento `Principal`, non è possibile utilizzare un carattere jolly (`*`) che indica "tutti gli utenti". I principali devono sempre nominare utenti determinati.
**Importante**
Se l'elemento `Principal` in una policy di attendibilità del ruolo contiene un nome ARN che punta a un determinato utente o IAM, allora IAM trasforma l'ARN nell'ID principale univoco dell'utente quando la policy viene salvata. Ciò aiuta a mitigare il rischio che qualcuno aumenti i propri privilegi rimuovendo e ricreando il ruolo o l'utente. Questa ID nella console non è normalmente presente, in quanto c'è anche una trasformazione inversa verso il nome ARN dell'utente quando la policy di affidabilità viene visualizzata. Tuttavia, se si elimina l'utente, la relazione viene interrotta. La policy non è più applicabile, anche se viene ricreato l'utente. Questo perché il nuovo utente ha un nuovo ID principale che non corrisponde all'ID archiviato nella policy di affidabilità. Quando ciò accade, l'ID principale viene visualizzato nelle politiche basate sulle risorse perché non è più AWS possibile mapparlo su un ARN valido. Il risultato è che se si elimina e si ricrea un utente o referenziato in un elemento `Principal` della policy di attendibilità, è necessario modificare il ruolo per sostituire l'ID principale non corretto con il nome ARN corretto. IAM trasforma nuovamente l'ARN nel nuovo ID principale dell'utente quando si salva la policy.
## Principi fondamentali di Centro identità IAM
In Centro identità IAM, il principio di una policy basata sulle risorse deve essere definito come principale dell' Account AWS . Per specificare l'accesso, fai riferimento all'ARN del ruolo del set di autorizzazioni nel blocco delle condizioni. Per ulteriori dettagli, consulta la sezione [Referenziare i set di autorizzazioni nelle policy delle risorse, in Amazon EKS e in AWS KMS](https://docs.aws.amazon.com/singlesignon/latest/userguide/referencingpermissionsets.html) nella *Guida per l'utente di Centro identità IAM*.
## AWS STS principi utente federati
È possibile specificare le *sessioni come utente federato* nell'elemento `Principal` di una policy basata sulle risorse o in chiavi di condizione che supportano i principali.
**Importante**
AWS consiglia di limitare l'uso delle sessioni utente AWS STS federate. Invece, promuove l’uso di [ruoli IAM](IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).
Un user principal AWS STS federato viene creato tramite l'`GetFederationToken`operazione richiamata con credenziali IAM di lunga durata. Le autorizzazioni dell’utente federato sono l’intersezione tra il principale che ha effettuato la chiamata `GetFederationToken` e le policy della sessione passate come parametri all’API `GetFederationToken`.
In AWS, gli utenti IAM o un utente Utente root dell'account AWS possono autenticarsi utilizzando chiavi di accesso a lungo termine. Per ulteriori informazioni su quali principali possono eseguire la federazione utilizzando questa operazione, consulta [Confronta le AWS STS credenziali](id_credentials_sts-comparison.md).
+ **Utente federato IAM**: un utente IAM esegue la federazione utilizzando l’operazione `GetFederationToken`, che si traduce in una sessione come utente federato per quell’utente IAM.
+ **Utente root federato**: un utente root esegue la federazione usando l’operazione `GetFederationToken`, che si traduce in una sessione come utente federato per quell’utente root.
Quando un utente IAM o un utente root richiede credenziali temporanee per AWS STS utilizzare questa operazione, inizia una sessione utente federata temporanea. L'ARN di questa sessione si basa sull'identità originale federata.
Per specificare l'ARN della sessione come utente federato nell'elemento `Principal`, utilizza questo formato:
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:federated-user/user-name" }
```
## AWS presidi del servizio
È possibile specificare AWS i servizi nell'`Principal`elemento di una politica basata sulle risorse o in chiavi di condizione che supportano i principali. Un *principale del servizio* è un identificatore per un servizio.
*[I ruoli IAM che possono essere assunti da un AWS servizio sono chiamati ruoli di servizio.](id_roles.md#iam-term-service-role)* I ruoli di servizio devono includere una policy di affidabilità. Le *Policy di affidabilità* sono policy basate su risorse collegate a un ruolo che definisce quali principali possono assumere il ruolo. Alcuni ruoli di servizio hanno policy di affidabilità predefinite. Tuttavia, in alcuni casi, è necessario specificare il principale del servizio nella policy di affidabilità. Il principale del servizio in una policy IAM non può essere `"Service": "*"`.
**Importante**
L'identificatore di un principale del servizio include il nome del servizio ed è solitamente nel formato seguente:
`service-name.amazonaws.com`
Il principale del servizio è definito dal servizio. Puoi trovare il principale del servizio aprendo [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md), controllando se il servizio ha impostato **Sì** nella colonna **Ruolo collegato ai servizi** e aprendo il collegamento **Sì** per visualizzare la documentazione del ruolo collegato a tale servizio. Trova la sezione **Autorizzazioni del ruolo collegato ai servizi** per quel servizio per visualizzare il principale del servizio
L'esempio seguente mostra una policy che può essere collegata a un ruolo del servizio. Questa policy consente a due servizi, Amazon ECS e Elastic Load Balancing, di assumere il ruolo. I servizi possono eseguire qualsiasi attività concesse da una policy di autorizzazioni assegnata al ruolo (non visualizzato). Per specificare più principali del servizio, non si specificano due elementi `Service`, è possibile averne solo uno. Utilizzare invece una serie di principali del servizio come il valore di un elemento singolo `Service`.
```
"Principal": {
"Service": [
"ecs.amazonaws.com",
"elasticloadbalancing.amazonaws.com"
]
}
```
## AWS principali di servizio nelle regioni che accettano l'adesione
Puoi lanciare risorse in diverse AWS regioni e in alcune di esse devi aderire. Per un elenco completo delle regioni a cui devi aderire, consulta [Gestire AWS le regioni](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) nella *Riferimenti generali di AWS*guida.
Quando un AWS servizio in una regione opt-in effettua una richiesta all'interno della stessa regione, il formato del nome principale del servizio viene identificato come la versione non regionalizzata del nome principale del servizio:
`service-name.amazonaws.com`
Quando un AWS servizio in una regione opt-in invia una richiesta interregionale a un'altra regione, il formato del nome principale del servizio viene identificato come la versione regionalizzata del nome principale del servizio:
`service-name.{region}.amazonaws.com`
Ad esempio, si consideri un argomento Amazon SNS situato nella Regione `ap-southeast-1` e un bucket Amazon S3 nella Regione di adesione `ap-east-1`. Supponiamo che si desideri configurare le notifiche bucket S3 per pubblicare messaggi nell'argomento SNS. Per consentire al servizio S3 di inviare messaggi all'argomento SNS, è necessario concedere l'autorizzazione `sns:Publish` del principale del servizio S3 tramite la policy di accesso basata sulle risorse dell'argomento.
Se si specifica la versione non regionalizzata del principale del servizio S3 `s3.amazonaws.com`, nella policy di accesso all'argomento, la richiesta `sns:Publish` dal bucket all'argomento avrà esito negativo. L'esempio seguente specifica il principale del servizio S3 non regionalizzato nell'elemento della policy `Principal` della policy di accesso all'argomento SNS.
```
"Principal": { "Service": "s3.amazonaws.com" }
```
Poiché il bucket si trova in una regione di adesione e la richiesta viene effettuata al di fuori della stessa regione, il principale del servizio S3 appare come nome del principale del servizio regionalizzato, `s3.ap-east-1.amazonaws.com`. È necessario utilizzare il nome principale del servizio regionalizzato quando un AWS servizio in una regione opt-in invia una richiesta a un'altra regione. Dopo aver specificato il nome del principale del servizio regionalizzato, se il bucket effettua una richiesta `sns:Publish` all'argomento SNS situato in un'altra regione, la richiesta avrà esito positivo. L'esempio seguente specifica il principale del servizio S3 regionalizzato nell'elemento della policy `Principal` della policy di accesso all'argomento SNS.
```
"Principal": { "Service": "s3.ap-east-1.amazonaws.com" }
```
Le policy di risorse o gli elenchi di autorizzazioni basati sui principali dei servizi per le richieste tra regioni da una regione di adesione a un'altra regione avranno esito positivo solo se si specifica il nome del principale del servizio regionalizzato.
**Nota**
Per le policy di attendibilità dei ruoli IAM, consigliamo di utilizzare il nome del principale del servizio non regionalizzato. Le risorse IAM sono globali e quindi lo stesso ruolo può essere utilizzato in qualsiasi regione.
## Tutti i principali
Puoi utilizzare un carattere jolly (\$1) per specificare tutti i principali nell'elemento `Principal` di una policy basata sulle risorse o nelle chiavi della condizione che supportano tali entità. [Policy basate sulle risorse](access_policies.md#policies_resource-based) *concedono* le autorizzazioni e le [chiavi della condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) vengono utilizzate per limitare le condizioni di un'istruzione della policy.
**Importante**
Ti consigliamo di non utilizzare un carattere jolly (\$1) nell'elemento `Principal` di una policy basata sulle risorse con un effetto `Allow` a meno che tu non intenda concedere un accesso pubblico o anonimo. In caso contrario, specifica i principali, i servizi o gli account AWS previsti nell'elemento `Principal`, quindi limita ulteriormente l'accesso nell'elemento `Condition`. Ciò vale in special modo per le policy di attendibilità del ruolo IAM, perché consentono ad altri principali di diventare un principale nel tuo account.
Per le policy basate sulle risorse, l'utilizzo di un carattere jolly (\$1) con un effetto `Allow` concede l'accesso a tutti gli utenti, compresi gli utenti anonimi (accesso pubblico). Per gli utenti IAM e i principali del ruolo all'interno del tuo account non sono richieste altre autorizzazioni. Per i principali di altri account, devono inoltre disporre di autorizzazioni basate su identità nel proprio account che consentano loro di accedere alla tua risorsa. Questo è chiamato [accesso tra account](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html).
Per gli utenti anonimi, i seguenti elementi sono equivalenti:
```
"Principal": "*"
```
```
"Principal" : { "AWS" : "*" }
```
Non è possibile utilizzare un carattere jolly per associare parte di un nome di un principale o di un ARN.
L'esempio seguente mostra una policy basata sulle risorse che può essere utilizzata al posto di [AWS Elementi della policy JSON: NotPrincipal](reference_policies_elements_notprincipal.md) per negare esplicitamente tutti i principali, *eccetto* quelli specificati nell'elemento `Condition`. Questa policy deve essere [aggiunta a un bucket Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/add-bucket-policy.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "UsePrincipalArnInsteadOfNotPrincipalWithDeny",
"Effect": "Deny",
"Action": "s3:*",
"Principal": "*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:user/user-name"
}
}
}
]
}
```
------
## Ulteriori informazioni
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Esempi di policy di bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html) nella *Guida per l'utente di Amazon Simple Storage Service (Amazon S3)*
+ [Policy di esempio per Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/UsingIAMwithSNS.html#ExamplePolicies_SNS) nella *Guida per gli sviluppatori di Amazon Simple Notification Service*
+ [Policy di esempio per Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSExamples.html) nella *Guida per gli sviluppatori di Amazon Simple Queue Service*
+ [Policy delle chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) nella *Guida per gli sviluppatori di AWS Key Management Service *
+ [Identificatori di account](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) nella *Riferimenti generali di AWS*
+ [Federazione OIDC](id_roles_providers_oidc.md)
# AWS Elementi della policy JSON: NotPrincipal
L’elemento `NotPrincipal` utilizza `"Effect":"Deny"` per negare l’accesso a tutti i principali ***tranne*** il principale specificato nell’elemento `NotPrincipal`. Un principale può essere un utente IAM, un utente AWS STS federato, un ruolo IAM, una sessione di ruolo presunta Account AWS, un AWS servizio o un altro tipo principale. Per ulteriori informazioni sui principali, consulta [AWS Elementi della policy JSON: Principal](reference_policies_elements_principal.md).
`NotPrincipal` deve essere usato con `"Effect":"Deny"`. L'uso con `"Effect":"Allow"` non è supportato.
**Importante**
Si sconsiglia l’uso di `NotPrincipal` per nuove policy basate sulle risorse come parte della strategia di sicurezza e autorizzazione. Quando utilizzi `NotPrincipal`, la risoluzione dei problemi legati agli effetti di più tipi di policy può essere difficile. Con gli operatori di condizione ARN, si consiglia invece di utilizzare la chiave di contesto `aws:PrincipalArn`.
## Punti chiave
+ L’elemento `NotPrincipal` è supportato nelle policy basate sulle risorse per alcuni servizi AWS , tra cui gli endpoint VPC. Le policy basate su risorse sono policy che vengono incorporate direttamente in una risorsa. Non puoi utilizzare l'elemento `NotPrincipal` in una policy basata sull'identità IAM o in una policy di attendibilità del ruolo IAM.
+ Non utilizzare istruzioni di policy basate sulle risorse che includono un elemento di policy `NotPrincipal` con effetto `Deny` per gli utenti o i ruoli IAM ai quali è collegata una policy con limite delle autorizzazioni. L'elemento `NotPrincipal` con effetto `Deny` rifiuterà sempre qualsiasi principale IAM al quale è collegata una policy con limite delle autorizzazioni, indipendentemente dai valori specificati nell'elemento `NotPrincipal`. Ciò fa sì che alcuni utenti o ruoli IAM che altrimenti avrebbero accesso alla risorsa perdano l'accesso. Ti consigliamo di modificare le istruzioni di policy basate sulle risorse di modo che, per limitare l'accesso, utilizzino l'operatore di condizione [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN) con la chiave di contesto [`aws:PrincipalArn`](reference_policies_condition-keys.md#condition-keys-principalarn) anziché l'elemento `NotPrincipal`. Per ulteriori informazioni sui limiti delle autorizzazioni, consulta la pagina [Limiti delle autorizzazioni per le entità IAM](access_policies_boundaries.md).
+ Quando si utilizza `NotPrincipal`, è necessario specificare anche l’ARN dell’account del principale non rifiutato. In caso contrario, la policy potrebbe rifiutare l'accesso all'intero account contenente il principale. A seconda del servizio che si include nella policy, AWS potrebbe convalidare prima l'account e poi l'utente. Se viene valutato un utente con ruolo presunto (qualcuno che utilizza un ruolo), AWS potrebbe convalidare prima l'account, poi il ruolo e poi l'utente assunto. L'utente con ruolo assunto viene identificato tramite il nome della sessione del ruolo specificato quando l'utente ha assunto il ruolo. Pertanto, è fortemente consigliabile includere esplicitamente l'ARN di un account utente oppure includere sia l'ARN di un ruolo sia l'ARN dell'account che contiene quel ruolo.
+ L’elemento `NotPrincipal` non è supportato nelle policy di controllo dei servizi (SCP) e nelle policy di controllo delle risorse (RCP).
## Alternative all’elemento `NotPrincipal`
Quando si gestisce il controllo degli accessi in AWS, può verificarsi la necessità di negare esplicitamente a tutti i responsabili l'accesso a una risorsa, ad eccezione di uno o più principali specificati dall'utente. AWS consiglia di utilizzare un'istruzione Deny con tasti contestuali delle condizioni globali per un controllo più preciso e una risoluzione dei problemi più semplice. Gli esempi seguenti mostrano approcci alternativi che utilizzano operatori di condizione come `StringNotEquals` o `ArnNotEquals` per negare l’accesso a tutti i principali, ad eccezione di quelli specificati nell’elemento Condizione.
## Scenario di esempio che utilizza un ruolo IAM
Puoi utilizzare una policy basata sulle risorse con un’istruzione Nega per impedire a tutti i ruoli IAM, ad eccezione di quelli specificati nell’elemento Condizione, di accedere alle tue risorse o di manipolarle. Questo approccio segue il principio AWS di sicurezza secondo cui un'esplicita deny ha sempre la precedenza su qualsiasi istruzione di autorizzazione e aiuta a mantenere il principio del privilegio minimo nell'infrastruttura. AWS
Invece di usare `NotPrincipal`, consigliamo di utilizzare un’istruzione Nega con chiavi di contesto di condizione globali e l’operatore di condizione come [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN) per consentire esplicitamente a un ruolo IAM l’accesso alle tue risorse. L’esempio seguente impiega [aws:PrincipalArn](reference_policies_condition-keys.md#condition-keys-principalarn) per consentire esplicitamente al ruolo `read-only-role` di accedere ai bucket Amazon S3 nella cartella `Bucket_Account_Audit`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyCrossAuditAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::Bucket_Account_Audit",
"arn:aws:s3:::Bucket_Account_Audit/*"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:role/read-only-role"
}
}
}
]
}
```
------
## Scenario di esempio che utilizza un principale del servizio
È possibile utilizzare un’istruzione Nega per impedire a tutti i principali del servizio, ad eccezione di quelli specificati nell’elemento `Condition`, di accedere alle risorse o di manipolarle. Questo approccio è particolarmente utile quando è necessario implementare controlli di accesso granulari o stabilire limiti di sicurezza tra diversi servizi e applicazioni nell’ambiente AWS .
Invece di usare `NotPrincipal`, consigliamo di utilizzare un’istruzione Nega con chiavi di contesto di condizione globali e l’operatore di condizione [`StringNotEquals`](reference_policies_elements_condition_operators.md#Conditions_String) per consentire esplicitamente a un principale del servizio l’accesso alle tue risorse. L’esempio seguente impiega `aws:PrincipalServiceName` per consentire esplicitamente al principale del servizio AWS CodeBuild di accedere ai bucket Amazon S3 nella cartella `BUCKETNAME`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyNotCodeBuildAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::BUCKETNAME",
"arn:aws:s3:::BUCKETNAME/*"
],
"Condition": {
"StringNotEqualsIfExists": {
"aws:PrincipalServiceName": "codebuild.amazonaws.com"
}
}
}
]
}
```
------
# Elementi delle policy JSON IAM: Action
L'elemento `Action` descrive l'operazione o le operazioni specifiche che saranno concesse o negate. Le istruzioni devono includere un elemento `Action` o un elemento `NotAction`. Ogni AWS servizio dispone di un proprio set di azioni che descrivono le attività che è possibile eseguire con tale servizio. [Ad esempio, l'elenco delle azioni per Amazon S3 è disponibile in [Specificying Permissions in a Policy nella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-with-s3-actions.html)*Amazon Simple Storage Service User Guide*, l'elenco delle azioni per Amazon EC2 è disponibile nel riferimento alle API di Amazon EC2 e l'elenco delle azioni per AWS Identity and Access Management è disponibile nel [riferimento alle API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-apis.html) IAM.](https://docs.aws.amazon.com/IAM/latest/APIReference/API_Operations.html) Per trovare l'elenco delle operazioni per altri servizi, consulta la [documentazione](https://aws.amazon.com/documentation) di riferimento alle API per il servizio.
AWS fornisce inoltre informazioni di riferimento sui servizi in formato JSON per semplificare l'automazione dei flussi di lavoro di gestione delle policy. Con le informazioni di riferimento del servizio, è possibile accedere alle azioni, alle risorse e alle chiavi di condizione disponibili tramite file leggibili Servizi AWS dalla macchina. Per ulteriori informazioni, consulta [Simplified Servizio AWS information for programmatic access](https://docs.aws.amazon.com/service-authorization/latest/reference/service-reference.html) nella documentazione di riferimento sull’autorizzazione dei servizi.
È possibile specificare un valore utilizzando un namespace come prefisso dell’operazione (`iam`, `ec2` `sqs`, `sns`, `s3`, ecc.) seguito dal nome dell’operazione da consentire o negare. Il nome deve corrispondere a un'operazione che è supportata dal servizio. Il prefisso e il nome dell'operazione non fanno distinzione tra maiuscole e minuscole. Ad esempio, `iam:ListAccessKeys` è equivalente a `IAM:listaccesskeys`. I seguenti esempi mostrano gli elementi `Action` per diversi servizi.
**Operazione di Amazon SQS**
```
"Action": "sqs:SendMessage"
```
**Operazione Amazon EC2**
```
"Action": "ec2:StartInstances"
```
**Operazione IAM**
```
"Action": "iam:ChangePassword"
```
**Operazioni di Amazon S3**
```
"Action": "s3:GetObject"
```
Puoi specificare valori multipli per l'elemento `Action`.
```
"Action": [ "sqs:SendMessage", "sqs:ReceiveMessage", "ec2:StartInstances", "iam:ChangePassword", "s3:GetObject" ]
```
Puoi utilizzare caratteri jolly con abbinamento a più caratteri (`*`) e caratteri jolly con abbinamento a carattere singolo (`?`) per consentire l'accesso a tutte le azioni offerte dallo specifico prodotto. AWS Ad esempio, il seguente elemento `Action` si applica a tutte le operazioni S3.
```
"Action": "s3:*"
```
Puoi anche utilizzare caratteri jolly (`*` o `?`) come parte del nome dell’operazione. Ad esempio, il seguente elemento `Action` si applica a tutte le operazioni IAM che includono la stringa `AccessKey`, incluso `CreateAccessKey`, `DeleteAccessKey`, `ListAccessKeys` e `UpdateAccessKey`.
```
"Action": "iam:*AccessKey*"
```
Alcuni servizi ti consentono di limitare le operazioni disponibili. Ad esempio, Amazon SQS consente di rendere disponibile solo un sottoinsieme di tutte le operazioni Amazon SQS possibili. In questo caso, il carattere jolly `*` non ti permette il controllo completo della coda; ti permette solo il sottoinsieme di operazioni che hai condiviso. Per ulteriori informazioni, consulta [Informazioni sulle autorizzazioni](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html#PermissionTypes) nella *Guida per gli sviluppatori di Amazon Simple Storage Service*.
# Elementi delle policy JSON IAM: NotAction
`NotAction` è un elemento di policy avanzato che corrisponde esplicitamente a tutte le operazioni *tranne* quelle specificamente elencate. L'utilizzo di `NotAction` può determinare una policy più breve dal momento che è possibile elencare solo poche operazioni che non devono corrispondere, anziché includere un lungo elenco di operazioni che devono corrispondere. Le azioni specificate in non `NotAction` sono influenzate dall'effetto `Allow` o `Deny` contenuto in una istruzione della policy. Questo significa a sua volta che tutte le operazioni o i servizi applicabili che non sono elencati sono consentiti se utilizzi l'effetto `Allow`. Inoltre, tali operazioni o servizi non elencati vengono negati se utilizzi l'effetto `Deny`. Quando utilizzi `NotAction` con l'elemento `Resource`, fornisci l'ambito della policy. In questo modo si AWS determinano le azioni o i servizi applicabili. Per ulteriori informazioni, consulta la policy di esempio seguente.
**NotAction con Allow**
È possibile utilizzare l'`NotAction`elemento in un'istruzione con `"Effect": "Allow"` per fornire l'accesso a tutte le azioni di un AWS servizio, ad eccezione delle azioni specificate in`NotAction`. È possibile utilizzarlo con l'elemento `Resource` per fornire l'ambito della policy, limitando le operazioni consentite a quelle che possono essere eseguite sulla risorsa specificata.
L'esempio seguente consente agli utenti di accedere a tutte le operazioni Amazon S3 che possono essere eseguite su qualsiasi risorsa S3 *eccetto* l'eliminazione di un bucket. Inoltre, questa policy non consente operazioni in altri servizi, perché le operazioni di altri servizi non sono applicabili alle risorse S3.
```
"Effect": "Allow",
"NotAction": "s3:DeleteBucket",
"Resource": "arn:aws:s3:::*",
```
È possibile che talvolta si desideri consentire l'accesso a un numero elevato di operazioni. Utilizzando l'elemento `NotAction` si inverte efficacemente l'istruzione, determinando un elenco più breve di operazioni. Ad esempio, poiché AWS dispone di così tanti servizi, potresti voler creare una policy che consenta all'utente di fare tutto tranne accedere alle azioni IAM.
L'esempio seguente consente agli utenti di accedere a ogni azione in ogni AWS servizio tranne IAM.
```
"Effect": "Allow",
"NotAction": "iam:*",
"Resource": "*"
```
Va prestata attenzione all'utilizzo dell'elemento `NotAction` e `"Effect": "Allow"` nella stessa istruzione o in un'istruzione diversa nella policy. `NotAction` corrisponde a tutti i servizi e le operazioni che non sono esplicitamente elencati o applicabili alla risorsa specificata e può finire col concedere agli utenti più autorizzazioni del previsto.
**NotAction con Deny**
Puoi utilizzare l'elemento `NotAction` in un'istruzione con `"Effect": "Deny"` per negare l'accesso a tutte le risorse elencate tranne le operazioni specificate nell'elemento `NotAction`. Questa combinazione non consente gli elementi elencati ma invece nega esplicitamente le operazioni non elencate. Devi comunque consentire le operazioni che desideri consentire.
Il seguente esempio condizionale nega l'accesso alle operazioni non IAM se l'utente non ha eseguito l'accesso utilizzando l'autenticazione MFA. Se l'utente ha eseguito l'accesso con l'autenticazione MFA, il test `"Condition"` non riesce e l'istruzione `"Deny"` finale non produce effetti. Nota, tuttavia, che questa istruzione non concederebbe all'utente l'accesso ad alcuna operazione, ma negherebbe solamente in modo esplicito tutte le altre operazioni eccetto le operazioni IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyAllUsersNotUsingMFA",
"Effect": "Deny",
"NotAction": "iam:*",
"Resource": "*",
"Condition": {"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}}
}]
}
```
------
Per una policy di esempio che nega l'accesso alle operazioni al di fuori di regioni specifiche, ad eccezione delle operazioni di servizi specifici, consulta [AWS: nega l'accesso in AWS base alla regione richiesta](reference_policies_examples_aws_deny-requested-region.md).
# Elementi delle policy JSON IAM: Resource
In una istruzione di policy IAM, l'elemento `Resource` definisce l'oggetto o gli oggetti a cui si applica l'istruzione. Le istruzioni devono includere un elemento `Resource` o un elemento `NotResource`.
Specifica una risorsa utilizzando un nome della risorsa Amazon (ARN). Il formato dell'ARN dipende dalla Servizio AWS risorsa specifica a cui ti riferisci. Sebbene il formato ARN vari, si utilizza sempre un ARN per identificare una risorsa. Per ulteriori informazioni sul formato di ARNs, vedere[IAM ARNs](reference_identifiers.md#identifiers-arns). Per informazioni su come specificare una risorsa, consulta la documentazione relativa al servizio per la quale desideri scrivere un'istruzione.
**Nota**
Alcuni Servizi AWS non consentono di specificare azioni per singole risorse. In questi casi, tutte le azioni elencate nell'elemento `Action` o `NotAction` si applicano a tutte le risorse di quel servizio. In questo caso, viene utilizzato il carattere jolly (`*`) nell'elemento `Resource`.
L'esempio seguente si riferisce a una determinata coda Amazon SQS.
```
"Resource": "arn:aws:sqs:us-east-2:account-ID-without-hyphens:queue1"
```
L'esempio seguente si riferisce all'utente IAM denominato `Bob` in un Account AWS.
**Nota**
Nell'elemento `Resource`, il nome utente IAM prevede una distinzione tra lettere minuscole e maiuscole.
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/Bob"
```
## Utilizzo di caratteri jolly nella risorsa ARNs
È possibile utilizzare caratteri jolly (`*` e `?`) all'interno di singoli segmenti di un ARN (le parti separate da due punti) per rappresentare:
+ Qualsiasi combinazione di caratteri (`*`)
+ Qualsiasi carattere singolo (`?`)
È possibile utilizzare più caratteri `*` o `?` in ogni segmento. Se il carattere jolly `*` è l'ultimo carattere del segmento dell'ARN di una risorsa, può espandersi fino a superare i limiti dei due punti. Consigliamo di utilizzare i caratteri jolly (`*` e `?`) all'interno dei segmenti dell'ARN separati da due punti.
**Nota**
Non puoi utilizzare un carattere jolly nel segmento dei servizi che identifica il prodotto. AWS Per ulteriori informazioni sui segmenti degli ARN, consulta [Identifica AWS le risorse con Amazon Resource Names (ARNs)](reference-arns.md)
L'esempio seguente si riferisce a tutti gli utenti IAM il cui percorso è `/accounting`.
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/accounting/*"
```
L'esempio seguente si riferisce a tutti gli elementi all'interno di un determinato bucket Amazon S3.
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
```
Il carattere asterisco (`*`) può espandersi per sostituire tutto all'interno di un segmento, inclusi caratteri come una barra (`/`) che potrebbero sembrare un delimitatore all'interno di un determinato spazio dei nomi del servizio. Ad esempio, considera il seguente ARN di Amazon S3 come la stessa logica di espansione con caratteri jolly si applica a tutti i servizi.
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*/test/*"
```
I caratteri jolly nell'ARN si applicano a tutti i seguenti oggetti nel bucket, non solo al primo oggetto elencato.
```
amzn-s3-demo-bucket/1/test/object.jpg
amzn-s3-demo-bucket/1/2/test/object.jpg
amzn-s3-demo-bucket/1/2/test/3/object.jpg
amzn-s3-demo-bucket/1/2/3/test/4/object.jpg
amzn-s3-demo-bucket/1///test///object.jpg
amzn-s3-demo-bucket/1/test/.jpg
amzn-s3-demo-bucket//test/object.jpg
amzn-s3-demo-bucket/1/test/
```
Considera gli ultimi due oggetti dell'elenco precedente. Il nome di un oggetto Amazon S3 può iniziare o terminare validamente con il carattere barra (`/`) del delimitatore convenzionale. Mentre `/` funziona come delimitatore, non vi è alcun significato specifico quando questo carattere viene utilizzato all'interno dell'ARN di una risorsa. Viene trattato come qualsiasi altro carattere valido. L'ARN non corrisponde ai seguenti oggetti:
```
amzn-s3-demo-bucket/1-test/object.jpg
amzn-s3-demo-bucket/test/object.jpg
amzn-s3-demo-bucket/1/2/test.jpg
```
## Specifica di più risorse
È possibile specificare più risorse nell'`Resource`elemento utilizzando una matrice di. ARNs L'esempio seguente si riferisce a due tabelle DynamoDB.
```
"Resource": [
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/books_table",
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/magazines_table"
]
```
## Utilizzo di variabili politiche nella risorsa ARNs
Nell'elemento `Resource`, puoi utilizzare le [variabili di policy](reference_policies_variables.md) JSON nella parte dell'ARN che identifica la risorsa specifica (ovvero nella parte finale di ARN). Ad esempio, puoi utilizzare la chiave `{aws:username}` come parte di una risorsa ARN per indicare che l'attuale nome dell'utente deve essere incluso come parte del nome della risorsa. L'esempio seguente mostra come puoi utilizzare la chiave `{aws:username}` in un elemento `Resource`. La policy consente l'accesso a una tabella Amazon DynamoDB che corrisponde al nome dell'utente corrente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "arn:aws:dynamodb:us-east-2:111122223333:table/${aws:username}"
}
}
```
------
Per ulteriori informazioni sulle variabili di policy JSON, consultare la pagina [Elementi delle policy IAM: variabili e tag](reference_policies_variables.md).
# Elementi delle policy JSON IAM: NotResource
`NotResource` è un elemento della policy avanzato che corrisponde esplicitamente a tutte le risorse tranne quelle specificate. L'utilizzo di `NotResource` può risultare in una policy di durata inferiore elencando solo poche risorse che non devono corrispondere, anziché includere un lungo elenco di risorse che corrisponderanno. Ciò è particolarmente utile per le policy che si applicano all'interno di un singolo servizio AWS .
Ad esempio, immaginate di disporre di un gruppo denominato `HRPayroll`. I membri di `HRPayroll` non devono avere il permesso di accedere a qualsiasi risorsa Amazon S3 ad eccezione della cartella `Payroll` nel bucket `HRBucket`. La policy seguente rifiuta esplicitamente l'accesso a tutte le risorse Amazon S3 eccetto a quelle elencate. Tuttavia, questa policy non concede all'utente l'accesso a nessuna risorsa.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Deny",
"Action": "s3:*",
"NotResource": [
"arn:aws:s3:::HRBucket/Payroll",
"arn:aws:s3:::HRBucket/Payroll/*"
]
}
}
```
------
Di solito, per negare esplicitamente l'accesso a una risorsa è necessario scrivere una policy che utilizza `"Effect":"Deny"` e che include un elemento `Resource` che elenca ogni cartella individualmente. Tuttavia, in tal caso, ogni volta che aggiungi una cartella a `HRBucket` o una risorsa ad Amazon S3 che non deve essere accessibile, è necessario aggiungere il suo nome all’elenco nell’elemento `Resource`. Se si utilizza invece un elemento `NotResource`, agli utenti viene automaticamente negato l'accesso a nuove cartelle a meno che non si aggiungano i nomi delle cartelle all'elemento `NotResource`.
Quando si utilizza `NotResource`, è necessario tenere presente che le risorse specificate in questo elemento sono le *uniche* risorse a non essere limitate. Questo, a sua volta, limita tutte le risorse che si applicano all'operazione. Nell'esempio precedente, la policy riguarda solo le operazioni di Amazon S3 e quindi solo le risorse di Amazon S3. Se l’elemento `Action` avesse incluso anche operazioni di Amazon EC2, la policy avrebbe rifiutato l’accesso a qualunque risorsa EC2 non specificata nell’elemento `NotResource`. Per sapere quali azioni in un servizio consentono di specificare l'ARN di una risorsa, [consulta Azioni, risorse e chiavi AWS di condizione](reference_policies_actions-resources-contextkeys.html) per i servizi.
## NotResource con altri elementi
Non bisognerebbe **mai** utilizzare insieme gli elementi `"Effect": "Allow"`, `"Action": "*"` e `"NotResource": "arn:aws:s3:::HRBucket"`. Questa affermazione è molto pericolosa, perché consente tutte le azioni AWS su tutte le risorse tranne il bucket `HRBucket` S3. Ciò consentirebbe addirittura a un utente di aggiungere al proprio profilo una policy che gli consenta di accedere a `HRBucket`. Non bisogna farlo.
Va prestata attenzione all'utilizzo dell'elemento `NotResource` e `"Effect": "Allow"` nella stessa istruzione o in un'istruzione diversa nella policy. `NotResource` consente tutti i servizi e risorse che non sono elencati in modo esplicito e può concedere agli utenti più autorizzazioni del previsto. L'utilizzo dell'elemento `NotResource` e `"Effect": "Deny"` nella stessa istruzione nega i servizi e le risorse che non sono elencati in modo esplicito.
# 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 |
# Elementi delle policy IAM: variabili e tag
Usa le variabili di policy AWS Identity and Access Management (IAM) come segnaposto quando non conosci il valore esatto di una risorsa o di una chiave di condizione quando scrivi la policy.
**Nota**
Se AWS non riesci a risolvere una variabile, l'intera istruzione potrebbe non essere valida. Ad esempio, se utilizzi la variabile `aws:TokenIssueTime`, questa viene risolta in un valore solo quando il richiedente è stato autenticato tramite le credenziali temporanee (un ruolo IAM). [Per evitare che le variabili causino istruzioni non valide, usa il... IfExists operatore di condizione](reference_policies_elements_condition_operators.md#Conditions_IfExists).
**Topics**
+ [
## Introduzione
](#policy-vars-intro)
+ [
## Utilizzo delle variabili nelle policy
](#policy-vars-using-variables)
+ [
## Tag come variabili di policy
](#policy-vars-tags)
+ [
## Casi in cui è possibile utilizzare le variabili di policy
](#policy-vars-wheretouse)
+ [
## Variabili di policy senza valore
](#policy-vars-no-value)
+ [
## Richiesta di informazioni utilizzabili per le variabili di policy
](#policy-vars-infotouse)
+ [
## Specifica dei valori di default
](#policy-vars-default-values)
+ [
## Ulteriori informazioni
](#policy-vars-formoreinfo)
## Introduzione
Nelle policy IAM, numerose operazioni consentono di assegnare un nome a risorse specifiche per le quali si desidera controllare l'accesso. Ad esempio, la policy di seguito consente all'utente di elencare, leggere e scrivere gli oggetti nel bucket S3 `amzn-s3-demo-bucket` per i progetti `marketing`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["marketing/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/marketing/*"]
}
]
}
```
------
In alcuni casi, potresti non conoscere il nome esatto della risorsa al momento di scrivere la policy. Puoi generalizzare la policy per renderla utilizzabile da molti utenti senza bisogno di effettuare una copia univoca per ciascun utente. Invece di creare una policy separata per ciascun utente, consigliamo di creare una singola policy di gruppo che funzioni per tutti gli utenti che appartengono a tale gruppo.
## Utilizzo delle variabili nelle policy
È possibile definire valori dinamici all'interno delle policy utilizzando *variabili di policy* che impostano i segnaposti in una policy.
Le variabili sono contrassegnate utilizzando un prefisso **`$`**seguito da una coppia di parentesi graffe (**`{ }`**) che includono il nome della variabile del valore della richiesta.
Quando la policy viene valutata, le variabili di policy vengono sostituite con valori provenienti dalle chiavi di contesto condizionali inoltrate nella richiesta. Le variabili possono essere utilizzate nelle [policy basate sull'identità, nelle policy delle risorse, nelle policy di controllo dei servizi, nelle policy di sessione](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) e nelle [policy degli endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). Anche le policy basate sull'identità utilizzate come limiti delle autorizzazioni supportano le variabili di policy.
Le chiavi di contesto delle condizioni globali possono essere utilizzate come variabili nelle richieste tra AWS i servizi. Anche le chiavi di condizione specifiche del servizio possono essere utilizzate come variabili quando interagiscono con le risorse AWS , ma sono disponibili soltanto quando le richieste vengono effettuate su risorse che le supportano. Per un elenco delle chiavi di contesto disponibili per ogni AWS servizio e risorsa, consulta il [https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html](https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html). In determinate circostanze, non è possibile inserire un valore nelle chiavi di contesto delle condizioni globali. Per ulteriori informazioni su ciascuna chiave, consulta [AWS global condition context keys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html).
**Importante**
I nomi delle chiavi non fanno distinzione tra maiuscole e minuscole. Ad esempio, `aws:CurrentTime` è uguale a `AWS:currenttime`.
È possibile utilizzare qualsiasi chiave di condizione a valore singolo come variabile. Non è possibile utilizzare una chiave della condizione multi-valore come variabile.
L'esempio seguente mostra una policy per un utente o un ruolo IAM che sostituisce il nome di una risorsa specifica con una variabile di policy. Puoi riutilizzare questa policy sfruttando i vantaggi della chiave di condizione `aws:PrincipalTag`. Quando questa policy viene valutata, `${aws:PrincipalTag/team}` consente le operazioni solo se il nome del bucket termina con il nome del team dal tag del principale `team`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["${aws:PrincipalTag/team}/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/team}/*"]
}
]
}
```
------
La variabile viene contrassegnata utilizzando un prefisso `$` seguito da una coppia di parentesi graffe (`{ }`). All'interno dei caratteri `${ }` è possibile includere il nome del valore ricavato dalla richiesta da utilizzare nella policy. I valori che possono essere utilizzati sono descritti più avanti in questa pagina.
Per maggiori dettagli su questa chiave di condizione globale, consulta [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag) nell'elenco di chiavi di condizioni globali.
**Nota**
Per usare le variabili di policy, è necessario che l'elemento `Version` sia incluso in una dichiarazione. Inoltre, la versione deve essere impostata su una versione che supporti le variabili di policy. Le variabili sono state introdotte a partire dalla versione `2012-10-17`. Le versioni precedenti del linguaggio di policy non supportano le variabili. Se l'elemento `Version` non viene incluso e impostato su una data appropriata, alcune variabili, come ad esempio `${aws:username}`, saranno trattate come stringhe letterali nella policy.
Un elemento di policy `Version` è diverso da una versione di policy. L'elemento di policy `Version` viene utilizzato all'interno di una policy e definisce la versione del linguaggio di policy. Diversamente, viene creata una versione della policy quando si modifica una policy gestita dal cliente in IAM. La policy modificata non viene sovrascritta a quella precedente. IAM crea invece una nuova versione della policy gestita. Per ulteriori informazioni sull'elemento di policy `Version`, consultare [Elementi delle policy JSON IAM: Version](reference_policies_elements_version.md). Per ulteriori informazioni sulle versioni di policy, consultare [Controllo delle versioni delle policy IAM](access_policies_managed-versioning.md).
Una policy che consente a un principale di ottenere oggetti dal percorso /David di un bucket S3 è simile alla seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/David/*"
]
}
]
}
```
------
Se questa policy è collegata all'utente `David`, tale utente ottiene gli oggetti dal proprio bucket S3, ma potrebbe essere necessario creare una policy separata per ogni utente che include il nome dell'utente. Ciascuna policy dovrà quindi essere collegata ai singoli utenti.
Utilizzando una variabile di policy, è possibile creare policy che possono essere riutilizzate. La seguente policy consente a un utente di ottenere oggetti da un bucket Amazon S3 se il valore tag-chiave per `aws:PrincipalTag` corrisponde al valore del `owner` tag-chiave inviato nella richiesta.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "AllowUnlessOwnedBySomeoneElse",
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": ["*"],
"Condition": {
"StringEquals": {
"s3:ExistingObjectTag/owner": "${aws:PrincipalTag/owner}"
}
}
}
]
}
```
------
Se utilizzi una variabile di policy al posto di un utente di questo tipo, non è necessaria una policy separata per ogni singolo utente. Nell'esempio seguente, la policy è collegata a un ruolo IAM assunto dai Product Manager tramite credenziali di sicurezza temporanee. Quando un utente richiede di aggiungere un oggetto Amazon S3, IAM sostituisce il valore del tag `dept` della richiesta corrente per la variabile `${aws:PrincipalTag}` e valuta la policy.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowOnlyDeptS3Prefix",
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/dept}/*"
]
}
]
}
```
------
## Tag come variabili di policy
In alcuni AWS servizi è possibile associare attributi personalizzati alle risorse create da tali servizi. Ad esempio, puoi applicare tag a bucket Amazon S3 o a utenti IAM. Questi tag sono coppie chiave-valore. È possibile definire il nome della chiave di tag e il valore associato al nome della chiave. Ad esempio, puoi creare un tag con una chiave **department** e un valore **Human Resources**. Per ulteriori informazioni sul tagging delle entità IAM, consulta [Tag per AWS Identity and Access Management le risorse](id_tags.md). Per informazioni sul tagging delle risorse create da altri servizi AWS , consulta la documentazione di tali servizi. Per ulteriori informazioni sull'utilizzo dell'editor di tag, consulta l'articolo relativo all'[utilizzo dell'editor di tag](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/tag-editor.html) nella *Guida per l'utente della Console di gestione AWS *.
Puoi applicare tag alle risorse IAM per semplificare il rilevamento, l'organizzazione e il monitoraggio delle risorse IAM. Puoi inoltre applicare tag alle identità IAM per controllare l'accesso alle risorse o al tagging. Per ulteriori informazioni sull'uso dei tag per controllare l'accesso, consulta [Controllo dell'accesso a e per utenti e ruoli IAM mediante i tag](access_iam-tags.md).
## Casi in cui è possibile utilizzare le variabili di policy
Le variabili di policy possono essere utilizzate nell'elemento `Resource` e per confrontare stringhe nell'elemento `Condition`.
### Elemento risorsa
È possibile utilizzare una variabile criterio nell'elemento `Resource`, ma solo nella parte risorsa dell'ARN. Questa parte dell'ARN appare dopo i quinti due punti (:). Non è possibile utilizzare una variabile per sostituire parti dell'ARN prima dei quinti due punti, ad esempio il servizio o l'account. Per ulteriori informazioni sul formato ARN, consulta [IAM ARNs](reference_identifiers.md#identifiers-arns).
Per sostituire una parte di un ARN con un valore di tag, inserisci il prefisso e il nome della chiave in `${ }`. Ad esempio, il seguente elemento Risorsa si riferisce solo a un bucket con lo stesso nome del valore nel tag department dell'utente richiedente.
`"Resource": ["arn:aws::s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/department}"]`
Molte AWS risorse utilizzano queste risorse ARNs che contengono un nome creato dall'utente. La seguente policy IAM garantisce che solo gli utenti voluti con i valori di tag access-project, access-application e access-environment corrispondenti possono modificare le relative risorse. Inoltre, utilizzando le [corrispondenze con carattere jolly \$1](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html), sono in grado di consentire suffissi personalizzati per i nomi delle risorse.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessBasedOnArnMatching",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:DeleteTopic"],
"Resource": ["arn:aws:sns:*:*:${aws:PrincipalTag/access-project}-${aws:PrincipalTag/access-application}-${aws:PrincipalTag/access-environment}-*"
]
}
]
}
```
------
### Elemento condizione
È possibile utilizzare una variabile di criterio per i valori `Condition` in qualsiasi condizione che coinvolga gli operatori stringa o gli operatori ARN. Gli operatori stringa includono `StringEquals`, `StringLike` e `StringNotLike`. Gli operatori ARN includono `ArnEquals` e `ArnLike`. Non è possibile utilizzare una variabile di criterio con altri operatori, ad esempio `Numeric`, `Date`, `Boolean`, `Binary`, `IP Address` o `Null`. Per ulteriori informazioni sugli operatori delle condizioni, vedere [Elementi della policy JSON IAM: operatori di condizione](reference_policies_elements_condition_operators.md).
Quando fai riferimento a un tag in un'espressione dell'elemento `Condition`, utilizza il prefisso e il nome della chiave pertinenti come chiave di condizione. Quindi utilizza il valore che desideri testare nel valore della condizione.
Ad esempio, la seguente policy di esempio consente l'accesso completo agli utenti; ma solo se il tag `costCenter` è collegato all'utente. Il tag deve inotlre avere un valore pari a `12345` o `67890`. Se il tag non ha nessun valore o ha qualsiasi altro valore, la richiesta ha esito negativo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:*user*"
],
"Resource": "*",
"Condition": {
"StringLike": {
"iam:ResourceTag/costCenter": [ "12345", "67890" ]
}
}
}
]
}
```
------
## Variabili di policy senza valore
Quando le variabili di policy fanno riferimento a una chiave di contesto delle condizioni che non ha valore o non è presente nel contesto di autorizzazione per una richiesta, il valore è effettivamente nullo. Non esiste un valore uguale o simile. Le chiavi di contesto delle condizioni potrebbero non essere presenti nel contesto di autorizzazione quando:
+ Si utilizzano le chiavi di contesto delle condizioni specifiche del servizio nelle richieste inviate a risorse che non supportano tale chiave di condizione.
+ I tag sulle sessioni, sulle risorse, sulle richieste o sui principali IAM non sono presenti.
+ Altre circostanze, come specificate per ogni chiave di contesto delle condizioni globali alla pagina [AWS chiavi di contesto della condizione globale](reference_policies_condition-keys.md).
Quando si utilizza una variabile senza valore nell'elemento della condizione di una policy IAM, gli [Elementi della policy JSON IAM: operatori di condizione](reference_policies_elements_condition_operators.md) come `StringEquals` o `StringLike` non corrispondono e l'istruzione della policy non ha effetto.
Gli operatori di condizione invertiti come `StringNotEquals` o `StringNotLike` corrispondono a un valore nullo, poiché il valore della chiave di condizione che stanno verificando non corrisponde o non è uguale al valore effettivamente nullo.
Nel seguente esempio, per consentire l'accesso `aws:principaltag/Team` deve essere uguale a `s3:ExistingObjectTag/Team`. L'accesso è esplicitamente negato quando `aws:principaltag/Team` non è impostato. Se una variabile che non ha valore nel contesto di autorizzazione viene utilizzata come parte dell'elemento `Resource` o `NotResource` di una policy, la risorsa che include una variabile di policy senza valore non corrisponderà ad alcuna risorsa.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:ExistingObjectTag/Team": "${aws:PrincipalTag/Team}"
}
}
}
]
}
```
------
## Richiesta di informazioni utilizzabili per le variabili di policy
È possibile utilizzare l'elemento `Condition` di una policy JSON per confrontare le chiavi nel [contesto della richiesta](reference_policies_evaluation-logic_policy-eval-reqcontext.md) con i valori chiave specificati nella policy. Quando si utilizza una variabile di politica, AWS sostituisce un valore della chiave di contesto della richiesta al posto della variabile nella politica.
### Valori della chiave dell'entità principale
I valori per `aws:username`, `aws:userid` e `aws:PrincipalType` dipendono dal tipo di principale che ha avviato la richiesta. Ad esempio, la richiesta può essere effettuata utilizzando le credenziali di un utente IAM, di un ruolo IAM o dell' Utente root dell'account AWS. La seguente tabella mostra i valori di tali chiavi per i diversi tipi di principale.
****
| Principale | `aws:username` | `aws:userid` | `aws:PrincipalType` |
| --- | --- | --- | --- |
| Utente root dell'account AWS | (non presente) | Account AWS ID | Account |
| Utente IAM | IAM-user-name | [ID univoco](reference_identifiers.md#identifiers-unique-ids) | User |
| AWS STS utente federato principale | (non presente) | account:caller-specified-name | FederatedUser |
| Principale federato OIDC Per informazioni sulle chiavi di policy disponibili quando utilizzi la federazione delle identità Web, consultare [Chiavi disponibili per la federazione AWS OIDC](reference_policies_iam-condition-keys.md#condition-keys-wif). | (non presente) | *role-id*:*caller-specified-role-name* dove `role-id` è l'[id univoco del ruolo](reference_identifiers.md#identifiers-unique-ids) ed caller-specified-role-name è specificato dal [RoleSessionName parametro](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AssumeRole.html#API_AssumeRoleWithWebIdentity_RequestParameters) passato alla AssumeRoleWithWebIdentity richiesta. | AssumedRole |
| Principale federato SAML Per informazioni sulle chiavi di policy disponibili quando si usa la federazione SAML, consultare [Identificazione univoca degli utenti nella federazione basata su SAML](id_roles_providers_saml.md#CreatingSAML-userid). | (non presente) | *role-id*:*caller-specified-role-name* dove `role-id` è l'[id univoco del ruolo](reference_identifiers.md#identifiers-unique-ids) ed caller-specified-role-name è specificato dall'elemento Attribute con l'attributo [Name impostato su https://aws.amazon.com/SAML/ RoleSessionName attributes/](id_roles_providers_create_saml_assertions.md). | AssumedRole |
| Ruolo assunto | (non presente) | *role-id*:*caller-specified-role-name* dove `role-id` è l'[id univoco del ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) ed caller-specified-role-name è specificato dal [RoleSessionName parametro](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters) passato alla richiesta. AssumeRole | AssumedRole |
| Ruolo assegnato a un'istanza Amazon EC2 | (non presente) | *role-id*:*ec2-instance-id* dove `role-id` è l'[id univoco del ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) e l'id-istanza-ec2 è l'[identificativo univoco dell'istanza EC2](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html). | AssumedRole |
| Chiamante anonimo (solo Amazon SQS, Amazon SNS e Amazon S3) | (non presente) | anonymous | Anonymous |
Per gli elementi di questa tabella, nota quanto segue:
+ *non presente* significa che il valore non è riportato nelle informazioni della richiesta corrente e qualsiasi tentativo di trovare una corrispondenza avrà esito negativo e l'istruzione viene considerata non valida.
+ *role-id*è un identificatore univoco assegnato a ciascun ruolo al momento della creazione. È possibile visualizzare l'ID del ruolo con il AWS CLI comando: `aws iam get-role --role-name rolename`
+ *caller-specified-name*e *caller-specified-role-name* sono nomi che vengono passati dal processo chiamante (ad esempio un'applicazione o un servizio) quando effettua una chiamata per ottenere credenziali temporanee.
+ *ec2-instance-id*è un valore assegnato all'istanza al momento dell'avvio e viene visualizzato nella pagina **Istanze** della console Amazon EC2. Puoi anche visualizzare l'ID dell'istanza eseguendo il AWS CLI comando: `aws ec2 describe-instances`
### Informazioni disponibili nelle richieste per i principali federati
I principali federati vengono autenticati utilizzando un sistema diverso da IAM. Ad esempio, un'azienda potrebbe disporre di un'applicazione da utilizzare internamente che effettua chiamate verso AWS. Fornire un'identità IAM a ogni utente dell'azienda che utilizza l'applicazione potrebbe risultare poco pratico. Al contrario, l'azienda può utilizzare un'applicazione proxy (livello intermedio) con una singola identità IAM, oppure un provider di identità (IdP) SAML. L'applicazione proxy o l'IdP SAML autentica i singoli utenti individuali tramite la rete aziendale. Un'applicazione proxy può quindi utilizzare la propria identità di IAM per ottenere credenziali di sicurezza provvisorie per i singoli utenti. Un IdP SAML può in effetti scambiare informazioni sull'identità AWS per credenziali di sicurezza temporanee. Le credenziali temporanee possono quindi essere utilizzate per accedere alle risorse. AWS
Allo stesso modo, potresti creare un'applicazione per dispositivi mobili che richiede l'accesso alle risorse AWS . In questo caso, puoi ricorrere alla *federazione OIDC*, per fare in modo che l'app autentichi l'utente utilizzando un provider di identità conosciuto, come Login with Amazon, Amazon Cognito, Facebook o Google. A questo punto, l'applicazione potrà utilizzare le informazioni di autenticazione dell'utente fornite da tali provider per ottenere le credenziali di sicurezza temporanee per l'accesso alle risorse AWS .
Il modo consigliato per utilizzare la federazione OIDC è sfruttare Amazon Cognito e i dispositivi mobili. AWS SDKs Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Guida per l'utente di Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html)
+ [Scenari comuni per le credenziali temporanee](id_credentials_temp.md#sts-introduction)
### Caratteri speciali
Alcune variabili di policy speciali e predefinite hanno valori fissi che consentono di rappresentare caratteri che altrimenti avrebbero un significato diverso. Se tali caratteri speciali fanno parte della stringa per cui stai cercando una corrispondenza e vengono inseriti letteralmente, il loro significato sarebbe frainteso. Ad esempio, se nella stringa inserisci un asterisco (\$1), questo non sarà interpretato come un semplice asterisco, ma come un carattere jolly corrispondente a tutti i caratteri. In tali casi, puoi utilizzare le seguenti variabili di policy predefinite:
+ **\$1\$1\$1\$1** - da usare quando devi inserire un asterisco (\$1).
+ **\$1\$1?\$1** - da usare quando devi inserire un punto interrogativo (?).
+ **\$1\$1\$1\$1** - da usare quando devi inserire il simbolo del dollaro (\$1).
Queste variabili di policy predefinite possono essere inserite in qualsiasi stringa in cui è possibile utilizzare le normali variabili di policy.
## Specifica dei valori di default
Per aggiungere un valore di default a una variabile, racchiudi il valore di default tra virgolette singole (`' '`) e separa il testo della variabile e il valore di default con una virgola e uno spazio (`, `).
Ad esempio, se a un principale è applicato un tag`team=yellow`, è possibile accedere al bucket Amazon S3 `ExampleCorp's` denominato `amzn-s3-demo-bucket-yellow`. Una policy con questa risorsa consente ai membri del team di accedere al bucket del team, ma non a quelli di altri team. Per gli utenti senza tag team, la policy imposta un valore di default di `company-wide` per il nome del bucket. Questi utenti possono accedere solo al bucket `amzn-s3-demo-bucket-company-wide` dove possono visualizzare informazioni generali, come le istruzioni per entrare a far parte di un team.
```
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket-${aws:PrincipalTag/team, 'company-wide'}"
```
## Ulteriori informazioni
Per ulteriori informazioni sulle policy, consultare:
+ [Politiche e autorizzazioni in AWS Identity and Access Management](access_policies.md)
+ [Esempi di policy basate su identità IAM](access_policies_examples.md)
+ [Documentazione di riferimento degli elementi delle policy JSON IAM](reference_policies_elements.md)
+ [Logica di valutazione delle policy](reference_policies_evaluation-logic.md)
+ [Federazione OIDC](id_roles_providers_oidc.md)
# Elementi della policy JSON IAM: tipi di dati supportati
Questa sezione elenca i tipi di dati che sono supportati quando si specificano valori in policy JSON. Il linguaggio della policy non supporta tutti i tipi per ciascun elemento della policy; per informazioni su ciascun elemento, consultare le sezioni precedenti.
+ Stringhe
+ Numeri (interi e valori a virgola mobile)
+ Booleano
+ Null
+ Elenchi
+ Mappe
+ Strutture (sono solo mappe nidificate)
La tabella seguente associa ogni tipo di dati alla serializzazione. Notare che tutte le policy devono essere in UTF-8. Per informazioni sui tipi di dati JSON, consulta [RFC 4627](https://datatracker.ietf.org/doc/html/rfc4627).
****
| Tipo | JSON |
| --- | --- |
| Stringa | Stringa |
| Numero intero | Numero |
| Float | Numero |
| Booleano | true false |
| Null | null |
| Data | Stringa in linea con il [profilo W3C di ISO 8601](http://www.w3.org/TR/NOTE-datetime) |
| IpAddress | Stringa in linea con [RFC 4632](https://datatracker.ietf.org/doc/html/rfc4632) |
| List | Array |
| Oggetto | Oggetto |