Fonte de dados do SQL do Azure para um resolvedor

APLICA-SE A: Desenvolvedor | Básico | Básico v2 | Standard | Standard v2 | Premium

A política de resolvedor sql-data-source configura uma solicitação T-SQL (Transact-SQL) para um banco de dados SQL do Azure e uma resposta opcional para resolver dados para um tipo de objeto e campo em um esquema do GraphQL. O esquema deve ser importado para o Gerenciamento de API como uma API do GraphQL.

Declaração de política

<sql-data-source> 
    <connection-info>
        <connection-string use-managed-identity="true | false">
            Azure SQL connection string
        </connection-string>
        <include-fragment>...include-fragment policy configuration...</include-fragment>
        <authentication-certificate>...authentication-certificate policy configuration...</authentication-certificate>     
    </connection-info>
    <include-fragment>...include-fragment policy configuration...</include-fragment>
    <request single-result="true | false">
        <include-fragment>...include-fragment policy configuration...</include-fragment>
        <set-body>...set-body policy configuration...</set-body>
        <sql-statement>T-SQL query</sql-statement>
        <parameters>
            <parameter sql-type="parameter type" name="Query parameter name in @ notation">
                "Query parameter value or expression"
            </parameter>
            <!-- if there are multiple parameters, then add additional parameter elements -->
        </parameters>
    </request>
    <response>
        <include-fragment>...include-fragment policy configuration...</include-fragment>
        <set-body>...set-body policy configuration...</set-body>
        <publish-event>...publish-event policy configuration...</publish-event>
    </response>
</sql-data-source> 

Elementos

elementos de connection-info

atributos de connection-string

atributo de solicitação

elementos de solicitação

atributos de parâmetro

elementos de resposta

Uso

• Escopos de política: resolvedor do GraphQL
• Gateways: clássico, v2

Observações de uso

• Para configurar e gerenciar um resolvedor com essa política, confira Configurar um resolvedor do GraphQL.
• Essa política é invocada somente ao resolver um único campo em um tipo de operação correspondente no esquema.

Configurar a integração de identidade gerenciada com o SQL do Azure

Você pode configurar uma identidade gerenciada atribuída pelo sistema do Gerenciamento de API para ter acesso ao SQL do Azure em vez de configurar a autenticação do SQL com nome de usuário e senha. Para obter informações em segundo plano, consulte Configurar e gerenciar a autenticação do Microsoft Entra com o SQLdo Azure.

Pré-requisitos

• Habilite uma identidade gerenciada atribuída pelo sistema na instância do Gerenciamento de API.

Habilitar o acesso à ID do Microsoft Entra

Habilite a autenticação do Microsoft Entra no Banco de Dados SQL atribuindo um usuário do Microsoft Entra como administrador do servidor.

1. No portal, acesse o servidor SQL do Azure.
2. Selecione ID do Microsoft Entra.
3. Selecione Definir administrador e selecione você mesmo ou um grupo ao qual você pertence.
4. Selecione Salvar.

Atribuir funções

1. No portal, acesse o recurso de banco de dados SQL do Azure.

2. Selecione Editor de consultas (versão prévia).

3. Faça logon usando a autenticação do Active Directory.

4. Execute o script SQL a seguir. Substitua <identity-name> pelo nome da sua instância do Gerenciamento de API.

   CREATE USER [<identity-name>] FROM EXTERNAL PROVIDER;
   ALTER ROLE db_datareader ADD MEMBER [<identity-name>];
   ALTER ROLE db_datawriter ADD MEMBER [<identity-name>];
   ALTER ROLE db_ddladmin ADD MEMBER [<identity-name>];
   GO
   

Exemplos

Esquema de exemplo

Os exemplos nesta seção são resolvedores para o seguinte esquema GraphQL:

type Family {
  id: Int!
  name: String!
}

type Person {
  id: Int!
  name: String!
}

type PersonQueryResult {
  items: [Person]  
}

type Query {
  familyById(familyId: Int!): Family
  familyMembers(familyId: Int!): PersonQueryResult
}

type Mutation {
  createFamily(familyId: Int!, familyName: String!): Family
}

Resolvedor para consulta GraphQL usando solicitação T-SQL de resultado único

