Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Endpoint pubblici di Neptune

Panoramica

I cluster Amazon Neptune sono generalmente distribuiti all'interno del tuo VPC e sono accessibili solo dall'interno di quel VPC. Ciò richiede la configurazione di applicazioni e ambienti di sviluppo all'interno del VPC o l'utilizzo di servizi proxy per la connessione al VPC, il che aumenta i tempi e i costi di configurazione.

Gli endpoint pubblici semplificano questa esperienza consentendo connessioni dirette a Neptune tramite Internet, rendendo più facile iniziare a utilizzare i database a grafo senza conoscenze di rete specializzate.

Quando utilizzare gli endpoint pubblici

Prendi in considerazione l'utilizzo di endpoint pubblici nei seguenti scenari:

Considerazioni relative alla sicurezza

Quando utilizzi endpoint pubblici, tieni a mente queste considerazioni sulla sicurezza:

Abilitazione degli endpoint pubblici

Per impostazione predefinita, i nuovi database Neptune vengono creati con gli endpoint pubblici disabilitati. È necessario abilitare esplicitamente l'accesso pubblico durante la creazione o la modifica di un cluster.

Gli endpoint pubblici sono supportati dalla versione 1.4.6.x del motore Neptune. È necessario aggiornare i cluster esistenti almeno a questa versione per utilizzare questa funzionalità.

L'impostazione pubblica dell'endpoint è disponibile sull'istanza Neptune e non sul cluster Neptune. Pertanto, un cluster Neptune può esistere con alcune istanze con endpoint pubblici e altre senza. Tuttavia, non consigliamo di utilizzare tale impostazione. Per ulteriori informazioni in merito, consulta: Come funzionano gli endpoint pubblici

Prerequisiti

Impostazione di autenticazione IAM sul cluster Neptune

Prima di abilitare gli endpoint pubblici su un'istanza Neptune, assicurati che il cluster supporti l'autenticazione IAM. In caso contrario, abilitalo utilizzando il seguente comando:

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

Impostazioni di rete

Creazione di una nuova istanza con endpoint pubblici

Puoi creare una nuova istanza di Neptune con endpoint pubblici utilizzando la console di AWS gestione, la AWS CLI o l'SDK. AWS

Utilizzo della 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

Modifica di un'istanza esistente per l'accesso pubblico

Per modificare un'istanza di Neptune esistente per consentire l'accesso pubblico:

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

Utilizzo degli endpoint pubblici

Per verificare se il tuo database è raggiungibile, controlla lo stato utilizzando l'API AWS NeptuneData CLI:

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

Se il database è accessibile, la risposta è simile a:

{
    "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"
    }
}

Esempi di come interrogare il database

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

Come funzionano gli endpoint pubblici

Quando un'istanza di Neptune è accessibile pubblicamente:

Comportamento dell'endpoint del lettore

Comportamento degli endpoint del cluster

Comportamento dopo il failover del cluster

Requisiti relativi alla configurazione della rete

Affinché gli endpoint pubblici funzionino correttamente:

Limitare la creazione di accessi pubblici

Puoi utilizzare le policy IAM per limitare chi può creare o modificare i cluster Neptune con accesso pubblico. La seguente politica di esempio nega la creazione di istanze Neptune con accesso pubblico:

JSON

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

Ulteriori informazioni sulla chiave di condizione rds:PublicAccessEnabled IAM: Amazon RDS Service Authorization Reference

AWS CloudFormation supporto

È possibile AWS CloudFormation utilizzarlo per avviare cluster Neptune con endpoint pubblici abilitati PubliclyAccessible specificando il parametro nel modello. AWS CloudFormation

Compatibilità con le funzionalità di Neptune

Un cluster con endpoint pubblici abilitati supporta tutte le funzionalità di Neptune supportate da un cluster solo VPC, tra cui:

Prezzi

Gli endpoint pubblici sono disponibili senza costi aggiuntivi oltre ai prezzi standard di Neptune. Tuttavia, la connessione dall'ambiente locale a Neptune tramite un IP pubblico potrebbe comportare un aumento dei costi di trasferimento dei dati.