

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando a segurança em nível de linha no Amazon Quick
<a name="row-level-security"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 

Na edição Enterprise do Amazon Quick, você pode restringir o acesso a um conjunto de dados configurando a segurança em nível de linha (RLS) nele. Você pode fazer isso antes ou depois de compartilhar o conjunto de dados. Quando você compartilha um conjunto de dados com RLS com proprietários de conjuntos de dados, eles ainda poderão visualizar todos os dados. No entanto, quando você o compartilha com leitores, eles poderão visualizar somente os dados restritos pelas regras do conjunto de dados de permissão.

Além disso, ao incorporar painéis do Amazon Quick em seu aplicativo para usuários não registrados do Quick, você pode usar a segurança em nível de linha (RLS) para dados com tags. filter/restrict Uma tag é uma string especificada pelo usuário que identifica uma sessão em seu aplicativo. Você pode usar tags para implementar controles de RLS para seus conjuntos de dados. Ao configurar restrições baseadas em RLS em conjuntos de dados, o Quick filtra os dados com base nas tags de sessão vinculadas à identidade/sessão do usuário.

Você pode restringir o acesso a um conjunto de dados usando regras baseadas em nomes de usuários ou em grupos, regras baseadas em tags ou ambas.

Escolha regras baseadas no usuário se quiser proteger os dados de usuários ou grupos provisionados (registrados) no Quick. Para fazer isso, selecione um conjunto de dados de permissões que contenha regras definidas por colunas para cada usuário ou grupo com acesso aos dados. Somente usuários ou grupos identificados nas regras terão acesso aos dados.

Escolha regras baseadas em tags somente se você estiver usando painéis incorporados e quiser proteger dados para usuários não provisionados (usuários não registrados) no Quick. Para fazer isso, defina tags nas colunas para proteger os dados. Os valores para as tags devem ser aprovados ​​ao incorporar painéis.

**Topics**
+ [Uso da segurança por linha com regras baseadas em usuários para restringir o acesso a um conjunto de dados](restrict-access-to-a-data-set-using-row-level-security.md)
+ [Uso da segurança por linha com regras baseadas em etiquetas para restringir o acesso ao conjunto de dados ao realizar a incorporação de painéis para usuários anônimos](quicksight-dev-rls-tags.md)

# Uso da segurança por linha com regras baseadas em usuários para restringir o acesso a um conjunto de dados
<a name="restrict-access-to-a-data-set-using-row-level-security"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 

Na edição Enterprise do Amazon Quick, você pode restringir o acesso a um conjunto de dados configurando a segurança em nível de linha (RLS) nele. Você pode fazer isso antes ou depois de compartilhar o conjunto de dados. Quando você compartilha um conjunto de dados com RLS com proprietários de conjuntos de dados, eles ainda poderão visualizar todos os dados. No entanto, quando você o compartilha com leitores, eles poderão visualizar somente os dados restritos pelas regras do conjunto de dados de permissão. Ao adicionar segurança no nível da linha, você pode controlar ainda mais o acesso a eles.

