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à.

Utilizzo dei OpenSearch resolver Amazon Service in AWS AppSync

AWS AppSync supporta l'utilizzo OpenSearch di Amazon Service da domini che hai fornito nel tuo AWS account, a condizione che non esistano all'interno di un. VPC Dopo che sono stati assegnati i domini, è possibile connettersi a essi tramite un'origine dati, a quel punto è possibile configurare un resolver nello schema per eseguire operazioni di GraphQL, come ad esempio query, mutazioni e iscrizioni. Questo tutorial fornirà una descrizione di alcuni esempi comuni.

Per ulteriori informazioni, consulta il Resolver Mapping Template Reference per. OpenSearch

Impostazione One-Click

Per configurare automaticamente un endpoint GraphQL con AWS AppSync Amazon OpenSearch Service configurato, puoi utilizzare questo modello: AWS CloudFormation

Una volta completata la AWS CloudFormation distribuzione, puoi passare direttamente all'esecuzione di query e mutazioni GraphQL.

Crea un nuovo dominio di servizio OpenSearch

Per iniziare con questo tutorial, è necessario un dominio di OpenSearch servizio esistente. Se non si dispone di un dominio, è possibile usare il campione seguente. Tieni presente che possono essere necessari fino a 15 minuti per creare un dominio di OpenSearch servizio prima di poter passare all'integrazione con una fonte di AWS AppSync dati.

aws cloudformation create-stack --stack-name AppSyncOpenSearch \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/ESResolverCFTemplate.yaml \
--parameters ParameterKey=OSDomainName,ParameterValue=ddtestdomain ParameterKey=Tier,ParameterValue=development \
--capabilities CAPABILITY_NAMED_IAM

Puoi avviare il seguente AWS CloudFormation stack nella regione US West 2 (Oregon) nel tuo account: AWS

Configura l'origine dati per il servizio OpenSearch

Dopo aver creato il dominio OpenSearch Service, accedi a AWS AppSync GraphQL API e scegli la scheda Data Sources. Scegli Nuovo e inserisci un nome descrittivo per l'origine dati, ad esempio «oss». Quindi scegli il OpenSearch dominio Amazon per il tipo di origine dati, scegli la regione appropriata e dovresti vedere il tuo dominio OpenSearch di servizio elencato. Dopo averlo selezionato, puoi creare un nuovo ruolo e AWS AppSync assegnare le autorizzazioni appropriate al ruolo oppure puoi scegliere un ruolo esistente, che abbia la seguente politica in linea:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Stmt1234234",
            "Effect": "Allow",
            "Action": [
                "es:ESHttpDelete",
                "es:ESHttpHead",
                "es:ESHttpGet",
                "es:ESHttpPost",
                "es:ESHttpPut"
            ],
            "Resource": [
                "arn:aws:es:REGION:ACCOUNTNUMBER:domain/democluster/*"
            ]
        }
    ]
}

Dovrai anche stabilire una relazione di fiducia con per quel ruolo: AWS AppSync

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "appsync.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Inoltre, il dominio OpenSearch Service ha una propria politica di accesso che puoi modificare tramite la console di Amazon OpenSearch Service. Dovrai aggiungere una politica simile alla seguente, con le azioni e le risorse appropriate per il dominio del OpenSearch servizio. Tieni presente che il ruolo Principal sarà il ruolo dell'origine AppSync dati, che se lasci che sia la console a crearlo, può essere trovato nella IAM console.

{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Effect": "Allow",
        "Principal": {
            "AWS": "arn:aws:iam::ACCOUNTNUMBER:role/service-role/APPSYNC_DATASOURCE_ROLE"
        },
        "Action": [
            "es:ESHttpDelete",
            "es:ESHttpHead",
            "es:ESHttpGet",
            "es:ESHttpPost",
            "es:ESHttpPut"
        ],
        "Resource": "arn:aws:es:REGION:ACCOUNTNUMBER:domain/DOMAIN_NAME/*"
        }
    ]
}

Collegamento di un Resolver

Ora che l'origine dati è connessa al tuo dominio OpenSearch Service, puoi connetterla allo schema GraphQL con un resolver, come mostrato nell'esempio seguente:

 schema {
   query: Query
   mutation: Mutation
 }

 type Query {
   getPost(id: ID!): Post
   allPosts: [Post]
 }

 type Mutation {
   addPost(id: ID!, author: String, title: String, url: String, ups: Int, downs: Int, content: String): AWSJSON
 }

type Post {
  id: ID!
  author: String
  title: String
  url: String
  ups: Int
  downs: Int
  content: String
}
...

Si noti che vi è un tipo Post definito dall'utente con un campo di id. Negli esempi seguenti, supponiamo che esista un processo (che può essere automatizzato) per inserire questo tipo nel dominio del OpenSearch servizio, che verrebbe mappato alla radice del percorso di/post/_doc, where post è l'indice. Da questo percorso principale, è possibile eseguire ricerche su singoli documenti, ricerche con caratteri jolly o ricerche su più documenti con /id/post* un percorso di. /post/_search Ad esempio, se avete un altro tipo chiamatoUser, potete indicizzare i documenti in base a un nuovo indice chiamatouser, quindi eseguire ricerche con un percorso di. /user/_search

Dall'editor dello schema nella AWS AppSync console, modifica lo Posts schema precedente per includere una searchPosts query:

type Query {
  getPost(id: ID!): Post
  allPosts: [Post]
  searchPosts: [Post]
}

Salvare lo schema. Sul lato destro, per searchPosts, scegliere Allega resolver. Nel menu Azione, scegli Update runtime, quindi scegli Unit Resolver (VTLsolo). Quindi, scegli la fonte dei dati OpenSearch del servizio. Nella sezione modello di mappatura della richiesta, selezionare il menu a discesa per Post della query per ottenere un modello di base. Modificare il path in /post/_search. Avrà un aspetto simile al seguente:

