Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan AWS Lambda resolver di AWS AppSync
**catatan**
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)
Anda dapat menggunakan AWS Lambda dengan AWS AppSync untuk menyelesaikan bidang GraphQL apa pun. Misalnya, kueri GraphQL mungkin mengirim panggilan ke instance Amazon Relational Database Service (Amazon RDS), dan mutasi GraphQL mungkin menulis ke aliran Amazon Kinesis. Di bagian ini, kami akan menunjukkan cara menulis fungsi Lambda yang melakukan logika bisnis berdasarkan pemanggilan operasi lapangan GraphQL.
## Buat fungsi Lambda
Contoh berikut menunjukkan fungsi Lambda yang ditulis dalam `Node.js` yang melakukan operasi yang berbeda pada posting blog sebagai bagian dari aplikasi posting blog.
```
exports.handler = (event, context, callback) => {
console.log("Received event {}", JSON.stringify(event, 3));
var posts = {
"1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
"2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
"3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
"4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
"5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };
var relatedPosts = {
"1": [posts['4']],
"2": [posts['3'], posts['5']],
"3": [posts['2'], posts['1']],
"4": [posts['2'], posts['1']],
"5": []
};
console.log("Got an Invoke Request.");
switch(event.field) {
case "getPost":
var id = event.arguments.id;
callback(null, posts[id]);
break;
case "allPosts":
var values = [];
for(var d in posts){
values.push(posts[d]);
}
callback(null, values);
break;
case "addPost":
// return the arguments back
callback(null, event.arguments);
break;
case "addPostErrorWithData":
var id = event.arguments.id;
var result = posts[id];
// attached additional error information to the post
result.errorMessage = 'Error with the mutation, data has changed';
result.errorType = 'MUTATION_ERROR';
callback(null, result);
break;
case "relatedPosts":
var id = event.source.id;
callback(null, relatedPosts[id]);
break;
default:
callback("Unknown field, unable to resolve" + event.field, null);
break;
}
};
```
Fungsi Lambda ini mengambil posting dengan ID, menambahkan posting, mengambil daftar posting, dan mengambil posting terkait untuk posting tertentu.
**Catatan:** Fungsi Lambda menggunakan `switch` pernyataan `event.field` untuk menentukan bidang mana yang sedang diselesaikan.
Buat fungsi Lambda ini menggunakan Konsol AWS Manajemen atau tumpukan. AWS CloudFormation Untuk membuat fungsi dari CloudFormation tumpukan, Anda dapat menggunakan perintah AWS Command Line Interface (AWS CLI) berikut:
```
aws cloudformation create-stack --stack-name AppSyncLambdaExample \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml \
--capabilities CAPABILITY_NAMED_IAM
```
Anda juga dapat meluncurkan CloudFormation tumpukan di AWS Wilayah AS Barat (Oregon) di AWS akun Anda dari sini:
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml)
## Konfigurasikan sumber data untuk Lambda
**Setelah Anda membuat fungsi Lambda, navigasikan ke GraphQL API Anda di AWS AppSync konsol, lalu pilih tab Sumber Data.**
Pilih **Buat sumber data**, masukkan **nama sumber data** yang ramah (misalnya,**Lambda**), dan kemudian untuk **tipe sumber data**, pilih **AWS Lambda fungsi**. Untuk **Region**, pilih Region yang sama dengan fungsi Anda. (Jika Anda membuat fungsi dari CloudFormation tumpukan yang disediakan, fungsinya mungkin ada di **US-WEST-2**.) Untuk **Fungsi ARN**, pilih Amazon Resource Name (ARN) dari fungsi Lambda Anda.
Setelah memilih fungsi Lambda, Anda dapat membuat peran baru AWS Identity and Access Management (IAM) (yang AWS AppSync menetapkan izin yang sesuai) atau memilih peran yang ada yang memiliki kebijakan sebaris berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:LAMBDA_FUNCTION"
}
]
}
```
------
Anda juga harus mengatur hubungan kepercayaan dengan AWS AppSync peran IAM sebagai berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "appsync.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Buat skema GraphQL
Sekarang sumber data terhubung ke fungsi Lambda Anda, buat skema GraphQL.
Dari editor skema di AWS AppSync konsol, pastikan skema Anda cocok dengan skema berikut:
```
schema {
query: Query
mutation: Mutation
}
type Query {
getPost(id:ID!): Post
allPosts: [Post]
}
type Mutation {
addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!
}
type Post {
id: ID!
author: String!
title: String
content: String
url: String
ups: Int
downs: Int
relatedPosts: [Post]
}
```
## Konfigurasikan resolver
Setelah mendaftarkan sumber data Lambda dan skema GraphQL yang valid, Anda dapat menghubungkan bidang GraphQL ke sumber data Lambda menggunakan resolver.
Untuk membuat resolver, Anda memerlukan template pemetaan. Untuk mempelajari lebih lanjut tentang templat pemetaan, lihat[Resolver Mapping Template Overview](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
Untuk informasi selengkapnya tentang templat pemetaan Lambda, lihat. [Resolver mapping template reference for Lambda](resolver-mapping-template-reference-lambda.md#aws-appsync-resolver-mapping-template-reference-lambda)
Pada langkah ini, Anda melampirkan resolver ke fungsi Lambda untuk bidang berikut:`getPost(id:ID!): Post`,,, `allPosts: [Post]` dan. `addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!` `Post.relatedPosts: [Post]`
Dari editor skema di AWS AppSync konsol, di sisi kanan, pilih **Lampirkan Resolver** untuk. `getPost(id:ID!): Post`
Kemudian, di **menu Action**, pilih **Update runtime**, lalu pilih **Unit Resolver (hanya VTL**).
Setelah itu, pilih sumber data Lambda Anda. Di bagian **template pemetaan permintaan**, pilih **Invoke And Forward Arguments**.
Ubah `payload` objek untuk menambahkan nama bidang. Template Anda akan terlihat seperti berikut:
```
{
"version": "2017-02-28",
"operation": "Invoke",
"payload": {
"field": "getPost",
"arguments": $utils.toJson($context.arguments)
}
}
```
Di bagian **template pemetaan respons**, pilih **Kembalikan Hasil Lambda**.
Dalam hal ini, gunakan template dasar apa adanya. Seharusnya terlihat seperti berikut:
```
$utils.toJson($context.result)
```
Pilih **Simpan**. Anda telah berhasil melampirkan resolver pertama Anda. Ulangi operasi ini untuk bidang yang tersisa sebagai berikut:
Untuk templat pemetaan `addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!` permintaan:
```
{
"version": "2017-02-28",
"operation": "Invoke",
"payload": {
"field": "addPost",
"arguments": $utils.toJson($context.arguments)
}
}
```
Untuk template pemetaan `addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!` respons:
```
$utils.toJson($context.result)
```
Untuk templat pemetaan `allPosts: [Post]` permintaan:
```
{
"version": "2017-02-28",
"operation": "Invoke",
"payload": {
"field": "allPosts"
}
}
```
Untuk template pemetaan `allPosts: [Post]` respons:
```
$utils.toJson($context.result)
```
Untuk templat pemetaan `Post.relatedPosts: [Post]` permintaan:
```
{
"version": "2017-02-28",
"operation": "Invoke",
"payload": {
"field": "relatedPosts",
"source": $utils.toJson($context.source)
}
}
```
Untuk template pemetaan `Post.relatedPosts: [Post]` respons:
```
$utils.toJson($context.result)
```
## Uji GraphQL API
Sekarang fungsi Lambda Anda terhubung ke resolver GraphQL, Anda dapat menjalankan beberapa mutasi dan kueri menggunakan konsol atau aplikasi klien.
Di sisi kiri AWS AppSync konsol, pilih **Kueri**, lalu tempel kode berikut:
### AddPost Mutasi
```
mutation addPost {
addPost(
id: 6
author: "Author6"
title: "Sixth book"
url: "https://www.amazon.com/"
content: "This is the book is a tutorial for using GraphQL with AWS AppSync."
) {
id
author
title
content
url
ups
downs
}
}
```
### Kueri GetPost
```
query getPost {
getPost(id: "2") {
id
author
title
content
url
ups
downs
}
}
```
### AllPosts Query
```
query allPosts {
allPosts {
id
author
title
content
url
ups
downs
relatedPosts {
id
title
}
}
}
```
## Mengembalikan kesalahan
Setiap resolusi bidang yang diberikan dapat mengakibatkan kesalahan. Dengan AWS AppSync, Anda dapat meningkatkan kesalahan dari sumber-sumber berikut:
+ Templat pemetaan permintaan atau respons
+ Fungsi Lambda
### Dari template pemetaan
Untuk memunculkan kesalahan yang disengaja, Anda dapat menggunakan metode `$utils.error` pembantu dari template Velocity Template Language (VTL). Dibutuhkan sebagai argumen`errorMessage`, an`errorType`, dan `data` nilai opsional. `data`Ini berguna untuk mengembalikan data tambahan kembali ke klien ketika terjadi kesalahan. `data`Objek ditambahkan ke `errors` dalam respon akhir GraphQL.
Contoh berikut menunjukkan cara menggunakannya dalam template pemetaan `Post.relatedPosts: [Post]` respons:
```
$utils.error("Failed to fetch relatedPosts", "LambdaFailure", $context.result)
```
Ini menghasilkan respons GraphQL yang mirip dengan yang berikut:
```
{
"data": {
"allPosts": [
{
"id": "2",
"title": "Second book",
"relatedPosts": null
},
...
]
},
"errors": [
{
"path": [
"allPosts",
0,
"relatedPosts"
],
"errorType": "LambdaFailure",
"locations": [
{
"line": 5,
"column": 5
}
],
"message": "Failed to fetch relatedPosts",
"data": [
{
"id": "2",
"title": "Second book"
},
{
"id": "1",
"title": "First book"
}
]
}
]
}
```
`allPosts[0].relatedPosts`Dimana *nol* karena kesalahan dan`errorMessage`,`errorType`, dan `data` hadir dalam `data.errors[0]` objek.
### Dari fungsi Lambda
AWS AppSync juga memahami kesalahan yang dilemparkan fungsi Lambda. Model pemrograman Lambda memungkinkan Anda meningkatkan kesalahan yang *ditangani*. Jika fungsi Lambda memunculkan kesalahan, AWS AppSync gagal menyelesaikan bidang saat ini. Hanya pesan kesalahan yang dikembalikan dari Lambda yang disetel dalam respons. Saat ini, Anda tidak dapat meneruskan data asing apa pun kembali ke klien dengan memunculkan kesalahan dari fungsi Lambda.
**Catatan**: Jika fungsi Lambda Anda memunculkan kesalahan yang *tidak tertangani*, AWS AppSync gunakan pesan kesalahan yang ditetapkan Lambda.
Fungsi Lambda berikut menimbulkan kesalahan:
```
exports.handler = (event, context, callback) => {
console.log("Received event {}", JSON.stringify(event, 3));
callback("I fail. Always.");
};
```
Ini mengembalikan respon GraphQL mirip dengan berikut ini:
```
{
"data": {
"allPosts": [
{
"id": "2",
"title": "Second book",
"relatedPosts": null
},
...
]
},
"errors": [
{
"path": [
"allPosts",
0,
"relatedPosts"
],
"errorType": "Lambda:Handled",
"locations": [
{
"line": 5,
"column": 5
}
],
"message": "I fail. Always."
}
]
}
```
## Kasus penggunaan lanjutan: Batching
Fungsi Lambda dalam contoh ini memiliki `relatedPosts` bidang yang mengembalikan daftar posting terkait untuk posting tertentu. Dalam contoh kueri, pemanggilan `allPosts` bidang dari fungsi Lambda mengembalikan lima posting. Karena kami menetapkan bahwa kami juga ingin menyelesaikan `relatedPosts` untuk setiap posting yang dikembalikan, operasi `relatedPosts` lapangan dipanggil lima kali.
```
query allPosts {
allPosts { // 1 Lambda invocation - yields 5 Posts
id
author
title
content
url
ups
downs
relatedPosts { // 5 Lambda invocations - each yields 5 posts
id
title
}
}
}
```
Meskipun ini mungkin tidak terdengar substansif dalam contoh spesifik ini, pengambilan berlebihan yang diperparah ini dapat dengan cepat merusak aplikasi.
Jika Anda mengambil `relatedPosts` lagi pada terkait yang dikembalikan `Posts` dalam kueri yang sama, jumlah pemanggilan akan meningkat secara dramatis.
```
query allPosts {
allPosts { // 1 Lambda invocation - yields 5 Posts
id
author
title
content
url
ups
downs
relatedPosts { // 5 Lambda invocations - each yield 5 posts = 5 x 5 Posts
id
title
relatedPosts { // 5 x 5 Lambda invocations - each yield 5 posts = 25 x 5 Posts
id
title
author
}
}
}
}
```
Dalam kueri yang relatif sederhana ini, AWS AppSync akan memanggil fungsi Lambda 1 \$1 5 \$1 25 = 31 kali.
Ini adalah tantangan yang cukup umum dan sering disebut masalah N\$11 (dalam hal ini, N = 5), dan dapat menimbulkan peningkatan latensi dan biaya untuk aplikasi.
Salah satu pendekatan untuk memecahkan masalah ini adalah dengan mengumpulkan permintaan penyelesai bidang serupa bersama-sama. Dalam contoh ini, alih-alih memiliki fungsi Lambda menyelesaikan daftar posting terkait untuk satu posting tertentu, itu malah bisa menyelesaikan daftar posting terkait untuk kumpulan posting tertentu.
Untuk mendemonstrasikan hal ini, mari beralih `Post.relatedPosts: [Post]` resolver ke resolver batch-enabled.
Di sisi kanan AWS AppSync konsol, pilih `Post.relatedPosts: [Post]` resolver yang ada. Ubah template pemetaan permintaan menjadi berikut:
```
{
"version": "2017-02-28",
"operation": "BatchInvoke",
"payload": {
"field": "relatedPosts",
"source": $utils.toJson($context.source)
}
}
```
Hanya `operation` bidang yang berubah dari `Invoke` menjadi`BatchInvoke`. Bidang payload sekarang menjadi array dari apa pun yang ditentukan dalam template. Dalam contoh ini, fungsi Lambda menerima yang berikut sebagai input:
```
[
{
"field": "relatedPosts",
"source": {
"id": 1
}
},
{
"field": "relatedPosts",
"source": {
"id": 2
}
},
...
]
```
Kapan `BatchInvoke` ditentukan dalam template pemetaan permintaan, fungsi Lambda menerima daftar permintaan dan mengembalikan daftar hasil.
Secara khusus, daftar hasil harus sesuai dengan ukuran dan urutan entri payload permintaan sehingga AWS AppSync dapat cocok dengan hasil yang sesuai.
Dalam contoh batching ini, fungsi Lambda mengembalikan sekumpulan hasil sebagai berikut:
```
[
[{"id":"2","title":"Second book"}, {"id":"3","title":"Third book"}], // relatedPosts for id=1
[{"id":"3","title":"Third book"}] // relatedPosts for id=2
]
```
Fungsi Lambda berikut di Node.js menunjukkan fungsionalitas batching ini untuk bidang sebagai `Post.relatedPosts` berikut:
```
exports.handler = (event, context, callback) => {
console.log("Received event {}", JSON.stringify(event, 3));
var posts = {
"1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
"2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
"3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
"4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
"5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };
var relatedPosts = {
"1": [posts['4']],
"2": [posts['3'], posts['5']],
"3": [posts['2'], posts['1']],
"4": [posts['2'], posts['1']],
"5": []
};
console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
// event is now an array
var field = event[0].field;
switch(field) {
case "relatedPosts":
var results = [];
// the response MUST contain the same number
// of entries as the payload array
for (var i=0; i< event.length; i++) {
console.log("post {}", JSON.stringify(event[i].source));
results.push(relatedPosts[event[i].source.id]);
}
console.log("results {}", JSON.stringify(results));
callback(null, results);
break;
default:
callback("Unknown field, unable to resolve" + field, null);
break;
}
};
```
### Mengembalikan kesalahan individu
Contoh sebelumnya menunjukkan bahwa dimungkinkan untuk mengembalikan satu kesalahan dari fungsi Lambda atau memunculkan kesalahan dari templat pemetaan. Untuk pemanggilan batch, memunculkan kesalahan dari fungsi Lambda menandai seluruh batch sebagai gagal. Ini mungkin dapat diterima untuk skenario tertentu di mana terjadi kesalahan yang tidak dapat dipulihkan, seperti koneksi yang gagal ke penyimpanan data. Namun, dalam kasus di mana beberapa item dalam batch berhasil dan yang lainnya gagal, dimungkinkan untuk mengembalikan kesalahan dan data yang valid. Karena AWS AppSync memerlukan respons batch untuk mencantumkan elemen yang cocok dengan ukuran asli batch, Anda harus menentukan struktur data yang dapat membedakan data yang valid dari kesalahan.
*Misalnya, jika fungsi Lambda diharapkan mengembalikan kumpulan posting terkait, Anda dapat memilih untuk mengembalikan daftar `Response` objek di mana setiap objek memiliki *data opsional, ErrorMessage, dan bidang* *ErrorType*.* Jika bidang *ErrorMessage* ada, itu berarti terjadi kesalahan.
Kode berikut menunjukkan bagaimana Anda dapat memperbarui fungsi Lambda:
```
exports.handler = (event, context, callback) => {
console.log("Received event {}", JSON.stringify(event, 3));
var posts = {
"1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
"2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
"3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
"4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
"5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };
var relatedPosts = {
"1": [posts['4']],
"2": [posts['3'], posts['5']],
"3": [posts['2'], posts['1']],
"4": [posts['2'], posts['1']],
"5": []
};
console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
// event is now an array
var field = event[0].field;
switch(field) {
case "relatedPosts":
var results = [];
results.push({ 'data': relatedPosts['1'] });
results.push({ 'data': relatedPosts['2'] });
results.push({ 'data': null, 'errorMessage': 'Error Happened', 'errorType': 'ERROR' });
results.push(null);
results.push({ 'data': relatedPosts['3'], 'errorMessage': 'Error Happened with last result', 'errorType': 'ERROR' });
callback(null, results);
break;
default:
callback("Unknown field, unable to resolve" + field, null);
break;
}
};
```
Untuk contoh ini, template pemetaan respons berikut mem-parsing setiap item fungsi Lambda dan memunculkan kesalahan yang terjadi:
```
#if( $context.result && $context.result.errorMessage )
$utils.error($context.result.errorMessage, $context.result.errorType, $context.result.data)
#else
$utils.toJson($context.result.data)
#end
```
Contoh ini mengembalikan respon GraphQL mirip dengan berikut:
```
{
"data": {
"allPosts": [
{
"id": "1",
"relatedPostsPartialErrors": [
{
"id": "4",
"title": "Fourth book"
}
]
},
{
"id": "2",
"relatedPostsPartialErrors": [
{
"id": "3",
"title": "Third book"
},
{
"id": "5",
"title": "Fifth book"
}
]
},
{
"id": "3",
"relatedPostsPartialErrors": null
},
{
"id": "4",
"relatedPostsPartialErrors": null
},
{
"id": "5",
"relatedPostsPartialErrors": null
}
]
},
"errors": [
{
"path": [
"allPosts",
2,
"relatedPostsPartialErrors"
],
"errorType": "ERROR",
"locations": [
{
"line": 4,
"column": 9
}
],
"message": "Error Happened"
},
{
"path": [
"allPosts",
4,
"relatedPostsPartialErrors"
],
"data": [
{
"id": "2",
"title": "Second book"
},
{
"id": "1",
"title": "First book"
}
],
"errorType": "ERROR",
"locations": [
{
"line": 4,
"column": 9
}
],
"message": "Error Happened with last result"
}
]
}
```
### Mengkonfigurasi ukuran batching maksimum
Secara default, saat menggunakan`BatchInvoke`, AWS AppSync mengirim permintaan ke fungsi Lambda Anda dalam batch hingga lima item. Anda dapat mengonfigurasi ukuran batch maksimum resolver Lambda Anda.
Untuk mengonfigurasi ukuran batching maksimum pada resolver, gunakan perintah berikut di (): AWS Command Line Interface AWS CLI
```
$ aws appsync create-resolver --api-id --type-name Query --field-name relatedPosts \
--request-mapping-template "" --response-mapping-template "" --data-source-name "" \
--max-batch-size X
```
**catatan**
Saat menyediakan template pemetaan permintaan, Anda harus menggunakan `BatchInvoke` operasi untuk menggunakan batching.
Anda juga dapat menggunakan perintah berikut untuk mengaktifkan dan mengkonfigurasi batching pada Direct Lambda Resolvers:
```
$ aws appsync create-resolver --api-id --type-name Query --field-name relatedPosts \
--data-source-name "" \
--max-batch-size X
```
### Konfigurasi ukuran batching maksimum dengan template VTL
Untuk Resolver Lambda yang memiliki templat dalam permintaan VTL, ukuran batch maksimum tidak akan berpengaruh kecuali mereka secara langsung menentukannya sebagai operasi di VTL. `BatchInvoke` Demikian pula, jika Anda melakukan mutasi tingkat atas, batching tidak dilakukan untuk mutasi karena spesifikasi GraphQL memerlukan mutasi paralel untuk dieksekusi secara berurutan.
Misalnya, ambil mutasi berikut:
```
type Mutation {
putItem(input: Item): Item
putItems(inputs: [Item]): [Item]
}
```
Dengan menggunakan mutasi pertama, kita dapat membuat 10 `Items` seperti yang ditunjukkan pada cuplikan di bawah ini:
```
mutation MyMutation {
v1: putItem($someItem1) {
id,
name
}
v2: putItem($someItem2) {
id,
name
}
v3: putItem($someItem3) {
id,
name
}
v4: putItem($someItem4) {
id,
name
}
v5: putItem($someItem5) {
id,
name
}
v6: putItem($someItem6) {
id,
name
}
v7: putItem($someItem7) {
id,
name
}
v8: putItem($someItem8) {
id,
name
}
v9: putItem($someItem9) {
id,
name
}
v10: putItem($someItem10) {
id,
name
}
}
```
Dalam contoh ini, tidak `Items` akan dikelompokkan dalam grup 10 bahkan jika ukuran batch maksimum diatur ke 10 di Lambda Resolver. Sebaliknya, mereka akan mengeksekusi secara berurutan sesuai dengan spesifikasi GraphQL.
Untuk melakukan mutasi batch yang sebenarnya, Anda dapat mengikuti contoh di bawah ini menggunakan mutasi kedua:
```
mutation MyMutation {
putItems([$someItem1, $someItem2, $someItem3,$someItem4, $someItem5, $someItem6,
$someItem7, $someItem8, $someItem9, $someItem10]) {
id,
name
}
}
```
Untuk informasi selengkapnya tentang penggunaan batching dengan Direct Lambda Resolvers, lihat. [Resolver Lambda Langsung](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers)