Configurar um resolvedor GraphQL

APLICA-SE A: Todas as camadas de gerenciamento de API

Configure um resolvedor para recuperar ou definir dados para um campo GraphQL em um tipo de objeto especificado em um esquema GraphQL. O esquema deve ser importado para o Gerenciamento de API como uma API GraphQL.

Nota

Atualmente, esse recurso não está disponível em espaços de trabalho.

Atualmente, o Gerenciamento de API suporta resolvedores que podem acessar as seguintes fontes de dados:

Fonte de dados baseada em HTTP (REST ou SOAP API)
Banco de dados do Cosmos DB
Base de dados SQL do Azure

Aspetos importantes

Um resolvedor é um recurso que contém uma definição de política que é invocada somente quando um tipo de objeto e um campo correspondentes no esquema são executados.
Cada resolvedor resolve dados para um único campo. Para resolver dados para vários campos, configure um resolvedor separado para cada um.
As políticas com escopo de resolução são avaliadas após quaisquer políticas inbound e backend no fluxo de execução de políticas. Eles não herdam políticas de outros escopos. Para obter mais informações, consulte Políticas no Gerenciamento de API do Azure.
Você pode configurar políticas com escopo de API para uma API GraphQL, independentemente das políticas com escopo de resolutor. Por exemplo, adicione uma política validate-graphql-request ao inbound escopo para validar a solicitação antes que o resolvedor seja invocado. Configure políticas com definição específica para API na guia Políticas de API para a API.
Para suportar tipos de interface e union em resolvedores GraphQL, a resposta de back-end já deve conter o campo __typename ou ser alterada usando a política set-body para incluir __typename.

Pré-requisitos

Uma instância de gerenciamento de API existente. Crie um, caso ainda não o tenha feito.
Importe uma API GraphQL de passagem ou sintética.

Criar um resolvedor

As etapas a seguir criam um resolvedor usando uma fonte de dados baseada em HTTP. As etapas gerais são semelhantes para qualquer resolvedor que use uma fonte de dados suportada.

No portal do Azure, navegue até sua instância de Gerenciamento de API.
No menu à esquerda, selecione APIs e, em seguida, selecione o nome da sua API GraphQL.
Na guia Esquema, revise o esquema para um campo em um tipo de objeto no qual você deseja configurar um resolvedor.
1. Selecione um campo e, na margem esquerda, passe o ponteiro do mouse.
2. Selecione + Adicionar resolvedor.
Na página Criar resolvedor:
1. Atualize a propriedade Name se desejar, opcionalmente insira uma Descrição e confirme ou atualize as seleções Tipo e Campo .
2. Selecione a fonte de dados do resolvedor. Para este exemplo, selecione HTTP API.
No editor de políticas do Resolvedor, atualize a http-data-source política com elementos filho para o seu cenário.
1. Atualize o elemento necessário http-request com políticas para transformar a operação GraphQL em uma solicitação HTTP.
2. Opcionalmente, adicione um elemento http-response e adicione políticas filhas para transformar a resposta HTTP do resolvedor. Se o http-response elemento não for especificado, a resposta será retornada como uma cadeia de caracteres bruta.
3. Selecione Criar.
O resolvedor é anexado ao campo e aparece na guia Resolvedores .

Gerenciar resolvedores

Você pode listar e gerenciar os resolvedores para uma API GraphQL na guia Resolvedores da API.

Na guia Resolvedores:

A coluna 'Ligado' indica se o resolvedor está configurado para um campo que está atualmente no esquema GraphQL. Se um resolvedor não estiver vinculado, ele não poderá ser invocado.
No menu de contexto (...) de um resolvedor, localize comandos para Clonar, Editar ou Excluir um resolvedor. Clone um resolvedor listado para criar rapidamente um resolvedor semelhante que tenha como alvo um tipo e campo diferentes.
Você pode criar um novo resolvedor selecionando + Criar.

Editar e testar um resolvedor

Quando você edita um único resolvedor, a página Editar resolvedor é aberta. Pode:

Atualize a política do resolvedor e, opcionalmente, a fonte de dados. A alteração da fonte de dados substitui a política de resolução atual.
Altere o tipo e o campo a que o resolvedor se destina.
Teste e depure a configuração do resolvedor. Ao editar a política do resolvedor, selecione Executar teste para verificar a saída da fonte de dados, que pode ser validada em relação ao esquema. Se ocorrerem erros, a resposta inclui informações de solução de problemas.

Contexto do GraphQL

O contexto da solicitação e resposta do resolvedor (se especificado) difere do contexto da solicitação de API do gateway original:
- context.GraphQL As propriedades são definidas como os argumentos (Arguments) e o objeto pai (Parent) para a execução atual do resolvedor.
- O contexto da solicitação contém argumentos que são passados na consulta GraphQL como seu corpo.
- O contexto de resposta refere-se à resposta da chamada independente feita pelo resolvedor, e não ao contexto da resposta completa à solicitação do gateway. A context variável que é passada pelo pipeline de solicitação e resposta é enriquecida com o contexto GraphQL quando utilizada com uma resolução GraphQL.

contexto.GraphQL.pai

O context.GraphQL.parent é definido como o objeto pai para a execução atual do resolvedor. Considere o seguinte esquema parcial:

type Comment {
    id: ID!
    owner: string!
    content: string!
}

type Blog {
    id: ID!
    title: string!
    content: string!
    comments: [Comment]!
    comment(id: ID!): Comment
}

type Query {
    getBlog(): [Blog]!
    getBlog(id: ID!): Blog
}

Além disso, considere uma consulta GraphQL para todas as informações de um blog específico:

query {
    getBlog(id: 1) {
        title
        content
        comments {
            id
            owner
            content
        }
    }
}

Se você definir um resolvedor para o comments campo no Blog tipo, você vai querer entender qual ID de blog usar. Você pode obter o ID do blog usando context.GraphQL.Parent["id"] como mostrado no seguinte resolvedor:

<http-data-source>
    <http-request>
        <set-method>GET</set-method>
        <set-url>@($"https://data.contoso.com/api/blog/{context.GraphQL.Parent["id"]}")
        </set-url>
    </http-request>
</http-data-source>

contexto.GraphQL.Argumentos

Os argumentos para uma consulta GraphQL parametrizada são adicionados ao context.GraphQL.Arguments. Por exemplo, considere as duas consultas a seguir:

query($id: Int) {
    getComment(id: $id) {
        content
    }
}

query {
    getComment(id: 2) {
        content
    }
}

Essas consultas são duas maneiras de chamar o getComment resolvedor. O GraphQL envia a seguinte carga JSON:

{
    "query": "query($id: Int) { getComment(id: $id) { content } }",
    "variables": { "id": 2 }
}

{
    "query": "query { getComment(id: 2) { content } }"
}

Você pode definir o resolvedor da seguinte maneira:

<http-data-source>
    <http-request>
        <set-method>GET</set-method>
        <set-url>@($"https://data.contoso.com/api/comment/{context.GraphQL.Arguments["id"]}")</set-url>
    </http-request>
</http-data-source>

Para obter mais exemplos de resolvedores, consulte:

Comentários

Esta página foi útil?

Last updated on 2025-10-02