在 Azure Functions 中設定與遠端服務的連線

Functions 主機要求你的應用程式擁有以下特定命名的連線，這些連線同時支援函式執行與日誌記錄：

• AzureWebJobsStorage： Functions 使用此預設儲存帳號來啟用核心行為，例如協調計時器觸發器的單例執行，以及功能存取鍵的預設儲存。 主機要求此連線連接到受支援的儲存體帳戶。 你的函式應用程式沒有這個連線設定就無法啟動。 如需詳細資訊，請參閱 Azure Functions 的儲存體考量。

• APPLICATIONINSIGHTS_CONNECTION_STRING：您也應該將主機設定為把記錄寫入 Application Insights 執行個體。

• WEBSITE_CONTENTAZUREFILECONNECTIONSTRING：僅供運行於消費型或彈性高級方案的應用程式使用。 定義包含維護你應用程式部署套件的 Azure 檔案儲存體 共享的儲存帳號。

任何連接遠端服務的綁定擴充功能都必須在應用程式設定中儲存連線資訊。 這些觸發器和綁定有一個 connection 屬性，你可以設定為包含連線資訊的設定名稱或前綴。 這些設定的金鑰名稱與值的具體要求，取決於連線中使用的認證方式。 欲了解完整的綁定擴充功能清單，請參閱 支援服務。

函式主機會為您管理這些連線，並使用這些連線將資料讀入函式，以及將資料從函式寫出。 你不能直接在程式碼中使用這些連線的客戶端。

在合理的情況下，你的儲存綁定可以使用與主機儲存帳號相同的儲存帳號（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 clients

在你的新創公司註冊一個單例 CosmosClient ，讓所有功能共用同一個連線。 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 clients

建立一個靜態 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 clients

在函式處理外建立 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 clients

針對 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 clients

在模組層級建立 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 clients

在處理常式外部建立 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,
});