Configurar conexões para serviços remotos no Azure Functions

O host do Functions exige que seu aplicativo tenha estas conexões específicas nomeadas, que dão suporte tanto às execuções de função quanto aos logs:

• AzureWebJobsStorage: O Functions usa essa conta de armazenamento padrão para habilitar comportamentos principais, como coordenar a execução singleton dos gatilhos do temporizador e o armazenamento padrão para chaves de acesso à função. O host requer essa conexão com uma conta de armazenamento suportada. Seu aplicativo de funções não pode ser iniciado sem essa configuração de conexão. Para obter mais informações, confira Considerações de armazenamento do Azure Functions.

• APPLICATIONINSIGHTS_CONNECTION_STRING: Você também deve configurar o host para gravar logs em uma instância do Application Insights.

• WEBSITE_AZUREFILESCONNECTIONSTRING: Usado apenas por aplicativos que rodam em um plano Consumption ou Elastic Premium. Define a conta de armazenamento que contém o compartilhamento Arquivos do Azure que mantém o pacote de implantação para seu app.

Qualquer extensão de binding que se conecte a um serviço remoto deve armazenar informações de conexão nas configurações do app. Esses gatilhos e vinculações têm uma connection propriedade que você define para o nome ou prefixo da configuração que contém as informações da conexão. Os requisitos exatos tanto para o nome da chave quanto para o valor dessas configurações dependem do tipo de autenticação usada na conexão. Para obter uma lista completa de extensões de associação, consulte serviços compatíveis.

O host de Funções gerencia essas conexões para você e as usa para ler e gravar dados das suas funções. Você não pode usar os clientes para essas conexões diretamente no seu código.

Nos casos em que faz sentido, suas vinculações de armazenamento podem usar a mesma conta de armazenamento que a conta de armazenamento do host (AzureWebJobsStorage). Para mais informações, veja Contas de armazenamento compartilhado.

Instâncias de SDK de cliente sempre exigem uma conexão para alcançar um serviço remoto. Mantenha essas informações de conexão, no mínimo, nas configurações da aplicação e obtenha-as em tempo de execução no seu código usando variáveis de ambiente. Você é responsável por gerenciar e descartar quaisquer conexões do SDK do cliente que criar. Ao executar no Plano de consumo, você também deve levar em consideração a limitação em conexões de cliente.

Use injeção de dependência para registrar clientes singleton ou de escopo.

Use os campos static final para instâncias de cliente.

Crie clientes no escopo do módulo, fora do gerenciador de funções.

Inicialize clientes em profile.ps1 usando variáveis $global:.

Crie clientes no nível do módulo, acima da FunctionApp() instância.

Crie clientes no escopo do módulo, fora do gerenciador de funções.

Solicitações HTTP

Registre um HttpClient compartilhado usando injeção de dependência para que todas as invocações de funções reutilizem a mesma instância. Nesse caso, você não precisa descartar o cliente porque o tempo de execução gerencia sua vida útil.

using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(MyNamespace.Startup))]

namespace MyNamespace;

public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        builder.Services.AddHttpClient();
    }
}

Então injete IHttpClientFactory ou HttpClient na sua classe de função:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace MyNamespace;

public class MyFunction(HttpClient httpClient, ILogger<MyFunction> logger)
{
    [Function("MyFunction")]
    public async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo timer)
    {
        var response = await httpClient.GetAsync("https://example.com");
        logger.LogInformation("Response status: {Status}", response.StatusCode);
    }
}

Azure Cosmos DB clients

Registre um CosmosClient único na sua startup para que todas as funções compartilhem uma única conexão. A documentação do Azure Cosmos DB recomenda que você use um cliente singleton durante toda a vida útil da sua aplicação.

using Microsoft.Azure.Cosmos;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(MyNamespace.Startup))]

namespace MyNamespace;

public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        builder.Services.AddSingleton(_ =>
        {
            var connectionString = Environment.GetEnvironmentVariable("CosmosDBConnection");
            return new CosmosClient(connectionString);
        });
    }
}

Depois, injete CosmosClient na sua classe de função:

using Microsoft.Azure.Cosmos;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace MyNamespace;

public class MyCosmosFunction(CosmosClient cosmosClient, ILogger<MyCosmosFunction> logger)
{
    private readonly Container _container = cosmosClient.GetContainer("mydb", "mycontainer");

    [Function("MyCosmosFunction")]
    public async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo timer)
    {
        var item = new { id = "myId", partitionKey = "myPartitionKey", data = "example" };
        await _container.UpsertItemAsync(item, new PartitionKey("myPartitionKey"));
        logger.LogInformation("Item upserted");
    }
}

Solicitações HTTP

Crie um campo compartilhado HttpClient como estático para que a mesma instância seja reutilizada em todas as invocações:

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class MyFunction {
    // Shared HttpClient instance across all invocations
    private static final HttpClient httpClient = HttpClient.newHttpClient();

    @FunctionName("MyFunction")
    public void run(
        @TimerTrigger(name = "timer", schedule = "0 */5 * * * *") String timerInfo,
        final ExecutionContext context
    ) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        HttpResponse<String> response = httpClient.send(request, 
            HttpResponse.BodyHandlers.ofString());
        context.getLogger().info("Response status: " + response.statusCode());
    }
}

Azure Cosmos DB clients

Crie um estático CosmosClient que seja inicializado uma vez e compartilhado entre todas as invocações:

import com.azure.cosmos.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;

public class MyCosmosFunction {
    private static final CosmosClient cosmosClient = new CosmosClientBuilder()
        .endpoint(System.getenv("COSMOS_API_URL"))
        .key(System.getenv("COSMOS_API_KEY"))
        .buildClient();

