# Ejemplos para utilizar ABAC con tablas e índices de DynamoDB
<a name="abac-example-use-cases"></a>

En los siguientes ejemplos se describen algunos casos de uso para implementar condiciones basadas en atributos mediante etiquetas.

**Topics**
+ [Ejemplo 1: Permitir una acción con aws:ResourceTag](#abac-allow-example-resource-tag)
+ [Ejemplo 2: Concesión de permiso a una acción mediante aws:RequestTag](#abac-allow-example-request-tag)
+ [Ejemplo 3: Denegación de una acción mediante aws:TagKeys](#abac-deny-example-tag-key)

## Ejemplo 1: Permitir una acción con aws:ResourceTag
<a name="abac-allow-example-resource-tag"></a>

Con la clave de condición `aws:ResourceTag/tag-key`, puede comparar el par clave-valor de etiqueta que está especificado en una política de IAM con el par clave-valor que está asociado con una tabla de DynamoDB. Por ejemplo, puede permitir una acción específica, como [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html), si las condiciones de etiqueta coinciden en una política de IAM y en una tabla. Para ello, siga estos pasos:

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

1. Crear una tabla. En el siguiente ejemplo se utiliza el comando [create-table](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html) de la AWS CLI para crear una tabla denominada `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. Agregue una etiqueta a esta tabla. El siguiente ejemplo de comando [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) de la AWS CLI agrega el par clave-valor de etiqueta `Title: ProductManager` a `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. Cree una [política insertada](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) y agréguela a un rol que tenga asociada la política administrada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) de AWS, como se muestra en el siguiente ejemplo.

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

****  

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

------

   Esta política permite la `PutItem` en la tabla cuando la clave y el valor de etiqueta asociados a la tabla coinciden con las etiquetas especificadas en la política.

1. Asuma el rol con las políticas descritas en el paso 3.

1. Utilice el comando [put-item](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html) de la AWS CLI para colocar un elemento en `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. Examine la tabla para comprobar si el elemento se ha agregado a ella.

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

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

1. Crear una tabla. En el siguiente ejemplo se utiliza la API [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) para crear una tabla denominada `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. Agregue una etiqueta a esta tabla. La API [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html) del siguiente ejemplo agrega el par clave-valor de etiqueta `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. Cree una [política insertada](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) y agréguela a un rol que tenga asociada la política administrada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) de AWS, como se muestra en el siguiente ejemplo.

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

****  

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

------

   Esta política permite la `PutItem` en la tabla cuando la clave y el valor de etiqueta asociados a la tabla coinciden con las etiquetas especificadas en la política.

1. Asuma el rol con las políticas descritas en el paso 3.

1. Utilice la API [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) para colocar un elemento en `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. Examine la tabla para comprobar si el elemento se ha agregado a ella.

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

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

1. Crear una tabla. En el siguiente ejemplo se utiliza la API [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) para crear una tabla denominada `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. Agregue una etiqueta a esta tabla. La API [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html) del siguiente ejemplo agrega el par clave-valor de etiqueta `Title: ProductManager` a `myMusicTable`.

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

1. Cree una [política insertada](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) y agréguela a un rol que tenga asociada la política administrada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) de AWS, como se muestra en el siguiente ejemplo.

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

****  

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

------

   Esta política permite la `PutItem` en la tabla cuando la clave y el valor de etiqueta asociados a la tabla coinciden con las etiquetas especificadas en la política.

1. Asuma el rol con las políticas descritas en el paso 3.

1. Utilice la API [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) para colocar un elemento en `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. Examine la tabla para comprobar si el elemento se ha agregado a ella.

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

------

**Sin ABAC**  
Si ABAC no está habilitado para la Cuenta de AWS, las condiciones de etiquetado de la política de IAM y la tabla de DynamoDB no coinciden. En consecuencia, la acción `PutItem` devuelve `AccessDeniedException` debido al efecto de la 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.
```

**Con ABAC**  
Si ABAC está habilitado para la Cuenta de AWS, la acción `put-item` se completa correctamente y agrega un nuevo elemento a la tabla. Esto se debe a que la política insertada en la tabla permite la acción `PutItem` si coinciden las condiciones de etiqueta de la política de IAM y de la tabla.

## Ejemplo 2: Concesión de permiso a una acción mediante aws:RequestTag
<a name="abac-allow-example-request-tag"></a>

Con la clave de condición [aws:RequestTag/tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag), puede comparar el par clave-valor de etiqueta que se pasa en la solicitud con el par de etiquetas especificado en la política de IAM. Por ejemplo, puede permitir una acción específica, como `CreateTable`, mediante `aws:RequestTag` si las condiciones de etiqueta no coinciden. Para ello, siga estos pasos:

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

1. Cree una [política insertada](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) y agréguela a un rol que tenga asociada la política administrada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html) de AWS, como se muestra en el siguiente ejemplo.

------
#### [ 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. Cree una tabla que contenga el par clave-valor de etiqueta de `"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. Cree una [política insertada](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) y agréguela a un rol que tenga asociada la política administrada [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) de AWS, como se muestra en el siguiente ejemplo.

------
#### [ 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. Cree una tabla que contenga el par clave-valor de etiqueta de `"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'
           },
       ],
   )
   ```

------

**Sin ABAC**  
Si ABAC no está habilitado para la Cuenta de AWS, las condiciones de etiquetado de la política insertada y la tabla de DynamoDB no coinciden. En consecuencia, se produce un error en la solicitud `CreateTable` y no se crea la tabla.

```
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**  
Si ABAC está habilitado para la Cuenta de AWS, la solicitud de creación de tabla se completa correctamente. Como el par clave-valor de etiqueta de `"Owner": "John"` está presente en la solicitud `CreateTable`, la política insertada permite al usuario `John` realizar la acción `CreateTable`.

