Utilisation du client Java pour se connecter à une instance de base de données Neptune

La section suivante explique l'exécution d'un exemple Java complet qui se connecte à une instance de base de données Neptune et effectue une traversée de Gremlin à l'aide du client Apache Gremlin. TinkerPop

Vous devez suivre ces instructions à partir d'une instance Amazon EC2 située dans le même cloud privé virtuel (VPC) (VPC) que l'instance de base de données Neptune.

Pour se connecter à Neptune à l'aide de Java

Installez Apache Maven sur votre instance EC2. D'abord, saisissez la commande suivante pour ajouter un référentiel avec un package Maven :
```
sudo wget https://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
```
Entrez la commande suivante pour définir le numéro de version des packages :
```
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
```
Utilisez ensuite yum pour installer Maven :
```
sudo yum install -y apache-maven
```
Installez Java. Les bibliothèques Gremlin nécessitent Java 8 ou 11. Vous pouvez installer Java 11 comme suit :
- Si vous utilisez Amazon Linux 2 (AL2) :
```
sudo amazon-linux-extras install java-openjdk11
```
- Si vous utilisez Amazon Linux 2023 (AL2023) :
```
sudo yum install java-11-amazon-corretto-devel
```
- Pour les autres distributions, utilisez l'instruction qui convient le mieux parmi les suivantes :
```
sudo yum install java-11-openjdk-devel
```
  ou :
```
sudo apt-get install openjdk-11-jdk
```
Définissez Java 11 comme environnement d'exécution par défaut sur votre instance EC2 : entrez ce qui suit pour définir Java 8 comme environnement d'exécution par défaut sur l'instance EC2 :
```
sudo /usr/sbin/alternatives --config java
```
Lorsque vous y êtes invité, saisissez le nombre correspondant à Java 11.
Créez un répertoire appelé gremlinjava :
```
mkdir gremlinjava
cd gremlinjava
```
Dans le répertoire gremlinjava, créez un fichier pom.xml, puis ouvrez-le dans un éditeur de texte:
```
nano pom.xml
```

Copiez ce qui suit dans le fichier pom.xml et enregistrez-le:


<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.6.5</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.tinkerpop/gremlin-groovy
      (Not needed for TinkerPop version 3.5.2 and up)
    <dependency>
      <groupId>org.apache.tinkerpop</groupId>
      <artifactId>gremlin-groovy</artifactId>
      <version>3.6.5</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>

Note

Si vous modifiez un projet Maven existant, la dépendance obligatoire est mise en évidence dans le code précédent.

Créez des sous-répertoires pour l'exemple de code source (src/main/java/com/amazonaws/) en saisissant ce qui suit sur la ligne de commande :
```
mkdir -p src/main/java/com/amazonaws/
```
Dans le répertoire src/main/java/com/amazonaws/, créez un fichier App.java, puis ouvrez-le dans un éditeur de texte.
```
nano src/main/java/com/amazonaws/App.java
```

Copiez ce qui suit dans le fichier App.java. Remplacez your-neptune-endpointpar l'adresse de votre instance de base de données Neptune. N’incluez pas le préfixe https:// dans la méthode addContactPoint.

Note

Pour découvrir comment trouver le nom d'hôte de l'instance de base de données Neptune, consultez la section Connexion aux points de terminaison Amazon Neptune.


package com.amazonaws;
import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.apache.tinkerpop.gremlin.driver.Client;
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.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();
  }
}

Pour obtenir de l'aide sur la connexion à Neptune via SSL/TLS (obligatoire), consultez Configuration SSL/TLS.

Compilez et exécutez l'exemple à l'aide de la commande Maven suivante :
```
mvn compile exec:exec
```

L'exemple précédent renvoie une carte de la clé et les valeurs de chaque propriété pour les deux premiers vertex du graphe à l'aide de la traversée g.V().limit(3).elementMap(). Pour interroger quelque chose d'autre, remplacez la traversée par une autre traversée Gremlin avec l'une des méthodes de fin appropriées.

Note

La partie finale de la requête Gremlin, .toList(), est obligatoire pour soumettre la traversée au serveur à des fins d'évaluation. Si vous n'incluez pas cette méthode ou une autre méthode équivalente, la requête ne sera pas soumise à l'instance de base de données Neptune.

Vous devez également ajouter une terminaison appropriée lorsque vous ajoutez un sommet ou une arête, comme lorsque vous utilisez l'étape addV( ).

Les méthodes suivantes soumettent la requête à l'instance de base de données Neptune :

toList()
toSet()
next()
nextTraverser()
iterate()

Configuration SSL/TLS pour le client Java Gremlin

Neptune nécessite que le protocole SSL/TLS soit activé par défaut. Généralement, si le pilote Java est configuré avec enableSsl(true), il peut se connecter à Neptune sans avoir à configurer trustStore() ou keyStore() avec une copie locale d'un certificat. Les versions antérieures de l'utilisation TinkerPop encourageaient l'utilisation de keyCertChainFile() pour configurer un .pem fichier stocké localement, mais celle-ci est devenue obsolète et n'est plus disponible après la version 3.5.x. Si vous utilisiez cette configuration avec un certificat public, avec SFSRootCAG2.pem, vous pouvez désormais supprimer la copie locale.

Toutefois, si l'instance à laquelle vous vous connectez ne dispose pas d'une connexion Internet permettant de vérifier un certificat public ou si le certificat que vous utilisez n'est pas public, vous pouvez suivre les étapes ci-dessous pour configurer une copie du certificat local :

Configuration d'une copie du certificat local pour activer le protocole SSL/TLS

Téléchargez et installez keytool depuis Oracle. Cela facilitera grandement la configuration du magasin de clés local.
Téléchargez le certificat CA SFSRootCAG2.pem (le kit SDK Java Gremlin a besoin d'un certificat pour vérifier le certificat à distance).
```
wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
```
Créez un magasin de clés au format JKS ou PKCS12. Cet exemple utilise JKS. Répondez aux questions qui suivent à l'invite. Le mot de passe que vous créez ici sera nécessaire ultérieurement :
```
keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
```
Importez le fichier SFSRootCAG2.pem que vous avez téléchargé dans le magasin de clés que vous venez de créer :
```
keytool -import -keystore server.jks -file .pem
```

Configurez l'objet Cluster par programmation :



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

Vous pouvez faire la même chose dans un fichier de configuration si vous le souhaitez, comme vous pourriez le faire avec 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.driver.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Java

Exemple de reconnexion Java