**nota**  
Ao aplicar conjuntos de dados do SPICE à segurança por linha, cada campo no conjunto de dados poderá conter, no máximo, 2.047 caracteres Unicode. Os campos que contêm mais do que essa cota são truncados durante a ingestão. Para saber mais sobre as cotas para dados do SPICE, consulte [Cotas do SPICE para dados importados](data-source-limits.md#spice-limits).

Para fazer isso, você cria uma consulta ou arquivo com uma coluna para identificação do usuário ou do grupo. Você pode usar um `UserName` e`GroupName`, ou alternativamente, `UserARN` `GroupARN` e. Você pode pensar nisso como a *adição de uma regra* para esse usuário ou grupo. Em seguida, você pode adicionar uma coluna à consulta ou arquivo para cada campo ao qual deseja conceder ou restringir o acesso. Para cada nome de usuário ou grupo que você adiciona, os valores de cada campo também são adicionados. Use NULL (sem valor) para significar "todos os valores". Para visualizar exemplos de regras do conjunto de dados, consulte [Como criar regras do conjunto de dados para a segurança por linha](#create-data-set-rules-for-row-level-security).

Para aplicar as regras do conjunto de dados, adicione-as como um conjunto de dados de permissões ao seu conjunto de dados. Lembre-se dos seguintes pontos:
+ O conjunto de dados de permissões não pode conter valores duplicados. As duplicações são ignoradas ao avaliar como aplicar as regras.
+ Cada usuário ou grupo especificado pode ver somente as linhas que *correspondem* aos valores dos campos nas regras do conjunto de dados. 
+ Se você adicionar uma regra para um usuário ou para um grupo e deixar todas as outras colunas sem valor (NULO), você concederá a eles acesso a todos os dados. 
+ Se você não adicionar uma regra para um usuário ou grupo, eles não poderão ver nenhum dado. 
+ O conjunto completo de registros de regras que são aplicadas por usuário não deve exceder 999. Essa limitação se aplica ao número total de regras atribuídas diretamente a um nome do usuário, acrescida de quaisquer regras atribuídas ao usuário por meio de nomes de grupos. 
+ Se um campo incluir uma vírgula (,), o Amazon Quick tratará cada palavra separada da outra por uma vírgula como um valor individual no filtro. Por exemplo, em `('AWS', 'INC')`, `AWS,INC` é considerado como duas strings: `AWS` e `INC`. Para filtrar com `AWS,INC`, coloque a string entre aspas duplas no conjunto de dados de permissões. 

  Se o conjunto de dados restrito for um conjunto de dados do SPICE, o número de valores de filtragem aplicados por usuário não poderá exceder 192 mil para cada campo restrito. Isso se aplica ao número total de valores de filtragem atribuídos diretamente a um nome do usuário, acrescido de quaisquer valores de filtragem atribuídos ao usuário por meio de nomes de grupos.

  Se o conjunto de dados restrito for um conjunto de dados de consulta direta, o número de valores de filtragem aplicados por usuário varia de acordo com as fontes de dados.

  Exceder o limite do valor de filtragem pode causar falha na renderização do elemento visual. Recomendamos adicionar uma coluna adicional ao seu conjunto de dados restrito para dividir as linhas em grupos com base na coluna restrita original. Dessa forma, a lista de filtros pode ser reduzida.

O Amazon Quick trata os espaços como valores literais. Se você tiver um espaço em um campo que está sendo restringido, a regra do conjunto de dados se aplicará a essas linhas. O Amazon Quick trata ambos NULLs e espaços em branco (cadeias de caracteres vazias “”) como “sem valor”. Um NULL é um valor de campo vazio. 

Dependendo da fonte de dados da qual o seu conjunto de dados é proveniente, você pode configurar uma consulta direta para acessar uma tabela de permissões. Termos com espaços dentro deles não precisam ser delimitados com aspas. Se você usar uma consulta direta, poderá alterar facilmente a consulta na fonte de dados original. 

Como alternativa, você pode fazer upload de regras do conjunto de dados usando um arquivo de texto ou uma planilha. Se você estiver usando um arquivo de valores separados por vírgulas (CSV), não inclua espaços na linha. Os termos que tiverem espaços dentro deles precisam ser delimitados entre aspas. Se você usar regras do conjunto de dados baseadas em arquivos, aplique quaisquer alterações ao substituir as regras existentes nas configurações de permissões do conjunto de dados.

Os conjuntos de dados restritos são marcados com a palavra **RESTRITO** na tela **Dados**.

Os conjuntos de dados secundários que são criados a partir de um conjunto de dados primário com regras de RLS ativas mantêm as mesmas regras de RLS que o conjunto de dados primário tem. Você pode adicionar mais regras de RLS ao conjunto de dados secundário, mas não é possível remover as regras de RLS que o conjunto de dados herda do conjunto de dados primário. 

Os conjuntos de dados secundários que são criados a partir de um conjunto de dados primário com regras de RLS ativas só podem ser criados com a consulta direta. Os conjuntos de dados secundários que herdam as regras de RLS do conjunto de dados primário não são compatíveis com o SPICE.

A segurança por linha funciona somente para campos que contêm dados textuais (string, char, varchar e assim por diante). Ela não funciona atualmente para datas nem campos numéricos. A detecção de anomalias não é compatível com conjuntos de dados que usam segurança por linha (RLS).

## Como criar regras do conjunto de dados para a segurança por linha
<a name="create-data-set-rules-for-row-level-security"></a>

Use o procedimento apresentado a seguir para criar um arquivo de permissões ou uma consulta para usar como regras do conjunto de dados.

**Criar arquivos de permissões ou consultas para usar como regras do conjunto de dados**

1. Crie um arquivo ou uma consulta que contenha as regras (permissões) do conjunto de dados para a segurança por linha. 

   Não importa em que ordem os campos estão. No entanto, todos os campos fazem distinção entre maiúsculas e minúsculas. Certifique-se de que eles correspondam exatamente aos nomes e aos valores dos campos. 

   A estrutura deve ser semelhante a uma das seguintes. Certifique-se de ter, no mínimo, um campo que identifique usuários ou grupos. Você pode incluir os dois, mas apenas um é necessário, e apenas um é usado de cada vez. O campo usado para usuários ou grupos pode ter qualquer nome que você escolher.
**nota**  
Se você estiver especificando grupos, use somente grupos do Amazon Quick ou grupos do Microsoft AD. 

   O exemplo a seguir mostra uma tabela com grupos.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/restrict-access-to-a-data-set-using-row-level-security.html)

   O exemplo a seguir mostra uma tabela com nomes de usuários.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/restrict-access-to-a-data-set-using-row-level-security.html)

   O exemplo a seguir mostra uma tabela com o usuário e o grupo Amazon Resource Names (ARNs).    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/restrict-access-to-a-data-set-using-row-level-security.html)

   Como alternativa, se você usar um arquivo .csv, a estrutura deverá ser semelhante a uma das apresentadas a seguir.

   ```
   UserName,SalesRegion,Segment
   AlejandroRosalez,EMEA,"Enterprise,SMB,Startup"
   MarthaRivera,US,Enterprise
   NikhilJayashankars,US,SMB
   PauloSantos,US,Startup
   SaanviSarkar,APAC,"SMB,Startup"
   sales-tps@example.com,"",""
   ZhangWei,APAC-Sales,"Enterprise,Startup"
   ```

   ```
   GroupName,SalesRegion,Segment
   EMEA-Sales,EMEA,"Enterprise,SMB,Startup"
   US-Sales,US,Enterprise
   US-Sales,US,SMB
   US-Sales,US,Startup
   APAC-Sales,APAC,"SMB,Startup"
   Corporate-Reporting,"",""
   APAC-Sales,APAC,"Enterprise,Startup"
   ```

   ```
   UserARN,GroupARN,SalesRegion
   arn:aws:quicksight:us-east-1:123456789012:user/Bob,arn:aws:quicksight:us-east-1:123456789012:group/group-1,APAC
   arn:aws:quicksight:us-east-1:123456789012:user/Sam,arn:aws:quicksight:us-east-1:123456789012:group/group-2,US
   ```

   Veja a seguir um exemplo de SQL.

   ```
   /* for users*/
   	select User as UserName, SalesRegion, Segment
   	from tps-permissions;
   
   	/* for groups*/
   	select Group as GroupName, SalesRegion, Segment
   	from tps-permissions;
   ```

