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 **Nota** Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) 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 il [Resolver Mapping Template Reference](resolver-mapping-template-reference-elasticsearch.md#aws-appsync-resolver-mapping-template-reference-elasticsearch) per. OpenSearch ## Impostazione One-Click Per configurare automaticamente un endpoint GraphQL con AWS AppSync Amazon OpenSearch Service configurato, puoi utilizzare questo modello: AWS CloudFormation [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/appsynces.yml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/appsynces.yml) Una volta completata la AWS CloudFormation distribuzione, puoi passare direttamente all'esecuzione di query e mutazioni [GraphQL](#tutorial-elasticsearch-resolvers-perform-queries-mutations). ## 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 l'origine dei dati per il servizio OpenSearch Dopo aver creato il dominio OpenSearch Service, accedi all'API AWS AppSync GraphQL 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: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1234234", "Effect": "Allow", "Action": [ "es:ESHttpDelete", "es:ESHttpHead", "es:ESHttpGet", "es:ESHttpPost", "es:ESHttpPut" ], "Resource": [ "arn:aws:es:us-east-1:111122223333:domain/democluster/*" ] } ] } ``` ------ Dovrai anche 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. 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 console IAM. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111122223333:role/service-role/APPSYNC_DATASOURCE_ROLE" }, "Action": [ "es:ESHttpDelete", "es:ESHttpHead", "es:ESHttpGet", "es:ESHttpPost", "es:ESHttpPut" ], "Resource": "arn:aws:es:us-east-1:111122223333: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 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. Sul lato destro, per `searchPosts`, scegliere **Allega resolver**. Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (solo VTL**). Quindi, scegli la fonte dei dati del OpenSearch 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 dello schema della console di AWS AppSync aggiungere una query `allPostsByAuthor`: ``` 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à](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference). 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](aws-appsync-real-time-data.md), 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 procedere, 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 si desidera usare la query `getPost(id:ID)` nello schema per restituire un documento singolo, trovare questa query nell'editor dello schema della console di AWS AppSync e selezionare **Allega 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 + 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.](tutorial-combining-graphql-resolvers.md#aws-appsync-tutorial-combining-graphql-resolvers) + Concedi l'accesso al tuo dominio solo permettendo 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.