Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Titik Akhir Publik Neptunus

Gambaran umum

Cluster Amazon Neptunus biasanya digunakan dalam VPC Anda dan hanya dapat diakses dari dalam VPC tersebut. Ini memerlukan konfigurasi aplikasi dan lingkungan pengembangan dalam VPC atau menggunakan layanan proxy untuk terhubung ke VPC, yang meningkatkan waktu dan biaya penyiapan.

Titik akhir publik menyederhanakan pengalaman ini dengan memungkinkan koneksi langsung ke Neptunus melalui internet, membuatnya lebih mudah untuk memulai dengan database grafik tanpa pengetahuan jaringan khusus.

Kapan menggunakan titik akhir publik

Pertimbangkan untuk menggunakan titik akhir publik dalam skenario berikut:

Pertimbangan keamanan

Saat menggunakan titik akhir publik, ingatlah pertimbangan keamanan ini:

Mengaktifkan titik akhir publik

Secara default, database Neptunus baru dibuat dengan titik akhir publik dinonaktifkan. Anda harus secara eksplisit mengaktifkan akses publik saat membuat atau memodifikasi klaster.

Titik akhir publik didukung dari rilis mesin Neptunus versi 1.4.6.x. Anda perlu memutakhirkan cluster yang ada ke setidaknya versi ini untuk menggunakan fitur ini.

Pengaturan titik akhir publik tersedia pada instance Neptunus dan bukan cluster Neptunus. Oleh karena itu, cluster Neptunus dapat eksis dengan beberapa contoh dengan titik akhir publik dan beberapa tidak. Namun, kami tidak menyarankan memiliki pengaturan seperti itu. Untuk informasi lebih lanjut tentang ini, lihat: Cara kerja titik akhir publik

Prasyarat

Pengaturan otentikasi IAM pada cluster Neptunus

Sebelum mengaktifkan titik akhir publik pada instans Neptunus, pastikan klaster Anda mendukung autentikasi IAM. Jika tidak, aktifkan menggunakan perintah berikut:

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

Pengaturan jaringan

Membuat instance baru dengan titik akhir publik

Anda dapat membuat instance Neptunus baru dengan titik akhir publik menggunakan AWS Management Console, AWS CLI, atau SDK. AWS

Menggunakan 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

Memodifikasi instance yang ada untuk akses publik

Untuk memodifikasi instance Neptunus yang ada untuk mengaktifkan akses publik:

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

Menggunakan titik akhir publik

Untuk memeriksa apakah database Anda dapat dijangkau, periksa status menggunakan CLI API AWS : NeptuneData

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

Jika database dapat diakses, responsnya seperti:

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

Contoh cara menanyakan 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))
        }
    }
}

Bagaimana titik akhir publik bekerja

Ketika instance Neptunus dapat diakses publik:

Perilaku titik akhir pembaca

Perilaku titik akhir cluster

Perilaku setelah failover cluster

Persyaratan konfigurasi jaringan

Agar titik akhir publik berfungsi dengan baik:

Membatasi pembuatan akses publik

Anda dapat menggunakan kebijakan IAM untuk membatasi siapa yang dapat membuat atau memodifikasi kluster Neptunus dengan akses publik. Contoh kebijakan berikut menyangkal pembuatan instance Neptunus dengan akses publik:

JSON

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

Lebih lanjut tentang kunci kondisi rds:PublicAccessEnabled IAM: Referensi Otorisasi Layanan Amazon RDS

AWS CloudFormation dukungan

Anda dapat menggunakan AWS CloudFormation untuk meluncurkan cluster Neptunus dengan titik akhir publik diaktifkan dengan menentukan PubliclyAccessible parameter dalam template Anda. AWS CloudFormation

Kompatibilitas dengan fitur Neptunus

Cluster dengan titik akhir publik yang diaktifkan mendukung semua fitur Neptunus yang didukung oleh cluster khusus VPC, termasuk:

Harga

Titik akhir publik tersedia tanpa biaya tambahan di luar harga Neptunus standar. Namun, menghubungkan dari lingkungan lokal Anda ke Neptunus melalui IP publik mungkin menimbulkan peningkatan biaya transfer data.