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 da uno schema, hai la possibilità di risolvere o manipolare i tuoi tipi di GraphQL attraverso diverse fonti di dati, consentendoti di combinare uno schema per soddisfare al meglio le tue esigenze.

Gli scenari seguenti mostrano come combinare e abbinare le fonti di dati nello schema. Prima di iniziare, dovresti avere familiarità con la configurazione di sorgenti di dati e resolver per Amazon AWS Lambda DynamoDB e Amazon Service. OpenSearch

Schema di esempio

Lo schema seguente ha un tipo Post di tre Query Mutation operazioni ciascuna:

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, avresti un totale di sei resolver, ognuno dei quali necessita di una fonte di dati. Un modo per risolvere questo problema sarebbe collegarli a una singola tabella Amazon DynamoDB, Posts chiamata, in cui AllPost il campo esegue una scansione e il campo esegue una query (JavaScriptvedi riferimento searchPosts alla funzione resolver per DynamoDB). Tuttavia, non sei limitato ad Amazon DynamoDB; esistono diverse fonti di dati come Lambda OpenSearch o Service per soddisfare le tue esigenze aziendali.

Alterazione dei dati tramite resolver

Potrebbe essere necessario restituire i risultati da un database di terze parti non supportato direttamente dalle fonti di dati. AWS AppSync Potrebbe inoltre essere necessario eseguire modifiche complesse sui dati prima che vengano restituiti ai API client. Ciò potrebbe essere causato da una formattazione impropria dei tipi di dati, ad esempio differenze di data e ora sui client o dalla gestione di problemi di compatibilità con le versioni precedenti. In questo caso, la soluzione appropriata è collegare AWS Lambda le funzioni come fonte di dati all'utente AWS AppSync API. A scopo illustrativo, nell'esempio seguente, una AWS Lambda funzione manipola i dati recuperati da un archivio dati di terze parti:

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

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

    // return to AppSync
    return data
};

Questa è una funzione di Lambda perfettamente valida e potrebbe essere associata al campo AllPost 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 È sufficiente collegare il searchPosts resolver all'origine dati del OpenSearch servizio e restituire i risultati della ricerca (dai dati originati in DynamoDB) utilizzando una query GraphQL. Ciò può rivelarsi estremamente efficace quando si aggiungono operazioni di ricerca avanzate alle applicazioni, ad esempio parole chiave, corrispondenze di parole confuse o persino 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.

Per iniziare con queste particolari fonti di dati, consulta i nostri tutorial su DynamoDB e Lambda.

Ad esempio, utilizzando lo schema del nostro tutorial precedente, la seguente mutazione aggiunge 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
  }
}

Questo scrive i dati su DynamoDB, che quindi trasmette i dati tramite Lambda ad OpenSearch Amazon Service, che poi usi per cercare 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
    }
}

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

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. allPost{...} getPost{...} Questo stack utilizza il seguente codice di esempio per i flussi 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.'

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.