O exemplo a seguir resolve uma consulta GraphQL fazendo uma solicitação T-SQL de resultado único para um banco de dados SQL do Azure de back-end. A cadeia de conexão usa a autenticação do SQL com nome de usuário e senha e é fornecida usando um valor nomeado. A resposta é retornada como um único objeto JSON que representa uma única linha.

<sql-data-source>
    <connection-info>
        <connection-string>
            {{my-connection-string}}
        </connection-string>
    </connection-info>
    <request single-result="true">
        <sql-statement>
            SELECT 
                f.[Id] AS [id]
                f.[Name] AS [name]
            WHERE @familyId = f.[Id] 
        </sql-statement> 
        <parameters> 
            <parameter name="@familyId">       
                @(context.GraphQL.Arguments["id"])
            </parameter> 
        </parameters> 
    </request>
    <response />
</sql-data-source>

Resolvedor para consulta GraphQL com resposta de consulta de várias linhas transformada

O exemplo a seguir resolve uma consulta GraphQL usando uma consulta T-SQL para um banco de dados SQL do Azure. A conexão com o banco de dados usa a identidade gerenciada atribuída pelo sistema da instância do Gerenciamento de API. A identidade deve ser configurada para acessar o banco de dados SQL do Azure.

O parâmetro de consulta é acessado usando a variável de contexto context.GraphQL.Arguments. A resposta da consulta de várias linhas é transformada usando a política set-body com um modelo Liquid.

<sql-data-source> 
    <connection-info>
        <connection-string use-managed-identity="true">
            Server=tcp:{your_server_name}.database.windows.net,1433;Initial Catalog={your_database_name}; 
        </connection-string>
    </connection-info> 
    <request> 
        <sql-statement> 
            SELECT 
                p.[Id] AS [Id] 
                p.[FirstName] AS [FirstName] 
                p.[LastName] AS [LastName] 
            FROM [Person] p 
            JOIN [Family] f ON p.[FamilyId] = f.[Id] 
            WHERE @familyId = f.[Id] 
        </sql-statement> 
        <parameters> 
            <parameter name="@familyId">       
                @(context.GraphQL.Arguments["id"])
            </parameter> 
        </parameters> 
    </request> 
    <response> 
        <set-body template="liquid"> 
            { 
                "items": [ 
                    {% JSONArray For person in body.items %} 
                        "id": "{{ person.id }}" 
                        "name": "{{ person.firstName }} + "" "" + {{body.lastName}}" 
                    {% endJSONArrayFor %} 
                ] 
            } 
        </set-body> 
  </response> 
</sql-data-source>

Resolvedor para a mutação do GraphQL

O exemplo a seguir resolve uma mutação do GraphQL usando uma instrução T-SQL INSERT para inserir uma linha em um banco de dados SQL do Azure. A conexão com o banco de dados usa a identidade gerenciada atribuída pelo sistema da instância do Gerenciamento de API. A identidade deve ser configurada para acessar o banco de dados SQL do Azure.

<sql-data-source> 
    <connection-info>
        <connection-string use-managed-identity="true">
            Server=tcp:{your_server_name}.database.windows.net,1433;Initial Catalog={your_database_name};</connection-string>
    </connection-info> 
    <request single-result="true"> 
        <sql-statement> 
                INSERT INTO [dbo].[Family]
                       ([Id]
                       ,[Name])
                VALUES
                       (@familyId
                       , @familyName)

                SELECT
                    f.[Id] AS [id],
                    f.[Name] AS [name]
                FROM [Family] f
                WHERE @familyId = f.[Id]
        </sql-statement> 
        <parameters> 
            <parameter name="@familyId">       
                @(context.GraphQL.Arguments["id"])
            </parameter>
            <parameter name="@familyName">       
                @(context.GraphQL.Arguments["name"])
            </parameter> 
        </parameters> 
    </request>    
</sql-data-source>

Políticas relacionadas

• Resolvedores do GraphQL

Conteúdo relacionado

Para obter mais informações sobre como trabalhar com políticas, consulte:

• Tutorial: Transformar e proteger sua API
• Referência de Política para uma lista completa das instruções de política e suas configurações
• Expressões de política
• Definir ou editar políticas
• Reutilizar configurações de política
• Repositório de snippets de política
• Criar políticas usando o Microsoft Copilot no Azure