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.

# Uso de un cliente Java para conectarse a una instancia de base de datos de Neptune
<a name="access-graph-gremlin-java"></a>

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/ <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. **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:

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

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

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)