Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Elementi 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.

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. 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 e scegli il servizio che desideri visualizzare.

Gli operatori di condizione possono essere raggruppati nelle seguenti categorie:

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.

Ad esempio, l'istruzione seguente contiene un elemento Condition che utilizza la chiave aws: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::account-id: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.

Puoi utilizzare una variabile di policy con l'operatore di condizione String.

Nell'esempio seguente viene utilizzato l'operatore di condizione StringLike per eseguire il confronto con una variabile di policy 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:::BUCKET-NAME",
      "Condition": {"StringLike": {"s3:prefix": [
        "",
        "home/",
        "home/${aws:username}/"
      ]}}
    },
    {
      "Effect": "Allow",
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::BUCKET-NAME/home/${aws:username}",
        "arn:aws:s3:::BUCKET-NAME/home/${aws:username}/*"
      ]
    }
  ]
}

Per un esempio di politica che mostra come utilizzare l'Conditionelemento per limitare l'accesso alle risorse in base a un ID applicazione e un ID utente per la federazione OIDC, vedere. Amazon S3: consente agli utenti di Amazon Cognito di accedere a oggetti nel relativo bucket

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. Quando si utilizzano StringNotLike gli operatori StringLike or per le corrispondenze parziali di stringhe di un ARN o di una data, la corrispondenza ignora quale parte della struttura è contrassegnata da caratteri jolly.

Ad esempio, le seguenti condizioni cercano una corrispondenza parziale di un ARN utilizzando operatori di condizioni diversi.

Quando ArnLike viene utilizzata, le parti partition, service, account-id, resource-type e resource-id parziale dell'ARN devono corrispondere esattamente all'ARN nel contesto della richiesta. La corrispondenza parziale è consentita solo per la regione e il percorso della risorsa.

"Condition": {"ArnLike": {"aws:SourceArn": "arn:aws:cloudtrail:*:111122223333:trail/*"}}

Quando StringLike viene utilizzato al posto di ArnLike, matching ignora la struttura ARN e consente la corrispondenza parziale, indipendentemente dalla parte che è stata selezionata come wildcard.

"Condition": {"StringLike": {"aws:SourceArn": "arn:aws:cloudtrail:*:111122223333:trail/*"}}

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.

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 example_bucket alla volta.

{
  "Version": "2012-10-17",
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_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.

Puoi utilizzare una variabile di policy con l'operatore di condizione Numeric.

Operatori di condizione data

Gli operatori di condizione data consentono di creare elementi Condition che limitano l'accesso in base al confronto con una chiave con un valore data/ora. Utilizza questi operatori di condizione con la chiave aws:CurrentTime o la chiave aws:EpochTime. È necessario specificare i valori di data/ora con una delle implementazioni W3C dei formati di data ISO 8601 o con tempo epoca (UNIX epoch).

Ad esempio, l'istruzione seguente contiene un elemento Condition che utilizza l'operatore di condizione DateGreaterThan con la chiave aws: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.

{
  "Version": "2012-10-17",
  "Statement": {
    "Effect": "Allow",
    "Action": "iam:*AccessKey*",
    "Resource": "arn:aws:iam::account-id: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.

Puoi utilizzare una variabile di policy con l'operatore di condizione Date.

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 "vero" o "falso".

Ad esempio, questa policy basata sull'identità utilizza l'operatore di condizione Bool con la chiave aws: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.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "BooleanExample",
      "Action": "s3:ReplicateObject",
      "Effect": "Deny",
      "Resource": [
        "arn:aws:s3:::DOC-EXAMPLE-BUCKET",
        "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*"
      ],
      "Condition": {
        "Bool": {
          "aws:SecureTransport": "false"
        }
      }
    }
  ]
}

Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. Il contesto della richiesta aws:SecureTransport restituisce vero o faso.

Puoi utilizzare una variabile di policy con l'operatore di condizione Boolean.

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 nella policy.

"Condition" : {
  "BinaryEquals": {
    "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
  }
}     

Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono.

Puoi utilizzare una variabile di policy con l'operatore di condizione Binary.

Operatori di condizione con indirizzo IP

Gli operatori di condizione con indirizzo IP consentono di creare elementi Condition che limitano l'accesso in base al confronto di una chiave con un indirizzo IPv4 o IPv6 o un intervallo di indirizzi IP. È possibile utilizzare questi operatori con la chiave aws:SourceIp. Il valore deve essere nel formato CIDR standard (ad esempio, 203.0.113.0/24 or 2001:DB8:1234:5678::/64). Se si specifica un indirizzo IP senza il prefisso di instradamento associato, IAM utilizza il valore predefinito di prefisso /32.

Alcuni AWS servizi supportano IPv6, utilizzando:: per rappresentare un intervallo di 0. Per sapere se un servizio supporta IPv6, consultare la documentazione per tale servizio.

Ad esempio, 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::account-id: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.

Puoi utilizzare una variabile di policy con l'operatore di condizione IpAddress.

Nella policy di bucket di esempio riportata di seguito viene mostrato come combinare gli indirizzi IPv4 e IPv6 per coprire tutti gli indirizzi IP validi dell'organizzazione. Ti consigliamo di aggiornare le policy dell'organizzazione con gli intervalli di indirizzi IPv6 in aggiunta agli intervalli IPv4 di cui già disponi per garantire che le policy continuino a funzionare mentre effettui la transizione a 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. Questo può accadere, ad esempio, se chiami Amazon EC2 AWS CloudFormation per creare istanze per te. 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.

Puoi utilizzare una variabile di policy con l'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": {"AWS": "123456789012"},
    "Action": "SQS:SendMessage",
    "Resource": "arn:aws:sqs:REGION:123456789012:QUEUE-ID",
    "Condition": {"ArnEquals": {"aws:SourceArn": "arn:aws:sns:REGION:123456789012:TOPIC-ID"}}
  }
}

Se la chiave specificata in una condizione di policy non è presente nel contesto della richiesta, i valori non corrispondono. La chiave aws: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.

... 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 il tag.

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:

{
  "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 (*) 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.

{
    "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": "*"
        }]
}

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 con l'operatore di condizione Null.

Ad esempio, è possibile utilizzare questo operatore di condizione per determinare se un utente sta utilizzando per l'operazione le proprie credenziali o le credenziali temporanee. 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 non deve utilizzare credenziali temporanee (la chiave non deve esistere) affinché l'utente possa utilizzare l'API Amazon EC2.

{
  "Version": "2012-10-17",
  "Statement":{
      "Action":"ec2:*",
      "Effect":"Allow",
      "Resource":"*",
      "Condition":{"Null":{"aws:TokenIssueTime":"true"}}
  }
}