Verwenden des AWS SDK zum Ausführen von Gremlin-Abfragen

Mit dem AWS SDK können Sie Gremlin-Abfragen für Ihr Neptune-Diagramm mit einer Programmiersprache Ihrer Wahl ausführen. Das Neptune Data API SDK (Dienstnameneptunedata) bietet die ExecuteGremlinQueryAktion zum Senden von Gremlin-Abfragen.

Sie müssen diese Beispiele von einer Amazon EC2 EC2-Instance in derselben Virtual Private Cloud (VPC) wie Ihr Neptune-DB-Cluster oder von einem Standort aus ausführen, der über eine Netzwerkverbindung zu Ihrem Cluster-Endpunkt verfügt.

Direkte Links zur API-Referenzdokumentation für den neptunedata Service in jeder SDK-Sprache finden Sie unten:

Programmiersprache	Neptunedata API-Referenz
C++	https://sdk.amazonaws.com/cpp/api/LATEST/aws-cpp-sdk-neptunedata/html/annotated.html
Go	https://docs.aws.amazon.com/sdk-for-go/api/service/neptunedata/
Java	https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/neptunedata/package-summary.html
JavaScript	https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptunedata/
Kotlin	https://sdk.amazonaws.com/kotlin/api/latest/neptunedata/index.html
.NET	https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Neptunedata/NNeptunedata.html
PHP	https://docs.aws.amazon.com/aws-sdk-php/v3/api/namespace-Aws.Neptunedata.html
Python	https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/neptunedata.html
Ruby	https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Neptunedata.html
Rust	https://crates.io/crates/aws-sdk-neptunedata
CLI	https://docs.aws.amazon.com/cli/latest/reference/neptunedata/

Gremlin SDK-Beispiele AWS

Die folgenden Beispiele zeigen, wie Sie einen neptunedata Client einrichten, eine Gremlin-Abfrage ausführen und die Ergebnisse drucken. Ersetzen Sie YOUR_NEPTUNE_HOST und YOUR_NEPTUNE_PORT durch den Endpunkt und Port Ihres Neptune-DB-Clusters.

Clientseitiges Timeout und Konfiguration erneut versuchen

Das SDK-Client-Timeout steuert, wie lange der Client auf eine Antwort wartet. Es steuert nicht, wie lange die Abfrage auf dem Server ausgeführt wird. Wenn der Client das Timeout überschreitet, bevor der Server fertig ist, wird die Abfrage möglicherweise weiterhin auf Neptune ausgeführt, während der Client keine Möglichkeit hat, die Ergebnisse abzurufen.

Wir empfehlen, das clientseitige Lese-Timeout auf 0 (kein Timeout) oder auf einen Wert zu setzen, der mindestens ein paar Sekunden länger ist als die serverseitige neptune_query_timeout-Einstellung auf Ihrem Neptune-DB-Cluster. Auf diese Weise kann Neptune kontrollieren, wann das Timeout bei Abfragen abläuft.

Wir empfehlen außerdem, die maximale Anzahl an Wiederholungsversuchen auf 1 (keine Wiederholungsversuche) festzulegen. Wenn das SDK eine Abfrage wiederholt, die noch auf dem Server ausgeführt wird, kann dies zu doppelten Vorgängen führen. Dies ist besonders wichtig bei Mutationsabfragen, bei denen ein erneuter Versuch zu unbeabsichtigten doppelten Schreibvorgängen führen kann.

Python

1. Folgen Sie den Installationsanweisungen, um Boto3 zu installieren.

2. Erstellen Sie eine Datei mit dem Namen gremlinExample.py und fügen Sie den folgenden Code ein:

   import boto3
   import json
   from botocore.config import Config
   
   # Disable the client-side read timeout and retries so that
   # Neptune's server-side neptune_query_timeout controls query duration.
   client = boto3.client(
       'neptunedata',
       endpoint_url=f'https://YOUR_NEPTUNE_HOST:YOUR_NEPTUNE_PORT',
       config=Config(read_timeout=None, retries={'total_max_attempts': 1})
   )
   
   # Use the untyped GraphSON v3 serializer for a cleaner JSON response.
   response = client.execute_gremlin_query(
       gremlinQuery='g.V().limit(1)',
       serializer='application/vnd.gremlin-v3.0+json;types=false'
   )
   
   print(json.dumps(response['result'], indent=2))

3. Führen Sie das Beispiel aus: python gremlinExample.py

Java

1. Folgen Sie den Installationsanweisungen, um das AWS SDK for Java einzurichten.

2. Verwenden Sie den folgenden Code, um eine Gremlin-Abfrage einzurichtenNeptunedataClient, eine Gremlin-Abfrage auszuführen und das Ergebnis auszudrucken:

   import java.net.URI;
   import java.time.Duration;
   import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
   import software.amazon.awssdk.core.retry.RetryPolicy;
   import software.amazon.awssdk.services.neptunedata.NeptunedataClient;
   import software.amazon.awssdk.services.neptunedata.model.ExecuteGremlinQueryRequest;
   import software.amazon.awssdk.services.neptunedata.model.ExecuteGremlinQueryResponse;
   
   // Disable the client-side timeout and retries so that
   // Neptune's server-side neptune_query_timeout controls query duration.
   NeptunedataClient client = NeptunedataClient.builder()
       .endpointOverride(URI.create("https://YOUR_NEPTUNE_HOST:YOUR_NEPTUNE_PORT"))
       .overrideConfiguration(ClientOverrideConfiguration.builder()
           .apiCallTimeout(Duration.ZERO)
           .retryPolicy(RetryPolicy.none())
           .build())
       .build();
   
   // Use the untyped GraphSON v3 serializer for a cleaner JSON response.
   ExecuteGremlinQueryRequest request = ExecuteGremlinQueryRequest.builder()
       .gremlinQuery("g.V().limit(1)")
       .serializer("application/vnd.gremlin-v3.0+json;types=false")
       .build();
   
   ExecuteGremlinQueryResponse response = client.executeGremlinQuery(request);
   
   System.out.println(response.result().toString());

JavaScript

1. Folgen Sie den Installationsanweisungen, um das AWS SDK für einzurichten. JavaScript Installieren Sie das Neptunedata-Client-Paket:. npm install @aws-sdk/client-neptunedata

2. Erstellen Sie eine Datei mit dem Namen gremlinExample.js und fügen Sie den folgenden Code ein:

   import { NeptunedataClient, ExecuteGremlinQueryCommand } from "@aws-sdk/client-neptunedata";
   import { NodeHttpHandler } from "@smithy/node-http-handler";
   
   const config = {
       endpoint: "https://YOUR_NEPTUNE_HOST:YOUR_NEPTUNE_PORT",
       // Disable the client-side request timeout so that
       // Neptune's server-side neptune_query_timeout controls query duration.
       requestHandler: new NodeHttpHandler({
           requestTimeout: 0
       }),
       maxAttempts: 1
   };
   
   const client = new NeptunedataClient(config);
   
   // Use the untyped GraphSON v3 serializer for a cleaner JSON response.
   const input = {
       gremlinQuery: "g.V().limit(1)",
       serializer: "application/vnd.gremlin-v3.0+json;types=false"
   };
   
   const command = new ExecuteGremlinQueryCommand(input);
   const response = await client.send(command);
   
   console.log(JSON.stringify(response, null, 2));

3. Führen Sie das Beispiel aus: node gremlinExample.js