Associações de saída do SQL do Azure para o Azure Functions

A associação de saída do SQL do Azure permite gravar em um banco de dados.

Para obter informações sobre a instalação e detalhes de configuração, confira a visão geral.

Importante

Este artigo usa guias para dar suporte a várias versões do modelo de programação Node.js. O modelo v4 normalmente está disponível e foi projetado para oferecer uma experiência mais flexível e intuitiva para desenvolvedores de JavaScript e TypeScript. Para obter mais detalhes sobre como funciona o modelo v4, consulte o Guia do desenvolvedor do Node.js para o Azure Functions. Para conhecer as diferenças entre a v3 e a v4, consulte o Guia de migração.

Para obter um exemplo completo de ponta a ponta do uso da associação de saída SQL do Azure, consulte Respond para Banco de Dados SQL do Azure alterações usando Azure Functions.

Exemplos

O suporte do Go não está disponível para essa ligação no momento.

Você pode criar uma função C# usando um dos seguintes modos C#:

  • Modelo de trabalho isolado: função C# compilada executada em um processo de trabalho que está isolado do runtime. Um processo de trabalho isolado é necessário para dar suporte a funções C# em execução em LTS (suporte de longo prazo) e versões não LTS para .NET e .NET Framework.
  • Modelo em processo: função C# compilada que é executada no mesmo processo que o runtime do Azure Functions.
  • Script C#: usado principalmente ao criar funções C# no portal do Azure.

Importante

O suporte terminará para o modelo em processo em 10 de novembro de 2026. É altamente recomendável migrar seus aplicativos para o modelo de trabalho isolado para obter suporte completo.

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos se referem a uma classe ToDoItem e a uma tabela de banco de dados correspondente:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Para retornar várias associações de saída em nossos exemplos, criamos um tipo de retorno personalizado:

public static class OutputType
{
    [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
    public static ToDoItem ToDoItem { get; set; }
    public static HttpResponseData HttpResponse { get; set; }
}

Gatilho HTTP, gravar um registro

O exemplo a seguir mostra uma função C# que adiciona um registro a um banco de dados, usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON. O objeto de retorno é a classe OutputType que criamos para lidar com uma resposta HTTP e a associação de saída do SQL.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("PostToDo");
            logger.LogInformation("C# HTTP trigger function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            return new OutputType()
            {
                ToDoItem = toDoItem,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }
}

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma função C# que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Para usar uma associação de saída extra, adicionamos uma classe e RequestLog modificamos nossa OutputType classe:

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;

            return new OutputType()
            {
                ToDoItem = toDoItem,
                RequestLog = requestLog,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public class RequestLog {
        public DateTime RequestTimeStamp { get; set; }
        public int ItemCount { get; set; }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        [SqlOutput("dbo.RequestLog", connectionStringSetting: "SqlConnectionString")]
        public RequestLog RequestLog { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }

}

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos se referem a uma classe ToDoItem (em um arquivo ToDoItem.java separado) e a uma tabela de banco de dados correspondente:

package com.function;
import java.util.UUID;

public class ToDoItem {
    public UUID Id;
    public int order;
    public String title;
    public String url;
    public boolean completed;

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, gravar um registro em uma tabela

O exemplo a seguir mostra uma associação de saída SQL em uma função Java que adiciona um registro a uma tabela, usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON. A função usa outra dependência na biblioteca com.google.code.gson para analisar o corpo JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDo {
    @FunctionName("PostToDo")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output) {
        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);

        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        return request.createResponseBuilder(HttpStatus.CREATED).header("Content-Type", "application/json").body(output).build();
    }
}

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL em uma função JavaS que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída. A função usa outra dependência na biblioteca com.google.code.gson para analisar o corpo JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id INT IDENTITY(1,1) PRIMARY KEY,
    RequestTimeStamp DATETIME2 NOT NULL DEFAULT(GETDATE()),
    ItemCount INT NOT NULL
)

e a classe Java em RequestLog.java:

package com.function;

import java.util.Date;

public class RequestLog {
    public int Id;
    public Date RequestTimeStamp;
    public int ItemCount;

    public RequestLog() {
    }

