Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Utilitas Amazon Neptunus untuk GraphQL
Utilitas Amazon Neptune untuk [GraphQL](https://graphql.org/) adalah alat baris perintah Node.js open-source yang dapat membantu Anda membuat dan memelihara API GraphQL untuk database grafik properti Neptunus (belum berfungsi dengan data RDF). Ini adalah cara tanpa kode untuk membuat resolver GraphQL untuk kueri GraphQL yang memiliki jumlah parameter input variabel dan mengembalikan sejumlah variabel bidang bersarang.
Ini telah dirilis sebagai proyek sumber terbuka yang berlokasi di [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql).
Anda dapat menginstal utilitas menggunakan NPM seperti ini (lihat [Instalasi dan Pengaturan](tools-graphql-setup.md) untuk detailnya):
```
npm i @aws/neptune-for-graphql -g
```
Utilitas dapat menemukan skema grafik dari grafik properti Neptunus yang ada, termasuk node, tepi, properti, dan kardinalitas tepi. Kemudian menghasilkan skema GraphQL dengan arahan yang diperlukan untuk memetakan tipe GraphQL ke node dan tepi database, dan secara otomatis menghasilkan kode resolver. Kode resolver dirancang untuk meminimalkan latensi dengan hanya mengembalikan data yang diminta oleh kueri GraphQL.
Anda juga dapat memulai dengan skema GraphQL yang ada dan database Neptunus kosong, dan biarkan utilitas menyimpulkan arahan yang diperlukan untuk memetakan skema GraphQL itu ke node dan tepi data yang akan dimuat ke dalam database. Atau, Anda dapat memulai dengan skema GraphQL dan arahan yang telah Anda buat atau modifikasi.
Utilitas ini mampu menciptakan semua AWS sumber daya yang dibutuhkan untuk pipeline, termasuk AWS AppSync API, peran IAM, sumber data, skema, dan resolver, dan fungsi AWS Lambda yang menanyakan Neptunus.
**catatan**
Contoh baris perintah di sini mengasumsikan konsol Linux. Jika Anda menggunakan Windows, ganti garis miring terbalik ('\$1') di akhir baris dengan tanda sisipan ('^').
**Topics**
+ [Menginstal dan menyiapkan utilitas Amazon Neptunus untuk GraphQL](tools-graphql-setup.md)
+ [Memindai data dalam database Neptunus yang ada](tools-graphql-scan-existing.md)
+ [Mulai dari skema GraphQL tanpa arahan](tools-graphql-start-from-schema.md)
+ [Bekerja dengan arahan untuk skema GraphQL](tools-graphql-schema-with-directives.md)
+ [Argumen baris perintah untuk utilitas GraphQL](tools-graphql-cmd-line-args.md)
# Menginstal dan menyiapkan utilitas Amazon Neptunus untuk GraphQL
Jika Anda akan menggunakan utilitas dengan database Neptunus yang ada, Anda memerlukannya untuk dapat terhubung ke titik akhir database. Secara default, database Neptunus hanya dapat diakses dari dalam VPC di mana ia berada.
Karena utilitas adalah alat baris perintah Node.js, Anda harus menginstal Node.js (versi 18 atau lebih tinggi) agar utilitas dapat dijalankan. [Untuk menginstal Node.js pada instans EC2 di VPC yang sama dengan database Neptunus Anda, ikuti petunjuknya di sini.](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html) Contoh ukuran minimum untuk menjalankan utilitas adalah t2.micro. Selama pembuatan instance pilih VPC database Neptunus dari menu pulldown Common Security **Groups**.
Untuk menginstal utilitas itu sendiri pada instans EC2 atau mesin lokal Anda, gunakan NPM:
```
npm i @aws/neptune-for-graphql -g
```
Anda kemudian dapat menjalankan perintah bantuan utilitas untuk memeriksa apakah itu diinstal dengan benar:
```
neptune-for-graphql --help
```
Anda mungkin juga ingin [menginstal AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) untuk mengelola AWS sumber daya.
# Memindai data dalam database Neptunus yang ada
Apakah Anda sudah familiar dengan GraphQL atau tidak, perintah di bawah ini adalah cara tercepat untuk membuat GraphQL API. Ini mengasumsikan bahwa Anda telah menginstal dan mengkonfigurasi utilitas Neptunus untuk GraphQL seperti yang dijelaskan [di bagian instalasi, sehingga terhubung ke](tools-graphql-setup.md) titik akhir database Neptunus Anda.
```
neptune-for-graphql \
--input-graphdb-schema-neptune-endpoint (your neptune database endpoint):(port number) \
--create-update-aws-pipeline \
--create-update-aws-pipeline-name (your new GraphQL API name) \
--output-resolver-query-https
```
Utilitas menganalisis database untuk menemukan skema node, tepi, dan properti di dalamnya. Berdasarkan skema itu, ia menyimpulkan skema GraphQL dengan kueri dan mutasi terkait. Kemudian membuat AppSync GraphQL API dan sumber daya yang AWS diperlukan untuk menggunakannya. Sumber daya ini mencakup sepasang peran IAM dan fungsi Lambda yang berisi kode resolver GraphQL.
Ketika utilitas selesai, Anda akan menemukan GraphQL API baru di konsol AppSync dengan nama yang Anda tetapkan dalam perintah. Untuk mengujinya, gunakan opsi AppSync **Kueri** pada menu.
Jika Anda menjalankan perintah yang sama lagi setelah menambahkan lebih banyak data ke database, akan memperbarui kode AppSync API dan Lambda yang sesuai.
Untuk melepaskan semua sumber daya yang terkait dengan perintah, jalankan:
```
neptune-for-graphql \
--remove-aws-pipeline-name (your new GraphQL API name from above)
```
# Mulai dari skema GraphQL tanpa arahan
Anda dapat memulai dari database Neptunus kosong dan menggunakan skema GraphQL tanpa arahan untuk membuat data dan menanyakannya. Perintah di bawah ini secara otomatis membuat AWS sumber daya untuk melakukan ini:
```
neptune-for-graphql \
--input-schema-file (your GraphQL schema file)
--create-update-aws-pipeline \
--create-update-aws-pipeline-name (name for your new GraphQL API) \
--create-update-aws-pipeline-neptune-endpoint (your Neptune database endpoint):(port number) \
--output-resolver-query-https
```
File skema GraphQL harus menyertakan jenis skema GraphQL, seperti yang ditunjukkan pada contoh TODO di bawah ini. Utilitas menganalisis skema Anda dan membuat versi diperpanjang berdasarkan tipe Anda. Ini menambahkan kueri dan mutasi untuk node yang disimpan dalam database grafik, dan jika skema Anda memiliki tipe bersarang, itu menambahkan hubungan antara tipe yang disimpan sebagai tepi dalam database.
Utilitas membuat AppSync GraphQL API, dan semua AWS sumber daya yang dibutuhkan. Ini termasuk sepasang peran IAM dan fungsi Lambda yang berisi kode resolver GraphQL. Ketika perintah selesai, Anda dapat menemukan GraphQL API baru dengan nama yang Anda tentukan di konsol. AppSync Untuk mengujinya, gunakan **Query** di AppSync menu.
Contoh di bawah ini menggambarkan cara kerjanya:
## Contoh todo, mulai dari skema GraphQL tanpa arahan
Dalam contoh ini kita mulai dari skema Todo GraphQL tanpa arahan, yang dapat Anda temukan di direktori. *???samples???* Ini mencakup dua jenis ini:
```
type Todo {
name: String
description: String
priority: Int
status: String
comments: [Comment]
}
type Comment {
content: String
}
```
Perintah ini memproses skema Todo dan titik akhir database Neptunus kosong untuk membuat GraphQL API di: AWS AppSync
```
neptune-for-graphql /
--input-schema-file ./samples/todo.schema.graphql \
--create-update-aws-pipeline \
--create-update-aws-pipeline-name TodoExample \
--create-update-aws-pipeline-neptune-endpoint (empty Neptune database endpoint):(port number) \
--output-resolver-query-https
```
Utilitas membuat file baru di folder output yang disebut`TodoExample.source.graphql`, dan GraphQL API di. AppSync Utilitas menyimpulkan hal berikut:
+ Pada tipe Todo ditambahkan `@relationship` untuk CommentEdge tipe baru. Ini menginstruksikan resolver untuk menghubungkan Todo ke Komentar menggunakan tepi database grafik yang disebut. CommentEdge
+ Ia menambahkan input baru yang dipanggil TodoInput untuk membantu kueri dan mutasi.
+ Ini menambahkan dua kueri untuk setiap jenis (Todo, Komentar): satu untuk mengambil satu jenis menggunakan `id` atau salah satu bidang jenis yang tercantum dalam input, dan yang lainnya untuk mengambil beberapa nilai, disaring menggunakan input untuk jenis itu.
+ Ini menambahkan tiga mutasi untuk setiap jenis: buat, perbarui, dan hapus. Jenis yang akan dihapus ditentukan menggunakan `id` atau input untuk jenis itu. Mutasi ini mempengaruhi data yang disimpan dalam database Neptunus.
+ Ini menambahkan dua mutasi untuk koneksi: sambungkan dan hapus. Mereka mengambil sebagai input id node dari dari dan ke simpul yang digunakan oleh Neptunus dan koneksi adalah tepi dalam database.
[Penyelesai mengenali kueri dan mutasi berdasarkan namanya, tetapi Anda dapat menyesuaikannya seperti yang ditunjukkan di bawah ini.](tools.md)
Berikut adalah isi dari `TodoExample.source.graphql` file tersebut:
```
type Todo {
_id: ID! @id
name: String
description: String
priority: Int
status: String
comments(filter: CommentInput, options: Options): [Comment] @relationship(type: "CommentEdge", direction: OUT)
bestComment: Comment @relationship(type: "CommentEdge", direction: OUT)
commentEdge: CommentEdge
}
type Comment {
_id: ID! @id
content: String
}
input Options {
limit: Int
}
input TodoInput {
_id: ID @id
name: String
description: String
priority: Int
status: String
}
type CommentEdge {
_id: ID! @id
}
input CommentInput {
_id: ID @id
content: String
}
input Options {
limit: Int
}
type Query {
getNodeTodo(filter: TodoInput, options: Options): Todo
getNodeTodos(filter: TodoInput): [Todo]
getNodeComment(filter: CommentInput, options: Options): Comment
getNodeComments(filter: CommentInput): [Comment]
}
type Mutation {
createNodeTodo(input: TodoInput!): Todo
updateNodeTodo(input: TodoInput!): Todo
deleteNodeTodo(_id: ID!): Boolean
connectNodeTodoToNodeCommentEdgeCommentEdge(from_id: ID!, to_id: ID!): CommentEdge
deleteEdgeCommentEdgeFromTodoToComment(from_id: ID!, to_id: ID!): Boolean
createNodeComment(input: CommentInput!): Comment
updateNodeComment(input: CommentInput!): Comment
deleteNodeComment(_id: ID!): Boolean
}
schema {
query: Query
mutation: Mutation
}
```
Sekarang Anda dapat membuat dan meminta data. Berikut adalah snapshot dari konsol AppSync **Queries** yang digunakan untuk menguji GraphQL API baru, yang dinamai dalam kasus ini. `TodoExampleAPI` Di jendela tengah, Explorer menunjukkan daftar kueri dan mutasi dari mana Anda dapat memilih kueri, parameter input, dan bidang pengembalian. Screenshot ini menunjukkan pembuatan tipe node Todo menggunakan `createNodeTodo` mutasi:
![\[Screenshot yang menampilkan konsol AppSync Queries membuat node Todo\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/todoCreate.png)
Tangkapan layar ini menunjukkan kueri semua node Todo menggunakan kueri: `getNodeTodos`
![\[Screenshot yang menampilkan konsol AppSync Queries yang menanyakan node Todo\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/todoGetTodos.png)
Setelah membuat Komentar menggunakan`createNodeComment`, Anda dapat menggunakan `connectNodeTodoToNodeCommentEdgeCommentEdge` mutasi untuk menghubungkannya dengan menentukan id mereka. Berikut adalah kueri bersarang untuk mengambil Todos dan komentar terlampirnya:
![\[Screenshot yang menampilkan kueri bersarang untuk mengambil Todos dan komentar terlampirnya di konsol Queries AppSync\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/todoNestedQuery.png)
Jika Anda ingin membuat perubahan pada `TodoExample.source.graphql` file seperti yang dijelaskan dalam [Bekerja dengan arahan](tools-graphql-schema-with-directives.md), Anda kemudian dapat menggunakan skema yang diedit sebagai input dan menjalankan utilitas lagi. Utilitas kemudian akan memodifikasi GraphQL API yang sesuai.
# Bekerja dengan arahan untuk skema GraphQL
Anda dapat memulai dari skema GraphQL yang sudah memiliki arahan, menggunakan perintah seperti berikut:
```
neptune-for-graphql \
--input-schema-file (your GraphQL schema file with directives) \
--create-update-aws-pipeline \
--create-update-aws-pipeline-name (name for your new GraphQL API) \
--create-update-aws-pipeline-neptune-endpoint (empty Neptune database endpoint):(port number) \
--output-resolver-query-https
```
Anda dapat memodifikasi arahan yang telah dibuat oleh utilitas atau menambahkan arahan Anda sendiri ke skema GraphQL. Berikut adalah beberapa cara untuk bekerja dengan arahan:
## Menjalankan utilitas sehingga tidak menghasilkan mutasi
Untuk mencegah utilitas menghasilkan muatasi di GraphQL API, gunakan opsi dalam perintah. `--output-schema-no-mutations` `neptune-for-graphql`
## `@alias`Arahan
`@alias`Direktif dapat diterapkan ke jenis atau bidang skema GraphQL. Ini memetakan nama yang berbeda antara database grafik dan skema GraphQL. Sintaksnya adalah:
```
@alias(property: (property name))
```
[Dalam contoh di bawah ini `airport` adalah label node database grafik yang dipetakan ke tipe GraphQL, `desc` dan merupakan properti node grafik yang dipetakan ke bidang (lihat Contoh `description` Rute Udara): `Airport`](tools-graphql.md)
```
type Airport @alias(property: "airport") {
city: String
description: String @alias(property: "desc")
}
```
Perhatikan bahwa pemformatan GraphQL standar memerlukan nama tipe Pascal-casing dan nama bidang casing unta.
## `@relationship`Arahan
`@relationship`Direktif memetakan jenis GraphQL bersarang untuk membuat grafik tepi basis data. Sintaksnya adalah:
```
@relationship(edgeType: (edge name), direction: (IN or OUT))
```
Berikut adalah contoh perintah:
```
type Airport @alias(property: "airport") {
...
continentContainsIn: Continent @relationship(edgeType: "contains", direction: IN)
countryContainsIn: Country @relationship(edgeType: "contains", direction: IN)
airportRoutesOut(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: OUT)
airportRoutesIn(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: IN)
}
```
Anda dapat menemukan `@relationship` arahan dalam contoh [Todo dan Contoh](tools-graphql-start-from-schema.md#tools-graphql-todo-example) [Rute Udara](tools-graphql.md).
## `@graphQuery`Dan `@cypher` arahan
Anda dapat menentukan kueri OpenCypher untuk menyelesaikan nilai bidang, menambahkan kueri, atau menambahkan mutasi. Misalnya, ini menambahkan `outboundRoutesCount` bidang baru ke `Airport` tipe untuk menghitung rute outboud:
```
type Airport @alias(property: "airport") {
...
outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)")
}
```
Berikut contoh kueri dan mutasi baru:
```
type Query {
getAirportConnection(fromCode: String!, toCode: String!): Airport \
@cypher(statement: \
"MATCH (:airport{code: '$fromCode'})-[:route]->(this:airport)-[:route]->(:airport{code:'$toCode'})")
}
type Mutation {
createAirport(input: AirportInput!): Airport @graphQuery(statement: "CREATE (this:airport {$input}) RETURN this")
addRoute(fromAirportCode:String, toAirportCode:String, dist:Int): Route \
@graphQuery(statement: \
"MATCH (from:airport{code:'$fromAirportCode'}), (to:airport{code:'$toAirportCode'}) \
CREATE (from)-[this:route{dist:$dist}]->(to) \
RETURN this")
}
```
Perhatikan bahwa jika Anda menghilangkan`RETURN`, resolver mengasumsikan kata kunci `this` adalah lingkup kembali.
Anda juga dapat menambahkan kueri atau mututasi menggunakan kueri Gremlin:
```
type Query {
getAirportWithGremlin(code:String): Airport \
@graphQuery(statement: "g.V().has('airport', 'code', '$code').elementMap()") # single node
getAirportsWithGremlin: [Airport] \
@graphQuery(statement: "g.V().hasLabel('airport').elementMap().fold()") # list of nodes
getCountriesCount: Int \
@graphQuery(statement: "g.V().hasLabel('country').count()") # scalar
}
```
Pada saat ini kueri Gremlin terbatas pada kueri yang mengembalikan nilai skalar, atau `elementMap()` untuk satu node, atau `elementMap().fold()` untuk daftar node.
## `@id`Arahan
`@id`Direktif mengidentifikasi bidang yang dipetakan ke entitas database `id` grafik. Database grafik seperti Amazon Neptunus selalu memiliki `id` keunikan untuk node dan tepi yang ditetapkan selama impor massal atau yang dibuat secara otomatis. Contoh:
```
type Airport {
_id: ID! @id
city: String
code: String
}
```
## Jenis cadangan, kueri, dan nama mutasi
Utilitas membuat kueri dan mutasi secara otomatis untuk membuat GraphQL API yang berfungsi. Pola nama-nama ini dikenali oleh resolver dan dicadangkan. Berikut adalah contoh untuk tipe `Airport` dan tipe penghubung`Route`:
`Options`Tipe ini dicadangkan.
```
input Options {
limit: Int
}
```
Parameter `filter` dan `options` fungsi dicadangkan.
```
type Query {
getNodeAirports(filter: AirportInput, options: Options): [Airport]
}
```
Awalan getNode dari nama kueri dicadangkan, dan awalan nama mutasi seperti`createNode`,,,,, `updateNode` `deleteNode` `connectNode``deleteNode`, `updateEdge` dan dicadangkan. `deleteEdge`
```
type Query {
getNodeAirport(id: ID, filter: AirportInput): Airport
getNodeAirports(filter: AirportInput): [Airport]
}
type Mutation {
createNodeAirport(input: AirportInput!): Airport
updateNodeAirport(id: ID!, input: AirportInput!): Airport
deleteNodeAirport(id: ID!): Boolean
connectNodeAirportToNodeAirportEdgeRout(from: ID!, to: ID!, edge: RouteInput!): Route
updateEdgeRouteFromAirportToAirport(from: ID!, to: ID!, edge: RouteInput!): Route
deleteEdgeRouteFromAirportToAirport(from: ID!, to: ID!): Boolean
}
```
## Menerapkan perubahan pada skema GraphQL
Anda dapat memodifikasi skema sumber GraphQL dan menjalankan utilitas lagi, mendapatkan skema terbaru dari database Neptunus Anda. Setiap kali utilitas menemukan skema baru dalam database, itu menghasilkan skema GraphQL baru.
Anda juga dapat mengedit skema sumber GraphQL secara manual dan menjalankan utilitas lagi menggunakan skema sumber sebagai input alih-alih titik akhir basis data Neptunus.
Akhirnya, Anda dapat menempatkan perubahan Anda dalam file menggunakan format JSON ini:
```
[
{
"type": "(GraphQL type name)",
"field": "(GraphQL field name)",
"action": "(remove or add)",
"value": "(value)"
}
]
```
Contoh:
```
[
{
"type": "Airport",
"field": "outboundRoutesCountAdd",
"action": "add",
"value":"outboundRoutesCountAdd: Int @graphQuery(statement: \"MATCH (this)-[r:route]->(a) RETURN count(r)\")"
},
{
"type": "Mutation",
"field": "deleteNodeVersion",
"action": "remove",
"value": ""
},
{
"type": "Mutation",
"field": "createNodeVersion",
"action": "remove",
"value": ""
}
]
```
Kemudian, saat Anda menjalankan utilitas pada file ini menggunakan `--input-schema-changes-file` parameter dalam perintah, utilitas menerapkan perubahan Anda sekaligus.
# Argumen baris perintah untuk utilitas GraphQL
+ **`--help, -h`**— Mengembalikan teks bantuan untuk utilitas GraphQL ke konsol.
+ **`--input-schema (schema text)`**— Skema GraphQL, dengan atau tanpa arahan, untuk digunakan sebagai input.
+ **`--input-schema-file (file URL)`**— URL file yang berisi skema GraphQL untuk digunakan sebagai input.
+ **`--input-schema-changes-file (file URL)`**— URL file yang berisi perubahan yang ingin Anda buat pada skema GraphQL. Jika Anda menjalankan utilitas terhadap database Neptunus beberapa kali, dan juga mengubah skema sumber GraphQL secara manual, mungkin menambahkan kueri khusus, chnages manual Anda akan hilang. Untuk menghindari hal ini, letakkan perubahan Anda dalam file perubahan dan teruskan menggunakan argumen ini.
File perubahan menggunakan format JSON berikut:
```
[
{
"type": "(GraphQL type name)",
"field": "(GraphQL field name)",
"action": "(remove or add)",
"value": "(value)"
}
]
```
Lihat [contoh Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) untuk informasi lebih lanjut.
+ **`--input-graphdb-schema (schema text)`**— Alih-alih menjalankan utilitas terhadap database Neptunus, Anda dapat mengekspresikan skema graphdb dalam bentuk teks untuk digunakan sebagai input. Skema graphdb memiliki format JSON seperti ini:
```
{
"nodeStructures": [
{ "label":"nodelabel1",
"properties": [
{ "name":"name1", "type":"type1" }
]
},
{ "label":"nodelabel2",
"properties": [
{ "name":"name2", "type":"type1" }
]
}
],
"edgeStructures": [
{
"label":"label1",
"directions": [
{ "from":"nodelabel1", "to":"nodelabel2", "relationship":"ONE-ONE|ONE-MANY|MANY-MANY" }
],
"properties": [
{ "name":"name1", "type":"type1" }
]
}
]
}
```
+ **`--input-graphdb-schema-file (file URL)`**— Alih-alih menjalankan utilitas terhadap database Neptunus, Anda dapat menyimpan skema graphdb dalam file untuk digunakan sebagai input. Lihat `--input-graphdb-schema` di atas untuk contoh format JSON untuk file skema graphdb.
+ **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`**— Database Neptunus menunjukkan dari mana utilitas harus mengekstrak skema graphdb.
+ **`--output-schema-file (file name)`**- Nama file output untuk skema GraphQL. Jika tidak ditentukan, defaultnya adalah`output.schema.graphql`, kecuali nama pipeline telah disetel menggunakan`--create-update-aws-pipeline-name`, dalam hal ini nama file default adalah`(pipline name).schema.graphql`.
+ **`--output-source-schema-file (file name)`**- Nama file output untuk skema GraphQL dengan arahan. Jika tidak ditentukan, defaultnya adalah`output.source.schema.graphql`, kecuali nama pipeline telah disetel menggunakan`--create-update-aws-pipeline-name`, dalam hal ini nama defaultnya adalah`(pipeline name).source.schema.graphql`.
+ **`--output-schema-no-mutations`**— Jika argumen ini ada, utilitas tidak menghasilkan mutasi di GraphQL API, hanya kueri.
+ **`--output-neptune-schema-file (file name)`**— Nama file output untuk skema Neptunus graphdb yang ditemukan utilitas. Jika tidak ditentukan, defaultnya adalah`output.graphdb.json`, kecuali nama pipeline telah disetel menggunakan`--create-update-aws-pipeline-name`, dalam hal ini nama file default adalah`(pipeline name).graphdb.json`.
+ **`--output-js-resolver-file (file name)`**— Nama file output untuk salinan kode resolver. Jika tidak ditentukan, defaultnya adalah`output.resolver.graphql.js`, kecuali nama pipeline telah disetel menggunakan`--create-update-aws-pipeline-name`, dalam hal ini nama file tersebut`(pipeline name).resolver.graphql.js`.
File ini di-zip dalam paket kode yang diunggah ke fungsi Lambda yang menjalankan resolver.
+ **`--output-resolver-query-sdk`**[— Argumen ini menetapkan bahwa fungsi Lambda utilitas harus menanyakan Neptunus menggunakan SDK data Neptunus, yang telah tersedia dimulai dengan mesin Neptunus versi 1.2.1.0.R5 (ini adalah default).](engine-releases-1.2.1.0.R5.md) Namun, jika utilitas mendeteksi versi mesin Neptunus yang lebih lama, itu menyarankan untuk menggunakan opsi Lambda HTTPS sebagai gantinya, yang dapat Anda panggil menggunakan argumen. `--output-resolver-query-https`
+ **`--output-resolver-query-https`**— Argumen ini menetapkan bahwa fungsi Lambda utilitas harus menanyakan Neptunus menggunakan API HTTPS Neptunus.
+ **`--create-update-aws-pipeline`**- Argumen ini memicu pembuatan AWS sumber daya untuk GraphQL API untuk digunakan, termasuk GraphQL API dan AppSync Lambda yang menjalankan resolver.
+ **`--create-update-aws-pipeline-name (pipeline name)`**— Argumen ini menetapkan nama untuk pipeline, seperti `pipeline-name` API untuk AppSync atau `pipeline-name` fungsi untuk fungsi Lambda. Jika nama tidak ditentukan, `--create-update-aws-pipeline` gunakan nama `Neptune ` database.
+ **`--create-update-aws-pipeline-region (AWS region)`**— Argumen ini menetapkan AWS wilayah di mana pipeline untuk GraphQL API dibuat. Jika tidak ditentukan, wilayah default adalah salah satu `us-east-1` atau wilayah tempat database Neptunus berada, diekstraksi dari titik akhir database.
+ **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`**Argumen ini menetapkan endpoint database Neptunus yang digunakan oleh fungsi Lambda untuk query database. Jika tidak disetel, titik akhir yang ditetapkan oleh `--input-graphdb-schema-neptune-endpoint` digunakan.
+ **`--remove-aws-pipeline-name (pipeline name)`**— Argumen ini menghapus pipeline yang dibuat menggunakan`--create-update-aws-pipeline`. Sumber daya yang akan dihapus tercantum dalam file bernama`(pipeline name).resources.json`.
+ **`--output-aws-pipeline-cdk`**Argumen ini memicu pembuatan file CDK yang dapat digunakan untuk membuat AWS sumber daya untuk GraphQL API, termasuk GraphQL API dan fungsi Lambda yang menjalankan AppSync resolver.
+ **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`**Argumen ini menetapkan titik akhir database Neptunus yang digunakan oleh fungsi Lambda untuk menanyakan database Neptunus. Jika tidak disetel, titik akhir yang ditetapkan oleh `--input-graphdb-schema-neptune-endpoint` digunakan.
+ **`--output-aws-pipeline-cdk-name (pipeline name)`**— Argumen ini menetapkan nama pipeline untuk AppSync API dan fungsi nama pipeline Lambda yang akan digunakan. Jika tidak ditentukan, `--create-update-aws-pipeline` gunakan nama database Neptunus.
+ **`--output-aws-pipeline-cdk-region (AWS region)`**— Ini menetapkan AWS wilayah di mana pipeline untuk GraphQL API dibuat. Jika tidak ditentukan, default ke `us-east-1` atau wilayah di mana database Neptunus berada, diekstraksi dari titik akhir database.
+ **`--output-aws-pipeline-cdk-file (file name)`**— Ini menetapkan nama file CDK. Jika tidak diatur defaultnya adalah`(pipeline name)-cdk.js`.