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

Menggabungkan resolver GraphQL di AWS AppSync

Resolver dan bidang dalam skema GraphQL memiliki hubungan 1:1 dengan tingkat fleksibilitas yang besar. Karena sumber data dikonfigurasi pada resolver secara independen dari skema, Anda memiliki kemampuan untuk jenis GraphQL untuk diselesaikan atau dimanipulasi melalui sumber data yang berbeda, pencampuran dan pencocokan pada skema untuk memenuhi kebutuhan Anda.

Contoh skenario berikut menunjukkan cara mencampur dan mencocokkan sumber data dalam skema Anda. Sebelum Anda mulai, kami sarankan Anda terbiasa dengan pengaturan sumber data dan resolver untuk AWS Lambda, Amazon DynamoDB, dan OpenSearch Amazon Service seperti yang dijelaskan dalam tutorial sebelumnya.

Contoh skema

Skema berikut memiliki jenis Post dengan 3 Query operasi dan 3 Mutation operasi didefinisikan:

type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    version: Int!
}

type Query {
    allPost: [Post]
    getPost(id: ID!): Post
    searchPosts: [Post]
}

type Mutation {
    addPost(
        id: ID!,
        author: String!,
        title: String,
        content: String,
        url: String
    ): Post
    updatePost(
        id: ID!,
        author: String!,
        title: String,
        content: String,
        url: String,
        ups: Int!,
        downs: Int!,
        expectedVersion: Int!
    ): Post
    deletePost(id: ID!): Post
}

Dalam contoh ini Anda akan memiliki total 6 resolver untuk dilampirkan. Salah satu cara yang mungkin adalah agar semua ini berasal dari tabel Amazon DynamoDB, yang Posts disebut, AllPosts di mana menjalankan pemindaian searchPosts dan menjalankan kueri, seperti yang diuraikan dalam Referensi Template Pemetaan DynamoDB Resolver. Namun, ada alternatif untuk memenuhi kebutuhan bisnis Anda, seperti menyelesaikan kueri GraphQL ini dari Lambda atau Layanan. OpenSearch

Mengubah data melalui resolver

Anda mungkin perlu mengembalikan hasil dari database seperti DynamoDB (atau Amazon Aurora) ke klien dengan beberapa atribut diubah. Ini mungkin karena pemformatan tipe data, seperti perbedaan stempel waktu pada klien, atau untuk menangani masalah kompatibilitas mundur. Untuk tujuan ilustrasi, dalam contoh berikut, AWS Lambda fungsi memanipulasi up-votes dan down-votes untuk posting blog dengan menetapkan nomor acak setiap kali GraphQL resolver dipanggil:

'use strict';
const doc = require('dynamodb-doc');
const dynamo = new doc.DynamoDB();

exports.handler = (event, context, callback) => {
    const payload = {
        TableName: 'Posts',
        Limit: 50,
        Select: 'ALL_ATTRIBUTES',
    };

    dynamo.scan(payload, (err, data) => {
        const result = { data: data.Items.map(item =>{
            item.ups = parseInt(Math.random() * (50 - 10) + 10, 10);
            item.downs = parseInt(Math.random() * (20 - 0) + 0, 10);
            return item;
        }) };
        callback(err, result.data);
    });
};

Ini adalah fungsi Lambda yang benar-benar valid dan dapat dilampirkan ke AllPosts bidang dalam skema GraphQL sehingga setiap kueri yang mengembalikan semua hasil mendapat angka acak untuk naik/turun.

DynamoDB dan Layanan OpenSearch

Untuk beberapa aplikasi, Anda mungkin melakukan mutasi atau kueri pencarian sederhana terhadap DynamoDB, dan memiliki proses latar belakang mentransfer dokumen ke Layanan. OpenSearch Anda kemudian dapat melampirkan searchPosts Resolver ke sumber data OpenSearch Layanan dan mengembalikan hasil pencarian (dari data yang berasal dari DynamoDB) menggunakan query GraphQL. Ini bisa sangat kuat saat menambahkan operasi pencarian lanjutan ke aplikasi Anda seperti kata kunci, kecocokan kata kabur atau bahkan pencarian geospasial. Mentransfer data dari DynamoDB dapat dilakukan melalui proses atau sebagai alternatif Anda dapat melakukan streaming dari DynamoDB ETL menggunakan Lambda. Anda dapat meluncurkan contoh lengkap ini menggunakan AWS CloudFormation tumpukan berikut di Wilayah AS Barat 2 (Oregon) di AWS akun Anda:

