Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Penataan GraphQL API (kosong atau diimpor) APIs
Sebelum Anda membuat GraphQL API Anda dari template kosong, akan membantu untuk meninjau konsep seputar GraphQL. Ada tiga komponen dasar dari GraphQL API:
1. **Skema** adalah file yang berisi bentuk dan definisi data Anda. Ketika permintaan dibuat oleh klien ke layanan GraphQL Anda, data yang dikembalikan akan mengikuti spesifikasi skema. Untuk informasi selengkapnya, lihat [GraphQL skema](schema-components.md#aws-appsync-schema-components).
1. **Sumber data** dilampirkan ke skema Anda. Ketika permintaan dibuat, di sinilah data diambil dan dimodifikasi. Untuk informasi selengkapnya, lihat [Sumber data](data-source-components.md#aws-appsync-data-source-components).
1. **Resolver** berada di antara skema dan sumber data. Ketika permintaan dibuat, resolver melakukan operasi pada data dari sumber, kemudian mengembalikan hasilnya sebagai respons. Untuk informasi selengkapnya, lihat [Penyelesai](resolver-components.md#aws-appsync-resolver-components).
![\[GraphQL API architecture showing schema, resolvers, and data sources connected via AppSync.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/appsync-architecture-graphql-api.png)
AWS AppSync mengelola Anda APIs dengan memungkinkan Anda untuk membuat, mengedit, dan menyimpan kode untuk skema dan resolver Anda. Sumber data Anda akan berasal dari repositori eksternal seperti database, tabel DynamoDB, dan fungsi Lambda. Jika Anda menggunakan AWS layanan untuk menyimpan data atau berencana melakukannya, AWS AppSync berikan pengalaman yang hampir mulus saat mengaitkan data dari akun Anda AWS ke GraphQL Anda. APIs
Di bagian selanjutnya, Anda akan belajar cara membuat masing-masing komponen ini menggunakan AWS AppSync layanan.
**Topics**
+ [Merancang skema GraphQL Anda](designing-your-schema.md)
+ [Melampirkan sumber data](attaching-a-data-source.md)
+ [Mengkonfigurasi resolver AWS AppSync](resolver-config-overview.md)
+ [Menggunakan APIs CDK](using-your-api.md)
# Merancang skema GraphQL Anda
Skema GraphQL adalah dasar dari setiap implementasi server GraphQL. Setiap GraphQL API didefinisikan oleh skema tunggal **yang** berisi jenis dan bidang yang menjelaskan bagaimana data dari permintaan akan diisi. Data yang mengalir melalui API Anda dan operasi yang dilakukan harus divalidasi terhadap skema.
Secara umum, sistem [tipe GraphQL](https://graphql.org/learn/schema/#type-system) menggambarkan kemampuan server GraphQL dan digunakan untuk menentukan apakah kueri valid. Sistem tipe server sering disebut sebagai skema server dan dapat terdiri dari berbagai jenis objek, jenis skalar, tipe input, dan banyak lagi. GraphQL bersifat deklaratif dan diketik dengan kuat, artinya tipe akan didefinisikan dengan baik saat runtime dan hanya akan mengembalikan apa yang ditentukan.
AWS AppSync memungkinkan Anda untuk menentukan dan mengkonfigurasi skema GraphQL. Bagian berikut menjelaskan cara membuat skema GraphQL dari awal menggunakan layanan ini. AWS AppSync
## Penataan Skema GraphQL
**Tip**
Kami merekomendasikan untuk meninjau bagian [Skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-components.html) sebelum melanjutkan.
GraphQL adalah alat yang ampuh untuk mengimplementasikan layanan API. Menurut [situs web GraphQL, GraphQL](https://graphql.org/) adalah sebagai berikut:
*GraphQL adalah bahasa kueri APIs untuk dan runtime untuk memenuhi kueri tersebut dengan data Anda yang ada. GraphQL memberikan deskripsi data yang lengkap dan mudah dipahami di API Anda, memberi klien kekuatan untuk meminta apa yang mereka butuhkan dan tidak lebih, membuatnya lebih mudah untuk APIs berkembang dari waktu ke waktu, dan memungkinkan alat pengembang yang kuat.* “
Bagian ini mencakup bagian pertama dari implementasi GraphQL Anda, skema. Menggunakan kutipan di atas, skema memainkan peran “memberikan deskripsi data yang lengkap dan dapat dimengerti di API Anda”. Dengan kata lain, skema GraphQL adalah representasi tekstual dari data, operasi, dan hubungan layanan Anda di antara mereka. Skema ini dianggap sebagai titik masuk utama untuk implementasi layanan GraphQL Anda. Tidak mengherankan, ini sering menjadi salah satu hal pertama yang Anda buat dalam proyek Anda. Kami merekomendasikan untuk meninjau bagian [Skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-components.html) sebelum melanjutkan.
*Untuk mengutip bagian [Skema, skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-components.html) GraphQL ditulis dalam Schema Definition Language (SDL).* SDL terdiri dari jenis dan bidang dengan struktur yang mapan:
+ **Jenis**: Jenis adalah bagaimana GraphQL mendefinisikan bentuk dan perilaku data. GraphQL mendukung banyak jenis yang akan dijelaskan nanti di bagian ini. Setiap jenis yang didefinisikan dalam skema Anda akan berisi cakupannya sendiri. Di dalam ruang lingkup akan ada satu atau lebih bidang yang dapat berisi nilai atau logika yang akan digunakan dalam layanan GraphQL Anda. Jenis mengisi banyak peran yang berbeda, yang paling umum adalah objek atau skalar (tipe nilai primitif).
+ **Bidang**: Bidang ada dalam lingkup tipe dan menyimpan nilai yang diminta dari layanan GraphQL. Ini sangat mirip dengan variabel dalam bahasa pemrograman lain. Bentuk data yang Anda tentukan di bidang Anda akan menentukan bagaimana data terstruktur dalam suatu request/response operasi. Hal ini memungkinkan pengembang untuk memprediksi apa yang akan dikembalikan tanpa mengetahui bagaimana backend layanan diimplementasikan.
Skema paling sederhana akan berisi tiga kategori data yang berbeda:
1. **Akar skema**: Akar menentukan titik masuk skema Anda. Ini menunjuk ke bidang yang akan melakukan beberapa operasi pada data seperti menambahkan, menghapus, atau memodifikasi sesuatu.
1. **Jenis**: Ini adalah tipe dasar yang digunakan untuk mewakili bentuk data. Anda hampir dapat menganggap ini sebagai objek atau representasi abstrak dari sesuatu dengan karakteristik yang ditentukan. Misalnya, Anda bisa membuat `Person` objek yang mewakili seseorang dalam database. Karakteristik setiap orang akan didefinisikan di dalam bidang `Person` as. Mereka bisa berupa apa saja seperti nama orang tersebut, usia, pekerjaan, alamat, dll.
1. **Jenis objek khusus**: Ini adalah tipe yang menentukan perilaku operasi dalam skema Anda. Setiap jenis objek khusus didefinisikan sekali per skema. Mereka pertama kali ditempatkan di akar skema, kemudian didefinisikan dalam badan skema. Setiap bidang dalam jenis objek khusus mendefinisikan operasi tunggal yang akan diimplementasikan oleh resolver Anda.
Untuk menempatkan ini ke dalam perspektif, bayangkan Anda membuat layanan yang menyimpan penulis dan buku-buku yang telah mereka tulis. Setiap penulis memiliki nama dan serangkaian buku yang telah mereka tulis. Setiap buku memiliki nama dan daftar penulis terkait. Kami juga ingin kemampuan untuk menambah atau mengambil buku dan penulis. Representasi UFL sederhana dari hubungan ini mungkin terlihat seperti ini:
![\[UML diagram showing Author and Book classes with attributes and methods, linked by association.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/GraphQL-UML-1.png)
Dalam GraphQL, `Author` entitas `Book` dan mewakili dua jenis objek yang berbeda dalam skema Anda:
```
type Author {
}
type Book {
}
```
`Author`berisi `authorName` dan`Books`, sementara `Book` berisi `bookName` dan`Authors`. Ini dapat direpresentasikan sebagai bidang dalam lingkup tipe Anda:
```
type Author {
authorName: String
Books: [Book]
}
type Book {
bookName: String
Authors: [Author]
}
```
Seperti yang Anda lihat, representasi tipe sangat dekat dengan diagram. Namun, metodenya adalah di mana ia menjadi sedikit lebih rumit. Ini akan ditempatkan di salah satu dari beberapa jenis objek khusus sebagai bidang. Kategorisasi objek khusus mereka tergantung pada perilaku mereka. GraphQL berisi tiga jenis objek khusus mendasar: kueri, mutasi, dan langganan. Untuk informasi selengkapnya, lihat [Objek khusus](https://docs.aws.amazon.com//appsync/latest/devguide/graphql-types.html#special-object-components).
Karena `getAuthor` dan `getBook` keduanya meminta data, mereka akan ditempatkan dalam jenis objek `Query` khusus:
```
type Author {
authorName: String
Books: [Book]
}
type Book {
bookName: String
Authors: [Author]
}
type Query {
getAuthor(authorName: String): Author
getBook(bookName: String): Book
}
```
Operasi ditautkan ke kueri, yang itu sendiri terkait dengan skema. Menambahkan root skema akan menentukan jenis objek khusus (`Query`dalam hal ini) sebagai salah satu titik masuk Anda. Ini dapat dilakukan dengan menggunakan `schema` kata kunci:
```
schema {
query: Query
}
type Author {
authorName: String
Books: [Book]
}
type Book {
bookName: String
Authors: [Author]
}
type Query {
getAuthor(authorName: String): Author
getBook(bookName: String): Book
}
```
Melihat dua metode terakhir, `addAuthor` dan `addBook` menambahkan data ke database Anda, sehingga mereka akan didefinisikan dalam jenis objek `Mutation` khusus. Namun, dari halaman [Types](https://docs.aws.amazon.com/appsync/latest/devguide/graphql-types.html#input-components), kita juga tahu bahwa input langsung mereferensikan Objek tidak diperbolehkan karena mereka benar-benar tipe output. Dalam hal ini, kita tidak dapat menggunakan `Author` atau`Book`, jadi kita perlu membuat tipe input dengan bidang yang sama. Dalam contoh ini, kami menambahkan `AuthorInput` dan`BookInput`, keduanya menerima bidang yang sama dari jenisnya masing-masing. Kemudian, kami membuat mutasi kami menggunakan input sebagai parameter kami:
```
schema {
query: Query
mutation: Mutation
}
type Author {
authorName: String
Books: [Book]
}
input AuthorInput {
authorName: String
Books: [BookInput]
}
type Book {
bookName: String
Authors: [Author]
}
input BookInput {
bookName: String
Authors: [AuthorInput]
}
type Query {
getAuthor(authorName: String): Author
getBook(bookName: String): Book
}
type Mutation {
addAuthor(input: [BookInput]): Author
addBook(input: [AuthorInput]): Book
}
```
Mari kita tinjau apa yang baru saja kita lakukan:
1. Kami membuat skema dengan `Author` tipe `Book` dan untuk mewakili entitas kami.
1. Kami menambahkan bidang yang berisi karakteristik entitas kami.
1. Kami menambahkan query untuk mengambil informasi ini dari database.
1. Kami menambahkan mutasi untuk memanipulasi data dalam database.
1. Kami menambahkan tipe input untuk mengganti parameter objek kami dalam mutasi untuk mematuhi aturan GraphQL.
1. Kami menambahkan kueri dan mutasi ke skema root kami sehingga implementasi GraphQL memahami lokasi tipe root.
Seperti yang Anda lihat, proses pembuatan skema membutuhkan banyak konsep dari pemodelan data (terutama pemodelan basis data) secara umum. Anda dapat menganggap skema sesuai dengan bentuk data dari sumbernya. Ini juga berfungsi sebagai model yang akan diterapkan oleh resolver. Di bagian berikut, Anda akan belajar cara membuat skema menggunakan berbagai alat dan AWS layanan yang didukung.
**catatan**
Contoh di bagian berikut tidak dimaksudkan untuk berjalan dalam aplikasi nyata. Mereka hanya ada untuk menampilkan perintah sehingga Anda dapat membangun aplikasi Anda sendiri.
## Membuat skema
Skema Anda akan berada dalam file bernama`schema.graphql`. AWS AppSync memungkinkan pengguna untuk membuat skema baru untuk APIs GraphQL mereka menggunakan berbagai metode. Dalam contoh ini, kita akan membuat API kosong bersama dengan skema kosong.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **Dasbor**, pilih **Buat API**.
1. **Di bawah **opsi API**, pilih ** APIsGraphQL****, Desain dari awal,** lalu Berikutnya.**
1. Untuk **nama API**, ubah nama yang telah diisi sebelumnya menjadi kebutuhan aplikasi Anda.
1. Untuk **detail kontak**, Anda dapat memasukkan titik kontak untuk mengidentifikasi manajer API. Ini adalah bidang opsional.
1. Di bawah **konfigurasi API Pribadi**, Anda dapat mengaktifkan fitur API pribadi. API pribadi hanya dapat diakses dari titik akhir VPC (VPCE) yang dikonfigurasi. Untuk informasi selengkapnya, lihat [Pribadi APIs](https://docs.aws.amazon.com/appsync/latest/devguide/using-private-apis.html).
Kami tidak menyarankan mengaktifkan fitur ini untuk contoh ini. Pilih **Berikutnya** setelah meninjau input Anda.
1. Di bawah **Buat tipe GraphQL**, Anda dapat memilih untuk membuat tabel DynamoDB untuk digunakan sebagai sumber data atau melewatkan ini dan melakukannya nanti.
Untuk contoh ini, pilih **Buat sumber daya GraphQL nanti**. Kami akan membuat sumber daya di bagian terpisah.
1. Tinjau input Anda, lalu pilih **Buat API**.
1. Anda akan berada di dasbor API spesifik Anda. Anda bisa tahu karena nama API akan berada di bagian atas dasbor. Jika ini tidak terjadi, Anda dapat memilih **APIs**di **Sidebar**, lalu pilih API Anda di **APIs dasbor**.
1. **Di **Sidebar** di bawah nama API Anda, pilih Skema.**
1. Di **editor Skema**, Anda dapat mengonfigurasi `schema.graphql` file Anda. Mungkin kosong atau diisi dengan tipe yang dihasilkan dari model. Di sebelah kanan, Anda memiliki bagian **Resolvers untuk melampirkan resolver** ke bidang skema Anda. Kami tidak akan melihat resolver di bagian ini.
------
#### [ CLI ]
**catatan**
Saat menggunakan CLI, pastikan Anda memiliki izin yang benar untuk mengakses dan membuat sumber daya dalam layanan. Anda mungkin ingin menetapkan kebijakan [hak istimewa paling sedikit](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) untuk pengguna non-admin yang perlu mengakses layanan. Untuk informasi selengkapnya tentang AWS AppSync kebijakan, lihat [Identitas dan manajemen akses untuk AWS AppSync](https://docs.aws.amazon.com//appsync/latest/devguide/security-iam.html).
Selain itu, kami sarankan membaca versi konsol terlebih dahulu jika Anda belum melakukannya.
1. [Jika Anda belum melakukannya, [instal](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-getting-started.html)AWS CLI, lalu tambahkan konfigurasi Anda.](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html)
1. Buat objek GraphQL API dengan menjalankan perintah. [https://docs.aws.amazon.com/cli/latest/reference/appsync/create-graphql-api.html](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-graphql-api.html)
Anda harus mengetikkan dua parameter untuk perintah khusus ini:
1. API Anda. `name`
1. Itu`authentication-type`, atau jenis kredensil yang digunakan untuk mengakses API (IAM, OIDC, dll.).
**catatan**
Parameter lain seperti `Region` harus dikonfigurasi tetapi biasanya akan default ke nilai konfigurasi CLI Anda.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-graphql-api --name testAPI123 --authentication-type API_KEY
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"graphqlApi": {
"xrayEnabled": false,
"name": "testAPI123",
"authenticationType": "API_KEY",
"tags": {},
"apiId": "abcdefghijklmnopqrstuvwxyz",
"uris": {
"GRAPHQL": "https://zyxwvutsrqponmlkjihgfedcba.appsync-api.us-west-2.amazonaws.com/graphql",
"REALTIME": "wss://zyxwvutsrqponmlkjihgfedcba.appsync-realtime-api.us-west-2.amazonaws.com/graphql"
},
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz"
}
}
```
1.
**catatan**
Ini adalah perintah opsional yang mengambil skema yang ada dan mengunggahnya ke AWS AppSync layanan menggunakan gumpalan basis-64. Kami tidak akan menggunakan perintah ini demi contoh ini.
Jalankan perintah [https://docs.aws.amazon.com/cli/latest/reference/appsync/start-schema-creation.html](https://docs.aws.amazon.com/cli/latest/reference/appsync/start-schema-creation.html).
Anda harus mengetikkan dua parameter untuk perintah khusus ini:
1. Anda `api-id` dari langkah sebelumnya.
1. Skema `definition` adalah gumpalan biner yang dikodekan basis-64.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync start-schema-creation --api-id abcdefghijklmnopqrstuvwxyz --definition "aa1111aa-123b-2bb2-c321-12hgg76cc33v"
```
Output akan dikembalikan:
```
{
"status": "PROCESSING"
}
```
Perintah ini tidak akan mengembalikan output akhir setelah diproses. Anda harus menggunakan perintah terpisah, [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/get-schema-creation-status.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/get-schema-creation-status.html), untuk melihat hasilnya. Perhatikan bahwa kedua perintah ini asinkron, sehingga Anda dapat memeriksa status output bahkan saat skema masih dibuat.
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
1. Titik awal untuk CDK sedikit berbeda. Idealnya, `schema.graphql` file Anda seharusnya sudah dibuat. Anda hanya perlu membuat file baru dengan ekstensi `.graphql` file. Ini bisa menjadi file kosong.
1. Secara umum, Anda mungkin harus menambahkan direktif impor ke layanan yang Anda gunakan. Misalnya, mungkin mengikuti formulir:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
Untuk menambahkan GraphQL API, file stack Anda perlu mengimpor layanan: AWS AppSync
```
import * as appsync from 'aws-cdk-lib/aws-appsync';
```
**catatan**
Ini berarti kami mengimpor seluruh layanan di bawah `appsync` kata kunci. Untuk menggunakan ini di aplikasi Anda, AWS AppSync konstruksi Anda akan menggunakan format`appsync.construct_name`. Misalnya, jika kita ingin membuat GraphQL API, kita akan mengatakan. `new appsync.GraphqlApi(args_go_here)` Langkah berikut menggambarkan ini.
1. GraphQL API yang paling dasar akan menyertakan `name` untuk API dan jalur. `schema`
```
const add_api = new appsync.GraphqlApi(this, 'API_ID', {
name: 'name_of_API_in_console',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema_name.graphql')),
});
```
**catatan**
Mari kita tinjau apa yang dilakukan cuplikan ini. Di dalam lingkup`api`, kami membuat GraphQL API baru dengan menelepon. `appsync.GraphqlApi(scope: Construct, id: string, props: GraphqlApiProps)` Ruang lingkupnya adalah`this`, yang mengacu pada objek saat ini. Id adalah*API\$1ID*, yang akan menjadi nama CloudFormation sumber daya GraphQL API Anda saat dibuat. `GraphqlApiProps`Berisi `name` dari GraphQL API Anda dan file. `schema` `schema`Akan menghasilkan skema (`SchemaFile.fromAsset`) dengan mencari path absolut (`__dirname`) untuk `.graphql` file (*schema\$1name.graphql*). Dalam skenario nyata, file skema Anda mungkin akan berada di dalam aplikasi CDK.
Untuk menggunakan perubahan yang dibuat pada GraphQL API, Anda harus menerapkan ulang aplikasi.
------
## Menambahkan tipe ke skema
Sekarang Anda telah menambahkan skema Anda, Anda dapat mulai menambahkan jenis input dan output Anda. Perhatikan bahwa tipe di sini tidak boleh digunakan dalam kode nyata; mereka hanya contoh untuk membantu Anda memahami prosesnya.
Pertama, kita akan membuat tipe objek. Dalam kode nyata, Anda tidak harus memulai dengan jenis ini. Anda dapat membuat jenis apa pun yang Anda inginkan kapan saja selama Anda mengikuti aturan dan sintaks GraphQL.
**catatan**
Beberapa bagian berikutnya akan menggunakan **editor skema**, jadi biarkan ini tetap terbuka.
------
#### [ Console ]
+ Anda dapat membuat tipe objek menggunakan `type` kata kunci bersama dengan nama tipe:
```
type Type_Name_Goes_Here {}
```
Di dalam cakupan tipe, Anda dapat menambahkan bidang yang mewakili karakteristik objek:
```
type Type_Name_Goes_Here {
# Add fields here
}
```
Inilah contohnya:
```
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
```
**catatan**
Pada langkah ini, kami menambahkan tipe objek generik dengan `id` bidang wajib disimpan sebagai`ID`, `title` bidang yang disimpan sebagai`String`, dan `date` bidang yang disimpan sebagai`AWSDateTime`. Untuk melihat daftar jenis dan bidang dan apa yang mereka lakukan, lihat [Skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-components.html). Untuk melihat daftar skalar dan apa yang mereka lakukan, lihat [referensi Type](https://docs.aws.amazon.com/appsync/latest/devguide/type-reference.html).
------
#### [ CLI ]
**catatan**
Kami merekomendasikan membaca versi konsol terlebih dahulu jika Anda belum melakukannya.
+ Anda dapat membuat tipe objek dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah:
```
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
```
1. `format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-type --api-id abcdefghijklmnopqrstuvwxyz --definition "type Obj_Type_1{id: ID! title: String date: AWSDateTime}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "type Obj_Type_1{id: ID! title: String date: AWSDateTime}",
"name": "Obj_Type_1",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Obj_Type_1",
"format": "SDL"
}
}
```
**catatan**
Pada langkah ini, kami menambahkan tipe objek generik dengan `id` bidang wajib disimpan sebagai`ID`, `title` bidang yang disimpan sebagai`String`, dan `date` bidang yang disimpan sebagai`AWSDateTime`. Untuk melihat daftar jenis dan bidang dan apa yang mereka lakukan, lihat [Skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-components.html). Untuk melihat daftar skalar dan apa yang mereka lakukan, lihat [Jenis referensi](https://docs.aws.amazon.com/appsync/latest/devguide/type-reference.html).
Pada catatan lebih lanjut, Anda mungkin telah menyadari bahwa memasukkan definisi secara langsung berfungsi untuk tipe yang lebih kecil tetapi tidak layak untuk menambahkan jenis yang lebih besar atau lebih banyak. Anda dapat memilih untuk menambahkan semuanya dalam `.graphql` file dan kemudian [meneruskannya sebagai input](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html).
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Untuk menambahkan tipe, Anda perlu menambahkannya ke `.graphql` file Anda. Misalnya, contoh konsol adalah:
```
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
```
Anda dapat menambahkan tipe Anda langsung ke skema seperti file lainnya.
**catatan**
Untuk menggunakan perubahan yang dibuat pada GraphQL API, Anda harus menerapkan ulang aplikasi.
------
[Jenis objek](https://graphql.org/learn/schema/#object-types-and-fields) memiliki bidang yang merupakan [tipe skalar](https://graphql.org/learn/schema/#scalar-types) seperti string dan bilangan bulat. AWS AppSync juga memungkinkan Anda untuk menggunakan jenis skalar yang disempurnakan seperti `AWSDateTime` selain skalar GraphQL dasar. Juga, bidang apa pun yang berakhir dengan tanda seru diperlukan.
Jenis `ID` skalar khususnya adalah pengidentifikasi unik yang dapat berupa atau`String`. `Int` Anda dapat mengontrol ini dalam kode resolver Anda untuk penugasan otomatis.
Ada kesamaan antara tipe objek khusus seperti `Query` dan tipe objek “biasa” seperti contoh di atas karena keduanya menggunakan `type` kata kunci dan dianggap objek. Namun, untuk tipe objek khusus (`Query`,`Mutation`, dan`Subscription`), perilakunya sangat berbeda karena diekspos sebagai titik masuk untuk API Anda. Mereka juga lebih tentang membentuk operasi daripada data. Untuk informasi selengkapnya, lihat [Jenis kueri dan mutasi](https://graphql.org/learn/schema/#the-query-and-mutation-types).
Pada topik jenis objek khusus, langkah selanjutnya bisa menambahkan satu atau lebih dari mereka untuk melakukan operasi pada data berbentuk. Dalam skenario nyata, setiap skema GraphQL setidaknya harus memiliki tipe kueri root untuk meminta data. Anda dapat menganggap kueri sebagai salah satu titik masuk (atau titik akhir) untuk server GraphQL Anda. Mari tambahkan kueri sebagai contoh.
------
#### [ Console ]
+ Untuk membuat kueri, Anda cukup menambahkannya ke file skema seperti jenis lainnya. Kueri akan membutuhkan `Query` tipe dan entri di root seperti ini:
```
schema {
query: Name_of_Query
}
type Name_of_Query {
# Add field operation here
}
```
Perhatikan bahwa *Name\$1of\$1Query* dalam lingkungan produksi hanya akan dipanggil `Query` dalam banyak kasus. Kami merekomendasikan untuk menyimpannya pada nilai ini. Di dalam jenis kueri, Anda dapat menambahkan bidang. Setiap bidang akan melakukan operasi dalam permintaan. Akibatnya, sebagian besar, jika tidak semua, bidang ini akan dilampirkan ke resolver. Namun, kami tidak peduli dengan itu di bagian ini. Mengenai format operasi lapangan, mungkin terlihat seperti ini:
```
Name_of_Query(params): Return_Type # version with params
Name_of_Query: Return_Type # version without params
```
Inilah contohnya:
```
schema {
query: Query
}
type Query {
getObj: [Obj_Type_1]
}
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
```
**catatan**
Pada langkah ini, kami menambahkan `Query` tipe dan mendefinisikannya di `schema` root kami. `Query`Tipe kami mendefinisikan `getObj` bidang yang mengembalikan daftar `Obj_Type_1` objek. Perhatikan bahwa itu `Obj_Type_1` adalah objek dari langkah sebelumnya. Dalam kode produksi, operasi lapangan Anda biasanya akan bekerja dengan data yang dibentuk oleh objek seperti`Obj_Type_1`. Selain itu, bidang seperti biasanya `getObj` akan memiliki resolver untuk melakukan logika bisnis. Itu akan dibahas di bagian yang berbeda.
Sebagai catatan tambahan, AWS AppSync secara otomatis menambahkan root skema selama ekspor, jadi secara teknis Anda tidak perlu menambahkannya langsung ke skema. Layanan kami akan secara otomatis memproses skema duplikat. Kami menambahkannya di sini sebagai praktik terbaik.
------
#### [ CLI ]
**catatan**
Kami merekomendasikan membaca versi konsol terlebih dahulu jika Anda belum melakukannya.
1. Buat `schema` root dengan `query` definisi dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah:
```
schema {
query: Query
}
```
1. `format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-type --api-id abcdefghijklmnopqrstuvwxyz --definition "schema {query: Query}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "schema {query: Query}",
"name": "schema",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/schema",
"format": "SDL"
}
}
```
**catatan**
Perhatikan bahwa jika Anda tidak memasukkan sesuatu dengan benar dalam `create-type` perintah, Anda dapat memperbarui root skema Anda (atau jenis apa pun dalam skema) dengan menjalankan perintah. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-type.html) Dalam contoh ini, kita akan sementara mengubah root skema untuk berisi `subscription` definisi.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
API Anda. `api-id`
Tipe Anda. `type-name` Dalam contoh konsol, ini adalah`schema`.
Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah:
```
schema {
query: Query
}
```
Skema setelah menambahkan `subscription` akan terlihat seperti ini:
```
schema {
query: Query
subscription: Subscription
}
```
`format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync update-type --api-id abcdefghijklmnopqrstuvwxyz --type-name schema --definition "schema {query: Query subscription: Subscription}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "schema {query: Query subscription: Subscription}",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/schema",
"format": "SDL"
}
}
```
Menambahkan file yang telah diformat akan tetap berfungsi dalam contoh ini.
1. Buat `Query` tipe dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah:
```
type Query {
getObj: [Obj_Type_1]
}
```
1. `format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-type --api-id abcdefghijklmnopqrstuvwxyz --definition "type Query {getObj: [Obj_Type_1]}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "Query {getObj: [Obj_Type_1]}",
"name": "Query",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query",
"format": "SDL"
}
}
```
**catatan**
Pada langkah ini, kami menambahkan `Query` tipe dan mendefinisikannya di `schema` root Anda. `Query`Tipe kami mendefinisikan `getObj` bidang yang mengembalikan daftar `Obj_Type_1` objek.
Dalam kode `schema` root`query: Query`, `query:` bagian menunjukkan bahwa kueri didefinisikan dalam skema Anda, sedangkan `Query` bagian tersebut menunjukkan nama objek khusus yang sebenarnya.
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Anda harus menambahkan kueri dan root skema ke `.graphql` file. Contoh kami terlihat seperti contoh di bawah ini, tetapi Anda ingin menggantinya dengan kode skema Anda yang sebenarnya:
```
schema {
query: Query
}
type Query {
getObj: [Obj_Type_1]
}
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
```
Anda dapat menambahkan tipe Anda langsung ke skema seperti file lainnya.
**catatan**
Memperbarui root skema adalah opsional. Kami menambahkannya ke contoh ini sebagai praktik terbaik.
Untuk menggunakan perubahan yang dibuat pada GraphQL API, Anda harus menerapkan ulang aplikasi.
------
Anda sekarang telah melihat contoh membuat objek dan objek khusus (query). Anda juga telah melihat bagaimana ini dapat saling berhubungan untuk menggambarkan data dan operasi. Anda dapat memiliki skema hanya dengan deskripsi data dan satu atau lebih kueri. Namun, kami ingin menambahkan operasi lain untuk menambahkan data ke sumber data. Kami akan menambahkan jenis objek khusus lain `Mutation` yang disebut yang memodifikasi data.
------
#### [ Console ]
+ Mutasi akan disebut`Mutation`. Seperti`Query`, operasi lapangan di dalam `Mutation` akan menggambarkan operasi dan akan dilampirkan ke resolver. Juga, perhatikan bahwa kita perlu mendefinisikannya di `schema` root karena ini adalah jenis objek khusus. Berikut adalah contoh mutasi:
```
schema {
mutation: Name_of_Mutation
}
type Name_of_Mutation {
# Add field operation here
}
```
Mutasi tipikal akan terdaftar di root seperti kueri. Mutasi didefinisikan menggunakan `type` kata kunci bersama dengan nama. *Name\$1of\$1Mutation*biasanya akan dipanggil`Mutation`, jadi kami sarankan untuk tetap seperti itu. Setiap bidang juga akan melakukan operasi. Mengenai format operasi lapangan, mungkin terlihat seperti ini:
```
Name_of_Mutation(params): Return_Type # version with params
Name_of_Mutation: Return_Type # version without params
```
Inilah contohnya:
```
schema {
query: Query
mutation: Mutation
}
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
type Query {
getObj: [Obj_Type_1]
}
type Mutation {
addObj(id: ID!, title: String, date: AWSDateTime): Obj_Type_1
}
```
**catatan**
Pada langkah ini, kami menambahkan `Mutation` tipe dengan `addObj` bidang. Mari kita rangkum apa yang dilakukan bidang ini:
```
addObj(id: ID!, title: String, date: AWSDateTime): Obj_Type_1
```
`addObj`menggunakan `Obj_Type_1` objek untuk melakukan operasi. Ini jelas karena bidang, tetapi sintaks membuktikan ini dalam tipe `: Obj_Type_1` pengembalian. Di dalam`addObj`, itu menerima`id`,`title`, dan `date` bidang dari `Obj_Type_1` objek sebagai parameter. Seperti yang Anda lihat, ini sangat mirip dengan deklarasi metode. Namun, kami belum menjelaskan perilaku metode kami. Seperti yang dinyatakan sebelumnya, skema hanya ada untuk menentukan apa data dan operasi nantinya dan bukan bagaimana mereka beroperasi. Menerapkan logika bisnis yang sebenarnya akan datang kemudian ketika kita membuat resolver pertama kita.
Setelah Anda selesai dengan skema Anda, ada opsi untuk mengekspornya sebagai `schema.graphql` file. Di **editor Skema**, Anda dapat memilih **skema Ekspor** untuk mengunduh file dalam format yang didukung.
Sebagai catatan tambahan, AWS AppSync secara otomatis menambahkan root skema selama ekspor, jadi secara teknis Anda tidak perlu menambahkannya langsung ke skema. Layanan kami akan secara otomatis memproses skema duplikat. Kami menambahkannya di sini sebagai praktik terbaik.
------
#### [ CLI ]
**catatan**
Kami merekomendasikan membaca versi konsol terlebih dahulu jika Anda belum melakukannya.
1. Perbarui skema root Anda dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-type.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Tipe Anda. `type-name` Dalam contoh konsol, ini adalah`schema`.
1. Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah:
```
schema {
query: Query
mutation: Mutation
}
```
1. `format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync update-type --api-id abcdefghijklmnopqrstuvwxyz --type-name schema --definition "schema {query: Query mutation: Mutation}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "schema {query: Query mutation: Mutation}",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/schema",
"format": "SDL"
}
}
```
1. Buat `Mutation` tipe dengan menjalankan [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-type.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Itu`definition`, atau konten tipe Anda. Dalam contoh konsol, ini adalah
```
type Mutation {
addObj(id: ID!, title: String, date: AWSDateTime): Obj_Type_1
}
```
1. `format`Masukan Anda. Dalam contoh ini, kita menggunakan`SDL`.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-type --api-id abcdefghijklmnopqrstuvwxyz --definition "type Mutation {addObj(id: ID! title: String date: AWSDateTime): Obj_Type_1}" --format SDL
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"type": {
"definition": "type Mutation {addObj(id: ID! title: String date: AWSDateTime): Obj_Type_1}",
"name": "Mutation",
"arn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation",
"format": "SDL"
}
}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Anda harus menambahkan kueri dan root skema ke `.graphql` file. Contoh kami terlihat seperti contoh di bawah ini, tetapi Anda ingin menggantinya dengan kode skema Anda yang sebenarnya:
```
schema {
query: Query
mutation: Mutation
}
type Obj_Type_1 {
id: ID!
title: String
date: AWSDateTime
}
type Query {
getObj: [Obj_Type_1]
}
type Mutation {
addObj(id: ID!, title: String, date: AWSDateTime): Obj_Type_1
}
```
**catatan**
Memperbarui root skema adalah opsional. Kami menambahkannya ke contoh ini sebagai praktik terbaik.
Untuk menggunakan perubahan yang dibuat pada GraphQL API, Anda harus menerapkan ulang aplikasi.
------
## Pertimbangan opsional - Menggunakan enum sebagai status
Pada titik ini, Anda tahu cara membuat skema dasar. Namun, ada banyak hal yang dapat Anda tambahkan untuk meningkatkan fungsionalitas skema. Satu hal umum yang ditemukan dalam aplikasi adalah penggunaan enum sebagai status. Anda dapat menggunakan enum untuk memaksa nilai tertentu dari sekumpulan nilai yang akan dipilih saat dipanggil. Ini bagus untuk hal-hal yang Anda tahu tidak akan berubah secara drastis dalam jangka waktu yang lama. Secara hipotetis, kita dapat menambahkan enum yang mengembalikan kode status atau String dalam respons.
Sebagai contoh, mari kita asumsikan kita membuat aplikasi media sosial yang menyimpan data posting pengguna di backend. Skema kami berisi `Post` jenis yang mewakili data posting individu:
```
type Post {
id: ID!
title: String
date: AWSDateTime
poststatus: PostStatus
}
```
`Post`Will kami berisi postingan `title` unik`id`, posting, dan enum `PostStatus` yang disebut yang mewakili status posting saat diproses oleh aplikasi. `date` Untuk operasi kami, kami akan memiliki kueri yang mengembalikan semua data posting:
```
type Query {
getPosts: [Post]
}
```
Kami juga akan memiliki mutasi yang menambahkan posting ke sumber data:
```
type Mutation {
addPost(id: ID!, title: String, date: AWSDateTime, poststatus: PostStatus): Post
}
```
Melihat skema kami, `PostStatus` enum bisa memiliki beberapa status. Kita mungkin ingin tiga status dasar dipanggil `success` (post berhasil diproses), `pending` (post sedang diproses), dan `error` (post tidak dapat diproses). Untuk menambahkan enum, kita bisa melakukan ini:
```
enum PostStatus {
success
pending
error
}
```
Skema lengkap mungkin terlihat seperti ini:
```
schema {
query: Query
mutation: Mutation
}
type Post {
id: ID!
title: String
date: AWSDateTime
poststatus: PostStatus
}
type Mutation {
addPost(id: ID!, title: String, date: AWSDateTime, poststatus: PostStatus): Post
}
type Query {
getPosts: [Post]
}
enum PostStatus {
success
pending
error
}
```
Jika pengguna menambahkan a `Post` dalam aplikasi, `addPost` operasi akan dipanggil untuk memproses data tersebut. Sebagai resolver dilampirkan untuk `addPost` memproses data, itu akan terus memperbarui `poststatus` dengan status operasi. Saat ditanyakan, `Post` akan berisi status akhir data. Perlu diingat, kami hanya menjelaskan bagaimana kami ingin data bekerja dalam skema. Kami mengasumsikan banyak tentang implementasi resolver kami, yang akan menerapkan logika bisnis aktual untuk menangani data guna memenuhi permintaan.
## Pertimbangan opsional - Langganan
Langganan di AWS AppSync dipanggil sebagai respons terhadap mutasi. Anda mengonfigurasi ini dengan `Subscription` tipe dan `@aws_subscribe()` arahan dalam skema untuk menunjukkan mutasi mana yang memanggil satu atau beberapa langganan. Untuk informasi selengkapnya tentang mengonfigurasi langganan, lihat Data [waktu nyata](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html).
## Pertimbangan opsional - Hubungan dan pagination
Misalkan Anda memiliki satu juta `Posts` disimpan dalam tabel DynamoDB, dan Anda ingin mengembalikan beberapa data itu. Namun, contoh query yang diberikan di atas hanya mengembalikan semua posting. Anda tidak ingin mengambil semua ini setiap kali Anda membuat permintaan. Sebaliknya, Anda ingin membuat [paginasi](https://graphql.org/learn/pagination/) melalui mereka. Buat perubahan berikut pada skema Anda:
+ Di `getPosts` lapangan, tambahkan dua argumen masukan: `nextToken` (iterator) dan `limit` (batas iterasi).
+ Tambahkan `PostIterator` tipe baru yang berisi `Posts` (mengambil daftar `Post` objek) dan `nextToken` (iterator) bidang.
+ Ubah `getPosts` sehingga kembali `PostIterator` dan bukan daftar `Post` objek.
```
schema {
query: Query
mutation: Mutation
}
type Post {
id: ID!
title: String
date: AWSDateTime
poststatus: PostStatus
}
type Mutation {
addPost(id: ID!, title: String, date: AWSDateTime, poststatus: PostStatus): Post
}
type Query {
getPosts(limit: Int, nextToken: String): PostIterator
}
enum PostStatus {
success
pending
error
}
type PostIterator {
posts: [Post]
nextToken: String
}
```
`PostIterator`Jenis ini memungkinkan Anda untuk mengembalikan sebagian dari daftar `Post` objek dan `nextToken` untuk mendapatkan bagian berikutnya. Di dalamnya`PostIterator`, ada daftar `Post` item (`[Post]`) yang dikembalikan dengan token pagination (`nextToken`). Pada tahun AWS AppSync, ini akan terhubung ke Amazon DynamoDB melalui resolver dan secara otomatis dihasilkan sebagai token terenkripsi. Ini mengubah nilai `limit` argumen ke `maxResults` parameter dan `nextToken` argumen ke `exclusiveStartKey` parameter. Untuk contoh dan contoh templat bawaan di AWS AppSync konsol, lihat [Referensi resolusi () JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html).
# Melampirkan sumber data di AWS AppSync
Sumber data adalah sumber daya di AWS akun Anda yang dapat berinteraksi dengan APIs GraphQL. AWS AppSync mendukung banyak sumber data seperti AWS Lambda, Amazon DynamoDB, database relasional (Amazon Aurora Tanpa Server), Layanan Amazon, dan titik akhir HTTP. OpenSearch AWS AppSync API dapat dikonfigurasi untuk berinteraksi dengan beberapa sumber data, memungkinkan Anda untuk mengumpulkan data di satu lokasi. AWS AppSync dapat menggunakan AWS sumber daya yang ada dari akun Anda atau menyediakan tabel DynamoDB atas nama Anda dari definisi skema.
Bagian berikut akan menunjukkan cara melampirkan sumber data ke GraphQL API Anda.
## Jenis sumber data
Sekarang setelah Anda membuat skema di AWS AppSync konsol, Anda dapat melampirkan sumber data ke dalamnya. Saat Anda pertama kali membuat API, ada opsi untuk menyediakan tabel Amazon DynamoDB selama pembuatan skema yang telah ditentukan. Namun, kami tidak akan membahas opsi itu di bagian ini. Anda dapat melihat contoh ini di bagian [Meluncurkan skema](https://docs.aws.amazon.com//appsync/latest/devguide/schema-launch-start.html).
Sebagai gantinya, kita akan melihat semua sumber data yang AWS AppSync mendukung. Ada banyak faktor yang masuk ke dalam memilih solusi yang tepat untuk aplikasi Anda. Bagian di bawah ini akan memberikan beberapa konteks tambahan untuk setiap sumber data. Untuk informasi umum tentang sumber data, lihat [Sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/data-source-components.html).
### Amazon DynamoDB
Amazon DynamoDB adalah salah satu 'solusi penyimpanan utama AWS untuk aplikasi yang dapat diskalakan. **Komponen inti dari DynamoDB adalah tabel, yang hanya merupakan kumpulan data.** Anda biasanya akan membuat tabel berdasarkan entitas seperti `Book` atau`Author`. Informasi entri tabel disimpan sebagai **item**, yang merupakan kelompok bidang yang unik untuk setiap entri. Item lengkap mewakili a row/record dalam database. Misalnya, item untuk `Book` entri mungkin termasuk `title` dan `author` bersama dengan nilainya. Bidang individu seperti `title` dan `author` disebut **atribut**, yang mirip dengan nilai kolom dalam database relasional.
Seperti yang bisa Anda tebak, tabel akan digunakan untuk menyimpan data dari aplikasi Anda. AWS AppSync memungkinkan Anda untuk menghubungkan tabel DynamoDB Anda ke GraphQL API Anda untuk memanipulasi data. Ambil [kasus penggunaan](https://aws.amazon.com/blogs/mobile/new-real-time-multi-group-app-with-aws-amplify-graphql-build-a-twitter-community-clone/) ini dari *web Front-end dan blog seluler*. Aplikasi ini memungkinkan pengguna mendaftar untuk aplikasi media sosial. Pengguna dapat bergabung dengan grup dan mengunggah posting yang disiarkan ke pengguna lain yang berlangganan grup. Aplikasi mereka menyimpan informasi pengguna, posting, dan grup pengguna di DynamoDB. GraphQL API (dikelola AWS AppSync oleh) berinteraksi dengan tabel DynamoDB. Ketika pengguna membuat perubahan dalam sistem yang akan tercermin di front-end, GraphQL API mengambil perubahan ini dan menyiarkannya ke pengguna lain secara real time.
### AWS Lambda
Lambda adalah layanan berbasis peristiwa yang secara otomatis membangun sumber daya yang diperlukan untuk menjalankan kode sebagai respons terhadap suatu peristiwa. Lambda menggunakan **fungsi**, yang merupakan pernyataan grup yang berisi kode, dependensi, dan konfigurasi untuk mengeksekusi sumber daya. Fungsi dijalankan secara otomatis ketika mereka mendeteksi **pemicu**, sekelompok aktivitas yang memanggil fungsi Anda. Pemicu bisa berupa apa saja seperti aplikasi yang melakukan panggilan API, AWS layanan di akun Anda yang memutar sumber daya, dll. Ketika dipicu, fungsi akan memproses **peristiwa**, yang merupakan dokumen JSON yang berisi data untuk dimodifikasi.
Lambda bagus untuk menjalankan kode tanpa harus menyediakan sumber daya untuk menjalankannya. Ambil [kasus penggunaan](https://aws.amazon.com/blogs/mobile/building-a-graphql-api-with-java-and-aws-lambda/) ini dari *web Front-end dan blog seluler*. Kasus penggunaan ini sedikit mirip dengan yang dipamerkan di bagian DynamoDB. Dalam aplikasi ini, GraphQL API bertanggung jawab untuk mendefinisikan operasi untuk hal-hal seperti menambahkan posting (mutasi) dan mengambil data itu (kueri). Untuk mengimplementasikan fungsionalitas operasi mereka (misalnya,`getPost ( id: String ! ) : Post`,`getPostsByAuthor ( author: String ! ) : [ Post ]`), mereka menggunakan fungsi Lambda untuk memproses permintaan masuk. Di bawah *Opsi 2: AWS AppSync dengan Lambda resolver*, mereka menggunakan AWS AppSync layanan untuk mempertahankan skema mereka dan menautkan sumber data Lambda ke salah satu operasi. Ketika operasi dipanggil, Lambda berinteraksi dengan proxy Amazon RDS untuk melakukan logika bisnis pada database.
### Amazon RDS
Amazon RDS memungkinkan Anda membangun dan mengonfigurasi database relasional dengan cepat. Di Amazon RDS, Anda akan membuat **instance database** generik yang akan berfungsi sebagai lingkungan database terisolasi di cloud. Dalam hal ini, Anda akan menggunakan **mesin DB**, yang merupakan perangkat lunak RDBMS yang sebenarnya (PostgreSQL, MySQL, dll.). Layanan ini membongkar sebagian besar pekerjaan backend dengan menyediakan skalabilitas menggunakan AWS'infrastruktur, layanan keamanan seperti patching dan enkripsi, dan menurunkan biaya administrasi untuk penerapan.
Ambil [kasus penggunaan](https://aws.amazon.com/blogs/mobile/building-a-graphql-api-with-java-and-aws-lambda/) yang sama dari bagian Lambda. Di bawah *Opsi 3: AWS AppSync dengan Amazon RDS resolver*, opsi lain yang disajikan adalah menautkan GraphQL API ke Amazon RDS secara langsung. AWS AppSync Menggunakan [API data](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html), mereka mengaitkan database dengan GraphQL API. Resolver dilampirkan ke bidang (biasanya kueri, mutasi, atau langganan) dan mengimplementasikan pernyataan SQL yang diperlukan untuk mengakses database. Ketika permintaan memanggil bidang dibuat oleh klien, resolver mengeksekusi pernyataan dan mengembalikan respon.
### Amazon EventBridge
Di EventBridge, Anda akan membuat **bus acara**, yang merupakan saluran pipa yang menerima acara dari layanan atau aplikasi yang Anda lampirkan (**sumber acara**) dan memprosesnya berdasarkan seperangkat aturan. **Peristiwa** adalah beberapa perubahan status dalam lingkungan eksekusi, sedangkan **aturan** adalah seperangkat filter untuk acara. Aturan mengikuti **pola peristiwa**, atau metadata perubahan status peristiwa (id, Wilayah, nomor akun, ARN, dll.). Ketika suatu peristiwa cocok dengan pola acara, EventBridge akan mengirim acara melintasi pipeline ke layanan tujuan (**target**) dan memicu tindakan yang ditentukan dalam aturan.
EventBridge baik untuk merutekan operasi yang mengubah status ke beberapa layanan lain. Ambil [kasus penggunaan](https://aws.amazon.com/blogs/mobile/appsync-eventbridge/) ini dari *web Front-end dan blog seluler*. Contoh ini menggambarkan solusi e-commerce yang memiliki beberapa tim yang mempertahankan layanan yang berbeda. Salah satu layanan ini menyediakan pembaruan pesanan kepada pelanggan pada setiap langkah pengiriman (pesanan ditempatkan, sedang berlangsung, dikirim, dikirim, dll.) Di front-end. Namun, tim front-end yang mengelola layanan ini tidak memiliki akses langsung ke data sistem pemesanan seperti yang dikelola oleh tim backend terpisah. Sistem pemesanan tim backend juga digambarkan sebagai kotak hitam, sehingga sulit untuk mengumpulkan informasi tentang cara mereka menyusun data mereka. Namun, tim backend memang menyiapkan sistem yang menerbitkan data pesanan melalui bus acara yang dikelola oleh. EventBridge Untuk mengakses data yang berasal dari bus acara dan mengarahkannya ke front-end, tim front-end membuat target baru yang menunjuk ke GraphQL API mereka. AWS AppSync Mereka juga membuat aturan untuk hanya mengirim data yang relevan dengan pembaruan pesanan. Saat pembaruan dibuat, data dari bus acara dikirim ke GraphQL API. Skema dalam API memproses data, lalu meneruskannya ke front-end.
### Tidak ada sumber data
Jika Anda tidak berencana menggunakan sumber data, Anda dapat mengaturnya`none`. Sumber `none` data, meskipun masih secara eksplisit dikategorikan sebagai sumber data, bukanlah media penyimpanan. Biasanya, resolver akan memanggil satu atau lebih sumber data di beberapa titik untuk memproses permintaan. Namun, ada situasi di mana Anda mungkin tidak perlu memanipulasi sumber data. Menyetel sumber data ke `none` akan menjalankan permintaan, lewati langkah pemanggilan data, lalu jalankan respons.
Ambil [kasus penggunaan](https://aws.amazon.com/blogs/mobile/appsync-eventbridge/) yang sama dari EventBridge bagian. Dalam skema, mutasi memproses pembaruan status, lalu mengirimkannya ke pelanggan. Mengingat cara kerja resolver, biasanya ada setidaknya satu pemanggilan sumber data. Namun, data dalam skenario ini sudah dikirim secara otomatis oleh bus acara. Ini berarti mutasi tidak perlu melakukan pemanggilan sumber data; status pesanan dapat ditangani secara lokal. Mutasi diatur ke`none`, yang bertindak sebagai nilai pass-through tanpa pemanggilan sumber data. Skema tersebut kemudian diisi dengan data, yang dikirim ke pelanggan.
### OpenSearch
Amazon OpenSearch Service adalah seperangkat alat untuk menerapkan pencarian teks lengkap, visualisasi data, dan logging. Anda dapat menggunakan layanan ini untuk menanyakan data terstruktur yang telah Anda unggah.
Dalam layanan ini, Anda akan membuat contoh. OpenSearch Ini disebut **node**. Dalam sebuah node, Anda akan menambahkan setidaknya satu **indeks**. Indeks secara konseptual sedikit mirip tabel dalam database relasional. (Namun, OpenSearch tidak sesuai dengan ACID, jadi tidak boleh digunakan seperti itu). Anda akan mengisi indeks Anda dengan data yang Anda unggah ke OpenSearch layanan. Ketika data Anda diunggah, itu akan diindeks dalam satu atau lebih pecahan yang ada di indeks. **Shard** seperti partisi indeks Anda yang berisi beberapa data Anda dan dapat ditanyakan secara terpisah dari pecahan lainnya. **Setelah diunggah, data Anda akan terstruktur sebagai file JSON yang disebut dokumen.** Anda kemudian dapat menanyakan node untuk data dalam dokumen.
### Titik akhir HTTP
Anda dapat menggunakan titik akhir HTTP sebagai sumber data. AWS AppSync dapat mengirim permintaan ke titik akhir dengan informasi yang relevan seperti params dan payload. Respons HTTP akan diekspos ke resolver, yang akan mengembalikan respons akhir setelah selesai operasinya.
## Menambahkan sumber data
Jika Anda membuat sumber data, Anda dapat menautkannya ke AWS AppSync layanan dan, lebih khusus lagi, API.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Pilih API Anda di **Dasbor**.
1. Di **Sidebar**, pilih **Sumber Data**.
1. Pilih **Buat sumber data**.
1. Beri nama sumber data Anda. Anda juga dapat memberikan deskripsi, tetapi itu opsional.
1. Pilih **tipe sumber data** Anda.
1. Untuk DynamoDB, Anda harus memilih Region Anda, lalu tabel di Region. Anda dapat mendikte aturan interaksi dengan tabel Anda dengan memilih untuk membuat peran tabel generik baru atau mengimpor peran yang ada untuk tabel. Anda dapat mengaktifkan [pembuatan versi](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html), yang secara otomatis dapat membuat versi data untuk setiap permintaan saat beberapa klien mencoba memperbarui data secara bersamaan. Versioning digunakan untuk menyimpan dan memelihara beberapa varian data untuk tujuan deteksi dan resolusi konflik. Anda juga dapat mengaktifkan pembuatan skema otomatis, yang mengambil sumber data Anda dan menghasilkan beberapa CRUD,`List`, dan `Query` operasi yang diperlukan untuk mengaksesnya dalam skema Anda.
Untuk OpenSearch, Anda harus memilih Region Anda, lalu domain (cluster) di Region. Anda dapat mendikte aturan interaksi dengan domain Anda dengan memilih untuk membuat peran tabel generik baru atau mengimpor peran yang ada untuk tabel.
Untuk Lambda, Anda harus memilih Wilayah Anda, lalu ARN dari fungsi Lambda di Wilayah. Anda dapat mendikte aturan interaksi dengan fungsi Lambda Anda dengan memilih untuk membuat peran tabel generik baru atau mengimpor peran yang ada untuk tabel.
Untuk HTTP, Anda harus memasukkan titik akhir HTTP Anda.
Untuk EventBridge, Anda harus memilih Wilayah Anda, lalu bus acara di Wilayah. Anda dapat mendikte aturan interaksi dengan bus acara Anda dengan memilih untuk membuat peran tabel generik baru atau mengimpor peran yang ada untuk tabel.
Untuk RDS, Anda harus memilih Wilayah Anda, lalu toko rahasia (nama pengguna dan kata sandi), nama database, dan skema.
Untuk tidak ada, Anda akan menambahkan sumber data tanpa sumber data aktual. Ini untuk menangani resolver secara lokal daripada melalui sumber data aktual.
**catatan**
Jika Anda mengimpor peran yang ada, mereka memerlukan kebijakan kepercayaan. Untuk informasi selengkapnya, lihat [kebijakan kepercayaan IAM](#iam-trust-policy.title).
1. Pilih **Buat**.
**catatan**
**Atau, jika Anda membuat sumber data DynamoDB, Anda dapat pergi ke halaman Skema di konsol, **pilih Buat** Sumber Daya di bagian atas halaman, lalu isi model yang telah ditentukan untuk dikonversi menjadi tabel.** Dalam opsi ini, Anda akan mengisi atau mengimpor tipe dasar, mengkonfigurasi data tabel dasar termasuk kunci partisi, dan meninjau perubahan skema.
------
#### [ CLI ]
+ Buat sumber data Anda dengan menjalankan [https://docs.aws.amazon.com/cli/latest/reference/appsync/create-data-source.html](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-data-source.html)perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Meja Anda. `name`
1. `type`Sumber data. Bergantung pada jenis sumber data yang Anda pilih, Anda mungkin perlu memasukkan `service-role-arn` dan `-config` tag.
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name data_source_name --type data_source_type --service-role-arn arn:aws:iam::107289374856:role/role_name --[data_source_type]-config {params}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Untuk menambahkan sumber data khusus Anda, Anda harus menambahkan konstruksi ke file tumpukan Anda. Daftar tipe sumber data dapat ditemukan di sini:
+ [ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
+ [ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
+ [ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
+ [ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
+ [ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
+ [ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
+ [ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
1. Secara umum, Anda mungkin harus menambahkan direktif impor ke layanan yang Anda gunakan. Misalnya, mungkin mengikuti formulir:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
Misalnya, inilah cara Anda dapat mengimpor layanan DynamoDB AWS AppSync dan DynamoDB:
```
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
```
1. Beberapa layanan seperti RDS memerlukan beberapa pengaturan tambahan dalam file tumpukan sebelum membuat sumber data (misalnya, pembuatan VPC, peran, dan kredenal akses). Lihat contoh di halaman CDK yang relevan untuk informasi lebih lanjut.
1. Untuk sebagian besar sumber data, terutama AWS layanan, Anda akan membuat instance baru dari sumber data di file tumpukan Anda. Biasanya, ini akan terlihat seperti berikut:
```
const add_data_source_func = new service_scope.resource_name(scope: Construct, id: string, props: data_source_props);
```
Misalnya, berikut adalah contoh tabel Amazon DynamoDB:
```
const add_ddb_table = new dynamodb.Table(this, 'Table_ID', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
sortKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
tableClass: dynamodb.TableClass.STANDARD,
});
```
**catatan**
Sebagian besar sumber data akan memiliki setidaknya satu prop yang diperlukan (akan dilambangkan **tanpa** simbol). `?` Konsultasikan dokumentasi CDK untuk melihat alat peraga mana yang diperlukan.
1. Selanjutnya, Anda perlu menautkan sumber data ke GraphQL API. Metode yang disarankan adalah menambahkannya saat Anda membuat fungsi untuk penyelesai pipa Anda. Misalnya, cuplikan di bawah ini adalah fungsi yang memindai semua elemen dalam tabel DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func_ID', {
name: 'func_name_in_console',
add_api,
dataSource: add_api.addDynamoDbDataSource('data_source_name_in_console', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
```
Di `dataSource` props, Anda dapat memanggil GraphQL API `add_api` () dan menggunakan salah satu metode bawaannya `addDynamoDbDataSource` () untuk membuat asosiasi antara tabel dan GraphQL API. Argumen adalah nama tautan ini yang akan ada di AWS AppSync konsol (`data_source_name_in_console`dalam contoh ini) dan metode tabel (`add_ddb_table`). Lebih lanjut tentang topik ini akan terungkap di bagian selanjutnya ketika Anda mulai membuat resolver.
Ada metode alternatif untuk menghubungkan sumber data. Anda secara teknis dapat menambahkan `api` ke daftar alat peraga dalam fungsi tabel. Misalnya, inilah cuplikan dari langkah 3 tetapi dengan alat `api` peraga yang berisi GraphQL API:
```
const add_api = new appsync.GraphqlApi(this, 'API_ID', {
...
});
const add_ddb_table = new dynamodb.Table(this, 'Table_ID', {
...
api: add_api
});
```
Atau, Anda dapat memanggil `GraphqlApi` konstruksi secara terpisah:
```
const add_api = new appsync.GraphqlApi(this, 'API_ID', {
...
});
const add_ddb_table = new dynamodb.Table(this, 'Table_ID', {
...
});
const link_data_source = add_api.addDynamoDbDataSource('data_source_name_in_console', add_ddb_table);
```
Kami merekomendasikan hanya membuat asosiasi di alat peraga fungsi. Jika tidak, Anda harus menautkan fungsi resolver Anda ke sumber data secara manual di AWS AppSync konsol (jika Anda ingin tetap menggunakan nilai konsol`data_source_name_in_console`) atau membuat asosiasi terpisah dalam fungsi dengan nama lain seperti. `data_source_name_in_console_2` Ini karena keterbatasan dalam cara alat peraga memproses informasi.
**catatan**
Anda harus menerapkan ulang aplikasi untuk melihat perubahan Anda.
------
### Kebijakan kepercayaan IAM
Jika Anda menggunakan peran IAM yang ada untuk sumber data Anda, Anda harus memberikan peran tersebut izin yang sesuai untuk melakukan operasi pada AWS sumber daya Anda, seperti `PutItem` pada tabel Amazon DynamoDB. Anda juga perlu mengubah kebijakan kepercayaan pada peran tersebut agar dapat menggunakannya AWS AppSync untuk akses sumber daya seperti yang ditunjukkan dalam contoh kebijakan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appsync.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Anda juga dapat menambahkan ketentuan ke kebijakan kepercayaan Anda untuk membatasi akses ke sumber data sesuai keinginan. Saat ini, `SourceArn` dan `SourceAccount` kunci dapat digunakan dalam kondisi ini. Misalnya, kebijakan berikut membatasi akses ke sumber data Anda ke akun`123456789012`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appsync.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
Atau, Anda dapat membatasi akses ke sumber data ke API tertentu, seperti`abcdefghijklmnopq`, menggunakan kebijakan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appsync.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:appsync:us-west-2:123456789012:apis/abcdefghijklmnopq"
}
}
}
]
}
```
------
Anda dapat membatasi akses ke semua AWS AppSync APIs dari wilayah tertentu, seperti`us-east-1`, menggunakan kebijakan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appsync.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:appsync:us-east-1:123456789012:apis/*"
}
}
}
]
}
```
------
Pada bagian berikutnya ([Configuring Resolvers](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-config-overview.html)), kami akan menambahkan logika bisnis resolver kami dan melampirkannya ke bidang dalam skema kami untuk memproses data di sumber data kami.
Untuk informasi selengkapnya mengenai konfigurasi kebijakan peran, lihat [Memodifikasi peran](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_manage_modify.html) dalam *Panduan Pengguna IAM*.
Untuk informasi selengkapnya mengenai akses resolver lintas akun AWS AppSync, lihat [Membangun AWS Lambda resolver lintas AWS Lambda](https://aws.amazon.com/blogs/mobile/appsync-lambda-cross-account/) akun untuk. AWS AppSync
# Mengkonfigurasi resolver di AWS AppSync
Di bagian sebelumnya, Anda mempelajari cara membuat skema GraphQL dan sumber data, lalu menghubungkannya bersama dalam layanan. AWS AppSync Dalam skema Anda, Anda mungkin telah menetapkan satu atau beberapa bidang (operasi) dalam kueri dan mutasi Anda. Sementara skema menggambarkan jenis data yang akan diminta operasi dari sumber data, skema tersebut tidak pernah menerapkan bagaimana operasi tersebut akan berperilaku di sekitar data.
Perilaku operasi selalu diimplementasikan dalam resolver, yang akan dikaitkan dengan bidang yang melakukan operasi. Untuk informasi selengkapnya tentang cara kerja resolver secara umum, lihat halaman [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html).
Di AWS AppSync, resolver Anda terkait dengan runtime, yang merupakan lingkungan di mana resolver Anda mengeksekusi. Runtime mendikte bahasa tempat resolver Anda akan ditulis. Saat ini ada dua runtime yang didukung: APPSYNC\$1JS (JavaScript) dan Apache Velocity Template Language (VTL).
Saat menerapkan resolver, ada struktur umum yang mereka ikuti:
+ **Sebelum langkah**: Ketika permintaan dibuat oleh klien, resolver untuk bidang skema yang digunakan (biasanya kueri, mutasi, langganan Anda) diteruskan data permintaan. Penyelesai akan mulai memproses data permintaan dengan penangan langkah sebelum, yang memungkinkan beberapa operasi pra-pemrosesan dilakukan sebelum data bergerak melalui resolver.
+ **Fungsi**: Setelah langkah sebelum berjalan, permintaan diteruskan ke daftar fungsi. Fungsi pertama dalam daftar akan dijalankan terhadap sumber data. Fungsi adalah subset dari kode resolver Anda yang berisi permintaan dan penangan responsnya sendiri. Handler permintaan akan mengambil data permintaan dan melakukan operasi terhadap sumber data. Response handler akan memproses respon sumber data sebelum meneruskannya kembali ke daftar. Jika ada lebih dari satu fungsi, data permintaan akan dikirim ke fungsi berikutnya dalam daftar yang akan dieksekusi. Fungsi dalam daftar akan dijalankan secara serial dalam urutan yang ditentukan oleh pengembang. Setelah semua fungsi dieksekusi, hasil akhir diteruskan ke langkah setelahnya.
+ **Langkah setelah: Langkah** setelah adalah fungsi handler yang memungkinkan Anda melakukan beberapa operasi akhir pada respons fungsi akhir sebelum meneruskannya ke respons GraphQL.
Aliran ini adalah contoh dari resolver pipa. Resolver pipeline didukung di kedua runtime. Namun, ini adalah penjelasan yang disederhanakan tentang apa yang dapat dilakukan oleh penyelesai pipa. Juga, kami hanya menjelaskan satu konfigurasi resolver yang mungkin. [Untuk informasi selengkapnya tentang konfigurasi resolver yang didukung, lihat ikhtisar resolver untuk APPSYNC\$1JS atau [ikhtisar template pemetaan JavaScript Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) untuk VTL.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html)
Seperti yang Anda lihat, resolver bersifat modular. Agar komponen resolver berfungsi dengan baik, mereka harus dapat mengintip ke dalam keadaan eksekusi dari komponen lain. Dari bagian [Resolvers](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html), Anda tahu bahwa setiap komponen dalam resolver dapat diteruskan informasi penting tentang status eksekusi sebagai satu set argumen (`args`,`context`, dll.). Dalam AWS AppSync, ini ditangani secara ketat oleh. `context` Ini adalah wadah untuk informasi tentang bidang yang sedang diselesaikan. Ini dapat mencakup semuanya mulai dari argumen yang diteruskan, hasil, data otorisasi, data header, dll. Untuk informasi lebih lanjut tentang konteksnya, lihat [referensi objek konteks Resolver untuk APPSYNC\$1JS atau referensi](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) konteks template pemetaan [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html) untuk VTL.
Konteksnya bukan satu-satunya alat yang dapat Anda gunakan untuk mengimplementasikan resolver Anda. AWS AppSync mendukung berbagai utilitas untuk menghasilkan nilai, penanganan kesalahan, penguraian, konversi, dll. [Anda dapat melihat daftar utilitas [di sini](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) untuk APPSYNC\$1JS atau di sini untuk VTL.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference.html)
Di bagian berikut, Anda akan mempelajari cara mengonfigurasi resolver di GraphQL API Anda.
**Topics**
+ [Membuat query dasar () JavaScript](configuring-resolvers-js.md)
+ [Membuat kueri dasar (VTL)](configuring-resolvers.md)
# Membuat query dasar () JavaScript
GraphQL resolver menghubungkan bidang dalam skema tipe ke sumber data. Resolver adalah mekanisme dimana permintaan dipenuhi.
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 menjelaskan cara mengkonfigurasi resolver menggunakan. JavaScript Bagian tutorial [Resolver (JavaScript) menyediakan tutorial](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) mendalam tentang cara menerapkan resolver menggunakan. JavaScript Bagian [Referensi Resolver (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) memberikan penjelasan tentang operasi utilitas yang dapat digunakan dengan JavaScript resolver.
Sebaiknya ikuti panduan ini sebelum mencoba menggunakan salah satu tutorial yang disebutkan di atas.
Di bagian ini, kita akan membahas cara membuat dan mengkonfigurasi resolver untuk kueri dan mutasi.
**catatan**
Panduan ini mengasumsikan Anda telah membuat skema Anda dan memiliki setidaknya satu kueri atau mutasi. Jika Anda mencari langganan (data waktu nyata), lihat panduan [ini](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html).
Di bagian ini, kami akan memberikan beberapa langkah umum untuk mengonfigurasi resolver bersama dengan contoh yang menggunakan skema di bawah ini:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Membuat resolver kueri dasar
Bagian ini akan menunjukkan cara membuat resolver kueri dasar.
------
#### [ 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. Masukkan detail skema dan sumber data Anda. Lihat bagian [Merancang skema Anda](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) dan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) untuk informasi selengkapnya.
1. Di sebelah editor **Skema**, Ada jendela bernama **Resolvers**. Kotak ini berisi daftar jenis dan bidang seperti yang didefinisikan di jendela **Skema** Anda. Anda dapat melampirkan resolver ke bidang. Anda kemungkinan besar akan melampirkan resolver ke operasi lapangan Anda. Pada bagian ini, kita akan melihat konfigurasi query sederhana. Di bawah Jenis **kueri**, pilih **Lampirkan** di sebelah bidang kueri Anda.
1. Pada halaman **Attach resolver**, di bawah **jenis Resolver, Anda dapat memilih antara pipeline atau resolver** unit. Untuk informasi selengkapnya tentang jenis ini, lihat [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Panduan ini akan memanfaatkan`pipeline resolvers`.
**Tip**
Saat membuat resolver pipeline, sumber data Anda akan dilampirkan ke fungsi pipeline. Fungsi dibuat setelah Anda membuat resolver pipeline itu sendiri, itulah sebabnya tidak ada opsi untuk mengaturnya di halaman ini. Jika Anda menggunakan resolver unit, sumber data terikat langsung ke resolver, jadi Anda akan mengaturnya di halaman ini.
Untuk **runtime Resolver, pilih `APPSYNC_JS` untuk mengaktifkan runtime**. JavaScript
1. Anda dapat mengaktifkan [caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) untuk API ini. Sebaiknya matikan fitur ini untuk saat ini. Pilih **Buat**.
1. Pada halaman **Edit resolver**, ada editor kode bernama kode **Resolver** yang memungkinkan Anda mengimplementasikan logika untuk penangan dan respons resolver (sebelum dan sesudah langkah). Untuk informasi selengkapnya, lihat ikhtisar [JavaScriptresolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
**catatan**
Dalam contoh kita, kita hanya akan membiarkan permintaan kosong dan respons ditetapkan untuk mengembalikan hasil sumber data terakhir dari [konteks](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html):
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Di bawah bagian ini, ada tabel yang disebut **Functions**. Fungsi memungkinkan Anda untuk menerapkan kode yang dapat digunakan kembali di beberapa resolver. Alih-alih terus-menerus menulis ulang atau menyalin kode, Anda dapat menyimpan kode sumber sebagai fungsi untuk ditambahkan ke resolver kapan pun Anda membutuhkannya.
Fungsi membentuk sebagian besar daftar operasi pipa. Saat menggunakan beberapa fungsi dalam resolver, Anda mengatur urutan fungsi, dan mereka akan dijalankan dalam urutan itu secara berurutan. Mereka dieksekusi setelah fungsi permintaan berjalan dan sebelum fungsi respon dimulai.
Untuk menambahkan fungsi baru, di bawah **Fungsi**, pilih **Tambah fungsi**, lalu **Buat fungsi baru**. Atau, Anda mungkin melihat tombol **Create function** untuk memilih sebagai gantinya.
1. Pilih sumber data. Ini akan menjadi sumber data tempat resolver bertindak.
**catatan**
Dalam contoh kita, kita melampirkan resolver untuk`getPost`, yang mengambil objek oleh. `Post` `id` Mari kita asumsikan kita sudah menyiapkan tabel DynamoDB untuk skema ini. Kunci partisi diatur ke `id` dan kosong.
1. Masukkan a`Function name`.
1. Di bawah **kode Fungsi**, Anda harus mengimplementasikan perilaku fungsi. Ini mungkin membingungkan, tetapi setiap fungsi akan memiliki permintaan lokal dan penangan respons sendiri. Permintaan berjalan, kemudian pemanggilan sumber data dibuat untuk menangani permintaan, kemudian respons sumber data diproses oleh penangan respons. Hasilnya disimpan dalam objek [konteks](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html). Setelah itu, fungsi berikutnya dalam daftar akan berjalan atau akan diteruskan ke penangan respons langkah setelah jika itu yang terakhir.
**catatan**
Dalam contoh kita, kita melampirkan resolver ke`getPost`, yang mendapat daftar `Post` objek dari sumber data. Fungsi permintaan kami akan meminta data dari tabel kami, tabel akan meneruskan responsnya ke konteks (ctx), maka respons akan mengembalikan hasilnya dalam konteks. AWS AppSync Kekuatan terletak pada keterkaitannya dengan layanan lain. AWS Karena kami menggunakan DynamoDB, kami memiliki [serangkaian operasi untuk menyederhanakan hal-hal](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) seperti ini. Kami memiliki beberapa contoh boilerplate untuk tipe sumber data lainnya juga.
Kode kita akan terlihat seperti ini:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Pada langkah ini, kami menambahkan dua fungsi:
`request`: Handler permintaan melakukan operasi pengambilan terhadap sumber data. Argumen berisi objek konteks (`ctx`), atau beberapa data yang tersedia untuk semua resolver melakukan operasi tertentu. Misalnya, mungkin berisi data otorisasi, nama bidang yang diselesaikan, dll. Pernyataan pengembalian melakukan [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)operasi (lihat [di sini](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) untuk contoh). Karena kami bekerja dengan DynamoDB, kami diizinkan untuk menggunakan beberapa operasi dari layanan itu. Pemindaian melakukan pengambilan dasar semua item di tabel kami. Hasil operasi ini disimpan dalam objek konteks sebagai `result` wadah sebelum diteruskan ke handler respons. `request`Dijalankan sebelum respons dalam pipa.
`response`: Response handler yang mengembalikan output dari. `request` Argumennya adalah objek konteks yang diperbarui, dan pernyataan pengembaliannya adalah`ctx.prev.result`. Pada titik ini dalam panduan ini, Anda mungkin tidak terbiasa dengan nilai ini. `ctx`mengacu pada objek konteks. `prev`mengacu pada operasi sebelumnya dalam pipa, yang merupakan milik kami`request`. `result`Berisi hasil resolver saat bergerak melalui pipa. Jika Anda menempatkan semuanya bersama-sama, `ctx.prev.result` mengembalikan hasil dari operasi terakhir yang dilakukan, yang merupakan handler permintaan.
1. Pilih **Buat** setelah selesai.
1. Kembali ke layar resolver, di bawah **Fungsi**, pilih drop-down **Tambah fungsi** dan tambahkan fungsi Anda ke daftar fungsi Anda.
1. Pilih **Simpan** untuk memperbarui resolver.
------
#### [ CLI ]
**Untuk menambahkan fungsi Anda**
+ Buat fungsi untuk resolver pipeline Anda menggunakan perintah. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `name`Fungsi di AWS AppSync konsol.
1. Itu`data-source-name`, atau nama sumber data yang akan digunakan fungsi. Itu harus sudah dibuat dan ditautkan ke GraphQL API Anda di layanan. AWS AppSync
1. atau lingkungan dan bahasa dari fungsi tersebut. `runtime` Untuk JavaScript, nama harus`APPSYNC_JS`, dan runtime,`1.0.0`.
1. Penangan`code`, atau permintaan dan respons fungsi Anda. Meskipun Anda dapat mengetiknya secara manual, jauh lebih mudah untuk menambahkannya ke file.txt (atau format serupa) dan kemudian meneruskannya sebagai argumen.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**catatan**
Pastikan Anda merekam `functionId` suatu tempat karena ini akan digunakan untuk melampirkan fungsi ke resolver.
**Untuk membuat resolver Anda**
+ Buat fungsi pipeline `Query` dengan menjalankan `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Jenis objek`type-name`, atau khusus dalam skema Anda (Query, Mutation, Subscription).
1. Operasi`field-name`, atau bidang di dalam jenis objek khusus yang ingin Anda lampirkan resolver.
1. The`kind`, yang menentukan unit atau resolver pipa. Setel ini `PIPELINE` untuk mengaktifkan fungsi pipeline.
1. The`pipeline-config`, atau fungsi (s) untuk melampirkan ke resolver. Pastikan Anda mengetahui `functionId` nilai-nilai fungsi Anda. Urutan daftar penting.
1. Yang`runtime`, yang `APPSYNC_JS` (JavaScript). `runtimeVersion`Saat ini adalah`1.0.0`.
1. Itu`code`, yang berisi penangan langkah sebelum dan sesudah.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Aplikasi dasar akan membutuhkan hal-hal berikut:
1. Arahan impor layanan
1. Kode skema
1. Generator sumber data
1. Kode fungsi
1. Kode penyelesai
Dari bagian [Merancang skema Anda](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) dan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), kami tahu bahwa file tumpukan akan menyertakan arahan impor formulir:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**catatan**
Di bagian sebelumnya, kami hanya menyatakan cara AWS AppSync mengimpor konstruksi. Dalam kode nyata, Anda harus mengimpor lebih banyak layanan hanya untuk menjalankan aplikasi. Dalam contoh kami, jika kami membuat aplikasi CDK yang sangat sederhana, kami setidaknya akan mengimpor AWS AppSync layanan bersama dengan sumber data kami, yang merupakan tabel DynamoDB. Kami juga perlu mengimpor beberapa konstruksi tambahan untuk menerapkan aplikasi:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Untuk meringkas masing-masing:
`import * as cdk from 'aws-cdk-lib';`: Ini memungkinkan Anda untuk menentukan aplikasi CDK dan konstruksi seperti tumpukan. Ini juga berisi beberapa fungsi utilitas yang berguna untuk aplikasi kita seperti memanipulasi metadata. Jika Anda terbiasa dengan arahan impor ini, tetapi bertanya-tanya mengapa pustaka inti cdk tidak digunakan di sini, lihat halaman [Migrasi](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: Ini mengimpor [AWS AppSync layanan](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: Ini mengimpor layanan [DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`: Kita membutuhkan ini untuk mendefinisikan [konstruksi](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html) root.
Jenis impor tergantung pada layanan yang Anda panggil. Kami merekomendasikan untuk melihat dokumentasi CDK sebagai contoh. Skema di bagian atas halaman akan menjadi file terpisah di aplikasi CDK Anda sebagai `.graphql` file. Dalam file stack, kita dapat mengaitkannya dengan GraphQL baru menggunakan formulir:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**catatan**
Dalam lingkup`add_api`, kami menambahkan API GraphQL baru menggunakan kata kunci yang diikuti `new` oleh. `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` Cakupan kami adalah`this`, id CFN adalah`graphQL-example`, dan alat peraga kami adalah `my-first-api` (nama API di konsol) dan `schema.graphql` (jalur absolut ke file skema).
Untuk menambahkan sumber data, pertama-tama Anda harus menambahkan sumber data ke tumpukan. Kemudian, Anda perlu mengaitkannya dengan GraphQL API menggunakan metode khusus sumber. Asosiasi akan terjadi ketika Anda membuat fungsi resolver Anda. Sementara itu, mari kita gunakan contoh dengan membuat tabel DynamoDB menggunakan: `dynamodb.Table`
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**catatan**
Jika kita menggunakan ini dalam contoh kita, kita akan menambahkan tabel DynamoDB baru dengan id CFN `posts-table` dari dan kunci partisi. `id (S)`
Selanjutnya, kita perlu mengimplementasikan resolver kita di file stack. Berikut adalah contoh kueri sederhana yang memindai semua item dalam tabel DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**catatan**
Pertama, kami membuat fungsi yang disebut`add_func`. Urutan pembuatan ini mungkin tampak agak berlawanan dengan intuisi, tetapi Anda harus membuat fungsi di resolver pipeline Anda sebelum Anda membuat resolver itu sendiri. Sebuah fungsi mengikuti formulir:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Ruang lingkup kami adalah`this`, id CFN kami`func-get-posts`, dan alat peraga kami berisi detail fungsi yang sebenarnya. Di dalam alat peraga, kami menyertakan:
Fungsi `name` yang akan hadir di AWS AppSync konsol (`get_posts_func_1`).
GraphQL API yang kita buat sebelumnya (). `add_api`
Sumber data; ini adalah titik di mana kita menghubungkan sumber data ke nilai GraphQL API, lalu melampirkannya ke fungsi. Kami mengambil tabel yang kami buat (`add_ddb_table`) dan melampirkannya ke GraphQL API `add_api` () menggunakan salah `GraphqlApi` satu metode (). [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options) Nilai id (`table-for-posts`) adalah nama sumber data di AWS AppSync konsol. Untuk daftar metode khusus sumber, lihat halaman berikut:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
Kode berisi permintaan fungsi dan penangan respons, yang merupakan pemindaian dan pengembalian sederhana.
Runtime menentukan bahwa kita ingin menggunakan APPSYNC\$1JS runtime versi 1.0.0. Perhatikan bahwa saat ini satu-satunya versi yang tersedia untuk APPSYNC\$1JS.
Selanjutnya, kita perlu melampirkan fungsi ke resolver pipa. Kami membuat resolver kami menggunakan formulir:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Ruang lingkup kami adalah`this`, id CFN kami`pipeline-resolver-get-posts`, dan alat peraga kami berisi detail fungsi yang sebenarnya. Di dalam alat peraga, kami menyertakan:
GraphQL API yang kita buat sebelumnya (). `add_api`
Nama tipe objek khusus; ini adalah operasi query, jadi kita hanya menambahkan nilai`Query`.
Nama bidang (`getPost`) adalah nama bidang dalam skema di bawah `Query` tipe.
Kode berisi penangan sebelum dan sesudah Anda. Contoh kami hanya mengembalikan hasil apa pun yang ada dalam konteks setelah fungsi melakukan operasinya.
Runtime menentukan bahwa kita ingin menggunakan APPSYNC\$1JS runtime versi 1.0.0. Perhatikan bahwa saat ini satu-satunya versi yang tersedia untuk APPSYNC\$1JS.
Konfigurasi pipeline berisi referensi ke fungsi yang kita buat (`add_func`).
------
Untuk meringkas apa yang terjadi dalam contoh ini, Anda melihat AWS AppSync fungsi yang menerapkan permintaan dan penangan respons. Fungsi ini bertanggung jawab untuk berinteraksi dengan sumber data Anda. Handler permintaan mengirim `Scan` operasi ke AWS AppSync, menginstruksikannya tentang operasi apa yang harus dilakukan terhadap sumber data DynamoDB Anda. Response handler mengembalikan daftar item (`ctx.result.items`). Daftar item kemudian dipetakan ke tipe `Post` GraphQL secara otomatis.
## Membuat resolver mutasi dasar
Bagian ini akan menunjukkan cara membuat resolver mutasi dasar.
------
#### [ 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 bawah bagian **Resolvers** dan jenis **Mutasi**, pilih **Lampirkan di sebelah bidang** Anda.
**catatan**
Dalam contoh kita, kita melampirkan resolver untuk`createPost`, yang menambahkan `Post` objek ke tabel kita. Mari kita asumsikan kita menggunakan tabel DynamoDB yang sama dari bagian terakhir. Kunci partisi diatur ke `id` dan kosong.
1. Pada halaman **Attach resolver**, di bawah jenis **Resolver**, pilih. `pipeline resolvers` [Sebagai pengingat, Anda dapat menemukan informasi lebih lanjut tentang resolver di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Untuk **runtime Resolver, pilih `APPSYNC_JS` untuk mengaktifkan runtime**. JavaScript
1. Anda dapat mengaktifkan [caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) untuk API ini. Sebaiknya matikan fitur ini untuk saat ini. Pilih **Buat**.
1. Pilih **Tambah fungsi**, lalu pilih **Buat fungsi baru**. Atau, Anda mungkin melihat tombol **Create function** untuk memilih sebagai gantinya.
1. Pilih sumber data Anda. Ini harus menjadi sumber yang datanya akan Anda manipulasi dengan mutasi.
1. Masukkan a`Function name`.
1. Di bawah **kode Fungsi**, Anda harus mengimplementasikan perilaku fungsi. Ini adalah mutasi, jadi permintaan idealnya akan melakukan beberapa operasi perubahan status pada sumber data yang dipanggil. Hasilnya akan diproses oleh fungsi respons.
**catatan**
`createPost`menambahkan, atau “menempatkan”, yang baru `Post` dalam tabel dengan parameter kami sebagai data. Kita bisa menambahkan sesuatu seperti ini:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Pada langkah ini, kami juga menambahkan `request` dan `response` berfungsi:
`request`: Handler permintaan menerima konteks sebagai argumen. Pernyataan pengembalian request handler melakukan [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)perintah, yang merupakan operasi DynamoDB bawaan ([lihat](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) di sini [atau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) di sini untuk contoh). `PutItem`Perintah menambahkan `Post` objek ke tabel DynamoDB kami dengan mengambil nilai `key` partisi (dihasilkan secara otomatis `util.autoid()` oleh) `attributes` dan dari input argumen konteks (ini adalah nilai yang akan kami berikan dalam permintaan kami). `key`Itu adalah `id` dan `attributes` adalah argumen `title` lapangan `date` dan. Keduanya diformat sebelumnya melalui [https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)helper untuk bekerja dengan tabel DynamoDB.
`response`: Respons menerima konteks yang diperbarui dan mengembalikan hasil penangan permintaan.
1. Pilih **Buat** setelah selesai.
1. Kembali ke layar resolver, di bawah **Fungsi**, pilih drop-down **Tambah fungsi** dan tambahkan fungsi Anda ke daftar fungsi Anda.
1. Pilih **Simpan** untuk memperbarui resolver.
------
#### [ CLI ]
**Untuk menambahkan fungsi Anda**
+ Buat fungsi untuk resolver pipeline Anda menggunakan perintah. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `name`Fungsi di AWS AppSync konsol.
1. Itu`data-source-name`, atau nama sumber data yang akan digunakan fungsi. Itu harus sudah dibuat dan ditautkan ke GraphQL API Anda di layanan. AWS AppSync
1. atau lingkungan dan bahasa dari fungsi tersebut. `runtime` Untuk JavaScript, nama harus`APPSYNC_JS`, dan runtime,`1.0.0`.
1. Penangan`code`, atau permintaan dan respons fungsi Anda. Meskipun Anda dapat mengetiknya secara manual, jauh lebih mudah untuk menambahkannya ke file.txt (atau format serupa) kemudian meneruskannya sebagai argumen.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**catatan**
Pastikan Anda merekam `functionId` suatu tempat karena ini akan digunakan untuk melampirkan fungsi ke resolver.
**Untuk membuat resolver Anda**
+ Buat fungsi pipeline `Mutation` dengan menjalankan `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Jenis objek`type-name`, atau khusus dalam skema Anda (Query, Mutation, Subscription).
1. Operasi`field-name`, atau bidang di dalam jenis objek khusus yang ingin Anda lampirkan resolver.
1. The`kind`, yang menentukan unit atau resolver pipa. Setel ini `PIPELINE` untuk mengaktifkan fungsi pipeline.
1. The`pipeline-config`, atau fungsi (s) untuk melampirkan ke resolver. Pastikan Anda mengetahui `functionId` nilai-nilai fungsi Anda. Urutan daftar penting.
1. Yang`runtime`, yang `APPSYNC_JS` (JavaScript). `runtimeVersion`Saat ini adalah`1.0.0`.
1. Itu`code`, yang berisi langkah sebelum dan sesudah.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
+ Untuk membuat mutasi, dengan asumsi Anda berada di proyek yang sama, Anda dapat menambahkannya ke file tumpukan seperti kueri. Berikut adalah fungsi dan resolver yang dimodifikasi untuk mutasi yang menambahkan yang baru `Post` ke tabel:
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**catatan**
Karena mutasi dan kueri ini terstruktur dengan cara yang sama, kami hanya akan menjelaskan perubahan yang kami buat untuk membuat mutasi.
Dalam fungsinya, kami mengubah id CFN menjadi `func-add-post` dan nama `add_posts_func_1` untuk mencerminkan fakta bahwa kami menambahkan `Posts` ke tabel. Di sumber data, kami membuat asosiasi baru ke table (`add_ddb_table`) kami di AWS AppSync konsol `table-for-posts-2` karena `addDynamoDbDataSource` metode memerlukannya. Perlu diingat, asosiasi baru ini masih menggunakan tabel yang sama yang kita buat sebelumnya, tetapi kita sekarang memiliki dua koneksi ke sana di AWS AppSync konsol: satu untuk kueri sebagai `table-for-posts` dan satu untuk mutasi sebagai`table-for-posts-2`. Kode diubah untuk menambahkan a `Post` dengan menghasilkan `id` nilainya secara otomatis dan menerima masukan klien untuk bidang lainnya.
Dalam resolver, kita mengubah nilai id `pipeline-resolver-create-posts` untuk mencerminkan fakta bahwa kita menambahkan `Posts` ke tabel. Untuk mencerminkan mutasi dalam skema, nama tipe diubah menjadi`Mutation`, dan nama,. `createPost` Konfigurasi pipeline disetel ke fungsi mutasi baru kami. `add_func_2`
------
Untuk meringkas apa yang terjadi dalam contoh ini, AWS AppSync secara otomatis mengonversi argumen yang ditentukan di `createPost` bidang dari skema GraphQL Anda menjadi operasi DynamoDB. Contoh menyimpan catatan di DynamoDB menggunakan kunci`id`, yang secara otomatis dibuat menggunakan helper kami. `util.autoId()` Semua bidang lain yang Anda berikan ke argumen konteks (`ctx.args.input`) dari permintaan yang dibuat di AWS AppSync konsol atau sebaliknya akan disimpan sebagai atribut tabel. Baik kunci dan atribut secara otomatis dipetakan ke format DynamoDB yang kompatibel menggunakan helper. `util.dynamodb.toMapValues(values)`
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 memanggilnya. Secara opsional, Anda dapat melihat permintaan lengkap ke sumber data secara interaktif saat menjalankan kueri. Untuk informasi selengkapnya, lihat [Menguji dan debug resolvers (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) serta [Monitoring](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring) dan logging.
## Resolver tingkat lanjut
Jika Anda mengikuti bagian pagination opsional dalam [Merancang skema Anda](designing-your-schema.md#aws-appsync-designing-your-schema), Anda masih perlu menambahkan resolver Anda ke permintaan Anda untuk menggunakan pagination. Contoh kami menggunakan pagination query yang dipanggil `getPosts` untuk mengembalikan hanya sebagian dari hal-hal yang diminta pada suatu waktu. Kode resolver kami di bidang itu mungkin terlihat seperti ini:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Dalam permintaan, kami lulus dalam konteks permintaan. Kami `limit` adalah*20*, artinya kami mengembalikan hingga 20 `Posts` di kueri pertama. `nextToken`Kursor kami diperbaiki ke `Post` entri pertama di sumber data. Ini diteruskan ke argumen. Permintaan kemudian melakukan pemindaian dari yang pertama `Post` hingga nomor batas pemindaian. Sumber data menyimpan hasil dalam konteks, yang diteruskan ke respons. Respons mengembalikan `Posts` itu diambil, kemudian menetapkan `nextToken` diatur ke `Post` entri tepat setelah batas. Permintaan berikutnya dikirim untuk melakukan hal yang sama persis tetapi dimulai dari offset tepat setelah kueri pertama. Perlu diingat bahwa permintaan semacam ini dilakukan secara berurutan dan tidak secara paralel.
# Menguji dan men-debug resolver di () AWS AppSync JavaScript
AWS AppSync mengeksekusi resolver pada bidang GraphQL terhadap sumber data. Saat bekerja dengan resolver pipeline, fungsi berinteraksi dengan sumber data Anda. Seperti yang dijelaskan dalam [ikhtisar JavaScript resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html), fungsi berkomunikasi dengan sumber data dengan menggunakan penangan permintaan dan respons yang ditulis JavaScript dan dijalankan pada runtime. `APPSYNC_JS` Ini memungkinkan Anda untuk memberikan logika dan kondisi khusus sebelum dan sesudah berkomunikasi dengan sumber data.
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 seluruh permintaan dari Amazon. CloudWatch Ini termasuk hasil dari sumber data.
## Pengujian dengan data tiruan
Ketika resolver GraphQL dipanggil, itu berisi objek yang memiliki informasi `context` yang relevan tentang permintaan. Ini termasuk argumen dari klien, informasi identitas, dan data dari bidang GraphQL induk. Ini juga menyimpan hasil dari sumber data, yang dapat digunakan dalam penangan respons. Untuk informasi selengkapnya tentang struktur ini dan utilitas pembantu yang tersedia untuk digunakan saat pemrograman, lihat referensi [objek konteks Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
Saat menulis atau mengedit fungsi resolver, Anda dapat meneruskan objek *konteks *tiruan* atau pengujian* ke editor konsol. Ini memungkinkan Anda untuk melihat bagaimana permintaan dan penangan 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 **Functions**.
1. Pilih fungsi yang ada.
1. Di bagian atas halaman **fungsi Perbarui**, **pilih Pilih konteks pengujian**, lalu pilih **Buat konteks baru**.
1. Pilih objek konteks sampel atau isi JSON secara manual di jendela **Konfigurasi konteks pengujian** di bawah ini.
1. Masukkan **nama konteks Teks**.
1. Pilih tombol **Simpan**.
1. **Untuk mengevaluasi resolver Anda menggunakan objek konteks tiruan ini, 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. Cuplikan berikut menunjukkan seperti apa skema itu:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Anda dapat menulis AWS AppSync fungsi dan menambahkannya ke `addDog` resolver Anda untuk menangani mutasi. Untuk menguji AWS AppSync fungsi Anda, 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 AWS AppSync fungsi Anda menggunakan kode berikut:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
Handler permintaan dan respons 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 permintaan dan penangan respons dengan's AWS AppSync APIs
Anda dapat menggunakan perintah `EvaluateCode` API untuk menguji kode Anda dari jarak jauh dengan data tiruan. Untuk memulai dengan perintah, pastikan Anda telah menambahkan `appsync:evaluateMappingCode` izin ke kebijakan Anda. Contoh:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"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 permintaan AWS AppSync fungsinya dan penangan respons dari bagian sebelumnya. Menggunakan CLI di stasiun lokal Anda, simpan kode ke file bernama`code.js`, lalu simpan `context` objek ke file bernama. `context.json` Dari shell Anda, jalankan perintah berikut:
```
$ aws appsync evaluate-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
Responsnya `evaluationResult` berisi muatan yang dikembalikan oleh handler Anda. Ini juga berisi `logs` objek, yang memegang daftar log yang dihasilkan oleh handler Anda selama evaluasi. Hal ini memudahkan untuk men-debug eksekusi kode Anda dan melihat informasi tentang evaluasi Anda untuk membantu memecahkan masalah. Contoh:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
`evaluationResult`Dapat diurai sebagai JSON, yang memberikan:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Dengan menggunakan SDK, Anda dapat dengan mudah menggabungkan pengujian dari rangkaian pengujian favorit untuk memvalidasi perilaku penangan 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' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).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 totalTime: 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 pipeline di () AWS AppSync JavaScript
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.
Untuk informasi selengkapnya tentang arsitektur resolver JavaScript pipeline, lihat ikhtisar [JavaScriptresolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js).
## 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. Atur resolver ke `pipeline resolver` dan `APPSYNC_JS` runtime, lalu buat resolver.
Pipeline resolver kami mendaftarkan pengguna dengan terlebih dahulu memvalidasi input alamat email dan kemudian menyimpan pengguna dalam sistem. **Kami akan merangkum validasi email di dalam fungsi **ValidateEmail dan penyimpanan pengguna di dalam fungsi SaveUser**.** **Fungsi **ValidateEmail** dijalankan terlebih dahulu, dan jika email valid, maka fungsi SaveUser dijalankan.**
Alur eksekusi adalah sebagai berikut:
1. Mutation.signup penangan permintaan resolver
1. fungsi ValidateEmail
1. Fungsi SaveUser
1. Penangan 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.
Perbarui kode resolver Anda dengan mengganti fungsi permintaan dan respons Anda:
```
export function request(ctx) {
ctx.stash.email = ctx.args.input.email
return {};
}
export function response(ctx) {
return ctx.prev.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.
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:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { email } = ctx.stash;
const valid = util.matches(
'^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
email
);
if (!valid) {
util.error(`"${email}" is not a valid email.`);
}
return { payload: { email } };
}
export function response(ctx) {
return ctx.result;
}
```
Tinjau input Anda, lalu pilih **Buat**. Kami baru saja membuat fungsi **ValidateEmail** kami. ****Ulangi langkah-langkah ini untuk membuat fungsi SaveUser dengan kode berikut (Demi kesederhanaan, kami menggunakan sumber data NONE dan berpura-pura pengguna telah disimpan dalam sistem setelah fungsi dijalankan.**** ):
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return ctx.prev.result;
}
export function response(ctx) {
ctx.result.id = util.autoId();
return 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 tidak terjadi, atau Anda membuat fungsi melalui halaman **Fungsi**, Anda dapat mengklik **Tambah fungsi** kembali pada halaman `signUp` 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
username
}
}
```
Ini harus mengembalikan sesuatu seperti:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"username": "nadia"
}
}
}
```
Kami telah berhasil mendaftarkan pengguna kami dan memvalidasi email input menggunakan resolver pipeline.
# 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
# Menggunakan AWS AppSync API dengan AWS CDK
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Kami juga merekomendasikan untuk memastikan bahwa instalasi [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dan [NPM](https://docs.npmjs.com/) Anda bekerja pada sistem Anda.
Pada bagian ini, kita akan membuat aplikasi CDK sederhana yang dapat menambahkan dan mengambil item dari tabel DynamoDB. Ini dimaksudkan untuk menjadi contoh quickstart menggunakan beberapa kode dari bagian [Merancang skema Anda](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html), [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), dan [Mengkonfigurasi resolvers](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html) (). JavaScript
## Menyiapkan proyek CDK
**Awas**
Langkah-langkah ini mungkin tidak sepenuhnya akurat tergantung pada lingkungan Anda. Kami berasumsi sistem Anda memiliki utilitas yang diperlukan yang diinstal, cara untuk berinteraksi dengan AWS layanan, dan konfigurasi yang tepat di tempat.
Langkah pertama adalah menginstal AWS CDK. Di CLI Anda, Anda dapat memasukkan perintah berikut:
```
npm install -g aws-cdk
```
Selanjutnya, Anda perlu membuat direktori proyek, lalu arahkan ke sana. Contoh set perintah untuk membuat dan menavigasi ke direktori adalah:
```
mkdir example-cdk-app
cd example-cdk-app
```
Selanjutnya, Anda perlu membuat aplikasi. Layanan kami terutama menggunakan TypeScript. Di direktori proyek Anda, masukkan perintah berikut:
```
cdk init app --language typescript
```
Ketika Anda melakukan ini, aplikasi CDK bersama dengan file inisialisasi akan diinstal:
![\[Terminal output showing Git repository initialization and npm install completion.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-init-app-example.png)
Struktur proyek Anda mungkin terlihat seperti ini:
![\[Project directory structure showing folders and files for an example CDK app.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-init-directories.png)
Anda akan melihat kami memiliki beberapa direktori penting:
+ `bin`: File bin awal akan membuat aplikasi. Kami tidak akan menyentuh ini dalam panduan ini.
+ `lib`: Direktori lib berisi file tumpukan Anda. Anda dapat menganggap file tumpukan sebagai unit eksekusi individual. Konstruksi akan berada di dalam file tumpukan kami. Pada dasarnya, ini adalah sumber daya untuk layanan yang akan diputar CloudFormation saat aplikasi diterapkan. Di sinilah sebagian besar pengkodean kami akan terjadi.
+ `node_modules`: Direktori ini dibuat oleh NPM dan berisi semua dependensi paket yang Anda instal menggunakan perintah. `npm`
File tumpukan awal kami mungkin berisi sesuatu seperti ini:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// import * as sqs from 'aws-cdk-lib/aws-sqs';
export class ExampleCdkAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// The code that defines your stack goes here
// example resource
// const queue = new sqs.Queue(this, 'ExampleCdkAppQueue', {
// visibilityTimeout: cdk.Duration.seconds(300)
// });
}
}
```
Ini adalah kode boilerplate untuk membuat tumpukan di aplikasi kita. Sebagian besar kode kita dalam contoh ini akan masuk ke dalam lingkup kelas ini.
Untuk memverifikasi bahwa file stack Anda ada di aplikasi, di direktori aplikasi Anda, jalankan perintah berikut di terminal:
```
cdk ls
```
Daftar tumpukan Anda akan muncul. Jika tidak, maka Anda mungkin perlu menjalankan langkah-langkah lagi atau memeriksa dokumentasi resmi untuk bantuan.
Jika Anda ingin membuat perubahan kode Anda sebelum menerapkan, Anda selalu dapat menjalankan perintah berikut di terminal:
```
npm run build
```
Dan, untuk melihat perubahan sebelum menerapkan:
```
cdk diff
```
Sebelum kita menambahkan kode kita ke file stack, kita akan melakukan bootstrap. Bootstrapping memungkinkan kami menyediakan sumber daya untuk CDK sebelum aplikasi diterapkan. Informasi lebih lanjut tentang proses ini dapat ditemukan [di sini](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html). Untuk membuat bootstrap, perintahnya adalah:
```
cdk bootstrap aws://ACCOUNT-NUMBER/REGION
```
**Tip**
Langkah ini memerlukan beberapa izin IAM di akun Anda. Bootstrap Anda akan ditolak jika Anda tidak memilikinya. Jika ini terjadi, Anda mungkin harus menghapus sumber daya yang tidak lengkap yang disebabkan oleh bootstrap seperti bucket S3 yang dihasilkannya.
Bootstrap akan memutar beberapa sumber daya. Pesan terakhir akan terlihat seperti ini:
![\[Terminal output showing successful bootstrapping of an AWS environment.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-init-bootstrap-final.png)
Ini dilakukan sekali per akun per Wilayah, jadi Anda tidak perlu sering melakukannya. Sumber daya utama bootstrap adalah CloudFormation tumpukan dan bucket Amazon S3.
Bucket Amazon S3 digunakan untuk menyimpan file dan peran IAM yang memberikan izin yang diperlukan untuk melakukan penerapan. Sumber daya yang diperlukan didefinisikan dalam CloudFormation tumpukan, yang disebut tumpukan bootstrap, yang biasanya diberi nama`CDKToolkit`. Seperti CloudFormation tumpukan apa pun, itu muncul di CloudFormation konsol setelah digunakan:
![\[CDKToolkit stack with CREATE_COMPLETE status in CloudFormation console.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-init-bootstrap-cfn-console.png)
Hal yang sama dapat dikatakan untuk ember:
![\[S3 bucket details showing name, region, access settings, and creation date.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-init-bootstrap-bucket-console.png)
Untuk mengimpor layanan yang kita butuhkan di file stack kita, kita dapat menggunakan perintah berikut:
```
npm install aws-cdk-lib # V2 command
```
**Tip**
Jika Anda mengalami masalah dengan V2, Anda dapat menginstal pustaka individual menggunakan perintah V1:
```
npm install @aws-cdk/aws-appsync @aws-cdk/aws-dynamodb
```
Kami tidak merekomendasikan ini karena V1 telah usang.
## Menerapkan proyek CDK - Skema
Kita sekarang dapat mulai menerapkan kode kita. Pertama, kita harus membuat skema kita. Anda cukup membuat `.graphql` file di aplikasi Anda:
```
mkdir schema
touch schema.graphql
```
Dalam contoh kami, kami menyertakan direktori tingkat atas `schema` yang disebut berisi: `schema.graphql`
![\[File structure showing a schema folder containing schema.graphql file.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-schema-directory.png)
Di dalam skema kita, mari kita sertakan contoh sederhana:
```
input CreatePostInput {
title: String
content: String
}
type Post {
id: ID!
title: String
content: String
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
Kembali ke file tumpukan kami, kami perlu memastikan arahan impor berikut ditentukan:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Di dalam kelas, kita akan menambahkan kode untuk membuat GraphQL API kita dan menghubungkannya ke file kita: `schema.graphql`
```
export class ExampleCdkAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// makes a GraphQL API
const api = new appsync.GraphqlApi(this, 'post-apis', {
name: 'api-to-process-posts',
schema: appsync.SchemaFile.fromAsset('schema/schema.graphql'),
});
}
}
```
Kami juga akan menambahkan beberapa kode untuk mencetak URL GraphQL, kunci API, dan Wilayah:
```
export class ExampleCdkAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Makes a GraphQL API construct
const api = new appsync.GraphqlApi(this, 'post-apis', {
name: 'api-to-process-posts',
schema: appsync.SchemaFile.fromAsset('schema/schema.graphql'),
});
// Prints out URL
new cdk.CfnOutput(this, "GraphQLAPIURL", {
value: api.graphqlUrl
});
// Prints out the AppSync GraphQL API key to the terminal
new cdk.CfnOutput(this, "GraphQLAPIKey", {
value: api.apiKey || ''
});
// Prints out the stack region to the terminal
new cdk.CfnOutput(this, "Stack Region", {
value: this.region
});
}
}
```
Pada titik ini, kita akan menggunakan deploy aplikasi kita lagi:
```
cdk deploy
```
Ini adalah hasilnya:
![\[Deployment output showing ExampleCdkAppStack details, including GraphQL API URL and stack region.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-schema.png)
Tampaknya contoh kami berhasil, tetapi mari kita periksa AWS AppSync konsol hanya untuk mengonfirmasi:
![\[GraphQL interface showing successful API request with response data displayed.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-schema-result-1.png)
Tampaknya API kami telah dibuat. Sekarang, kita akan memeriksa skema yang dilampirkan ke API:
![\[GraphQL schema defining CreatePostInput, Post type, Mutation, and Query operations.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-schema-result-2.png)
Ini tampaknya cocok dengan kode skema kami, jadi berhasil. Cara lain untuk mengonfirmasi ini dari sudut pandang metadata adalah dengan melihat tumpukan: CloudFormation
![\[CloudFormation stack showing ExampleCdkAppStack update complete and CDKToolkit creation complete.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-schema-result-3.png)
Saat kami menerapkan aplikasi CDK kami, aplikasi ini akan CloudFormation memutar sumber daya seperti bootstrap. Setiap tumpukan dalam aplikasi kami memetakan 1:1 dengan CloudFormation tumpukan. Jika Anda kembali ke kode tumpukan, nama tumpukan diambil dari nama `ExampleCdkAppStack` kelas. Anda dapat melihat sumber daya yang dibuatnya, yang juga cocok dengan konvensi penamaan kami di konstruksi GraphQL API kami:
![\[Expanded view of post-apis resource showing Schema, DefaultApiKey, and CDKMetadata.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-schema-result-4.png)
## Menerapkan proyek CDK - Sumber data
Selanjutnya, kita perlu menambahkan sumber data kita. Contoh kita akan menggunakan tabel DynamoDB. Di dalam kelas stack, kita akan menambahkan beberapa kode untuk membuat tabel baru:
```
export class ExampleCdkAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Makes a GraphQL API construct
const api = new appsync.GraphqlApi(this, 'post-apis', {
name: 'api-to-process-posts',
schema: appsync.SchemaFile.fromAsset('schema/schema.graphql'),
});
//creates a DDB table
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
// Prints out URL
new cdk.CfnOutput(this, "GraphQLAPIURL", {
value: api.graphqlUrl
});
// Prints out the AppSync GraphQL API key to the terminal
new cdk.CfnOutput(this, "GraphQLAPIKey", {
value: api.apiKey || ''
});
// Prints out the stack region to the terminal
new cdk.CfnOutput(this, "Stack Region", {
value: this.region
});
}
}
```
Pada titik ini, mari kita gunakan lagi:
```
cdk deploy
```
Kita harus memeriksa konsol DynamoDB untuk tabel baru kita:
![\[DynamoDB console showing ExampleCdkAppStack-poststable as Active with Provisioned capacity.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-ddb-result-1.png)
Nama tumpukan kami benar, dan nama tabel cocok dengan kode kami. Jika kita memeriksa CloudFormation tumpukan kita lagi, kita sekarang akan melihat tabel baru:
![\[Expanded view of a logical ID in CloudFormation showing post-apis, posts-table, and CDKMetadata.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-ddb-result-2.png)
## Menerapkan proyek CDK - Resolver
Contoh ini akan menggunakan dua resolver: satu untuk menanyakan tabel dan satu untuk menambahkannya. Karena kita menggunakan resolver pipeline, kita perlu mendeklarasikan dua resolver pipeline dengan satu fungsi di masing-masing. Dalam query, kita akan menambahkan kode berikut:
```
export class ExampleCdkAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Makes a GraphQL API construct
const api = new appsync.GraphqlApi(this, 'post-apis', {
name: 'api-to-process-posts',
schema: appsync.SchemaFile.fromAsset('schema/schema.graphql'),
});
//creates a DDB table
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
// Creates a function for query
const add_func = new appsync.AppsyncFunction(this, 'func-get-post', {
name: 'get_posts_func_1',
api,
dataSource: api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
// Creates a function for mutation
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
api,
dataSource: api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
// Adds a pipeline resolver with the get function
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
// Adds a pipeline resolver with the create function
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
// Prints out URL
new cdk.CfnOutput(this, "GraphQLAPIURL", {
value: api.graphqlUrl
});
// Prints out the AppSync GraphQL API key to the terminal
new cdk.CfnOutput(this, "GraphQLAPIKey", {
value: api.apiKey || ''
});
// Prints out the stack region to the terminal
new cdk.CfnOutput(this, "Stack Region", {
value: this.region
});
}
}
```
Dalam cuplikan ini, kami menambahkan resolver pipeline yang disebut `pipeline-resolver-create-posts` dengan fungsi yang disebut melekat padanya. `func-add-post` Ini adalah kode yang akan ditambahkan `Posts` ke tabel. Pipeline resolver lainnya dipanggil `pipeline-resolver-get-posts` dengan fungsi yang disebut `func-get-post` yang mengambil `Posts` ditambahkan ke tabel.
Kami akan menerapkan ini untuk menambahkannya ke AWS AppSync layanan:
```
cdk deploy
```
Mari kita periksa AWS AppSync konsol untuk melihat apakah mereka dilampirkan ke GraphQL API kami:
![\[GraphQL API schema showing mutation and query fields with Pipeline resolvers.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-1.png)
Tampaknya benar. Dalam kode, kedua resolver ini dilampirkan ke GraphQL API yang kami buat (dilambangkan dengan nilai `api` props yang ada di resolver dan fungsi). Di GraphQL API, bidang yang kami lampirkan pada resolver kami juga ditentukan dalam alat peraga (ditentukan oleh `typename` dan props di setiap resolver). `fieldname`
Mari kita lihat apakah konten resolver sudah benar dimulai dengan: `pipeline-resolver-get-posts`
![\[Code snippet showing request and response functions in a resolver, with an arrow pointing to them.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-2.png)
Penangan sebelum dan sesudah cocok dengan nilai `code` alat peraga kami. Kita juga dapat melihat bahwa fungsi dipanggil`add_posts_func_1`, yang cocok dengan nama fungsi yang kita lampirkan di resolver.
Mari kita lihat isi kode dari fungsi itu:
![\[Function code showing request and response methods for a PutItem operation.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-3.png)
Ini cocok dengan `code` alat peraga `add_posts_func_1` fungsi. Kueri kami berhasil diunggah, jadi mari kita periksa kueri:
![\[Resolver code with request and response functions, and a get_posts_func_1 function listed below.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-4.png)
Ini juga cocok dengan kode. Jika kita melihat`get_posts_func_1`:
![\[Code snippet showing two exported functions: request returning 'Scan' operation and response returning items.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-5.png)
Semuanya tampak ada di tempatnya. Untuk mengonfirmasi ini dari perspektif metadata, kita dapat memeriksa tumpukan kita lagi: CloudFormation
![\[List of logical IDs for AWS resources including API, table, functions, and pipelines.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-deploy-resolver-result-6.png)
Sekarang, kita perlu menguji kode ini dengan melakukan beberapa permintaan.
## Menerapkan proyek CDK - Permintaan
Untuk menguji aplikasi kami di AWS AppSync konsol, kami membuat satu kueri dan satu mutasi:
![\[GraphQL code snippet showing a query to get post details and a mutation to create a post.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-request-1.png)
`MyMutation`berisi `createPost` operasi dengan argumen `1970-01-01T12:30:00.000Z` dan`first post`. Ia mengembalikan `date` dan `title` yang kami lewatkan serta `id` nilai yang dihasilkan secara otomatis. Menjalankan mutasi menghasilkan hasil:
```
{
"data": {
"createPost": {
"date": "1970-01-01T12:30:00.000Z",
"id": "4dc1c2dd-0aa3-4055-9eca-7c140062ada2",
"title": "first post"
}
}
}
```
Jika kita memeriksa tabel DynamoDB dengan cepat, kita dapat melihat entri kita di tabel ketika kita memindainya:
![\[DynamoDB table entry showing id, date, and title fields for a single item.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cdk-code-request-2.png)
Kembali ke AWS AppSync konsol, jika kita menjalankan kueri untuk mengambil ini`Post`, kita mendapatkan hasil sebagai berikut:
```
{
"data": {
"getPost": [
{
"id": "9f62c4dd-49d5-48d5-b835-143284c72fe0",
"date": "1970-01-01T12:30:00.000Z",
"title": "first post"
}
]
}
}
```