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.

Points de terminaison publics Neptune

Présentation de

Les clusters Amazon Neptune sont généralement déployés au sein de votre VPC et ne sont accessibles que depuis ce VPC. Cela nécessite de configurer les applications et les environnements de développement au sein du VPC ou d'utiliser des services proxy pour se connecter au VPC, ce qui augmente le temps et les coûts de configuration.

Les terminaux publics simplifient cette expérience en permettant des connexions directes à Neptune via Internet, ce qui facilite la prise en main des bases de données graphiques sans connaissances spécialisées en matière de réseau.

Quand utiliser les points de terminaison publics

Envisagez d'utiliser des points de terminaison publics dans les scénarios suivants :

Considérations sur la sécurité

Lorsque vous utilisez des terminaux publics, tenez compte des considérations de sécurité suivantes :

Activation des terminaux publics

Par défaut, les nouvelles bases de données Neptune sont créées avec les points de terminaison publics désactivés. Vous devez explicitement activer l'accès public lors de la création ou de la modification d'un cluster.

Les points de terminaison publics sont pris en charge à partir de la version 1.4.6.x du moteur Neptune. Vous devez mettre à niveau les clusters existants vers au moins cette version pour utiliser cette fonctionnalité.

Le paramètre de point de terminaison public est disponible sur l'instance Neptune et non sur le cluster Neptune. Par conséquent, un cluster Neptune peut exister avec certaines instances avec des points de terminaison publics et d'autres non. Cependant, nous ne recommandons pas d'utiliser un tel réglage. Pour plus d'informations à ce sujet, consultez : Comment fonctionnent les terminaux publics

Conditions préalables

Paramètre d'authentification IAM sur le cluster Neptune

Avant d'activer les points de terminaison publics sur une instance Neptune, assurez-vous que votre cluster prend en charge l'authentification IAM. Si ce n'est pas le cas, activez-le à l'aide de la commande suivante :

aws neptune modify-db-cluster \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-cluster-identifier neptune-public-endpoint \
  --enable-iam-database-authentication

Paramètres réseau

Création d'une nouvelle instance avec des points de terminaison publics

Vous pouvez créer une nouvelle instance Neptune avec des points de terminaison publics à l'aide de la console de AWS gestion, de la AWS CLI ou AWS du SDK.

À l'aide de la AWS CLI :

aws neptune create-db-instance \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-cluster-identifier neptune-public-endpoint \
  --publicly-accessible

Modifier une instance existante pour un accès public

Pour modifier une instance Neptune existante afin de permettre l'accès public :

aws neptune modify-db-instance \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-instance-identifier neptune-public-endpoint \
  --publicly-accessible

Utilisation des points de terminaison publics

Pour vérifier si votre base de données est accessible, vérifiez son état à l'aide de l'NeptuneDataAPI AWS CLI :

aws neptunedata get-engine-status \
  --endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

Si la base de données est accessible, la réponse est la suivante :

{
    "status": "healthy",
    "startTime": "Sun Aug 10 06:54:15 UTC 2025",
    "dbEngineVersion": "1.4.6.0.R1",
    "role": "writer",
    "dfeQueryEngine": "viaQueryHint",
    "gremlin": {
        "version": "tinkerpop-3.7.1"
    },
    "sparql": {
        "version": "sparql-1.1"
    },
    "opencypher": {
        "version": "Neptune-9.0.20190305-1.0"
    },
    "labMode": {
        "ObjectIndex": "disabled",
        "ReadWriteConflictDetection": "enabled"
    },
    "features": {
        "SlowQueryLogs": "disabled",
        "InlineServerGeneratedEdgeId": "disabled",
        "ResultCache": {
            "status": "disabled"
        },
        "IAMAuthentication": "disabled",
        "Streams": "disabled",
        "AuditLog": "disabled"
    },
    "settings": {
        "StrictTimeoutValidation": "true",
        "clusterQueryTimeoutInMs": "120000",
        "SlowQueryLogsThreshold": "5000"
    }
}

Exemples d'interrogation de la base de données

AWS INTERFACE DE LIGNE DE COMMANDE (CLI)

aws neptunedata execute-open-cypher-query \
--open-cypher-query "MATCH (n) RETURN n LIMIT 10" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

Python

import boto3
import json
from botocore.config import Config

# Configuration - Replace with your actual Neptune cluster details
cluster_endpoint = "my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com"
port = 8182
region = "my-region"

# Configure Neptune client
# This disables retries and sets the client timeout to infinite 
#     (relying on Neptune's query timeout)
endpoint_url = f"https://{cluster_endpoint}:{port}"
config = Config(
    region_name=region,
    retries={'max_attempts': 1},
    read_timeout=None
)

client = boto3.client("neptunedata", config=config, endpoint_url=endpoint_url)

cypher_query = "MATCH (n) RETURN n LIMIT 5"
try:
    response = client.execute_open_cypher_query(openCypherQuery=cypher_query)
    print("openCypher Results:")
    for item in response.get('results', []):
        print(f"  {item}")
except Exception as e:
    print(f"openCypher query failed: {e}")

