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

# Esempi di utilizzo dell’ABAC con tabelle e indici DynamoDB
<a name="abac-example-use-cases"></a>

Gli esempi seguenti illustrano alcuni casi d’uso per implementare condizioni basate su attributi utilizzando i tag.

**Topics**
+ [Esempio 1: consenti un'azione utilizzando aws: ResourceTag](#abac-allow-example-resource-tag)
+ [Esempio 2: consenti un'azione utilizzando aws: RequestTag](#abac-allow-example-request-tag)
+ [Esempio 3: Negare un'azione utilizzando aws: TagKeys](#abac-deny-example-tag-key)

## Esempio 1: consenti un'azione utilizzando aws: ResourceTag
<a name="abac-allow-example-resource-tag"></a>

Utilizzando la chiave di condizione `aws:ResourceTag/tag-key` è possibile confrontare la coppia chiave-valore del tag specificata in una policy IAM con la coppia chiave-valore collegata in una tabella DynamoDB. Ad esempio, puoi consentire un'azione specifica, ad esempio se le condizioni del tag corrispondono in una politica IAM e in una tabella. [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) A tal fine, segui questa procedura:

------
#### [ Using the AWS CLI ]

1. Creare una tabella. L'esempio seguente utilizza il AWS CLI comando [create-table](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html) per creare una tabella denominata. `myMusicTable`

   ```
   aws dynamodb create-table \
     --table-name myMusicTable \
     --attribute-definitions AttributeName=id,AttributeType=S \
     --key-schema AttributeName=id,KeyType=HASH \
     --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
     --region us-east-1
   ```

1. Aggiungi un tag a questa tabella. Il seguente esempio di AWS CLI comando [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) aggiunge la coppia chiave-valore del tag a. `Title: ProductManager` `myMusicTable`

   ```
   aws dynamodb tag-resource --region us-east-1 --resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable --tags Key=Title,Value=ProductManager
   ```

1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Action": "dynamodb:PutItem",
         "Resource": "arn:aws:dynamodb:*:*:table/*",
         "Condition": {
           "StringEquals": {
             "aws:ResourceTag/Title": "ProductManager"
           }
         }
       }
     ]
   }
   ```

------

   Questa policy consente l’azione `PutItem` sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

1. Assumi il ruolo con le policy descritte nella Fase 3.

1. Usa il AWS CLI comando [put-item](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html) per inserire un elemento in. `myMusicTable`

   ```
   aws dynamodb put-item \
       --table-name myMusicTable --region us-east-1 \
       --item '{
           "id": {"S": "2023"},
           "title": {"S": "Happy Day"},
           "info": {"M": {
               "rating": {"N": "9"},
               "Artists": {"L": [{"S": "Acme Band"}, {"S": "No One You Know"}]},
               "release_date": {"S": "2023-07-21"}
           }}
       }'
   ```

1. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

   ```
   aws dynamodb scan --table-name myMusicTable  --region us-east-1
   ```

------
#### [ Using the AWS SDK for Java 2.x ]

1. Creare una tabella. L'esempio seguente utilizza l'[CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html)API per creare una tabella denominata. `myMusicTable`

   ```
   DynamoDbClient dynamoDB = DynamoDbClient.builder().region(region).build();
   CreateTableRequest createTableRequest = CreateTableRequest.builder()
       .attributeDefinitions(
           Arrays.asList(
               AttributeDefinition.builder()
               .attributeName("id")
               .attributeType(ScalarAttributeType.S)
               .build()
           )
       )
       .keySchema(
           Arrays.asList(
               KeySchemaElement.builder()
               .attributeName("id")
               .keyType(KeyType.HASH)
               .build()
           )
       )
       .provisionedThroughput(ProvisionedThroughput.builder()
           .readCapacityUnits(5L)
           .writeCapacityUnits(5L)
           .build()
       )
       .tableName("myMusicTable")
       .build();
   
   CreateTableResponse createTableResponse = dynamoDB.createTable(createTableRequest);
   String tableArn = createTableResponse.tableDescription().tableArn();
   String tableName = createTableResponse.tableDescription().tableName();
   ```

1. Aggiungi un tag a questa tabella. L'[TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html)API nell'esempio seguente aggiunge la coppia chiave-valore del tag `Title: ProductManager` a. `myMusicTable`

   ```
   TagResourceRequest tagResourceRequest = TagResourceRequest.builder()
       .resourceArn(tableArn)
       .tags(
           Arrays.asList(
               Tag.builder()
               .key("Title")
               .value("ProductManager")
               .build()
           )
       )
       .build();
   dynamoDB.tagResource(tagResourceRequest);
   ```

1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Action": "dynamodb:PutItem",
         "Resource": "arn:aws:dynamodb:*:*:table/*",
         "Condition": {
           "StringEquals": {
             "aws:ResourceTag/Title": "ProductManager"
           }
         }
       }
     ]
   }
   ```

