Utiliser le AWS SDK pour exécuter des requêtes Gremlin - Amazon Neptune
Exemples

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utiliser le AWS SDK pour exécuter des requêtes Gremlin

Avec le AWS SDK, vous pouvez exécuter des requêtes G705 sur votre graphe Neptune à l'aide du langage de programmation de votre choix. Le SDK de l'API de données Neptune (nom du serviceneptunedata) fournit l'ExecuteGremlinQueryaction permettant de soumettre des requêtes Gremlin.

Vous devez exécuter ces exemples depuis une instance Amazon EC2 dans le même cloud privé virtuel (VPC) que votre cluster de base de données Neptune, ou depuis un emplacement disposant d'une connectivité réseau avec le point de terminaison de votre cluster.

Vous trouverez ci-dessous des liens directs vers la documentation de référence neptunedata de l'API pour le service dans chaque langue du SDK :

Langage de programmation Référence de l'API neptunedata

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

INTERFACE DE LIGNE DE COMMANDE (CLI)

https://docs.aws.amazon.com/cli/latest/reference/neptunedata/

Exemples du AWS SDK Gremlin

Les exemples suivants montrent comment configurer un neptunedata client, exécuter une requête Gremlin et imprimer les résultats. Remplacez YOUR_NEPTUNE_HOST et YOUR_NEPTUNE_PORT par le point de terminaison et le port de votre cluster de base de données Neptune.

Configuration du délai d'expiration et des nouvelles tentatives côté client

Le délai d'attente du client SDK contrôle le temps d'attente d'une réponse par le client. Il ne contrôle pas la durée d'exécution de la requête sur le serveur. Si le client expire avant la fin du serveur, la requête peut continuer à s'exécuter sur Neptune alors que le client n'a aucun moyen de récupérer les résultats.

Nous vous recommandons de définir le délai de lecture côté client sur 0 (aucun délai d'attente) ou sur une valeur supérieure d'au moins quelques secondes au paramètre neptune_query_timeout côté serveur sur votre cluster de base de données Neptune. Cela permet à Neptune de contrôler l'expiration du délai d'expiration des requêtes.

Nous recommandons également de fixer le nombre maximum de tentatives à 1 (aucune tentative). Si le SDK réessaie une requête toujours en cours d'exécution sur le serveur, cela peut entraîner des opérations dupliquées. Cela est particulièrement important pour les requêtes de mutation, où une nouvelle tentative peut entraîner des écritures dupliquées involontaires.

Python

  1. Suivez les instructions d'installation pour installer Boto3.

  2. Créez un fichier nommé gremlinExample.py et collez le code suivant :

    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. Exécutez l'exemple : python gremlinExample.py

Java

  1. Suivez les instructions d'installation pour configurer le AWS SDK for Java.

  2. Utilisez le code suivant pour configurer uneNeptunedataClient, exécuter une requête Gremlin et imprimer le résultat :

    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. Suivez les instructions d'installation pour configurer le AWS SDK pour JavaScript. Installez le package client neptunedata :. npm install @aws-sdk/client-neptunedata

  2. Créez un fichier nommé gremlinExample.js et collez le code suivant :

    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. Exécutez l'exemple : node gremlinExample.js