# Exemplos de uso do ABAC com tabelas e índices do DynamoDB
<a name="abac-example-use-cases"></a>

Os exemplos a seguir descrevem alguns casos de uso para implementar condições baseadas em atributos usando tags.

**Topics**
+ [Exemplo 1: permitir uma ação usando aws:ResourceTag](#abac-allow-example-resource-tag)
+ [Exemplo 2: permitir uma ação usando aws:RequestTag](#abac-allow-example-request-tag)
+ [Exemplo 3: negar uma ação usando aws:TagKeys](#abac-deny-example-tag-key)

## Exemplo 1: permitir uma ação usando aws:ResourceTag
<a name="abac-allow-example-resource-tag"></a>

Usando a chave de condição `aws:ResourceTag/tag-key`, é possível comparar o par de chave-valor da tag especificado em uma política do IAM com o par de chave-valor anexado a uma tabela do DynamoDB. Por exemplo, é possível permitir uma ação específica, como [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html), caso haja correspondência das condições da tag em uma política do IAM e em uma tabela. Para fazer isso, execute as seguintes etapas:

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

1. Crie uma tabela. O exemplo a seguir usa o comando [create-table](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html) da AWS CLI para criar uma tabela chamada `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. Adicione uma tag a essa tabela. O exemplo de comando [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) da AWS CLI a seguir adiciona o par de chave-valor de tag `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. Crie uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e adicione-a a um perfil que tenha a política gerenciada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

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

****  

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

------

   Essa política permite a ação `PutItem` na tabela quando a chave e o valor da tag anexados à tabela correspondem às tags especificadas na política.

1. Assuma o perfil com as políticas descritas na Etapa 3.

1. Use o comando [put-item](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html) da AWS CLI para inserir um item na `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. Verifique a tabela para saber se o item foi adicionado a ela.

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

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

1. Crie uma tabela. O exemplo a seguir usa a API [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) para criar uma tabela chamada `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. Adicione uma tag a essa tabela. A API [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html) no exemplo a seguir adiciona o par de chave-valor de tag `Title: ProductManager` à `myMusicTable`.

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

1. Crie uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e adicione-a a um perfil que tenha a política gerenciada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

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

****  

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

------

   Essa política permite a ação `PutItem` na tabela quando a chave e o valor da tag anexados à tabela correspondem às tags especificadas na política.

1. Assuma o perfil com as políticas descritas na Etapa 3.

1. Use a API [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) para colocar um item na `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. Verifique a tabela para saber se o item foi adicionado a ela.

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

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

1. Crie uma tabela. O exemplo a seguir usa a API [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) para criar uma tabela chamada `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. Adicione uma tag a essa tabela. A API [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html) no exemplo a seguir adiciona o par de chave-valor de tag `Title: ProductManager` à `myMusicTable`.

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

1. Crie uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e adicione-a a um perfil que tenha a política gerenciada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

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

****  

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

------

   Essa política permite a ação `PutItem` na tabela quando a chave e o valor da tag anexados à tabela correspondem às tags especificadas na política.

1. Assuma o perfil com as políticas descritas na Etapa 3.

1. Use a API [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) para colocar um item na `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. Verifique a tabela para saber se o item foi adicionado a ela.

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

------

**Sem ABAC**  
Se o ABAC não estiver habilitado para a Conta da AWS, as condições de tag na política do IAM e na tabela do DynamoDB não serão correspondentes. Consequentemente, a ação `PutItem` exibirá uma `AccessDeniedException` devido ao efeito da política `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.
```

**Com ABAC**  
Se o ABAC estiver habilitado para a Conta da AWS, a ação `put-item` será concluída com êxito e adicionará um novo item à tabela. Isso ocorre porque a política em linha na tabela permite a ação `PutItem` caso as condições de tag na política do IAM e na tabela coincidam.

## Exemplo 2: permitir uma ação usando aws:RequestTag
<a name="abac-allow-example-request-tag"></a>

Usando a chave de condição [aws:RequestTag/tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag), você pode comparar o par de chave-valor de tag que é transmitido em sua solicitação com o par de tags especificado na política do IAM. Por exemplo, você pode permitir uma ação específica, como `CreateTable`, usando o `aws:RequestTag` caso as condições de tag não coincidam. Para fazer isso, execute as seguintes etapas:

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

1. Crie uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e adicione-a a um perfil que tenha a política gerenciada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

------
#### [ 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. Crie uma tabela que contenha o par de chave-valor de tag `"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 para Python (Boto3) ]

1. Crie uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e adicione-a a um perfil que tenha a política gerenciada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

------
#### [ 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. Crie uma tabela que contenha o par de chave-valor de tag `"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'
           },
       ],
   )
   ```

------

**Sem ABAC**  
Se o ABAC não estiver habilitado para a Conta da AWS, as condições de tag na política em linha e na tabela do DynamoDB não vão coincidir. Consequentemente, a solicitação `CreateTable` falhará e a tabela não será criada.

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

**Com ABAC**  
Se o ABAC estiver habilitado para a Conta da AWS, sua solicitação de criação de tabela será concluída com êxito. Como o par de chave-valor de tag `"Owner": "John"` está presente na solicitação `CreateTable`, a política em linha permite que o usuário `John` realize a ação `CreateTable`.

## Exemplo 3: negar uma ação usando aws:TagKeys
<a name="abac-deny-example-tag-key"></a>

Usando a chave de condição [aws:TagKeys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys), você pode comparar as chaves de tag em uma solicitação com as chaves especificadas na política do IAM. Por exemplo, será possível negar uma ação específica, como `CreateTable`, usando `aws:TagKeys` se uma chave de tag específica *não* estiver presente na solicitação. Para fazer isso, execute as seguintes etapas:

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

1. Adicione uma [política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a um perfil que tenha a política gerenciada [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

------
#### [ 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. Assuma o perfil ao qual a política foi anexada e crie uma tabela com a chave de 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 para Python (Boto3) ]

1. Adicione uma [política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a um perfil que tenha a política gerenciada [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html) pela AWS anexada a ela, conforme mostrado no exemplo a seguir.

------
#### [ 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. Assuma o perfil ao qual a política foi anexada e crie uma tabela com a chave de 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'
           },
       ],
   )
   ```

------

**Sem ABAC**  
Se o ABAC não estiver habilitado para a Conta da AWS, o DynamoDB não enviará as chaves de tag no comando `create-table` ao IAM. A condição `Null` garante que a condição seja avaliada como `false` caso não haja tags na solicitação. Como a política `Deny` não coincide, o comando `create-table` é concluído com êxito.

**Com ABAC**  
Se o ABAC estiver habilitado para a Conta da AWS, as chaves de tag transmitidas no comando `create-table` serão enviadas ao IAM. A chave de tag `Title` é avaliada em relação à chave de tag baseada em condições, `CostCenter`, presente na política `Deny`. A chave de tag `Title` não corresponde à chave de tag presente na política `Deny` por causa do operador `StringNotEquals`. Portanto, a ação `CreateTable` falha e sua tabela não é criada. A execução do comando `create-table` exibe uma `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.
```