Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Öffentliche Endpunkte von Neptune

Übersicht

Amazon Neptune Neptune-Cluster werden normalerweise in Ihrer VPC bereitgestellt und können nur von dieser VPC aus aufgerufen werden. Dies erfordert die Konfiguration von Anwendungen und Entwicklungsumgebungen innerhalb der VPC oder die Verwendung von Proxydiensten für die Verbindung mit der VPC, was die Einrichtungszeit und die Kosten erhöht.

Öffentliche Endpunkte vereinfachen diese Erfahrung, indem sie direkte Verbindungen zu Neptune über das Internet ermöglichen, was den Einstieg in Graphdatenbanken ohne spezielle Netzwerkkenntnisse erleichtert.

Wann sollten öffentliche Endpunkte verwendet werden

Erwägen Sie die Verwendung öffentlicher Endpunkte in den folgenden Szenarien:

Sicherheitsüberlegungen

Beachten Sie bei der Verwendung öffentlicher Endpunkte die folgenden Sicherheitsaspekte:

Öffentliche Endpunkte aktivieren

Standardmäßig werden neue Neptune-Datenbanken mit deaktivierten öffentlichen Endpunkten erstellt. Sie müssen den öffentlichen Zugriff explizit aktivieren, wenn Sie einen Cluster erstellen oder ändern.

Öffentliche Endpunkte werden ab der Neptune Engine-Release-Version 1.4.6.x unterstützt. Sie müssen bestehende Cluster auf mindestens diese Version aktualisieren, um diese Funktion nutzen zu können.

Die öffentliche Endpunkteinstellung ist auf der Neptune-Instanz und nicht auf dem Neptun-Cluster verfügbar. Daher kann ein Neptun-Cluster bei einigen Instanzen mit öffentlichen Endpunkten existieren und bei anderen ohne. Wir empfehlen jedoch nicht, eine solche Einstellung zu verwenden. Weitere Informationen dazu finden Sie unter: So funktionieren öffentliche Endgeräte

Voraussetzungen

IAM-Authentifizierungseinstellung auf dem Neptune-Cluster

Bevor Sie öffentliche Endpunkte auf einer Neptune-Instance aktivieren, stellen Sie sicher, dass Ihr Cluster die IAM-Authentifizierung unterstützt. Wenn nicht, aktivieren Sie es mit dem folgenden Befehl:

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 (Netzwerkeinstellungen)

Eine neue Instanz mit öffentlichen Endpunkten erstellen

Sie können mithilfe der AWS Management Console, der AWS CLI oder des SDK eine neue Neptune-Instanz mit öffentlichen Endpunkten erstellen. AWS

Verwenden der 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

Änderung einer vorhandenen Instanz für den öffentlichen Zugriff

Um eine bestehende Neptune-Instanz zu ändern, um den öffentlichen Zugriff zu ermöglichen:

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

Verwenden der öffentlichen Endpunkte

Um zu überprüfen, ob Ihre Datenbank erreichbar ist, überprüfen Sie den Status mithilfe der AWS NeptuneData CLI-API:

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

Wenn auf die Datenbank zugegriffen werden kann, lautet die Antwort wie folgt:

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

Beispiele für die Abfrage der Datenbank

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

Wie funktionieren öffentliche Endpunkte

Wenn eine Neptun-Instanz öffentlich zugänglich ist:

Verhalten der Leser-Endgeräte

Verhalten der Cluster-Endpunkte

Verhalten nach einem Cluster-Failover

Anforderungen an die Netzwerkkonfiguration

Damit öffentliche Endpunkte ordnungsgemäß funktionieren:

Die Erstellung von öffentlichem Zugriff einschränken

Sie können IAM-Richtlinien verwenden, um einzuschränken, wer Neptune-Cluster mit öffentlichem Zugriff erstellen oder ändern kann. Die folgende Beispielrichtlinie verweigert die Erstellung von Neptune-Instanzen mit öffentlichem Zugriff:

JSON

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

Weitere Informationen zum rds:PublicAccessEnabled IAM-Bedingungsschlüssel: Amazon RDS Service Authorization Reference

AWS CloudFormation Unterstützung

Sie können AWS CloudFormation Neptune-Cluster mit aktivierten öffentlichen Endpunkten starten, indem Sie den PubliclyAccessible Parameter in Ihrer Vorlage angeben. AWS CloudFormation

Kompatibilität mit Neptune-Funktionen

Ein Cluster mit aktivierten öffentlichen Endpunkten unterstützt alle Neptune-Funktionen, die ein Nur-VPC-Cluster unterstützt, einschließlich:

Preise

Öffentliche Endgeräte sind ohne zusätzliche Kosten verfügbar, die über die Standardpreise von Neptune hinausgehen. Eine Verbindung von Ihrer lokalen Umgebung zu Neptune über eine öffentliche IP kann jedoch zu erhöhten Datenübertragungskosten führen.