Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Combinaison de résolveurs GraphQL dans AWS AppSync

Les résolveurs et les champs d'un schéma GraphQL possèdent des relations 1:1 avec un haut niveau de flexibilité. Comme une source de données est configurée sur un résolveur indépendamment d'un schéma, vous avez la possibilité de résoudre ou de manipuler vos types de GraphQL via différentes sources de données, ce qui vous permet de combiner un schéma pour répondre au mieux à vos besoins.

Les scénarios suivants montrent comment mélanger et associer des sources de données dans votre schéma. Avant de commencer, vous devez être familiarisé avec la configuration des sources de données et des résolveurs pour AWS Lambda Amazon DynamoDB et Amazon Service. OpenSearch

Exemple de schéma

Le schéma suivant a un type Post de trois Query Mutation opérations chacune :

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
}

Dans cet exemple, vous auriez un total de six résolveurs, chacun ayant besoin d'une source de données. Une façon de résoudre ce problème serait de les connecter à une seule table Amazon DynamoDB, Posts appelée, dans laquelle le champ exécute une analyse et AllPost le champ exécute une requête (JavaScriptvoir la référence de searchPosts la fonction de résolution pour DynamoDB). Cependant, vous n'êtes pas limité à Amazon DynamoDB ; différentes sources de données, telles que Lambda OpenSearch ou Service, existent pour répondre aux besoins de votre entreprise.

Modification des données par le biais de résolveurs

Vous devrez peut-être renvoyer les résultats d'une base de données tierce qui n'est pas directement prise en charge par AWS AppSync les sources de données. Il se peut également que vous deviez effectuer des modifications complexes sur les données avant qu'elles ne soient renvoyées au (x) API client (s). Cela peut être dû à un formatage incorrect des types de données, tel que des différences d'horodatage sur les clients ou à la gestion de problèmes de rétrocompatibilité. Dans ce cas, la solution appropriée AWS AppSync API consiste à connecter des AWS Lambda fonctions en tant que source de données à la vôtre. À des fins d'illustration, dans l'exemple suivant, une AWS Lambda fonction manipule les données extraites d'un magasin de données tiers :

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

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

    // return to AppSync
    return data
};

Il s'agit d'une fonction Lambda parfaitement valide qui peut être attachée à un champ AllPost dans le schéma GraphQL afin que toute requête renvoyant tous les résultats obtienne des nombres aléatoires pour les pour et/ou les contre.

DynamoDB et service OpenSearch

Pour certaines applications, vous pouvez effectuer des mutations ou de simples requêtes de recherche sur DynamoDB et demander à un processus en arrière-plan de transférer des documents vers Service. OpenSearch Vous pouvez simplement associer le searchPosts résolveur à la source de données du OpenSearch service et renvoyer les résultats de recherche (à partir de données provenant de DynamoDB) à l'aide d'une requête GraphQL. Cela peut être extrêmement puissant lorsque vous ajoutez des opérations de recherche avancées à vos applications, telles que des mots clés, des correspondances de mots flous ou même des recherches géospatiales. Le transfert de données depuis DynamoDB peut être effectué par le biais d'ETLun processus, ou vous pouvez également diffuser des données depuis DynamoDB à l'aide de Lambda.

Pour commencer à utiliser ces sources de données spécifiques, consultez nos didacticiels DynamoDB et Lambda.

Par exemple, en utilisant le schéma de notre précédent didacticiel, la mutation suivante ajoute un élément à 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
  }
}

Cela écrit des données dans DynamoDB, qui les diffuse ensuite via Lambda vers OpenSearch Amazon Service, que vous utilisez ensuite pour rechercher des publications dans différents champs. Par exemple, comme les données se trouvent dans Amazon OpenSearch Service, vous pouvez effectuer une recherche dans les champs d'auteur ou de contenu avec du texte libre, même avec des espaces, comme suit :

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

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

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

Les données étant écrites directement dans DynamoDB, vous pouvez toujours effectuer des opérations efficaces de recherche de listes ou d'éléments par rapport à la table contenant allPost{...} les requêtes et. getPost{...} Cette pile utilise l'exemple de code suivant pour les flux 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.'

Vous pouvez ensuite utiliser des flux DynamoDB pour l'associer à une table DynamoDB avec une clé primaire de, et toute modification apportée à la source id de DynamoDB sera répercutée dans votre domaine de service. OpenSearch Pour plus d'informations sur la configuration de ce processus, consultez la Documentation DynamoDB Streams.