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à.

# Utilizzo di un client Java per connettersi a un'istanza database Neptune
<a name="access-graph-gremlin-java"></a>

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/ <version>/binaries/apache-maven-<version>-bin.tar.gz
   sudo tar -xzf apache-maven-<version>-bin.tar.gz -C /opt/
   sudo ln -sf /opt/apache-maven-<version> /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:

   ```
   <project xmlns="https://maven.apache.org/POM/4.0.0"
            xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
     <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.amazonaws</groupId>
     <artifactId>GremlinExample</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>GremlinExample</name>
     <url>https://maven.apache.org</url>
     <dependencies>
       <dependency>
         <groupId>org.apache.tinkerpop</groupId>
         <artifactId>gremlin-driver</artifactId>
         <version>3.7.2</version>
       </dependency>
       <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-jdk14</artifactId>
         <version>1.7.25</version>
       </dependency>
     </dependencies>
     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>2.5.1</version>
           <configuration>
             <source>11</source>
             <target>11</target>
           </configuration>
         </plugin>
           <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>exec-maven-plugin</artifactId>
             <version>1.3</version>
             <configuration>
               <executable>java</executable>
               <arguments>
                 <argument>-classpath</argument>
                 <classpath/>
                 <argument>com.amazonaws.App</argument>
               </arguments>
               <mainClass>com.amazonaws.App</mainClass>
               <complianceLevel>1.11</complianceLevel>
               <killAfter>-1</killAfter>
             </configuration>
           </plugin>
       </plugins>
     </build>
   </project>
   ```
**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
<a name="access-graph-gremlin-java-ssl"></a>

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
<a name="access-graph-gremlin-java-iam"></a>

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).