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 Neptune 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 berikut:

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 cluster.

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

Pengaturan titik akhir publik tersedia pada instance Neptunus dan bukan cluster Neptunus. Oleh karena itu, cluster Neptunus dapat ada dengan beberapa contoh dengan titik akhir publik dan beberapa dengan tidak. Namun, kami tidak menyarankan untuk 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 Neptune, pastikan cluster Anda mendukung otentikasi 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 Neptune baru dengan titik akhir publik menggunakan AWS Management Console, AWS CLI, atau AWS SDK.

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 statusnya menggunakan API AWS CLI: 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))
        }
    }
}

Cara kerja titik akhir publik

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 cluster Neptunus dengan akses publik. Kebijakan contoh berikut menolak 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
        }
      }
    }
  ]
}

Selengkapnya tentang kunci kondisi rds:PublicAccessEnabled IAM: Referensi O torisasi Layanan Amazon RDS

CloudFormation dukungan

Anda dapat menggunakan CloudFormation untuk meluncurkan cluster Neptune dengan titik akhir publik diaktifkan dengan menentukan PubliclyAccessible parameter di CloudFormation template Anda.

Kompatibilitas dengan fitur Neptunus

Cluster dengan titik akhir publik diaktifkan mendukung semua fitur Neptunus yang VPC-only didukung cluster, 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.