1. Crie um conjunto de dados para as regras do conjunto de dados. Para que você possa encontrá-lo facilmente, forneça um nome significativo; por exemplo, **Permissions-Sales-Pipeline**.

## Sinalização de conjunto de dados de regras para a segurança em nível de linha
<a name="rules-dataset-flagging-for-row-level-security"></a>

Use o procedimento a seguir para sinalizar adequadamente um conjunto de dados como conjunto de dados de regras.

O conjunto de dados de regras é um sinalizador que distingue os conjuntos de dados de permissões usados para a segurança em nível de linha dos conjuntos de dados regulares. Se um conjunto de dados de permissões tiver sido aplicado a um conjunto de dados regular antes de 31 de março de 2025, ele terá uma sinalização de conjunto de dados de regras na página inicial do **conjunto de dados**. 

Se um conjunto de dados de permissões não tiver sido aplicado a um conjunto de dados regular até 31 de março de 2025, ele será categorizado como um conjunto de dados regular. Para usá-lo como um conjunto de dados de regras, duplique o conjunto de dados de permissões e sinalize-o como um conjunto de dados de regras no console ao criar o conjunto de dados. Selecione EDITAR CONJUNTO DE DADOS e, nas opções, escolha DUPLICAR COMO CONJUNTO DE DADOS DE REGRAS. 

Para duplicá-lo com êxito como um conjunto de dados de regras, certifique-se de que o conjunto de dados original tenha: 1. Colunas de metadados de usuários ou de grupos obrigatórias e 2. Somente colunas do tipo string.

