Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membuat kueri dasar (VTL)
**catatan**
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
GraphQL resolver menghubungkan bidang dalam skema tipe ke sumber data. Resolver adalah mekanisme dimana permintaan dipenuhi. AWS AppSync dapat secara otomatis membuat dan menghubungkan resolver dari skema atau membuat skema dan menghubungkan resolver dari tabel yang ada tanpa Anda perlu menulis kode apa pun.
Resolver AWS AppSync digunakan JavaScript untuk mengonversi ekspresi GraphQL menjadi format yang dapat digunakan sumber data. Atau, template pemetaan dapat ditulis dalam [Apache Velocity Template Language (VTL) untuk](https://velocity.apache.org/engine/2.0/vtl-reference.html) mengubah ekspresi GraphQL menjadi format yang dapat digunakan sumber data.
Bagian ini akan menunjukkan cara mengkonfigurasi resolver menggunakan VTL. [Panduan pemrograman gaya tutorial pengantar untuk menulis resolver dapat ditemukan di panduan pemrograman [template pemetaan Resolver, dan utilitas pembantu yang tersedia untuk digunakan ketika pemrograman](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide) dapat ditemukan di referensi konteks template pemetaan Resolver.](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync juga memiliki alur pengujian dan debug bawaan yang dapat Anda gunakan saat mengedit atau menulis dari awal. Untuk informasi selengkapnya, lihat [Menguji dan men-debug resolver](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Sebaiknya ikuti panduan ini sebelum mencoba menggunakan salah satu tutorial yang disebutkan di atas.
Di bagian ini, kita akan membahas cara membuat resolver, menambahkan resolver untuk mutasi, dan menggunakan konfigurasi lanjutan.
## Buat resolver pertama Anda
Mengikuti contoh dari bagian sebelumnya, langkah pertama adalah membuat resolver untuk tipe Anda`Query`.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSync konsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Di sisi kanan halaman, ada jendela yang disebut **Resolvers**. Kotak ini berisi daftar jenis dan bidang seperti yang didefinisikan dalam jendela **Skema** Anda di sisi kiri halaman. Anda dapat melampirkan resolver ke bidang. Misalnya, di bawah Jenis **kueri**, pilih **Lampirkan** di sebelah `getTodos` bidang.
1. Pada halaman **Create Resolver**, pilih sumber data yang Anda buat dalam panduan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). Di jendela **Konfigurasikan templat pemetaan**, Anda dapat memilih templat pemetaan permintaan umum dan respons menggunakan daftar drop-down di sebelah kanan atau menulis sendiri.
**catatan**
Pasangan template pemetaan permintaan ke template pemetaan respons disebut resolver unit. Resolver unit biasanya dimaksudkan untuk melakukan operasi hafalan; kami sarankan menggunakannya hanya untuk operasi tunggal dengan sejumlah kecil sumber data. Untuk operasi yang lebih kompleks, sebaiknya gunakan resolver pipa, yang dapat menjalankan beberapa operasi dengan beberapa sumber data secara berurutan.
Untuk informasi selengkapnya tentang perbedaan antara templat pemetaan permintaan dan respons, lihat Resolver [unit](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Untuk informasi selengkapnya tentang penggunaan resolver pipeline, lihat [Pipeline](pipeline-resolvers.md#aws-appsync-pipeline-resolvers) resolvers.
1. Untuk kasus penggunaan umum, AWS AppSync konsol memiliki templat bawaan yang dapat Anda gunakan untuk mendapatkan item dari sumber data (misalnya, semua kueri item, pencarian individual, dll.). Misalnya, pada versi sederhana skema dari [Merancang skema Anda](designing-your-schema.md#aws-appsync-designing-your-schema) di mana `getTodos` tidak memiliki pagination, template pemetaan permintaan untuk item daftar adalah sebagai berikut:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Anda selalu membutuhkan template pemetaan respons untuk menyertai permintaan. Konsol menyediakan default dengan nilai passthrough berikut untuk daftar:
```
$util.toJson($ctx.result.items)
```
Dalam contoh ini, `context` objek (alias sebagai`$ctx`) untuk daftar item memiliki formulir`$context.result.items`. Jika operasi GraphQL Anda mengembalikan satu item, itu akan menjadi. `$context.result` AWS AppSync menyediakan fungsi pembantu untuk operasi umum, seperti `$util.toJson` fungsi yang tercantum sebelumnya, untuk memformat respons dengan benar. Untuk daftar lengkap fungsi, lihat Referensi utilitas [template pemetaan Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. Pilih **Simpan Resolver**.
------
#### [ API ]
1. Buat objek resolver dengan memanggil API. [https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)
1. Anda dapat memodifikasi bidang resolver dengan memanggil API. [https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)
------
#### [ CLI ]
1. Buat resolver dengan menjalankan perintah. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)
Anda harus mengetikkan 6 parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `type-name`Jenis yang ingin Anda modifikasi dalam skema Anda. Dalam contoh konsol, ini adalah`Query`.
1. `field-name`Bidang yang ingin Anda modifikasi dalam tipe Anda. Dalam contoh konsol, ini adalah`getTodos`.
1. Sumber data yang Anda buat dalam panduan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). `data-source-name`
1. Itu`request-mapping-template`, yang merupakan badan permintaan. Dalam contoh konsol, ini adalah:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Itu`response-mapping-template`, yang merupakan tubuh respons. Dalam contoh konsol, ini adalah:
```
$util.toJson($ctx.result.items)
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Untuk memodifikasi templat and/or pemetaan bidang resolver, jalankan perintah. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)
Dengan pengecualian `api-id` parameter, parameter yang digunakan dalam `create-resolver` perintah akan ditimpa oleh nilai-nilai baru dari `update-resolver` perintah.
------
## Menambahkan resolver untuk mutasi
Langkah selanjutnya adalah membuat resolver untuk tipe Anda`Mutation`.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSync konsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Di bawah jenis **Mutasi**, pilih **Lampirkan** di sebelah `addTodo` bidang.
1. Pada halaman **Create Resolver**, pilih sumber data yang Anda buat dalam panduan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Di jendela **Configure mapping templates**, Anda harus memodifikasi template permintaan karena ini adalah mutasi di mana Anda menambahkan item baru ke DynamoDB. Gunakan template pemetaan permintaan berikut:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync secara otomatis mengonversi argumen yang ditentukan di `addTodo` bidang dari skema GraphQL Anda menjadi operasi DynamoDB. Contoh sebelumnya menyimpan catatan di DynamoDB menggunakan kunci `id` dari, yang dilewatkan dari argumen mutasi sebagai. `$ctx.args.id` Semua bidang lain yang Anda lewati secara otomatis dipetakan ke atribut DynamoDB. `$util.dynamodb.toMapValuesJson($ctx.args)`
Untuk resolver ini, gunakan template pemetaan respons berikut:
```
$util.toJson($ctx.result)
```
AWS AppSync juga mendukung alur kerja pengujian dan debug untuk mengedit resolver. Anda dapat menggunakan `context` objek tiruan untuk melihat nilai template yang diubah sebelum memanggil. Secara opsional, Anda dapat melihat eksekusi permintaan penuh ke sumber data secara interaktif saat menjalankan kueri. Untuk informasi selengkapnya, lihat [Menguji dan men-debug resolver](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) serta [Monitoring](monitoring.md#aws-appsync-monitoring) dan logging.
1. Pilih **Simpan Resolver**.
------
#### [ API ]
Anda juga dapat melakukan ini APIs dengan menggunakan perintah di bagian [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) dan rincian parameter dari bagian ini.
------
#### [ CLI ]
Anda juga dapat melakukan ini di CLI dengan memanfaatkan perintah di bagian [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) dan rincian parameter dari bagian ini.
------
[Pada titik ini, jika Anda tidak menggunakan resolver lanjutan, Anda dapat mulai menggunakan GraphQL API seperti yang diuraikan dalam Menggunakan API Anda.](using-your-api.md#aws-appsync-using-your-api)
## Resolver tingkat lanjut
Jika Anda mengikuti bagian Advanced dan Anda sedang membuat skema sampel dalam [Merancang skema Anda](designing-your-schema.md#aws-appsync-designing-your-schema) untuk melakukan pemindaian paginasi, gunakan template permintaan berikut untuk bidang sebagai gantinya: `getTodos`
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
Untuk kasus penggunaan pagination ini, pemetaan respons lebih dari sekadar passthrough karena harus berisi *kursor* (sehingga klien tahu halaman apa yang akan dimulai selanjutnya) dan set hasil. Template pemetaan adalah sebagai berikut:
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Bidang dalam template pemetaan respons sebelumnya harus sesuai dengan bidang yang ditentukan dalam tipe Anda. `TodoConnection`
Untuk kasus relasi di mana Anda memiliki `Comments` tabel dan Anda menyelesaikan kolom komentar pada `Todo` tipe (yang mengembalikan tipe`[Comment]`), Anda dapat menggunakan template pemetaan yang menjalankan kueri terhadap tabel kedua. Untuk melakukan ini, Anda harus sudah membuat sumber data untuk `Comments` tabel seperti yang diuraikan dalam [Melampirkan sumber data](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch).
**catatan**
Kami menggunakan operasi kueri terhadap tabel kedua hanya untuk tujuan ilustrasi. Anda dapat menggunakan operasi lain terhadap DynamoDB sebagai gantinya. Selain itu, Anda dapat menarik data dari sumber data lain, seperti AWS Lambda atau Amazon OpenSearch Service, karena relasinya dikendalikan oleh skema GraphQL Anda.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSync konsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Di bawah tipe **Todo**, pilih **Lampirkan** di sebelah `comments` bidang.
1. Pada halaman **Create Resolver**, pilih sumber data tabel **Komentar** Anda. Nama default untuk tabel **Komentar** dari panduan mulai cepat adalah`AppSyncCommentTable`, tetapi dapat bervariasi tergantung pada nama yang Anda berikan.
1. Tambahkan cuplikan berikut ke template pemetaan permintaan Anda:
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. `context.source`Referensi objek induk dari bidang saat ini yang sedang diselesaikan. Dalam contoh ini, `source.id` mengacu pada `Todo` objek individu, yang kemudian digunakan untuk ekspresi query.
Anda dapat menggunakan template pemetaan respons passthrough sebagai berikut:
```
$util.toJson($ctx.result.items)
```
1. Pilih **Simpan Resolver**.
1. Terakhir, kembali ke halaman **Skema** di konsol, lampirkan resolver ke `addComment` bidang, dan tentukan sumber data untuk tabel. `Comments` Templat pemetaan permintaan dalam hal ini sederhana `PutItem` dengan spesifik `todoid` yang dikomentari sebagai argumen, tetapi Anda menggunakan `$utils.autoId()` utilitas untuk membuat kunci pengurutan unik untuk komentar sebagai berikut:
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Gunakan template respon passthrough sebagai berikut:
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Anda juga dapat melakukan ini APIs dengan menggunakan perintah di bagian [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) dan rincian parameter dari bagian ini.
------
#### [ CLI ]
Anda juga dapat melakukan ini di CLI dengan memanfaatkan perintah di bagian [Create your first resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) dan rincian parameter dari bagian ini.
------
# Menonaktifkan template pemetaan VTL dengan penyelesai Lambda langsung (VTL)
**catatan**
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
Dengan penyelesai Lambda langsung, Anda dapat menghindari penggunaan templat pemetaan VTL saat menggunakan sumber data. AWS Lambda AWS AppSync dapat memberikan payload default ke fungsi Lambda Anda serta terjemahan default dari respons fungsi Lambda ke tipe GraphQL. Anda dapat memilih untuk memberikan template permintaan, template respons, atau tidak keduanya dan AWS AppSync akan menanganinya sesuai dengan itu.
Untuk mempelajari selengkapnya tentang payload permintaan default dan terjemahan respons yang AWS AppSync disediakan, lihat referensi penyelesai [Lambda Langsung](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Untuk informasi selengkapnya tentang menyiapkan sumber AWS Lambda data dan menyiapkan Kebijakan Kepercayaan IAM, lihat [Melampirkan sumber data](attaching-a-data-source.md).
## Konfigurasikan penyelesai Lambda langsung
Bagian berikut akan menunjukkan cara melampirkan sumber data Lambda dan menambahkan resolver Lambda ke bidang Anda.
### Tambahkan sumber data Lambda
Sebelum Anda dapat mengaktifkan resolver Lambda langsung, Anda harus menambahkan sumber data Lambda.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Sumber data**.
1. Pilih **Buat sumber data**.
1. Untuk **nama sumber data**, masukkan nama untuk sumber data Anda, seperti**myFunction**.
1. Untuk **tipe sumber data**, pilih **AWS Lambda fungsi**.
1. Untuk **Wilayah**, pilih wilayah yang sesuai.
1. Untuk **Fungsi ARN**, pilih fungsi Lambda dari daftar dropdown. Anda dapat mencari nama fungsi atau secara manual memasukkan ARN dari fungsi yang ingin Anda gunakan.
1. Buat peran IAM baru (disarankan) atau pilih peran yang sudah ada yang memiliki izin `lambda:invokeFunction` IAM. Peran yang ada memerlukan kebijakan kepercayaan, seperti yang dijelaskan di bagian [Melampirkan sumber data](attaching-a-data-source.md).
Berikut ini adalah contoh kebijakan IAM yang memiliki izin yang diperlukan untuk melakukan operasi pada sumber daya:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-west-2:123456789012:function:myFunction",
"arn:aws:lambda:us-west-2:123456789012:function:myFunction:*"
]
}
]
}
```
------
1. Pilih tombol **Buat**.
------
#### [ CLI ]
1. Buat objek sumber data dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html)perintah.
Anda harus mengetikkan 4 parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `name`Dari sumber data Anda. Dalam contoh konsol, ini adalah **nama sumber data**.
1. `type`Sumber data. Dalam contoh konsol, ini adalah **AWS Lambda fungsi**.
1. The`lambda-config`, yang merupakan **Fungsi ARN** dalam contoh konsol.
**catatan**
Ada parameter lain seperti `Region` yang harus dikonfigurasi tetapi biasanya akan default ke nilai konfigurasi CLI Anda.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name myFunction --type AWS_LAMBDA --lambda-config lambdaFunctionArn=arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"dataSource": {
"dataSourceArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/datasources/myFunction",
"type": "AWS_LAMBDA",
"name": "myFunction",
"lambdaConfig": {
"lambdaFunctionArn": "arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example"
}
}
}
```
1. Untuk memodifikasi atribut sumber data, jalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html)perintah.
Dengan pengecualian `api-id` parameter, parameter yang digunakan dalam `create-data-source` perintah akan ditimpa oleh nilai-nilai baru dari `update-data-source` perintah.
------
### Aktifkan penyelesai Lambda langsung
Setelah membuat sumber data Lambda dan menyiapkan peran IAM yang sesuai untuk memungkinkan menjalankan fungsi, Anda dapat AWS AppSync menautkannya ke fungsi resolver atau pipeline.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Di jendela **Resolvers**, pilih bidang atau operasi dan kemudian pilih tombol **Lampirkan**.
1. Di halaman **Create new resolver**, pilih fungsi Lambda dari daftar dropdown.
1. **Untuk memanfaatkan penyelesai Lambda langsung, konfirmasikan bahwa templat pemetaan permintaan dan respons dinonaktifkan di bagian Konfigurasi templat pemetaan.**
1. Pilih tombol **Simpan Resolver**.
------
#### [ CLI ]
+ Buat resolver dengan menjalankan perintah. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)
Anda harus mengetikkan 6 parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `type-name`Jenis dalam skema Anda.
1. `field-name`Bidang dalam skema Anda.
1. Nama`data-source-name`, atau fungsi Lambda Anda.
1. Itu`request-mapping-template`, yang merupakan badan permintaan. Dalam contoh konsol, ini dinonaktifkan:
```
" "
```
1. Itu`response-mapping-template`, yang merupakan tubuh respons. Dalam contoh konsol, ini juga dinonaktifkan:
```
" "
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Ketika Anda menonaktifkan template pemetaan Anda, ada beberapa perilaku tambahan yang akan terjadi di AWS AppSync:
+ [Dengan menonaktifkan template pemetaan, Anda memberi sinyal AWS AppSync bahwa Anda menerima terjemahan data default yang ditentukan dalam referensi penyelesai Lambda Langsung.](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers)
+ [Dengan menonaktifkan template pemetaan permintaan, sumber data Lambda Anda akan menerima payload yang terdiri dari seluruh objek Context.](resolver-context-reference.md)
+ Dengan menonaktifkan template pemetaan respons, hasil pemanggilan Lambda Anda akan diterjemahkan tergantung pada versi templat pemetaan permintaan atau jika templat pemetaan permintaan juga dinonaktifkan.
# Menguji dan men-debug resolver di AWS AppSync (VTL)
**catatan**
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync mengeksekusi resolver pada bidang GraphQL terhadap sumber data. Seperti yang dijelaskan dalam [ikhtisar template pemetaan Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview), resolver berkomunikasi dengan sumber data dengan menggunakan bahasa templating. Ini memungkinkan Anda untuk menyesuaikan perilaku dan menerapkan logika dan kondisi sebelum dan sesudah berkomunikasi dengan sumber data. [Untuk panduan pemrograman gaya tutorial pengantar untuk menulis resolver, lihat panduan pemrograman template pemetaan Resolver.](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide)
Untuk membantu pengembang menulis, menguji, dan men-debug resolver ini, AWS AppSync konsol juga menyediakan alat untuk membuat permintaan dan respons GraphQL dengan data tiruan ke penyelesai bidang individual. Selain itu, Anda dapat melakukan kueri, mutasi, dan langganan di AWS AppSync konsol dan melihat aliran log terperinci dari Amazon CloudWatch dari seluruh permintaan. Ini termasuk hasil dari sumber data.
## Pengujian dengan data tiruan
Ketika resolver GraphQL dipanggil, itu berisi objek yang berisi informasi tentang `context` permintaan. Ini termasuk argumen dari klien, informasi identitas, dan data dari bidang GraphQL induk. Ini juga berisi hasil dari sumber data, yang dapat digunakan dalam template respons. Untuk informasi selengkapnya tentang struktur ini dan utilitas pembantu yang tersedia untuk digunakan saat pemrograman, lihat Referensi Konteks Template [Pemetaan Resolver](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
Saat menulis atau mengedit resolver, Anda dapat meneruskan objek *konteks *tiruan* atau pengujian* ke editor konsol. Ini memungkinkan Anda untuk melihat bagaimana permintaan dan template respons mengevaluasi tanpa benar-benar berjalan terhadap sumber data. Misalnya, Anda dapat lulus `firstname: Shaggy` argumen pengujian dan melihat bagaimana itu mengevaluasi saat menggunakan `$ctx.args.firstname` dalam kode template Anda. Anda juga dapat menguji evaluasi setiap pembantu utilitas seperti `$util.autoId()` atau`util.time.nowISO8601()`.
### Menguji penyelesai
Contoh ini akan menggunakan AWS AppSync konsol untuk menguji resolver.
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Jika Anda belum melakukannya, di bawah tipe dan di samping bidang, pilih **Lampirkan** untuk menambahkan resolver Anda.
[Untuk informasi selengkapnya tentang cara membuat resolver conplete, lihat Mengonfigurasi resolver.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html)
Jika tidak, pilih resolver yang sudah ada di lapangan.
1. Di bagian atas halaman **Edit resolver**, **pilih Pilih konteks pengujian, pilih Buat konteks** **baru**.
1. Pilih objek konteks sampel atau isi JSON secara manual di jendela **konteks Eksekusi di bawah** ini.
1. Masukkan **nama konteks Teks**.
1. Pilih tombol **Simpan**.
1. Di bagian atas halaman **Edit Resolver**, pilih **Run** test.
Untuk contoh yang lebih praktis, misalkan Anda memiliki aplikasi yang menyimpan tipe `Dog` GraphQL yang menggunakan pembuatan ID otomatis untuk objek dan menyimpannya di Amazon DynamoDB. Anda juga ingin menulis beberapa nilai dari argumen mutasi GraphQL, dan hanya mengizinkan pengguna tertentu untuk melihat respons. Berikut ini menunjukkan seperti apa skema itu:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Saat Anda menambahkan resolver untuk `addDog` mutasi, Anda dapat mengisi objek konteks seperti contoh berikut. Berikut ini memiliki argumen dari klien `name` dan`age`, dan `username` diisi dalam `identity` objek:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Anda dapat menguji ini menggunakan templat pemetaan permintaan dan respons berikut:
**Templat Permintaan**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Template Respon**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
Template yang dievaluasi memiliki data dari objek konteks pengujian Anda dan nilai yang dihasilkan dari`$util.autoId()`. Selain itu, jika Anda mengubah `username` ke nilai selain`Nadia`, hasilnya tidak akan dikembalikan karena pemeriksaan otorisasi akan gagal. Untuk informasi selengkapnya tentang kontrol akses berbutir halus, lihat Kasus [penggunaan otorisasi](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Menguji template pemetaan dengan's AWS AppSync APIs
Anda dapat menggunakan perintah `EvaluateMappingTemplate` API untuk menguji template pemetaan Anda dari jarak jauh dengan data tiruan. Untuk memulai dengan perintah, pastikan Anda telah menambahkan `appsync:evaluateMappingTemplate` izin ke kebijakan Anda. Contoh:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Anda dapat memanfaatkan perintah dengan menggunakan [AWS CLI](https://aws.amazon.com/cli/)atau [AWS SDKs](https://aws.amazon.com/tools/). Misalnya, ambil `Dog` skema dan templat request/response pemetaannya dari bagian sebelumnya. Menggunakan CLI di stasiun lokal Anda, simpan template permintaan ke file bernama`request.vtl`, lalu simpan `context` objek ke file bernama. `context.json` Dari shell Anda, jalankan perintah berikut:
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
Perintah mengembalikan respon berikut:
```
{
"evaluationResult": "{\n \"version\" : \"2017-02-28\",\n \"operation\" : \"PutItem\",\n \"key\" : {\n \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n },\n \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}
```
`evaluationResult`Berisi hasil pengujian template yang Anda berikan dengan yang disediakan`context`. Anda juga dapat menguji template Anda menggunakan AWS SDKs. Berikut adalah contoh menggunakan AWS SDK untuk JavaScript V2:
```
const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
client
.evaluateMappingTemplate({ template, context })
.promise()
.then((data) => console.log(data))
```
Menggunakan SDK, Anda dapat dengan mudah menggabungkan pengujian dari rangkaian pengujian favorit Anda untuk memvalidasi perilaku template Anda. Sebaiknya buat pengujian menggunakan [Jest Testing Framework](https://jestjs.io/), tetapi rangkaian pengujian apa pun berfungsi. Cuplikan berikut menunjukkan validasi hipotetis berjalan. Perhatikan bahwa kami mengharapkan respons evaluasi menjadi JSON yang valid, jadi kami gunakan `JSON.parse` untuk mengambil JSON dari respons string:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
test('request correctly calls DynamoDB', async () => {
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateMappingTemplate({ template, context }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Ini menghasilkan hasil sebagai berikut:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 1.511 s, estimated 2 s
```
## Mendebug kueri langsung
Tidak ada pengganti untuk end-to-end pengujian dan logging untuk men-debug aplikasi produksi. AWS AppSync memungkinkan Anda mencatat kesalahan dan detail permintaan lengkap menggunakan Amazon CloudWatch. Selain itu, Anda dapat menggunakan AWS AppSync konsol untuk menguji kueri GraphQL, mutasi, dan langganan serta data log streaming langsung untuk setiap permintaan kembali ke editor kueri untuk di-debug secara real time. Untuk langganan, log menampilkan informasi waktu koneksi.
Untuk melakukan ini, Anda harus mengaktifkan CloudWatch log Amazon terlebih dahulu, seperti yang dijelaskan dalam [Pemantauan dan pencatatan](monitoring.md#aws-appsync-monitoring). Selanjutnya, di AWS AppSync konsol, pilih tab **Queries dan kemudian masukkan kueri** GraphQL yang valid. Di bagian kanan bawah, klik dan seret jendela **Log** untuk membuka tampilan log. Di bagian atas halaman, pilih ikon panah putar untuk menjalankan kueri GraphQL Anda. Dalam beberapa saat, log permintaan dan respons lengkap Anda untuk operasi dialirkan ke bagian ini dan Anda dapat melihatnya di konsol.
# Mengkonfigurasi dan menggunakan resolver pipa di AWS AppSync (VTL)
**catatan**
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync mengeksekusi resolver pada bidang GraphQL. Dalam beberapa kasus, aplikasi memerlukan eksekusi beberapa operasi untuk menyelesaikan satu bidang GraphQL. Dengan resolver pipeline, pengembang sekarang dapat membuat operasi yang disebut Fungsi dan menjalankannya secara berurutan. Pipeline resolver berguna untuk aplikasi yang, misalnya, memerlukan melakukan pemeriksaan otorisasi sebelum mengambil data untuk bidang.
Pipeline resolver terdiri dari template **Sebelum** pemetaan, template **After** mapping, dan daftar Functions. Setiap Fungsi memiliki template pemetaan **permintaan** dan **respons** yang dijalankan terhadap sumber data. Karena penyelesai pipa mendelegasikan eksekusi ke daftar fungsi, oleh karena itu tidak ditautkan ke sumber data apa pun. Resolver dan fungsi unit adalah primitif yang menjalankan operasi terhadap sumber data. Lihat [ikhtisar template pemetaan Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview) untuk informasi selengkapnya.
## Langkah 1: Membuat resolver pipa
Di AWS AppSync konsol, buka halaman **Skema**.
Simpan skema berikut:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
**Kita akan memasang resolver pipa ke bidang **SignUp** pada tipe Mutasi.** Pada tipe **Mutasi** di sisi kanan, pilih **Lampirkan** di sebelah bidang `signUp` mutasi. Pada halaman create resolver, klik **Actions**, lalu **Update** runtime. Pilih`Pipeline Resolver`, lalu pilih`VTL`, lalu pilih **Perbarui**. Halaman sekarang harus menampilkan tiga bagian: area teks **Sebelum memetakan template**, bagian **Fungsi**, dan area teks **template Setelah pemetaan**.
Pipeline resolver kami mendaftarkan pengguna dengan terlebih dahulu memvalidasi input alamat email dan kemudian menyimpan pengguna dalam sistem. **Kita akan merangkum validasi email di dalam fungsi ValidateEmail, dan menyimpan pengguna di dalam fungsi **SaveUser**.** **Fungsi **ValidateEmail** dijalankan terlebih dahulu, dan jika email valid, maka fungsi SaveUser dijalankan.**
Alur eksekusi adalah sebagai berikut:
1. Templat pemetaan permintaan resolver mutation.signup
1. fungsi ValidateEmail
1. Fungsi SaveUser
1. Templat pemetaan respons penyelesai mutasi.signup
Karena kami mungkin akan menggunakan kembali fungsi **ValidateEmail** di resolver lain di API kami, kami ingin menghindari mengakses `$ctx.args` karena ini akan berubah dari satu bidang GraphQL ke bidang GraphQL lainnya. Sebagai gantinya, kita dapat menggunakan `$ctx.stash` untuk menyimpan atribut email dari argumen field `signUp(input: Signup)` input.
**SEBELUM** template pemetaan:
```
## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}
```
Konsol menyediakan passthrough default **setelah** template pemetaan yang akan kita gunakan:
```
$util.toJson($ctx.result)
```
Pilih **Buat** atau **Simpan** untuk memperbarui resolver.
## Langkah 2: Membuat fungsi
Dari halaman resolver pipeline, di bagian **Functions**, klik **Add function**, lalu **Create new** function. Dimungkinkan juga untuk membuat fungsi tanpa melalui halaman resolver; untuk melakukan ini, di AWS AppSync konsol, buka halaman **Fungsi**. Pilih tombol **Create Function**. Mari buat fungsi yang memeriksa apakah email valid dan berasal dari domain tertentu. Jika email tidak valid, fungsi tersebut menimbulkan kesalahan. Jika tidak, itu meneruskan input apa pun yang diberikan.
Pada halaman fungsi baru, pilih **Tindakan**, lalu **Perbarui runtime**. Pilih`VTL`, lalu **Perbarui**. Pastikan Anda telah membuat sumber data dari tipe **NONE**. Pilih sumber data ini di daftar **Nama sumber data**. Untuk **nama fungsi**, masukkan`validateEmail`. Di area **kode fungsi**, timpa semuanya dengan cuplikan ini:
```
#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
$util.error("$ctx.stash.email is not a valid email.")
#end
{
"payload": { "email": $util.toJson(${ctx.stash.email}) }
}
```
Tempelkan ini ke template pemetaan respons:
```
$util.toJson($ctx.result)
```
Tinjau perubahan Anda, lalu pilih **Buat**. Kami baru saja membuat fungsi **ValidateEmail** kami. ****Ulangi langkah-langkah ini untuk membuat fungsi SaveUser dengan template pemetaan permintaan dan respons berikut (Demi kesederhanaan, kami menggunakan sumber data NONE dan berpura-pura pengguna telah disimpan dalam sistem setelah fungsi dijalankan.**** ):
Permintaan template pemetaan:
```
## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
"payload": $util.toJson($ctx.prev.result)
}
```
Templat pemetaan respons:
```
## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($ctx.result)
```
Kami baru saja membuat fungsi **SaveUser** kami.
## Langkah 3: Menambahkan fungsi ke resolver pipa
Fungsi kita seharusnya ditambahkan secara otomatis ke resolver pipeline yang baru saja kita buat. Jika ini bukan masalahnya, atau Anda membuat fungsi melalui halaman **Fungsi**, Anda dapat mengklik **Tambahkan fungsi** pada halaman resolver untuk melampirkannya. Tambahkan fungsi **ValidateEmail** **dan SaveUser ke resolver**. **Fungsi **ValidateEmail** harus ditempatkan sebelum fungsi SaveUser.** Saat Anda menambahkan lebih banyak fungsi, Anda dapat menggunakan opsi **pindah ke atas** dan **bergerak ke bawah** untuk mengatur ulang urutan eksekusi fungsi Anda. Tinjau perubahan Anda, lalu pilih **Simpan**.
## Langkah 4: Menjalankan kueri
Di AWS AppSync konsol, buka halaman **Kueri.** Di penjelajah, pastikan Anda menggunakan mutasi Anda. Jika tidak, pilih `Mutation` di daftar drop-down, lalu pilih`+`. Masukkan kueri berikut:
```
mutation {
signUp(input: {
email: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Ini harus mengembalikan sesuatu seperti:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
Kami telah berhasil mendaftarkan pengguna kami dan memvalidasi email input menggunakan resolver pipeline. Untuk mengikuti tutorial yang lebih lengkap yang berfokus pada resolver pipeline, Anda dapat pergi ke [Tutorial:](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers) Pipeline Resolvers