As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usar o cliente do Java para conectar-se a uma instância de banco de dados do Neptune
<a name="access-graph-gremlin-java"></a>

A seção a seguir mostra a execução de uma amostra completa de Java que se conecta a uma instância de banco de dados Neptune e executa uma travessia do Gremlin usando o cliente Apache Gremlin. TinkerPop

Estas instruções devem ser seguidas em uma instância do Amazon EC2 na mesma nuvem privada virtual (VPC) que a instância de banco de dados do Neptune.

**Como conectar-se ao Neptune usando o Java**

1. Instale o Apache Maven na instância do EC2. Se estiver usando o Amazon Linux 2023 (preferencial), use:

   ```
   sudo dnf update -y
   sudo dnf install maven -y
   ```

   Se estiver usando o Amazon Linux 2, baixe o binário mais recente em [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 o Java.** As bibliotecas do Gremlin precisam do Java 8 ou 11. Você pode instalar o Java 11 da seguinte maneira:
   + Se você estiver usando o [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):

     ```
     sudo amazon-linux-extras install java-openjdk11
     ```
   + Se você estiver usando o [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 outras distribuições, use qualquer uma das seguintes opções que seja apropriada:

     ```
     sudo yum install java-11-openjdk-devel
     ```

     ou:

     ```
     sudo apt-get install openjdk-11-jdk
     ```

1. **Defina o Java 11 como o runtime padrão na instância do EC2:** digite o seguinte para definir o Java 8 como o runtime padrão na instância do EC2:

   ```
   sudo /usr/sbin/alternatives --config java
   ```

   Quando solicitado, insira o número do Java 11.

1. **Crie um diretório denominado `gremlinjava`:**

   ```
   mkdir gremlinjava
   cd gremlinjava
   ```

1.  No diretório `gremlinjava`, crie um arquivo `pom.xml` e abra-o em um editor de texto:

   ```
   nano pom.xml
   ```

1. Copie o seguinte no arquivo `pom.xml` e salve-o:

   ```
   <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 estiver modificando um projeto existente do Maven, a dependência necessária será destacada no código anterior.

1. Crie subdiretórios para o código-fonte de exemplo (`src/main/java/com/amazonaws/`) digitando o seguinte na linha de comando:

   ```
   mkdir -p src/main/java/com/amazonaws/
   ```

1. No diretório `src/main/java/com/amazonaws/`, crie um arquivo denominado `App.java` e abra-o em um editor de texto.

   ```
   nano src/main/java/com/amazonaws/App.java
   ```

1. Copie o seguinte no arquivo `App.java`. *your-neptune-endpoint*Substitua pelo endereço da sua instância de banco de dados Neptune. *Não* inclua o prefixo `https://` no método `addContactPoint`.
**nota**  
Para obter informações sobre como localizar o nome do host da instância de banco de dados do Neptune, consulte [Conectar-se a endpoints do 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 obter ajuda na conexão com Neptune SSL/TLS com (o que é obrigatório), consulte. [Configuração de SSL/TLS](#access-graph-gremlin-java-ssl)

1. Compile e execute o exemplo usando o seguinte comando do Maven:

   ```
   mvn compile exec:exec
   ```

O exemplo anterior retorna um mapa da chave e dos valores de cada propriedade dos dois primeiros vértices no gráfico usando a travessia `g.V().limit(3).elementMap()`. Para consultar outro elemento, substitua-a por outra travessia do Gremlin com um dos métodos de término adequado.

**nota**  
A parte final da consulta do Gremlin, `.toList()`, é necessária para enviar a travessia ao servidor para avaliação. Se você não incluir esse método ou outro método equivalente, a consulta não será enviada à instância de banco de dados do Neptune.  
Você também deve associar uma terminação adequada ao adicionar um vértice ou uma borda, por exemplo, ao usar a etapa `addV( )`.

Os seguintes métodos enviam a consulta à instância de banco de dados do Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`

## Configuração de SSL/TLS para o cliente Java do Gremlin
<a name="access-graph-gremlin-java-ssl"></a>

O Neptune SSL/TLS precisa estar ativado por padrão. Normalmente, se o driver Java estiver configurado com `enableSsl(true)`, ele poderá se conectar ao Neptune sem precisar configurar um `trustStore()` ou um `keyStore()` com uma cópia local de um certificado.

No entanto, se a instância com a qual você está se conectando não tiver conexão com a Internet para verificar um certificado público, ou se o certificado utilizado não for público, siga estas etapas para configurar uma cópia do certificado local:

**Configurar uma cópia de certificado local para habilitar SSL/TLS**

1. Baixe e instale o [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) da Oracle. Isso facilitará muito a configuração do armazenamento de chaves local.

1. Baixe um certificado CA `SFSRootCAG2.pem` (o SDK Java do Gremlin exige um certificado para verificar o certificado remoto):

   ```
   wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
   ```

1. Crie um armazenamento de chaves em JKS ou PKCS12 formato. Este exemplo usa JKS. Responda às perguntas que se seguem no prompt. A senha que você criar aqui será necessária posteriormente:

   ```
   keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
   ```

1. Importe o arquivo `SFSRootCAG2.pem` que você baixou para o repositório de chaves recém-criado:

   ```
   keytool -import -keystore server.jks -file .pem
   ```

1. Configure o objeto `Cluster` programaticamente:

   ```
   Cluster cluster = Cluster.build("(your neptune endpoint)")
                            .port(8182)
                            .enableSSL(true)
                            .keyStore(‘server.jks’)
                            .keyStorePassword("(the password from step 2)")
                            .create();
   ```

   Se desejar, você poderá fazer o mesmo em um arquivo de configuração, como faria com o console do 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 }}
   ```

## Autenticação do IAM
<a name="access-graph-gremlin-java-iam"></a>

O Neptune [oferece suporte à autenticação do IAM](iam-auth-enable.md) para controlar o acesso ao seu cluster de banco de dados. Se você tiver a autenticação do IAM ativada, precisará usar a assinatura Signature versão 4 para autenticar suas solicitações. Para obter instruções detalhadas e exemplos de código para se conectar a partir de um cliente Java, consulte[Conectar-se a bancos de dados do Amazon Neptune usando o IAM com o Gremlin Java](iam-auth-connecting-gremlin-java.md).