在 Azure Functions 中配置与远程服务的连接

Functions主机要求你的应用拥有以下特定命名连接，这些连接支持函数执行和日志记录：

• AzureWebJobsStorage： 函数使用该默认存储账户来启用核心行为，如协调定时触发器的单例执行和函数访问密钥的默认存储。 主机要求此连接连接到受支持的存储帐户。 没有这个连接设置，你的功能应用无法启动。 有关详细信息，请参阅 Azure Functions 的存储注意事项。

• APPLICATIONINSIGHTS_CONNECTION_STRING你还应该配置主机写入 Application Insights 实例的日志。

• WEBSITE_AZUREFILESCONNECTIONSTRING：仅由运行在 消费计划 或 弹性高级计划中的应用使用。 定义包含维护你应用部署包的Azure 文件存储共享的存储账户。

任何连接到远程服务的绑定扩展都必须在应用设置中存储连接信息。 这些触发器和绑定有一个 connection 属性，你设置为包含连接信息的设置名称或前缀。 这些设置的密钥名和值的具体要求取决于连接中使用的认证类型。 有关完整的绑定扩展列表，请参见 支持的服务。

Functions 主机进程会为你管理这些连接，并使用它们将数据读入函数，以及将数据从函数中写出。 你不能直接在代码中使用这些连接的客户端。

在合理的情况下，你的存储绑定可以使用与主机存储账户相同的存储账户（AzureWebJobsStorage）。 更多信息请参见 共享存储账户。

客户端SDK实例总是需要连接才能访问远程服务。 至少在应用设置中保留这些连接信息，并在运行时通过使用环境变量在代码中获取。 你负责管理和处理你创建的任何客户端SDK连接。 在 消耗计划下运行时，还必须考虑客户端连接数限制。

使用依赖注入来注册单例或有作用域的客户端。

客户端实例请使用 static final 字段。

在模块作用域中创建客户端，即在函数处理程序之外。

在 profile.ps1 中使用 $global: 变量初始化客户端。

在模块级别、位于 FunctionApp() 实例之上创建客户端。

在模块作用域中创建客户端，即在函数处理程序之外。

HTTP 请求

通过依赖注入注册共享 HttpClient ，使所有函数调用重复使用同一个实例。 在这种情况下，你不必丢弃客户端，因为运行时管理其生命周期。

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();
    }
}

然后在你的函数类中注入 IHttpClientFactory 或 HttpClient ：

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客户端

在你的初创公司注册一个单例 Cosmos客户端 ，让所有功能共享一个连接。 Azure Cosmos DB 文档建议你在整个应用生命周期内使用单例客户端。

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);
        });
    }
}

然后在你的函数类中注入 CosmosClient ：

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");
    }
}

HTTP 请求

创建一个共享 HttpClient 字段作为静态字段，使同一实例在所有调用中都能重复使用：

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客户端

创建一个初始化一次并在所有调用中共享的静态 CosmosClient ：

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");
    }
}

HTTP 请求

使用原生 http.agent 类以更好地管理连接。 在函数中配置连接限制的推荐方法是全局设置最大连接数：

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

你也可以为特定请求创建自定义 HTTP 代理：

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

Azure Cosmos DB客户端

在函数处理程序外创建 CosmosClient ，使所有调用共享单一连接。 Azure Cosmos DB 文档建议你在整个应用生命周期内使用单例客户端。

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);
}

HTTP 请求

在PowerShell中，函数脚本中无法轻易创建静态单例。 相反，应使用 profile.ps1 文件来初始化在同一工作器实例内跨多次调用持续存在的共享状态：

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

在你的函数中，使用 Invoke-RestMethod，它会自动处理连接池：

# run.ps1
param($Timer)

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

Azure Cosmos DB客户端

对于 Azure Cosmos DB，请在 profile.ps1 中使用 Azure SDK 初始化共享客户端：

# 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")
}

然后在你的函数中使用共享客户端：

# run.ps1
param($Timer)

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

HTTP 请求

在模块层创建共享会话，使所有函数调用重复使用同一个连接池：

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客户端

在模块级别创建 CosmosClient，使其在多次调用之间持续存在：

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

HTTP 请求

在模块范围创建一个共享客户端。 在 v4 编程模型中，模块级状态会在调用中持续存在：

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客户端

在处理程序外创建 CosmosClient ，使所有调用共享单一连接：

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,
});