Para criar um novo conjunto de dados de regras no console, selecione NOVO CONJUNTO DE DADOS DE REGRAS no menu suspenso NOVO CONJUNTO DE DADOS. [Ao criar um conjunto de dados de regras programaticamente, adicione o seguinte parâmetro:: UseAs RLS\$1RULES.](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_CreateDataSet.html#API_CreateDataSet_RequestSyntax) Este é um parâmetro opcional usado somente para criar um conjunto de dados de regras. Depois que um conjunto de dados é criado, pelo console ou de forma programática, e é sinalizado como um conjunto de dados de regras ou um conjunto de dados regular, ele não poderá ser alterado.

Depois que os conjuntos de dados forem marcados como conjuntos de dados de regras, o Amazon Quick aplicará regras estritas de ingestão de SPICE a eles. Para garantir a integridade dos dados, as ingestões do SPICE para conjuntos de dados de regras falharão se houver linhas ou células inválidas que excedam os limites de tamanho. Você deve corrigir os problemas de ingestão para reiniciar uma ingestão com êxito. Regras estritas de ingestão são aplicáveis somente aos conjuntos de dados de regras. Conjuntos de dados regulares não terão falhas na ingestão de conjuntos de dados quando houver linhas ignoradas ou truncamentos de strings. 

## Como aplicar a segurança em nível de linha
<a name="apply-row-level-security"></a>

Use o procedimento a seguir para aplicar a segurança por linha (RLS) ao usar um arquivo ou uma consulta como um conjunto de dados que contém as regras de permissões. 

**Aplicar segurança por linha ao usar um arquivo ou uma consulta**

1. Confirme se você adicionou suas regras como um novo conjunto de dados. Se você as adicionou, mas não as visualiza na lista de conjuntos de dados, atualize a tela.

1. Na página **Dados**, escolha o conjunto de dados

1. Na página de detalhes do conjunto de dados que é aberta, em **Segurança por linha**, escolha **Configurar**.

1. Na página **Configurar segurança por linha** que é aberta, escolha **Regras baseadas em usuários**.

1. Na lista de conjuntos de dados que aparece, escolha seu conjunto de dados de permissões. 

   Caso o seu conjunto de dados de permissões não seja exibido nesta tela, retorne aos seus conjuntos de dados e atualize a página.

1. Em **Política de permissões**, escolha **Conceder acesso ao conjunto de dados**. Cada conjunto de dados tem somente um conjunto de dados de permissões ativo. Se você tentar adicionar um segundo conjunto de dados de permissões, ele substituirá o existente.
**Importante**  
Algumas restrições se aplicam a valores NULOS e de string vazia ao trabalhar com a segurança por linha:  
Se o seu conjunto de dados tiver valores NULOS ou strings vazias (“”) nos campos restritos, essas linhas serão ignoradas quando as restrições forem aplicadas. 
Dentro do conjunto de dados de permissões, os valores NULOS e as strings vazias são tratados de forma semelhante. Para obter mais informações, consulte a tabela a seguir.
Para evitar a exposição acidental de informações confidenciais, o Amazon Quick ignora regras vazias de RLS que concedem acesso a todos. Uma *regra de RLS vazia* ocorre quando todas as colunas de uma linha não têm valor. O Quick RLS trata NULL, strings vazias (“”) ou strings vazias separadas por vírgula (por exemplo, “,,”) como nenhum valor.  
Após ignorar as regras vazias, outras regras de RLS não vazias ainda se aplicam.
Se um conjunto de dados de permissão tiver somente regras vazias e todas elas tiverem sido ignoradas, ninguém terá acesso a nenhum dado restrito por esse conjunto de dados de permissão.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/restrict-access-to-a-data-set-using-row-level-security.html)

   Qualquer pessoa com quem você compartilhou o painel poderá visualizar todos os dados contidos nele, a menos que o conjunto de dados seja restrito por regras do conjunto de dados. 

1. Escolha **Aplicar conjunto de dados** para salvar as alterações. Em seguida, na página **Deseja salvar as regras do conjunto de dados?**, escolha **Aplicar e ativar**. As alterações nas permissões serão aplicadas imediatamente aos usuários existentes. 

1. (Opcional) Para remover permissões, primeiro remova as regras do conjunto de dados do conjunto de dados. 

   Certifique-se de que as regras do conjunto de dados sejam removidas. Em seguida, escolha o conjunto de dados de permissões e selecione **Remover conjunto de dados**.

   Para substituir as permissões, escolha um novo conjunto de dados de permissões e aplique-o. Você pode reutilizar o mesmo nome para o conjunto de dados. No entanto, certifique-se de aplicar as novas permissões na tela **Permissões** para ativá-las. As consultas SQL são atualizadas dinamicamente para que possam ser gerenciadas fora do Amazon Quick. Para consultas, as permissões são atualizadas quando o cache da consulta direta é atualizado automaticamente.

Se você excluir um conjunto de dados de permissões baseado em arquivos antes de removê-lo do conjunto de dados de destino, os usuários restritos não poderão acessar o conjunto de dados. Enquanto o conjunto de dados estiver nesse estado, ele permanecerá marcado como **RESTRITO**. No entanto, ao visualizar as **Permissões** para esse conjunto de dados, você perceberá que ele não tem regras do conjunto de dados selecionadas. 

Para corrigir isso, especifique novas regras do conjunto de dados. Como criar um conjunto de dados com o mesmo nome não é suficiente para corrigir isso. Você deve escolher o novo conjunto de dados de permissões na tela **Permissões**. Essa restrição não se aplica a consultas SQL diretas.

# Uso da segurança por linha com regras baseadas em etiquetas para restringir o acesso ao conjunto de dados ao realizar a incorporação de painéis para usuários anônimos
<a name="quicksight-dev-rls-tags"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: administradores do Amazon Quick e desenvolvedores do Amazon Quick  | 

Ao incorporar painéis do Amazon Quick em seu aplicativo para usuários que não estão provisionados (registrados) no Quick, você pode usar a segurança em nível de linha (RLS) para dados com tags. filter/restrict Uma tag é uma string especificada pelo usuário que identifica uma sessão em seu aplicativo. Você pode usar tags para implementar controles de RLS para seus conjuntos de dados. Ao configurar restrições baseadas em RLS em conjuntos de dados, o Quick filtra os dados com base nas tags de sessão vinculadas à identidade/sessão do usuário.

