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.
# Bonnes pratiques d'ordre général pour l'utilisation de Gremlin avec Neptune
Suivez ces recommandations lorsque vous utilisez le langage de parcours de graphe Gremlin avec Neptune. Pour plus d'informations sur l'utilisation de Gremlin avec Neptune, consultez [Accès au graphe Neptune avec Gremlin](access-graph-gremlin.md).
**Important**
Une modification a été apportée à TinkerPop la version 3.4.11 qui améliore l'exactitude du traitement des requêtes, mais qui, pour le moment, peut parfois avoir un impact sérieux sur les performances des requêtes.
Par exemple, une requête de ce type peut être beaucoup plus lente :
```
g.V().hasLabel('airport').
order().
by(out().count(),desc).
limit(10).
out()
```
Les sommets après l'étape de limite sont désormais récupérés de manière non optimale en raison de la TinkerPop modification 3.4.11. Pour éviter cela, vous pouvez modifier la requête en ajoutant l'étape barrier() à tout moment après `order().by()`. Par exemple :
```
g.V().hasLabel('airport').
order().
by(out().count(),desc).
limit(10).
barrier().
out()
```
TinkerPop [La version 3.4.11 a été activée dans la version 1.0.5.0 du moteur Neptune.](engine-releases-1.0.5.0.md)
**Topics**
+ [Configuration Heartbeat pour Neptune Serverless](best-practices-gremlin-heartbeat-serverless.md)
+ [Structurer les requêtes upsert pour tirer parti du moteur DFE](#best-practices-gremlin-upserts)
+ [Testez le code Gremlin dans le contexte dans lequel vous allez le déployer](best-practices-gremlin-console-glv-differences.md)
+ [Création d'écritures Gremlin multithreads efficaces](best-practices-gremlin-multithreaded-writes.md)
+ [Élagage des enregistrements avec la propriété de date/heure de création](best-practices-gremlin-prune.md)
+ [Utilisation de la méthode `datetime( )` pour les données temporelles Groovy](best-practices-gremlin-datetime.md)
+ [Utilisation de la date et de l'heure natives pour les données temporelles GLV](best-practices-gremlin-datetime-glv.md)
# Configuration Heartbeat pour Neptune Serverless
Lorsque vous utilisez des WebSocket clients G705 avec Neptune Serverless, vous devez configurer l'intervalle de ping du client de manière appropriée afin de maintenir des connexions stables pendant les événements de dimensionnement. Le client G705 utilise des WebSocket connexions et envoie des pings périodiques pour vérifier que la connexion est active. Le client attend une réponse du serveur dans le délai imparti pour le ping. Si le serveur ne répond pas, le client ferme automatiquement la connexion.
**Pour les instances **provisionnées par** Neptune, nous recommandons de définir l'intervalle ping sur 5 secondes.** Pour les **clusters Neptune Serverless**, nous recommandons de définir l'intervalle ping sur au moins **20 secondes** afin de tenir compte des retards potentiels lors des opérations de dimensionnement. Ce paramètre contrôle la durée pendant laquelle le client attend entre deux écritures sur le serveur avant d'envoyer un ping pour vérifier que la connexion est toujours active.
La configuration de ce paramètre varie en fonction de l'implémentation du client :
**Configuration du client Java**
Pour le client Java TinkerPop G705, configurez le `keepAliveInterval` paramètre :
```
Cluster.Builder builder = Cluster.build()
.addContactPoint(endpoint)
.keepAliveInterval(20000); // Configure ping interval in milliseconds
```
Pour plus de détails sur la configuration du pilote Java, consultez la [ TinkerPop documentation Java](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration).
**Configuration du client Go**
Pour le client G705 Go, configurez le `KeepAliveInterval` paramètre :
```
rc, err := driver.NewDriverRemoteConnection(endpoint,
func(settings *driver.DriverRemoteConnectionSettings) {
settings.TraversalSource = "g"
settings.AuthInfo = auth
settings.KeepAliveInterval = 20 * time.Second // Configure ping interval
...
})
```
Pour plus de détails sur la configuration du pilote Go, consultez la [ TinkerPop documentation Go](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go-configuration).
**JavaScriptConfiguration du client /Node.js**
Pour le client JavaScript /Node.js G705, configurez le `pingInterval` paramètre :
```
const gremlin = require('gremlin');
const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection;
const connection = new DriverRemoteConnection(endpoint, {
traversalSource: 'g',
pingInterval: 20000 // Configure ping interval in milliseconds
});
```
Pour plus de détails sur la configuration du JavaScript pilote, reportez-vous à la [JavaScript TinkerPop documentation](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript-configuration).
**Configuration du client Python**
Pour le client Python Gremlin, l'intervalle ping est généralement géré au niveau de la couche de transport. Consultez la documentation spécifique de mise en œuvre du transport pour connaître les options de configuration :
```
from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
g = traversal().with_remote(
DriverRemoteConnection('wss://your-neptune-endpoint:your-neptune-port/gremlin','g',
transport_factory=lambda: AiohttpTransport(read_timeout=60,
write_timeout=20,
heartbeat=20, // Configure heartbeat
call_from_event_loop=True,
max_content_length=100*1024*1024,
ssl_options=ssl.create_default_context(Purpose.CLIENT_AUTH))))
```
Pour plus de détails sur la configuration du pilote Python, consultez la [ TinkerPop documentation Python](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python-configuration).
Cette configuration garantit à votre client la stabilité de la connexion lors des événements de dimensionnement Neptune Serverless, en évitant les fermetures de connexion inutiles et en améliorant la fiabilité des applications.
## Structurer les requêtes upsert pour tirer parti du moteur DFE
[Réalisation d'upserts efficaces avec les étapes Gremlin `mergeV()` et `mergeE()`](gremlin-efficient-upserts.md) explique comment structurer les requêtes upsert pour utiliser le moteur DFE le plus efficacement possible.
# Testez le code Gremlin dans le contexte dans lequel vous allez le déployer
Dans G705, les clients peuvent envoyer des requêtes au serveur de plusieurs manières : en utilisant ou en utilisant le Bytecode GLV WebSocket, ou via la console G705 à l'aide de scripts basés sur des chaînes.
Il est important de savoir que l'exécution d'une requête Gremlin peut varier en fonction de la manière dont vous la soumettez. Une requête qui renvoie un résultat vide peut être considérée comme ayant abouti si elle est soumise en mode Bytecode, mais comme ayant échoué si elle est soumise en mode script. Par exemple, si vous incluez une requête `next()` en mode script, elle `next()` est envoyée au serveur, mais l'utilisation du client ByteCode la `next()` traite généralement elle-même. Dans le premier cas, la requête échoue si aucun résultat n'est trouvé, mais dans le second, elle aboutit, que le jeu de résultats soit vide ou non.
Si vous développez et testez le code dans un seul contexte (par exemple, la console Gremlin qui envoie généralement des requêtes sous forme de texte), mais que vous déployez ensuite le code dans un autre contexte (par exemple via le pilote Java utilisant Bytecode), vous pouvez rencontrer des problèmes liés au fait que le code se comporte différemment en production que dans l'environnement de développement.
**Important**
Assurez-vous de tester le code Gremlin dans le contexte GLV dans lequel il sera déployé, afin d'éviter des résultats inattendus.
# Création d'écritures Gremlin multithreads efficaces
Quelques recommandations sont à observer pour le chargement multithread de données dans Neptune avec Gremlin.
Dans la mesure du possible, attribuez à chaque thread un ensemble de sommets ou d'arcs à insérer ou modifier qui ne se chevauchent pas. Par exemple, le thread 1 concerne la plage d'ID allant de 1 à 50 000, le thread 2 concerne la plage d'ID allant de 50 001 à 100 000, et ainsi de suite. Cela réduit le risque de générer une exception `ConcurrentModificationException`. Par mesure de sécurité, placez un bloc `try/catch` autour de toutes les écritures. En cas d'échec, vous pouvez effectuer une nouvelle tentative après un court délai.
Le traitement par lots de 50 à 100 écritures (sommets ou arcs) donne généralement de bons résultats. Si, pour chaque sommet, un grand nombre de propriétés sont ajoutées, il est préférable de tendre vers 50 plutôt que 100. Il est utile de réaliser des expérimentations. Ainsi, pour les écritures traitées par lots, vous pouvez utiliser un code similaire à ce qui suit :
```
g.addV(‘test’).property(id,’1’).as(‘a’).
addV(‘test’).property(id,’2’).
addE(‘friend’).to(‘a’).
```
Il est ensuite repris dans chaque opération de traitement par lots.
Il est nettement plus efficace d'utiliser des lots que d'ajouter un sommet ou un arc au serveur pour chaque boucle Gremlin.
Si vous utilisez un client GLV (Gremlin Language Variant), vous pouvez créer un lot par programmation en commençant par la création d'un parcours. Ensuite, effectuez des ajouts et, enfin, des itérations, par exemple :
```
t.addV(‘test’).property(id,’1’).as(‘a’)
t.addV(‘test’).property(id,’2’)
t.addE(‘friend’).to(‘a’)
t.iterate()
```
Il est préférable d'utiliser le client GLV (Gremlin Language Variant) si possible. Mais vous pouvez faire quelque chose de similaire avec un client qui soumet des requêtes sous forme de chaînes de texte qui sont concaténées pour former un lot.
Si vous utilisez l'une des bibliothèques de client Gremlin plutôt que le protocole HTTP de base pour les requêtes, les threads doivent tous partager le même client, cluster ou groupe de connexion. Vous pouvez être amené à ajuster les paramètres pour bénéficier d'un débit optimal, des paramètres tels que la taille du groupe de connexion et le nombre de threads de travail qu'utilise le client Gremlin.
# Élagage des enregistrements avec la propriété de date/heure de création
Vous pouvez élaguer les enregistrements obsolètes en stockant la date/heure de création en tant que propriété sur les sommets et en les supprimant périodiquement.
Si vous devez stocker des données pour une durée de vie spécifique, puis les supprimer du graphe (durée de vie du sommet), vous pouvez stocker une propriété d'horodatage lors de la création du sommet. Vous pouvez ensuite exécuter périodiquement une requête `drop()` pour tous les sommets qui ont été créés avant une certaine date/heure, par exemple :
```
g.V().has(“timestamp”, lt(datetime('2018-10-11')))
```
# Utilisation de la méthode `datetime( )` pour les données temporelles Groovy
Neptune fournit la méthode `datetime` afin de spécifier des dates et heures pour les requêtes envoyées dans la variante Gremlin **Groovy**. Cela inclut la console Gremlin, les chaînes de texte utilisant l'API REST HTTP, et toute autre sérialisation qui utilise Groovy.
**Important**
Ceci s'applique *uniquement* aux méthodes dans lesquelles vous envoyez la requête Gremlin en tant que *chaîne de texte*. Si vous utilisez une variante du langage Gremlin (Gremlin Language Variant), vous devez utiliser les classes et fonctions de dates natives pour le langage. Pour plus d’informations, consultez la section suivante, [Utilisation de la date et de l'heure natives pour les données temporelles GLV](best-practices-gremlin-datetime-glv.md).
Commencer par TinkerPop `3.5.2` (introduit dans la [version 1.1.1.0 du moteur Neptune](engine-releases-1.1.1.0.md)) fait partie intégrante de. `datetime` TinkerPop
Vous pouvez utiliser la méthode `datetime` pour stocker et comparer des dates :
```
g.V('3').property('date',datetime('2001-02-08'))
```
```
g.V().has('date',gt(datetime('2000-01-01')))
```
# Utilisation de la date et de l'heure natives pour les données temporelles GLV
Si vous utilisez une variante du langage Gremlin (GLV), vous devez utiliser les classes et fonctions de date et d'heure natives fournies par le langage de programmation pour les données temporelles Gremlin.
Les TinkerPop bibliothèques officielles sont toutes des bibliothèques de variantes de langage G705.
+ [Go](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go)
+ [Java](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java)
+ [JavaScript](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript)
+ [.NET](https://tinkerpop.apache.org/docs/current/reference/#gremlin-dotnet)
+ [Python](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python)
**Important**
Cette page s'applique uniquement aux bibliothèques GLV (G705 Language Variant). Si vous utilisez une méthode dans laquelle vous envoyez la requête Gremlin sous forme de chaîne de texte, vous devez utiliser la fonction datetime () de G705. Cela inclut la console G705, les chaînes de texte utilisant l'API HTTP REST ou la soumission directe de chaînes G705 via les pilotes.
**Go**
Voici un exemple partiel dans Go qui crée une propriété unique nommée « date » pour le sommet avec un ID de « 3 ». Il définit la valeur comme étant une date générée à l'aide de la fonction Go Time.now ().
```
import ( "time" )
g.V('3').property('date', time.Now()).next();
```
Pour un exemple complet de connexion à Neptune à l'aide de Go, voir [Utilisation d'un client Go pour se connecter à une instance de base de données Neptune](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-go.html).
**Java**
Voici un exemple partiel en Java qui crée une propriété unique nommée « `date` » pour le sommet avec l'ID « `3` ». Cet exemple définit la valeur sur une date générée à l'aide du constructeur `Date()` Java.
```
import java.util.date
g.V('3').property('date', new Date()).next();
```
Pour un exemple complet de connexion à Neptune à l'aide de Java, consultez. [Utilisation du client Java pour se connecter à une instance de base de données Neptune](access-graph-gremlin-java.md)
**Node.js (JavaScript)**
Voici un exemple partiel de création JavaScript d'une propriété unique nommée « `date` » pour le sommet avec un ID de « `3` ». Cet exemple définit la valeur sur une date générée à l'aide du constructeur `Date()` Node.js.
```
g.V('3').property('date', new Date()).next()
```
Pour un exemple complet de connexion à Neptune à l'aide de Node.js, consultez. [Utilisation de Node.js pour se connecter à une instance de base de données Neptune](access-graph-gremlin-node-js.md)
**.NET (C\$1)**
Voici un exemple partiel en C\$1 qui crée une propriété unique nommée « `date` » pour le sommet avec l'ID « `3` ». Cet exemple définit la valeur sur une date générée à l'aide de la propriété .NET `DateTime.UtcNow`.
```
Using System;
g.V('3').property('date', DateTime.UtcNow).next()
```
Pour un exemple complet de connexion à Neptune à l'aide de C\$1, consultez. [Utilisation de .NET pour se connecter à une instance de base de données Neptune](access-graph-gremlin-dotnet.md)
**Python**
Voici un exemple partiel en Python qui crée une propriété unique nommée « `date` » pour le sommet avec l'ID « `3` ». Cet exemple définit la valeur sur une date générée à l'aide de la méthode `datetime.now()` Python.
```
import datetime
g.V('3').property('date',datetime.datetime.now()).next()
```
Pour un exemple complet de connexion à Neptune à l'aide de Python, consultez. [Utilisation de Python pour se connecter à une instance de base de données Neptune](access-graph-gremlin-python.md)