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.
# Consulta de un gráfico de Neptune
Neptune admite los siguientes lenguajes de consulta de gráficos para obtener acceso a un gráfico:
+ [Gremlin](https://tinkerpop.apache.org/gremlin.html), definido por [Apache TinkerPop](https://tinkerpop.apache.org/) para crear y consultar gráficos de propiedades.
En Gremlin, una consulta es un recorrido compuesto por pasos discretos, cada uno de los cuales sigue un borde hasta un nodo.
Consulte [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md) para obtener información sobre el uso de Gremlin en Neptune y [Conformidad con los estándares de Gremlin en Amazon Neptune](access-graph-gremlin-differences.md) para encontrar detalles específicos sobre la implementación de Gremlin en Neptune.
+ [openCypher](access-graph-opencypher.md) es un lenguaje de consulta declarativo para gráficos de propiedades que desarrolló originalmente Neo4j, luego de código abierto en 2015, y que contribuyó al proyecto [openCypher](http://www.opencypher.org/) en virtud de una licencia de código abierto Apache 2. Su sintaxis está documentada en la [especificación de OpenCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf).
+ [SPARQL](https://www.w3.org/TR/sparql11-overview/) es un lenguaje declarativo basado en la coincidencia de patrones de gráficos para consultar datos [RDF](https://www.w3.org/2001/sw/wiki/RDF). Cuenta con el apoyo del [World Wide Web Consortium](https://www.w3.org/).
Consulte [Acceso al gráfico de Neptune con SPARQL](access-graph-sparql.md) para obtener información sobre el uso de SPARQL en Neptune y [Conformidad con los estándares de SPARQL en Amazon Neptune](feature-sparql-compliance.md) para encontrar detalles específicos sobre la implementación de SPARQL en Neptune.
**nota**
Tanto Gremlin como openCypher se pueden usar para consultar cualquier dato de gráfico de propiedades almacenado en Neptune, independientemente de cómo se haya cargado.
**Topics**
+ [Colas de consultas en Amazon Neptune](access-graph-queuing.md)
+ [Memoria caché de planes de consultas en Amazon Neptune](access-graph-qpc.md)
+ [Inserte un identificador personalizado en una consulta de Neptune Gremlin o SPARQL](features-query-id.md)
+ [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md)
+ [Acceso al gráfico de Neptune con openCypher](access-graph-opencypher.md)
+ [Acceso al gráfico de Neptune con SPARQL](access-graph-sparql.md)
# Colas de consultas en Amazon Neptune
Al desarrollar y ajustar aplicaciones gráficas, puede ser útil conocer las implicaciones de cómo la base de datos está colocando en cola las consultas. En Amazon Neptune, la cola de consultas se produce de la siguiente manera:
+ El número máximo de consultas que se pueden colocar en cola por instancia, con independencia del tamaño de instancia, es 8.192. Cualquier consulta superior a este número se rechaza y se genera un error con una `ThrottlingException`.
+ El número máximo de consultas que se pueden ejecutar a la vez viene determinado por el número de subprocesos de trabajo asignados, que generalmente se establece en el doble del número de núcleos de CPU virtuales (vCPUs) disponibles.
+ La latencia de consulta incluye el tiempo que una consulta pasa en la cola, así como los viajes de ida y vuelta a la red y el tiempo que realmente tarda en ejecutarse.
## Determinación del número de consultas en la cola en un momento dado
La `MainRequestQueuePendingRequests` CloudWatch métrica registra el número de solicitudes en espera en la cola de entrada con una granularidad de cinco minutos (consulte). [Métricas de Neptune CloudWatch](cw-metrics.md)
Para Gremlin, puede obtener un recuento actual de consultas en la cola utilizando el valor `acceptedQueryCount` devuelto por el [API del estado de la consulta de Gremlin](gremlin-api-status.md). Tenga en cuenta, sin embargo, que el valor `acceptedQueryCount` devuelto por el [API de estado de la consulta SPARQL](sparql-api-status.md) incluye todas las consultas aceptadas desde que se inició el servidor, incluidas las consultas completadas.
## Cómo puede afectar a los tiempos de espera la cola de consultas
Como se señaló anteriormente, la latencia de consulta incluye el tiempo que pasa una consulta en la cola, así como el tiempo que tarda en ejecutarse.
Dado que el período de tiempo de espera de una consulta generalmente se mide a partir del momento en que entra en la cola, una cola con movimiento lento puede hacer que muchas consultas agoten el tiempo de espera en cuanto se eliminan de la cola. Obviamente, esto no es deseable, por lo que es bueno evitar poner en cola un gran número de consultas a menos que se puedan ejecutar rápidamente.
# Memoria caché de planes de consultas en Amazon Neptune
Cuando se envía una consulta a Neptune, la cadena de consulta se analiza, optimiza y transforma en un plan de consulta que, después, el motor ejecuta. Las aplicaciones suelen estar respaldadas por patrones de consulta comunes para los que se crean instancias con diferentes valores. La caché de planes de consultas puede reducir la latencia general al almacenar en caché los planes de consulta y, por lo tanto, evitar el análisis y la optimización de dichos patrones repetidos.
La memoria caché del plan de consultas se puede utilizar para **OpenCypher**consultas, tanto no parametrizadas como parametrizadas. Está habilitada para READ, HTTP y Bolt. **No** es compatible con consultas de mutación de OC. **No** es compatible con consultas de Gremlin o SPARQL.
## Cómo forzar la habilitación o deshabilitación de la caché de planes de consultas
La caché de planes de consultas está habilitada de forma predeterminada para consultas parametrizadas de baja latencia. El plan de una consulta parametrizada se almacena en caché solo cuando la latencia es inferior al umbral de **100 ms**. La sugerencia de consulta `QUERY:PLANCACHE` en el ámbito de la consulta permite anular este comportamiento en cada consulta (parametrizada o no). Debe usarse con la cláusula `USING`. La sugerencia de consulta acepta como valor `enabled` o `disabled`.
```
# 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"
```
## Cómo determinar si un plan está almacenado en caché o no
En el caso de HTTP READ, si la consulta se ha enviado y el plan se ha almacenado en caché, `explain` mostraría detalles relevantes sobre la caché de planes de consultas.
```
% 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).
```
Cuando se utiliza Bolt, no se admite la característica explain.
## Expulsión
Un plan de consultas se expulsa por el tiempo de vida (TTL) de la caché o cuando se alcanza el número máximo de planes de consulta almacenados en caché. Cuando se alcanza el plan de consultas, se actualiza el TTL. Los valores predeterminados son:
+ 1000: el número máximo de planes que se pueden almacenar en caché por instancia.
+ TTL: 300 000 milisegundos o 5 minutos. El acierto de la caché reinicia el TTL y lo restablece a 5 minutos.
## Condiciones que impiden que el plan se almacene en caché
La caché de planes de consultas no se utilizará en las siguientes condiciones:
1. Cuando se envía una consulta con la sugerencia de consulta `QUERY:PLANCACHE "disabled"`. Puede volver a ejecutar la consulta y eliminar `QUERY:PLANCACHE "disabled"` para habilitar la caché de planes de consultas.
1. Si la consulta enviada no es una consulta parametrizada y no contiene la sugerencia `QUERY:PLANCACHE "enabled"`.
1. Si el tiempo de evaluación de la consulta es superior al umbral de latencia, la consulta no se almacena en caché y se considera una consulta de larga duración que no se beneficiará de la caché de planes de consultas.
1. Si la consulta contiene un patrón que no devuelve ningún resultado.
+ Por ejemplo, `MATCH (n:nonexistentLabel) return n` cuando no hay nodos con la etiqueta especificada.
+ Por ejemplo, `MATCH (n {name: $param}) return n` con `parameters={"param": "abcde"}` cuando no hay nodos que contengan `name=abcde`.
1. Si el parámetro de consulta es de tipo compuesto, como `list` o `map`.
```
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 el parámetro de consulta es una cadena que no ha formado parte de una operación de carga o inserción de datos. Por ejemplo, si se ejecuta `CREATE (n {name: "X"})` para insertar `"X"`, entonces `RETURN "X"` se almacena en caché, mientras que `RETURN "Y"` no se almacenará en caché, ya que `"Y"` no se ha insertado y no existe en la base de datos.
# Inserte un identificador personalizado en una consulta de Neptune Gremlin o SPARQL
De forma predeterminada, Neptune asigna un valor `queryId` único a cada consulta. Puede utilizar este ID para obtener información sobre una consulta en ejecución (consulte [API del estado de la consulta de Gremlin](gremlin-api-status.md) o [API de estado de la consulta SPARQL](sparql-api-status.md)) o cancelarla (consulte [Cancelación de consultas de Gremlin](gremlin-api-status-cancel.md) o [Cancelación de consultas SPARQL](sparql-api-status-cancel.md)).
Neptune también le permite especificar su propio valor `queryId` para una consulta de Gremlin o SPARQL, ya sea en el encabezado HTTP o para una consulta SPARQL mediante la sugerencia de la consulta `queryId`. La asignación de su propio `queryID` facilita la realización de un seguimiento de una consulta para obtener el estado o cancelarlo.
## Inserción de un valor `queryId` personalizado mediante el encabezado HTTP
Tanto para Gremlin como para SPARQL, el encabezado HTTP se puede utilizar para insertar su propio valor `queryId` en una consulta.
**Ejemplo de Gremlin**
```
curl -XPOST https://your-neptune-endpoint:port \
-d "{\"gremlin\": \
\"g.V().limit(1).count()\" , \
\"queryId\":\"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" }"
```
**Ejemplo de SPARQL**
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=SELECT * WHERE { ?s ?p ?o } " \
--data-urlencode \
"queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
## Inserción de un valor `queryId` personalizado mediante una sugerencia de consulta SPARQL
A continuación se muestra un ejemplo de cómo utilizaría la sugerencia de la consulta `queryId` SPARQL para insertar un valor `queryId` personalizado en una consulta 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}}"
```
## Uso del valor `queryId` para comprobar el estado de la consulta
**Ejemplo de Gremlin**
```
curl https://your-neptune-endpoint:port/gremlin/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
**Ejemplo de SPARQL**
```
curl https://your-neptune-endpoint:port/sparql/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
# Acceso al gráfico de Neptune con Gremlin
Amazon Neptune es compatible con Apache TinkerPop y Gremlin. Esto significa que puede conectarse a una instancia de base de datos de Neptune y utilizar el lenguaje transversal Gremlin para consultar el gráfico (consulte The Graph en [la](https://tinkerpop.apache.org/docs/current/reference/#graph) documentación de Apache). TinkerPop Para conocer las diferencias en la implementación de Gremlin, consulte [Conformidad con los estándares de Gremlin](access-graph-gremlin-differences.md).
Un *recorrido* en Gremlin es una serie de pasos encadenados. Comienza en un vértice (o borde). Recorre el gráfico siguiendo el borde de salida de cada vértice y, después, los bordes resultantes de todos ellos. Cada paso es una operación del recorrido. Para obtener más información, consulte [The Traversal en la documentación](https://tinkerpop.apache.org/docs/current/reference/#traversal). TinkerPop
Las diferentes versiones del motor de Neptune admiten diferentes versiones de Gremlin. Consulte la [página de versiones del motor](engine-releases.md) de la versión de Neptuno que esté utilizando para determinar qué versión de Gremlin admite o consulte la siguiente tabla, que enumera las versiones anteriores y más recientes TinkerPop compatibles con las diferentes versiones del motor de Neptuno:
| Versión del motor de Neptune | Versión mínima TinkerPop | TinkerPop Versión máxima |
| --- | --- | --- |
| `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 Los clientes suelen ser compatibles con versiones anteriores dentro de una serie (`3.6.x`por ejemplo, o`3.7.x`) y, si bien suelen funcionar más allá de esos límites, en la tabla anterior se recomiendan las combinaciones de versiones que se deben utilizar para obtener la mejor experiencia y compatibilidad posibles. A menos que se indique lo contrario, generalmente es mejor seguir estas pautas y actualizar las aplicaciones cliente para que coincidan con la versión TinkerPop que esté utilizando.
Al actualizar TinkerPop las versiones, siempre es importante consultar la [documentación TinkerPop de actualización](http://tinkerpop.apache.org/docs/current/upgrade/), que le ayudará a identificar las nuevas funciones que puede aprovechar, pero también los problemas que quizás deba tener en cuenta a medida que se acerca la actualización. Lo normal es que las consultas y funciones existentes funcionen después de la actualización, a menos que se indique algo en particular como cuestión a tener en cuenta. Por último, es importante tener en cuenta que si una versión que actualice para incluir una nueva función, es posible que no pueda utilizarla si es de una versión posterior a la que admite Neptune.
Existen variantes del lenguaje Gremlin y compatibilidad con el acceso a Gremlin en varios lenguajes de programación. Para obtener más información, consulte [Sobre las variantes del lenguaje Gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) en la documentación. TinkerPop
Esta documentación describe cómo acceder a Neptune con las siguientes variantes y lenguajes de programación:
+ [Configure la consola de Gremlin para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-console.md)
+ [Uso del punto de conexión HTTP REST para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-rest.md)
+ [Clientes Gremlin basados en Java que se utilizan con Amazon Neptune](access-graph-gremlin-client.md)
+ [Uso de Python para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-python.md)
+ [Uso de .NET para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-dotnet.md)
+ [Uso de Node.js para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-node-js.md)
+ [Uso de Go para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-go.md)
Como se explica en[Cifrado de conexiones a la base de datos de Amazon Neptune con SSL/HTTPS](security-ssl.md), debe utilizar la capa de Security/Secure sockets de capa de transporte (TLS/SSL) cuando se conecte a Neptune en todas las regiones. AWS
Antes de comenzar, debe disponer de lo siguiente:
+ Una instancia de base de datos de Neptune. Para obtener información acerca de la creación de una instancia de base de datos de Neptune, consulte [Creación de un clúster de Amazon Neptune](get-started-create-cluster.md).
+ Una instancia de Amazon EC2 en la misma nube privada virtual (VPC) que su instancia de base de datos de Neptune.
Para obtener más información acerca de cómo cargar datos en Neptune, incluidos los requisitos previos, los formatos de carga y los parámetros de carga, consulte [Carga de datos en Amazon Neptune](load-data.md).
**Topics**
+ [Configure la consola de Gremlin para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-console.md)
+ [Uso del punto de conexión HTTP REST para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-rest.md)
+ [Clientes Gremlin basados en Java que se utilizan con Amazon Neptune](access-graph-gremlin-client.md)
+ [Uso de Python para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-python.md)
+ [Uso de .NET para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-dotnet.md)
+ [Uso de Node.js para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-node-js.md)
+ [Uso de Go para conectarse a una instancia de base de datos de Neptune](access-graph-gremlin-go.md)
+ [Uso del AWS SDK para ejecutar consultas de Gremlin](access-graph-gremlin-sdk.md)
+ [Sugerencias de consulta de Gremlin](gremlin-query-hints.md)
+ [API del estado de la consulta de Gremlin](gremlin-api-status.md)
+ [Cancelación de consultas de Gremlin](gremlin-api-status-cancel.md)
+ [Compatibilidad con sesiones basadas en scripts de Gremlin](access-graph-gremlin-sessions.md)
+ [Transacciones de Gremlin en Neptune](access-graph-gremlin-transactions.md)
+ [Uso de la API de Gremlin con Amazon Neptune](gremlin-api-reference.md)
+ [Almacenamiento en caché de los resultados de las consultas en Gremlin de Amazon Neptune](gremlin-results-cache.md)
+ [Realización de actualizaciones o inserciones eficientes con los pasos `mergeV()` y `mergeE()` de Gremlin](gremlin-efficient-upserts.md)
+ [Realización de actualizaciones o inserciones de Gremlin eficientes con `fold()/coalesce()/unfold()`](gremlin-efficient-upserts-pre-3.6.md)
+ [Análisis de la ejecución de las consultas de Neptune con `explain` de Gremlin](gremlin-explain.md)
+ [Uso de Gremlin con el motor de consultas DFE de Neptune](gremlin-with-dfe.md)
# Configure la consola de Gremlin para conectarse a una instancia de base de datos de Neptune
La consola Gremlin le permite experimentar con TinkerPop gráficos y consultas en un entorno REPL (bucle). read-eval-print
## Instalación de la consola de Gremlin y conexión a ella de la forma habitual
Puede utilizar dicha consola para conectarse a una base de datos de gráficos remota. En la siguiente sección, se explica la instalación y la configuración de la consola de Gremlin para conectarse a una instancia de base de datos de Neptune de forma remota. Siga estas instrucciones desde una instancia de Amazon EC2 que esté en la misma nube privada virtual (VPC) que su instancia de base de datos de Neptune.
Para obtener ayuda para conectarse a Neptune con SSL/TLS (obligatorio), consulte. [Configuración de SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)
**nota**
Si tiene [habilitada la autenticación de IAM](iam-auth-enable.md) en su clúster de base de datos de Neptune, siga en [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con la consola de Gremlin](iam-auth-connecting-gremlin-console.md) las instrucciones para instalar la consola de Gremlin en lugar de las instrucciones que aparecen aquí.
**Para instalar la consola de Gremlin y conectarse a Neptune**
1. Los archivos binarios de la consola de Gremlin requieren Java 8 o Java 11. En estas instrucciones se presupone el uso de Java 11. Puede instalar Java 11 en su instancia de EC2 de la siguiente manera:
+ Si utilizas [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Si utilizas [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
```
+ Para otras distribuciones, utilice la que sea adecuada de las siguientes opciones:
```
sudo yum install java-11-openjdk-devel
```
o bien:
```
sudo apt-get install openjdk-11-jdk
```
1. Escriba lo siguiente para establecer Java 11 como tiempo de ejecución predeterminado en la instancia EC2.
```
sudo /usr/sbin/alternatives --config java
```
Cuando se le solicite, escriba el número para Java 11.
1. Descargue la versión adecuada de la consola Gremlin del sitio web de Apache. Puedes comprobar [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md) qué versión de Gremlin es compatible con tu versión de Neptune. Por ejemplo, si necesita la versión 3.7.2, puede descargar la [consola Gremlin](https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip) del sitio web de [Apache Tinkerpop](https://tinkerpop.apache.org/download.html) a su instancia EC2 de la siguiente manera:
```
wget https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Descomprima el archivo .zip de la consola de Gremlin.
```
unzip apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Cambie al directorio del directorio descomprimido.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. En el subdirectorio `conf` del directorio extraído, cree un archivo llamado `neptune-remote.yaml` con el texto siguiente. *your-neptune-endpoint*Sustitúyalo por el nombre de host o la dirección IP de la instancia de base de datos de Neptune. Los corchetes (`[ ]`) son obligatorios.
**nota**
Para obtener información acerca de cómo encontrar el nombre de host de la instancia de base de datos de Neptune, consulte la sección [Conexión a los puntos de conexión de Amazon Neptune](feature-overview-endpoints.md).
```
hosts: [your-neptune-endpoint]
port: 8182
connectionPool: { enableSsl: true }
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1,
config: { serializeResultToString: true }}
```
**nota**
Los serializadores se trasladaron del módulo `gremlin-driver` al nuevo módulo `gremlin-util` de la versión 3.7.0. El paquete cambió de org.apache.tinkerpop.gremlin.driver.ser a org.apache.tinkerpop.gremlin.util.ser.
1. En un terminal, vaya al directorio de la consola de Gremlin (`apache-tinkerpop-gremlin-console-3.7.2`) y, a continuación, escriba el siguiente comando para ejecutarla.
```
bin/gremlin.sh
```
Debería ver los siguientes datos de salida:
```
\,,,/
(o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin>
```
Ahora se encuentra en `gremlin>`. Escriba los pasos restantes en este punto.
1. En el símbolo del sistema `gremlin>`, escriba lo siguiente para conectarse a la instancia de base de datos de Neptune.
```
:remote connect tinkerpop.server conf/neptune-remote.yaml
```
1. En la entrada `gremlin>`, escriba lo siguiente para cambiar al modo remoto. Esto envía todas las consultas de Gremlin a la conexión remota.
```
:remote console
```
1. Escriba lo siguiente para enviar una consulta al gráfico de Gremlin.
```
g.V().limit(1)
```
1. Cuando haya terminado, escriba lo siguiente para salir de la consola de Gremlin.
```
:exit
```
**nota**
Utilice punto y coma (`;`) o un carácter de nueva línea (`\n`) para separar las instrucciones.
Cada recorrido anterior al final debe terminar en `next()` para ejecutarse. Solo se devuelven los datos del recorrido final.
Para obtener más información sobre la implementación de Gremlin en Neptune, consulte [Conformidad con los estándares de Gremlin en Amazon Neptune](access-graph-gremlin-differences.md).
# Una forma alternativa de conectarse a la consola de Gremlin
**Inconvenientes del enfoque de conexión normal**
La forma más común de conectarse a la consola de Gremlin es la que hemos explicado anteriormente, utilizando comandos como estos en el símbolo del sistema de `gremlin>`:
```
gremlin> :remote connect tinkerpop.server conf/(file name).yaml
gremlin> :remote console
```
Esto funciona bien y permite enviar consultas a Neptune. Sin embargo, saca del bucle al motor de scripts Groovy, por lo que Neptune trata todas las consultas como puras de Gremlin. Esto significa que los siguientes formularios de consulta fallan:
```
gremlin> 1 + 1
gremlin> x = g.V().count()
```
Lo más parecido a utilizar una variable cuando se está conectado de esta forma es utilizar la variable `result` que mantiene la consola y enviar la consulta utilizando `:>`, de esta forma:
```
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]
```
**Una forma diferente de conectarse**
También puede conectarse a la consola de Gremlin de una forma diferente, que tal vez le parezca más agradable, como esta:
```
gremlin> g = traversal().withRemote('conf/neptune.properties')
```
Aquí `neptune.properties` toma esta forma:
```
gremlin.remote.remoteConnectionClass=org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection
gremlin.remote.driver.clusterFile=conf/my-cluster.yaml
gremlin.remote.driver.sourceName=g
```
El archivo `my-cluster.yaml` debería ser similar a esto:
```
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 }
```
**nota**
Los serializadores se trasladaron del módulo `gremlin-driver` al nuevo módulo `gremlin-util` de la versión 3.7.0. El paquete cambió de org.apache.tinkerpop.gremlin.driver.ser a org.apache.tinkerpop.gremlin.util.ser.
Configurar la conexión de la consola de Gremlin de esta manera le permite realizar correctamente los siguientes tipos de consultas:
```
gremlin> 1+1
==>2
gremlin> x=g.V().count().next()
==>4249
gremlin> println("The answer was ${x}")
The answer was 4249
```
Puede evitar que se muestre el resultado, de esta manera:
```
gremlin> x=g.V().count().next();[]
gremlin> println(x)
4249
```
Todas las formas habituales de realizar consultas (sin el paso del terminal) siguen funcionando. Por ejemplo:
```
gremlin> g.V().count()
==>4249
```
Incluso puede usar el paso [https://tinkerpop.apache.org/docs/current/reference/#io-step](https://tinkerpop.apache.org/docs/current/reference/#io-step) para cargar un archivo con este tipo de conexión.
## Autenticación de IAM
Neptune admite la [autenticación de IAM](iam-auth-enable.md) para controlar el acceso a su clúster de base de datos. Si tiene habilitada la autenticación de IAM, debe utilizar la firma de la versión 4 de Signature para autenticar sus solicitudes. Para obtener instrucciones detalladas y ejemplos de código para conectarse desde la consola de Gremlin, consulte. [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con la consola de Gremlin](iam-auth-connecting-gremlin-console.md)
# Uso del punto de conexión HTTP REST para conectarse a una instancia de base de datos de Neptune
Amazon Neptune proporciona un punto de conexión HTTP para las consultas de Gremlin. La interfaz REST es compatible con cualquier versión de Gremlin que utilice su clúster de base de datos (consulte la [página de versiones del motor](engine-releases.md) de Neptune que esté utilizando para determinar qué versión de Gremlin admite).
**nota**
Como se explica en [Cifrado de conexiones a la base de datos de Amazon Neptune con SSL/HTTPS](security-ssl.md), Neptune ahora requiere que se conecte mediante HTTPS en lugar de HTTP. Además, Neptune no admite actualmente HTTP/2 para las solicitudes de la API REST. Los clientes deben usar HTTP/1.1 al conectarse a los puntos finales.
Las siguientes instrucciones le ayudarán a conectar con el punto de enlace de Gremlin mediante el comando `curl` y HTTPS. Siga estas instrucciones desde una instancia de Amazon EC2 que esté en la misma nube privada virtual (VPC) que su instancia de base de datos de Neptune.
El punto de conexión HTTPS para las consultas de Gremlin a una instancia de base de datos de Neptune es `https://your-neptune-endpoint:port/gremlin`.
**nota**
Para obtener información acerca de cómo encontrar el nombre de host de la instancia de base de datos de Neptune, consulte [Conexión a los puntos de conexión de Amazon Neptune](feature-overview-endpoints.md).
## Para conectarse a Neptune mediante el punto de conexión HTTP REST
En el siguiente ejemplo se utiliza **curl** para enviar una consulta de Gremlin a través de HTTP **POST**. La consulta se envía en formato JSON en el cuerpo de la publicación como propiedad `gremlin`.
```
curl -X POST -d '{"gremlin":"g.V().limit(1)"}' https://your-neptune-endpoint:port/gremlin
```
Este ejemplo devuelve el primer vértice del gráfico utilizando el recorrido `g.V().limit(1)`. Puede consultar otra cosa sustituyéndolo por otro recorrido de Gremlin.
**importante**
De manera predeterminada, el punto de conexión REST devuelve todos los resultados en un único conjunto de resultados JSON. Si este conjunto de resultados es demasiado grande, se puede producir una excepción `OutOfMemoryError` en la instancia de base de datos de Neptune.
Para evitarlo, habilite las respuestas fragmentadas (los resultados se devuelven en una serie de respuestas independientes). Consulte [Use encabezados finales HTTP opcionales para habilitar las respuestas de Gremlin compuestas por varias partes](access-graph-gremlin-rest-trailing-headers.md).
Aunque se recomiendan las solicitudes HTTP **POST** para enviar consultas de Gremlin, también es posible utilizar solicitudes HTTP **GET**:
```
curl -G "https://your-neptune-endpoint:port?gremlin=g.V().count()"
```
**nota**
Neptune no admite la propiedad `bindings`.
# Use encabezados finales HTTP opcionales para habilitar las respuestas de Gremlin compuestas por varias partes
De forma predeterminada, la respuesta HTTP a las consultas de Gremlin se devuelve en un único conjunto de resultados JSON. En el caso de un conjunto de resultados muy grande, esto puede provocar una excepción `OutOfMemoryError` en la instancia de base de datos.
Sin embargo, puede habilitar las respuestas *fragmentadas* (respuestas que se devuelven en varias partes separadas). Para ello, incluya un encabezado final (`te: trailers`) con codificación de transferencia (TE) en su solicitud. Consulte [la página de MDN sobre los encabezados de las solicitudes TE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE) para obtener más información sobre los encabezados TE.
Cuando se devuelve una respuesta en varias partes, puede resultar difícil diagnosticar un problema que se produce después de recibir la primera parte, ya que la primera parte llega con un código de estado HTTP de `200` (OK). Un error posterior suele provocar que el cuerpo del mensaje contenga una respuesta dañada, al final de la cual Neptune añade un mensaje de error.
Para facilitar la detección y el diagnóstico de este tipo de errores, Neptune también incluye dos nuevos campos de encabezado dentro de los encabezados finales de cada fragmento de respuesta:
+ `X-Neptune-Status`: contiene el código de respuesta seguido de un nombre abreviado. Por ejemplo, en caso de que se realizara correctamente, el encabezado final sería: `X-Neptune-Status: 200 OK`. En caso de fallo, el código de respuesta sería uno de los [códigos de error del motor de Neptune](errors-engine-codes.md), como `X-Neptune-Status: 500 TimeLimitExceededException`.
+ `X-Neptune-Detail`: está vacío si las solicitudes se han realizado correctamente. En caso de errores, contiene el mensaje de error JSON. Como solo se permiten caracteres ASCII en los valores de los encabezados HTTP, la cadena JSON está codificada en URL.
**nota**
Neptune no admite actualmente la compresión `gzip` de respuestas fragmentadas. Si el cliente solicita codificación y compresión fragmentadas al mismo tiempo, Neptune omite la compresión.
# Clientes Gremlin basados en Java que se utilizan con Amazon Neptune
[Puede usar cualquiera de los dos clientes Gremlin de código abierto basados en Java con Amazon Neptune: el cliente [Apache TinkerPop Java Gremlin o el cliente Gremlin](https://search.maven.org/artifact/org.apache.tinkerpop/gremlin-driver) para Amazon Neptune.](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client)
## El cliente Apache Java Gremlin TinkerPop
El [controlador gremlin Apache TinkerPop Java es el cliente estándar y oficial de](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java) Gremlin que funciona con cualquier base de datos de gráficos habilitada. TinkerPop Utilice este cliente cuando necesite la máxima compatibilidad con un espacio de TinkerPop desarrollo más amplio, cuando trabaje con varios sistemas de bases de datos de gráficos o cuando no necesite las funciones avanzadas de administración de clústeres y equilibrio de carga específicas de Neptune. Este cliente también es adecuado para aplicaciones sencillas que se conectan a una sola instancia de Neptune o cuando prefiere gestionar el equilibrio de carga a nivel de infraestructura en lugar de hacerlo dentro del cliente.
**importante**
La elección de la versión correcta del controlador Apache TinkerPop Gremlin es fundamental para la compatibilidad con la versión del motor Neptune. El uso de una versión incompatible puede provocar fallos de conexión o un comportamiento inesperado. Para obtener información detallada sobre la compatibilidad de versiones, consulte[Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md).
**nota**
La tabla que le ayuda a determinar la TinkerPop versión correcta de Apache para usar con Neptune se ha trasladado a. [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md) Esta tabla estuvo ubicada anteriormente en esta página durante muchos años y ahora está más centralizada como referencia para todos los lenguajes de programación TinkerPop compatibles.
## Cliente Java de Gremlin para Amazon Neptune
El cliente Gremlin para Amazon Neptune es [un cliente Gremlin de código abierto basado en Java que sustituye directamente](https://github.com/aws/neptune-gremlin-client) al cliente Java estándar. TinkerPop
El cliente de Gremlin para Neptune está optimizado para los clústeres de Neptune. Le permite administrar la distribución del tráfico entre varias instancias de un clúster y se adapta a los cambios en la topología del clúster al añadir o eliminar una réplica. Incluso puede configurar el cliente para que distribuya las solicitudes entre un subconjunto de instancias del clúster, en función del rol, el tipo de instancia, la zona de disponibilidad (AZ) o las etiquetas asociadas a las instancias.
La [versión más reciente del cliente Java de Gremlin para Neptune](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client) está disponible en Maven Central.
Para obtener más información acerca del cliente Java de Gremlin para Neptune, consulte esta [publicación del blog](https://aws.amazon.com/blogs/database/load-balance-graph-queries-using-the-amazon-neptune-gremlin-client/). [Para ver ejemplos de código y demostraciones, consulte el proyecto del cliente. GitHub ](https://github.com/aws/neptune-gremlin-client)
Al elegir la versión del cliente Neptune Gremlin, debe tener en cuenta la TinkerPop versión subyacente en relación con la versión del motor Neptune. Consulte la tabla de compatibilidad en [Acceso al gráfico de Neptune con Gremlin](access-graph-gremlin.md) para determinar la TinkerPop versión correcta para su motor Neptuno y, a continuación, utilice la siguiente tabla para seleccionar la versión de cliente Neptune Gremlin adecuada:
**Compatibilidad de las versiones del cliente Neptune Gremlin**
| Versión del cliente Neptune Gremlin | TinkerPop versión |
| --- | --- |
| 3.x | 3.7.x (AWS SDK para Java 2.x/1.x) |
| 2.1.x | 3.7.x (AWS SDK para Java 1.x) |
| 2.0.x | 3.6.x |
| 1.12 | 3.5.x |
# Uso de un cliente Java para conectarse a una instancia de base de datos de Neptune
En la siguiente sección, se explica cómo ejecutar un ejemplo completo de Java que se conecta a una instancia de base de datos de Neptune y realiza un recorrido por Gremlin mediante el cliente Apache Gremlin. TinkerPop
Siga estas instrucciones desde una instancia de Amazon EC2 que esté en la misma nube privada virtual (VPC) que su instancia de base de datos de Neptune.
**Para conectarse a Neptune mediante Java**
1. Instale Apache Maven en la instancia EC2. Si utiliza Amazon Linux 2023 (preferido), utilice:
```
sudo dnf update -y
sudo dnf install maven -y
```
Si utiliza Amazon Linux 2, descargue el archivo binario más reciente desde [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. **Instale Java.** Las bibliotecas de Gremlin necesitan Java 8 u 11. Puede instalar Java 11 como se indica a continuación:
+ Si utilizas [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Si utilizas [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
```
+ Para otras distribuciones, utilice la que sea adecuada de las siguientes opciones:
```
sudo yum install java-11-openjdk-devel
```
o bien:
```
sudo apt-get install openjdk-11-jdk
```
1. **Defina Java 11 como tiempo de ejecución predeterminado en su instancia EC2:** introduzca lo siguiente para establecer Java 8 como tiempo de ejecución predeterminado en su instancia EC2:
```
sudo /usr/sbin/alternatives --config java
```
Cuando se le solicite, escriba el número para Java 11.
1. **Cree un nuevo directorio llamado `gremlinjava`:**
```
mkdir gremlinjava
cd gremlinjava
```
1. En el directorio `gremlinjava`, cree un archivo `pom.xml` y, a continuación, ábralo en un editor de texto:
```
nano pom.xml
```
1. Copie lo siguiente en el archivo `pom.xml` y guárdelo:
```
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
```
**nota**
Si está modificando un proyecto de Maven ya existente, la dependencia requerida aparece resaltada en el código anterior.
1. Escriba lo siguiente en la línea de comandos a fin de crear subdirectorios para el código fuente de ejemplo (`src/main/java/com/amazonaws/`):
```
mkdir -p src/main/java/com/amazonaws/
```
1. En el directorio `src/main/java/com/amazonaws/`, cree un archivo llamado `App.java` y, a continuación, ábralo en un editor de texto.
```
nano src/main/java/com/amazonaws/App.java
```
1. Copie lo siguiente en el archivo `App.java`. *your-neptune-endpoint*Sustitúyala por la dirección de la instancia de base de datos de Neptune. *No* incluya el prefijo `https://` en el método `addContactPoint`.
**nota**
Para obtener información acerca de cómo encontrar el nombre de host de la instancia de base de datos de Neptune, consulte [Conexión a los puntos de conexión de 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();
}
}
```
Para obtener ayuda para conectarse a Neptune con SSL/TLS (obligatorio), consulte. [Configuración de SSL/TLS](#access-graph-gremlin-java-ssl)
1. Compile y ejecute el ejemplo usando el siguiente comando Maven:
```
mvn compile exec:exec
```
El ejemplo anterior devuelve un mapa de las claves y los valores de cada propiedad para los dos primeros índices del gráfico utilizando el recorrido `g.V().limit(3).elementMap()`. Para otras consultas, sustitúyalo por otro recorrido de Gremlin con uno de los métodos de finalización adecuados.
**nota**
La parte final de la consulta de Gremlin, `.toList()`, es necesaria para enviar el recorrido al servidor para su evaluación. Si no incluye ese método u otro equivalente, la consulta no se envía a la instancia de base de datos de Neptune.
También debe añadir una terminación adecuada al añadir un vértice o borde, como cuando utiliza el paso `addV( )`.
Los siguientes métodos envían la consulta a la instancia de base de datos de Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Configuración de SSL/TLS para el cliente Java de Gremlin
Neptune debe estar activado SSL/TLS de forma predeterminada. Normalmente, si el controlador Java está configurado con `enableSsl(true)`, se puede conectar a Neptune sin tener que configurar un `trustStore()` o `keyStore()` con una copia local de un certificado.
Sin embargo, si la instancia con la que se está conectando no tiene una conexión a Internet a través de la cual verificar un certificado público, o si el certificado que está usando no es público, puede seguir estos pasos para configurar una copia del certificado local:
**Configuración de una copia del certificado local para habilitar SSL/TLS**
1. Descargue e instale [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) de Oracle. Esto facilitará mucho la configuración del almacén de claves local.
1. Descargue el certificado `SFSRootCAG2.pem`CA (el SDK de Java de Gremlin necesita un certificado para verificar el certificado remoto):
```
wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
```
1. Cree un almacén de claves en formato JKS o PKCS12 en formato. En este ejemplo se utiliza JKS. Responda las preguntas que aparecen a continuación cuando se le pida. La contraseña que cree aquí la necesitará más adelante:
```
keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
```
1. Importe el archivo `SFSRootCAG2.pem` que descargó al almacén de claves recién creado:
```
keytool -import -keystore server.jks -file .pem
```
1. Configure el objeto `Cluster` mediante programación:
```
Cluster cluster = Cluster.build("(your neptune endpoint)")
.port(8182)
.enableSSL(true)
.keyStore(‘server.jks’)
.keyStorePassword("(the password from step 2)")
.create();
```
Si lo desea, puede hacer lo mismo en un archivo de configuración, y también con la consola de 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 }}
```
## Autenticación de IAM
Neptune admite la [autenticación de IAM](iam-auth-enable.md) para controlar el acceso a su clúster de base de datos. Si tiene habilitada la autenticación de IAM, debe utilizar la firma de la versión 4 de Signature para autenticar sus solicitudes. Para obtener instrucciones detalladas y ejemplos de código para conectarse desde un cliente Java, consulte. [Conexión a bases de datos de Amazon Neptune mediante IAM con Java de Gremlin](iam-auth-connecting-gremlin-java.md)
# Ejemplo en Java de conexión a una instancia de base de datos de Neptune con lógica de reconexión
El siguiente ejemplo de Java muestra cómo conectarse al cliente de Gremlin con una lógica de reconexión para recuperarse de una desconexión inesperada.
Tiene las siguientes dependencias:
```
org.apache.tinkerpopgremlin-driver${gremlin.version}com.amazonawsamazon-neptune-sigv4-signer${sig4.signer.version}com.evanlennickretry4j0.15.0
```
Este es el código de ejemplo:
**importante**
Es posible que el `CallExecutor` de Retry4j no sea seguro para subprocesos. Considere la posibilidad de que cada subproceso use su propia instancia `CallExecutor` o use una biblioteca de reintentos diferente.
**nota**
El siguiente ejemplo se ha actualizado para incluir el uso de requestInterceptor(). Esto se añadió en la versión TinkerPop 3.6.6. Antes de la TinkerPop versión 3.6.6, el ejemplo de código utilizaba handshakeInterceptor (), que quedó obsoleto en esa versión.
```
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