Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esecuzione di query su un grafo Neptune
Neptune supporta i seguenti linguaggi di query a grafo per accedere a un grafo:
+ [Gremlin](https://tinkerpop.apache.org/gremlin.html), definito da [Apache per la creazione e l'interrogazione di grafici TinkerPop](https://tinkerpop.apache.org/) delle proprietà.
Una query in Gremlin è un attraversamento composto da passaggi discreti, ognuno dei quali segue un arco fino a un nodo.
Vedi [Accesso al grafo Neptune con Gremlin](access-graph-gremlin.md) per ottenere informazioni sull'uso di Gremlin in Neptune e [Conformità agli standard Gremlin in Amazon Neptune](access-graph-gremlin-differences.md) per trovare dettagli specifici sull'implementazione di Gremlin in Neptune.
+ [openCypher](access-graph-opencypher.md) è un linguaggio di query dichiarativo per grafi di proprietà che è stato sviluppato originariamente da Neo4j, per poi diventare open source nel 2015, e che ha contribuito al progetto [openCypher](http://www.opencypher.org/) con una licenza open source Apache 2. La sintassi è documentata nella [specifica openCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf).
+ [SPARQL](https://www.w3.org/TR/sparql11-overview/) è un linguaggio dichiarativo basato sulla corrispondenza di modelli del grafo, per l'esecuzione di query sui dati [RDF](https://www.w3.org/2001/sw/wiki/RDF). È supportato dal [World Wide Web Consortium](https://www.w3.org/).
Vedi [Accesso al grafo Neptune con SPARQL](access-graph-sparql.md) per ottenere informazioni sull'uso di SPARQL in Neptune e [Conformità agli standard SPARQL in Amazon Neptune](feature-sparql-compliance.md) per trovare dettagli specifici sull'implementazione di SPARQL in Neptune.
**Nota**
Sia Gremlin che openCypher possono essere usati per eseguire query sui dati dei grafi di proprietà archiviati in Neptune, indipendentemente da come sono stati caricati.
**Topics**
+ [
# Accodamento delle query in Amazon Neptune
](access-graph-queuing.md)
+ [
# Cache del piano di query in Amazon Neptune
](access-graph-qpc.md)
+ [
# Inserimento di un ID personalizzato in una query Neptune Gremlin o SPARQL
](features-query-id.md)
+ [
# Accesso al grafo Neptune con Gremlin
](access-graph-gremlin.md)
+ [
# Accesso al grafo di Neptune con openCypher
](access-graph-opencypher.md)
+ [
# Accesso al grafo Neptune con SPARQL
](access-graph-sparql.md)
# Accodamento delle query in Amazon Neptune
Durante lo sviluppo e l'ottimizzazione di applicazioni grafiche, può essere utile conoscere le implicazioni di come le query vengono accodate dal database. In Amazon Neptune, l'accodamento delle query si verifica come segue:
+ Il numero massimo di query che è possibile accodare per istanza, indipendentemente dalla dimensione dell'istanza, è 8.192. Tutte le query superiori a quel numero vengono rifiutate e danno esito negativo con un `ThrottlingException`.
+ Il numero massimo di query che possono essere eseguite contemporaneamente è determinato dal numero di thread di lavoro assegnati, che in genere è impostato sul doppio del numero di core CPU virtuali (v) disponibili. CPUs
+ La latenza delle query include il tempo trascorso da una query nella coda, nonché il round trip della rete e il tempo necessario per l'esecuzione.
## Determinare quante query ci sono nella coda in un dato momento
La `MainRequestQueuePendingRequests` CloudWatch metrica registra il numero di richieste in attesa nella coda di input con una granularità di cinque minuti (vedi). [Metriche di Neptune CloudWatch](cw-metrics.md)
Per Gremlin, è possibile ottenere un conteggio corrente di query nella coda utilizzando il valore `acceptedQueryCount` restituito da [API di stato delle query Gremlin](gremlin-api-status.md). Si noti, tuttavia, che il valore `acceptedQueryCount` restituito da [API di stato delle query SPARQL](sparql-api-status.md) include tutte le query accettate dall'avvio del server, incluse le query completate.
## Come l'accodamento delle query può influire sui timeout
Come notato in precedenza, la latenza delle query include il tempo impiegato da una query nella coda e il tempo necessario per l'esecuzione.
Poiché il periodo di timeout di una query viene generalmente misurato a partire da quando entra nella coda, una coda a spostamento lento può mandare molte query in timeout non appena vengono rimosse dalla coda. Questo è ovviamente indesiderabile, quindi è bene evitare di accodare un gran numero di query a meno che non possano essere eseguite rapidamente.
# Cache del piano di query in Amazon Neptune
Quando una query viene inviata a Neptune, la stringa di query viene analizzata, ottimizzata e trasformata in un piano di query, che viene quindi eseguito dal motore. Le applicazioni sono spesso supportate da modelli di query comuni istanziati con valori diversi. La cache del piano di query può ridurre la latenza complessiva memorizzando nella cache i piani di query ed evitando così l'analisi e l'ottimizzazione di tali schemi ripetuti.
Query Plan Cache può essere utilizzata per le query, sia quelle non **OpenCypher**parametrizzate che quelle parametrizzate. È abilitato per READ e per HTTP e Bolt. **Non** è supportato per le query di mutazione OC. **Non** è supportato per le query Gremlin o SPARQL.
## Come forzare l'attivazione o la disabilitazione della cache del piano di query
La cache del piano di query è abilitata di default per le query parametrizzate a bassa latenza. **Un piano per una query con parametri viene memorizzato nella cache solo quando la latenza è inferiore alla soglia di 100 ms.** Questo comportamento può essere sovrascritto per singola query (parametrizzata o meno) dal Query Hint a livello di query. `QUERY:PLANCACHE` Deve essere usato con la clausola. `USING` Il suggerimento di interrogazione accetta `enabled` o `disabled` come valore.
```
# 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"
```
## Come determinare se un piano è memorizzato nella cache o meno
Per HTTP READ, se la query è stata inviata e il piano è stato memorizzato nella cache, `explain` mostrerebbe i dettagli relativi alla cache del piano di query.
```
% 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).
```
Quando si utilizza Bolt, la funzione di spiegazione non è supportata.
## Sfratto
Un piano di query viene eliminato dal cache time to live (TTL) o quando è stato raggiunto un numero massimo di piani di query memorizzati nella cache. Quando il piano di query viene raggiunto, il TTL viene aggiornato. Le impostazioni predefinite sono:
+ 1000: il numero massimo di piani che possono essere memorizzati nella cache per istanza.
+ TTL: 300.000 millisecondi o 5 minuti. L'accesso alla cache riavvia il TTL e lo reimposta a 5 minuti.
## Condizioni che impediscono la memorizzazione del piano nella cache
La cache del piano di query non verrebbe utilizzata nelle seguenti condizioni:
1. Quando viene inviata una query utilizzando il suggerimento `QUERY:PLANCACHE "disabled"` di interrogazione. È possibile eseguire nuovamente la query e rimuoverla `QUERY:PLANCACHE "disabled"` per abilitare la cache del piano di interrogazione.
1. Se la query inviata non è un'interrogazione con parametri e non contiene il suggerimento. `QUERY:PLANCACHE "enabled"`
1. Se il tempo di valutazione della query è superiore alla soglia di latenza, la query non viene memorizzata nella cache e viene considerata una query di lunga durata che non trarrebbe vantaggio dalla cache del piano di query.
1. Se la query contiene uno schema che non restituisce alcun risultato.
+ cioè `MATCH (n:nonexistentLabel) return n` quando ci sono zero nodi con l'etichetta specificata.
+ cioè `MATCH (n {name: $param}) return n` con `parameters={"param": "abcde"}` quando non ci sono nodi contenenti`name=abcde`.
1. Se il parametro di interrogazione è di tipo composito, ad esempio a `list` o a`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. Se il parametro di query è una stringa che non ha fatto parte di un'operazione di caricamento o inserimento di dati. Ad esempio, se `CREATE (n {name: "X"})` viene eseguito per inserire`"X"`, `RETURN "X"` viene memorizzato nella cache, mentre non `RETURN "Y"` verrebbe memorizzato nella cache, poiché `"Y"` non è stato inserito e non esiste nel database.
# Inserimento di un ID personalizzato in una query Neptune Gremlin o SPARQL
Per impostazione predefinita, Neptune assegna un valore `queryId` univoco a ogni query. Puoi utilizzare questo ID per ottenere informazioni su una query in esecuzione (consulta [API di stato delle query Gremlin](gremlin-api-status.md) o [API di stato delle query SPARQL](sparql-api-status.md)) o annullarla (consulta [Annullamento delle query Gremlin](gremlin-api-status-cancel.md) o [Annullamento della query SPARQL](sparql-api-status-cancel.md)).
Neptune consente inoltre di specificare il proprio valore `queryId` per una query Gremlin o SPARQL, nell'intestazione HTTP o per una query SPARQL utilizzando l'hint di query `queryId`. L'assegnazione del proprio `queryID` consente di tenere traccia di una query in modo da ottenere lo stato o annullarla.
## Inserimento di un valore `queryId` personalizzato tramite l'intestazione HTTP
Per Gremlin e SPARQL, l'intestazione HTTP può essere utilizzata per inserire il proprio valore `queryId` in una query.
**Esempio Gremlin**
```
curl -XPOST https://your-neptune-endpoint:port \
-d "{\"gremlin\": \
\"g.V().limit(1).count()\" , \
\"queryId\":\"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" }"
```
**Esempio SPARQL**
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=SELECT * WHERE { ?s ?p ?o } " \
--data-urlencode \
"queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
## Inserimento di un valore `queryId` personalizzato mediante un hint di query SPARQL
Di seguito è riportato un esempio di come utilizzare l'hint di query `queryId` SPARQL per inserire un valore `queryId` personalizzato in una query 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}}"
```
## Utilizzo del valore `queryId` per controllare lo stato della query
**Esempio Gremlin**
```
curl https://your-neptune-endpoint:port/gremlin/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
**Esempio SPARQL**
```
curl https://your-neptune-endpoint:port/sparql/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
# Accesso al grafo Neptune con Gremlin
Amazon Neptune è compatibile con TinkerPop Apache e Gremlin. Ciò significa che puoi connetterti a un'istanza DB di Neptune e usare il linguaggio di attraversamento Gremlin per interrogare il grafico ([vedi](https://tinkerpop.apache.org/docs/current/reference/#graph) The Graph nella documentazione di Apache). TinkerPop Per le differenze nell'implementazione di Gremlin in Neptune, consulta [Conformità agli standard Gremlin](access-graph-gremlin-differences.md).
L'*attraversamento* in Gremlin corrisponde a una serie di passaggi concatenati. Inizia in un vertice (o edge). Percorre il grafo seguendo gli edge in uscita di ogni vertice, quindi gli edge in uscita di quei vertici. Nell'attraversamento, ogni passaggio corrisponde a un'operazione. [Per ulteriori informazioni, consulta The Traversal nella documentazione.](https://tinkerpop.apache.org/docs/current/reference/#traversal) TinkerPop
Versioni diverse del motore Neptune supportano versioni diverse di Gremlin. Controlla la [pagina di rilascio del motore](engine-releases.md) della versione di Neptune in uso per determinare quale versione di Gremlin supporta o consulta la seguente tabella che elenca le versioni più vecchie e più recenti TinkerPop supportate da diverse versioni del motore Neptune:
| Versione del motore Neptune | Versione minima TinkerPop | TinkerPop Versione massima |
| --- | --- | --- |
| `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 I client sono in genere retrocompatibili all'interno di una serie (ad esempio`3.6.x`, o`3.7.x`) e sebbene possano spesso funzionare oltre tali limiti, la tabella precedente consiglia le combinazioni di versioni da utilizzare per la migliore esperienza e compatibilità possibili. Salvo diversa indicazione, in genere è meglio attenersi a queste linee guida e aggiornare le applicazioni client in modo che corrispondano alla versione in uso TinkerPop .
Quando si aggiornano TinkerPop le versioni, è sempre importante fare riferimento alla [documentazione TinkerPop di aggiornamento](http://tinkerpop.apache.org/docs/current/upgrade/), che aiuterà a identificare le nuove funzionalità da sfruttare, ma anche i problemi di cui potrebbe essere necessario essere consapevoli man mano che ci si avvicina all'aggiornamento. In genere è necessario aspettarsi che le query e le funzionalità esistenti funzionino dopo l'aggiornamento, a meno che non venga indicato qualcosa in particolare come un problema da considerare. Infine, è importante notare che se una versione aggiornata include una nuova funzionalità, potrebbe non essere possibile utilizzarla se proviene da una versione successiva a quella supportata da Neptune.
Per l'accesso a Gremlin esistono varianti di linguaggio e supporto in diversi linguaggi di programmazione. Per ulteriori informazioni, vedete [On Gremlin Language Variants nella documentazione](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants). TinkerPop
Questa documentazione descrive come accedere a Neptune con le seguenti varianti e linguaggi di programmazione:
+ [Configurazione della console Gremlin per la connessione a un'istanza database Neptune](access-graph-gremlin-console.md)
+ [Utilizzo dell'endpoint HTTPS REST per connettersi a un'istanza database Neptune](access-graph-gremlin-rest.md)
+ [Client Gremlin basati su Java da utilizzare con Amazon Neptune](access-graph-gremlin-client.md)
+ [Utilizzo di Python per connettersi a un'istanza database Neptune](access-graph-gremlin-python.md)
+ [Utilizzo di .NET per connettersi a un'istanza database Neptune](access-graph-gremlin-dotnet.md)
+ [Utilizzo di Node.js per connettersi a un'istanza database Neptune](access-graph-gremlin-node-js.md)
+ [Utilizzo di Go per connettersi a un'istanza database Neptune](access-graph-gremlin-go.md)
Come discusso in precedenza[Crittografia delle connessioni al tuo database Amazon Neptune con SSL/HTTPS](security-ssl.md), è necessario utilizzare Transport Layer Security/Secure Sockets Layer (TLS/SSL) per la connessione a Neptune in tutte le regioni. AWS
Prima di iniziare, devi disporre di quanto segue:
+ Istanza database Neptune. Per informazioni sulla creazione di un'istanza database Neptune, consulta [Creazione di un cluster Amazon Neptune](get-started-create-cluster.md).
+ Istanza Amazon EC2 nello stesso cloud privato virtuale (VPC) dell'istanza database Neptune.
Per ulteriori informazioni sul caricamento di dati in Neptune, incluso i prerequisiti, i formati di caricamento e i parametri di caricamento, vedi [Caricamento di dati in Amazon Neptune](load-data.md).
**Topics**
+ [
# Configurazione della console Gremlin per la connessione a un'istanza database Neptune
](access-graph-gremlin-console.md)
+ [
# Utilizzo dell'endpoint HTTPS REST per connettersi a un'istanza database Neptune
](access-graph-gremlin-rest.md)
+ [
# Client Gremlin basati su Java da utilizzare con Amazon Neptune
](access-graph-gremlin-client.md)
+ [
# Utilizzo di Python per connettersi a un'istanza database Neptune
](access-graph-gremlin-python.md)
+ [
# Utilizzo di .NET per connettersi a un'istanza database Neptune
](access-graph-gremlin-dotnet.md)
+ [
# Utilizzo di Node.js per connettersi a un'istanza database Neptune
](access-graph-gremlin-node-js.md)
+ [
# Utilizzo di Go per connettersi a un'istanza database Neptune
](access-graph-gremlin-go.md)
+ [
# Utilizzo dell' AWS SDK per eseguire le query Gremlin
](access-graph-gremlin-sdk.md)
+ [
# Hint di query Gremlin
](gremlin-query-hints.md)
+ [
# API di stato delle query Gremlin
](gremlin-api-status.md)
+ [
# Annullamento delle query Gremlin
](gremlin-api-status-cancel.md)
+ [
# Supporto delle sessioni basate su script Gremlin
](access-graph-gremlin-sessions.md)
+ [
# Transazioni Gremlin in Neptune
](access-graph-gremlin-transactions.md)
+ [
# Utilizzo dell'API Gremlin con Amazon Neptune
](gremlin-api-reference.md)
+ [
# Memorizzazione nella cache dei risultati delle query con Gremlin in Amazon Neptune
](gremlin-results-cache.md)
+ [
# Creazione di upsert efficienti con i passaggi `mergeV()` e `mergeE()` di Gremlin
](gremlin-efficient-upserts.md)
+ [
# Creazione di upsert Gremlin efficienti con `fold()/coalesce()/unfold()`
](gremlin-efficient-upserts-pre-3.6.md)
+ [
# Analisi dell'esecuzione di query Neptune tramite la funzionalità Gremlin `explain`
](gremlin-explain.md)
+ [
# Utilizzo di Gremlin con il motore di query Neptune DFE
](gremlin-with-dfe.md)
# Configurazione della console Gremlin per la connessione a un'istanza database Neptune
La console Gremlin consente di sperimentare TinkerPop grafici e interrogazioni in un ambiente REPL (loop). read-eval-print
## Installazione della console Gremlin e connessione ad essa nel modo consueto
Con la console Gremlin puoi connetterti a un database a grafo remoto. La sezione seguente illustra l'installazione e la configurazione della console Gremlin per connettersi in remoto a un'istanza database Neptune. Segui queste istruzioni da un'istanza Amazon EC2 nello stesso cloud privato virtuale (VPC) dell'istanza database Neptune.
Per informazioni sulla connessione a Neptune SSL/TLS con (operazione obbligatoria), consulta. [Configurazione SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)
**Nota**
Se nel cluster database Neptune è [abilitata l'autenticazione IAM](iam-auth-enable.md), per installare la console Gremlin seguire le istruzioni riportate in [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con la console Gremlin](iam-auth-connecting-gremlin-console.md) anziché le istruzioni riportate qui.
**Per installare la console Gremlin e connettersi a Neptune**
1. I binari della console Gremlin richiedono Java 8 o Java 11. Queste istruzioni presuppongono l'uso di Java 11. Puoi installare Java 11 sull'istanza EC2 come segue:
+ Se utilizzi [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Se utilizzi [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
```
+ Per altre distribuzioni, usa l'opzione appropriata tra le seguenti:
```
sudo yum install java-11-openjdk-devel
```
oppure:
```
sudo apt-get install openjdk-11-jdk
```
1. Per impostare Java 11 come runtime predefinito sull'istanza EC2, digita quanto segue.
```
sudo /usr/sbin/alternatives --config java
```
Quando richiesto, immetti il numero per Java 11.
1. Scarica la versione appropriata della console Gremlin dal sito Web di Apache. Puoi controllare quale versione di [Accesso al grafo Neptune con Gremlin](access-graph-gremlin.md) Gremlin è supportata dalla tua versione di Neptune. Ad esempio, se hai bisogno della versione 3.7.2, puoi scaricare la [console Gremlin](https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip) dal sito web di [Apache](https://tinkerpop.apache.org/download.html) Tinkerpop sulla tua istanza EC2 in questo modo:
```
wget https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Decomprimi il file zip della console Gremlin.
```
unzip apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Cambiare directory nella directory decompressa.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. Nella sottodirectory `conf` della directory estratta, creare un file denominato `neptune-remote.yaml` con il testo seguente. Sostituisci *your-neptune-endpoint* con il nome host o l'indirizzo IP dell'istanza DB di Neptune. Le parentesi quadre (`[ ]`) sono obbligatorie.
**Nota**
Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta la sezione [Connessione agli endpoint 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**
I serializzatori sono stati spostati dal `gremlin-driver` modulo al nuovo `gremlin-util` modulo nella versione 3.7.0. Il pacchetto è cambiato da org.apache.tinkerpop.gremlin.driver.ser a org.apache.tinkerpop.gremlin.util.ser.
1. In un terminale, vai alla directory della console Gremlin (`apache-tinkerpop-gremlin-console-3.7.2`) e immetti il comando seguente per eseguire la console Gremlin.
```
bin/gremlin.sh
```
Verrà visualizzato l’output seguente:
```
\,,,/
(o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin>
```
Ora ti trovi al prompt `gremlin>`. Immetti i restanti passaggi in questo prompt.
1. Al prompt `gremlin>`, immetti quanto segue per connetterti all'istanza database Neptune.
```
:remote connect tinkerpop.server conf/neptune-remote.yaml
```
1. Al prompt `gremlin>`, immetti quanto segue per passare alla modalità remota. In questo modo tutte le query Gremlin vengono inviate alla connessione remota.
```
:remote console
```
1. Immetti quanto segue per inviare una query al grafo Gremlin.
```
g.V().limit(1)
```
1. Al termine, immetti quanto segue per uscire dalla console di Gremlin.
```
:exit
```
**Nota**
Utilizzare un punto e virgola (`;`) o un carattere nuova riga (`\n`) per separare ogni istruzione.
Ogni attraversamento che precede l'attraversamento finale deve terminare in `next()` per essere eseguito. Vengono restituiti solo i dati dell'ultimo attraversamento.
Per ulteriori informazioni sull'implementazione di Gremlin in Neptune, consulta [Conformità agli standard Gremlin in Amazon Neptune](access-graph-gremlin-differences.md).
# Un modo alternativo per connettersi alla console Gremlin
**Svantaggi dell'approccio di connessione normale**
Il modo più comune per connettersi alla console Gremlin è quello spiegato sopra, utilizzando comandi come questo al prompt `gremlin>`.
```
gremlin> :remote connect tinkerpop.server conf/(file name).yaml
gremlin> :remote console
```
Funziona bene e consente di inviare query a Neptune. Tuttavia, esclude il motore di script Groovy dal ciclo, quindi Neptune tratta tutte le query come puro Gremlin. Ciò significa che i seguenti moduli di query hanno esito negativo:
```
gremlin> 1 + 1
gremlin> x = g.V().count()
```
La cosa più vicina all'utilizzo di una variabile quando si è connessi in questo modo è utilizzare la variabile `result` gestita dalla console e inviare la query utilizzando `:>`, in questo modo:
```
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]
```
**Un modo diverso di connettersi**
Puoi anche connetterti alla console Gremlin in un modo diverso, che potresti trovare più comodo, come questo:
```
gremlin> g = traversal().withRemote('conf/neptune.properties')
```
In questo caso il formato di `neptune.properties` è il seguente:
```
gremlin.remote.remoteConnectionClass=org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection
gremlin.remote.driver.clusterFile=conf/my-cluster.yaml
gremlin.remote.driver.sourceName=g
```
Il file `my-cluster.yaml` sarà simile al seguente:
```
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**
I serializzatori sono stati spostati dal modulo al nuovo modulo nella versione `gremlin-driver` 3.7.0. `gremlin-util` Il pacchetto è cambiato da org.apache.tinkerpop.gremlin.driver.ser a org.apache.tinkerpop.gremlin.util.ser.
La configurazione della connessione alla console Gremlin in questo modo consente di effettuare correttamente i seguenti tipi di query:
```
gremlin> 1+1
==>2
gremlin> x=g.V().count().next()
==>4249
gremlin> println("The answer was ${x}")
The answer was 4249
```
Puoi evitare di visualizzare il risultato, in questo modo:
```
gremlin> x=g.V().count().next();[]
gremlin> println(x)
4249
```
Tutti i metodi usuali di esecuzione di query (senza il passaggio terminale) continuano a funzionare. Esempio:
```
gremlin> g.V().count()
==>4249
```
Puoi anche usare il passaggio [https://tinkerpop.apache.org/docs/current/reference/#io-step](https://tinkerpop.apache.org/docs/current/reference/#io-step) per caricare un file con questo tipo di connessione.
## Autenticazione IAM
Neptune [supporta l'autenticazione IAM](iam-auth-enable.md) per controllare l'accesso al cluster DB. Se hai abilitato l'autenticazione IAM, devi utilizzare la firma Signature Version 4 per autenticare le tue richieste. Per istruzioni dettagliate ed esempi di codice per la connessione dalla console Gremlin, consulta. [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con la console Gremlin](iam-auth-connecting-gremlin-console.md)
# Utilizzo dell'endpoint HTTPS REST per connettersi a un'istanza database Neptune
Amazon Neptune fornisce un endpoint HTTPS per le query Gremlin. L'interfaccia REST è compatibile con qualsiasi versione di Gremlin utilizzata dal cluster database (consulta la [pagina di rilascio del motore](engine-releases.md) della versione del motore Neptune che stai utilizzando per determinare quale rilascio di Gremlin supporta).
**Nota**
Come illustrato in [Crittografia delle connessioni al tuo database Amazon Neptune con SSL/HTTPS](security-ssl.md), Neptune ora richiede la connessione tramite HTTPS anziché HTTP. Inoltre, Neptune attualmente non supporta HTTP/2 per le richieste API REST. I client devono utilizzare HTTP/1.1 per la connessione agli endpoint.
Le istruzioni seguenti mostrano come connettersi a un endpoint di Gremlin utilizzando il comando `curl` e HTTPS. Segui queste istruzioni da un'istanza Amazon EC2 nello stesso cloud privato virtuale (VPC) dell'istanza database Neptune.
L'endpoint HTTPS per le query Gremlin in un'istanza database Neptune è `https://your-neptune-endpoint:port/gremlin`.
**Nota**
Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta [Connessione agli endpoint Amazon Neptune](feature-overview-endpoints.md).
## Per connettersi a Neptune utilizzando l'endpoint HTTP REST
L'esempio seguente utilizza **curl** per inviare una query Gremlin tramite HTTP **POST**. La query viene inviata in formato JSON nel corpo del post come proprietà `gremlin`.
```
curl -X POST -d '{"gremlin":"g.V().limit(1)"}' https://your-neptune-endpoint:port/gremlin
```
Questo esempio restituisce il primo vertice nel grafo utilizzando l'attraversamento `g.V().limit(1)`. Per eseguire una query su qualcos'altro, sostituirlo con un altro attraversamento Gremlin.
**Importante**
Per impostazione predefinita, l'endpoint REST restituisce tutti i risultati in un unico insieme di risultati JSON. Se questo insieme di risultati è troppo grande, può verificarsi un'eccezione `OutOfMemoryError` sull'istanza database Neptune.
È possibile evitare tale problema abilitando le risposte in blocchi (risultati restituiti in una serie di risposte separate). Per informazioni, consulta [Utilizzo di intestazioni HTTP finali opzionali per abilitare le risposte Gremlin in più parti](access-graph-gremlin-rest-trailing-headers.md).
Sebbene le richieste HTTP **POST** siano consigliate per l'invio di query Gremlin, è possibile utilizzare anche le richieste HTTP **GET**:
```
curl -G "https://your-neptune-endpoint:port?gremlin=g.V().count()"
```
**Nota**
Neptune non supporta la proprietà `bindings`.
# Utilizzo di intestazioni HTTP finali opzionali per abilitare le risposte Gremlin in più parti
Per impostazione predefinita, la risposta HTTP alle query Gremlin viene restituita in un unico insieme di risultati JSON. Nel caso di un insieme di risultati molto grande, ciò può causare un'eccezione `OutOfMemoryError` sull'istanza database.
Tuttavia, è possibile abilitare le risposte *in blocchi* (risposte restituite in più parti separate). A tale scopo, includere nella richiesta un'intestazione transfer-encoding (TE) trailers (`te: trailers`). Per ulteriori informazioni sulle intestazioni TE, vedi [la pagina MDN sulle intestazioni di richiesta TE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE).
Quando una risposta viene restituita in più parti, può essere difficile diagnosticare un problema che si verifica dopo la ricezione della prima parte, poiché la prima parte arriva con il codice di stato HTTP `200` (OK). Un errore successivo di solito si traduce in un corpo del messaggio contenente una risposta danneggiata, al termine della quale Neptune aggiunge un messaggio di errore.
Per facilitare il rilevamento e la diagnosi di questo tipo di errore, Neptune include anche due nuovi campi di intestazione all'interno delle intestazioni finali di ogni blocco di risposta:
+ `X-Neptune-Status`: contiene il codice di risposta seguito da un nome breve. Ad esempio, in caso di esito positivo, l'intestazione finale sarà: `X-Neptune-Status: 200 OK`. In caso di errore, il codice di risposta sarà uno dei [codici di errore del motore Neptune](errors-engine-codes.md), ad esempio `X-Neptune-Status: 500 TimeLimitExceededException`.
+ `X-Neptune-Detail`: è vuoto per le richieste riuscite. In caso di errori, contiene il messaggio di errore JSON. Poiché nei valori di intestazione HTTP sono consentiti solo caratteri ASCII, la stringa JSON è codificata come URL.
**Nota**
Neptune attualmente non supporta la compressione `gzip` delle risposte in blocchi. Se il client richiede contemporaneamente la codifica e la compressione in blocchi, Neptune salta la compressione.
# Client Gremlin basati su Java da utilizzare con Amazon Neptune
[Puoi utilizzare uno dei due client Gremlin open source basati su Java con Amazon Neptune: il client [Apache TinkerPop Java Gremlin o il client Gremlin](https://search.maven.org/artifact/org.apache.tinkerpop/gremlin-driver) per Amazon Neptune.](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client)
## Client Apache Java Gremlin TinkerPop
Il [driver gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java) Apache TinkerPop Java è il client Gremlin standard e ufficiale che funziona con qualsiasi database grafico abilitato. TinkerPop Usa questo client quando hai bisogno della massima compatibilità con lo spazio di TinkerPop sviluppo più ampio, quando lavori con più sistemi di database a grafi o quando non hai bisogno della gestione avanzata dei cluster e delle funzionalità di bilanciamento del carico specifiche di Neptune. Questo client è adatto anche per applicazioni semplici che si connettono a una singola istanza di Neptune o quando si preferisce gestire il bilanciamento del carico a livello di infrastruttura anziché all'interno del client.
**Importante**
La scelta della versione corretta del driver Apache TinkerPop Gremlin è fondamentale per la compatibilità con la versione del motore Neptune in uso. L'utilizzo di una versione incompatibile può causare errori di connessione o comportamenti imprevisti. Per informazioni dettagliate sulla compatibilità delle versioni, vedere. [Accesso al grafo Neptune con Gremlin](access-graph-gremlin.md)
**Nota**
La tabella che consente di determinare la TinkerPop versione di Apache corretta da utilizzare con Neptune è stata spostata in. [Accesso al grafo Neptune con Gremlin](access-graph-gremlin.md) Questa tabella si trovava in precedenza in questa pagina per molti anni e ora è più centralizzata come riferimento per tutti i linguaggi di programmazione che lo supportano. TinkerPop
## Client Java Gremlin per Amazon Neptune
Il client Gremlin per Amazon Neptune è [un client Gremlin open source basato su Java che funge da sostituto](https://github.com/aws/neptune-gremlin-client) diretto del client Java standard. TinkerPop
Il client Gremlin di Neptune è ottimizzato per i cluster Neptune. Consente di gestire la distribuzione del traffico su più istanze di un cluster e si adatta alle modifiche della topologia del cluster quando si aggiunge o si rimuove una replica. È anche possibile configurare il client per distribuire le richieste su un sottoinsieme di istanze del cluster, in base al ruolo, al tipo di istanza, alla zona di disponibilità (AZ) o ai tag associati alle istanze.
L'[ultima versione del client Java Gremlin di Neptune](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client) è disponibile su Maven Central.
Per ulteriori informazioni sul client Java Gremlin di Neptune, consulta [questo post del blog](https://aws.amazon.com/blogs/database/load-balance-graph-queries-using-the-amazon-neptune-gremlin-client/). [Per esempi di codice e demo, consulta il progetto del cliente. GitHub ](https://github.com/aws/neptune-gremlin-client)
Quando si sceglie la versione del client Neptune Gremlin, è necessario considerare la versione TinkerPop sottostante in relazione alla versione del motore Neptune. Fai riferimento alla tabella di compatibilità all'indirizzo [Accesso al grafo Neptune con Gremlin](access-graph-gremlin.md) per determinare la TinkerPop versione corretta per il tuo motore Neptune, quindi usa la tabella seguente per selezionare la versione del client Neptune Gremlin appropriata:
**Compatibilità della versione del client Neptune Gremlin**
| Versione client Neptune Gremlin | TinkerPop versione |
| --- | --- |
| 3.x | 3.7.x (AWS SDK per Java 2.x/1.x) |
| 2.1.x | 3.7.x (AWS SDK per Java 1.x) |
| 2.0.x | 3.6.x |
| 1.12 | 3.5.x |
# Utilizzo di un client Java per connettersi a un'istanza database Neptune
La sezione seguente illustra l'esecuzione di un esempio Java completo che si connette a un'istanza DB di Neptune ed esegue un attraversamento di Gremlin utilizzando il client Apache Gremlin. TinkerPop
Segui queste istruzioni da un'istanza Amazon EC2 nello stesso cloud privato virtuale (VPC) dell'istanza database Neptune.
**Per connettersi a Neptune tramite Java**
1. Installare Apache Maven sull'istanza EC2. Se usi Amazon Linux 2023 (preferito), usa:
```
sudo dnf update -y
sudo dnf install maven -y
```
Se usi Amazon Linux 2, scarica il file binario più recente da [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. **Installare Java.** Le librerie Gremlin richiedono Java 8 o 11. Puoi installare Java 11 nel modo seguente:
+ Se utilizzi [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Se utilizzi [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
```
+ Per altre distribuzioni, usa l'opzione appropriata tra le seguenti:
```
sudo yum install java-11-openjdk-devel
```
oppure:
```
sudo apt-get install openjdk-11-jdk
```
1. **Imposta Java 11 come runtime predefinito sull'istanza EC2:** inserisci quanto segue per impostare Java 8 come runtime predefinito sull'stanza EC2:
```
sudo /usr/sbin/alternatives --config java
```
Quando richiesto, immetti il numero per Java 11.
1. **Crea una nuova directory denominata `gremlinjava`:**
```
mkdir gremlinjava
cd gremlinjava
```
1. Nella directory `gremlinjava`, creare un file `pom.xml`, quindi aprirlo in un editor di testo:
```
nano pom.xml
```
1. Copiare quanto segue nel file `pom.xml` e salvare:
```
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**
Se stai modificando un progetto Maven esistente, la dipendenza necessaria è evidenziata nel codice precedente.
1. Creare sottodirectory per il codice sorgente di esempio (`src/main/java/com/amazonaws/`) digitando quanto segue nella riga di comando:
```
mkdir -p src/main/java/com/amazonaws/
```
1. Nella directory `src/main/java/com/amazonaws/`, creare un file denominato `App.java`, quindi aprirlo in un editor di testo.
```
nano src/main/java/com/amazonaws/App.java
```
1. Copiare quanto segue nel file `App.java`. Sostituisci *your-neptune-endpoint* con l'indirizzo della tua istanza DB Neptune. *Non* includere il prefisso `https://` nel metodo `addContactPoint`.
**Nota**
Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta [Connessione agli endpoint 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();
}
}
```
Per informazioni sulla connessione a Neptune SSL/TLS con (operazione obbligatoria), consulta. [Configurazione SSL/TLS](#access-graph-gremlin-java-ssl)
1. Compilare ed eseguire il campione usando il comando Maven seguente:
```
mvn compile exec:exec
```
L'esempio precedente restituisce una mappa della chiave e i valori di ogni proprietà per i primi due vertici nel grafo utilizzando l'attraversamento `g.V().limit(3).elementMap()`. Per eseguire query per qualcos'altro, sostituirla con un altro attraversamento Gremlin con uno dei metodi finali appropriati.
**Nota**
La parte finale della query Gremlin, `.toList()` è obbligatoria per inviare l'attraversamento al server per la valutazione. Se non includi quel metodo o un altro metodo equivalente, la query non viene inviata all'istanza database Neptune.
È inoltre necessario aggiungere una chiusura appropriata quando si aggiunge un vertice o un arco, ad esempio quando si utilizza il passaggio `addV( )`.
I metodi riportati sotto inviano la query all'istanza database Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Configurazione SSL/TLS per il client Java Gremlin
Neptune SSL/TLS deve essere abilitato per impostazione predefinita. In genere, se il driver Java è configurato con `enableSsl(true)`, può connettersi a Neptune senza dover impostare `trustStore()` o `keyStore()` con una copia locale di un certificato.
Tuttavia, se l'istanza con cui ti stai connettendo non dispone di una connessione Internet tramite la quale verificare un certificato pubblico o se il certificato che stai utilizzando non è pubblico, puoi effettuare le seguenti operazioni per configurare una copia locale del certificato:
**Configurazione di una copia locale del certificato per abilitare SSL/TLS**
1. Scarica e installa [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) da Oracle. Ciò renderà molto più semplice la configurazione dell'archivio chiavi locale.
1. Scarica il certificato CA `SFSRootCAG2.pem` (l'SDK Gremlin Java richiede un certificato per verificare il certificato remoto):
```
wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
```
1. Crea un archivio di chiavi in formato JKS o. PKCS12 Questo esempio usa JKS. Rispondi alle domande che seguono al prompt. La password che crei qui sarà necessaria in seguito:
```
keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
```
1. Importa il file `SFSRootCAG2.pem` che hai scaricato nell'archivio chiavi appena creato:
```
keytool -import -keystore server.jks -file .pem
```
1. Configura l'oggetto `Cluster` a livello di codice:
```
Cluster cluster = Cluster.build("(your neptune endpoint)")
.port(8182)
.enableSSL(true)
.keyStore(‘server.jks’)
.keyStorePassword("(the password from step 2)")
.create();
```
Si può fare la stessa cosa in un file di configurazione, come è possibile fare con 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 }}
```
## Autenticazione IAM
Neptune [supporta l'autenticazione IAM](iam-auth-enable.md) per controllare l'accesso al cluster DB. Se hai abilitato l'autenticazione IAM, devi utilizzare la firma Signature Version 4 per autenticare le tue richieste. Per istruzioni dettagliate ed esempi di codice per la connessione da un client Java, consulta[Connessione ai database Amazon Neptune tramite IAM con Gremlin Java](iam-auth-connecting-gremlin-java.md).
# Esempio Java di connessione a un'istanza database Neptune con logica di riconnessione
Il seguente esempio Java mostra come connettersi al client Gremlin con la logica di riconnessione per eseguire il ripristino in seguito a una disconnessione imprevista.
Presenta le seguenti dipendenze:
```
org.apache.tinkerpopgremlin-driver${gremlin.version}com.amazonawsamazon-neptune-sigv4-signer${sig4.signer.version}com.evanlennickretry4j0.15.0
```
Ecco il codice di esempio:
**Importante**
L'executor `CallExecutor` di Retry4j potrebbe non essere thread-safe. Prendi in considerazione l'idea di fare in modo che ogni thread utilizzi la propria `CallExecutor` istanza o utilizzi una libreria di riprova diversa.
**Nota**
L'esempio seguente è stato aggiornato per includere l'uso di requestInterceptor (). Questo è stato aggiunto nella versione 3.6.6. TinkerPop Prima della TinkerPop versione 3.6.6, l'esempio di codice utilizzava handshakeInterceptor (), che era obsoleto in quella versione.
```
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