Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan resolver pipa di AWS AppSync
**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/tutorials-js.html)
AWS AppSync menyediakan cara sederhana untuk menghubungkan bidang GraphQL ke sumber data tunggal melalui resolver unit. Namun, menjalankan satu operasi mungkin tidak cukup. Pipeline resolvers menawarkan kemampuan untuk menjalankan operasi secara serial terhadap sumber data. Buat fungsi di API Anda dan lampirkan ke resolver pipeline. Setiap hasil eksekusi fungsi disalurkan ke yang berikutnya sampai tidak ada fungsi yang tersisa untuk dieksekusi. Dengan resolver pipeline, Anda sekarang dapat membangun alur kerja yang lebih kompleks secara langsung. AWS AppSync Dalam tutorial ini, Anda membangun aplikasi tampilan gambar sederhana, di mana pengguna dapat memposting dan melihat gambar yang diposting oleh teman-teman mereka.
## Pengaturan Satu-Klik
Jika Anda ingin secara otomatis mengatur titik akhir AWS AppSync GraphQL dengan semua resolver yang dikonfigurasi dan sumber daya yang AWS diperlukan, Anda dapat menggunakan templat berikut: AWS CloudFormation
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml)
Tumpukan ini membuat sumber daya berikut di akun Anda:
+ Peran IAM AWS AppSync untuk mengakses sumber daya di akun Anda
+ 2 tabel DynamoDB
+ 1 kumpulan pengguna Amazon Cognito
+ 2 grup kumpulan pengguna Amazon Cognito
+ 3 pengguna kumpulan pengguna Amazon Cognito
+ 1 AWS AppSync API
Di akhir proses pembuatan AWS CloudFormation tumpukan, Anda menerima satu email untuk masing-masing dari tiga pengguna Amazon Cognito yang dibuat. Setiap email berisi kata sandi sementara yang Anda gunakan untuk masuk sebagai pengguna Amazon Cognito ke konsol. AWS AppSync Simpan kata sandi untuk sisa tutorial.
## Pengaturan Manual
Jika Anda lebih suka melalui step-by-step proses secara manual melalui AWS AppSync konsol, ikuti proses pengaturan di bawah ini.
### Menyiapkan Non AWS AppSync Sumber Daya Anda
API berkomunikasi dengan dua tabel DynamoDB: tabel gambar **yang** menyimpan gambar dan tabel teman **yang** menyimpan hubungan antar pengguna. API dikonfigurasi untuk menggunakan kumpulan pengguna Amazon Cognito sebagai jenis otentikasi. CloudFormation Tumpukan berikut mengatur sumber daya ini di akun.
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml)
Di akhir proses pembuatan AWS CloudFormation tumpukan, Anda menerima satu email untuk masing-masing dari tiga pengguna Amazon Cognito yang dibuat. Setiap email berisi kata sandi sementara yang Anda gunakan untuk masuk sebagai pengguna Amazon Cognito ke konsol. AWS AppSync Simpan kata sandi untuk sisa tutorial.
### Membuat GraphQL API
Untuk membuat GraphQL API di: AWS AppSync
1. Buka AWS AppSync konsol dan pilih **Build From Scratch** dan pilih **Start**.
1. Tetapkan nama API ke`AppSyncTutorial-PicturesViewer`.
1. Pilih **Buat**.
AWS AppSync Konsol membuat API GraphQL baru untuk Anda menggunakan mode autentikasi kunci API. Anda dapat menggunakan konsol untuk mengatur sisa GraphQL API dan menjalankan kueri terhadapnya selama sisa tutorial ini.
### Mengkonfigurasi API GraphQL
Anda perlu mengonfigurasi AWS AppSync API dengan kumpulan pengguna Amazon Cognito yang baru saja Anda buat.
1. Pilih tab **Pengaturan**.
1. Di bawah bagian **Jenis Otorisasi**, pilih Kumpulan Pengguna *Amazon Cognito*.
1. *Di bawah **Konfigurasi Pool Pengguna**, pilih **US-WEST-2 untuk Wilayah**.AWS *
1. Pilih **AppSyncTutorial-** kumpulan UserPool pengguna.
1. Pilih **DENY** sebagai *Default Action*.
1. Biarkan bidang **regex AppId klien** kosong.
1. Pilih **Simpan**.
API sekarang disiapkan untuk menggunakan kumpulan pengguna Amazon Cognito sebagai jenis otorisasi.
### Mengkonfigurasi Sumber Data untuk Tabel DynamoDB
**Setelah tabel DynamoDB dibuat, navigasikan ke AWS AppSync GraphQL API Anda di konsol dan pilih tab Sumber Data.** Sekarang, Anda akan membuat sumber data AWS AppSync untuk setiap tabel DynamoDB yang baru saja Anda buat.
1. Pilih tab **Sumber data**.
1. Pilih **Baru** untuk membuat sumber data baru.
1. Untuk nama sumber data, masukkan`PicturesDynamoDBTable`.
1. Untuk tipe sumber data, pilih tabel **Amazon DynamoDB**.
1. Untuk wilayah, pilih **US-WEST-2**.
1. Dari daftar tabel, pilih tabel **AppSyncTutorial-Pictures** DynamoDB.
1. Di bagian **Buat atau gunakan peran yang ada**, pilih **Peran yang ada**.
1. Pilih peran yang baru saja dibuat dari CloudFormation template. Jika Anda tidak mengubah *ResourceNamePrefix*, nama peran harus **AppSyncTutorialDBRole-Dynamo**.
1. Pilih **Buat**.
Ulangi proses yang sama untuk tabel **teman**, nama tabel DynamoDB **AppSyncTutorialharus** -Friends jika Anda tidak mengubah parameter *ResourceNamePrefix*pada saat membuat tumpukan. CloudFormation
### Membuat Skema GraphQL
Sekarang sumber data terhubung ke tabel DynamoDB Anda, mari buat skema GraphQL. Dari editor skema di AWS AppSync konsol, pastikan skema Anda cocok dengan skema berikut:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
createPicture(input: CreatePictureInput!): Picture!
@aws_auth(cognito_groups: ["Admins"])
createFriendship(id: ID!, target: ID!): Boolean
@aws_auth(cognito_groups: ["Admins"])
}
type Query {
getPicturesByOwner(id: ID!): [Picture]
@aws_auth(cognito_groups: ["Admins", "Viewers"])
}
type Picture {
id: ID!
owner: ID!
src: String
}
input CreatePictureInput {
owner: ID!
src: String!
}
```
Pilih **Simpan Skema** untuk menyimpan skema Anda.
*Beberapa bidang skema telah dianotasi dengan direktif @aws\$1auth.* Karena konfigurasi tindakan default API disetel ke *DENY*, API menolak semua pengguna yang bukan anggota grup yang disebutkan di dalam direktif *@aws\$1auth*. Untuk informasi selengkapnya tentang cara mengamankan API, Anda dapat membaca halaman [Keamanan](security-authz.md#aws-appsync-security). **Dalam hal ini, hanya pengguna admin yang memiliki akses ke bidang *mutation.createPicture dan mutation.createFriendship**, sementara pengguna yang merupakan anggota grup Admin atau Pemirsa* dapat mengakses Kueri.** * getPicturesByBidang pemilik*. Semua pengguna lain tidak memiliki akses.
### Mengkonfigurasi Resolver
Sekarang Anda memiliki skema GraphQL yang valid dan dua sumber data, Anda dapat melampirkan resolver ke bidang GraphQL pada skema. API menawarkan kemampuan berikut:
+ Buat gambar melalui bidang *mutation.createPicture*
+ Buat pertemanan melalui bidang *mutation.createFriendship*
+ Mengambil gambar melalui bidang *Query.getPicture*
#### mutasi.createPicture
Dari editor skema di AWS AppSync konsol, di sisi kanan pilih **Lampirkan Resolver** untuk. `createPicture(input: CreatePictureInput!): Picture!` Pilih sumber data *PicturesDynamoDBTable*DynamoDB. Di bagian **template pemetaan permintaan**, tambahkan template berikut:
```
#set($id = $util.autoId())
{
"version" : "2018-05-29",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($id),
"owner": $util.dynamodb.toDynamoDBJson($ctx.args.input.owner)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args.input)
}
```
Di bagian **template pemetaan respons**, tambahkan templat berikut:
```
#if($ctx.error)
$util.error($ctx.error.message, $ctx.error.type)
#end
$util.toJson($ctx.result)
```
Fungsionalitas membuat gambar selesai. Anda menyimpan gambar di tabel **Gambar**, menggunakan UUID yang dihasilkan secara acak sebagai id gambar, dan menggunakan nama pengguna Cognito sebagai pemilik gambar.
#### mutation.createFriendship
Dari editor skema di AWS AppSync konsol, di sisi kanan pilih **Lampirkan Resolver** untuk. `createFriendship(id: ID!, target: ID!): Boolean` Pilih sumber data **FriendsDynamoDBTable**DynamoDB. Di bagian **template pemetaan permintaan**, tambahkan template berikut:
```
#set($userToFriendFriendship = { "userId" : "$ctx.args.id", "friendId": "$ctx.args.target" })
#set($friendToUserFriendship = { "userId" : "$ctx.args.target", "friendId": "$ctx.args.id" })
#set($friendsItems = [$util.dynamodb.toMapValues($userToFriendFriendship), $util.dynamodb.toMapValues($friendToUserFriendship)])
{
"version" : "2018-05-29",
"operation" : "BatchPutItem",
"tables" : {
## Replace 'AppSyncTutorial-' default below with the ResourceNamePrefix you provided in the CloudFormation template
"AppSyncTutorial-Friends": $util.toJson($friendsItems)
}
}
```
Penting: Dalam template **BatchPutItem**permintaan, nama yang tepat dari tabel DynamoDB harus ada. Nama tabel default adalah *AppSyncTutorial-Friends*. Jika Anda menggunakan nama tabel yang salah, Anda mendapatkan kesalahan saat AppSync mencoba mengambil peran yang disediakan.
Demi kesederhanaan dalam tutorial ini, lanjutkan seolah-olah permintaan pertemanan telah disetujui dan simpan entri hubungan langsung ke **AppSyncTutorialFriends**tabel.
Secara efektif, Anda menyimpan dua item untuk setiap pertemanan karena hubungan itu dua arah. Untuk detail selengkapnya tentang praktik terbaik Amazon DynamoDB untuk many-to-many mewakili hubungan, lihat Praktik Terbaik [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html).
Di bagian **template pemetaan respons**, tambahkan templat berikut:
```
#if($ctx.error)
$util.error($ctx.error.message, $ctx.error.type)
#end
true
```
Catatan: Pastikan template permintaan Anda berisi nama tabel yang tepat. Nama default adalah *AppSyncTutorial-Friends*, tetapi nama tabel Anda mungkin berbeda jika Anda mengubah CloudFormation **ResourceNamePrefix**parameter.
#### Permintaan. getPicturesByPemilik
Sekarang setelah Anda memiliki pertemanan dan gambar, Anda perlu memberikan kemampuan bagi pengguna untuk melihat foto teman-teman mereka. Untuk memenuhi persyaratan ini, Anda harus terlebih dahulu memeriksa apakah pemohon berteman dengan pemilik, dan akhirnya meminta gambar.
Karena fungsi ini memerlukan dua operasi sumber data, Anda akan membuat dua fungsi. Fungsi pertama, **IsFriend**, memeriksa apakah pemohon dan pemiliknya adalah teman. Fungsi kedua, **getPicturesByOwner**, mengambil gambar yang diminta diberikan ID pemilik. *Mari kita lihat alur eksekusi di bawah ini untuk resolver yang diusulkan pada Query. getPicturesByBidang pemilik*:
1. Sebelum memetakan template: Siapkan konteks dan argumen masukan bidang.
1. Fungsi isFriend: Memeriksa apakah pemohon adalah pemilik gambar. Jika tidak, ia memeriksa apakah pengguna pemohon dan pemilik adalah teman dengan melakukan operasi GetItem DynamoDB di meja teman.
1. getPicturesBy*Fungsi pemilik: Mengambil gambar dari tabel Gambar menggunakan operasi Query DynamoDB pada indeks pemilik Indeks Sekunder Global.*
1. Setelah memetakan template: Hasil gambar peta sehingga DynamoDB mengatribusikan peta dengan benar ke bidang tipe GraphQL yang diharapkan.
Pertama mari kita buat fungsinya.
##### Fungsi isFriend
1. Pilih tab **Fungsi**.
1. Pilih **Create Function** untuk membuat fungsi.
1. Untuk nama sumber data, masukkan`FriendsDynamoDBTable`.
1. Untuk nama fungsi, masukkan *isFriend*.
1. Di dalam area teks template pemetaan permintaan, tempel template berikut:
```
#set($ownerId = $ctx.prev.result.owner)
#set($callerId = $ctx.prev.result.callerId)
## if the owner is the caller, no need to make the check
#if($ownerId == $callerId)
#return($ctx.prev.result)
#end
{
"version" : "2018-05-29",
"operation" : "GetItem",
"key" : {
"userId" : $util.dynamodb.toDynamoDBJson($callerId),
"friendId" : $util.dynamodb.toDynamoDBJson($ownerId)
}
}
```
1. Di dalam area teks template pemetaan respons, tempel template berikut:
```
#if($ctx.error)
$util.error("Unable to retrieve friend mapping message: ${ctx.error.message}", $ctx.error.type)
#end
## if the users aren't friends
#if(!$ctx.result)
$util.unauthorized()
#end
$util.toJson($ctx.prev.result)
```
1. Pilih **Buat Fungsi**.
Hasil: Anda telah membuat fungsi **isFriend**.
##### getPicturesByFungsi pemilik
1. Pilih tab **Fungsi**.
1. Pilih **Create Function** untuk membuat fungsi.
1. Untuk nama sumber data, masukkan`PicturesDynamoDBTable`.
1. Untuk nama fungsi, masukkan`getPicturesByOwner`.
1. Di dalam area teks template pemetaan permintaan, tempel template berikut:
```
{
"version" : "2018-05-29",
"operation" : "Query",
"query" : {
"expression": "#owner = :owner",
"expressionNames": {
"#owner" : "owner"
},
"expressionValues" : {
":owner" : $util.dynamodb.toDynamoDBJson($ctx.prev.result.owner)
}
},
"index": "owner-index"
}
```
1. Di dalam area teks template pemetaan respons, tempel template berikut:
```
#if($ctx.error)
$util.error($ctx.error.message, $ctx.error.type)
#end
$util.toJson($ctx.result)
```
1. Pilih **Buat Fungsi**.
Hasil: Anda telah membuat fungsi **getPicturesByOwner**. *Sekarang fungsi telah dibuat, lampirkan resolver pipeline ke Query. getPicturesByBidang pemilik*.
Dari editor skema di AWS AppSync konsol, di sisi kanan pilih **Lampirkan Resolver** untuk. `Query.getPicturesByOwner(id: ID!): [Picture]` Pada halaman berikut, pilih tautan **Convert to pipeline resolver** yang muncul di bawah daftar drop-down sumber data. Gunakan yang berikut ini untuk template sebelum pemetaan:
```
#set($result = { "owner": $ctx.args.id, "callerId": $ctx.identity.username })
$util.toJson($result)
```
Di bagian **template setelah pemetaan**, gunakan yang berikut ini:
```
#foreach($picture in $ctx.result.items)
## prepend "src://" to picture.src property
#set($picture['src'] = "src://${picture['src']}")
#end
$util.toJson($ctx.result.items)
```
Pilih **Buat Resolver**. Anda telah berhasil memasang resolver pipa pertama Anda. Pada halaman yang sama, tambahkan dua fungsi yang Anda buat sebelumnya. Di bagian fungsi, pilih **Tambahkan Fungsi** dan kemudian pilih atau ketik nama fungsi pertama, **IsFriend**. Tambahkan fungsi kedua dengan mengikuti proses yang sama untuk fungsi **getPicturesByPemilik**. Pastikan fungsi **isFriend** muncul pertama kali dalam daftar diikuti oleh fungsi **getPicturesByOwner**. Anda dapat menggunakan panah atas dan bawah untuk mengatur ulang urutan pelaksanaan fungsi dalam pipa.
Sekarang setelah pipeline resolver dibuat dan Anda telah melampirkan fungsinya, mari kita uji GraphQL API yang baru dibuat.
## Menguji GraphQL API
Pertama, Anda perlu mengisi gambar dan pertemanan dengan mengeksekusi beberapa mutasi menggunakan pengguna admin yang Anda buat. Di sisi kiri AWS AppSync konsol, pilih tab **Kueri.**
### Mutasi CreatePicture
1. Di AWS AppSync konsol, pilih tab **Kueri**.
1. Pilih **Login Dengan User Pools**.
1. Pada modal, masukkan Cognito Sample Client ID yang dibuat oleh CloudFormation stack misalnya, 37solo6mmhh7k4v63cqdfgdg5d).
1. Masukkan nama pengguna yang Anda berikan sebagai parameter ke CloudFormation tumpukan. Defaultnya adalah **nadia**.
1. Gunakan kata sandi sementara yang dikirim ke email yang Anda berikan sebagai parameter ke CloudFormation tumpukan (misalnya, *UserPoolUserEmail*).
1. Pilih Login. Anda sekarang akan melihat tombol berganti nama menjadi **Logout nadia**, atau nama pengguna apa pun yang Anda pilih saat membuat CloudFormation tumpukan (yaitu,). *UserPoolUsername*
Mari kita kirim beberapa mutasi *CreatePicture* untuk mengisi tabel gambar. Jalankan query GraphQL berikut di dalam konsol:
```
mutation {
createPicture(input:{
owner: "nadia"
src: "nadia.jpg"
}) {
id
owner
src
}
}
```
Responsnya akan terlihat seperti di bawah ini:
```
{
"data": {
"createPicture": {
"id": "c6fedbbe-57ad-4da3-860a-ffe8d039882a",
"owner": "nadia",
"src": "nadia.jpg"
}
}
}
```
Mari tambahkan beberapa gambar lagi:
```
mutation {
createPicture(input:{
owner: "shaggy"
src: "shaggy.jpg"
}) {
id
owner
src
}
}
```
```
mutation {
createPicture(input:{
owner: "rex"
src: "rex.jpg"
}) {
id
owner
src
}
}
```
Anda telah menambahkan tiga gambar menggunakan **nadia** sebagai pengguna admin.
### Mutasi CreateFriendship
Mari tambahkan entri persahabatan. Jalankan mutasi berikut di konsol.
Catatan: Anda masih harus masuk sebagai pengguna admin (pengguna admin default adalah **nadia**).
```
mutation {
createFriendship(id: "nadia", target: "shaggy")
}
```
Responsnya akan terlihat seperti:
```
{
"data": {
"createFriendship": true
}
}
```
**Nadia** dan **shaggy** adalah teman. **Rex** tidak berteman dengan siapa pun.
### getPicturesByKueri Pemilik
Untuk langkah ini, masuk sebagai pengguna **nadia** menggunakan Cognito User Pools, menggunakan kredensil yang diatur di awal tutorial ini. **Sebagai **nadia**, ambil foto-foto yang dimiliki oleh shaggy.**
```
query {
getPicturesByOwner(id: "shaggy") {
id
owner
src
}
}
```
Karena **nadia** dan **shaggy** adalah teman, kueri harus mengembalikan gambar yang sesuai.
```
{
"data": {
"getPicturesByOwner": [
{
"id": "05a16fba-cc29-41ee-a8d5-4e791f4f1079",
"owner": "shaggy",
"src": "src://shaggy.jpg"
}
]
}
}
```
Demikian pula, jika **nadia** mencoba mengambil fotonya sendiri, itu juga berhasil. Pipeline resolver telah dioptimalkan untuk menghindari menjalankan GetItem operasi **IsFriend** dalam kasus itu. Coba kueri berikut:
```
query {
getPicturesByOwner(id: "nadia") {
id
owner
src
}
}
```
Jika Anda mengaktifkan logging pada API Anda (di panel **Pengaturan**), mengatur tingkat debug ke **ALL**, dan menjalankan kueri yang sama lagi, itu akan mengembalikan log untuk eksekusi bidang. Dengan melihat log, Anda dapat menentukan apakah fungsi **isFriend kembali lebih awal pada tahap Template** **Pemetaan Permintaan**:
```
{
"errors": [],
"mappingTemplateType": "Request Mapping",
"path": "[getPicturesByOwner]",
"resolverArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/types/Query/fields/getPicturesByOwner",
"functionArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/functions/o2f42p2jrfdl3dw7s6xub2csdfs",
"functionName": "isFriend",
"earlyReturnedValue": {
"owner": "nadia",
"callerId": "nadia"
},
"context": {
"arguments": {
"id": "nadia"
},
"prev": {
"result": {
"owner": "nadia",
"callerId": "nadia"
}
},
"stash": {},
"outErrors": []
},
"fieldInError": false
}
```
*earlyReturnedValue*Kunci mewakili data yang dikembalikan oleh direktif *\$1return*.
****Akhirnya, meskipun **rex** adalah anggota Grup UserPool Cognito **Pemirsa**, dan **karena** rex tidak berteman dengan siapa pun, dia tidak akan dapat mengakses salah satu gambar yang dimiliki oleh shaggy atau nadia.**** Jika Anda masuk sebagai **rex** di konsol dan menjalankan kueri berikut:
```
query {
getPicturesByOwner(id: "nadia") {
id
owner
src
}
}
```
Anda mendapatkan kesalahan tidak sah berikut:
```
{
"data": {
"getPicturesByOwner": null
},
"errors": [
{
"path": [
"getPicturesByOwner"
],
"data": null,
"errorType": "Unauthorized",
"errorInfo": null,
"locations": [
{
"line": 2,
"column": 9,
"sourceName": null
}
],
"message": "Not Authorized to access getPicturesByOwner on type Query"
}
]
}
```
Anda telah berhasil menerapkan otorisasi kompleks menggunakan resolver pipa.