Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Herstellen einer Verbindung zu einer Neptune-DB-Instance über einen Java-Client
<a name="access-graph-gremlin-java"></a>

Der folgende Abschnitt führt Sie durch die Ausführung eines vollständigen Java-Beispiels, das eine Verbindung zu einer Neptune-DB-Instance herstellt und mithilfe des Apache Gremlin-Clients eine Gremlin-Traversal durchführt. TinkerPop

Sie müssen diese Anweisungen für eine Amazon-EC2-Instance befolgen, die sich in derselben Virtual Private Cloud (VPC) wie Ihre Neptune-DB-Instance befindet.

**Herstellen einer Verbindung mit Neptune über Java**

1. Installieren Sie Apache Maven auf Ihrer EC2-Instance. Wenn Sie Amazon Linux 2023 (bevorzugt) verwenden, verwenden Sie:

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

   Wenn Sie Amazon Linux 2 verwenden, laden Sie die neueste Binärdatei von [https://maven.apache.org/download.cgi herunter:](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. **Installieren Sie Java.** Die Gremlin-Bibliotheken erfordern Java 8 oder 11. Sie können Java 11 wie folgt installieren:
   + Wenn Sie [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2) verwenden:

     ```
     sudo amazon-linux-extras install java-openjdk11
     ```
   + Wenn Sie [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html) verwenden:

     ```
     sudo yum install java-11-amazon-corretto-devel
     ```
   + Verwenden Sie für andere Distributionen die jeweils zutreffende Anweisung:

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

     oder:

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

1. **Legen Sie Java 11 als Standardlaufzeit für Ihre EC2-Instance fest:** Geben Sie Folgendes ein, um Java 11 als Standardlaufzeit für Ihre EC2-Instance festzulegen:

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

   Geben Sie die Nummer für Java 11 ein, wenn Sie aufgefordert werden.

1. **Erstellen Sie ein neues Verzeichnis mit dem Namen `gremlinjava`:**

   ```
   mkdir gremlinjava
   cd gremlinjava
   ```

1.  Erstellen Sie im Verzeichnis `gremlinjava` eine `pom.xml`-Datei und öffnen Sie diese in einem Text-Editor:

   ```
   nano pom.xml
   ```

1. Kopieren Sie Folgendes in die `pom.xml`-Datei und speichern Sie sie:

   ```
   <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>
   ```
**Anmerkung**  
Wenn Sie ein vorhandenes Maven-Projekt ändern, ist die erforderliche Abhängigkeit im vorhergehenden Code hervorgehoben.

1. Erstellen Sie Unterverzeichnisse für den Beispielquellcode (`src/main/java/com/amazonaws/`), indem Sie Folgendes in die Befehlszeile eingeben:

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

1. Erstellen Sie im Verzeichnis `src/main/java/com/amazonaws/` eine Datei namens `App.java` und öffnen Sie diese dann in einem Text-Editor.

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

1. Kopieren Sie Folgendes in die `App.java`-Datei. *your-neptune-endpoint*Ersetzen Sie durch die Adresse Ihrer Neptune-DB-Instance. Sie dürfen das Präfix `https://` *nicht* in die Methode `addContactPoint` einfügen.
**Anmerkung**  
Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie in [Verbinden mit Amazo-Neptune-Endpunkten](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();
     }
   }
   ```

   Hilfe zum Herstellen einer Verbindung mit Neptune mit SSL/TLS (was erforderlich ist) finden Sie unter. [SSL/TLS-Konfiguration](#access-graph-gremlin-java-ssl)

1. Nutzen Sie folgenden Maven-Befehl, um das Beispiel zu kompilieren und auszuführen:

   ```
   mvn compile exec:exec
   ```

Das vorherige Beispiel gibt über die `g.V().limit(3).elementMap()`-Traversierung eine Übersicht der Schlüssel und Werte der einzelnen Eigenschaften für die ersten beiden Knoten im Diagramm zurück. Um etwas anderes abzufragen, ersetzen Sie diese durch eine andere Gremlin-Traversierung mit einer der entsprechenden Ending-Methoden.

**Anmerkung**  
Der letzte Teil der Gremlin-Abfrage, `.toList()`, ist für die Übermittlung der Traversierung zur Auswertung an den Server erforderlich. Wenn Sie diese oder eine gleichwertige Methode nicht einschließen, wird die Abfrage nicht an die Neptune-DB-Instance übermittelt.  
Sie müssen auch eine geeignete Endung anfügen, wenn Sie einen Eckpunkt oder eine Kante hinzufügen, wie beim Schritt `addV( )`.

Die folgenden Methoden senden die Abfrage an die Neptune-DB-Instance:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`

## SSL/TLS-Konfiguration für den Gremlin-Java-Client
<a name="access-graph-gremlin-java-ssl"></a>

Neptune SSL/TLS muss standardmäßig aktiviert sein. Wenn der Java-Treiber mit `enableSsl(true)` konfiguriert ist, kann er in der Regel eine Verbindung mit Neptune herstellen, ohne einen `trustStore()` oder `keyStore()` mit der lokalen Kopie eines Zertifikats einrichten zu müssen.

Wenn die Instance, mit der Sie eine Verbindung herstellen, keine Internetverbindung hat, um ein öffentliches Zertifikat zu verifizieren, oder wenn das verwendete Zertifikat nicht öffentlich ist, können Sie zur Konfiguration einer lokalen Zertifikatkopie die folgenden Schritte ausführen:

**Einrichten einer lokalen Zertifikatkopie zur Aktivierung von SSL/TLS**

1. Laden Sie [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) von Oracle herunter und installieren Sie es. Dies vereinfacht die Einrichtung des lokalen Schlüsselspeichers erheblich.

1. Laden Sie das `SFSRootCAG2.pem`-CA-Zertifikat herunter (das Gremlin-Java-SDK erfordert ein Zertifikat, um das Remote-Zertifikat zu verifizieren):

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

1. Erstellen Sie einen Schlüsselspeicher entweder im JKS- oder im Format. PKCS12 In diesem Beispiel wird JKS verwendet. Beantworten Sie die Fragen an der Eingabeaufforderung. Das hier erstellte Passwort wird später benötigt:

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

1. Importieren Sie die heruntergeladene Datei `SFSRootCAG2.pem` in den neu erstellten Schlüsselspeicher:

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

1. Konfigurieren Sie das `Cluster`-Objekt programmgesteuert:

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

   Sie können dies auch in einer Konfigurationsdatei ausführen, wenn Sie möchten, wie im Fall der Gremlin-Konsole:

   ```
   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 }}
   ```

## IAM-Authentifizierung
<a name="access-graph-gremlin-java-iam"></a>

Neptune unterstützt die [IAM-Authentifizierung](iam-auth-enable.md), um den Zugriff auf Ihren DB-Cluster zu kontrollieren. Wenn Sie die IAM-Authentifizierung aktiviert haben, müssen Sie die Signature Version 4-Signatur verwenden, um Ihre Anfragen zu authentifizieren. Ausführliche Anweisungen und Codebeispiele für die Verbindung von einem Java-Client aus finden Sie unter. [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java](iam-auth-connecting-gremlin-java.md)