JavaScript

import {
    NeptunedataClient,
    GetPropertygraphSummaryCommand
} from "@aws-sdk/client-neptunedata";
import { inspect } from "util";
import { NodeHttpHandler } from "@smithy/node-http-handler";

/**
 * Main execution function
 */
async function main() {
    // Configuration - Replace with your actual Neptune cluster details
    const clusterEndpoint = 'my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com';
    const port = 8182;
    const region = 'my-region';

    // Configure Neptune client
    // This disables retries and sets the client timeout to infinite 
    //     (relying on Neptune's query timeout)
    const endpoint = `https://${clusterEndpoint}:${port}`;
    const clientConfig = {
        endpoint: endpoint,
        sslEnabled: true,
        region: region,
        maxAttempts: 1,  // do not retry
        requestHandler: new NodeHttpHandler({
            requestTimeout: 0  // no client timeout
        })
    };

    const client = new NeptunedataClient(clientConfig);
    try {
        try {
            const command = new GetPropertygraphSummaryCommand({ mode: "basic" });
            const response = await client.send(command);
            console.log("Graph Summary:", inspect(response.payload, { depth: null }));
        } catch (error) {
            console.log("Property graph summary failed:", error.message);
        }    
    } catch (error) {
        console.error("Error in main execution:", error);
    }
}

// Run the main function
main().catch(console.error);

Go

package main
import (
    "context"
    "fmt"
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/neptunedata"
    "os"
    "encoding/json"
    "net/http"
)

func main() {    
    // Configuration - Replace with your actual Neptune cluster details
    clusterEndpoint := "my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com"
    port := 8182
    region := "my-region"
    
    // Configure Neptune client
    // Configure HTTP client with no timeout
    //    (relying on Neptune's query timeout)
    endpoint := fmt.Sprintf("https://%s:%d", clusterEndpoint, port)
    // Load AWS SDK configuration
    sdkConfig, _ := config.LoadDefaultConfig(
        context.TODO(),
        config.WithRegion(region),
        config.WithHTTPClient(&http.Client{Timeout: 0}),
    )
    
    // Create Neptune client with custom endpoint
    client := neptunedata.NewFromConfig(sdkConfig, func(o *neptunedata.Options) {
        o.BaseEndpoint = aws.String(endpoint)
        o.Retryer = aws.NopRetryer{} // Do not retry calls if they fail
    })

    gremlinQuery := "g.addV('person').property('name','charlie').property(id,'charlie-1')"
    serializer := "application/vnd.gremlin-v1.0+json;types=false"
    
    gremlinInput := &neptunedata.ExecuteGremlinQueryInput{
        GremlinQuery: &gremlinQuery,
        Serializer:   &serializer,
    }
    gremlinResult, err := client.ExecuteGremlinQuery(context.TODO(), gremlinInput)
    if err != nil {
        fmt.Printf("Gremlin query failed: %v\n", err)
    } else {
        var resultMap map[string]interface{}
        err = gremlinResult.Result.UnmarshalSmithyDocument(&resultMap)
        if err != nil {
            fmt.Printf("Error unmarshaling Gremlin result: %v\n", err)
        } else {
            resultJSON, _ := json.MarshalIndent(resultMap, "", "  ")
            fmt.Printf("Gremlin Result: %s\n", string(resultJSON))
        }
    }
}

Comment fonctionnent les terminaux publics

Lorsqu'une instance de Neptune est accessible au public :

Comportement des terminaux du lecteur

Comportement des terminaux du cluster

Comportement après le basculement du cluster

Exigences en matière de configuration du réseau

Pour que les terminaux publics fonctionnent correctement :

Restreindre la création d'accès public

Vous pouvez utiliser les politiques IAM pour restreindre les personnes autorisées à créer ou à modifier des clusters Neptune accessibles au public. L'exemple de politique suivant interdit la création d'instances Neptune avec un accès public :

JSON

{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Action": [
        "rds:CreateDBInstance",
        "rds:ModifyDBInstance",
        "rds:RestoreDBInstanceFromDBSnapshot",
        "rds:RestoreDBInstanceToPointInTime"
      ],
      "Resource": "*",
      "Condition": {
        "Bool": {
          "rds:PubliclyAccessible": true
        }
      }
    }
  ]
}

Pour en savoir plus sur la clé de condition rds:PublicAccessEnabled IAM : Référence d'autorisation du service Amazon RDS

CloudFormation Prise en charge de par la  

Vous pouvez l'utiliser CloudFormation pour lancer des clusters Neptune avec des points de terminaison publics activés en spécifiant le PubliclyAccessible paramètre dans votre CloudFormation modèle.

Compatibilité avec les fonctionnalités de Neptune

Un cluster sur lequel les points de terminaison publics sont activés prend en charge toutes les fonctionnalités de Neptune prises en charge par un VPC-only cluster, notamment :

Tarification

Les terminaux publics sont disponibles sans frais supplémentaires au-delà de la tarification standard de Neptune. Cependant, la connexion de votre environnement local à Neptune via une adresse IP publique peut entraîner une augmentation des coûts de transfert de données.