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

Les clusters Amazon Neptune sont généralement déployés au sein de votre VPC et ne sont accessibles qu'à partir de ce VPC. Cela nécessite de configurer des applications et des 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 points de terminaison publics simplifient cette expérience en permettant des connexions directes à Neptune via Internet, ce qui permet de démarrer plus facilement avec des bases de données de graphes sans connaissances spécifiques en matière de réseau.

Quand utiliser des 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 points de terminaison publics, tenez compte des considérations de sécurité suivantes :

Activation des points de terminaison 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. Toutefois, nous ne recommandons pas d'utiliser un tel paramètre. Pour plus d'informations à ce sujet, reportez-vous à : Fonctionnement des points de terminaison publics

Prérequis

Paramètre d'authentification IAM sur le cluster Neptune

Avant d'activer des points de terminaison publics sur une instance Neptune, assurez-vous que votre cluster prend en charge l'authentification IAM. Sinon, 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

Network settings (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 du SDK. AWS

À 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

Modification d'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 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 points de terminaison publics

Lorsqu'une instance Neptune est accessible au public :

Comportement du terminal du lecteur

Comportement des terminaux du cluster

Comportement après le basculement d'un cluster

Exigences en matière de configuration du réseau

Pour que les points de terminaison 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 avec un accès public. L'exemple de politique suivant refuse la création d'instances Neptune accessibles au public :

JSON

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

En savoir plus sur la clé de condition rds:PublicAccessEnabled IAM : Amazon RDS Service Authorization Reference

AWS CloudFormation soutien

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

Compatibilité avec les fonctionnalités de Neptune

Un cluster dont les points de terminaison publics sont activés prend en charge toutes les fonctionnalités Neptune prises en charge par un cluster uniquement VPC, 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.