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. # Prácticas recomendadas para utilizar Gremlin con Neptune Siga estas recomendaciones cuando utilice el lenguaje de recorrido de gráficos Gremlin con Neptune. Para obtener información sobre el uso de Gremlin con Neptune, consulte [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md). **importante** Se realizó un cambio en la TinkerPop versión 3.4.11 que mejora la corrección del procesamiento de las consultas, pero por el momento a veces puede afectar gravemente al rendimiento de las consultas. Por ejemplo, una consulta de este tipo podría ejecutarse de una forma mucho más lenta: ``` g.V().hasLabel('airport'). order(). by(out().count(),desc). limit(10). out() ``` Los vértices situados tras el paso límite ahora se obtienen de forma no óptima debido al cambio de la versión 3.4.11. TinkerPop Para evitarlo, puede modificar la consulta añadiendo el paso barrier() en cualquier punto después de `order().by()`. Por ejemplo: ``` g.V().hasLabel('airport'). order(). by(out().count(),desc). limit(10). barrier(). out() ``` TinkerPop [La versión 3.4.11 estaba habilitada en la versión 1.0.5.0 del motor de Neptune.](engine-releases-1.0.5.0.md) **Topics** + [Configuración de Heartbeat para Neptune Serverless](best-practices-gremlin-heartbeat-serverless.md) + [Estructure las consultas de actualización o inserción para aprovechar el motor DFE](#best-practices-gremlin-upserts) + [Pruebe el código de Gremlin en el contexto en el que lo va a implementar](best-practices-gremlin-console-glv-differences.md) + [Creación de escrituras de Gremlin eficientes de múltiples subprocesos](best-practices-gremlin-multithreaded-writes.md) + [Depuración de registros con la propiedad de hora de creación](best-practices-gremlin-prune.md) + [Uso del método `datetime( )` para datos de tiempo de Groovy](best-practices-gremlin-datetime.md) + [Uso de la fecha y hora nativas para los datos de tiempo de GLV](best-practices-gremlin-datetime-glv.md) # Configuración de Heartbeat para Neptune Serverless Al utilizar WebSocket clientes Gremlin con Neptune Serverless, debe configurar el intervalo de ping del cliente de forma adecuada para mantener conexiones estables durante los eventos de escalado. El cliente Gremlin utiliza WebSocket las conexiones y envía pings periódicos para comprobar que la conexión está activa. El cliente espera una respuesta del servidor dentro del intervalo de ping. Si el servidor no responde, el cliente cierra automáticamente la conexión. **Para las instancias **aprovisionadas** por Neptune, recomendamos establecer el intervalo de ping en 5 segundos.** Para los **clústeres Neptune Serverless**, recomendamos establecer el intervalo de ping en al menos **20 segundos** para adaptarse a posibles retrasos durante las operaciones de escalado. Este parámetro controla el tiempo que el cliente espera entre escrituras en el servidor antes de enviar un ping para comprobar que la conexión sigue activa. La configuración de este parámetro varía en función de la implementación del cliente: **Configuración del cliente Java** Para el cliente Java TinkerPop Gremlin, configure el `keepAliveInterval` parámetro: ``` Cluster.Builder builder = Cluster.build() .addContactPoint(endpoint) .keepAliveInterval(20000); // Configure ping interval in milliseconds ``` Para obtener más información sobre la configuración del controlador de Java, consulte la documentación de [Java TinkerPop ](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration). **Configuración del cliente Go** Para el cliente Gremlin Go, configure el `KeepAliveInterval` parámetro: ``` rc, err := driver.NewDriverRemoteConnection(endpoint, func(settings *driver.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = auth settings.KeepAliveInterval = 20 * time.Second // Configure ping interval ... }) ``` Para obtener más información sobre la configuración del controlador Go, consulte la documentación de [Go TinkerPop ](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go-configuration). **JavaScriptConfiguración del cliente de /Node.js** Para el cliente Gremlin de JavaScript /Node.js, configure el `pingInterval` parámetro: ``` const gremlin = require('gremlin'); const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection; const connection = new DriverRemoteConnection(endpoint, { traversalSource: 'g', pingInterval: 20000 // Configure ping interval in milliseconds }); ``` [Para obtener más información sobre la configuración JavaScript del controlador, consulte la JavaScript TinkerPop documentación.](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript-configuration) **Configuración del cliente Python** Para el cliente Python Gremlin, el intervalo de ping normalmente se gestiona en la capa de transporte. Consulte la documentación específica de implementación del transporte para ver las opciones de configuración: ``` 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)))) ``` Para obtener más información sobre la configuración del controlador de Python, consulte la [ TinkerPop documentación de Python](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python-configuration). Esta configuración garantiza que su cliente mantenga la estabilidad de la conexión durante los eventos de escalado de Neptune Serverless, lo que evita cierres de conexión innecesarios y mejora la confiabilidad de las aplicaciones. ## Estructure las consultas de actualización o inserción para aprovechar el motor DFE En [Realización de actualizaciones o inserciones eficientes con los pasos `mergeV()` y `mergeE()` de Gremlin](gremlin-efficient-upserts.md), se explica cómo estructurar las consultas de actualización o inserción para utilizar el motor DFE de la forma más eficaz posible. # Pruebe el código de Gremlin en el contexto en el que lo va a implementar En Gremlin, los clientes pueden enviar consultas al servidor de varias maneras: mediante Bytecode GLV o mediante WebSocket la consola Gremlin mediante scripts basados en cadenas. Es importante reconocer que la ejecución de las consultas de Gremlin puede variar según la forma en que se envíe la consulta. Una consulta que devuelve un resultado vacío puede considerarse correcta si se envía en el modo de Bytecode, pero puede considerarse que ha fallado si se envía en el modo de script. Por ejemplo, si incluyes una consulta `next()` en modo script, se envía al servidor, pero al usar el cliente, por lo general, `next()` se procesa por sí misma. ByteCode `next()` En el primer caso, la consulta falla si no se encuentra ningún resultado, pero en el segundo, la consulta se realiza correctamente independientemente de que el conjunto de resultados esté vacío o no. Si desarrolla y prueba su código en un solo contexto (por ejemplo, la consola de Gremlin, que normalmente envía consultas en forma de texto), pero luego implementa el código en un contexto diferente (por ejemplo, mediante el controlador de Java con Bytecode), podría tener problemas, ya que su código podría comportarse de manera diferente en producción que en su entorno de desarrollo. **importante** Asegúrese de probar el código de Gremlin en el contexto de GLV en el que se va a implementar para evitar resultados inesperados. # Creación de escrituras de Gremlin eficientes de múltiples subprocesos Hay algunas directrices para la carga con múltiples subprocesos de datos en Neptune mediante Gremlin. Si fuera posible, asigne a cada hilo un conjunto de vértices o bordes para su inserción o modificación que no colisionen. Por ejemplo, ID de direcciones de hilo 1, rango 1–50 000; ID de direcciones de hilo 2, rango 50 001–100 000, y así sucesivamente. Esto reduce el riesgo de alcanzar un `ConcurrentModificationException`. Para estar seguro, coloque un bloque `try/catch` alrededor de todas las escrituras. Si se produce cualquier error, puede volver a intentarlo después de un breve retraso. Las operaciones de escritura por lotes en un tamaño de lote entre 50 y 100 (vértices o bordes) generalmente funcionan bien. Si está agregando una gran cantidad de propiedades para cada vértice, un número cercano al 50 en lugar de 100 podría ser una elección más acertada. Merece la pena experimentar. Por lo tanto, para las escrituras por lotes, puede utilizar algo así como esto: ``` g.addV(‘test’).property(id,’1’).as(‘a’). addV(‘test’).property(id,’2’). addE(‘friend’).to(‘a’). ``` Esto se repite en cada operación por lotes. El uso de lotes es bastante más eficiente que la adición de un vértice o borde por cada viaje de ida y vuelta de Gremlin al servidor. Si está utilizando un cliente de la variante de lenguaje Gremlin (GLV), puede crear un lote mediante programación creando en primer lugar un recorrido. Añádala y, por último, realice una iteración sobre ella. Por ejemplo: ``` t.addV(‘test’).property(id,’1’).as(‘a’) t.addV(‘test’).property(id,’2’) t.addE(‘friend’).to(‘a’) t.iterate() ``` Si es posible, es mejor utilizar el cliente de la variante de lenguaje Gremlin. Sin embargo, puede hacer algo similar con un cliente que envía consultas como cadenas de texto concatenando cadenas para construir un lote. Si utiliza una de las bibliotecas de clientes Gremlin en lugar de HTTP básicos de las consultas, todos los subprocesos deberán compartir el mismo cliente, clúster o grupo de conexiones. Es posible que tenga que ajustar la configuración para obtener el mejor rendimiento posible; por ejemplo, puede que tenga que ajustar el tamaño del grupo de conexiones y el número de subprocesos de trabajo que utiliza el cliente de Gremlin. # Depuración de registros con la propiedad de hora de creación Puede depurar los registros viejos almacenando la hora de creación como una propiedad en los vértices y descartándolos periódicamente. Si necesita almacenar datos durante un periodo específico y, a continuación, eliminarlos del gráfico (tiempo de vida de vértice), puede almacenar una propiedad de marca temporal en la creación del vértice. A continuación, puede emitir periódicamente una consulta `drop()` para todos los vértices que se crearon antes de una hora determinada; por ejemplo: ``` g.V().has(“timestamp”, lt(datetime('2018-10-11'))) ``` # Uso del método `datetime( )` para datos de tiempo de Groovy Neptune proporciona el método `datetime` para especificar fechas y horas para las consultas enviadas en la variante **Groovy** de Gremlin. Esto incluye la consola de Gremlin, cadenas de texto que utilizan la API REST HTTP y cualquier otra serialización que utilice Groovy. **importante** Esto *solo* se aplica a aquellos casos en los que envíe la consulta de Gremlin como una *cadena de texto*. Si utiliza una variante del lenguaje Gremlin, debe usar las clases y funciones de fecha nativas para el lenguaje. Para obtener más información, consulte la siguiente sección, [Uso de la fecha y hora nativas para los datos de tiempo de GLV](best-practices-gremlin-datetime-glv.md). Empezando por TinkerPop `3.5.2` (introducido en la [versión 1.1.1.0 del motor Neptune](engine-releases-1.1.1.0.md)), `datetime` es una parte integral de. TinkerPop Puede utilizar el método `datetime` para almacenar y comparar fechas: ``` g.V('3').property('date',datetime('2001-02-08')) ``` ``` g.V().has('date',gt(datetime('2000-01-01'))) ``` # Uso de la fecha y hora nativas para los datos de tiempo de GLV Si utiliza una variante del lenguaje Gremlin (GLV), debe usar las clases y funciones de fecha y hora nativas que proporciona el lenguaje de programación para los datos de tiempo de Gremlin. Las TinkerPop bibliotecas oficiales son todas las bibliotecas de variantes del lenguaje Gremlin. + [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) **importante** Esta página solo se aplica a las bibliotecas de la variante de lenguaje Gremlin (GLV). Si utiliza un método en el que envía la consulta de Gremlin como cadena de texto, debe utilizar la función datetime() de Gremlin. Esto incluye la consola de Gremlin, las cadenas de texto que utilizan la API de REST de HTTP o el envío directo de cadenas de Gremlin a través de los controladores. **Go** A continuación, se muestra un ejemplo parcial en Go que crea una única propiedad llamada “date” para el vértice con un ID de “3”. Establece el valor como una fecha generada mediante la función time.Now() de Go. ``` import ( "time" ) g.V('3').property('date', time.Now()).next(); ``` Para ver un ejemplo completo de conexión a Neptune mediante Go, consulte [Uso de un cliente Go para conectarse a una instancia de base de datos de Neptune](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-go.html). **Java** A continuación se muestra un ejemplo parcial en Java que crea una única propiedad llamada "`date`" para el vértice con un ID de "`3`". Define el valor que será una fecha generada utilizando el constructor `Date()` de Java. ``` import java.util.date g.V('3').property('date', new Date()).next(); ``` Para ver un ejemplo completo de cómo conectarse a Neptune mediante Java, consulte [Uso de un cliente Java para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-java.md). **Node.js () JavaScript** El siguiente es un ejemplo parcial en el JavaScript que se crea una propiedad única llamada '`date`' para el vértice con un identificador de '`3`'. Define el valor que será una fecha generada utilizando el constructor `Date()` de Node.js. ``` g.V('3').property('date', new Date()).next() ``` Para ver un ejemplo completo de cómo conectarse a Neptune mediante Node.js, consulte [Uso de Node.js para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-node-js.md). **.NET (C\$1)** A continuación se muestra un ejemplo parcial en C\$1 que crea una única propiedad llamada "`date`" para el vértice con un ID de "`3`". Define el valor que será una fecha generada utilizando la propiedad `DateTime.UtcNow` de .NET. ``` Using System; g.V('3').property('date', DateTime.UtcNow).next() ``` Para ver un ejemplo completo de cómo conectarse a Neptune mediante C\$1, consulte [Uso de .NET para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-dotnet.md). **Python** A continuación se muestra un ejemplo parcial en Python que crea una única propiedad llamada "`date`" para el vértice con un ID de "`3`". Define el valor que será una fecha generada utilizando el método `datetime.now()` de Python. ``` import datetime g.V('3').property('date',datetime.datetime.now()).next() ``` Para ver un ejemplo completo de cómo conectarse a Neptune mediante Python, consulte [Uso de Python para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-python.md).