As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Usando resolvedores OpenSearch do Amazon Service em AWS AppSync **nota** Agora, oferecemos suporte principalmente ao runtime do APPSYNC\$1JS e sua documentação. Considere usar o runtime do APPSYNC\$1JS e seus guias disponíveis [aqui](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html). AWS AppSync suporta o uso do Amazon OpenSearch Service a partir de domínios que você provisionou em sua própria AWS conta, desde que eles não existam dentro de uma VPC. Assim que os domínios forem provisionados, conecte-se a eles usando uma fonte de dados, no momento em que pode configurar um resolvedor no esquema para realizar operações do GraphQL, como consultas, mutações e assinaturas. Esse tutorial apresentará alguns exemplos comuns. Para obter mais informações, consulte a [Referência do modelo de mapeamento do Resolver para OpenSearch](resolver-mapping-template-reference-elasticsearch.md#aws-appsync-resolver-mapping-template-reference-elasticsearch). ## Configuração com um clique Para configurar automaticamente um endpoint do GraphQL com o AWS AppSync Amazon OpenSearch Service configurado, você pode usar este modelo: 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) Após a conclusão da AWS CloudFormation implantação, você pode pular diretamente para a execução de consultas e mutações do [GraphQL](#tutorial-elasticsearch-resolvers-perform-queries-mutations). ## Criar um novo domínio OpenSearch de serviço Para começar com este tutorial, você precisa de um domínio OpenSearch de serviço existente. Caso não tenha um, use o exemplo a seguir. Observe que pode levar até 15 minutos para que um domínio OpenSearch de serviço seja criado antes que você possa prosseguir com a integração com uma fonte de AWS AppSync dados. ``` 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 ``` Você pode lançar a seguinte AWS CloudFormation pilha na região Oeste dos EUA 2 (Oregon) em sua AWS conta: [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) ## Configurar fonte de dados para OpenSearch serviço Depois que o domínio OpenSearch Service for criado, navegue até a API do AWS AppSync GraphQL e escolha a guia **Fontes de dados**. Selecione **Novo** e insira um nome acessível para a fonte de dados, como "oss". Em seguida, escolha ** OpenSearch o domínio da Amazon** para o **tipo de fonte de dados**, escolha a região apropriada e você deverá ver seu domínio OpenSearch de serviço listado. Depois de selecioná-la, você pode criar uma nova função e AWS AppSync atribuir as permissões apropriadas à função ou escolher uma função existente, que tenha a seguinte política embutida: ------ #### [ 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/*" ] } ] } ``` ------ Você também precisará estabelecer uma relação de confiança com AWS AppSync essa função: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "appsync.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Além disso, o domínio do OpenSearch serviço tem sua própria **política de acesso**, que você pode modificar por meio do console do Amazon OpenSearch Service. Você precisará adicionar uma política semelhante à seguinte, com as ações e os recursos apropriados para o domínio do OpenSearch Serviço. Observe que o **principal** será a função da fonte de AppSync dados, que, se você permitir que o console a crie, pode ser encontrada no console do 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/*" } ] } ``` ------ ## Conexão de um resolvedor Agora que a fonte de dados está conectada ao seu domínio de OpenSearch serviço, você pode conectá-la ao seu esquema do GraphQL com um resolvedor, conforme mostrado no exemplo a seguir: ``` 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 } ... ``` Observe que há um tipo `Post` definido pelo usuário com um campo de `id`. Nos exemplos a seguir, presumimos que há um processo (que pode ser automatizado) para colocar esse tipo em seu domínio de OpenSearch serviço, que seria mapeado para uma raiz de caminho de`/post/_doc`, onde `post` está o índice. A partir desse caminho raiz, você pode executar pesquisas de documento individuais, pesquisas com curingas com `/id/post*` ou pesquisas de vários documentos com um caminho de `/post/_search`. Por exemplo, se você tiver outro tipo chamado `User`, poderá indexar documentos em um novo índice chamado `user` e depois realizar pesquisas com um **caminho** de `/user/_search`. No editor de esquemas no AWS AppSync console, modifique o `Posts` esquema anterior para incluir uma consulta: `searchPosts` ``` type Query { getPost(id: ID!): Post allPosts: [Post] searchPosts: [Post] } ``` Salve o esquema. À direita, em `searchPosts`, selecione **Anexar resolvedor**. No **menu Ação**, escolha **Atualizar runtime** e selecione **Resolvedor de unidade (somente VTL)**. Em seguida, escolha sua fonte OpenSearch de dados do Serviço. Na seção **modelo de mapeamento da solicitação**, selecione o menu suspenso em **Postagens de consulta** para obter um modelo base. Modifique o `path` para `/post/_search`. Ele deve ter a seguinte aparência: ``` { "version":"2017-02-28", "operation":"GET", "path":"/post/_search", "params":{ "headers":{}, "queryString":{}, "body":{ "from":0, "size":50 } } } ``` Isso pressupõe que o esquema anterior tenha documentos que foram indexados no OpenSearch Serviço sob o campo. `post` Se você estruturar os dados de forma diferente, será necessário atualizar de forma adequada. Na seção do **modelo de mapeamento de resposta**, você precisa especificar o `_source` filtro apropriado se quiser recuperar os resultados dos dados de uma consulta de OpenSearch serviço e traduzir para o GraphQL. Use o modelo a seguir: ``` [ #foreach($entry in $context.result.hits.hits) #if( $velocityCount > 1 ) , #end $utils.toJson($entry.get("_source")) #end ] ``` ## Modificação das pesquisas O modelo de mapeamento da solicitação anterior executa uma consulta simples para todos os registros. Digamos que você queira pesquisar um autor específico. Além disso, digamos que queira que esse autor seja um argumento definido na consulta do GraphQL. No editor de esquema do console do AWS AppSync, adicione uma consulta `allPostsByAuthor`: ``` type Query { getPost(id: ID!): Post allPosts: [Post] allPostsByAuthor(author: String!): [Post] searchPosts: [Post] } ``` Agora escolha **Anexar resolvedor** e selecione a fonte OpenSearch de dados do Serviço, mas use o exemplo a seguir no **modelo de mapeamento de resposta**: ``` { "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) } } } } } ``` Observe que o `body` é preenchido com uma consulta de termo para o campo `author`, que é enviada a partir do cliente como um argumento. Também é possível ter informações pré-preenchidas, como texto padrão, ou até mesmo usar outros [utilitários](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference). Se estiver usando esse resolvedor, preencha o **modelo de mapeamento da resposta** com as mesmas informações que o exemplo anterior. ## Adicionando dados ao OpenSearch serviço Talvez você queira adicionar dados ao seu domínio de OpenSearch serviço como resultado de uma mutação do GraphQL. Esse é um poderoso mecanismo para pesquisa e outras finalidades. Como você pode usar assinaturas do GraphQL para [tornar seus dados em tempo real](aws-appsync-real-time-data.md), ele serve como um mecanismo para notificar os clientes sobre atualizações nos dados em seu domínio de serviço. OpenSearch Retorne à página **Esquema** no AWS AppSync console e selecione **Anexar resolvedor** para a `addPost()` mutação. Selecione a fonte OpenSearch de dados do Serviço novamente e use o seguinte **modelo de mapeamento de resposta** para o `Posts` esquema: ``` { "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) } } } ``` Como antes, este é um exemplo de como os dados podem ser estruturados. Se tiver diferentes nomes de campos ou índices, é necessário atualizar o `path` e o `body` conforme apropriado. Esse exemplo também mostra como usar `$context.arguments` para preencher o modelo a partir dos argumentos da mutação do GraphQL. Antes de prosseguir, use o seguinte modelo de mapeamento de resposta, que retornará o resultado da operação de mutação ou informações de erro como saída: ``` #if($context.error) $util.toJson($ctx.error) #else $util.toJson($context.result) #end ``` ## Recuperação de um único documento Finalmente, se quiser usar a consulta `getPost(id:ID)` no esquema para retornar um documento individual, encontre essa consulta no editor de esquema do console do AWS AppSync e selecione **Attach resolver (Anexar resolvedor)**. Selecione a fonte OpenSearch de dados do Serviço novamente e use o seguinte modelo de mapeamento: ``` { "version":"2017-02-28", "operation":"GET", "path": $util.toJson("post/_doc/$context.arguments.id"), "params":{ "headers":{}, "queryString":{}, "body":{} } } ``` Como o `path` acima usa o argumento `id` com um corpo vazio, isso retorna o único documento. No entanto, é necessário usar o seguinte modelo de mapeamento da resposta, pois agora você está retornando um único item, e não uma lista: ``` $utils.toJson($context.result.get("_source")) ``` ## Executar consultas e mutações Agora você deve ser capaz de realizar operações do GraphQL em seu domínio OpenSearch Service. Navegue até a guia **Consultas** do AWS AppSync console e adicione um novo registro: ``` 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 ) } ``` Você verá o resultado da mutação à direita. Da mesma forma, agora você pode executar uma `searchPosts` consulta em seu domínio OpenSearch de serviço: ``` query searchPosts { searchPosts { id title author content } } ``` ## Práticas recomendadas + OpenSearch O serviço deve ser para consultar dados, não como seu banco de dados principal. [Talvez você queira usar o OpenSearch Service em conjunto com o Amazon DynamoDB, conforme descrito em Combinação de resolvedores GraphQL.](tutorial-combining-graphql-resolvers.md#aws-appsync-tutorial-combining-graphql-resolvers) + Só conceda acesso ao seu domínio permitindo que a função AWS AppSync de serviço acesse o cluster. + Você pode começar pequeno no desenvolvimento, com o cluster de menor custo e, em seguida, migrar para um cluster maior com alta disponibilidade (HA) à medida que entrar na produção.