Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan resolver lokal di AWS AppSync
<a name="tutorial-local-resolvers-js"></a>

AWS AppSync memungkinkan Anda menggunakan sumber data yang didukung (AWS Lambda, Amazon DynamoDB, atau OpenSearch Amazon Service) untuk melakukan berbagai operasi. Namun, dalam skenario tertentu, panggilan ke sumber data yang didukung mungkin tidak diperlukan.

Di sinilah resolver lokal berguna. Alih-alih memanggil sumber data jarak jauh, resolver lokal hanya akan **meneruskan** hasil penangan permintaan ke penangan respons. Resolusi lapangan tidak akan pergi AWS AppSync.

Resolver lokal berguna dalam banyak situasi. Kasus penggunaan yang paling populer adalah mempublikasikan notifikasi tanpa memicu panggilan sumber data. Untuk mendemonstrasikan kasus penggunaan ini, mari buat aplikasi pub/sub tempat pengguna dapat mempublikasikan dan berlangganan pesan. Contoh ini memanfaatkan *Langganan*, jadi jika Anda tidak terbiasa dengan *Langganan*, Anda dapat mengikuti tutorial Data [Waktu Nyata](aws-appsync-real-time-data.md).

## Membuat aplikasi pub/sub
<a name="create-the-pub-sub-application-js"></a>

Pertama, buat API GraphQL kosong dengan memilih opsi **Desain dari** awal dan mengonfigurasi detail opsional saat membuat GraphQL API Anda.

Dalam aplikasi pub/sub kami, klien dapat berlangganan dan mempublikasikan pesan. Setiap pesan yang diterbitkan mencakup nama dan data. Tambahkan ini ke skema:

```
type Channel {
	name: String!
	data: AWSJSON!
}

type Mutation {
	publish(name: String!, data: AWSJSON!): Channel
}

type Query {
	getChannel: Channel
}

type Subscription {
	subscribe(name: String!): Channel
		@aws_subscribe(mutations: ["publish"])
}
```

Selanjutnya, mari kita lampirkan resolver ke bidang. `Mutation.publish` **Di panel **Resolvers** di sebelah panel **Schema**, temukan `Mutation` jenisnya, lalu `publish(...): Channel` bidangnya, lalu klik Lampirkan.**

Buat sumber data *None* dan beri nama *PageDataSource*. Lampirkan ke resolver Anda.

Tambahkan implementasi resolver Anda menggunakan cuplikan berikut:

```
export function request(ctx) {
  return { payload: ctx.args };
}

export function response(ctx) {
  return ctx.result;
}
```

Pastikan Anda membuat resolver dan menyimpan perubahan yang Anda buat.

## Kirim dan berlangganan pesan
<a name="send-and-subscribe-to-messages-js"></a>

Agar klien dapat menerima pesan, mereka harus terlebih dahulu berlangganan kotak masuk.

Di panel **Kueri**, jalankan langganan: `SubscribeToData`

```
subscription SubscribeToData {
    subscribe(name:"channel") {
        name
        data
    }
}
```

 Pelanggan akan menerima pesan setiap kali `publish` mutasi dipanggil tetapi hanya ketika pesan dikirim ke langganan. `channel` Mari kita coba ini di panel **Queries**. Saat langganan Anda masih berjalan di konsol, buka konsol lain dan jalankan permintaan berikut di panel **Kueri**:

**catatan**  
Kami menggunakan string JSON yang valid dalam contoh ini.

```
mutation PublishData {
    publish(data: "{\"msg\": \"hello world!\"}", name: "channel") {
        data
        name
    }
}
```

Hasilnya akan terlihat seperti ini:

```
{
  "data": {
    "publish": {
      "data": "{\"msg\":\"hello world!\"}",
      "name": "channel"
    }
  }
}
```

Kami baru saja mendemonstrasikan penggunaan resolver lokal, dengan menerbitkan pesan dan menerimanya tanpa meninggalkan layanan. AWS AppSync