Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengajukan Kueri Grafik Neptune
Neptune mendukung bahasa kueri grafik berikut untuk mengakses grafik:
+ [Gremlin](https://tinkerpop.apache.org/gremlin.html), didefinisikan oleh [Apache TinkerPop](https://tinkerpop.apache.org/) untuk membuat dan menanyakan grafik properti.
Sebuah kueri di Gremlin adalah sebuah traversal yang terdiri dari langkah-langkah berlainan, yang masing-masing mengikuti edge ke simpul.
Lihat [Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md) untuk mempelajari cara menggunakan Gremlin di Neptune, dan [Kepatuhan standar Gremlin di Amazon Neptune](access-graph-gremlin-differences.md) untuk menemukan detail spesifik tentang implementasi Neptune Gremlin.
+ [OpenCypher](access-graph-opencypher.md)adalah bahasa kueri deklaratif untuk grafik properti yang awalnya dikembangkan oleh Neo4j, kemudian bersumber terbuka pada tahun 2015, dan berkontribusi pada proyek [OpenCypher](http://www.opencypher.org/) di bawah lisensi open-source Apache 2. Sintaksnya didokumentasikan dalam spesifikasi [OpenCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf).
+ [SPARQL](https://www.w3.org/TR/sparql11-overview/) adalah bahasa deklaratif berdasarkan grafik pola-pencocokan, untuk mengajukan kueri data [RDF](https://www.w3.org/2001/sw/wiki/RDF). Hal ini didukung oleh [World Wide Web Consortium](https://www.w3.org/).
Lihat [Mengakses grafik Neptune dengan SPARQL](access-graph-sparql.md) untuk mempelajari cara menggunakan SPARQL di Neptune, dan [Kepatuhan standar SPARQL di Amazon Neptunus](feature-sparql-compliance.md) untuk menemukan detail spesifik tentang implementasi Neptune SPARQL.
**catatan**
Baik Gremlin dan OpenCypher dapat digunakan untuk menanyakan data grafik properti apa pun yang disimpan di Neptunus, terlepas dari bagaimana itu dimuat.
**Topics**
+ [Antrean kueri di Amazon Neptune](access-graph-queuing.md)
+ [Cache paket kueri di Amazon Neptunus](access-graph-qpc.md)
+ [Menyuntikkan ID Kustom Ke Dalam Gremlin Neptune atau Kueri SPARQL](features-query-id.md)
+ [Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md)
+ [Mengakses Grafik Neptunus dengan OpenCypher](access-graph-opencypher.md)
+ [Mengakses grafik Neptune dengan SPARQL](access-graph-sparql.md)
# Antrean kueri di Amazon Neptune
Ketika mengembangkan dan menyesuaikan aplikasi grafik, mengetahui implikasi dari bagaimana kueri diantrekan oleh database akan sangat membantu. Di Amazon Neptune, antrean kueri terjadi sebagai berikut:
+ Jumlah maksimum kueri yang dapat diantrekan per instans, terlepas dari ukuran instans, adalah 8.192. Setiap kueri yang melebihi jumlah tersebut ditolak dan gagal dengan `ThrottlingException`.
+ Jumlah maksimum kueri yang dapat dijalankan pada satu waktu ditentukan oleh jumlah thread pekerja yang ditetapkan, yang umumnya diatur ke dua kali jumlah core CPU virtual (vCPUs) yang tersedia.
+ Latensi kueri menyertakan waktu yang dihabiskan sebuah kueri dalam antrean serta perjalanan memutari jaringan dan waktu yang benar-benar diperlukan kueri untuk dieksekusi.
## Menentukan berapa banyak kueri dalam antrean Anda pada saat tertentu
`MainRequestQueuePendingRequests` CloudWatch Metrik mencatat jumlah permintaan yang menunggu dalam antrian input dengan perincian lima menit (lihat). [Metrik Neptunus CloudWatch](cw-metrics.md)
Untuk Gremlin, Anda dapat memperoleh jumlah kueri dalam antrean menggunakan nilai `acceptedQueryCount` yang dikembalikan oleh [API status kueri Gremlin](gremlin-api-status.md). Namun, perlu diingat bahwa nilai `acceptedQueryCount` yang dikembalikan oleh [API status kueri SPARQL](sparql-api-status.md) mencakup semua kueri yang diterima sejak server dimulai, termasuk kueri yang telah selesai.
## Bagaimana antrean kueri dapat memengaruhi waktu habis
Seperti yang dinyatakan di atas, latensi kueri menyertakan waktu yang dihabiskan sebuah kueri dalam antrean serta waktu yang diperlukan kueri untuk dieksekusi.
Karena periode waktu habis kueri umumnya diukur mulai dari ketika memasuki antrean, antrean yang bergerak lambat dapat membuat banyak kueri kehabisan waktu segera setelah keluar dari antrean. Hal ini jelas tidak diinginkan, jadi hindari antrean kueri dalam jumlah besar kecuali kueri tersebut dapat dieksekusi dengan cepat.
# Cache paket kueri di Amazon Neptunus
Ketika kueri dikirimkan ke Neptunus, string kueri diurai, dioptimalkan, dan diubah menjadi rencana kueri, yang kemudian dieksekusi oleh mesin. Aplikasi sering didukung oleh pola kueri umum yang dipakai dengan nilai yang berbeda. Cache rencana kueri dapat mengurangi latensi keseluruhan dengan menyimpan paket kueri dan dengan demikian menghindari penguraian dan pengoptimalan untuk pola berulang tersebut.
Query Plan Cache dapat digunakan untuk **OpenCypher**kueri — baik kueri non-parameter maupun parameter. Ini diaktifkan untuk READ, dan untuk HTTP dan Bolt. Ini **tidak** didukung untuk kueri mutasi OC. Ini **tidak** didukung untuk kueri Gremlin atau SPARQL.
## Cara memaksa mengaktifkan atau menonaktifkan cache rencana kueri
Cache paket kueri diaktifkan secara default untuk kueri berparameter latensi rendah. **Rencana untuk kueri berparameter hanya di-cache ketika latensi lebih rendah dari ambang batas 100 ms.** Perilaku ini dapat diganti berdasarkan per-kueri (diparameterisasi atau tidak) oleh Petunjuk Kueri tingkat kueri. `QUERY:PLANCACHE` Itu perlu digunakan dengan `USING` klausa. Petunjuk kueri menerima `enabled` atau `disabled` sebagai nilai.
```
# Forcing plan to be cached or reused
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1"
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": 123}"
# Forcing plan to be neither cached nor reused
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"disabled\" MATCH(n) RETURN n LIMIT 1"
```
## Cara menentukan apakah rencana di-cache atau tidak
Untuk HTTP READ, jika kueri dikirimkan dan paket di-cache, `explain` akan menampilkan detail yang relevan dengan cache rencana kueri.
```
% curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" \
-d "explain=[static|details]"
Query:
Plan cached by request:
Plan cached at:
Parameters:
Plan cache hits:
First query evaluation time:
The query has been executed based on a cached query plan. Detailed explain with operator runtime statistics can be obtained by running the query with plan cache disabled (using HTTP parameter planCache=disabled).
```
Saat menggunakan Bolt, fitur jelaskan tidak didukung.
## Penggusuran
Rencana kueri diusir oleh cache time to live (TTL) atau ketika jumlah maksimum paket kueri cache telah tercapai. Saat paket kueri terpukul, TTL disegarkan. Defaultnya adalah:
+ 1000 - Jumlah maksimum paket yang dapat di-cache per instance.
+ TTL - 300.000 milidetik atau 5 menit. Cache hit memulai ulang TTL, dan mengatur ulang kembali ke 5 menit.
## Kondisi yang menyebabkan rencana tidak di-cache
Cache paket kueri tidak akan digunakan dalam kondisi berikut:
1. Saat kueri dikirimkan menggunakan petunjuk `QUERY:PLANCACHE "disabled"` kueri. Anda dapat menjalankan kembali kueri dan menghapus `QUERY:PLANCACHE "disabled"` untuk mengaktifkan cache rencana kueri.
1. Jika kueri yang dikirimkan bukan kueri berparameter dan tidak berisi petunjuk. `QUERY:PLANCACHE "enabled"`
1. Jika waktu evaluasi kueri lebih besar dari ambang latensi, kueri tidak di-cache dan dianggap sebagai kueri yang berjalan lama yang tidak akan mendapat manfaat dari cache paket kueri.
1. Jika kueri berisi pola yang tidak mengembalikan hasil apa pun.
+ yaitu `MATCH (n:nonexistentLabel) return n` ketika ada nol node dengan label yang ditentukan.
+ yaitu `MATCH (n {name: $param}) return n` dengan `parameters={"param": "abcde"}` ketika ada nol node yang mengandung`name=abcde`.
1. Jika parameter kueri adalah tipe komposit, seperti a `list` atau a`map`.
```
curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": [1, 2, 3]}"
curl -k https://:/opencypher \
-d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \
-d "parameters={\"arg\": {\"a\": 1}}"
```
1. Jika parameter query adalah string yang belum menjadi bagian dari beban data atau operasi penyisipan data. Misalnya, jika `CREATE (n {name: "X"})` dijalankan untuk menyisipkan`"X"`, `RETURN "X"` maka di-cache, sementara tidak `RETURN "Y"` akan di-cache, karena `"Y"` belum dimasukkan dan tidak ada dalam database.
# Menyuntikkan ID Kustom Ke Dalam Gremlin Neptune atau Kueri SPARQL
Secara default, Neptune memberikan nilai `queryId` yang unik untuk setiap kueri. Anda dapat menggunakan ID ini untuk mendapatkan informasi tentang kueri yang berjalan (lihat [API status kueri Gremlin](gremlin-api-status.md) atau [API status kueri SPARQL](sparql-api-status.md)), atau membatalkannya (lihat [Pembatalan kueri Gremlin](gremlin-api-status-cancel.md) atau [Pembatalan kueri SPARQL](sparql-api-status-cancel.md)).
Neptune juga memungkinkan Anda menentukan nilai `queryId` sendiri untuk kueri Gremlin atau SPARQL, baik di header HTTP, atau untuk kueri SPARQL menggunakan petunjuk kueri `queryId`. Menugaskan `queryID` Anda sendiri memudahkan pelacakan kueri untuk mendapatkan statusnya atau membatalkannya.
## Menyuntikkan Nilai `queryId` Kustom Menggunakan Header HTTP
Untuk Gremlin dan SPARQL, header HTTP dapat digunakan untuk menyuntikkan nilai `queryId` Anda sendiri ke dalam kueri.
**Contoh Gremlin**
```
curl -XPOST https://your-neptune-endpoint:port \
-d "{\"gremlin\": \
\"g.V().limit(1).count()\" , \
\"queryId\":\"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" }"
```
**Contoh SPARQL**
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=SELECT * WHERE { ?s ?p ?o } " \
--data-urlencode \
"queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
## Menyuntikkan Nilai `queryId` Kustom menggunakan Petunjuk Kueri SPARQL
Berikut adalah contoh bagaimana Anda akan menggunakan petunjuk kueri `queryId` SPARQL untuk menyuntikkan nilai `queryId` kustom ke dalam kueri SPARQL:
```
curl https://your-neptune-endpoint:port/sparql \
-d "query=PREFIX hint: \
SELECT * WHERE { hint:Query hint:queryId \"4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47\" \
{?s ?p ?o}}"
```
## Menggunakan Nilai `queryId` untuk Memeriksa Status Kueri
**Contoh Gremlin**
```
curl https://your-neptune-endpoint:port/gremlin/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
**Contoh SPARQL**
```
curl https://your-neptune-endpoint:port/sparql/status \
-d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
```
# Mengakses grafik Neptune dengan Gremlin
Amazon Neptunus kompatibel dengan TinkerPop Apache dan Gremlin. Ini berarti Anda dapat terhubung ke instans DB Neptunus dan menggunakan bahasa traversal Gremlin untuk menanyakan grafik ([lihat](https://tinkerpop.apache.org/docs/current/reference/#graph) Grafik dalam dokumentasi Apache). TinkerPop Untuk perbedaan dalam implementasi Neptune Gremlin, lihat [Kepatuhan standar Gremlin](access-graph-gremlin-differences.md).
Sebuah *traversal* di Gremlin adalah serangkaian langkah berantai. Traversal dimulai pada sebuah vertex (atau edge). Traversal menelusuri grafik dengan mengikuti edge keluar dari setiap vertex lalu edge keluar dari vertex tersebut. Setiap langkah adalah operasi dalam traversal. Untuk informasi selengkapnya, lihat [The Traversal](https://tinkerpop.apache.org/docs/current/reference/#traversal) dalam TinkerPop dokumentasi.
Versi mesin Neptune yang berbeda mendukung versi Gremlin yang berbeda. Periksa [halaman rilis mesin](engine-releases.md) versi Neptunus yang Anda jalankan untuk menentukan rilis Gremlin mana yang didukungnya atau lihat tabel berikut yang mencantumkan versi paling awal dan terbaru yang TinkerPop didukung oleh versi mesin Neptunus yang berbeda:
| Versi Mesin Neptune | TinkerPop Versi Minimum | TinkerPop Versi Maksimum |
| --- | --- | --- |
| `1.3.2.0 and newer` | `3.7.1` | `3.7.3` |
| `1.3.1.0` | `3.6.2` | `3.6.5` |
| `1.3.0.0` | `3.6.2` | `3.6.4` |
| `1.2.1.0 <= 1.2.1.2` | `3.6.2` | `3.6.2` |
| `1.1.1.0 <= 1.2.0.2` | `3.5.5` | `3.5.6` |
| `1.1.0.0 and older` | `(deprecated)` | `(deprecated)` |
TinkerPop klien biasanya kompatibel ke belakang dalam seri (`3.6.x`, misalnya, atau`3.7.x`) dan sementara mereka sering dapat bekerja melintasi batas-batas tersebut, tabel di atas merekomendasikan kombinasi versi untuk digunakan untuk pengalaman dan kompatibilitas terbaik. Kecuali disarankan lain, umumnya yang terbaik adalah mematuhi pedoman ini dan meningkatkan aplikasi klien agar sesuai dengan versi yang TinkerPop Anda gunakan.
Saat memutakhirkan TinkerPop versi, selalu penting untuk merujuk ke [TinkerPopdokumentasi pemutakhiran](http://tinkerpop.apache.org/docs/current/upgrade/) yang akan membantu Anda mengidentifikasi fitur baru yang dapat Anda manfaatkan, tetapi juga masalah yang mungkin perlu Anda waspadai saat mendekati peningkatan. Anda biasanya mengharapkan kueri dan fitur yang ada berfungsi setelah peningkatan kecuali sesuatu secara khusus disebut sebagai masalah untuk dipertimbangkan. Terakhir, penting untuk dicatat bahwa jika versi yang Anda tingkatkan untuk memiliki fitur baru, Anda mungkin tidak dapat menggunakannya jika berasal dari versi yang lebih lambat dari yang didukung Neptunus.
Ada beberapa varian bahasa Gremlin dan dukungan untuk akses Gremlin dalam berbagai bahasa pemrograman. Untuk informasi selengkapnya, lihat [Tentang Varian Bahasa Gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) dalam dokumentasi. TinkerPop
Dokumentasi ini menjelaskan cara mengakses Neptunus dengan varian dan bahasa pemrograman berikut:
+ [Mengatur konsol Gremlin agar terhubung ke instans DB Neptune](access-graph-gremlin-console.md)
+ [Menggunakan titik akhir HTTPS REST untuk menyambung ke instans DB Neptune](access-graph-gremlin-rest.md)
+ [Klien Gremlin berbasis Java untuk digunakan dengan Amazon Neptunus](access-graph-gremlin-client.md)
+ [Menggunakan Python untuk terhubung ke instans DB Neptune](access-graph-gremlin-python.md)
+ [Gunakan .NET untuk terhubung ke instans DB Neptune](access-graph-gremlin-dotnet.md)
+ [Gunakan Node.js untuk terhubung ke instans DB Neptune](access-graph-gremlin-node-js.md)
+ [Menggunakan Go untuk terhubung ke instans DB Neptunus](access-graph-gremlin-go.md)
Seperti dibahas dalam[Mengenkripsi koneksi ke database Amazon Neptunus Anda dengan SSL/HTTPS](security-ssl.md), Anda harus menggunakan Transport Layer Security/Secure Sockets Layer (TLS/SSL) saat menghubungkan ke Neptunus di semua Wilayah. AWS
Sebelum Anda mulai, Anda harus memiliki yang berikut:
+ Instans DB Neptune. Untuk informasi tentang membuat instans DB Neptune, lihat [Membuat cluster Amazon Neptunus](get-started-create-cluster.md).
+ Instans Amazon EC2 di virtual private cloud (VPC) yang sama seperti instans DB Neptune Anda.
Untuk informasi lebih lanjut tentang memuat data ke dalam Neptune, termasuk prasyarat, format pemuatan, dan parameter beban, lihat [Memuat data ke Amazon Neptune](load-data.md).
**Topics**
+ [Mengatur konsol Gremlin agar terhubung ke instans DB Neptune](access-graph-gremlin-console.md)
+ [Menggunakan titik akhir HTTPS REST untuk menyambung ke instans DB Neptune](access-graph-gremlin-rest.md)
+ [Klien Gremlin berbasis Java untuk digunakan dengan Amazon Neptunus](access-graph-gremlin-client.md)
+ [Menggunakan Python untuk terhubung ke instans DB Neptune](access-graph-gremlin-python.md)
+ [Gunakan .NET untuk terhubung ke instans DB Neptune](access-graph-gremlin-dotnet.md)
+ [Gunakan Node.js untuk terhubung ke instans DB Neptune](access-graph-gremlin-node-js.md)
+ [Menggunakan Go untuk terhubung ke instans DB Neptunus](access-graph-gremlin-go.md)
+ [Menggunakan AWS SDK untuk menjalankan kueri Gremlin](access-graph-gremlin-sdk.md)
+ [Petunjuk kueri Gremlin](gremlin-query-hints.md)
+ [API status kueri Gremlin](gremlin-api-status.md)
+ [Pembatalan kueri Gremlin](gremlin-api-status-cancel.md)
+ [Support untuk sesi berbasis skrip Gremlin](access-graph-gremlin-sessions.md)
+ [Transaksi Gremlin di Neptunus](access-graph-gremlin-transactions.md)
+ [Menggunakan API Gremlin dengan Amazon Neptune](gremlin-api-reference.md)
+ [Hasil kueri cache di Amazon Neptunus Gremlin](gremlin-results-cache.md)
+ [Membuat peningkatan yang efisien dengan `mergeV()` Gremlin dan langkah-langkah `mergeE()`](gremlin-efficient-upserts.md)
+ [Membuat peningkatan Gremlin yang efisien dengan `fold()/coalesce()/unfold()`](gremlin-efficient-upserts-pre-3.6.md)
+ [Menganalisis eksekusi kueri Neptune menggunakan `explain` Gremlin](gremlin-explain.md)
+ [Menggunakan Gremlin dengan mesin kueri Neptunus DFE](gremlin-with-dfe.md)
# Mengatur konsol Gremlin agar terhubung ke instans DB Neptune
Konsol Gremlin memungkinkan Anda bereksperimen dengan TinkerPop grafik dan kueri di lingkungan REPL (loop). read-eval-print
## Menginstal konsol Gremlin dan menghubungkannya dengan cara biasa
Anda dapat menggunakan Konsol Gremlin untuk terhubung ke basis data grafik jarak jauh. Bagian berikut memandu Anda melalui penginstalan dan konfigurasi Konsol Gremlin untuk menghubungkan ke instans DB Neptune secara jarak jauh. Anda harus mengikuti petunjuk ini dari instans Amazon EC2 di virtual private cloud (VPC) yang sama seperti instans DB Neptune Anda.
Untuk bantuan menghubungkan ke Neptunus SSL/TLS dengan (yang diperlukan), lihat. [Konfigurasi SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)
**catatan**
Jika [autentikasi IAM diaktifkan](iam-auth-enable.md) di cluster DB Neptunus Anda, ikuti petunjuk [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan konsol Gremlin](iam-auth-connecting-gremlin-console.md) untuk menginstal konsol Gremlin daripada instruksi di sini.
**Untuk memasang Konsol Gremlin dan menyambung ke Neptune**
1. Biner Konsol Gremlin memerlukan Java 8 atau Java 11. Instruksi ini mengasumsikan penggunaan Java 11. Anda dapat menginstal Java 11 pada instans EC2 Anda sebagai berikut:
+ Jika Anda menggunakan [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Jika Anda menggunakan [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html):
```
sudo yum install java-11-amazon-corretto-devel
```
+ Untuk distribusi lain, gunakan salah satu dari berikut ini yang sesuai:
```
sudo yum install java-11-openjdk-devel
```
atau:
```
sudo apt-get install openjdk-11-jdk
```
1. Masukkan yang berikut ini untuk mengatur Java 11 sebagai runtime default pada instans EC2 Anda.
```
sudo /usr/sbin/alternatives --config java
```
Saat diminta, masukkan nomor untuk Java 11.
1. Unduh versi Konsol Gremlin yang sesuai dari situs web Apache. Anda dapat memeriksa versi Gremlin mana yang didukung versi Neptunus Anda. [Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md) Misalnya, jika Anda memerlukan versi 3.7.2, Anda dapat mengunduh [konsol Gremlin](https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip) dari situs web [Apache Tinkerpop](https://tinkerpop.apache.org/download.html) ke instans EC2 Anda seperti ini:
```
wget https://archive.apache.org/dist/tinkerpop/3.7.2/apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Unzip file Konsol Gremlin.
```
unzip apache-tinkerpop-gremlin-console-3.7.2-bin.zip
```
1. Ubah direktori ke dalam direktori yang di-unzip.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. Di sudirektori `conf` dari direktori yang diekstrak, buat sebuah file bernama `neptune-remote.yaml` dengan teks berikut. Ganti *your-neptune-endpoint* dengan nama host atau alamat IP instans DB Neptunus Anda. Tanda kurung persegi (`[ ]`) wajib diisi.
**catatan**
Untuk informasi tentang menemukan nama host instans DB Neptune Anda, lihat bagian [Menghubungkan ke Titik Akhir Amazon Neptune.](feature-overview-endpoints.md).
```
hosts: [your-neptune-endpoint]
port: 8182
connectionPool: { enableSsl: true }
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1,
config: { serializeResultToString: true }}
```
**catatan**
Serializer dipindahkan dari `gremlin-driver` modul ke `gremlin-util` modul baru di versi 3.7.0. Paket diubah dari org.apache.tinkerpop.gremlin.driver.ser menjadi org.apache.tinkerpop.gremlin.util.ser.
1. Di terminal, bernavigasilah ke direktori Konsol Gremlin (`apache-tinkerpop-gremlin-console-3.7.2`), lalu masukkan perintah berikut untuk menjalankan Konsol Gremlin.
```
bin/gremlin.sh
```
Anda akan melihat output berikut:
```
\,,,/
(o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin>
```
Anda sekarang berada di prompt `gremlin>`. Anda akan memasukkan langkah-langkah yang tersisa pada prompt ini.
1. Di prompt `gremlin>`, masukkan hal berikut untuk menyambung ke instans DB Neptune.
```
:remote connect tinkerpop.server conf/neptune-remote.yaml
```
1. Di prompt `gremlin>`, masukkan hal berikut ini untuk beralih ke mode jarak jauh. Ini mengirimkan semua kueri Gremlin ke koneksi remote.
```
:remote console
```
1. Masukkan hal berikut untuk mengirim kueri ke Gremlin Graph.
```
g.V().limit(1)
```
1. Setelah Anda selesai, masukkan hal berikut untuk keluar dari Konsol Gremlin.
```
:exit
```
**catatan**
Gunakan titik koma (`;`) atau karakter baris baru (`\n`) untuk memisahkan setiap pernyataan.
Setiap traversal sebelum traversal akhir harus diakhiri dengan `next()` yang akan dieksekusi. Hanya data dari traversal akhir yang dikembalikan.
Untuk informasi lebih lanjut tentang implementasi Neptune dari Gremlin, lihat [Kepatuhan standar Gremlin di Amazon Neptune](access-graph-gremlin-differences.md).
# Cara alternatif untuk terhubung ke konsol Gremlin
**Kelemahan dari pendekatan koneksi normal**
Cara paling umum untuk terhubung ke konsol Gremlin adalah yang dijelaskan di atas, menggunakan perintah seperti ini pada `gremlin>` prompt:
```
gremlin> :remote connect tinkerpop.server conf/(file name).yaml
gremlin> :remote console
```
Ini berfungsi dengan baik, dan memungkinkan Anda mengirim kueri ke Neptunus. Namun, itu mengeluarkan mesin skrip Groovy dari loop, jadi Neptunus memperlakukan semua kueri sebagai Gremlin murni. Ini berarti bahwa formulir kueri berikut gagal:
```
gremlin> 1 + 1
gremlin> x = g.V().count()
```
Yang paling dekat yang bisa Anda dapatkan menggunakan variabel saat terhubung dengan cara ini adalah dengan menggunakan `result` variabel yang dikelola oleh konsol dan mengirim kueri menggunakan`:>`, seperti ini:
```
gremlin> :remote console
==>All scripts will now be evaluated locally - type ':remote console' to return to remote mode for Gremlin Server - [krl-1-cluster.cluster-ro-cm9t6tfwbtsr.us-east-1.neptune.amazonaws.com/172.31.19.217:8182]
gremlin> :> g.V().count()
==>4249
gremlin> println(result)
[result{object=4249 class=java.lang.Long}]
gremlin> println(result['object'])
[4249]
```
**Cara berbeda untuk terhubung**
Anda juga dapat terhubung ke konsol Gremlin dengan cara yang berbeda, yang mungkin Anda temukan lebih bagus, seperti ini:
```
gremlin> g = traversal().withRemote('conf/neptune.properties')
```
Di sini `neptune.properties` mengambil formulir ini:
```
gremlin.remote.remoteConnectionClass=org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection
gremlin.remote.driver.clusterFile=conf/my-cluster.yaml
gremlin.remote.driver.sourceName=g
```
`my-cluster.yaml`File akan terlihat seperti ini:
```
hosts: [my-cluster-abcdefghijk.us-east-1.neptune.amazonaws.com]
port: 8182
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1,
config: { serializeResultToString: false } }
connectionPool: { enableSsl: true }
```
**catatan**
Serializer dipindahkan dari `gremlin-driver` modul ke `gremlin-util` modul baru di versi 3.7.0. Paket diubah dari org.apache.tinkerpop.gremlin.driver.ser menjadi org.apache.tinkerpop.gremlin.util.ser.
Mengkonfigurasi koneksi konsol Gremlin seperti itu memungkinkan Anda membuat jenis kueri berikut dengan sukses:
```
gremlin> 1+1
==>2
gremlin> x=g.V().count().next()
==>4249
gremlin> println("The answer was ${x}")
The answer was 4249
```
Anda dapat menghindari menampilkan hasilnya, seperti ini:
```
gremlin> x=g.V().count().next();[]
gremlin> println(x)
4249
```
Semua cara kueri yang biasa (tanpa langkah terminal) terus berfungsi. Contoh:
```
gremlin> g.V().count()
==>4249
```
Anda bahkan dapat menggunakan [https://tinkerpop.apache.org/docs/current/reference/#io-step](https://tinkerpop.apache.org/docs/current/reference/#io-step)langkah untuk memuat file dengan koneksi semacam ini.
## Autentikasi IAM
Neptunus [mendukung otentikasi IAM](iam-auth-enable.md) untuk mengontrol akses ke cluster DB Anda. Jika autentikasi IAM diaktifkan, Anda harus menggunakan penandatanganan Signature Version 4 untuk mengautentikasi permintaan Anda. Untuk instruksi terperinci dan contoh kode untuk menghubungkan dari konsol Gremlin, lihat. [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan konsol Gremlin](iam-auth-connecting-gremlin-console.md)
# Menggunakan titik akhir HTTPS REST untuk menyambung ke instans DB Neptune
Amazon Neptune menyediakan titik akhir HTTPS untuk kueri Gremlin. Antarmuka REST kompatibel dengan apa pun versi Gremlin yang digunakan klaster DB Anda (lihat [halaman rilis mesin](engine-releases.md) dari versi mesin Neptune yang Anda jalankan untuk menentukan rilis Gremlin yang didukungnya).
**catatan**
Sebagaimana dibahas dalam [Mengenkripsi koneksi ke database Amazon Neptunus Anda dengan SSL/HTTPS](security-ssl.md), Neptune sekarang mengharuskan Anda terhubung menggunakan HTTPS dan bukan HTTP. Selain itu, Neptunus saat ini tidak mendukung HTTP/2 untuk permintaan REST API. Klien harus menggunakan HTTP/1.1 saat menghubungkan ke titik akhir.
Petunjuk berikut memandu Anda menyambung ke titik akhir Gremlin menggunakan perintah `curl` dan HTTPS. Anda harus mengikuti petunjuk ini dari instans Amazon EC2 di virtual private cloud (VPC) yang sama seperti instans DB Neptune Anda.
Titik akhir HTTPS untuk kueri Gremlin ke instans DB Neptune adalah `https://your-neptune-endpoint:port/gremlin`.
**catatan**
Untuk informasi tentang menemukan nama host instans DB Neptune Anda, lihat [Menghubungkan ke Titik Akhir Amazon Neptune.](feature-overview-endpoints.md).
## Untuk menyambung ke Neptune menggunakan titik akhir HTTP REST
Contoh berikut menggunakan **curl** untuk mengirimkan kueri Gremlin melalui **POST** HTTP. Kueri dikirimkan dalam format JSON dalam tubuh posting sebagai properti `gremlin`.
```
curl -X POST -d '{"gremlin":"g.V().limit(1)"}' https://your-neptune-endpoint:port/gremlin
```
Contoh ini mengembalikan vertex pertama dalam grafik menggunakan traversal `g.V().limit(1)`. Anda dapat mengajukan kueri untuk sesuatu yang lain dengan menggantinya dengan traversal Gremlin lain.
**penting**
Secara default, titik akhir REST mengembalikan semua hasil dalam satu set hasil JSON. Jika set hasil ini terlalu besar, pengecualian `OutOfMemoryError` dapat terjadi pada instans DB Neptune.
Anda dapat menghindari hal ini dengan mengaktifkan respons bongkahan (hasil dikembalikan dalam serangkaian respons terpisah). Lihat [Gunakan header jejak HTTP opsional untuk mengaktifkan respons multi-bagian Gremlin](access-graph-gremlin-rest-trailing-headers.md).
Meskipun permintaan **POST** HTTP direkomendasikan untuk mengirim kueri Gremlin, tetapi memungkinkan juga untuk menggunakan permintaan **GET** HTTP:
```
curl -G "https://your-neptune-endpoint:port?gremlin=g.V().count()"
```
**catatan**
Neptune tidak mendukung properti `bindings`.
# Gunakan header jejak HTTP opsional untuk mengaktifkan respons multi-bagian Gremlin
Secara default, respons HTTP untuk kueri Gremlin dikembalikan dalam satu set hasil JSON. Dalam kasus set hasil yang sangat besar, ini dapat menyebabkan pengecualian `OutOfMemoryError` pada instans DB.
Namun, Anda dapat mengaktifkan respons *bongkahan* (respons yang dikembalikan dalam beberapa bagian yang terpisah). Anda melakukan ini dengan menyertakan header jejak transfer-encoding (TE) (`te: trailers`) dalam permintaan Anda. Lihat [halaman MDN tentang header permintaan TE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE)) untuk informasi lebih lanjut tentang header TE.
Ketika respons dikembalikan dalam beberapa bagian, akan sulit untuk mendiagnosis masalah yang terjadi setelah bagian pertama diterima, karena bagian pertama tiba dengan kode status HTTP `200` (OK). Kegagalan berikutnya biasanya menghasilkan badan pesan yang berisi respons yang rusak, pada akhirnya Neptune menambahkan pesan kesalahan.
Agar deteksi dan diagnosis kegagalan semacam ini jadi lebih mudah, Neptune juga mencakup dua bidang header baru dalam trailing header dari setiap bongkahan respons:
+ `X-Neptune-Status` – berisi kode respons diikuti dengan nama pendek. Misalnya, dalam kasus keberhasilan, trailing header akan berupa: `X-Neptune-Status: 200 OK`. Dalam kasus kegagalan, kode respon akan menjadi salah satu [kode kesalahan mesin Neptune](errors-engine-codes.md), seperti `X-Neptune-Status: 500 TimeLimitExceededException`.
+ `X-Neptune-Detail` – kosong untuk permintaan yang berhasil. Dalam kasus kesalahan, ia berisi pesan kesalahan JSON. Karena hanya karakter ASCII yang diperbolehkan dalam nilai header HTTP, string JSON di-enkode dengan URL.
**catatan**
Neptune saat ini tidak mendukung kompresi `gzip` respons bongkahan. Jika klien meminta kedua encoding bongkahan dan kompresi pada saat yang sama, Neptune melewatkan kompresi.
# Klien Gremlin berbasis Java untuk digunakan dengan Amazon Neptunus
[Anda dapat menggunakan salah satu dari dua klien Gremlin berbasis Java open-source dengan Amazon Neptunus: klien [Apache TinkerPop Java Gremlin, atau klien Gremlin](https://search.maven.org/artifact/org.apache.tinkerpop/gremlin-driver) untuk Amazon Neptunus.](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client)
## Apache TinkerPop Java Gremlin klien
Apache TinkerPop Java [gremlin-driver](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java) adalah standar, klien Gremlin resmi yang bekerja dengan database grafik -enabled. TinkerPop Gunakan klien ini ketika Anda membutuhkan kompatibilitas maksimum dengan ruang TinkerPop pengembangan yang lebih luas, saat Anda bekerja dengan beberapa sistem database grafik, atau ketika Anda tidak memerlukan manajemen cluster lanjutan dan fitur load balancing khusus untuk Neptunus. Klien ini juga cocok untuk aplikasi sederhana yang terhubung ke satu instance Neptunus atau ketika Anda lebih suka menangani load balancing di tingkat infrastruktur daripada di dalam klien.
**penting**
Memilih versi driver Apache TinkerPop Gremlin yang benar sangat penting untuk kompatibilitas dengan versi mesin Neptunus Anda. Menggunakan versi yang tidak kompatibel dapat mengakibatkan kegagalan koneksi atau perilaku yang tidak terduga. Untuk informasi kompatibilitas versi terperinci, lihat[Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md).
**catatan**
Tabel yang membantu Anda menentukan TinkerPop versi Apache yang benar untuk digunakan dengan Neptunus telah dipindahkan ke. [Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md) Tabel ini sebelumnya terletak di halaman ini selama bertahun-tahun dan sekarang lebih terpusat untuk referensi untuk semua bahasa pemrograman yang TinkerPop mendukung.
## Klien Gremlin Java untuk Amazon Neptunus
Klien Gremlin untuk Amazon Neptunus adalah klien [Gremlin berbasis Java open-source yang bertindak sebagai pengganti drop-in](https://github.com/aws/neptune-gremlin-client) untuk klien Java standar. TinkerPop
Klien Neptunus Gremlin dioptimalkan untuk cluster Neptunus. Ini memungkinkan Anda mengelola distribusi lalu lintas di beberapa instance dalam sebuah cluster, dan beradaptasi dengan perubahan topologi cluster saat Anda menambahkan atau menghapus replika. Anda bahkan dapat mengonfigurasi klien untuk mendistribusikan permintaan di seluruh subset instance di klaster Anda, berdasarkan peran, tipe instans, zona ketersediaan (AZ), atau tag yang terkait dengan instance.
[Versi terbaru dari klien Neptunus Gremlin Java tersedia di Maven](https://search.maven.org/artifact/software.amazon.neptune/gremlin-client) Central.
[Untuk informasi lebih lanjut tentang klien Neptunus Gremlin Java, lihat posting blog ini.](https://aws.amazon.com/blogs/database/load-balance-graph-queries-using-the-amazon-neptune-gremlin-client/) Untuk contoh kode dan demo, lihat [ GitHub proyek klien](https://github.com/aws/neptune-gremlin-client).
Saat memilih versi klien Neptunus Gremlin, Anda perlu mempertimbangkan versi yang TinkerPop mendasarinya sehubungan dengan versi mesin Neptunus Anda. Lihat tabel kompatibilitas di [Mengakses grafik Neptune dengan Gremlin](access-graph-gremlin.md) untuk menentukan TinkerPop versi yang benar untuk mesin Neptunus Anda, lalu gunakan tabel berikut untuk memilih versi klien Neptunus Gremlin yang sesuai:
**Kompatibilitas versi klien Neptunus Gremlin**
| Versi klien Neptunus Gremlin | TinkerPop versi |
| --- | --- |
| 3.x | 3.7.x (AWS SDK for Java 2.x/1.x) |
| 2.1.x | 3.7.x (AWS SDK for Java 1.x) |
| 2.0.x | 3.6.x |
| 1.12 | 3.5.x |
# Menggunakan klien Java untuk terhubung ke instance DB Neptunus
Bagian berikut memandu Anda melalui menjalankan sampel Java lengkap yang terhubung ke instance DB Neptunus dan melakukan traversal Gremlin menggunakan klien Apache Gremlin. TinkerPop
Anda harus mengikuti petunjuk ini dari instans Amazon EC2 di virtual private cloud (VPC) yang sama seperti instans DB Neptune Anda.
**Untuk menyambung ke Neptune menggunakan Java**
1. Install Apache Maven pada instans EC2 Anda. Jika menggunakan Amazon Linux 2023 (lebih disukai), gunakan:
```
sudo dnf update -y
sudo dnf install maven -y
```
Jika menggunakan Amazon Linux 2, unduh biner terbaru dari [https://maven.apache.org/download.cgi:](https://maven.apache.org/download.cgi:)
```
sudo yum remove maven -y
wget https://dlcdn.apache.org/maven/maven-3/ /binaries/apache-maven--bin.tar.gz
sudo tar -xzf apache-maven--bin.tar.gz -C /opt/
sudo ln -sf /opt/apache-maven- /opt/maven
echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
```
1. **Instal Java.** Perpustakaan Gremlin membutuhkan Java 8 atau 11. Anda dapat menginstal Java 11 sebagai berikut:
+ Jika Anda menggunakan [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Jika Anda menggunakan [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html):
```
sudo yum install java-11-amazon-corretto-devel
```
+ Untuk distribusi lain, gunakan salah satu dari berikut ini yang sesuai:
```
sudo yum install java-11-openjdk-devel
```
atau:
```
sudo apt-get install openjdk-11-jdk
```
1. **Setel Java 11 sebagai runtime default pada instans EC2 Anda:** Masukkan yang berikut ini untuk menetapkan Java 8 sebagai runtime default pada instans EC2 Anda:
```
sudo /usr/sbin/alternatives --config java
```
Saat diminta, masukkan nomor untuk Java 11.
1. **Buat direktori baru bernama`gremlinjava`:**
```
mkdir gremlinjava
cd gremlinjava
```
1. Di direktori `gremlinjava`, buat file `pom.xml`, lalu buka file tersebut dalam editor teks:
```
nano pom.xml
```
1. Salin JSON berikut ke dalam file `pom.xml` dan simpan filenya:
```
UTF-84.0.0com.amazonawsGremlinExamplejar1.0-SNAPSHOTGremlinExamplehttps://maven.apache.orgorg.apache.tinkerpopgremlin-driver3.7.2org.slf4jslf4j-jdk141.7.25org.apache.maven.pluginsmaven-compiler-plugin2.5.11111org.codehaus.mojoexec-maven-plugin1.3java-classpathcom.amazonaws.Appcom.amazonaws.App1.11-1
```
**catatan**
Jika Anda memodifikasi proyek Maven yang ada, dependensi yang diperlukan disorot dalam kode sebelumnya.
1. Buat subdirektori untuk kode sumber contoh (`src/main/java/com/amazonaws/`) dengan mengetik teks berikut pada baris perintah:
```
mkdir -p src/main/java/com/amazonaws/
```
1. Di direktori `src/main/java/com/amazonaws/`, buat file bernama `App.java`, lalu buka file tersebut dalam editor teks.
```
nano src/main/java/com/amazonaws/App.java
```
1. Salin hal berikut ke dalam file `App.java`. Ganti *your-neptune-endpoint* dengan alamat instans DB Neptunus Anda. *Jangan* sertakan prefiks `https://` di metode `addContactPoint`.
**catatan**
Untuk informasi tentang menemukan nama host instans DB Neptune Anda, lihat [Menghubungkan ke Titik Akhir Amazon Neptune.](feature-overview-endpoints.md).
```
package com.amazonaws;
import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.structure.T;
public class App
{
public static void main( String[] args )
{
Cluster.Builder builder = Cluster.build();
builder.addContactPoint("your-neptune-endpoint");
builder.port(8182);
builder.enableSsl(true);
Cluster cluster = builder.create();
GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));
// Add a vertex.
// Note that a Gremlin terminal step, e.g. iterate(), is required to make a request to the remote server.
// The full list of Gremlin terminal steps is at https://tinkerpop.apache.org/docs/current/reference/#terminal-steps
g.addV("Person").property("Name", "Justin").iterate();
// Add a vertex with a user-supplied ID.
g.addV("Custom Label").property(T.id, "CustomId1").property("name", "Custom id vertex 1").iterate();
g.addV("Custom Label").property(T.id, "CustomId2").property("name", "Custom id vertex 2").iterate();
g.addE("Edge Label").from(__.V("CustomId1")).to(__.V("CustomId2")).iterate();
// This gets the vertices, only.
GraphTraversal t = g.V().limit(3).elementMap();
t.forEachRemaining(
e -> System.out.println(t.toList())
);
cluster.close();
}
}
```
Untuk bantuan menghubungkan ke Neptunus SSL/TLS dengan (yang diperlukan), lihat. [Konfigurasi SSL/TLS](#access-graph-gremlin-java-ssl)
1. Kompilasikan dan jalankan sampel menggunakan perintah Maven berikut:
```
mvn compile exec:exec
```
Contoh sebelumnya mengembalikan peta kunci dan nilai-nilai masing-masing properti untuk dua vertex pertama dalam grafik menggunakan traversal `g.V().limit(3).elementMap()`. Untuk mengajukan kueri untuk sesuatu yang lain, ganti dengan traversal Gremlin lain dengan salah satu metode ending yang tepat.
**catatan**
Bagian akhir dari kueri Gremlin, `.toList()`, diperlukan untuk mengirimkan traversal ke server untuk evaluasi. Jika Anda tidak menyertakan metode tersebut atau metode setara lain, kueri tidak diserahkan ke instans DB Neptune.
Anda juga harus menambahkan ending yang tepat ketika Anda menambahkan sebuah vertex atau edge, seperti ketika Anda menggunakan langkah `addV( )`.
Metode berikut mengirimkan kueri ke instans DB Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Konfigurasi SSL/TLS untuk klien Gremlin Java
Neptunus harus diaktifkan SSL/TLS secara default. Biasanya, jika driver Java dikonfigurasi dengan`enableSsl(true)`, ia dapat terhubung ke Neptunus tanpa harus mengatur `keyStore()` atau `trustStore()` dengan salinan lokal sertifikat.
Namun, jika instans yang Anda sambungkan tidak memiliki koneksi internet untuk memverifikasi sertifikat publik, atau jika sertifikat yang Anda gunakan tidak bersifat publik, Anda dapat mengambil langkah-langkah berikut untuk mengonfigurasi salinan sertifikat lokal:
**Menyiapkan salinan sertifikat lokal untuk mengaktifkan SSL/TLS**
1. Unduh dan instal [keytool](https://docs.oracle.com/javase/9/tools/keytool.htm#JSWOR-GUID-5990A2E4-78E3-47B7-AE75-6D1826259549) dari Oracle. Ini akan membuat pengaturan toko kunci lokal jauh lebih mudah.
1. Unduh sertifikat `SFSRootCAG2.pem` CA (Gremlin Java SDK memerlukan sertifikatuntuk memverifikasi sertifikat jarak jauh):
```
wget https://www.amazontrust.com/repository/SFSRootCAG2.pem
```
1. Buat toko kunci dalam JKS atau PKCS12 format. Contoh ini menggunakan JKS. Jawab pertanyaan-pertanyaan yang mengikuti pada prompt. Kata sandi yang Anda buat di sini akan dibutuhkan nanti:
```
keytool -genkey -alias (host name) -keyalg RSA -keystore server.jks
```
1. Impor `SFSRootCAG2.pem` file yang Anda unduh ke toko kunci yang baru dibuat:
```
keytool -import -keystore server.jks -file .pem
```
1. Konfigurasikan `Cluster` objek secara terprogram:
```
Cluster cluster = Cluster.build("(your neptune endpoint)")
.port(8182)
.enableSSL(true)
.keyStore(‘server.jks’)
.keyStorePassword("(the password from step 2)")
.create();
```
Anda dapat melakukan hal yang sama dalam file konfigurasi jika Anda mau, seperti yang mungkin Anda lakukan dengan konsol Gremlin:
```
hosts: [(your neptune endpoint)]
port: 8182
connectionPool: { enableSsl: true, keyStore: server.jks, keyStorePassword: (the password from step 2) }
serializer: { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }}
```
## Autentikasi IAM
Neptunus [mendukung otentikasi IAM](iam-auth-enable.md) untuk mengontrol akses ke cluster DB Anda. Jika autentikasi IAM diaktifkan, Anda harus menggunakan penandatanganan Signature Version 4 untuk mengautentikasi permintaan Anda. Untuk petunjuk rinci dan contoh kode untuk menghubungkan dari klien Java, lihat[Menghubungkan ke database Amazon Neptunus menggunakan IAM dengan Gremlin Java](iam-auth-connecting-gremlin-java.md).
# Contoh Java tentang menghubungkan ke instans DB Neptune dengan logika sambungan ulang
Contoh Java berikut menunjukkan cara terhubung ke klien Gremlin dengan logika sambungan ulang untuk pulih dari pemutusan sambungan tak terduga.
Contoh ini memiliki dependensi berikut:
```
org.apache.tinkerpopgremlin-driver${gremlin.version}com.amazonawsamazon-neptune-sigv4-signer${sig4.signer.version}com.evanlennickretry4j0.15.0
```
Berikut adalah kode sampelnya:
**penting**
`CallExecutor`Dari Retry4j mungkin tidak aman untuk utas. Pertimbangkan agar setiap utas menggunakan `CallExecutor` instancenya sendiri, atau gunakan pustaka percobaan ulang yang berbeda.
**catatan**
Contoh berikut telah diperbarui untuk menyertakan penggunaan requestInterceptor (). Ini ditambahkan di TinkerPop 3.6.6. Sebelum TinkerPop versi 3.6.6, contoh kode menggunakan HandshakeInterceptor (), yang tidak digunakan lagi dengan rilis itu.
```
public static void main(String args[]) {
boolean useIam = true;
// Create Gremlin cluster and traversal source
Cluster.Builder builder = Cluster.build()
.addContactPoint(System.getenv("neptuneEndpoint"))
.port(Integer.parseInt(System.getenv("neptunePort")))
.enableSsl(true)
.minConnectionPoolSize(1)
.maxConnectionPoolSize(1)
.serializer(Serializers.GRAPHBINARY_V1D0)
.reconnectInterval(2000);
if (useIam) {
builder.requestInterceptor( r -> {
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
new NeptuneNettyHttpSigV4Signer("(your region)", new DefaultAWSCredentialsProviderChain());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
});
}
Cluster cluster = builder.create();
GraphTraversalSource g = AnonymousTraversalSource
.traversal()
.withRemote(DriverRemoteConnection.using(cluster));
// Configure retries
RetryConfig retryConfig = new RetryConfigBuilder()
.retryOnCustomExceptionLogic(getRetryLogic())
.withDelayBetweenTries(1000, ChronoUnit.MILLIS)
.withMaxNumberOfTries(5)
.withFixedBackoff()
.build();
@SuppressWarnings("unchecked")
CallExecutor