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á.
# Criar declarações personalizadas de políticas do IAM para acessar dados no Amazon Neptune
As declarações de política de acesso a dados do Neptune usam [ações de acesso a dados](iam-dp-actions.md), [recursos](iam-data-resources.md) e [chaves de condição](iam-data-condition-keys.md#iam-neptune-condition-keys), todos precedidos por um prefixo `neptune-db:`.
**Topics**
+ [Usar ações de consulta nas declarações de política de acesso a dados do Neptune](#iam-data-query-actions)
+ [Ações do IAM para acesso a dados no Amazon Neptune](iam-dp-actions.md)
+ [Tipos de recursos do IAM para acessar dados no Amazon Neptune](iam-data-resources.md)
+ [Chaves de condição do IAM para acessar dados no Amazon Neptune](iam-data-condition-keys.md)
+ [Criar políticas de acesso a dados do IAM no Amazon Neptune](iam-data-access-examples.md)
## Usar ações de consulta nas declarações de política de acesso a dados do Neptune
Há três ações de consulta do Neptune que podem ser usadas em declarações de política de acesso a dados, a saber, `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Uma consulta específica pode precisar de permissões para realizar mais de uma dessas ações e nem sempre é óbvio qual combinação dessas ações deve ser permitida para executar uma consulta.
Antes de executar uma consulta, o Neptune determina as permissões necessárias para executar cada etapa da consulta e as combina no conjunto completo de permissões que a consulta exige. Observe que esse conjunto completo de permissões inclui todas as ações que a consulta *pode* realizar, o que não é necessariamente o conjunto de ações que a consulta realmente executará quando for realizada em seus dados.
Isso significa que, para permitir que uma consulta específica seja executada, é necessário conceder permissões para cada ação que a consulta possa realizar, independentemente de ela realmente as executar ou não.
Veja alguns exemplos de consulta do Gremlin em que isso é explicado com mais detalhes:
+
```
g.V().count()
```
`g.V()` e `count()` exigem apenas acesso de leitura, portanto, a consulta como um todo exige apenas acesso `ReadDataViaQuery`.
+
```
g.addV()
```
`addV()` precisa conferir se um vértice com um ID específico existe ou não antes de inserir um novo. Isso significa que ele exige acesso `ReadDataViaQuery` e `WriteDataViaQuery`.
+
```
g.V('1').as('a').out('created').addE('createdBy').to('a')
```
`g.V('1').as('a')` e `out('created')` exigem apenas acesso de leitura, mas `addE().from('a')` requer acesso de leitura e gravação porque `addE()` precisa ler os vértices `from` e `to` e conferir se uma borda com o mesmo ID já existe antes de adicionar uma nova. A consulta como um todo, portanto, precisa de acesso `ReadDataViaQuery` e `WriteDataViaQuery`.
+
```
g.V().drop()
```
`g.V()` exige apenas acesso de leitura. `drop()` requer acesso de leitura e exclusão porque precisa ler um vértice ou uma borda antes de excluí-lo, portanto, a consulta como um todo exige acesso `ReadDataViaQuery` e `DeleteDataViaQuery`.
+
```
g.V('1').property(single, 'key1', 'value1')
```
`g.V('1')` requer apenas acesso de leitura, mas `property(single, 'key1', 'value1')` exige acesso de leitura, gravação e exclusão. Aqui, a etapa `property()` vai inserir a chave e o valor se eles ainda não existirem no vértice, mas se já existirem, ela vai excluir o valor da propriedade existente e inserir um novo valor em seu lugar. Portanto, a consulta como um todo exige acesso `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`.
Qualquer consulta que contenha uma etapa `property()` precisará de permissões `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`.
Veja a seguir alguns exemplos do openCypher:
+
```
MATCH (n)
RETURN n
```
Essa consulta lê todos os nós no banco de dados e os gera, o que exige apenas acesso `ReadDataViaQuery`.
+
```
MATCH (n:Person)
SET n.dept = 'AWS'
```
Essa consulta exige acesso `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Ela lê todos os nós com o rótulo “Pessoa” e adiciona uma nova propriedade com a chave `dept` e o valor `AWS` a eles ou, se a propriedade `dept` já existir, vai excluir o valor antigo e inserir `AWS` em seu lugar. Além disso, se o valor a ser definido for `null`, `SET` excluirá completamente a propriedade.
Como, em alguns casos, a cláusula `SET` talvez precise excluir um valor existente, ela **sempre** precisará de permissões `DeleteDataViaQuery`, além de permissões `ReadDataViaQuery` e `WriteDataViaQuery`.
+
```
MATCH (n:Person)
DETACH DELETE n
```
Essa consulta precisa das permissões `ReadDataViaQuery` e `DeleteDataViaQuery`. Ela encontra todos os nós com o rótulo `Person` e os exclui junto com as bordas conectadas a esses nós e todas as propriedades e os rótulos associados.
+
```
MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'})
RETURN n
```
Essa consulta precisa das permissões `ReadDataViaQuery` e `WriteDataViaQuery`. A cláusula `MERGE` corresponde a um padrão especificado ou o cria. Como uma gravação poderá ocorrer se não houver correspondência ao padrão, são necessárias permissões de gravação e leitura.