# Usar o controle de acesso por atributo com o DynamoDB
O [controle de acesso por atributo (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) é uma estratégia de autorização que define as permissões de acesso com base em [condições de tag](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) em suas políticas baseadas em identidade ou em outras políticas da AWS, como políticas baseadas em recursos e políticas do IAM da organização. É possível anexar tags às tabelas do DynamoDB, que são então avaliadas em relação às condições baseadas em tags. Os índices associados a uma tabela herdam as tags adicionadas à tabela. É possível adicionar até cinquenta tags a cada tabela do DynamoDB. O tamanho máximo aceito para todas as tags em uma tabela é de 10 KB. Para ter mais informações sobre a marcação de recursos do DynamoDB e restrições de marcação, consulte [Marcar recursos no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.Operations.html) e [Restrições de marcação no DynamoDB](Tagging.md#TaggingRestrictions).
Para ter informações sobre como usar essas tags para controlar o acesso aos recursos da AWS, consulte no Guia do usuário do IAM:
+ [What is ABAC for AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)
+ [Controlar o acesso a recursos da AWS usando tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)
Com o uso do ABAC, é possível impor diferentes níveis de acesso para que suas equipes e aplicações realizem ações nas tabelas do DynamoDB usando menos políticas. É possível especificar uma tag no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política do IAM para controlar o acesso às tabelas ou aos índices do DynamoDB. Essas condições determinam o nível de acesso que uma entidade principal do IAM, um usuário ou um perfil tem às tabelas e aos índices do DynamoDB. Quando uma entidade principal do IAM faz uma solicitação de acesso ao DynamoDB, as tags do recurso e da identidade são avaliadas em relação às condições de tag na política do IAM. Depois disso, a política será efetiva somente se as condições de tag forem atendidas. Isso permite criar uma política do IAM que informe efetivamente uma das seguintes opções:
+ *Permitir que o usuário gerencie apenas os recursos que têm uma tag com uma chave `X` e um valor `Y`*.
+ *Negar acesso a todos os usuários aos recursos marcados com uma chave `X`*.
Por exemplo, é possível criar uma política que permita que os usuários atualizem uma tabela apenas se ela tiver o par de chave-valor de tag: `"environment": "staging"`. É possível usar a chave de condição [aws:ResourceTag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) para permitir ou negar acesso a uma tabela com base nas tags anexadas a essa tabela.
É possível incluir condições baseadas em atributos ao criar a política ou posteriormente usar o Console de gerenciamento da AWS, a API da AWS, a AWS Command Line Interface (AWS CLI), o AWS SDK ou o AWS CloudFormation.
O exemplo a seguir permite a ação [UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) em uma tabela chamada `MusicTable` se ela incluir uma chave de tag com o nome `environment` e o valor `production`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/MusicTable",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
]
}
```
------
**Topics**
+ [Por que devo usar o ABAC?](#why-use-abac)
+ [Chaves de condição para implementar o ABAC com o DynamoDB](#condition-keys-implement-abac)
+ [Considerações sobre o uso do ABAC com o DynamoDB](#abac-considerations)
+ [Habilitar o ABAC no DynamoDB](abac-enable-ddb.md)
+ [Usar o ABAC com tabelas e índices do DynamoDB](abac-implementation-ddb-tables.md)
+ [Exemplos de uso do ABAC com tabelas e índices do DynamoDB](abac-example-use-cases.md)
+ [Solução de problemas comuns de ABAC para tabelas e índices do DynamoDB](abac-troubleshooting.md)
## Por que devo usar o ABAC?
+ **Gerenciamento de políticas mais simples:** é possível usar menos políticas porque não é necessário criar políticas diferentes para definir o nível de acesso para cada entidade principal do IAM.
+ **Controle de acesso escalável:** ajustar a escala do controle de acesso é mais fácil com o ABAC, pois não é necessário atualizar as políticas ao criar recursos do DynamoDB. É possível usar tags para autorizar o acesso às entidades principais do IAM que contêm tags correspondentes às tags do recurso. É possível integrar novas entidades principais do IAM ou recursos do DynamoDB e aplicar as tags apropriadas para conceder automaticamente as permissões necessárias sem precisar fazer nenhuma alteração na política.
+ **Gerenciamento de permissões refinado:** é prática recomendada [conceder o privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) ao criar políticas. Com o uso do ABAC, é possível criar tags para a entidade principal do IAM e usá-las para conceder acesso a ações e recursos específicos que correspondam às tags na entidade principal do IAM.
+ **Alinhamento com o diretório corporativo:** é possível associar tags a atributos de funcionários existentes do seu diretório corporativo com o objetivo de alinhar suas políticas de controle de acesso à estrutura organizacional.
## Chaves de condição para implementar o ABAC com o DynamoDB
É possível usar as seguintes chaves de condição nas políticas da AWS para controlar o nível de acesso às suas tabelas e índices do DynamoDB:
+ [aws:ResourceTag/tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag): controla o acesso com base no fato de o par de chave-valor da tag em uma tabela ou um índice do DynamoDB corresponder ou não à chave e ao valor da tag em uma política. Essa chave de condição é relevante para todas as APIs que operam em uma tabela ou um índice existente.
As condições `dynamodb:ResourceTag` são avaliadas como se você não tivesse anexado nenhuma tag a um recurso.
+ [aws:RequestTag/tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag): permite comparar o par de chave/valor da tag que foi transmitido na solicitação com o par de tags especificado na política. Essa chave de condição é relevante para APIs que contêm tags como parte da carga útil da solicitação. Essas APIs incluem [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) e [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html).
+ [aws:TagKeys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys): compara as chaves de tag em uma solicitação com as chaves especificadas na política. Essa chave de condição é relevante para APIs que contêm tags como parte da carga útil da solicitação. Essas APIs incluem `CreateTable`, `TagResource` e `UntagResource`.
## Considerações sobre o uso do ABAC com o DynamoDB
Ao usar o ABAC com tabelas ou índices do DynamoDB, as seguintes considerações se aplicam:
+ A marcação e o ABAC não são aceitos no DynamoDB Streams.
+ A marcação e o ABAC não são aceitos em backups do DynamoDB. Para usar o ABAC com backups, recomendamos usar o [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html).
+ As tags não são preservadas nas tabelas restauradas. É necessário adicionar tags às tabelas restauradas para usar condições baseadas em tags em políticas.
# Habilitar o ABAC no DynamoDB
Para a maioria das Contas da AWS, o ABAC é habilitado por padrão. Usando o [console do DynamoDB](https://console.aws.amazon.com/dynamodb/), é possível confirmar se o ABAC está habilitado para sua conta. Para fazer isso, abra o console do DynamoDB com um perfil que tenha a permissão [dynamodb:GetAbacStatus](#required-permissions-abac). Depois, abra a página **Configurações** do console do DynamoDB.
Se você não vir o cartão **Controle de acesso por atributo** ou se o cartão exibir o status **Ativado**, isso significa que o ABAC está habilitado para sua conta. No entanto, se você vir o cartão **Controle de acesso por atributo** com o status **Desativado**, conforme mostrado na imagem a seguir, o ABAC não está habilitado para sua conta.
## Controle de acesso por atributo: não habilitado
![\[Página Configurações no console do DynamoDB que mostra o cartão Controle de acesso por atributo.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/ddb-console-settings-page.png)
O ABAC não está habilitado para Contas da AWS para as quais as condições baseadas em tags especificadas nas políticas baseadas em identidade ou em outras políticas ainda precisam ser auditadas. Se o ABAC não estiver habilitado para sua conta, as condições baseadas em tags nas políticas destinadas a atuar nas tabelas ou nos índices do DynamoDB serão avaliadas como se nenhuma tag estivesse presente nos recursos ou nas solicitações de API. Quando o ABAC está habilitado para sua conta, as condições baseadas em tags nas políticas da conta são avaliadas levando em conta as tags anexadas às tabelas ou às solicitações de API.
Para habilitar o ABAC para sua conta, recomendamos primeiro auditar as políticas conforme descrito na seção [Auditoria de políticas](#policy-audit-for-abac). Depois, inclua as [permissões necessárias para o ABAC](#required-permissions-abac) na política do IAM. Por fim, siga as etapas descritas em [Habilitar o ABAC no console](#abac-enable-console) para habilitar o ABAC para sua conta na região atual. Depois de habilitar o ABAC, é possível cancelá-lo nos próximos sete dias corridos após a adesão.
**Topics**
+ [Auditar as políticas antes de habilitar o ABAC](#policy-audit-for-abac)
+ [Permissões do IAM necessárias para habilitar o ABAC](#required-permissions-abac)
+ [Habilitar o ABAC no console](#abac-enable-console)
## Auditar as políticas antes de habilitar o ABAC
Antes de habilitar o ABAC para sua conta, audite as políticas para confirmar se as condições baseadas em tags que possam existir nas políticas da conta estão configuradas conforme o pretendido. A auditoria das políticas ajudará a evitar surpresas com alterações de autorização nos fluxos de trabalho do DynamoDB após a habilitação do ABAC. Para ver exemplos do uso de condições baseadas em atributos com tags e o comportamento antes e depois da implementação do ABAC, consulte [Exemplos de uso do ABAC com tabelas e índices do DynamoDBExemplo de casos de uso](abac-example-use-cases.md).
## Permissões do IAM necessárias para habilitar o ABAC
É necessário ter a permissão `dynamodb:UpdateAbacStatus` para habilitar o ABAC para sua conta na região atual. Para confirmar se o ABAC está habilitado para a conta, você também deve ter a permissão `dynamodb:GetAbacStatus`. Com essa permissão, é possível visualizar o status do ABAC para uma conta em qualquer região. É necessário ter essas permissões além da permissão necessária para acessar o console do DynamoDB.
A política do IAM a seguir concede a permissão para habilitar o ABAC e visualizar seu status para uma conta na região atual.
```
{
"version": "2012-10-17", &TCX5-2025-waiver;
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateAbacStatus",
"dynamodb:GetAbacStatus"
],
"Resource": "*"
}
]
}
```
## Habilitar o ABAC no console
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação superior, escolha a região para a qual você deseja habilitar o ABAC.
1. No painel de navegação esquerdo, escolha **Configurações**.
1. Na página **Configurações**, faça o seguinte:
1. No cartão **Controle de acesso por atributo**, escolha **Habilitar**.
1. Na caixa **Confirmar configuração de controle de acesso por atributo**, escolha **Habilitar** para confirmar sua escolha.
Isso habilita o ABAC para a região atual e o cartão **Controle de acesso por atributo** mostra o status **Ativado**.
Se você quiser cancelar a habilitação do ABAC no console, poderá fazer isso nos próximos sete dias corridos após a habilitação. Para cancelar a habilitação, escolha **Desabilitar** no cartão **Controle de acesso por atributo** na página **Configurações**.
**nota**
A atualização do status do ABAC é uma operação assíncrona. Se as tags em suas políticas não forem avaliadas imediatamente, talvez seja necessário esperar algum tempo, pois a aplicação das alterações será finalmente consistente.
# Usar o ABAC com tabelas e índices do DynamoDB
As etapas a seguir demonstram como configurar permissões usando o ABAC. Neste cenário de exemplo, você adicionará tags a uma tabela do DynamoDB e criará um perfil do IAM com uma política que inclui condições baseadas em tags. Depois, você testará as permissões permitidas na tabela do DynamoDB combinando as condições da tag.
**Topics**
+ [Etapa 1: adicionar tags a uma tabela do DynamoDB](#abac-add-table-tags)
+ [Etapa 2: criar um perfil do IAM com uma política que inclui condições baseadas em tags](#abac-create-iam-role)
+ [Etapa 3: testar permissões](#abac-test-permissions)
## Etapa 1: adicionar tags a uma tabela do DynamoDB
É possível adicionar tags a tabelas novas ou existentes do DynamoDB usando o Console de gerenciamento da AWS, a API da AWS, a AWS Command Line Interface (AWS CLI), o AWS SDK ou o AWS CloudFormation. Por exemplo, o comando da CLI [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) a seguir adiciona uma tag a uma tabela chamada `MusicTable`.
```
aws dynamodb tag-resource —resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/MusicTable —tags Key=environment,Value=staging
```
## Etapa 2: criar um perfil do IAM com uma política que inclui condições baseadas em tags
[Crie uma política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor) usando a chave de condição [aws:ResourceTag/tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) para comparar o par de chave-valor da tag especificado na política do IAM com o par de chave-valor anexado à tabela. O seguinte exemplo de política permite que os usuários coloquem ou atualizem itens em tabelas caso essas tabelas contenham o par de chave-valor de tag: `"environment": "staging"`. Se uma tabela não tiver o par de chave-valor de tag especificado, essas ações serão negadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "staging"
}
}
}
]
}
```
------
## Etapa 3: testar permissões
1. Anexe a política do IAM a um usuário ou um perfil de teste à sua Conta da AWS. Assegure-se de que a entidade principal do IAM utilizada não tenha acesso à tabela do DynamoDB por meio de uma política diferente.
1. Assegure-se de que sua tabela do DynamoDB contenha a chave de tag `"environment"` com um valor de `"staging"`.
1. Realize as ações `dynamodb:PutItem` e `dynamodb:UpdateItem` na tabela marcada. Essas ações devem ser bem-sucedidas caso o par de chave-valor de tag `"environment": "staging"` esteja presente.
Se você realizar essas ações em uma tabela que não tenha o par de chave-valor de tag `"environment": "staging"`, sua solicitação falhará com uma `AccessDeniedException`.
Você também pode analisar os outros [exemplos de casos de uso](abac-example-use-cases.md) descritos na seção a seguir para implementar o ABAC e realizar mais testes.
# Exemplos de uso do ABAC com tabelas e índices do DynamoDB
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
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 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 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
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
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.
```
# Solução de problemas comuns de ABAC para tabelas e índices do DynamoDB
Este tópico oferece conselhos para solução de erros e problemas comuns que você pode encontrar ao implementar o ABAC em tabelas ou índices do DynamoDB.
## Chaves de condição específicas do serviço em políticas geram um erro
Chaves de condição específicas do serviço não são consideradas chaves de condição válidas. Se você usou essas chaves em suas políticas, elas gerarão um erro. Para corrigir esse problema, você deve substituir as chaves de condição específicas do serviço por uma [chave de condição apropriada para implementar o ABAC](attribute-based-access-control.md#condition-keys-implement-abac) no DynamoDB.
Por exemplo, digamos que você tenha usado a chave de condição `dynamodb:ResourceTag` em uma [política em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) que executa a solicitação [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Imagine que a solicitação falhe com uma `AccessDeniedException`. O exemplo a seguir mostra a política em linha errônea com a chave de condição `dynamodb:ResourceTag`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"dynamodb:ResourceTag/Owner": "John"
}
}
}
]
}
```
------
Para corrigir esse problema, substitua a chave de condição `dynamodb:ResourceTag` por `aws:ResourceTag`, 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/Owner": "John"
}
}
}
]
}
```
------
## Não é possível cancelar o ABAC
Se o ABAC foi habilitado para sua conta por meio do Suporte, você não poderá cancelá-lo pelo console do DynamoDB. Para cancelá-lo, entre em contato com o [Suporte](https://console.aws.amazon.com/support).
Você mesmo poderá cancelar o ABAC *somente se* as seguintes condições forem verdadeiras:
+ Você usou o método de autoatendimento para [ativar por meio do console do DynamoDB](abac-enable-ddb.md#abac-enable-console).
+ Você está cancelando o recurso em até sete dias corridos após a ativação.