Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Creación de instrucciones de políticas de IAM personalizadas para acceder a datos en Amazon Neptune
Las instrucciones de políticas de acceso a datos de Neptune utilizan [acciones](iam-dp-actions.md), [recursos](iam-data-resources.md) y [claves de condición](iam-data-condition-keys.md#iam-neptune-condition-keys) de acceso a los datos, todos ellos precedidos por el prefijo `neptune-db:`.
**Topics**
+ [Uso de acciones de consulta en las declaraciones de políticas de acceso a datos de Neptune](#iam-data-query-actions)
+ [Acciones de IAM para el acceso a los datos en Amazon Neptune](iam-dp-actions.md)
+ [Tipos de recursos de IAM para acceder a los datos en Amazon Neptune](iam-data-resources.md)
+ [Claves de condición de IAM para acceder a los datos en Amazon Neptune](iam-data-condition-keys.md)
+ [Creación de políticas de acceso a datos de IAM en Amazon Neptune](iam-data-access-examples.md)
## Uso de acciones de consulta en las declaraciones de políticas de acceso a datos de Neptune
Hay tres acciones de consulta de Neptune que se pueden utilizar en las declaraciones de políticas de acceso a los datos: `ReadDataViaQuery`, `WriteDataViaQuery` y `DeleteDataViaQuery`. Es posible que una consulta en particular necesite permisos para realizar varias de estas acciones, y puede que no siempre sea evidente qué combinación de estas acciones debe permitirse para ejecutar una consulta.
Antes de ejecutar una consulta, Neptune determina los permisos necesarios para ejecutar cada paso de la consulta y los combina en el conjunto completo de permisos que requiere la consulta. Tenga en cuenta que este conjunto completo de permisos incluye todas las acciones que *puede* realizar la consulta, que no es necesariamente el conjunto de acciones que la consulta realizará realmente cuando se ejecute en sus datos.
Esto significa que, para permitir que se ejecute una consulta determinada, debe proporcionar permisos para todas las acciones que la consulta pueda realizar, tanto si las acaba realizando como si no.
Estos son algunos ejemplos de consultas de Gremlin en las que esto se explica con más detalle:
+
```
g.V().count()
```
`g.V()` y `count()` solo requieren acceso de lectura, por lo que la consulta en su conjunto solo requiere acceso `ReadDataViaQuery`.
+
```
g.addV()
```
`addV()` necesita comprobar si existe o no un vértice con un identificador determinado antes de insertar uno nuevo. Esto significa que requiere tanto acceso `ReadDataViaQuery` como `WriteDataViaQuery`.
+
```
g.V('1').as('a').out('created').addE('createdBy').to('a')
```
`g.V('1').as('a')` y `out('created')` solo requieren acceso de lectura, pero `addE().from('a')` requiere acceso de lectura y escritura, ya que `addE()` necesita leer los vértices `from` y `to` y comprobar si ya existe un borde con el mismo identificador antes de añadir uno nuevo. Por lo tanto, la consulta en su conjunto necesita tanto el acceso `ReadDataViaQuery` como `WriteDataViaQuery`.
+
```
g.V().drop()
```
`g.V()` solo requiere acceso de lectura. `drop()` necesita acceso de lectura y eliminación porque tiene que leer un vértice o borde antes de eliminarlo, por lo que la consulta en su conjunto requiere tanto acceso `ReadDataViaQuery` como `DeleteDataViaQuery`.
+
```
g.V('1').property(single, 'key1', 'value1')
```
`g.V('1')` solo requiere acceso de lectura, pero `property(single, 'key1', 'value1')` requiere acceso de lectura, escritura y eliminación. En este caso, en el paso `property()`, se inserta la clave y el valor si aún no existen en el vértice, pero si ya existen, se elimina el valor de la propiedad existente y se inserta un nuevo valor en su lugar. Por lo tanto, la consulta en su conjunto requiere acceso `ReadDataViaQuery`, `WriteDataViaQuery` y `DeleteDataViaQuery`.
Cualquier consulta que contenga un paso `property()` necesitará permisos `ReadDataViaQuery`, `WriteDataViaQuery` y `DeleteDataViaQuery`.
Estos son algunos ejemplos de openCypher:
+
```
MATCH (n)
RETURN n
```
Esta consulta lee todos los nodos de la base de datos y los devuelve, lo que solo requiere acceso `ReadDataViaQuery`.
+
```
MATCH (n:Person)
SET n.dept = 'AWS'
```
Esta consulta requiere acceso `ReadDataViaQuery`, `WriteDataViaQuery` y `DeleteDataViaQuery`. Lee todos los nodos con la etiqueta 'Person' y añade una nueva propiedad con la clave `dept` y el valor `AWS` o, si la propiedad `dept` ya existe, elimina el valor anterior e inserta `AWS` en su lugar. Además, si el valor que se va a establecer es `null`, `SET` elimina la propiedad por completo.
Como en algunos casos es posible que la cláusula `SET` necesite eliminar un valor existente, **siempre** necesitará permisos `DeleteDataViaQuery` y permisos `ReadDataViaQuery` y `WriteDataViaQuery`.
+
```
MATCH (n:Person)
DETACH DELETE n
```
Esta consulta necesita permisos `ReadDataViaQuery` y `DeleteDataViaQuery`. Busca todos los nodos con la etiqueta `Person` y los elimina junto con los bordes conectados a esos nodos y las etiquetas y propiedades asociadas.
+
```
MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'})
RETURN n
```
Esta consulta necesita permisos `ReadDataViaQuery` y `WriteDataViaQuery`. La cláusula `MERGE` coincide con un patrón específico o lo crea. Dado que puede producirse una escritura si el patrón no coincide, se necesitan permisos de escritura además de permisos de lectura.