    private static final CosmosContainer container = cosmosClient
        .getDatabase("mydb")
        .getContainer("mycontainer");

    @FunctionName("MyCosmosFunction")
    public void run(
        @TimerTrigger(name = "timer", schedule = "0 */5 * * * *") String timerInfo,
        final ExecutionContext context
    ) {
        container.upsertItem(new MyItem("myId", "myPartitionKey", "example"));
        context.getLogger().info("Item upserted");
    }
}

Solicitações HTTP

Use a classe nativa http.agent para melhor gerenciamento de conexão. A forma recomendada de configurar limites de conexão em Funções é definir um número máximo globalmente:

const http = require('http');
http.globalAgent.maxSockets = 200;

Você também pode criar um agente HTTP personalizado para requisições específicas:

const http = require('http');
const httpAgent = new http.Agent({ maxSockets: 200 });
const options = { agent: httpAgent };
http.request(options, onResponseCallback);

Azure Cosmos DB clients

Crie o CosmosClient fora do gerenciador de funções para que todas as invocações compartilhem uma única conexão. A documentação do Azure Cosmos DB recomenda que você use um cliente singleton durante toda a vida útil da sua aplicação.

const { CosmosClient } = require('@azure/cosmos');

const client = new CosmosClient({ 
    endpoint: process.env.COSMOS_API_URL, 
    key: process.env.COSMOS_API_KEY 
});
const container = client.database("MyDatabaseName").container("MyContainerName");

module.exports = async function (context) {
    const { resources: items } = await container.items.readAll().fetchAll();
    context.log(items);
}

Solicitações HTTP

No PowerShell, você não pode facilmente criar singletons estáticos dentro de um script de função. Em vez disso, use o profile.ps1 arquivo para inicializar o estado compartilhado que persiste entre invocações dentro de uma instância de trabalho:

# profile.ps1 - runs once when the worker starts
# Nothing special needed for HTTP; PowerShell manages connections internally

Na sua função, use Invoke-RestMethod qual gerencia automaticamente o pool de conexões:

# run.ps1
param($Timer)

$response = Invoke-RestMethod -Uri "https://example.com" -Method Get
Write-Host "Response received with $($response.Length) characters"

Azure Cosmos DB clients

Para o Azure Cosmos DB, inicialize um cliente compartilhado em profile.ps1, usando o SDK do Azure:

# profile.ps1 - runs once per worker instance
if (-not $global:CosmosContainer) {
    $cosmosClient = New-Object Microsoft.Azure.Cosmos.CosmosClient(
        $env:COSMOS_API_URL, $env:COSMOS_API_KEY)
    $global:CosmosContainer = $cosmosClient.GetDatabase("mydb").GetContainer("mycontainer")
}

Depois, use o cliente compartilhado na sua função:

# run.ps1
param($Timer)

$items = $global:CosmosContainer.ReadContainerAsync().GetAwaiter().GetResult()
Write-Host "Container accessed successfully"

Solicitações HTTP

Crie uma sessão compartilhada no nível do módulo para que todas as invocações de funções reutilizem o mesmo pool de conexão:

import azure.functions as func
import requests

# Shared session reuses TCP connections across invocations
session = requests.Session()
session.mount("https://", requests.adapters.HTTPAdapter(pool_maxsize=200))

app = func.FunctionApp()

@app.timer_trigger(schedule="0 */5 * * * *", arg_name="timer")
def my_function(timer: func.TimerRequest) -> None:
    response = session.get("https://example.com")
    logging.info(f"Response status: {response.status_code}")

Azure Cosmos DB clients

Crie o CosmosClient no nível do módulo para que persista entre as invocações:

import azure.functions as func
from azure.cosmos import CosmosClient
import os

# Singleton client shared across all invocations
cosmos_client = CosmosClient(
    os.environ["COSMOS_API_URL"], 
    credential=os.environ["COSMOS_API_KEY"]
)
container = cosmos_client.get_database_client("mydb").get_container_client("mycontainer")

app = func.FunctionApp()

@app.timer_trigger(schedule="0 */5 * * * *", arg_name="timer")
def my_cosmos_function(timer: func.TimerRequest) -> None:
    items = list(container.read_all_items())
    logging.info(f"Read {len(items)} items")

Solicitações HTTP

Crie um cliente compartilhado no escopo do módulo. No modelo de programação v4, o estado em nível de módulo persiste entre as invocações:

import { app, InvocationContext, Timer } from "@azure/functions";

// Shared across all invocations in this worker instance
const baseUrl = "https://example.com";

async function myFunction(timer: Timer, context: InvocationContext): Promise<void> {
    // Node.js 18+ native fetch reuses connections automatically
    const response = await fetch(baseUrl);
    context.log(`Response status: ${response.status}`);
}

app.timer("myFunction", {
    schedule: "0 */5 * * * *",
    handler: myFunction,
});

Azure Cosmos DB clients

Crie o CosmosClient fora do handler para que todas as invocações compartilhem uma única conexão:

import { app, InvocationContext, Timer } from "@azure/functions";
import { CosmosClient, Container } from "@azure/cosmos";

const client = new CosmosClient({
    endpoint: process.env.COSMOS_API_URL!,
    key: process.env.COSMOS_API_KEY!,
});
const container: Container = client.database("MyDatabaseName").container("MyContainerName");

async function myCosmosFunction(timer: Timer, context: InvocationContext): Promise<void> {
    const { resources: items } = await container.items.readAll().fetchAll();
    context.log(`Read ${items.length} items`);
}

app.timer("myCosmosFunction", {
    schedule: "0 */5 * * * *",
    handler: myCosmosFunction,
});