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

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

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

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.

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:

Configurar fonte de dados para OpenSearch serviço

Depois que o domínio OpenSearch Service for criado, navegue até seu AWS AppSync GraphQL API 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:

{
    "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ê 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, poderá ser encontrada no 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/*"
        }
    ]
}

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 tempo de execução e, em seguida, escolha Resolvedor de unidades (VTLsomente). 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 esquemas do AWS AppSync console, adicione uma allPostsByAuthor consulta:

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.

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, 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

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 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 de OpenSearch serviço. 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