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. [SSL/TLS configuração](#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( )`.

Veja a seguir exemplos de métodos que enviam a consulta para a instância de banco de dados Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `iterate()`

Use `iterate()` quando não precisar dos resultados de suas consultas (por exemplo, mutações), pois isso economiza custos de serialização.

Essas etapas do terminal se comportam de forma diferente, dependendo se você envia consultas como strings (modo script) ou como objetos de passagem de bytecode (modo bytecode). As diferenças são especialmente importantes para o tratamento de transações. Para obter detalhes, consulte [Testar o código do Gremlin no contexto em que você o implantará](best-practices-gremlin-console-glv-differences.md).

## SSL/TLS configuração para o cliente Gremlin Java
<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:

**Configurando uma cópia local do certificado 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 no formato JKS ou PKCS12. 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).