    public RequestLog(int Id, Date RequestTimeStamp, int ItemCount) {
        this.Id = Id;
        this.RequestTimeStamp = RequestTimeStamp;
        this.ItemCount = ItemCount;
    }
}

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDoWithLog {
    @FunctionName("PostToDoWithLog")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output,
            @SQLOutput(
                name = "requestLog",
                commandText = "dbo.RequestLog",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<RequestLog> outputLog,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);
        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        RequestLog newLog = new RequestLog();
        newLog.ItemCount = 1;
        outputLog.setValue(newLog);

        return request.createResponseBuilder(HttpStatus.CREATED).header("Content-Type", "application/json").body(output).build();
    }
}

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos se referem a uma tabela de banco de dados:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, gravar registros em uma tabela

O exemplo a seguir mostra uma ligação de saída do SQL que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos se referem a uma tabela de banco de dados:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, gravar registros em uma tabela

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do PowerShell que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

Veja a seguir os dados de associação no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

A seção configuração explica essas propriedades.

Veja o seguinte exemplo de código do PowerShell para a função no arquivo run.ps1:


```powershell
using namespace System.Net

param($Request)

Write-Host "PowerShell function with SQL Output Binding processed a request."

# Update req_body with the body of the request
$req_body = $Request.Body

# Assign the value we want to pass to the SQL Output binding. 
# The -Name value corresponds to the name property in the function.json for the binding
Push-OutputBinding -Name todoItems -Value $req_body

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de entrada do SQL em um arquivo function.json e uma função do PowerShell que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Veja a seguir os dados de associação no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

A seção configuração explica essas propriedades.

Veja o seguinte exemplo de código do PowerShell para a função no arquivo run.ps1:

using namespace System.Net

param($Request)

Write-Host "PowerShell function with SQL Output Binding processed a request."

# Update req_body with the body of the request
$req_body = $Request.Body
$new_log = @{
    RequestTimeStamp = [DateTime]::Now
    ItemCount = 1
}

Push-OutputBinding -Name todoItems -Value $req_body
Push-OutputBinding -Name requestLog -Value $new_log

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos se referem a uma tabela de banco de dados:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, gravar registros em uma tabela

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do Python que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

Veja a seguir um exemplo de código python para o arquivo function_app.py:

import json
import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="AddToDo")
@app.route(route="addtodo")
@app.sql_output(arg_name="todo",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todo: func.Out[func.SqlRow]) -> func.HttpResponse:
    body = json.loads(req.get_body())
    row = func.SqlRow.from_dict(body)
    todo.set(row)

    return func.HttpResponse(
        body=req.get_body(),
        status_code=201,
        mimetype="application/json"
    )

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do Python que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Veja a seguir um exemplo de código python para o arquivo function_app.py:

from datetime import datetime
import json
import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="PostToDo")
@app.route(route="posttodo")
@app.sql_output(arg_name="todoItems",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
@app.sql_output(arg_name="requestLog",
                        command_text="[dbo].[RequestLog]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todoItems: func.Out[func.SqlRow], requestLog: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')
    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    requestLog.set(func.SqlRow({
        "RequestTimeStamp": datetime.now().isoformat(),
        "ItemCount": 1
    }))

    if req_body:
        todoItems.set(rows)
        return func.HttpResponse(
            "OK",
            status_code=201,
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            "Error accessing request body",
            status_code=400
        )

Atributos

A biblioteca C# usa o atributo SqlAttribute para declarar as associações SQL na função, que tem as seguintes propriedades:

Propriedade de atributo Descrição
CommandText Obrigatórios. O nome da tabela que está sendo gravada pela associação.
ConnectionStringSetting Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual os dados estão sendo gravados. Esse valor não é a cadeia de conexão real e, em vez disso, deve ser resolvido para uma variável de ambiente.

Anotações

Na biblioteca de runtime de funções Java, use a anotação @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) nos parâmetros cujo valor viria de um SQL do Azure. Essa anotação dá suporte aos seguintes elementos:

Elemento Descrição
commandText Obrigatórios. O nome da tabela que está sendo gravada pela associação.
connectionStringSetting Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual os dados estão sendo gravados. Esse valor não é a cadeia de conexão real e, em vez disso, deve ser resolvido para uma variável de ambiente.
nome Obrigatórios. O nome exclusivo da associação de função.

Configuração

A tabela a seguir explica as propriedades que você pode definir no objeto options transmitido para o método output.sql().

Propriedade Descrição
commandText Obrigatórios. O nome da tabela que está sendo gravada pela associação.
connectionStringSetting Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual os dados estão sendo gravados. Esse valor não é a cadeia de conexão real e, em vez disso, deve ser resolvido para uma variável de ambiente. As palavras-chave opcionais no valor da cadeia de conexão estão disponíveis para refinar a conectividade de associações do SQL.

Configuração

A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json.

Propriedade function.json Descrição
tipo Obrigatórios. Deve ser definido como sql.
direção Obrigatórios. Deve ser definido como out.
nome Obrigatórios. O nome da variável que representa a entidade no código da função.
commandText Obrigatórios. O nome da tabela que está sendo gravada pela associação.
connectionStringSetting Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual os dados estão sendo gravados. Esse valor não é a cadeia de conexão real e, em vez disso, deve ser resolvido para uma variável de ambiente. As palavras-chave opcionais no valor da cadeia de conexão estão disponíveis para refinar a conectividade de associações do SQL.

Quando você estiver desenvolvendo localmente, adicione as configurações do aplicativo no arquivo local.settings.json na coleção Values.

Uso

A propriedade CommandText é o nome da tabela em que os dados devem ser armazenados.

As associações de saída usam a instrução T-SQL MERGE que exige permissões SELECT no banco de dados de destino.

Se ocorrer uma exceção quando uma associação de saída do SQL for executada, o código de função interromperá a execução. Esse comportamento pode resultar em um código de erro sendo retornado, como um gatilho HTTP retornando um código de erro 500. Se for IAsyncCollector usado em uma função .NET, o código de função poderá lidar com exceções geradas pela chamada para FlushAsync().

Conexões

A connectionStringSetting propriedade é definida como uma chave nas configurações da aplicação que retorna um valor usado pelo runtime Functions para se conectar ao banco de dados SQL do Azure ou SQL Server usado pela extensão. O valor da configuração da propriedade de conexão depende do tipo de conexão:

  • Conexão de identidade gerenciada: A connectionStringSetting propriedade retorna uma cadeia de conexão que é usada Authentication=Active Directory Managed Identity para autenticar sem segredos. Você pode usar uma identidade gerenciada atribuída pelo sistema ou pelo usuário. Para mais informações, veja Conectar um aplicativo de função ao SQL do Azure com identidade gerenciada e Definir conexões de identidade.
  • Referência Key Vault: A connectionStringSetting configuração de propriedade retorna uma referência ao Azure Key Vault para o local onde a cadeia de conexão é mantida centralmente. Para mais informações, veja Definir conexões do Key Vault.
  • Referência de App Configuration: A connectionStringSetting configuração de propriedade retorna uma referência ao Configuração de Aplicativos do Azure que retorna uma cadeia de conexão ou uma referência ao Key Vault. Para mais informações, veja Configuração de Aplicativos do Azure no artigo de conexões.
  • Connection string: A connectionStringSetting configuração de propriedade retorna a cadeia de conexão SQL real. Como a cadeia de conexão pode conter credenciais, você deve usar uma conexão de identidade gerenciada ou pelo menos armazenar a cadeia de conexão no Key Vault. Para mais informações, veja Definir conexões.

Para saber mais sobre conexões de bindings, veja Gerenciar conexões no Azure Functions.

A cadeia de conexão é passada para a Microsoft. Data.SqlClient e suporta todas as palavras-chave definidas na documentação do SqlClient ConnectionString. Palavras-chave notáveis incluem:

  • Authentication: Conecte-se ao SQL do Azure com o Microsoft Entra ID. Defina para Active Directory Managed Identity identidades gerenciadas. Para mais informações, veja Conectar um aplicativo de função ao SQL do Azure com identidade gerenciada.
  • Command Timeout: Espere um tempo especificado em segundos antes de terminar uma consulta (padrão 30 segundos).
  • ConnectRetryCount: Fazer automaticamente tentativas adicionais de reconexão, especialmente aplicáveis ao nível serverless do Banco de Dados SQL do Azure (padrão 1).
  • Pooling: Reutilizar conexões ao banco de dados para melhorar o desempenho (padrão true). As configurações adicionais para o pool de conexões incluem Connection Lifetime, Max Pool Size e Min Pool Size. Saiba mais na documentação do ADO.NET.

Próximas etapas

  • Last updated on