------

   Questa policy consente l’azione `PutItem` sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

1. Assumi il ruolo con le policy descritte nella Fase 3.

1. Usa l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)API per inserire un elemento in. `myMusicTable`

   ```
   HashMap<String, AttributeValue> info = new HashMap<>();
   info.put("rating", AttributeValue.builder().s("9").build());
   info.put("artists", AttributeValue.builder().ss(List.of("Acme Band","No One You Know").build());
   info.put("release_date", AttributeValue.builder().s("2023-07-21").build());
   
   HashMap<String, AttributeValue> itemValues = new HashMap<>();
   itemValues.put("id", AttributeValue.builder().s("2023").build());
   itemValues.put("title", AttributeValue.builder().s("Happy Day").build());
   itemValues.put("info", AttributeValue.builder().m(info).build());
   
   
   PutItemRequest putItemRequest = PutItemRequest.builder()
                   .tableName(tableName)
                   .item(itemValues)
                   .build();
   dynamoDB.putItem(putItemRequest);
   ```

1. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

   ```
   ScanRequest scanRequest = ScanRequest.builder()
                   .tableName(tableName)
                   .build();
                   
   ScanResponse scanResponse = dynamoDB.scan(scanRequest);
   ```

------
#### [ Using the AWS SDK per Python (Boto3) ]

1. Creare una tabella. L'esempio seguente utilizza l'[CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html)API per creare una tabella denominata`myMusicTable`.

   ```
   create_table_response = ddb_client.create_table(
       AttributeDefinitions=[
           {
               'AttributeName': 'id',
               'AttributeType': 'S'
           },
       ],
       TableName='myMusicTable',
       KeySchema=[
           {
               'AttributeName': 'id',
               'KeyType': 'HASH'
           },
       ],
           ProvisionedThroughput={
           'ReadCapacityUnits': 5,
           'WriteCapacityUnits': 5
       },
   )
   
   table_arn = create_table_response['TableDescription']['TableArn']
   ```

1. Aggiungi un tag a questa tabella. L'[TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html)API nell'esempio seguente aggiunge la coppia chiave-valore del tag `Title: ProductManager` a. `myMusicTable`

   ```
   tag_resouce_response = ddb_client.tag_resource(
       ResourceArn=table_arn,
       Tags=[
           {
               'Key': 'Title',
               'Value': 'ProductManager'
           },
       ]
   )
   ```

