Configurar ligações a serviços remotos no Funções do Azure

O anfitrião de Funções exige que a sua aplicação tenha estas ligações específicas nomeadas, que suportam tanto execuções de funções como registos:

• AzureWebJobsStorage: O Functions utiliza esta conta de armazenamento predefinida para permitir funcionalidades essenciais, como coordenar a execução única dos disparadores de temporizador e o armazenamento predefinido das chaves de acesso da função. O host requer esta ligação a uma conta de armazenamento suportada. A tua aplicação de funções não consegue arrancar sem esta configuração de ligação. Para mais informações, consulte Considerações de armazenamento para Funções do Azure.

• APPLICATIONINSIGHTS_CONNECTION_STRING: Deve também configurar o host para escrever registos para uma instância do Application Insights.

• WEBSITE_AZUREFILESCONNECTIONSTRING: Usado apenas por aplicações que funcionam num plano Consumption ou Elastic Premium. Define a conta de armazenamento que contém a partilha Ficheiros do Azure que mantém o pacote de implementação da sua aplicação.

Qualquer extensão de ligação que se ligue a um serviço remoto deve armazenar a informação de ligação nas definições da aplicação. Estes triggers e bindings têm uma connection propriedade que defines para o nome ou prefixo da definição que contém a informação da ligação. Os requisitos exatos tanto para o nome da chave como para o valor destas definições dependem do tipo de autenticação utilizada na ligação. Para uma lista completa de extensões de ligação, veja serviços suportados.

O anfitrião das Funções gere estas ligações por ti e usa-as para ler e escrever dados a partir das tuas funções. Não podes usar os clientes para essas ligações diretamente no teu código.

Nos casos em que faz sentido, as suas ligações de armazenamento podem usar a mesma conta de armazenamento que a conta de armazenamento do anfitrião (AzureWebJobsStorage). Para mais informações, consulte Contas de armazenamento partilhado.

As instâncias do SDK do cliente requerem sempre uma ligação para aceder a um serviço remoto. Mantenha esta informação de ligação, no mínimo, nas definições da aplicação e obtenha-a em tempo de execução no seu código usando variáveis de ambiente. És responsável por gerir e eliminar quaisquer ligações ao SDK do cliente que cries. Ao usar o plano de Consumo, deve também considerar a limitação das ligações aos clientes.

Utilize a injeção de dependências para registar clientes singleton ou de âmbito.

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

Criar clientes no âmbito do módulo, fora do gestor de funções.

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

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

Criar clientes no âmbito do módulo, fora do gestor de funções.

Pedidos HTTP

Registar um HttpClient partilhado usando injeção de dependências para que todas as invocações de funções reutilizem a mesma instância. Neste caso, não tens de eliminar o cliente porque o runtime gere a 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();
    }
}

Depois injeta IHttpClientFactory ou HttpClient na tua 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

Regista um CosmosClient único na tua startup para que todas as funções partilhem uma ligação. A documentação do Azure Cosmos DB recomenda que utilize 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 injeta CosmosClient na tua 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");
    }
}

Pedidos HTTP

Crie um campo partilhado 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 uma estática CosmosClient que seja inicializada uma vez e partilhada 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");
    }
}

Pedidos HTTP

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

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

Também pode criar um agente HTTP personalizado para pedidos específicos:

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 gestor de funções para que todas as invocações partilhem uma única ligação. A documentação do Azure Cosmos DB recomenda que utilize 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);
}

Pedidos HTTP

No PowerShell, não é fácil criar singletons estáticos dentro de um script de funções. Em vez disso, use o profile.ps1 ficheiro para inicializar o estado partilhado 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, que gere automaticamente o pooling de ligaçõ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 Azure Cosmos DB, inicialize um cliente partilhado 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 usa o cliente partilhado na tua função:

# run.ps1
param($Timer)

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

Pedidos HTTP

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

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 ao 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")

Pedidos HTTP

Crie um cliente partilhado no âmbito do módulo. No modelo de programação v4, o estado ao nível do módulo persiste através das 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 partilhem uma única ligaçã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,
});