Tutorial: Penyelesai Lambda - AWS AppSync
Buat fungsi LambdaKonfigurasikan sumber data untuk LambdaBuat skema GraphQLKonfigurasikan resolverUji GraphQL APIMengembalikan kesalahanKasus penggunaan lanjutan: Batching

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

Tutorial: Penyelesai Lambda

catatan

Kami sekarang terutama mendukung runtime APPSYNC_JS dan dokumentasinya. Harap pertimbangkan untuk menggunakan runtime APPSYNC_JS dan panduannya di sini.

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 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 AWS CloudFormation tumpukan di AWS Wilayah AS Barat (Oregon) di AWS akun Anda dari sini:

Konfigurasikan sumber data untuk Lambda

Setelah Anda membuat fungsi Lambda, navigasikan ke GraphQL API 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 Lambdafungsi. 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:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:REGION:ACCOUNTNUMBER:function/LAMBDA_FUNCTION"
        }
    ]
}

Anda juga harus mengatur hubungan kepercayaan dengan AWS AppSync peran IAM sebagai berikut:

{
    "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, lihatResolver Mapping Template Overview.

Untuk informasi selengkapnya tentang templat pemetaan Lambda, lihat. Resolver mapping template reference for 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 Save (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 meningkatkan kesalahan yang disengaja, Anda dapat menggunakan metode $utils.error pembantu dari template Velocity Template Language (VTL). Dibutuhkan sebagai argumenerrorMessage, anerrorType, dan data nilai opsional. dataIni berguna untuk mengembalikan data tambahan kembali ke klien ketika terjadi kesalahan. dataObjek 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].relatedPostsDimana nol karena kesalahan danerrorMessage,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 melempar 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 + 5 + 25 = 31 kali.

Ini adalah tantangan yang cukup umum dan sering disebut masalah N+1 (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 yang 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 menjadiBatchInvoke. 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 menggunakanBatchInvoke, 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 <api-id> --type-name Query --field-name relatedPosts \
 --request-mapping-template "<template>" --response-mapping-template "<template>" --data-source-name "<lambda-datasource>" \ 
 --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 <api-id> --type-name Query --field-name relatedPosts \
 --data-source-name "<lambda-datasource>" \ 
 --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