1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
           "Effect": "Allow",
           "Action": "dynamodb:PutItem",
           "Resource": "arn:aws:dynamodb:*:*:table/*",
           "Condition": {
               "StringEquals": {
               "aws:ResourceTag/Title": "ProductManager"
               }
           }
           }
       ]
       }
   ```

------

   Questa policy consente l’azione `PutItem` sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

1. Assumi il ruolo con le policy descritte nella Fase 3.

1. Usa l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)API per inserire un elemento in. `myMusicTable`

   ```
   put_item_response = client.put_item(
       TableName = 'myMusicTable'
       Item = {
           'id': '2023',
           'title': 'Happy Day',
           'info': {
               'rating': '9',
               'artists': ['Acme Band','No One You Know'],
               'release_date': '2023-07-21'
           }
       }
   )
   ```

1. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

   ```
   scan_response = client.scan(
       TableName='myMusicTable'
   )
   ```

------

**Senza ABAC**  
Se ABAC non è abilitato per te Account AWS, le condizioni dei tag nella policy IAM e nella tabella DynamoDB non corrispondono. Di conseguenza, l’azione `PutItem` restituirà una `AccessDeniedException` a causa dell’effetto della policy `AmazonDynamoDBReadOnlyAccess`.

```
An error occurred (AccessDeniedException) when calling the PutItem operation: User: arn:aws:sts::123456789012:assumed-role/DynamoDBReadOnlyAccess/Alice is not authorized to perform: dynamodb:PutItem on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable because no identity-based policy allows the dynamodb:PutItem action.
```

**Con ABAC**  
Se ABAC è abilitato per la tua Account AWS, l'`put-item`azione viene completata correttamente e aggiunge un nuovo elemento alla tua tabella. Questo perché la policy in linea sulla tabella consente l’azione `PutItem` se le condizioni del tag nella policy IAM e nella tabella corrispondono.

## Esempio 2: consenti un'azione utilizzando aws: RequestTag
<a name="abac-allow-example-request-tag"></a>

Utilizzando la chiave di condizione [aws: RequestTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag), puoi confrontare la coppia chiave-valore del tag passata nella tua richiesta con la coppia di tag specificata nella policy IAM. Ad esempio, è possibile consentire un’azione specifica, come `CreateTable`, usando `aws:RequestTag` se le condizioni del tag non corrispondono. A tal fine, segui questa procedura:

------
#### [ Using the AWS CLI ]

1. Crea una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungila a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html) AWS gestita, come mostrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "dynamodb:CreateTable",
                   "dynamodb:TagResource"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/*",
               "Condition": {
                   "StringEquals": {
                       "aws:RequestTag/Owner": "John"
                   }
               }
           }
       ]
   }
   ```

------

1. Crea una tabella che contenga la coppia chiave-valore del tag di `"Owner": "John"`.

   ```
   aws dynamodb create-table \
   --attribute-definitions AttributeName=ID,AttributeType=S \
   --key-schema AttributeName=ID,KeyType=HASH  \
   --provisioned-throughput ReadCapacityUnits=1000,WriteCapacityUnits=500 \
   --region us-east-1 \
   --tags Key=Owner,Value=John \
   --table-name myMusicTable
   ```

------
#### [ Using the AWS SDK per Python (Boto3) ]

