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 di Amazon OpenSearch 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 la nostra guida di riferimento alla funzione [JavaScript resolver per](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-elasticsearch-js.html). OpenSearch ## 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 la creazione di 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 [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/ESResolverCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/ESResolverCFTemplate.yaml) ## Configura una fonte di dati per Service OpenSearch Dopo aver creato il dominio OpenSearch Service, accedi all'API AWS AppSync GraphQL e scegli la scheda **Data Sources**. Scegli **Crea origine dati** 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 di OpenSearch 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, con la seguente politica in linea: Dovrai inoltre stabilire una relazione di fiducia con per quel ruolo: AWS AppSync ------ #### [ JSON ] **** ``` { "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. È necessario aggiungere una politica simile a quella riportata di seguito con le azioni e le risorse appropriate per il dominio del OpenSearch servizio. Tieni presente che il ruolo **Principal** sarà il ruolo dell'origine AWS AppSync dati, che può essere trovato nella console IAM se lasci che sia la console a crearlo. ## 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: ``` 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 di OpenSearch servizio, che verrebbe mappato alla radice del percorso in `/post/_doc` cui si `post` trova 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 chiamato`User`, potete indicizzare i documenti in base a un nuovo indice chiamato`user`, 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. **Nel **riquadro Resolver, trova `searchPosts` e** scegli Allega.** Scegli la fonte dei dati OpenSearch del servizio e salva il resolver. Aggiorna il codice del tuo resolver utilizzando lo snippet seguente: ``` import { util } from '@aws-appsync/utils' /** * Searches for documents by using an input term * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the request */ export function request(ctx) { return { operation: 'GET', path: `/post/_search`, params: { body: { from: 0, size: 50 } }, } } /** * Returns the fetched items * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the result */ export function response(ctx) { if (ctx.error) { util.error(ctx.error.message, ctx.error.type) } return ctx.result.hits.hits.map((hit) => hit._source) } ``` Ciò presuppone che lo schema precedente contenga documenti che sono stati indicizzati in Service sotto il campo. OpenSearch `post` Se strutturi i dati in modo diverso, dovrai aggiornarli di conseguenza. ## Modificare le ricerche Il precedente gestore di richieste del resolver esegue una semplice interrogazione per tutti i record. Se si desidera eseguire la ricerca per un autore specifico Inoltre, supponiamo che tu voglia che quell'autore sia un argomento definito nella tua query GraphQL. Nell'editor dello **schema** della AWS AppSync console, aggiungi una `allPostsByAuthor` query: ``` type Query { getPost(id: ID!): Post allPosts: [Post] allPostsByAuthor(author: String!): [Post] searchPosts: [Post] } ``` **Nel **riquadro Resolver**, trova `allPostsByAuthor` e scegli Allega.** Scegli l'origine dati del OpenSearch servizio e utilizza il seguente codice: ``` import { util } from '@aws-appsync/utils' /** * Searches for documents by `author` * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the request */ export function request(ctx) { return { operation: 'GET', path: '/post/_search', params: { body: { from: 0, size: 50, query: { match: { author: ctx.args.author } }, }, }, } } /** * Returns the fetched items * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the result */ export function response(ctx) { if (ctx.error) { util.error(ctx.error.message, ctx.error.type) } return ctx.result.hits.hits.map((hit) => hit._source) } ``` Si noti che `body` viene popolato con una query del termine per il campo `author`, che è già passato attraverso il client come argomento. Facoltativamente, puoi utilizzare informazioni precompilate, come testo standard. ## 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é puoi utilizzare gli abbonamenti GraphQL per [rendere i tuoi dati in tempo reale](aws-appsync-real-time-data.md), può fungere da meccanismo per notificare ai clienti gli aggiornamenti dei dati nel tuo dominio di servizio. OpenSearch Torna alla pagina **Schema** nella AWS AppSync console e seleziona **Allega** per la mutazione. `addPost()` Seleziona nuovamente l'origine dati del OpenSearch servizio e utilizza il codice seguente: ``` import { util } from '@aws-appsync/utils' /** * Searches for documents by `author` * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the request */ export function request(ctx) { return { operation: 'PUT', path: `/post/_doc/${ctx.args.id}`, params: { body: ctx.args }, } } /** * Returns the inserted post * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the result */ export function response(ctx) { if (ctx.error) { util.error(ctx.error.message, ctx.error.type) } return ctx.result } ``` Come in precedenza, questo è un esempio di come potrebbero essere strutturati i dati. Se hai nomi o indici di campo diversi, devi aggiornare `path` and`body`. Questo esempio mostra anche come utilizzare`context.arguments`, che può anche essere scritto come`ctx.args`, nel gestore delle richieste. ## Recupero di un singolo documento **Infine, se desideri utilizzare la `getPost(id:ID)` query nello schema per restituire un singolo documento, trova questa query nell'editor di **schemi** della AWS AppSync console e scegli Allega.** Seleziona nuovamente l'origine dati del OpenSearch servizio e utilizza il seguente codice: ``` import { util } from '@aws-appsync/utils' /** * Searches for documents by `author` * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the request */ export function request(ctx) { return { operation: 'GET', path: `/post/_doc/${ctx.args.id}`, } } /** * Returns the post * @param {import('@aws-appsync/utils').Context} ctx the context * @returns {*} the result */ export function response(ctx) { if (ctx.error) { util.error(ctx.error.message, ctx.error.type) } return ctx.result._source } ``` ## Esegui interrogazioni 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 search { searchPosts { id title author content } } ``` ## Best practice + OpenSearch Il servizio deve essere utilizzato per l'interrogazione dei dati, non come database principale. [Potresti voler utilizzare OpenSearch Service insieme ad Amazon DynamoDB, come indicato in Combined GraphQL Resolvers.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-combining-graphql-resolvers-js.html) + Concedi l'accesso al tuo dominio solo consentendo al ruolo di servizio di accedere al cluster. AWS AppSync + È possibile iniziare con una soluzione di base in fase di sviluppo, con il cluster dal prezzo più basso, e quindi spostarsi in un cluster più grande con elevata disponibilità quando si passa alla produzione.