Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création de déclarations de politique IAM personnalisées pour accéder aux données dans Amazon Neptune
Les déclarations de stratégie d'accès aux données Neptune utilisent des [actions d'accès aux données](iam-dp-actions.md), des [ressources](iam-data-resources.md) et des [clés de condition](iam-data-condition-keys.md#iam-neptune-condition-keys), toutes précédées d'un préfixe `neptune-db:`.
**Topics**
+ [Utilisation d'actions de requête dans les déclarations de stratégie d'accès aux données Neptune](#iam-data-query-actions)
+ [Actions IAM pour l'accès aux données dans Amazon Neptune](iam-dp-actions.md)
+ [Types de ressources IAM pour accéder aux données dans Amazon Neptune](iam-data-resources.md)
+ [Clés de condition IAM pour accéder aux données dans Amazon Neptune](iam-data-condition-keys.md)
+ [Création de politiques d'accès aux données IAM dans Amazon Neptune](iam-data-access-examples.md)
## Utilisation d'actions de requête dans les déclarations de stratégie d'accès aux données Neptune
Trois actions de requête Neptune peuvent être utilisées dans les déclarations de stratégie d'accès aux données, à savoir `ReadDataViaQuery`, `WriteDataViaQuery` et `DeleteDataViaQuery`. Une requête particulière peut nécessiter les autorisations nécessaires pour effectuer plusieurs de ces actions, et il n'est pas toujours évident de savoir quelle combinaison de ces actions doit être autorisée pour exécuter une requête.
Avant d'exécuter une requête, Neptune détermine les autorisations nécessaires pour exécuter chaque étape de la requête et les combine dans l'ensemble complet d'autorisations requises par la requête. Notez que cet ensemble complet d'autorisations inclut toutes les actions que la requête *peut* effectuer, ce qui n'est pas nécessairement l'ensemble des actions que la requête effectuera réellement lorsqu'elle traitera vos données.
Autrement dit, pour autoriser l'exécution d'une requête donnée, vous devez fournir les autorisations nécessaires pour chaque action que la requête est susceptible d'effectuer, qu'elle les exécute réellement ou non.
Voici quelques exemples de requêtes Gremlin qui permettent d'illustrer ce principe :
+
```
g.V().count()
```
`g.V()` et `count()` ne nécessitent qu'un accès en lecture. La requête ne nécessite donc qu'un accès `ReadDataViaQuery`.
+
```
g.addV()
```
`addV()` doit vérifier si un sommet avec un ID donné existe ou non avant d'en insérer un nouveau. La requête a donc besoin à la fois d'un accès `ReadDataViaQuery` et d'un accès `WriteDataViaQuery`.
+
```
g.V('1').as('a').out('created').addE('createdBy').to('a')
```
`g.V('1').as('a')` et `out('created')` ne nécessitent qu'un accès en lecture, mais `addE().from('a')` nécessite un accès en lecture et en écriture, car `addE()` doit lire les sommets `from` et `to` et vérifier si une arête portant le même ID existe déjà avant d'en ajouter une autre. La requête dans son ensemble a donc besoin à la fois d'un accès `ReadDataViaQuery` et d'un accès `WriteDataViaQuery`.
+
```
g.V().drop()
```
`g.V()` ne nécessite qu'un accès en lecture. `drop()` a besoin à la fois d'un accès en lecture et en suppression, car il doit lire un sommet ou une arête avant de le supprimer. La requête nécessite donc à la fois un accès `ReadDataViaQuery` et un accès `DeleteDataViaQuery`.
+
```
g.V('1').property(single, 'key1', 'value1')
```
`g.V('1')` ne nécessite qu'un accès en lecture, mais `property(single, 'key1', 'value1')` nécessite un accès en lecture, en écriture et en suppression. Ici, l'étape `property()` insère la clé et la valeur si elles n'existent pas déjà dans le sommet, mais si elles existent déjà, elle supprime la valeur de propriété existante et insère une nouvelle valeur à sa place. Par conséquent, la requête nécessite les accès `ReadDataViaQuery`, `WriteDataViaQuery` et `DeleteDataViaQuery`.
Toute requête contenant une étape `property()` nécessite les autorisations `ReadDataViaQuery`, `WriteDataViaQuery` et `DeleteDataViaQuery`.
Voici quelques exemples openCypher :
+
```
MATCH (n)
RETURN n
```
Cette requête lit tous les nœuds de la base de données et les renvoie, ce qui nécessite uniquement un accès `ReadDataViaQuery`.
+
```
MATCH (n:Person)
SET n.dept = 'AWS'
```
Cette requête nécessite les accès `ReadDataViaQuery`, `WriteDataViaQuery` et `DeleteDataViaQuery`. Elle lit tous les nœuds portant l'étiquette « Personne » et y ajoute une nouvelle propriété avec la clé `dept` et la valeur `AWS`, ou si la propriété `dept` existe déjà, elle supprime l'ancienne valeur et insère `AWS` à la place. De même, si la valeur à définir est `null`, `SET` supprime complètement la propriété.
Étant donné que la clause `SET` peut dans certains cas nécessiter la suppression d'une valeur existante, elle a **toujours** besoin d'autorisations `DeleteDataViaQuery`, ainsi que d'autorisations `ReadDataViaQuery` et `WriteDataViaQuery`.
+
```
MATCH (n:Person)
DETACH DELETE n
```
Cette requête nécessite les autorisations `ReadDataViaQuery` et `DeleteDataViaQuery`. Elle trouve tous les nœuds portant l'étiquette `Person` et les supprime ainsi que les arêtes connectées à ces nœuds et toutes les étiquettes et propriétés associées.
+
```
MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'})
RETURN n
```
Cette requête nécessite les autorisations `ReadDataViaQuery` et `WriteDataViaQuery`. La clause `MERGE` correspond à un modèle spécifié ou le crée. Étant donné qu'une écriture peut avoir lieu si le modèle ne correspond pas, des autorisations d'écriture sont nécessaires, ainsi que des autorisations de lecture.