1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "dynamodb:CreateTable",
                   "dynamodb:TagResource"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/*",
               "Condition": {
                   "StringEquals": {
                       "aws:RequestTag/Owner": "John"
                   }
               }
           }
       ]
   }
   ```

------

1. Crea una tabella che contenga la coppia chiave-valore del tag di `"Owner": "John"`.

   ```
   ddb_client = boto3.client('dynamodb')
   
   create_table_response = ddb_client.create_table(
       AttributeDefinitions=[
           {
               'AttributeName': 'id',
               'AttributeType': 'S'
           },
       ],
       TableName='myMusicTable',
       KeySchema=[
           {
               'AttributeName': 'id',
               'KeyType': 'HASH'
           },
       ],
           ProvisionedThroughput={
           'ReadCapacityUnits': 1000,
           'WriteCapacityUnits': 500
       },
       Tags=[
           {
               'Key': 'Owner',
               'Value': 'John'
           },
       ],
   )
   ```

------

**Senza ABAC**  
Se ABAC non è abilitato per te Account AWS, le condizioni dei tag nella politica in linea e nella tabella DynamoDB non corrispondono. Di conseguenza, la richiesta `CreateTable` non andrà a buon fine e la tabella non verrà creata.

```
An error occurred (AccessDeniedException) when calling the CreateTable operation: User: arn:aws:sts::123456789012:assumed-role/Admin/John is not authorized to perform: dynamodb:CreateTable on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable because no identity-based policy allows the dynamodb:CreateTable action.
```

**Con ABAC**  
Se ABAC è abilitato per la tua Account AWS, la richiesta di creazione della tabella viene completata correttamente. Poiché la coppia chiave-valore del tag `"Owner": "John"` è presente nella richiesta `CreateTable`, la policy in linea consente all’utente `John` di eseguire l’azione `CreateTable`.

## Esempio 3: Negare un'azione utilizzando aws: TagKeys
<a name="abac-deny-example-tag-key"></a>

Utilizzando la chiave [aws: TagKeys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys) condition, puoi confrontare le chiavi dei tag in una richiesta con le chiavi specificate nella policy IAM. Ad esempio, è possibile negare un’azione specifica, come `CreateTable`, utilizzando `aws:TagKeys` se una chiave di tag specifica *non* è presente nella richiesta. A tal fine, segui questa procedura:

------
#### [ Using the AWS CLI ]

1. Aggiungi una [policy gestita dai clienti](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un ruolo a cui è associata la policy AWS gestita di [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html), come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Deny",
               "Action": [
                   "dynamodb:CreateTable",
                   "dynamodb:TagResource"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/*",
               "Condition": {
                   "Null": {
                       "aws:TagKeys": "false"
                   },
                   "ForAllValues:StringNotEquals": {
                       "aws:TagKeys": "CostCenter"
                   }
               }
           }
       ]
   }
   ```

------

1. Assumi il ruolo a cui è stata associata la policy e crea una tabella con la chiave del tag `Title`.

   ```
   aws dynamodb create-table \
   --attribute-definitions AttributeName=ID,AttributeType=S \
   --key-schema AttributeName=ID,KeyType=HASH  \
   --provisioned-throughput ReadCapacityUnits=1000,WriteCapacityUnits=500 \
   --region us-east-1 \
   --tags Key=Title,Value=ProductManager \
   --table-name myMusicTable
   ```

------
#### [ Using the AWS SDK per Python (Boto3) ]

1. Aggiungere una [politica gestita dai clienti](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un ruolo a cui è associata la politica di AWS gestione degli [AmazonDynamoDBFullaccessi](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html), come illustrato nell'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Deny",
               "Action": [
                   "dynamodb:CreateTable",
                   "dynamodb:TagResource"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/*",
               "Condition": {
                   "Null": {
                       "aws:TagKeys": "false"
                   },
                   "ForAllValues:StringNotEquals": {
                       "aws:TagKeys": "CostCenter"
                   }
               }
           }
       ]
   }
   ```

------

1. Assumi il ruolo a cui è stata associata la policy e crea una tabella con la chiave del tag `Title`.

   ```
   ddb_client = boto3.client('dynamodb')
   
   create_table_response = ddb_client.create_table(
       AttributeDefinitions=[
           {
               'AttributeName': 'id',
               'AttributeType': 'S'
           },
       ],
       TableName='myMusicTable',
       KeySchema=[
           {
               'AttributeName': 'id',
               'KeyType': 'HASH'
           },
       ],
           ProvisionedThroughput={
           'ReadCapacityUnits': 1000,
           'WriteCapacityUnits': 500
       },
       Tags=[
           {
               'Key': 'Title',
               'Value': 'ProductManager'
           },
       ],
   )
   ```

------

**Senza ABAC**  
Se ABAC non è abilitato per il tuo Account AWS, DynamoDB non invia le chiavi dei tag nel `create-table` comando a IAM. La condizione `Null` garantisce che la condizione restituisca `false` in assenza di chiavi di tag nella richiesta. Poiché la policy `Deny` non corrisponde, il comando `create-table` verrà completato correttamente.

**Con ABAC**  
Se ABAC è abilitato per il tuo Account AWS, le chiavi dei tag passate nel `create-table` comando vengono passate a IAM. La chiave del tag `Title` verrà valutata rispetto alla chiave del tag basata sulla condizione, `CostCenter`, presente nella policy `Deny`. La chiave del tag `Title` non corrisponde alla chiave del tag presente nella policy `Deny` a causa dell’operatore `StringNotEquals`. Pertanto, l’azione `CreateTable` non andrà a buon fine e la tabella non verrà creata. L’esecuzione del comando `create-table` restituisce una `AccessDeniedException`.

```
An error occurred (AccessDeniedException) when calling the CreateTable operation: User: arn:aws:sts::123456789012:assumed-role/DynamoFullAccessRole/ProductManager is not authorized to perform: dynamodb:CreateTable on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable with an explicit deny in an identity-based policy.
```