Usando resolvedores OpenSearch do Amazon Service em AWS AppSync

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

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

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 nossa referência JavaScript de função de resolução para OpenSearch.

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 US-West-2 (Oregon) em sua conta: AWS

Configurar uma fonte de dados para o 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. Escolha Criar fonte de dados e insira um nome amigável para a fonte de dados, como “oss”. Em seguida, escolha o OpenSearch 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 atribuir AWS AppSync as permissões apropriadas à função ou escolher uma função existente, que tenha a seguinte política embutida:

{
    "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/*"
            ]
        }
    ]
}

Você também precisará estabelecer uma relação de confiança com AWS AppSync essa função:

{
    "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ê deve adicionar uma política semelhante à abaixo 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 AWS AppSync dados, que pode ser encontrada no console do IAM se você permitir que o console a crie.

{
    "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/*"
        }
    ]
}

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:

 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. No painel Resolvedores, encontre searchPosts e escolha Anexar. Escolha sua fonte OpenSearch de dados de serviço e salve o resolvedor. Atualize o código do seu resolvedor usando o trecho abaixo:

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)
}

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.

Modificação das pesquisas

O manipulador de solicitação do resolvedor 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 esquemas do AWS AppSync console, adicione uma allPostsByAuthor consulta:

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

No painel Resolvedores, encontre allPostsByAuthor e escolha Anexar. Escolha a fonte OpenSearch de dados do Serviço e use o código a seguir:

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)
}

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 usar informações pré-preenchidas, como texto padrão.

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, ele pode servir como um mecanismo para notificar os clientes sobre atualizações nos dados em seu domínio de serviço. OpenSearch

Volte para a página Esquema no AWS AppSync console e selecione Anexar para a addPost() mutação. Selecione a fonte OpenSearch de dados do serviço novamente e use o código a seguir:

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
}

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. Este exemplo também mostra como usar context.arguments, que também pode ser escrito como ctx.args, em seu manipulador de solicitações.

Recuperação de um único documento

Por fim, se você quiser usar a getPost(id:ID) consulta em seu esquema para retornar um documento individual, localize essa consulta no editor de esquemas do AWS AppSync console e escolha Anexar. Selecione a fonte OpenSearch de dados do serviço novamente e use o código a seguir:

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
}

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 search {
    searchPosts {
        id
        title
        author
        content
    }
}

Práticas recomendadas