Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Combinazione di resolver GraphQL in AWS AppSync

I resolver e i campi in uno schema di GraphQL hanno un rapporto 1:1 con un elevato grado di flessibilità. Poiché un'origine dati è configurata su un resolver indipendentemente dallo schema, c'è la possibilità di risolvere o manipolare i tipi di GraphQL tramite diverse origini dati, mescolandole o combinandole in uno schema per soddisfare al meglio le esigenze.

Gli scenari di esempio seguenti mostrano come combinare e abbinare le fonti di dati nello schema. Prima di iniziare, ti consigliamo di acquisire dimestichezza con la configurazione di sorgenti di dati e resolver per Amazon AWS Lambda DynamoDB e Amazon OpenSearch Service, come descritto nei tutorial precedenti.

Schema di esempio

Lo schema seguente ha un tipo Post con 3 Query operazioni e 3 Mutation operazioni definite:

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
}

In questo esempio si dispone di un totale di 6 resolver da allegare. Un modo possibile sarebbe quello di far sì che tutti questi dati provengano da una tabella Amazon DynamoDB, Posts chiamata, AllPosts dove esegue una scansione searchPosts ed esegue una query, come indicato nel DynamoDB Resolver Mapping Template Reference. Tuttavia, esistono alternative per soddisfare le esigenze aziendali, come la risoluzione di queste query GraphQL da Lambda o Service. OpenSearch

Modificare i dati tramite resolver

Potrebbe essere necessario restituire i risultati di un database come DynamoDB (o Amazon Aurora) ai client con alcuni attributi modificati. Questo potrebbe essere dovuto alla formattazione dei tipi di dati, ad esempio differenze di timestamp sui client, oppure gestire problemi di retrocompatibilità. A scopo illustrativo, nell'esempio seguente, una AWS Lambda funzione manipola i voti positivi e negativi per i post del blog assegnando loro numeri casuali ogni volta che viene richiamato il resolver GraphQL:

'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);
    });
};

Questa è una funzione di Lambda perfettamente valida e potrebbe essere associata al campo AllPosts nello schema di GraphQL in modo che qualsiasi query che restituisce tutti i risultati ottenga numeri casuali per i voti in alto/in basso.

DynamoDB e Service OpenSearch

Per alcune applicazioni, è possibile eseguire mutazioni o semplici query di ricerca su DynamoDB e disporre di un processo in background per trasferire i documenti al Service. OpenSearch È quindi possibile collegare semplicemente il searchPosts Resolver all'origine dati del OpenSearch servizio e restituire i risultati della ricerca (dai dati originati in DynamoDB) utilizzando una query GraphQL. Questo può essere estremamente potente quando si aggiungono operazioni di ricerca avanzate per applicazioni come parole chiave, combinazioni ambigue di parole o anche ricerche geospaziali. Il trasferimento dei dati da DynamoDB può essere eseguito tramite ETL un processo o, in alternativa, è possibile eseguire lo streaming da DynamoDB utilizzando Lambda. Puoi lanciare un esempio completo di ciò utilizzando il seguente AWS CloudFormation stack nella regione US West 2 (Oregon) del tuo account: AWS

Lo schema in questo esempio consente di aggiungere post utilizzando un resolver DynamoDB come segue:

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

Questo scrive i dati su DynamoDB, che poi trasmette i dati tramite Lambda ad OpenSearch Amazon Service, dove puoi cercare tutti i post in base a campi diversi. Ad esempio, poiché i dati si trovano in Amazon OpenSearch Service, puoi cercare nei campi dell'autore o del contenuto con testo in formato libero, anche con spazi, come segue:

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

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

Poiché i dati vengono scritti direttamente su DynamoDB, è comunque possibile eseguire operazioni efficienti di ricerca di elenchi o elementi sulla tabella con le query and. allPosts{...} singlePost{...} Questo stack utilizza il seguente codice di esempio per i flussi DynamoDB:

Nota: questo codice è solo a scopo esemplificativo.

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);
};

Puoi quindi utilizzare i flussi DynamoDB per collegarla a una tabella DynamoDB con una chiave primaria di e qualsiasi modifica all'origine id di DynamoDB verrà trasferita nel tuo dominio di servizio. OpenSearch Per ulteriori informazioni sulla configurazione di questa funzionalità, consulta Documentazione dei flussi di DynamoDB.