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.
# Interrogation d'un graphe Neptune
Neptune prend en charge deux langages d'interrogation pour accéder à un graphe :
+ [Gkremlin](https://tinkerpop.apache.org/gremlin.html), défini par [Apache TinkerPop](https://tinkerpop.apache.org/) pour créer et interroger des graphes de propriétés.
Dans Gremlin, une requête est une traversée composée d'étapes distinctes, chacune suivant une arête jusqu'à un nœud.
Consultez [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md) pour en savoir plus sur l'utilisation de Gremlin dans Neptune, et [Conformité d'Amazon Neptune avec les normes Gremlin](access-graph-gremlin-differences.md) pour obtenir des informations spécifiques sur l'implémentation Neptune de Gremlin.
+ [openCypher](access-graph-opencypher.md) est un langage de requête déclaratif pour les graphes de propriétés initialement développé par Neo4j, puis rendu open source en 2015. Il a contribué au projet [openCypher](http://www.opencypher.org/) sous une licence open source Apache 2. Sa syntaxe est documentée dans la spécification [openCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf).
+ [SPARQL](https://www.w3.org/TR/sparql11-overview/) est un langage déclaratif basé sur la correspondance de modèles de graphes pour interroger des données [RDF](https://www.w3.org/2001/sw/wiki/RDF). Il est pris en charge par le [World Wide Web Consortium](https://www.w3.org/).
Consultez [Accès au graphe Neptune avec SPARQL](access-graph-sparql.md) pour en savoir plus sur l'utilisation de SPARQL dans Neptune, et [Conformité d'Amazon Neptune avec les normes SPARQL](feature-sparql-compliance.md) pour obtenir des informations spécifiques sur l'implémentation Neptune de SPARQL.
**Note**
Gremlin et openCypher peuvent tous deux être utilisés pour interroger toutes les données de graphes de propriétés stockées dans Neptune, quelle que soit la manière dont elles ont été chargées.
**Topics**
+ [Mise en file d'attente des requêtes dans Amazon Neptune](access-graph-queuing.md)
+ [Cache du plan de requête dans Amazon Neptune](access-graph-qpc.md)
+ [Injection d'un ID personnalisé dans une requête Neptune Gremlin ou SPARQL](features-query-id.md)
+ [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md)
+ [Accès au graphe Neptune avec openCypher](access-graph-opencypher.md)
+ [Accès au graphe Neptune avec SPARQL](access-graph-sparql.md)
# Mise en file d'attente des requêtes dans Amazon Neptune
Lors du développement et du réglage d'applications graphiques, il peut être utile de connaître les implications de la façon dont les requêtes sont mises en file d'attente par la base de données. Dans Amazon Neptune, la mise en file d'attente des requêtes présente les caractéristiques suivantes :
+ Le nombre maximal de requêtes pouvant être mises en file d'attente par instance, quelle que soit la taille de l'instance, est de 8 192. Toutes les requêtes au-delà de ce nombre sont rejetées et échouent avec une exception `ThrottlingException`.
+ Le nombre maximum de requêtes pouvant être exécutées simultanément est déterminé par le nombre de threads de travail affectés, qui est généralement défini sur le double du nombre de cœurs de processeur virtuels (vCPUs) disponibles.
+ La latence de requête inclut le temps passé par une requête dans la file d'attente, ainsi que le retour sur le réseau et le temps d'exécution réel.
## Comment déterminer le nombre de requêtes présentes dans votre file d'attente à un moment donné
La `MainRequestQueuePendingRequests` CloudWatch métrique enregistre le nombre de demandes en attente dans la file d'entrée avec une granularité de cinq minutes (voir[Métriques Neptune CloudWatch](cw-metrics.md)).
Pour Gremlin, vous pouvez obtenir le nombre actuel de requêtes dans la file d'attente en utilisant la valeur `acceptedQueryCount` renvoyée par l'[API de statut des requêtes Gremlin](gremlin-api-status.md). Notez toutefois que la valeur `acceptedQueryCount` renvoyée par l'[API de statut des requêtes SPARQL](sparql-api-status.md) inclut toutes les requêtes acceptées depuis le démarrage du serveur, y compris les requêtes terminées.
## Comment la mise en file d'attente des requêtes peut affecter les délais d'expiration
Comme indiqué précédemment, la latence de requête inclut le temps passé par une requête dans la file d'attente, ainsi que le temps d'exécution.
Étant donné que le délai d'expiration d'une requête est généralement mesuré à partir du moment où elle entre dans la file d'attente, une file d'attente lente peut faire expirer de nombreuses requêtes dès qu'elles sont retirées de la file d'attente. Ceci n'est évidemment pas souhaitable. Il est donc bon d'éviter de mettre en file d'attente un grand nombre de requêtes, à moins qu'elles ne puissent être exécutées rapidement.
# Cache du plan de requête dans Amazon Neptune
Lorsqu'une requête est soumise à Neptune, la chaîne de requête est analysée, optimisée et transformée en un plan de requête, qui est ensuite exécuté par le moteur. Les applications sont souvent soutenues par des modèles de requête courants instanciés avec des valeurs différentes. Le cache des plans de requêtes peut réduire la latence globale en mettant en cache les plans de requêtes et en évitant ainsi l'analyse et l'optimisation pour de tels modèles répétés.
Le cache du plan de requête peut être utilisé pour les **OpenCypher**requêtes, qu'elles soient paramétrées ou non paramétrées. Il est activé pour READ, HTTP et Bolt. Il **n'est pas** pris en charge pour les requêtes de mutation OC. Il **n'est pas** pris en charge pour les requêtes Gkremlin ou SPARQL.
## Comment forcer l'activation ou la désactivation du cache du plan de requêtes
Le cache du plan de requêtes est activé par défaut pour les requêtes paramétrées à faible latence. **Un plan pour une requête paramétrée est mis en cache uniquement lorsque la latence est inférieure au seuil de 100 ms.** Ce comportement peut être remplacé par requête (paramétré ou non) par le Query Hint au niveau de la requête. `QUERY:PLANCACHE` Il doit être utilisé avec la `USING` clause. L'indice de requête accepte `enabled` ou `disabled` en tant que valeur.
```
# Forcing plan to be cached or reused
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1"
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": 123}"
# Forcing plan to be neither cached nor reused
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"disabled\" MATCH(n) RETURN n LIMIT 1"
```
## Comment déterminer si un plan est mis en cache ou non
Pour HTTP READ, si la requête a été soumise et que le plan a été mis en cache, `explain` les détails relatifs au cache du plan de requête seront affichés.
```
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" \
-d "explain=[static|details]"
Query:
Plan cached by request:
Plan cached at:
Parameters:
Plan cache hits:
First query evaluation time:
The query has been executed based on a cached query plan. Detailed explain with operator runtime statistics can be obtained by running the query with plan cache disabled (using HTTP parameter planCache=disabled).
```
Lorsque vous utilisez Bolt, la fonction d'explication n'est pas prise en charge.
## Expulsion
Un plan de requête est supprimé en fonction de la durée de vie du cache (TTL) ou lorsqu'un nombre maximum de plans de requêtes mis en cache est atteint. Lorsque le plan de requête est atteint, le TTL est actualisé. Les valeurs par défaut sont les suivantes :
+ 1000 : nombre maximum de plans pouvant être mis en cache par instance.
+ TTL - 300 000 millisecondes ou 5 minutes. L'accès au cache redémarre le TTL et le réinitialise à 5 minutes.
## Conditions empêchant le plan d'être mis en cache
Le cache du plan de requête ne serait pas utilisé dans les conditions suivantes :
1. Lorsqu'une requête est soumise à l'aide de l'indice de requête`QUERY:PLANCACHE "disabled"`. Vous pouvez réexécuter la requête et la supprimer `QUERY:PLANCACHE "disabled"` pour activer le cache du plan de requête.
1. Si la requête soumise n'est pas une requête paramétrée et ne contient pas l'indice. `QUERY:PLANCACHE "enabled"`
1. Si le temps d'évaluation de la requête est supérieur au seuil de latence, la requête n'est pas mise en cache et est considérée comme une requête de longue durée qui ne bénéficierait pas du cache du plan de requêtes.
1. Si la requête contient un modèle qui ne renvoie aucun résultat.
+ c'est-à-dire `MATCH (n:nonexistentLabel) return n` lorsqu'il n'y a aucun nœud avec l'étiquette spécifiée.
+ c'est-à-dire `MATCH (n {name: $param}) return n` `parameters={"param": "abcde"}` lorsqu'il n'y a aucun nœud contenant`name=abcde`.
1. Si le paramètre de requête est un type composite, tel que a `list` ou `map` a.
```
curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": [1, 2, 3]}"
curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": {\"a\": 1}}"
```
1. Si le paramètre de requête est une chaîne qui n'a pas fait partie d'une opération de chargement ou d'insertion de données. Par exemple, s'il `CREATE (n {name: "X"})` est exécuté pour insérer`"X"`, `RETURN "X"` il est mis en cache, alors qu'`RETURN "Y"`il ne le serait pas, car il n'`"Y"`a pas été inséré et n'existe pas dans la base de données.
# Injection d'un ID personnalisé dans une requête Neptune Gremlin ou SPARQL
Par défaut, Neptune attribue une valeur `queryId` unique à chaque requête. Vous pouvez utiliser cet ID pour obtenir des informations sur une requête en cours d'exécution (voir [API de statut des requêtes Gremlin](gremlin-api-status.md) ou [API de statut des requêtes SPARQL](sparql-api-status.md)) ou pour l'annuler (voir [Annulation de requêtes Gremlin](gremlin-api-status-cancel.md) ou [Annulation de requêtes SPARQL](sparql-api-status-cancel.md)).
Neptune vous permet également de spécifier votre propre valeur `queryId` pour une requête Gremlin ou SPARQL, soit dans l'en-tête HTTP, soit pour une requête SPARQL à l'aide de l'indicateur de requête `queryId`. L'attribution de votre propre `queryID` permet de suivre facilement une requête afin d'obtenir son statut ou de l'annuler.
## Injection d'une valeur `queryId` personnalisée à l'aide de l'en-tête HTTP
Pour Gremlin et SPARQL, l'en-tête HTTP peut être utilisé pour injecter votre propre valeur `queryId` dans une requête.
**Exemple Gremlin**
```
curl -XPOST https://your-neptune-endpoint:port \
-d "{\"gremlin\": \
\"g.V().limit(1).count()\" , \
\"queryId\":\"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" }"
```
**Exemple SPARQL**
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=SELECT * WHERE { ?s ?p ?o } " \
--data-urlencode \
"queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
## Injection d'une valeur `queryId` personnalisée à l'aide d'un indicateur de requête SPARQL
Voici un exemple d'utilisation de l'indicateur de requête `queryId` SPARQL pour injecter une valeur `queryId` personnalisée dans une requête SPARQL :
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=PREFIX hint: \
SELECT * WHERE { hint:Query hint:queryId \"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" \
{?s ?p ?o}}"
```
## Utilisation de la valeur `queryId` pour vérifier le statut de la requête
**Exemple Gremlin**
```
curl https://your-neptune-endpoint:port/gremlin/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
**Exemple SPARQL**
```
curl https://your-neptune-endpoint:port/sparql/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
# Accès au graphe Neptune avec Gremlin
Amazon Neptune est compatible avec Apache TinkerPop et Gkremlin. Cela signifie que vous pouvez vous connecter à une instance de base de données Neptune et utiliser le langage de traversée Gremlin pour interroger le graphe (voir The Graph dans [la documentation d'Apache](https://tinkerpop.apache.org/docs/current/reference/#graph)). TinkerPop Pour voir les différences dans l'implémentation Neptune de Gremlin, consultez [Conformité avec les normes Gremlin](access-graph-gremlin-differences.md).
Une *traversée* dans Gremlin est une série d'étapes chaînées. Elle commence à un sommet (ou arc). Elle parcourt le graphe en suivant les arêtes extérieures de chaque sommet, puis les arêtes extérieures de ces sommets. Chaque étape représente une opération de la traversée. Pour plus d'informations, consultez [The Traversal](https://tinkerpop.apache.org/docs/current/reference/#traversal) dans la TinkerPop documentation.
Les différentes versions du moteur Neptune prennent en charge différentes versions de Gremlin. Consultez la [page de version du moteur](engine-releases.md) de la version de Neptune que vous utilisez pour déterminer quelle version de Gremlin est prise en charge ou consultez le tableau suivant qui répertorie les versions les plus anciennes et les plus récentes TinkerPop prises en charge par les différentes versions du moteur Neptune :
| Version du moteur Neptune | TinkerPop Version minimale | TinkerPop Version maximale |
| --- | --- | --- |
| `1.3.2.0 and newer` | `3.7.1` | `3.7.3` |
| `1.3.1.0` | `3.6.2` | `3.6.5` |
| `1.3.0.0` | `3.6.2` | `3.6.4` |
| `1.2.1.0 <= 1.2.1.2` | `3.6.2` | `3.6.2` |
| `1.1.1.0 <= 1.2.0.2` | `3.5.5` | `3.5.6` |
| `1.1.0.0 and older` | `(deprecated)` | `(deprecated)` |
TinkerPop les clients sont généralement rétrocompatibles au sein d'une série (par exemple`3.6.x`, ou`3.7.x`) et bien qu'ils puissent souvent travailler au-delà de ces limites, le tableau ci-dessus recommande les combinaisons de versions à utiliser pour une expérience et une compatibilité optimales. Sauf avis contraire, il est généralement préférable de respecter ces directives et de mettre à niveau les applications clientes pour qu'elles correspondent à la version TinkerPop que vous utilisez.
Lors de la mise à niveau des TinkerPop versions, il est toujours important [TinkerPopde consulter la documentation de mise](http://tinkerpop.apache.org/docs/current/upgrade/) à niveau qui vous aidera à identifier les nouvelles fonctionnalités dont vous pouvez tirer parti, mais également les problèmes dont vous devrez peut-être être conscient à l'approche de votre mise à niveau. Vous devez généralement vous attendre à ce que les requêtes et fonctionnalités existantes fonctionnent après la mise à niveau, sauf si un problème particulier est indiqué comme un problème à prendre en compte. Enfin, il est important de noter que si vous mettez à niveau une version pour intégrer une nouvelle fonctionnalité, vous ne pourrez peut-être pas l'utiliser si elle provient d'une version ultérieure à celle prise en charge par Neptune.
Il existe des variantes du langage Gremlin et une prise en charge de l'accès Gremlin dans les différents langages de programmation. Pour plus d'informations, voir À [propos des variantes linguistiques de Gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) dans la TinkerPop documentation.
Cette documentation décrit comment accéder à Neptune avec les variantes et langages de programmation suivants :
+ [Configuration de la console Gremlin pour se connecter à une instance de base de données Neptune](access-graph-gremlin-console.md)
+ [Utilisation du point de terminaison HTTP REST pour se connecter à une instance de base de données Neptune](access-graph-gremlin-rest.md)
+ [Clients Gremlin basés sur Java à utiliser avec Amazon Neptune](access-graph-gremlin-client.md)
+ [Utilisation de Python pour se connecter à une instance de base de données Neptune](access-graph-gremlin-python.md)
+ [Utilisation de .NET pour se connecter à une instance de base de données Neptune](access-graph-gremlin-dotnet.md)
+ [Utilisation de Node.js pour se connecter à une instance de base de données Neptune](access-graph-gremlin-node-js.md)
+ [Utilisation de Go pour se connecter à une instance de base de données Neptune](access-graph-gremlin-go.md)
Comme indiqué dans la section[Chiffrement des connexions à votre base de données Amazon Neptune avec SSL/HTTPS](security-ssl.md), vous devez utiliser le protocole TLS/SSL (Transport Security/Secure Layer Sockets Layer) lorsque vous vous connectez à Neptune dans toutes les régions. AWS
Avant de commencer, les prérequis suivants doivent être remplis :
+ Vous devez disposer d'une instance de base de données Neptune. Pour plus d'informations sur la création d'une instance de base de données Neptune, consultez [Création d'un cluster Amazon Neptune](get-started-create-cluster.md).
+ Vous devez disposer d'une instance Amazon EC2 dans le même cloud privé virtuel (VPC) que l'instance de base de données Neptune.
Pour plus d'informations sur le chargement des données dans Neptune, y compris les prérequis, les formats de chargement et les paramètres de chargement, consultez [Chargement de données dans Amazon Neptune](load-data.md).
**Topics**
+ [Configuration de la console Gremlin pour se connecter à une instance de base de données Neptune](access-graph-gremlin-console.md)
+ [Utilisation du point de terminaison HTTP REST pour se connecter à une instance de base de données Neptune](access-graph-gremlin-rest.md)
+ [Clients Gremlin basés sur Java à utiliser avec Amazon Neptune](access-graph-gremlin-client.md)
+ [Utilisation de Python pour se connecter à une instance de base de données Neptune](access-graph-gremlin-python.md)
+ [Utilisation de .NET pour se connecter à une instance de base de données Neptune](access-graph-gremlin-dotnet.md)
+ [Utilisation de Node.js pour se connecter à une instance de base de données Neptune](access-graph-gremlin-node-js.md)
+ [Utilisation de Go pour se connecter à une instance de base de données Neptune](access-graph-gremlin-go.md)
+ [Utiliser le AWS SDK pour exécuter des requêtes Gremlin](access-graph-gremlin-sdk.md)
+ [Indicateurs de requête Gremlin](gremlin-query-hints.md)
+ [API de statut des requêtes Gremlin](gremlin-api-status.md)
+ [Annulation de requêtes Gremlin](gremlin-api-status-cancel.md)
+ [Prise en charge des sessions basées sur des scripts Gremlin](access-graph-gremlin-sessions.md)
+ [Transactions Gremlin dans Neptune](access-graph-gremlin-transactions.md)
+ [Utilisation de l'API Gremlin avec Amazon Neptune](gremlin-api-reference.md)
+ [Mise en cache des résultats de requête dans Amazon Neptune Gremlin](gremlin-results-cache.md)
+ [Réalisation d'upserts efficaces avec les étapes Gremlin `mergeV()` et `mergeE()`](gremlin-efficient-upserts.md)
+ [Réalisation d'upserts Gremlin efficaces avec `fold()/coalesce()/unfold()`](gremlin-efficient-upserts-pre-3.6.md)
+ [Analyse de l'exécution des requêtes à l'aide de Gremlin `explain`](gremlin-explain.md)
+ [Utilisation de Gremlin avec le moteur de requêtes Neptune DFE](gremlin-with-dfe.md)
# Configuration de la console Gremlin pour se connecter à une instance de base de données Neptune
La console G705 vous permet d'expérimenter avec TinkerPop des graphes et des requêtes dans un environnement REPL (read-eval-print boucle).
## Installation de la console Gremlin et mode de connexion habituel
Vous pouvez utiliser la console Gremlin pour vous connecter à une base de données distante orientée graphe. La section suivante vous guide dans l’installation et la configuration de la console Gremlin pour une connexion à distance à une instance de base de données Neptune. Vous devez suivre ces instructions à partir d'une instance Amazon EC2 dans le même cloud privé virtuel (VPC) (VPC) que l'instance de base de données Neptune.
Pour obtenir de l'aide sur la connexion à Neptune avec SSL/TLS (obligatoire), consultez. [Configuration SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)
**Note**
Si l'[authentification IAM est activée](iam-auth-enable.md) sur votre cluster de bases de données Neptune, suivez les instructions décrites dans [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec la console Gremlin](iam-auth-connecting-gremlin-console.md) pour installer la console Gremlin plutôt que celles indiquées ici.
**Pour installer la console Gremlin et vous connecter à Neptune**
1. Les fichiers binaires de la console Gremlin nécessitent Java 8 ou Java 11. Ces instructions supposent l'utilisation de Java 11. Vous pouvez installer Java 11 sur une instance EC2 comme suit :
+ Si vous utilisez [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2) :
```
sudo amazon-linux-extras install java-openjdk11
```
+ Si vous utilisez [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html) :
```
sudo yum install java-11-amazon-corretto-devel
```
+ Pour les autres distributions, utilisez l'instruction qui convient le mieux parmi les suivantes :
```
sudo yum install java-11-openjdk-devel
```
ou :
```
sudo apt-get install openjdk-11-jdk
```
1. Entrez la commande suivante pour définir Java 8 en tant qu'environnement d'exécution par défaut sur votre instance EC2.
```
sudo /usr/sbin/alternatives --config java
```
Lorsque vous y êtes invité, saisissez le nombre correspondant à Java 11.
1. Téléchargez la version appropriée de la console Gremlin depuis le site Web d'Apache. Vous pouvez vérifier si votre version de [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md) Neptune est prise en charge par votre version de Gremlin. Par exemple, si vous avez besoin de la version 3.7.2, vous pouvez télécharger la [console Gremlin](https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip) depuis le site Web [Apache Tinkerpop](https://tinkerpop.apache.org/download.html) sur votre instance EC2 comme suit :
```
wget https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Décompressez le fichier zip Gremlin Console.
```
unzip apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Modifiez les répertoires du répertoire décompressé.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. Dans le sous-répertoire `conf` du répertoire extrait, créez un fichier nommé `neptune-remote.yaml` avec le texte suivant. *your-neptune-endpoint*Remplacez-le par le nom d'hôte ou l'adresse IP de votre instance de base de données Neptune. Les crochets (`[ ]`) sont obligatoires.
**Note**
Consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md) pour découvrir comment trouver le nom d'hôte de votre instance de base de données Neptune.
```
hosts: [your-neptune-endpoint]
port: 8182
connectionPool: { enableSsl: true }
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1,
config: { serializeResultToString: true }}
```
**Note**
Les sérialiseurs ont été déplacés du `gremlin-driver` module vers le nouveau `gremlin-util` module dans la version 3.7.0. Le package est passé de org.apache.tinkerpop.gremlin.driver.ser à org.apache.tinkerpop.gremlin.util.ser.
1. Dans un terminal, accédez au répertoire Gremlin Console (`apache-tinkerpop-gremlin-console-3.7.2`), puis entrez la commande suivante pour exécuter la console Gremlin.
```
bin/gremlin.sh
```
Vous devriez voir la sortie suivante :
```
\,,,/
(o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin>
```
Vous êtes maintenant à l'invite `gremlin>`. Vous entrez les étapes restantes à cette invite.
1. À l'invite de commande `gremlin>`, saisissez le texte suivant pour vous connecter à l'instance de base de données Neptune.
```
:remote connect tinkerpop.server conf/neptune-remote.yaml
```
1. À l'invite `gremlin>`, entrez ce qui suit pour passer en mode distant. Toutes les requêtes Gremlin sont alors envoyées à la connexion distante.
```
:remote console
```
1. Saisissez la commande suivante pour envoyer une requête au graphe Gremlin.
```
g.V().limit(1)
```
1. Lorsque vous avez terminé, saisissez la commande suivante pour quitter la console Gremlin.
```
:exit
```
**Note**
Utilisez un point-virgule (`;`) ou un caractère de saut de ligne (`\n`) pour séparer chaque instruction.
Chaque traversée précédant la traversée finale doit se terminer par l'exécution de `next()`. Seules les données de la traversée finale sont renvoyées.
Pour plus d'informations sur l'implémentation Neptune de Gremlin, consultez [Conformité d'Amazon Neptune avec les normes Gremlin](access-graph-gremlin-differences.md).
# Autre mode de connexion à la console Gremlin
**Inconvénients de l'approche de connexion habituelle**
La méthode la plus courante pour se connecter à la console Gremlin est expliquée ci-dessus et utilise des commandes comme celle-ci à l'invite `gremlin>` :
```
gremlin> :remote connect tinkerpop.server conf/(file name).yaml
gremlin> :remote console
```
Elle est opérationnelle et vous permet d'envoyer des requêtes à Neptune. Cependant, elle exclut le moteur de script Groovy, de sorte que Neptune traite toutes les requêtes comme si elles étaient entièrement écrites dans Gremlin. Par conséquent, les types de requête suivants échouent :
```
gremlin> 1 + 1
gremlin> x = g.V().count()
```
Le meilleur moyen d'utiliser une variable lorsque vous êtes connecté de cette façon consiste à utiliser la variable `result` gérée par la console et d'envoyer la requête en utilisant `:>`, comme ceci :
```
gremlin> :remote console
==>All scripts will now be evaluated locally - type ':remote console' to return to remote mode for Gremlin Server - [krl-1-cluster.cluster-ro-cm9t6tfwbtsr.us-east-1.neptune.amazonaws.com/172.31.19.217:8182]
gremlin> :> g.V().count()
==>4249
gremlin> println(result)
[result{object=4249 class=java.lang.Long}]
gremlin> println(result['object'])
[4249]
```
**Autre mode de connexion**
Vous pouvez également vous connecter à la console Gremlin d'une autre manière, que vous trouverez peut-être plus agréable, comme ceci :
```
gremlin> g = traversal().withRemote('conf/neptune.properties')
```
`neptune.properties` prend ici la forme suivante :
```
gremlin.remote.remoteConnectionClass=org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection
gremlin.remote.driver.clusterFile=conf/my-cluster.yaml
gremlin.remote.driver.sourceName=g
```
Le fichier `my-cluster.yaml` doit ressembler à ceci :
```
hosts: [my-cluster-abcdefghijk.us-east-1.neptune.amazonaws.com]
port: 8182
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1,
config: { serializeResultToString: false } }
connectionPool: { enableSsl: true }
```
**Note**
Les sérialiseurs ont été déplacés du `gremlin-driver` module vers le nouveau `gremlin-util` module dans la version 3.7.0. Le package est passé de org.apache.tinkerpop.gremlin.driver.ser à org.apache.tinkerpop.gremlin.util.ser.
En configurant ainsi la connexion à la console Gremlin, vous pouvez effectuer avec succès les types de requêtes suivants :
```
gremlin> 1+1
==>2
gremlin> x=g.V().count().next()
==>4249
gremlin> println("The answer was ${x}")
The answer was 4249
```
Pour éviter d'afficher le résultat, procédez comme suit :
```
gremlin> x=g.V().count().next();[]
gremlin> println(x)
4249
```
Toutes les méthodes habituelles d'interrogation (sans l'étape terminale) continuent de fonctionner. Par exemple :
```
gremlin> g.V().count()
==>4249
```
Vous pouvez même utiliser l'étape [https://tinkerpop.apache.org/docs/current/reference/#io-step](https://tinkerpop.apache.org/docs/current/reference/#io-step) pour charger un fichier avec ce type de connexion.
## Authentification IAM
Neptune prend en charge l'[authentification IAM](iam-auth-enable.md) pour contrôler l'accès à votre cluster de base de données. Si l'authentification IAM est activée, vous devez utiliser la signature Signature version 4 pour authentifier vos demandes. Pour obtenir des instructions détaillées et des exemples de code pour la connexion depuis la console Gremlin, consultez[Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec la console Gremlin](iam-auth-connecting-gremlin-console.md).
# Utilisation du point de terminaison HTTP REST pour se connecter à une instance de base de données Neptune
Amazon Neptune fournit un point de terminaison HTTP pour les requêtes Gremlin. L'interface REST est compatible avec n'importe quelle version Gremlin de votre cluster de bases de données (consultez la [page de mise à jour](engine-releases.md) correspondant à la version de moteur Neptune que vous exécutez pour déterminer la version Gremlin prise en charge).
**Note**
Comme indiqué dans [Chiffrement des connexions à votre base de données Amazon Neptune avec SSL/HTTPS](security-ssl.md), vous devez désormais vous connecter via HTTPS au lieu de HTTP dans Neptune. En outre, Neptune ne prend actuellement pas en charge le HTTP/2 pour les requêtes d'API REST. Les clients doivent utiliser HTTP/1.1 lorsqu'ils se connectent aux points de terminaison.
Les instructions suivantes vous guident à travers la connexion au point de terminaison Gremlin à l'aide de la commande `curl` et de HTTPS. Vous devez suivre ces instructions à partir d'une instance Amazon EC2 dans le même cloud privé virtuel (VPC) (VPC) que l'instance de base de données Neptune.
Le point de terminaison HTTPS pour les requêtes Gremlin dans une instance de base de données Neptune est `https://your-neptune-endpoint:port/gremlin`.
**Note**
Pour découvrir comment trouver le nom d'hôte de l'instance de base de données Neptune, consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md).
## Pour se connecter à Neptune à l'aide du point de terminaison HTTP REST
L'exemple suivant utilise **curl** pour soumettre une requête Gremlin via HTTP **POST**. La requête est soumise au format JSON dans le corps de la publication en tant que propriété `gremlin`.
```
curl -X POST -d '{"gremlin":"g.V().limit(1)"}' https://your-neptune-endpoint:port/gremlin
```
L'exemple précédent renvoie le premier sommet du graphe en utilisant la traversée `g.V().limit(1)`. Pour interroger autre chose, remplacez cette traversée par une autre traversée Gremlin.
**Important**
Par défaut, le point de terminaison REST renvoie tous les résultats dans un seul ensemble de résultats JSON. Si cet ensemble de résultats est trop volumineux, une exception `OutOfMemoryError` peut être générée dans l'instance de base de données Neptune.
Pour éviter cette exception, activez les réponses segmentées (résultats renvoyés sous la forme d'une série de réponses distinctes). Consultez [Utilisation d'en-têtes de suivi HTTP facultatifs pour activer les réponses Gremlin en plusieurs parties](access-graph-gremlin-rest-trailing-headers.md).
Bien que les demandes HTTP **POST** soient recommandées pour envoyer des requêtes Gremlin, il est également possible d'utiliser des demandes HTTP **GET** :
```
curl -G "https://your-neptune-endpoint:port?gremlin=g.V().count()"
```
**Note**
Neptune ne prend pas en charge la propriété `bindings`.
# Utilisation d'en-têtes de suivi HTTP facultatifs pour activer les réponses Gremlin en plusieurs parties
Par défaut, la réponse HTTP aux requêtes Gremlin est renvoyée dans un seul ensemble de résultats JSON. Un ensemble de résultats très volumineux peut générér une exception `OutOfMemoryError` dans l'instance de base de données.
Vous pouvez toutefois activer les *réponses segmentées* (réponses renvoyées en plusieurs parties distinctes). Pour ce faire, incluez un en-tête « trailer » (`te: trailers`) d'encodage de transfert (TE) dans la demande. Consultez la [page MDN (sur les en-têtes de demande TE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE)) pour plus d'informations sur ces en-têtes.
Lorsqu'une réponse est renvoyée en plusieurs parties, il peut être difficile de diagnostiquer un problème qui survient après la réception de la première partie, car la première partie arrive avec le code de statut HTTP `200` (OK). En cas d'échec ultérieur, le corps du message contient généralement une réponse corrompue, à la fin de laquelle Neptune ajoute un message d'erreur.
Pour faciliter la détection et le diagnostic de ce type d'échec, Neptune inclut également deux nouveaux champs d'en-tête dans les en-têtes suivants de chaque segment de réponse :
+ `X-Neptune-Status` : contient le code de réponse suivi d'un nom court. Par exemple, en cas de réussite, l'en-tête final serait : `X-Neptune-Status: 200 OK`. En cas d'échec, le code de réponse est l'un des [codes d'erreur du moteur Neptune](errors-engine-codes.md), tel que `X-Neptune-Status: 500 TimeLimitExceededException`.
+ `X-Neptune-Detail` : est vide pour les demandes qui ont abouti. En cas d'erreur, il contient le message d'erreur JSON. Étant donné que seuls les caractères ASCII sont autorisés dans les valeurs d'en-tête HTTP, la chaîne JSON est encodée en URL.
**Note**
Neptune ne prend actuellement pas en charge la compression `gzip` des réponses segmentées. Si le client demande à la fois un encodage et une compression segmentés, Neptune ignore la compression.
# Clients Gremlin basés sur Java à utiliser avec Amazon Neptune
[Vous pouvez utiliser l'un des deux clients G705 open source basés sur Java avec Amazon Neptune : le client [Apache TinkerPop Java G705 ou le client G705](https://search.maven.org/artifact/org.apache.tinkerpop/gremlin-driver) pour Amazon Neptune.](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client)
## Client Apache TinkerPop Java Garmlin
Le [pilote Apache TinkerPop Java gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java) est le client Gremlin standard et officiel qui fonctionne avec n'importe quelle TinkerPop base de données de graphes compatible. Utilisez ce client lorsque vous avez besoin d'une compatibilité maximale avec l'ensemble de l'espace de TinkerPop développement, lorsque vous travaillez avec plusieurs systèmes de base de données de graphes ou lorsque vous n'avez pas besoin des fonctionnalités avancées de gestion des clusters et d'équilibrage de charge spécifiques à Neptune. Ce client convient également aux applications simples qui se connectent à une seule instance Neptune ou lorsque vous préférez gérer l'équilibrage de charge au niveau de l'infrastructure plutôt qu'au sein du client.
**Important**
Le choix de la bonne version du pilote Apache TinkerPop Gremlin est essentiel pour garantir la compatibilité avec la version de votre moteur Neptune. L'utilisation d'une version incompatible peut entraîner des échecs de connexion ou un comportement inattendu. Pour obtenir des informations détaillées sur la compatibilité des versions, consultez[Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md).
**Note**
Le tableau qui vous aide à déterminer la TinkerPop version correcte d'Apache à utiliser avec Neptune a été déplacé vers. [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md) Ce tableau se trouvait auparavant sur cette page depuis de nombreuses années et est désormais plus centralisé à titre de référence pour tous les langages de programmation pris TinkerPop en charge.
## Client Java Gremlin pour Amazon Neptune
Le client Gremlin pour Amazon Neptune est [un client Gremlin open source basé sur Java](https://github.com/aws/neptune-gremlin-client) qui remplace directement le client Java standard. TinkerPop
Le client Gremlin Neptune est optimisé pour les clusters Neptune. Il vous permet de gérer la distribution du trafic entre plusieurs instances d'un cluster et s'adapte aux modifications de la topologie du cluster lorsque vous ajoutez ou supprimez un réplica. Vous pouvez même configurer le client pour distribuer les demandes sur un sous-ensemble d'instances du cluster, en fonction du rôle, du type d'instance, de la zone de disponibilité (AZ) ou des balises associées aux instances.
La [dernière version du client Java Gremlin Neptune](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client) est disponible sur Maven Central.
Pour plus d'informations sur le client Java Gremlin Neptune, consultez [ce billet de blog](https://aws.amazon.com/blogs/database/load-balance-graph-queries-using-the-amazon-neptune-gremlin-client/). Pour des exemples de code et des démos, consultez le [ GitHub projet du client](https://github.com/aws/neptune-gremlin-client).
Lorsque vous choisissez la version du client Neptune G705, vous devez prendre en compte la TinkerPop version sous-jacente par rapport à la version de votre moteur Neptune. Reportez-vous au tableau de compatibilité sur [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md) pour déterminer la TinkerPop version appropriée pour votre moteur Neptune, puis utilisez le tableau suivant pour sélectionner la version du client Neptune Gremlin appropriée :
**Compatibilité des versions du client Neptune Garmlin**
| Version du client Neptune Garmlin | TinkerPop version |
| --- | --- |
| 3.x | 3.7.x (AWS SDK pour Java 2.x/1.x) |
| 2.1.x | 3.7.x (AWS SDK pour Java 1.x) |
| 2.0.x | 3,6. x |
| 1.12 | 3.5.x |
# Utilisation du client Java pour se connecter à une instance de base de données Neptune
La section suivante explique comment exécuter un exemple Java complet qui se connecte à une instance de base de données Neptune et effectue une traversée de G705 à l'aide du client Apache G705. TinkerPop
Vous devez suivre ces instructions à partir d'une instance Amazon EC2 située dans le même cloud privé virtuel (VPC) (VPC) que l'instance de base de données Neptune.
**Pour se connecter à Neptune à l'aide de Java**
1. Installez Apache Maven sur votre instance EC2. Si vous utilisez Amazon Linux 2023 (de préférence), utilisez :
```
sudo dnf update -y
sudo dnf install maven -y
```
Si vous utilisez Amazon Linux 2, téléchargez le dernier fichier binaire [sur https://maven.apache.org/download.cgi :](https://maven.apache.org/download.cgi:)
```
sudo yum remove maven -y
wget https://dlcdn.apache.org/maven/maven-3/ /binaries/apache-maven--bin.tar.gz
sudo tar -xzf apache-maven--bin.tar.gz -C /opt/
sudo ln -sf /opt/apache-maven- /opt/maven
echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
```
1. **Installez Java.** Les bibliothèques Gremlin nécessitent Java 8 ou 11. Vous pouvez installer Java 11 comme suit :
+ Si vous utilisez [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2) :
```
sudo amazon-linux-extras install java-openjdk11
```
+ Si vous utilisez [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html) :
```
sudo yum install java-11-amazon-corretto-devel
```
+ Pour les autres distributions, utilisez l'instruction qui convient le mieux parmi les suivantes :
```
sudo yum install java-11-openjdk-devel
```
ou :
```
sudo apt-get install openjdk-11-jdk
```
1. **Définissez Java 11 comme environnement d'exécution par défaut sur votre instance EC2 :** entrez ce qui suit pour définir Java 8 comme environnement d'exécution par défaut sur l'instance EC2 :
```
sudo /usr/sbin/alternatives --config java
```
Lorsque vous y êtes invité, saisissez le nombre correspondant à Java 11.
1. **Créez un répertoire appelé `gremlinjava` :**
```
mkdir gremlinjava
cd gremlinjava
```
1. Dans le répertoire `gremlinjava`, créez un fichier `pom.xml`, puis ouvrez-le dans un éditeur de texte:
```
nano pom.xml
```
1. Copiez ce qui suit dans le fichier `pom.xml` et enregistrez-le:
```
UTF-84.0.0com.amazonawsGremlinExamplejar1.0-SNAPSHOTGremlinExamplehttps://maven.apache.orgorg.apache.tinkerpopgremlin-driver3.7.2org.slf4jslf4j-jdk141.7.25org.apache.maven.pluginsmaven-compiler-plugin2.5.11111org.codehaus.mojoexec-maven-plugin1.3java-classpathcom.amazonaws.Appcom.amazonaws.App1.11-1
```
**Note**
Si vous modifiez un projet Maven existant, la dépendance obligatoire est mise en évidence dans le code précédent.
1. Créez des sous-répertoires pour l'exemple de code source (`src/main/java/com/amazonaws/`) en saisissant ce qui suit sur la ligne de commande :
```
mkdir -p src/main/java/com/amazonaws/
```
1. Dans le répertoire `src/main/java/com/amazonaws/`, créez un fichier `App.java`, puis ouvrez-le dans un éditeur de texte.
```
nano src/main/java/com/amazonaws/App.java
```
1. Copiez ce qui suit dans le fichier `App.java`. Remplacez *your-neptune-endpoint* par l'adresse de votre instance de base de données Neptune. N’incluez *pas* le préfixe `https://` dans la méthode `addContactPoint`.
**Note**
Pour découvrir comment trouver le nom d'hôte de l'instance de base de données Neptune, consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md).
```
package com.amazonaws;
import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.structure.T;
public class App
{
public static void main( String[] args )
{
Cluster.Builder builder = Cluster.build();
builder.addContactPoint("your-neptune-endpoint");
builder.port(8182);
builder.enableSsl(true);
Cluster cluster = builder.create();
GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));
// Add a vertex.
// Note that a Gremlin terminal step, e.g. iterate(), is required to make a request to the remote server.
// The full list of Gremlin terminal steps is at https://tinkerpop.apache.org/docs/current/reference/#terminal-steps
g.addV("Person").property("Name", "Justin").iterate();
// Add a vertex with a user-supplied ID.
g.addV("Custom Label").property(T.id, "CustomId1").property("name", "Custom id vertex 1").iterate();
g.addV("Custom Label").property(T.id, "CustomId2").property("name", "Custom id vertex 2").iterate();
g.addE("Edge Label").from(__.V("CustomId1")).to(__.V("CustomId2")).iterate();
// This gets the vertices, only.
GraphTraversal t = g.V().limit(3).elementMap();
t.forEachRemaining(
e -> System.out.println(t.toList())
);
cluster.close();
}
}
```
Pour obtenir de l'aide sur la connexion à Neptune avec SSL/TLS (obligatoire), consultez. [Configuration SSL/TLS](#access-graph-gremlin-java-ssl)
1. Compilez et exécutez l'exemple à l'aide de la commande Maven suivante :
```
mvn compile exec:exec
```
L'exemple précédent renvoie une carte de la clé et les valeurs de chaque propriété pour les deux premiers vertex du graphe à l'aide de la traversée `g.V().limit(3).elementMap()`. Pour interroger quelque chose d'autre, remplacez la traversée par une autre traversée Gremlin avec l'une des méthodes de fin appropriées.
**Note**
La partie finale de la requête Gremlin, `.toList()`, est obligatoire pour soumettre la traversée au serveur à des fins d'évaluation. Si vous n'incluez pas cette méthode ou une autre méthode équivalente, la requête ne sera pas soumise à l'instance de base de données Neptune.
Vous devez également ajouter une terminaison appropriée lorsque vous ajoutez un sommet ou une arête, comme lorsque vous utilisez l'étape `addV( )`.
Les méthodes suivantes soumettent la requête à l'instance de base de données Neptune :
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Configuration SSL/TLS pour le client Java Gremlin
Neptune doit SSL/TLS être activé par défaut. Généralement, si le pilote Java est configuré avec `enableSsl(true)`, il peut se connecter à Neptune sans avoir à configurer `trustStore()` ou `keyStore()` avec une copie locale d'un certificat.
Toutefois, si l'instance à laquelle vous vous connectez ne dispose pas d'une connexion Internet permettant de vérifier un certificat public ou si le certificat que vous utilisez n'est pas public, vous pouvez suivre les étapes ci-dessous pour configurer une copie du certificat local :
**Configuration d'une copie du certificat local pour activer le protocole SSL/TLS**
1. Téléchargez et installez [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) depuis Oracle. Cela facilitera grandement la configuration du magasin de clés local.
1. Téléchargez le certificat CA `SFSRootCAG2.pem` (le kit SDK Java Gremlin a besoin d'un certificat pour vérifier le certificat à distance).
```
wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
```
1. Créez un magasin de clés au format JKS ou PKCS12 au format. Cet exemple utilise JKS. Répondez aux questions qui suivent à l'invite. Le mot de passe que vous créez ici sera nécessaire ultérieurement :
```
keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
```
1. Importez le fichier `SFSRootCAG2.pem` que vous avez téléchargé dans le magasin de clés que vous venez de créer :
```
keytool -import -keystore server.jks -file .pem
```
1. Configurez l'objet `Cluster` par programmation :
```
Cluster cluster = Cluster.build("(your neptune endpoint)")
.port(8182)
.enableSSL(true)
.keyStore(‘server.jks’)
.keyStorePassword("(the password from step 2)")
.create();
```
Vous pouvez faire la même chose dans un fichier de configuration si vous le souhaitez, comme vous pourriez le faire avec la console Gremlin :
```
hosts: [(your neptune endpoint)]
port: 8182
connectionPool: { enableSsl: true, keyStore: server.jks, keyStorePassword: (the password from step 2) }
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }}
```
## Authentification IAM
Neptune prend en charge l'[authentification IAM](iam-auth-enable.md) pour contrôler l'accès à votre cluster de base de données. Si l'authentification IAM est activée, vous devez utiliser la signature Signature version 4 pour authentifier vos demandes. Pour obtenir des instructions détaillées et des exemples de code pour la connexion à partir d'un client Java, consultez[Connexion aux bases de données Amazon Neptune à l'aide d'IAM avec Gkremlin Java](iam-auth-connecting-gremlin-java.md).
# Exemple Java de connexion à une instance de base de données Neptune avec une logique de reconnexion
L'exemple Java suivant montre comment se connecter au client Gremlin à l'aide d'une logique de reconnexion afin d'assurer la reprise après une déconnexion inattendue.
Il présente les dépendances suivantes :
```
org.apache.tinkerpopgremlin-driver${gremlin.version}com.amazonawsamazon-neptune-sigv4-signer${sig4.signer.version}com.evanlennickretry4j0.15.0
```
Voici l'exemple de code :
**Important**
Le `CallExecutor` de Retry4j n'est peut-être pas thread-safe. Envisagez de demander à chaque thread d'utiliser sa propre `CallExecutor` instance ou d'utiliser une bibliothèque de nouvelles tentatives différente.
**Note**
L'exemple suivant a été mis à jour pour inclure l'utilisation de RequestInterceptor (). Cela a été ajouté dans la version TinkerPop 3.6.6. Avant la TinkerPop version 3.6.6, l'exemple de code utilisait HandshakeInterceptor (), qui était obsolète avec cette version.
```
public static void main(String args[]) {
boolean useIam = true;
// Create Gremlin cluster and traversal source
Cluster.Builder builder = Cluster.build()
.addContactPoint(System.getenv("neptuneEndpoint"))
.port(Integer.parseInt(System.getenv("neptunePort")))
.enableSsl(true)
.minConnectionPoolSize(1)
.maxConnectionPoolSize(1)
.serializer(Serializers.GRAPHBINARY_V1D0)
.reconnectInterval(2000);
if (useIam) {
builder.requestInterceptor( r -> {
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
new NeptuneNettyHttpSigV4Signer("(your region)", new DefaultAWSCredentialsProviderChain());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
});
}
Cluster cluster = builder.create();
GraphTraversalSource g = AnonymousTraversalSource
.traversal()
.withRemote(DriverRemoteConnection.using(cluster));
// Configure retries
RetryConfig retryConfig = new RetryConfigBuilder()
.retryOnCustomExceptionLogic(getRetryLogic())
.withDelayBetweenTries(1000, ChronoUnit.MILLIS)
.withMaxNumberOfTries(5)
.withFixedBackoff()
.build();
@SuppressWarnings("unchecked")
CallExecutor