## Ejemplo 3: Denegación de una acción mediante aws:TagKeys
<a name="abac-deny-example-tag-key"></a>

Con la clave de condición [aws:TagKeys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys) puede comparar las claves de etiqueta de una solicitud con las claves especificadas en la política de IAM. Por ejemplo, puede denegar una acción específica, como `CreateTable`, mediante `aws:TagKeys` si una clave de etiqueta específica *no* está presente en la solicitud. Para ello, siga estos pasos:

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

1. Agregue una [política administrada por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un rol que tenga asociada la política administrada [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html) de AWS, como se muestra en el siguiente ejemplo.

------
#### [ 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. Asuma el rol al que se ha asociado la política y cree una tabla con la clave de etiqueta `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. Agregue una [política administrada por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un rol que tenga asociada la política administrada [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html) de AWS, como se muestra en el siguiente ejemplo.

------
#### [ 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. Asuma el rol al que se ha asociado la política y cree una tabla con la clave de etiqueta `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'
           },
       ],
   )
   ```

------

**Sin ABAC**  
Si ABAC no está habilitado para la Cuenta de AWS, DynamoDB no envía las claves de etiqueta del comando `create-table` a IAM. La condición `Null` garantiza que la condición se evalúe como `false` si no hay claves de etiqueta en la solicitud. Como la política `Deny` no coincide, el comando `create-table` se completa correctamente.

**Con ABAC**  
Si ABAC está habilitado para la Cuenta de AWS, las claves de etiqueta pasadas en el comando `create-table` se pasan a IAM. La clave de etiqueta `Title` se evalúa con respecto a la clave de etiqueta basada en condiciones, `CostCenter`, presente en la política `Deny`. La clave de etiqueta `Title` no coincide con la clave de etiqueta presente en la política `Deny` debido al operador `StringNotEquals`. Por lo tanto, se produce un error en la acción `CreateTable` y la tabla no se crea. Al ejecutar el comando `create-table`, se devuelve `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.
```