Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Combinación de solucionadores de GraphQL en AWS AppSync

Los solucionadores y los campos de un esquema de GraphQL mantienen una relación 1:1 con un alto grado de flexibilidad. Debido a que un origen de datos se configura en un solucionador independientemente de un esquema, usted tiene la capacidad de resolver o manipular sus tipos de GraphQL a través de diferentes orígenes de datos, lo que le permite mezclar y combinar un esquema para satisfacer mejor sus necesidades.

Los siguientes escenarios muestran cómo mezclar y hacer corresponder los orígenes de datos en su esquema. Antes de empezar, debe estar familiarizado con la configuración de orígenes de datos y solucionadores para AWS Lambda Amazon DynamoDB y Amazon OpenSearch Service.

Esquema de ejemplo

El siguiente esquema tiene un tipo Post con tres Query y operaciones Mutation cada una:

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
}

En este ejemplo, tendría un total de seis solucionadores y cada uno necesitaría un origen de datos. Una forma de resolver este problema sería conectarlos a una única tabla de Amazon DynamoDB, denominada Posts, en la que el campo AllPost ejecuta un análisis y el campo searchPosts ejecuta una consulta (consulte JavaScript resolver function reference for DynamoDB). Sin embargo, no está limitado a Amazon DynamoDB; existen diferentes orígenes de datos, como Lambda u OpenSearch Service, para cumplir con los requisitos de su empresa.

Modificación de datos mediante solucionadores

Es posible que tenga que devolver los resultados desde una base de datos de terceros que no sea compatible directamente con los orígenes de datos de AWS AppSync. También es posible que tenga que realizar modificaciones complejas en los datos antes de devolverlos a los clientes de la API. Esto podría deberse a un formato incorrecto de los tipos de datos, como diferencias de fecha y hora en los clientes, o a la gestión de problemas de compatibilidad con versiones anteriores. En este caso, la solución adecuada es conectar las funciones de AWS Lambda como un origen de datos a la API de AWS AppSync. A título ilustrativo, en el siguiente ejemplo, una función de AWS Lambda manipula datos obtenidos de un almacén de datos externo:

export const handler = (event, context, callback) => {
    // fetch data
    const result = fetcher()

    // apply complex business logic
    const data = transform(result)	

    // return to AppSync
    return data
};

Se trata de una función de Lambda perfectamente válida y puede asociarse al campo AllPost del esquema de GraphQL para que cualquier consulta que devuelva todos los resultados obtenga números aleatorios para las subidas/bajadas.

DynamoDB y OpenSearch Service

En algunas aplicaciones, puede realizar mutaciones o consultas de búsqueda sencilla en DynamoDB y tener un proceso en segundo plano para transferir documentos a OpenSearch Service. Podría simplemente asociar el solucionador searchPosts al origen de datos de OpenSearch Service y devolver los resultados de la búsqueda (a partir de los datos originados en DynamoDB) mediante una consulta GraphQL. Esto puede ser extremadamente útil al añadir operaciones de búsqueda avanzada a sus aplicaciones, como palabras clave, coincidencias parciales o incluso búsquedas geoespaciales. La transferencia de datos desde DynamoDB puede realizarse mediante un proceso ETL o, alternativamente, puede transmitir desde DynamoDB mediante Lambda.

Para empezar con estos orígenes de datos específicos, consulte nuestros tutoriales de DynamoDB y Lambda.

Por ejemplo, con el esquema de nuestro tutorial anterior, la siguiente mutación añade un elemento a DynamoDB:

mutation addPost {
  addPost(
    id: 123
    author: "Nadia"
    title: "Our first post!"
    content: "This is our first post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Esto escribe datos en DynamoDB, que transmite mediante Lambda a Amazon OpenSearch Service y que luego se utilizan para buscar publicaciones por distintos campos. Por ejemplo, como los datos se encuentran en Amazon OpenSearch Service, puede buscar los campos de autor o contenido con texto libre, incluso con espacios, del siguiente modo:

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

---------- or ----------

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

Como los datos se escriben directamente en DynamoDB, aún puede realizar operaciones eficientes de búsqueda de lista o de elemento en la tabla con las consultas allPost{...} y getPost{...}. Esta pila utiliza el siguiente código de ejemplo para los flujos de DynamoDB:

import boto3
import requests
from requests_aws4auth import AWS4Auth

region = '' # e.g. us-east-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)

host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com
index = 'lambda-index'
datatype = '_doc'
url = host + '/' + index + '/' + datatype + '/'

headers = { "Content-Type": "application/json" }

def handler(event, context):
    count = 0
    for record in event['Records']:
        # Get the primary key for use as the OpenSearch ID
        id = record['dynamodb']['Keys']['id']['S']

        if record['eventName'] == 'REMOVE':
            r = requests.delete(url + id, auth=awsauth)
        else:
            document = record['dynamodb']['NewImage']
            r = requests.put(url + id, auth=awsauth, json=document, headers=headers)
        count += 1
    return str(count) + ' records processed.'

Puede utilizar flujos de DynamoDB para asociarlo a una tabla de DynamoDB con la clave principal id, y cualquier cambio en el origen de DynamoDB se transmitirá al dominio de OpenSearch Service. Para obtener más información sobre cómo configurarlo, consulte la documentación de flujos de DynamoDB.