Skema dalam contoh ini memungkinkan Anda menambahkan posting menggunakan DynamoDB resolver sebagai berikut:

mutation add {
    putPost(author:"Nadia"
        title:"My first post"
        content:"This is some test content"
        url:"https://aws.amazon.com/appsync/"
    ){
        id
        title
    }
}

Ini menulis data ke DynamoDB yang kemudian mengalirkan data melalui Lambda ke OpenSearch Amazon Service yang dapat Anda cari untuk semua posting dengan bidang yang berbeda. Misalnya, karena data ada di OpenSearch Layanan Amazon, Anda dapat mencari bidang penulis atau konten dengan teks bentuk bebas, bahkan dengan spasi, sebagai berikut:

query searchName{
    searchAuthor(name:"   Nadia   "){
        id
        title
        content
    }
}

query searchContent{
    searchContent(text:"test"){
        id
        title
        content
    }
}

Karena data ditulis langsung ke DynamoDB, Anda masih dapat melakukan operasi pencarian daftar atau item yang efisien terhadap tabel dengan dan kueri. allPosts{...} singlePost{...} Tumpukan ini menggunakan kode contoh berikut untuk aliran DynamoDB:

Catatan: Kode ini misalnya saja.

var AWS = require('aws-sdk');
var path = require('path');
var stream = require('stream');

var esDomain = {
    endpoint: 'https://opensearch-domain-name.REGION.es.amazonaws.com',
    region: 'REGION',
    index: 'id',
    doctype: 'post'
};

var endpoint = new AWS.Endpoint(esDomain.endpoint)
var creds = new AWS.EnvironmentCredentials('AWS');

function postDocumentToES(doc, context) {
    var req = new AWS.HttpRequest(endpoint);

    req.method = 'POST';
    req.path = '/_bulk';
    req.region = esDomain.region;
    req.body = doc;
    req.headers['presigned-expires'] = false;
    req.headers['Host'] = endpoint.host;

    // Sign the request (Sigv4)
    var signer = new AWS.Signers.V4(req, 'es');
    signer.addAuthorization(creds, new Date());

    // Post document to ES
    var send = new AWS.NodeHttpClient();
    send.handleRequest(req, null, function (httpResp) {
        var body = '';
        httpResp.on('data', function (chunk) {
            body += chunk;
        });
        httpResp.on('end', function (chunk) {
            console.log('Successful', body);
            context.succeed();
        });
    }, function (err) {
        console.log('Error: ' + err);
        context.fail();
    });
}

exports.handler = (event, context, callback) => {
    console.log("event => " + JSON.stringify(event));
    var posts = '';

    for (var i = 0; i < event.Records.length; i++) {
        var eventName = event.Records[i].eventName;
        var actionType = '';
        var image;
        var noDoc = false;
        switch (eventName) {
            case 'INSERT':
                actionType = 'create';
                image = event.Records[i].dynamodb.NewImage;
                break;
            case 'MODIFY':
                actionType = 'update';
                image = event.Records[i].dynamodb.NewImage;
                break;
            case 'REMOVE':
            actionType = 'delete';
                image = event.Records[i].dynamodb.OldImage;
                noDoc = true;
                break;
        }

        if (typeof image !== "undefined") {
            var postData = {};
            for (var key in image) {
                if (image.hasOwnProperty(key)) {
                    if (key === 'postId') {
                        postData['id'] = image[key].S;
                    } else {
                        var val = image[key];
                        if (val.hasOwnProperty('S')) {
                            postData[key] = val.S;
                        } else if (val.hasOwnProperty('N')) {
                            postData[key] = val.N;
                        }
                    }
                }
            }

            var action = {};
            action[actionType] = {};
            action[actionType]._index = 'id';
            action[actionType]._type = 'post';
            action[actionType]._id = postData['id'];
            posts += [
                JSON.stringify(action),
            ].concat(noDoc?[]:[JSON.stringify(postData)]).join('\n') + '\n';
        }
    }
    console.log('posts:',posts);
    postDocumentToES(posts, context);
};

Anda kemudian dapat menggunakan aliran DynamoDB untuk melampirkan ini ke tabel DynamoDB dengan kunci id utama, dan setiap perubahan pada sumber DynamoDB akan mengalir ke domain Layanan Anda. OpenSearch Untuk informasi selengkapnya tentang mengonfigurasi ini, lihat dokumentasi DynamoDB Streams.