Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengakses data grafik di Amazon Neptunus
Anda dapat berinteraksi dengan cluster Amazon Neptunus DB setelah membuat koneksi. Ini melibatkan pemuatan data, mengeksekusi kueri, dan melakukan operasi lainnya. Sebagian besar pengguna memanfaatkan alat `awscurl` baris perintah `curl` atau untuk berkomunikasi dengan cluster DB Neptunus secara efektif. Alat-alat ini memungkinkan Anda mengirim permintaan, memuat data, dan mengambil hasil dari database grafik, memfasilitasi manajemen data yang mulus dan kemampuan kueri.
## Menyiapkan `curl` untuk berkomunikasi dengan titik akhir Neptunus Anda
Seperti diilustrasikan dalam banyak contoh dalam dokumentasi ini, alat baris perintah [curl](https://curl.haxx.se/) adalah pilihan berguna untuk berkomunikasi dengan titik akhir Neptune Anda. Untuk informasi tentang alat tersebut, lihat [halaman curl man](https://curl.haxx.se/docs/manpage.html), dan buku *[Semuanya curl](https://ec.haxx.se/)*.
Untuk menyambung menggunakan HTTPS (seperti yang kami sarankan dan seperti yang dibutuhkan Neptune di sebagian besar Wilayah), `curl` membutuhkan akses ke sertifikat yang sesuai. Untuk mempelajari cara mendapatkan sertifikat ini dan cara memformat mereka dengan benar ke penyimpanan sertifikat otoritas sertifikat (CA) yang dapat digunakan `curl`, lihat [Verifikasi Sertifikat SSL](https://curl.haxx.se/docs/sslcerts.html) dalam dokumentasi `curl`.
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).
Selama `curl` dapat menemukan sertifikat yang sesuai, ia menangani koneksi HTTPS seperti koneksi HTTP, tanpa parameter tambahan. Contoh dalam dokumentasi ini didasarkan pada skenario tersebut.
## Menggunakan bahasa kueri untuk mengakses data grafik di cluster DB Neptunus Anda
Setelah Anda terhubung, Anda dapat menggunakan bahasa kueri Gremlin dan OpenCypher untuk membuat dan menanyakan grafik properti, atau bahasa kueri SPARQL untuk membuat dan menanyakan grafik yang berisi data RDF.
**Bahasa kueri grafik yang didukung oleh Neptunus**
+ [Gremlin](access-graph-gremlin.md) adalah bahasa traversal grafik untuk grafik properti. Sebuah kueri di Gremlin adalah sebuah traversal yang terdiri dari langkah-langkah berlainan, yang masing-masing mengikuti edge ke simpul. Lihat dokumentasi Gremlin di [Apache TinkerPop](https://tinkerpop.apache.org/docs/current/reference/) untuk informasi lebih lanjut.
Implementasi Neptune dari Gremlin memiliki beberapa perbedaan dari implementasi lain, terutama ketika Anda menggunakan Gremlin-Groovy (kueri Gremlin dikirim sebagai teks serial). Untuk informasi selengkapnya, lihat [Kepatuhan standar Gremlin di Amazon Neptune](access-graph-gremlin-differences.md).
+ [OpenCypher](access-graph-opencypher.md) [adalah bahasa query deklaratif untuk grafik properti yang awalnya dikembangkan oleh Neo4j, kemudian open-source pada tahun 2015, dan berkontribusi pada proyek OpenCypher di bawah lisensi open-source Apache 2.](http://www.opencypher.org/) Sintaksnya didokumentasikan dalam [Referensi Bahasa Kueri Cypher, Versi 9](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf).
+ [SPARQL](access-graph-sparql.md) [adalah bahasa query deklaratif untuk data [RDF](https://www.w3.org/2001/sw/wiki/RDF), berdasarkan pencocokan pola grafik yang distandarisasi oleh World Wide Web Consortium (W3C) dan dijelaskan dalam SPARQL 1.1 Ikhtisar) dan spesifikasi [SPARQL](https://www.w3.org/TR/sparql11-overview/) 1.1 Query Language.](https://www.w3.org/TR/sparql11-query/)
**catatan**
Anda dapat mengakses data grafik properti di Neptunus menggunakan Gremlin dan OpenCypher, tetapi tidak menggunakan SPARQL. Demikian pula, Anda hanya dapat mengakses data RDF menggunakan SPARQL, bukan Gremlin atau OpenCypher.
# Menggunakan Gremlin untuk mengakses data grafik di Amazon Neptunus
Anda dapat menggunakan Konsol Gremlin untuk bereksperimen dengan TinkerPop grafik dan kueri di lingkungan REPL (loop). read-eval-print
Tutorial berikut memandu Anda melalui menggunakan konsol Gremlin untuk menambahkan vertex, edge, properti, dan banyak lagi ke grafik Neptune, menyoroti beberapa perbedaan dalam implementasi Gremlin khusus Neptune.
**catatan**
Contoh ini mengasumsikan bahwa Anda telah menyelesaikan hal berikut ini:
Anda telah terhubung menggunakan SSH ke instans Amazon EC2.
Anda telah membuat sebuah klaster Neptune seperti yang dijelaskan di [Buat cluster Neptunus](get-started-create-cluster.md).
Anda telah menginstal konsol Gremlin seperti yang diterangkan dalam [Menginstal konsol Gremlin](access-graph-gremlin-console.md).
**Menggunakan Konsol Gremlin**
1. Ubah direktori ke dalam folder tempat file konsol Gremlin di-unzip.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. 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 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. **Tambahkan vertex dengan label dan properti.**
```
g.addV('person').property('name', 'justin')
```
Vertex ditugaskan ID `string` yang berisi GUID. Semua simpul IDs adalah string di Neptunus.
1. **Tambahkan simpul dengan id kustom.**
```
g.addV('person').property(id, '1').property('name', 'martin')
```
Properti `id` tidak dikutip. Ini adalah kata kunci untuk ID vertex. ID vertex di sini adalah string dengan nomor `1` di dalamnya.
Nama properti normal harus berada di dalam tanda kutip.
1. **Ubah properti atau tambahkan properti jika tidak ada.**
```
g.V('1').property(single, 'name', 'marko')
```
Di sini Anda mengubah properti `name` untuk vertex dari langkah sebelumnya. Ini akan menghapus semua nilai yang ada dari properti `name`.
Jika Anda tidak menentukan `single`, ia justru akan menambahkan nilainya ke properti `name` jika belum dilakukannya.
1. **Tambahkan properti, tetapi tambahkan properti jika properti sudah memiliki nilai.**
```
g.V('1').property('age', 29)
```
Neptune menggunakan set secara kardinal sebagai tindakan default.
Perintah ini menambahkan properti `age` dengan nilai `29`, tetapi tidak menggantikan nilai yang ada.
Jika properti `age` sudah memiliki nilai, perintah ini menambahkan `29` ke properti. Sebagai contoh, jika properti `age` adalah `27`, nilai baru akan menjadi `[ 27, 29 ]`.
1. **Tambahkan beberapa simpul.**
```
g.addV('person').property(id, '2').property('name', 'vadas').property('age', 27).iterate()
g.addV('software').property(id, '3').property('name', 'lop').property('lang', 'java').iterate()
g.addV('person').property(id, '4').property('name', 'josh').property('age', 32).iterate()
g.addV('software').property(id, '5').property('name', 'ripple').property('lang', 'java').iterate()
g.addV('person').property(id, '6').property('name', 'peter').property('age', 35)
```
Anda dapat mengirim beberapa pernyataan pada saat yang sama ke Neptune.
Pernyataan dapat dipisahkan dengan baris baru (`'\n'`), spasi (`' '`), titik koma (`'; '`), atau kosong (misalnya: `g.addV(‘person’).iterate()g.V()` berlaku).
**catatan**
Konsol Gremlin mengirimkan perintah terpisah di setiap baris baru (`'\n'`), sehingga masing-masing mereka menjadi transaksi terpisah dalam kasus itu. Contoh ini memiliki semua perintah pada baris terpisah untuk dibaca. Hapus baris baru karakter (`'\n'`) untuk mengirimkannya sebagai perintah tunggal melalui Konsol Gremlin.
Semua pernyataan selain pernyataan terakhir harus diakhiri dengan langkah pengakhiran, seperti `.next()` atau `.iterate()`, atau mereka tidak akan berjalan. Konsol Gremlin tidak memerlukan langkah-langkah pengakhiran ini. Gunakan `.iterate` setiap kali Anda tidak memerlukan hasil yang akan diserialkan.
Semua pernyataan yang dikirim bersama-sama disertakan dalam satu transaksi dan berhasil atau gagal bersama-sama.
1. **Tambahkan tepi.**
```
g.V('1').addE('knows').to(__.V('2')).property('weight', 0.5).iterate()
g.addE('knows').from(__.V('1')).to(__.V('4')).property('weight', 1.0)
```
Berikut adalah dua cara berbeda untuk menambahkan edge.
1. **Tambahkan sisa grafik Modern.**
```
g.V('1').addE('created').to(__.V('3')).property('weight', 0.4).iterate()
g.V('4').addE('created').to(__.V('5')).property('weight', 1.0).iterate()
g.V('4').addE('knows').to(__.V('3')).property('weight', 0.4).iterate()
g.V('6').addE('created').to(__.V('3')).property('weight', 0.2)
```
1. **Hapus simpul.**
```
g.V().has('name', 'justin').drop()
```
Menghapus vertex dengan properti `name` sama dengan `justin`.
**penting**
*Berhenti di sini, dan Anda memiliki grafik Apache TinkerPop Modern lengkap. Contoh di [bagian Traversal](https://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps) TinkerPop dokumentasi menggunakan grafik Modern.*
1. **Jalankan traversal.**
```
g.V().hasLabel('person')
```
Mengembalikan semua vertex `person`.
1. **Jalankan Traversal dengan nilai (valueMap ()).**
```
g.V().has('name', 'marko').out('knows').valueMap()
```
Mengembalikan kunci, pasangan nilai untuk semua vertex yang “diketahui” `marko`.
1. **Tentukan beberapa label.**
```
g.addV("Label1::Label2::Label3")
```
Neptune mendukung beberapa label untuk sebuah vertex. Ketika Anda membuat label, Anda dapat menentukan beberapa label dengan memisahkannya dengan `::`.
Contoh ini menambahkan sebuah vertex dengan tiga label yang berbeda.
Langkah `hasLabel` cocok dengan vertex ini dengan salah satu dari tiga label tersebut: `hasLabel("Label1")`, `hasLabel("Label2")`, dan `hasLabel("Label3")`.
Pembatas `::` dicadangkan untuk penggunaan ini saja.
Anda tidak dapat menentukan beberapa label di langkah `hasLabel`. Misalnya, `hasLabel("Label1::Label2")` tidak cocok dengan apa pun.
1. **Tentukan Waktu/tanggal**.
```
g.V().property(single, 'lastUpdate', datetime('2018-01-01T00:00:00'))
```
Neptune tidak mendukung Java Date. Gunakan `datetime()` fungsi sebagai gantinya. `datetime()`menerima string ISO8061 `datetime` -compliant.
Mendukung format berikut: `YYYY-MM-DD, YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:SS`, dan `YYYY-MM-DDTHH:mm:SSZ`.
1. **Hapus simpul, properti, atau tepi.**
```
g.V().hasLabel('person').properties('age').drop().iterate()
g.V('1').drop().iterate()
g.V().outE().hasLabel('created').drop()
```
Berikut adalah beberapa contoh drop.
**catatan**
Langkah `.next()` tidak bekerja dengan `.drop()`. Gunakan `.iterate()` sebagai gantinya.
1. Setelah selesai, masukkan yang berikut ini untuk keluar dari Gremlin Console.
```
:exit
```
**catatan**
Gunakan titik koma (`;`) atau karakter baris baru (`\n`) untuk memisahkan setiap pernyataan.
Setiap traversal sebelum traversal akhir harus diakhiri dengan `iterate()` yang akan dieksekusi. Hanya data dari traversal akhir yang dikembalikan.
# Menggunakan OpenCypher untuk mengakses data grafik di Amazon Neptunus
[Untuk mulai menggunakan OpenCypher, lihat[OpenCypher](access-graph-opencypher.md), atau gunakan notebook OpenCypher di repositori graf-notebook Neptunus. GitHub ](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks)
# Menggunakan SPARQL untuk mengakses data grafik di Amazon Neptunus
SPARQL adalah bahasa kueri untuk Resource Description Framework (RDF), yang merupakan format data grafik yang dirancang untuk web. Amazon Neptune kompatibel dengan SPARQL 1.1. Ini berarti bahwa Anda dapat terhubung ke instans DB Neptune dan mengajukan kueri grafik menggunakan bahasa kueri yang dijelaskan dalam spesifikasi [Bahasa Kueri SPARQL 1.1](https://www.w3.org/TR/sparql11-query/).
Sebuah kueri di SPARQL terdiri dari klausa `SELECT` untuk menentukan variabel yang akan dikembalikan dan klausa `WHERE` untuk menentukan data yang mana yang akan dicocokkan dalam grafik. Jika Anda tidak terbiasa dengan kueri SPARQL, lihat [Menulis Kueri Sederhana](https://www.w3.org/TR/sparql11-query/#WritingSimpleQueries) dalam [Bahasa Kueri SPARQL 1.1](https://www.w3.org/TR/sparql11-query/).
Titik akhir HTTP untuk kueri SPARQL ke instans DB Neptune adalah: `https://your-neptune-endpoint:port/sparql`.
**Untuk terhubung ke SPARQL**
1. **Anda bisa mendapatkan titik akhir SPARQL untuk cluster Neptunus Anda dari **SparqlEndpoint**item di bagian Output tumpukan.** CloudFormation
1. Masukkan hal berikut untuk mengirimkan **`UPDATE`** SPARQL menggunakan HTTP `POST` dan perintah **curl**.
```
curl -X POST --data-binary 'update=INSERT DATA { . }' https://your-neptune-endpoint:port/sparql
```
Contoh sebelumnya menyisipkan tripel berikut ke dalam grafik default SPARQL: ` `
1. Masukkan hal berikut untuk mengirimkan **`QUERY`** SPARQL menggunakan HTTP `POST` dan perintah **curl**.
```
curl -X POST --data-binary 'query=select ?s ?p ?o where {?s ?p ?o} limit 10' https://your-neptune-endpoint:port/sparql
```
Contoh sebelumnya mengembalikan hingga 10 dari triple (subject-predicate-object) dalam grafik dengan menggunakan `?s ?p ?o` query dengan batas 10. Untuk mengajukan kueri untuk sesuatu yang lain, gantikan dengan kueri SPARQL lain.
**catatan**
Jenis MIME default respon adalah `application/sparql-results+json` untuk kueri `SELECT` dan `ASK`.
Jenis MIME default respon adalah `application/n-quads` untuk kueri `CONSTRUCT` dan `DESCRIBE`.
Untuk daftar semua jenis MIME yang tersedia, lihat [API HTTP SPARQL](sparql-api-reference.md).