Por exemplo, suponhamos que você tenha uma empresa no setor de logística com uma aplicação voltada ao cliente para vários varejistas. Milhares de usuários desses varejistas acessam sua aplicação para visualizar as métricas relacionadas à forma como os pedidos estão sendo enviados de seu local de armazenamento. 

Você não quer gerenciar milhares de usuários no Quick, então você usa a incorporação anônima para incorporar os painéis selecionados em seu aplicativo para que seus usuários autenticados e autorizados possam ver. No entanto, você deseja garantir que os varejistas visualizem somente os dados relativos aos seus negócios e não aos de outras empresas. Você pode usar a RLS com tags para garantir que seus clientes visualizem somente os dados relevantes para eles.

Para fazer isso, conclua as seguintes etapas:

1. Adicione a RLS com tags a um conjunto de dados.

1. Atribua valores para essas tags no runtime usando a operação de API `GenerateEmbedUrlForAnonymousUser`.

   Para obter mais informações sobre a incorporação de painéis para usuários anônimos usando a operação de API `GenerateEmbedUrlForAnonymousUser`, consulte [Incorporação de painéis do Amazon Quick Sight para usuários anônimos (não registrados)](embedded-analytics-dashboards-for-everyone.md).

Antes de usar a RLS com tags, lembre-se dos seguintes pontos:
+ No momento, o uso de RLS com tags é compatível somente com a incorporação anônima, especificamente para painéis incorporados que usam a operação de API `GenerateEmbedUrlForAnonymousUser`.
+ O uso de RLS com tags não é compatível com painéis incorporados que usam a operação de API `GenerateEmbedURLForRegisteredUser` ou a operação de API `GetDashboardEmbedUrl` antiga.
+ As tags RLS não são compatíveis com AWS Identity and Access Management (IAM) ou com o tipo de identidade rápida.
+ Ao aplicar conjuntos de dados do SPICE à segurança por linha, cada campo no conjunto de dados poderá conter, no máximo, 2.047 caracteres Unicode. Os campos que contêm mais do que essa cota são truncados durante a ingestão. Para saber mais sobre as cotas para dados do SPICE, consulte [Cotas do SPICE para dados importados](data-source-limits.md#spice-limits).

## Etapa 1: adicionar a RLS com tags a um conjunto de dados
<a name="quicksight-dev-rls-tags-add"></a>

Você pode adicionar regras baseadas em tags a um conjunto de dados no Amazon Quick. Como alternativa, você pode chamar a operação de API `CreateDataSet` ou `UpdateDataSet` e adicionar regras baseadas em tags dessa forma. Para obter mais informações, consulte [Adicionar RLS com tags a um conjunto de dados usando a API](#quicksight-dev-rls-tags-add-api).

Use o procedimento a seguir para adicionar tags RLS a um conjunto de dados no Quick.

**Adicionar a RLS com tags a um conjunto de dados**

1. Na página de início rápido, escolha **Dados** à esquerda.

1. Escolha o conjunto de dados ao qual você deseja adicionar o RLS.

1. Na página de detalhes do conjunto de dados que é aberta, em **Segurança por linha**, escolha **Configurar**.

1. Na página **Configurar segurança por linha** que é aberta, escolha **Regras baseadas em tags**.

1. Em **Coluna**, escolha uma coluna à qual você deseja adicionar regras baseadas em tags.

   Por exemplo, no caso da empresa no setor de logística, é utilizada a coluna `retailer_id`.

   Somente colunas com um tipo de dados string são listadas.

1. Em **Tag**, insira uma chave de tag. Você pode inserir qualquer nome de tag que desejar.

   Por exemplo, no caso da empresa no setor de logística, é utilizada a chave de tag `tag_retailer_id`. Fazer isso define a segurança por linha com base no varejista que está acessando a aplicação.

1. (Opcional) Em **Delimitador**, escolha um delimitador usando a lista ou insira o seu próprio delimitador.

   É possível usar delimitadores para separar strings de texto ao atribuir mais de um valor para uma tag. O valor de um delimitador pode ter, no máximo, dez caracteres.

1. (Opcional) Em **Corresponder a todos**, escolha o símbolo **\$1** ou insira seu próprio caractere ou caracteres.

   Esta opção pode ser qualquer caractere que você deseja usar ao filtrar por todos os valores dessa coluna no conjunto de dados. Em vez de listar os valores um por um, você pode usar o caractere. Se esse valor for especificado, ele poderá ter pelo menos um caractere ou no máximo 256 caracteres.

1. Escolha **Adicionar**.

   A regra baseada em tags será adicionada ao conjunto de dados e listada na parte inferior, mas ainda não será aplicada. Para adicionar outra regra baseada em tags ao conjunto de dados, repita as etapas 5 a 9. Para editar uma regra baseada em tags, escolha o ícone de lápis próximo à regra. Para excluir uma regra baseada em tags, escolha o ícone de exclusão próximo à regra. É possível adicionar até 50 tags a um conjunto de dados.

1. Quando estiver com tudo pronto para aplicar as regras baseadas em tags ao conjunto de dados, escolha **Aplicar regras**.

1. Na página **Deseja ativar a segurança baseada em tags?** que é aberta, escolha **Aplicar e ativar**.

   As regras baseadas em tags estarão ativas. Na página **Configurar segurança por linha**, um botão de alternância aparece para você ativar e desativar as regras baseadas em tags para o conjunto de dados.

   Para desativar todas as regras baseadas em tags para o conjunto de dados, desative o botão de alternância das **Regras baseadas em tags** e, em seguida, digite “confirmar” na caixa de texto que aparecer.

   Na página **Dados**, um ícone de cadeado aparece na linha do conjunto de dados para indicar que as regras de tag estão habilitadas.

   Agora, você pode usar regras baseadas em tags para definir valores de tags no runtime, conforme descrito em [Etapa 2: atribuir valores à RLS com tags no runtime](#quicksight-dev-rls-tags-assign-values). As regras afetam somente os leitores rápidos quando estão ativas.
**Importante**  
Depois que as tags forem atribuídas e habilitadas no conjunto de dados, certifique-se de conceder permissões aos autores do Quick para ver qualquer dado no conjunto de dados ao criar um painel.   
Para dar permissão aos autores do Quick para ver os dados no conjunto de dados, crie um arquivo de permissões ou uma consulta para usar como regras do conjunto de dados. Para obter mais informações, consulte [Como criar regras do conjunto de dados para a segurança por linha](restrict-access-to-a-data-set-using-row-level-security.md#create-data-set-rules-for-row-level-security).

Após criar uma regra baseada em tags, uma nova tabela **Gerenciar regras** será exibida para mostrar como suas regras baseadas em tags se relacionam. Para fazer alterações nas regras listadas na tabela **Gerenciar regras**, escolha o ícone de lápis próximo à regra. Em seguida, adicione ou remova as tags e escolha **Atualizar**. Para aplicar a regra atualizada ao conjunto de dados, escolha **Aplicar**.

### (Opcional) Adicionar a condição Or à RLS com tags
<a name="quicksight-dev-rls-tags-or"></a>

Você também pode adicionar a condição OR às suas regras baseadas em tags para personalizar ainda mais a forma como os dados são apresentados aos usuários da sua conta Quick. Quando você usa a condição OR com suas regras baseadas em tags, as imagens no Quick aparecem se pelo menos uma tag definida na regra for válida.

**Adicionar a condição OR às regras baseadas em tags**

1. Na tabela **Gerenciar regras**, escolha **Adicionar condição OU**.

1. Na lista suspensa **Selecionar tag** que é apresentada, escolha a tag para a qual você deseja criar uma condição OU. É possível adicionar até 50 condições OR à tabela **Gerenciar regras**. Você pode adicionar diversas tags a uma única coluna em um conjunto de dados, mas, no mínimo, uma tag de coluna precisa ser inclusa em uma regra.

1. Escolha **Atualizar** para adicionar a condição à regra e, em seguida, selecione **Aplicar** para aplicar a regra atualizada ao seu conjunto de dados.

### Adicionar RLS com tags a um conjunto de dados usando a API
<a name="quicksight-dev-rls-tags-add-api"></a>

Como alternativa, você pode configurar e habilitar a segurança por linha baseada em tags em seu conjunto de dados ao chamar a operação de API `CreateDataSet` ou `UpdateDataSet`. Use os exemplos apresentados a seguir para aprender a fazer isso.

**Importante**  
Ao configurar as tags de sessão na chamada da API,  
Trate as tags de sessão como credenciais de segurança. Não exponha as tags de sessão aos usuários finais ou ao código do lado do cliente.
Implemente controles do lado do servidor. Certifique-se de que as tags de sessão sejam definidas exclusivamente por seus serviços de back-end confiáveis, não por parâmetros que os usuários finais possam modificar.
Proteja as tags de sessão da enumeração. Certifique-se de que os usuários de um locatário não possam descobrir ou adivinhar valores de SessionTag pertencentes a outros locatários.
Revise sua arquitetura. Se clientes ou parceiros downstream tiverem permissão para chamar a API diretamente, avalie se essas partes poderiam especificar valores de SessionTag para locatários que não deveriam acessar.

------
#### [ CreateDataSet ]

Veja um exemplo a seguir de criação de um conjunto de dados que usa a RLS com tags. O exemplo assume o cenário da empresa no setor de logística descrito anteriormente. As tags estão definidas no elemento `row-level-permission-tag-configuration`. As tags são definidas nas colunas para as quais você deseja proteger os dados. Para obter mais informações sobre esse elemento opcional, consulte [RowLevelPermissionTagConfiguration](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RowLevelPermissionTagConfiguration.html)a *Amazon Quick API Reference*.

```
create-data-set
		--aws-account-id <value>
		--data-set-id <value>
		--name <value>
		--physical-table-map <value>
		[--logical-table-map <value>]
		--import-mode <value>
		[--column-groups <value>]
		[--field-folders <value>]
		[--permissions <value>]
		[--row-level-permission-data-set <value>]
		[--column-level-permission-rules <value>]
		[--tags <value>]
		[--cli-input-json <value>]
		[--generate-cli-skeleton <value>]
		[--row-level-permission-tag-configuration 
	'{
		"Status": "ENABLED",
		"TagRules": 
			[
				{
					"TagKey": "tag_retailer_id",
					"ColumnName": "retailer_id",
					"TagMultiValueDelimiter": ",",
					"MatchAllValue": "*"
				},
				{
					"TagKey": "tag_role",
					"ColumnName": "role"
				}
			],
		"TagRuleConfigurations":
			[
				tag_retailer_id
			],
			[
				tag_role
			]
	}'
]
```

Neste exemplo, as tags estão definidas na parte `TagRules` do elemento. No exemplo, duas tags são definidas com base em duas colunas:
+ A chave da tag `tag_retailer_id` é definida para a coluna `retailer_id`. Neste caso, para a empresa no setor de logística, isto define a segurança por linha com base no varejista que está tentando acessar a aplicação.
+ A chave da tag `tag_role` é definida para a coluna `role`. Neste caso, para a empresa no setor de logística, isso define uma camada adicional de segurança por linha com base no perfil do usuário que acessa a aplicação usando um varejista específico. Um exemplo é `store_supervisor` ou `manager`.

Para cada tag, você pode definir `TagMultiValueDelimiter` e `MatchAllValue`. Entretanto, são opcionais.
+ `TagMultiValueDelimiter`: esta opção pode ser qualquer string que você deseja usar para delimitar os valores ao transferi-los no runtime. O valor pode ter, no máximo, dez caracteres. Nesse caso, uma vírgula é usada como o valor delimitador.
+ `MatchAllValue`: esta opção pode ser qualquer caractere que você deseja usar ao filtrar por todos os valores dessa coluna no conjunto de dados. Em vez de listar os valores um por um, você pode usar o caractere. Se especificado, esse valor poderá ter no mínimo um caractere ou no máximo 256 caracteres. Nesse caso, um asterisco será usado como o correspondente a todos os valores.

Ao configurar as tags para as colunas do conjunto de dados, ative-as ou desative-as usando a propriedade obrigatória `Status`. Para habilitar as regras baseadas em tags, use o valor `ENABLED` para esta propriedade. Ao ativar as regras baseadas em tags, você poderá usá-las para definir valores de tags no runtime, conforme descrito em [Etapa 2: atribuir valores à RLS com tags no runtime](#quicksight-dev-rls-tags-assign-values).

Veja um exemplo a seguir de definição de resposta.

```
{
			"Status": 201,
			"Arn": "arn:aws:quicksight:us-west-2:11112222333:dataset/RLS-Dataset",
			"DataSetId": "RLS-Dataset",
			"RequestId": "aa4f3c00-b937-4175-859a-543f250f8bb2"
		}
```

------
#### [ UpdateDataSet ]

**UpdateDataSet**

Você pode usar a operação de API `UpdateDataSet` para adicionar ou atualizar a RLS com tags para um conjunto de dados existente.

Veja um exemplo a seguir de atualização de um conjunto de dados com a RLS com tags. O exemplo assume o cenário da empresa no setor de logística descrito anteriormente.

```
update-data-set
		--aws-account-id <value>
		--data-set-id <value>
		--name <value>
		--physical-table-map <value>
		[--logical-table-map <value>]
		--import-mode <value>
		[--column-groups <value>
		[--field-folders <value>]
		[--row-level-permission-data-set <value>]
		[--column-level-permission-rules <value>]
		[--cli-input-json <value>]
		[--generate-cli-skeleton <value>]
				[--row-level-permission-tag-configuration 
	'{
		"Status": "ENABLED",
		"TagRules": 
			[
				{
					"TagKey": "tag_retailer_id",
					"ColumnName": "retailer_id",
					"TagMultiValueDelimiter": ",",
					"MatchAllValue": "*"
				},
				{
					"TagKey": "tag_role",
					"ColumnName": "role"
				}
			],
		"TagRuleConfigurations":
			[
				tag_retailer_id
			],
			[
				tag_role
			]
	}'
]
```

Veja um exemplo a seguir de definição de resposta.

```
{
			"Status": 201,
			"Arn": "arn:aws:quicksight:us-west-2:11112222333:dataset/RLS-Dataset",
			"DataSetId": "RLS-Dataset",
			"RequestId": "aa4f3c00-b937-4175-859a-543f250f8bb2"
		}
```

------

**Importante**  
Depois que as tags forem atribuídas e habilitadas no conjunto de dados, certifique-se de conceder permissões aos autores do Quick para ver qualquer dado no conjunto de dados ao criar um painel.   
Para dar permissão aos autores do Quick para ver os dados no conjunto de dados, crie um arquivo de permissões ou uma consulta para usar como regras do conjunto de dados. Para obter mais informações, consulte [Como criar regras do conjunto de dados para a segurança por linha](restrict-access-to-a-data-set-using-row-level-security.md#create-data-set-rules-for-row-level-security).

Para obter mais informações sobre o `RowLevelPermissionTagConfiguration` elemento, consulte [RowLevelPermissionTagConfiguration](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RowLevelPermissionTagConfiguration.html)a *Amazon Quick API Reference*.

## Etapa 2: atribuir valores à RLS com tags no runtime
<a name="quicksight-dev-rls-tags-assign-values"></a>

Você pode usar tags para a RLS somente para a incorporação anônima. É possível definir valores para as tags usando a operação de API `GenerateEmbedUrlForAnonymousUser`.

**Importante**  
Ao configurar as tags de sessão na chamada da API,  
Trate as tags de sessão como credenciais de segurança. Não exponha as tags de sessão aos usuários finais ou ao código do lado do cliente.
Implemente controles do lado do servidor. Certifique-se de que as tags de sessão sejam definidas exclusivamente por seus serviços de back-end confiáveis, não por parâmetros que os usuários finais possam modificar.
Proteja as tags de sessão da enumeração. Certifique-se de que os usuários de um locatário não possam descobrir ou adivinhar valores de SessionTag pertencentes a outros locatários.
Revise sua arquitetura. Se clientes ou parceiros downstream tiverem permissão para chamar a API diretamente, avalie se essas partes poderiam especificar valores de SessionTag para locatários que não deveriam acessar.

O exemplo apresentado a seguir mostra como atribuir valores à RLS com tags definida no conjunto de dados na etapa anterior.

```
POST /accounts/AwsAccountId/embed-url/anonymous-user
	HTTP/1.1
	Content-type: application/json
	{
		“AwsAccountId”: “string”,
		“SessionLifetimeInMinutes”: integer,
		“Namespace”: “string”, // The namespace to which the anonymous end user virtually belongs
		“SessionTags”:  // Optional: Can be used for row-level security
			[
				{
					“Key”: “tag_retailer_id”,
					“Value”: “West,Central,South”
				}
				{
					“Key”: “tag_role”,
					“Value”: “shift_manager”
				}
			],
		“AuthorizedResourceArns”:
			[
				“string”
			],
		“ExperienceConfiguration”:
			{
				“Dashboard”:
					{
						“InitialDashboardId”: “string”
						// This is the initial dashboard ID the customer wants the user to land on. This ID goes in the output URL.
					}
			}
	}
```

Veja um exemplo a seguir de definição de resposta.

```
HTTP/1.1 Status
	Content-type: application/json

	{
	"EmbedUrl": "string",
	"RequestId": "string"
	}
```

O suporte a RLS sem registrar usuários no Quick é suportado somente na operação da `GenerateEmbedUrlForAnonymousUser` API. Nesta operação, em `SessionTags`, é possível definir os valores das tags associadas às colunas do conjunto de dados.

Neste caso, são definidas as seguintes atribuições:
+ Os valores `West`, `Central` e `South` são atribuídos à tag `tag_retailer_id` no runtime. Uma vírgula é usada para o delimitador, que foi definido em `TagMultipleValueDelimiter` no conjunto de dados. Para usar valores de chamada na coluna, você pode definir o valor como *\$1*, que foi definido como o `MatchAllValue` ao criar a tag.
+ O valor `shift_manager` é atribuído à tag `tag_role`.

O usuário que usar o URL gerado poderá visualizar somente as linhas com o valor `shift_manager` na coluna `role`. Esse usuário poderá visualizar somente o valor `West`, `Central` ou `South` na coluna `retailer_id`.

Para obter mais informações sobre a incorporação de painéis para usuários anônimos usando a operação de `GenerateEmbedUrlForAnonymousUser` API[Incorporação de painéis do Amazon Quick Sight para usuários anônimos (não registrados)](embedded-analytics-dashboards-for-everyone.md), consulte ou [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)na *Amazon Quick* API Reference