

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

# Menghubungkan ke cluster Amazon Neptunus
<a name="get-started-connecting"></a>

Setelah membuat cluster Neptunus, Anda dapat mengonfigurasi metode koneksi untuk mengaksesnya.

## Menyiapkan `curl` atau mengawscurl untuk berkomunikasi dengan titik akhir Neptunus Anda
<a name="get-started-access-graph-curl"></a>

Memiliki alat baris perintah untuk mengirimkan kueri ke cluster DB Neptunus Anda sangat berguna, seperti yang diilustrasikan dalam banyak contoh dalam dokumentasi ini. Alat baris perintah [curl](https://curl.haxx.se/) adalah opsi yang sangat baik untuk berkomunikasi dengan titik akhir Neptunus ketika otentikasi IAM tidak diaktifkan. Versi yang dimulai dengan 7.75.0 mendukung `--aws-sigv4` opsi untuk menandatangani permintaan saat autentikasi IAM diaktifkan.

Untuk titik akhir di mana otentikasi IAM *diaktifkan*, Anda juga dapat menggunakan [awscurl](https://github.com/okigan/awscurl), yang menggunakan sintaks yang hampir persis sama `curl` tetapi mendukung permintaan penandatanganan seperti yang diperlukan untuk otentikasi IAM. Karena keamanan tambahan yang disediakan oleh autentikasi IAM, umumnya merupakan ide yang baik untuk mengaktifkannya.

 Untuk informasi tentang cara menggunakan `curl` (atau`awscurl`), lihat [halaman manual curl](https://curl.haxx.se/docs/manpage.html), dan buku *[Everything curl](https://ec.haxx.se/)*.

Untuk terhubung menggunakan HTTPS (yang dibutuhkan Neptunus)`curl`, perlu akses ke sertifikat yang sesuai. Selama `curl` dapat menemukan sertifikat yang sesuai, ia menangani koneksi HTTPS seperti koneksi HTTP, tanpa parameter tambahan. Hal yang sama berlaku untuk`awscurl`. Contoh dalam dokumentasi ini didasarkan pada skenario tersebut.

Untuk mempelajari cara mendapatkan sertifikat tersebut dan cara memformatnya dengan benar ke dalam penyimpanan sertifikat otoritas sertifikat (CA) yang `curl` dapat digunakan, lihat [Verifikasi Sertifikat SSL](https://curl.haxx.se/docs/sslcerts.html) dalam `curl` dokumentasi.

Anda kemudian dapat menentukan lokasi penyimpanan sertifikat CA ini menggunakan variabel lingkungan `CURL_CA_BUNDLE`. Pada Windows, `curl` secara otomatis mencarinya dalam sebuah file bernama `curl-ca-bundle.crt`. Ia pertama mencari dalam direktori yang sama dengan `curl.exe` dan kemudian di tempat lain di jalurnya. Untuk informasi lebih lanjut, lihat [Verifikasi Sertifikat SSL](https://curl.haxx.se/docs/sslcerts.html).

## Berbagai cara untuk terhubung ke cluster DB Neptunus
<a name="get-started-connect-ways"></a>

Sebuah klaster DB Amazon Neptune *hanya* dapat dibuat di Amazon Virtual Private Cloud (Amazon VPC). Titik akhirnya hanya dapat diakses dalam VPC itu kecuali Anda mengaktifkan dan mengatur titik akhir publik [Neptunus](neptune-public-endpoints.md) untuk cluster DB.

Ada beberapa cara berbeda untuk mengatur akses ke cluster DB Neptunus Anda di VPC-nya:
+ [Menghubungkan dari instans Amazon EC2 di VPC yang sama](get-started-connect-ec2-same-vpc.md)
+ [Menghubungkan dari instans Amazon EC2 di VPC lain](get-started-connect-ec2-other-vpc.md)
+ [Menghubungkan dari jaringan pribadi](get-started-connect-private-net.md)
+ [Menghubungkan dari titik akhir publik](neptune-public-endpoints.md)

# Menghubungkan instans Amazon EC2 ke cluster Amazon Neptunus di VPC yang sama
<a name="get-started-connect-ec2-same-vpc"></a>

Salah satu cara paling umum untuk terhubung ke database Neptunus adalah dari instans Amazon EC2 di VPC yang sama dengan cluster DB Neptunus Anda. Misalnya, instans EC2 mungkin menjalankan server web yang terhubung dengan internet. Dalam hal ini, hanya instans EC2 yang memiliki akses ke cluster DB Neptunus, dan internet hanya memiliki akses ke instans EC2:

![\[Diagram mengakses cluster Neptunus dari instans EC2 di VPC yang sama.\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/VPC-connection-01.png)


Untuk mengaktifkan konfigurasi ini, Anda harus menyiapkan grup keamanan VPC dan grup subnet yang tepat. Server web di-host di subnet publik, sehingga dapat menjangkau internet publik, dan instance cluster Neptunus Anda di-host di subnet pribadi untuk menjaganya tetap aman. Lihat [Siapkan VPC Amazon di mana kluster DB Amazon Neptunus Anda berada](get-started-vpc.md).

Agar instans Amazon EC2 terhubung ke titik akhir Neptune Anda pada, misalnya, port `8182`, Anda perlu menyiapkan grup keamanan untuk melakukannya. Jika instans Amazon EC2 Anda menggunakan grup keamanan bernama, misalnya, `ec2-sg1`, Anda perlu membuat grup keamanan Amazon EC2 lainnya (katakanlah `db-sg1`) yang memiliki aturan masuk untuk port `8182` dan memiliki `ec2-sg1` sebagai sumbernya. Kemudian, tambahkan `db-sg1` ke klaster Neptune Anda untuk mengizinkan koneksi.

Setelah membuat instans Amazon EC2, Anda dapat masuk ke dalamnya menggunakan SSH dan terhubung ke cluster DB Neptunus Anda. Untuk informasi tentang menghubungkan ke instans EC2 menggunakan SSH, lihat [Connect to Linux Anda di Panduan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) Pengguna *Amazon EC2*.

Jika Anda menggunakan baris perintah Linux atau macOS untuk terhubung ke instans EC2, Anda dapat menempelkan perintah SSH dari **SSHAccess**item di bagian **Output** tumpukan. CloudFormation Anda harus memiliki file PEM di direktori saat ini dan izin file PEM harus ditetapkan ke 400 (`chmod 400 keypair.pem`).

**Untuk membuat VPC dengan subnet pribadi dan publik**

1. Masuk ke Konsol Manajemen AWS dan buka konsol VPC Amazon di. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

1. Di sudut kanan atas Konsol Manajemen AWS, pilih Wilayah untuk membuat VPC Anda.

1. Di **Dasbor VPC, pilih Luncurkan** Wisaya **VPC**.

1. Lengkapi area **Pengaturan VPC** di halaman Buat **VPC**:

   1. Di bawah **Sumber daya untuk membuat**, pilih **VPC, subnet, dll**.

   1. Biarkan tag nama default apa adanya, atau masukkan nama yang Anda pilih, atau hapus centang kotak centang **Buat otomatis** untuk menonaktifkan pembuatan tag nama.

   1. Biarkan nilai blok IPv4 CIDR di`10.0.0.0/16`.

   1. Biarkan nilai blok IPv6 CIDR di **No IPv6 CIDR** block.

   1. Tinggalkan **Tenancy** di **Default**.

   1. Biarkan jumlah **Availability Zones (AZs)** pada **2**.

   1. Tinggalkan **gateway NAT (\$1)** di **None**, kecuali jika Anda membutuhkan satu atau lebih gateway NAT.

   1. Setel **titik akhir VPC** ke **None**, kecuali Anda akan menggunakan Amazon S3.

   1. Baik **Aktifkan nama host DNS** dan **Aktifkan resolusi DNS harus diperiksa**.

1. Pilih **Buat VPC**.

# Menghubungkan instans Amazon EC2 ke cluster Amazon Neptunus di VPC yang berbeda
<a name="get-started-connect-ec2-other-vpc"></a>

Cluster Amazon Neptune DB hanya *dapat* dibuat di Amazon Virtual Private Cloud (Amazon VPC), dan titik akhirnya dapat diakses dalam VPC itu, biasanya dari instans Amazon Elastic Compute Cloud (Amazon EC2) yang berjalan di VPC itu. Atau, dapat diakses menggunakan titik akhir publik. Untuk informasi selengkapnya tentang titik akhir publik, lihat titik akhir publik [Neptunus](neptune-public-endpoints.md). 

Ketika cluster DB Anda berada di VPC yang berbeda dari instans EC2 yang Anda gunakan untuk mengaksesnya, Anda dapat menggunakan [VPC peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) untuk membuat koneksi:

![\[Diagram mengakses cluster Neptunus dari VPC yang berbeda.\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/VPC-connection-02.png)


Koneksi peering VPC adalah koneksi jaringan antara dua VPCs yang merutekan lalu lintas di antara mereka secara pribadi, sehingga contoh di salah satu VPC dapat berkomunikasi seolah-olah mereka berada dalam jaringan yang sama. Anda dapat membuat koneksi peering VPC antara VPCs di akun Anda, antara VPC di akun Anda AWS dan VPC di akun lain AWS , atau dengan VPC di Wilayah yang berbeda. AWS 

AWS menggunakan infrastruktur VPC yang ada untuk membuat koneksi peering VPC. Ini bukan gateway atau koneksi AWS Site-to-Site VPN, dan tidak bergantung pada perangkat keras fisik yang terpisah. Ini tidak memiliki titik kegagalan tunggal untuk komunikasi dan tidak ada hambatan bandwidth.

Lihat [Panduan Peering VPC Amazon](https://docs.aws.amazon.com/vpc/latest/peering/) untuk informasi selengkapnya tentang cara menggunakan VPC peering.

# Menghubungkan ke cluster Amazon Neptunus melalui jaringan pribadi
<a name="get-started-connect-private-net"></a>

Anda dapat mengakses cluster DB Neptunus dari jaringan pribadi dengan dua cara berbeda:
+ Menggunakan koneksi [AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html).
+ Menggunakan koneksi [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/).

Tautan di atas memiliki informasi tentang metode koneksi ini dan cara mengaturnya. Konfigurasi AWS Site-to-Site koneksi mungkin terlihat seperti ini:

![\[Diagram mengakses cluster Neptunus dari jaringan pribadi.\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/VPC-connection-04.png)


# Titik Akhir Publik Neptunus
<a name="neptune-public-endpoints"></a>

## Ikhtisar
<a name="neptune-public-endpoints-overview"></a>

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
<a name="neptune-public-endpoints-when-to-use"></a>

Pertimbangkan untuk menggunakan titik akhir publik dalam skenario berikut:
+ Anda ingin menguji Neptunus dengan cepat dalam lingkungan pengembangan atau pengujian tanpa konfigurasi jaringan yang rumit
+ Anda tidak memiliki pengetahuan AWS jaringan khusus
+ Postur keamanan aplikasi Anda tidak memerlukan VPC pribadi
+ Anda perlu terhubung ke Neptunus dari lingkungan pengembangan lokal Anda

## Pertimbangan keamanan
<a name="neptune-public-endpoints-security"></a>

Saat menggunakan titik akhir publik, ingatlah pertimbangan keamanan ini:
+ Autentikasi IAM diperlukan untuk cluster dengan titik akhir publik diaktifkan.
+ Akses ke database dikendalikan oleh grup keamanan yang digunakannya.
+ Anda dapat membatasi alamat IP mana yang dapat terhubung ke cluster Anda.
+ Anda dapat menggunakan kebijakan IAM untuk mengontrol siapa yang dapat membuat atau memodifikasi cluster dengan akses publik. Lihat: [Membatasi pembuatan akses publik](#neptune-public-endpoints-restrict-access)

## Mengaktifkan titik akhir publik
<a name="neptune-public-endpoints-enabling"></a>

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](#neptune-public-endpoints-how-they-work)

## Prasyarat
<a name="neptune-public-endpoints-prerequisites"></a>

### Pengaturan otentikasi IAM pada cluster Neptunus
<a name="neptune-public-endpoints-iam-auth"></a>

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
<a name="neptune-public-endpoints-network-settings"></a>

1. Pastikan VPC Anda memiliki subnet yang memungkinkan perutean publik (memiliki entri untuk gateway internet di tabel rute subnet). Jika Anda tidak memberikan `db-subnet-group-name` parameter saat membuat cluster, grup subnet default dipilih untuk pembuatan klaster.

1. Pastikan grup keamanan yang terpasang pada cluster memungkinkan lalu lintas masuk untuk rentang IP yang diizinkan dan port yang diizinkan. Misalnya, jika Anda ingin mengizinkan lalu lintas TCP dari semua IPs untuk terhubung ke instance Neptunus yang berjalan pada port 8182, aturan masuk harus memiliki:

   1. Jenis: Semua TCP

   1. Protokol: TCP

   1. Rentang port: 8182

   1. Blok CIDR: 0.0.0.0/0

**catatan**  
Meskipun Anda dapat mengatur rentang blok CIDR ke 0.0.0.0/0, kami sarankan untuk mengurangi ini ke rentang IP tertentu dari aplikasi klien Anda untuk postur keamanan yang lebih baik.

## Membuat instance baru dengan titik akhir publik
<a name="neptune-public-endpoints-creating-instance"></a>

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
<a name="neptune-public-endpoints-modifying-instance"></a>

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
```

**catatan**  
Akses publik diaktifkan pada tingkat instans, bukan tingkat cluster. Untuk memastikan klaster Anda selalu dapat diakses melalui titik akhir publik, semua instance di klaster harus mengaktifkan akses publik.

## Menggunakan titik akhir publik
<a name="neptune-public-endpoints-using"></a>

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
<a name="neptune-public-endpoints-examples"></a>

### AWS CLI
<a name="neptune-public-endpoints-aws-cli"></a>

```
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
<a name="neptune-public-endpoints-python"></a>

```
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
<a name="neptune-public-endpoints-javascript"></a>

```
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
<a name="neptune-public-endpoints-go"></a>

```
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
<a name="neptune-public-endpoints-how-they-work"></a>

Ketika instance Neptunus dapat diakses publik:
+ Titik akhir DNS-nya menyelesaikan ke alamat IP pribadi dari dalam VPC cluster DB.
+ Ini menyelesaikan ke alamat IP publik dari luar VPC cluster.
+ Akses dikendalikan oleh grup keamanan yang ditugaskan ke cluster.
+ Hanya contoh yang dapat diakses publik yang dapat diakses melalui internet.

### Perilaku titik akhir pembaca
<a name="neptune-public-endpoints-reader-behavior"></a>
+ Jika semua instance pembaca dapat diakses publik, titik akhir pembaca akan selalu diselesaikan melalui internet publik.
+ Jika hanya beberapa instance pembaca yang dapat diakses publik, titik akhir pembaca akan menyelesaikan secara publik hanya jika memilih instance yang dapat diakses publik untuk melayani kueri baca.

### Perilaku titik akhir cluster
<a name="neptune-public-endpoints-cluster-behavior"></a>
+ Titik akhir cluster DB selalu menyelesaikan titik akhir instance penulis.
+ Jika titik akhir publik diaktifkan pada instance penulis, titik akhir cluster akan dapat diakses publik, jika tidak maka tidak akan terjadi.

### Perilaku setelah failover cluster
<a name="neptune-public-endpoints-failover-behavior"></a>
+ Cluster Neptunus dapat memiliki instance pada pengaturan yang dapat diakses publik yang berbeda.
+ Jika cluster memiliki penulis publik dan pembaca non-publik, posting failover cluster, penulis baru (pembaca sebelumnya) menjadi non-publik dan pembaca baru (penulis sebelumnya) menjadi publik.

## Persyaratan konfigurasi jaringan
<a name="neptune-public-endpoints-network-requirements"></a>

Agar titik akhir publik berfungsi dengan baik:

1. Instans Neptunus harus berada dalam subnet publik dalam VPC Anda.

1. Tabel rute yang terkait dengan subnet ini harus memiliki rute ke gateway internet untuk 0.0.0.0/0.

1. Grup keamanan harus mengizinkan akses dari alamat IP publik atau rentang CIDR yang ingin Anda berikan akses.

## Membatasi pembuatan akses publik
<a name="neptune-public-endpoints-restrict-access"></a>

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](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonrds.html#amazonrds-rds_PubliclyAccessible)

## CloudFormation dukungan
<a name="neptune-public-endpoints-cloudformation"></a>

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

## Kompatibilitas dengan fitur Neptunus
<a name="neptune-public-endpoints-compatibility"></a>

Cluster dengan titik akhir publik yang diaktifkan mendukung semua fitur Neptunus yang didukung oleh cluster khusus VPC, termasuk:
+ Meja kerja Neptunus
+ Integrasi pencarian teks lengkap
+ Pengaliran Neptune
+ Titik akhir kustom
+ Neptunus Tanpa Server
+ Penjelajah Grafik

## Harga
<a name="neptune-public-endpoints-pricing"></a>

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.