As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Combinando resolvedores GraphQL em AWS AppSync

Os resolvedores e campos em um esquema do GraphQL têm relacionamentos 1:1 com um grande grau de flexibilidade. Como uma fonte de dados é configurada em um resolvedor independentemente de um esquema, você tem a capacidade de resolver ou manipular seus tipos do GraphQL por meio de diferentes fontes de dados, permitindo misturar e combinar um esquema para melhor atender às suas necessidades.

Os cenários a seguir demonstram como misturar e combinar fontes de dados no seu esquema. Antes de começar, você deve estar familiarizado com a configuração de fontes de dados e resolvedores para o Amazon AWS Lambda DynamoDB e o Amazon Service. OpenSearch

Esquema de exemplo

O esquema a seguir tem um tipo de Post com três Query e operações Mutation cada:

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
}

Neste exemplo, você teria um total de seis resolvedores, cada um precisando de uma fonte de dados. Uma forma de resolver esse problema seria conectá-los a uma única tabela do Amazon DynamoDB, Posts chamada, na qual o campo executa uma varredura e AllPost o campo executa uma consulta (JavaScriptconsulte searchPosts a referência da função de resolução do DynamoDB). No entanto, você não está limitado ao Amazon DynamoDB; existem fontes de dados diferentes, como Lambda OpenSearch ou Service, para atender às suas necessidades comerciais.

Alteração de dados por meio de resolvedores

Talvez seja necessário retornar resultados de um banco de dados de terceiros que não seja diretamente suportado por fontes AWS AppSync de dados. Talvez você também precise realizar modificações complexas nos dados antes que eles sejam devolvidos ao (s) API cliente (s). Isso pode ser causado pela formatação inadequada dos tipos de dados, como diferenças de carimbo de data/hora nos clientes ou pelo tratamento de problemas de compatibilidade com versões anteriores. Nesse caso, conectar AWS Lambda funções como fonte de dados à sua AWS AppSync API é a solução apropriada. Para fins ilustrativos, no exemplo a seguir, uma AWS Lambda função manipula dados obtidos de um armazenamento de dados de terceiros:

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

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

    // return to AppSync
    return data
};

Essa é uma função do Lambda perfeitamente válida e pode ser anexada ao campo AllPost no esquema do GraphQL para que qualquer consulta que retorne todos os resultados obtenha números aleatórios para os votos positivos/negativos.

DynamoDB e serviços OpenSearch

Para alguns aplicativos, você pode realizar mutações ou consultas de pesquisa simples no DynamoDB e fazer com que um processo em segundo plano transfira documentos para o Service. OpenSearch Você pode simplesmente anexar o searchPosts resolvedor à fonte de dados do OpenSearch Service e retornar os resultados da pesquisa (de dados originados no DynamoDB) usando uma consulta GraphQL. Isso pode ser extremamente poderoso ao adicionar operações de pesquisa avançadas aos aplicativos, como palavra-chave, correspondências de palavras confusas ou até mesmo pesquisas geoespaciais. A transferência de dados do DynamoDB pode ser feita por meio de ETL um processo ou, como alternativa, você pode transmitir do DynamoDB usando o Lambda.

Para começar a usar essas fontes de dados específicas, consulte nossos tutoriais do DynamoDB e Lambda.

Por exemplo, usando o esquema do nosso tutorial anterior, a seguinte mutação adiciona um item ao 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
  }
}

Isso grava dados no DynamoDB, que então transmite dados via Lambda para o OpenSearch Amazon Service, que você usa para pesquisar publicações em campos diferentes. Por exemplo, como os dados estão no Amazon OpenSearch Service, você pode pesquisar os campos do autor ou do conteúdo com texto de formato livre, mesmo com espaços, da seguinte forma:

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

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

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

Como os dados são gravados diretamente no DynamoDB, você ainda pode realizar operações de pesquisa de item ou lista eficientes na tabela com as consultas allPost{...} e getPost{...}. Essa pilha usa o seguinte código de exemplo para transmissões do 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.'

Em seguida, você pode usar os streams do DynamoDB para anexá-los a uma tabela do DynamoDB com uma chave primária de, e qualquer alteração na origem do DynamoDB será id transmitida para o seu domínio de serviço. OpenSearch Para obter mais informações sobre como configurar isso, consulte a documentação de Transmissões do DynamoDB.