{
    "version":"2017-02-28",
    "operation":"GET",
    "path":"/post/_search",
    "params":{
        "headers":{},
        "queryString":{},
        "body":{
            "from":0,
            "size":50
        }
    }
}

Ciò presuppone che lo schema precedente contenga documenti che sono stati indicizzati in OpenSearch Service sotto il campo. post Se si strutturano i dati in modo diverso, è necessario aggiornarli di conseguenza.

Nella sezione del modello di mappatura delle risposte, è necessario specificare il _source filtro appropriato se si desidera recuperare i risultati dei dati da una query di OpenSearch servizio e tradurli in GraphQL. Usare il modello seguente:

[
    #foreach($entry in $context.result.hits.hits)
    #if( $velocityCount > 1 ) , #end
    $utils.toJson($entry.get("_source"))
    #end
]

Modificare le ricerche

Il modello di mappatura della richiesta precedente esegue una semplice query per tutti i record. Se si desidera eseguire la ricerca per un autore specifico e se si desidera, inoltre, che l'autore sia un argomento definito nella query di GraphQL, Nell'editor di schemi della AWS AppSync console, aggiungi una allPostsByAuthor query:

type Query {
  getPost(id: ID!): Post
  allPosts: [Post]
  allPostsByAuthor(author: String!): [Post]
  searchPosts: [Post]
}

Ora scegli Attach resolver e seleziona l'origine dati del OpenSearch servizio, ma usa il seguente esempio nel modello di mappatura delle risposte:

{
    "version":"2017-02-28",
    "operation":"GET",
    "path":"/post/_search",
    "params":{
        "headers":{},
        "queryString":{},
        "body":{
            "from":0,
            "size":50,
            "query":{
                "match" :{
                    "author": $util.toJson($context.arguments.author)
                }
            }
        }
    }
}

Si noti che body viene popolato con una query del termine per il campo author, che è già passato attraverso il client come argomento. È possibile facoltativamente avere informazioni preinserite, come ad esempio il testo standard, o anche l'uso di altre utilità.

Se si usa questo resolver, compilare il modello di mappatura della risposta con le stesse informazioni dell'esempio precedente.

Aggiungere dati al servizio OpenSearch

Potresti voler aggiungere dati al tuo dominio di OpenSearch servizio come risultato di una mutazione GraphQL. Si tratta di un meccanismo potente per le ricerche e altri scopi. Poiché è possibile utilizzare gli abbonamenti GraphQL per rendere i dati in tempo reale, funge da meccanismo per notificare ai clienti gli aggiornamenti dei dati nel dominio di servizio. OpenSearch

Torna alla pagina Schema nella AWS AppSync console e seleziona Attach resolver per la mutazione. addPost() Seleziona nuovamente l'origine dati del OpenSearch servizio e utilizza il seguente modello di mappatura delle risposte per lo schema: Posts

{
    "version":"2017-02-28",
    "operation":"PUT",
    "path": $util.toJson("/post/_doc/$context.arguments.id"),
    "params":{
        "headers":{},
        "queryString":{},
        "body":{
            "id": $util.toJson($context.arguments.id),
            "author": $util.toJson($context.arguments.author),
            "ups": $util.toJson($context.arguments.ups),
            "downs": $util.toJson($context.arguments.downs),
            "url": $util.toJson($context.arguments.url),
            "content": $util.toJson($context.arguments.content),
            "title": $util.toJson($context.arguments.title)
        }
    }
}

Così come illustrato in precedenza, questo è un esempio di come i dati potrebbero essere strutturati. Se si dispone di nomi di campi o di indici diversi, è necessario aggiornare il path e il body in base alle esigenze. In questo esempio viene inoltre illustrato come usare $context.arguments per popolare il modello dagli argomenti della mutazione di GraphQL.

Prima di proseguire, utilizzate il seguente modello di mappatura delle risposte, che restituirà come output il risultato dell'operazione di mutazione o le informazioni sull'errore:

#if($context.error)
    $util.toJson($ctx.error)
#else
    $util.toJson($context.result)
#end

Recupero di un documento individuale

Infine, se desideri utilizzare la getPost(id:ID) query nel tuo schema per restituire un singolo documento, trova questa query nell'editor di schemi della AWS AppSync console e scegli Attach resolver. Seleziona nuovamente l'origine dati del OpenSearch servizio e utilizza il seguente modello di mappatura:

{
    "version":"2017-02-28",
    "operation":"GET",
    "path": $util.toJson("post/_doc/$context.arguments.id"),
    "params":{
        "headers":{},
        "queryString":{},
        "body":{}
    }
}

Poiché il path sopra indicato usa l'argomento id con un corpo vuoto, questo restituisce il singolo documento. Tuttavia, è necessario usare il seguente modello di mappatura della risposta, perché ora si restituisce un elemento singolo e non un elenco:

$utils.toJson($context.result.get("_source"))

Eseguire query e mutazioni

Ora dovresti essere in grado di eseguire operazioni GraphQL sul tuo dominio di OpenSearch servizio. Vai alla scheda Query della AWS AppSync console e aggiungi un nuovo record:

mutation addPost {
    addPost (
        id:"12345"
        author: "Fred"
        title: "My first book"
        content: "This will be fun to write!"
        url: "publisher website",
        ups: 100,
        downs:20 
       )
}

Vedrai il risultato della mutazione sulla destra. Allo stesso modo, ora puoi eseguire una searchPosts query sul tuo dominio OpenSearch di servizio:

query searchPosts {
    searchPosts {
        id
        title
        author
        content
    }
}

Best practice