Konfigurera anslutningar till fjärrtjänster i Azure Functions

Functions-värden kräver att din app har dessa specifika namngivna anslutningar, som stödjer både funktionsexekveringar och loggning:

• AzureWebJobsStorage: Functions använder det här standardlagringskontot för att möjliggöra grundläggande funktioner, såsom att samordna singleton-körning av timerutlösare och som standardlagring för funktionsåtkomstnycklar. Värden kräver att den här anslutningen är till ett lagringskonto som stöds. Din funktionsapp kan inte starta utan denna anslutningsinställning. Mer information finns i Lagringsöverväganden för Azure Functions.

• APPLICATIONINSIGHTS_CONNECTION_STRING: Du bör också konfigurera värdprogrammet så att det skriver loggar till en Application Insights-instans.

• WEBSITE_AZUREFILESCONNECTIONSTRING: Används endast av appar som körs i en konsumtionsplan eller Elastic Premium-plan. Definierar lagringskontot som innehåller Azure Files-delningen som underhåller distributionspaketet för din app.

Alla bindningstillägg som ansluter till en fjärrtjänst måste lagra anslutningsinformation i appens inställningar. Dessa triggers och bindningar har en connection egenskap som du sätter till namnet eller prefixet för inställningen som innehåller anslutningsinformationen. De exakta kraven för både nyckelnamnet och värdet på dessa inställningar beror på vilken typ av autentisering som används i anslutningen. För en komplett lista över bindande tillägg, se stödda tjänster.

Värden för Functions hanterar dessa anslutningar åt dig och använder dem för att läsa in data till och skriva ut data från dina funktioner. Du kan inte använda klienterna för dessa anslutningar direkt i din kod.

Om det är lämpligt kan dina lagringsbindningar använda samma lagringskonto som värdlagringskontot (AzureWebJobsStorage). För mer information, se Delade lagringskonton.

Client SDK-instanser kräver alltid en anslutning för att nå en fjärrtjänst. Behåll denna anslutningsinformation som ett minimum i applikationsinställningarna och hämta den vid körning i din kod genom att använda miljövariabler. Du ansvarar för att hantera och göra dig av med alla kund-SDK-anslutningar du skapar. När du kör i Consumption-planen måste du också ta hänsyn till begränsningen på klientanslutningar.

Använd beroendeinjektion för att registrera singleton- eller scoped-klienter.

Använd static final fält för klientinstanser.

Skapa klienter vid modulens omfattning, utanför funktionshanteraren.

Initiera klienter i profile.ps1 med hjälp av variabler i $global:.

Skapa klienter på modulnivå, ovanför instansen FunctionApp() .

Skapa klienter vid modulens omfattning, utanför funktionshanteraren.

HTTP-förfrågningar

Registrera en delad HttpClient genom att använda beroendeinjektion så att alla funktionsanrop återanvänder samma instans. I det här fallet behöver du inte avyttra klienten eftersom körmiljön hanterar dess livslängd.

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

Sedan injicerar du IHttpClientFactory eller HttpClient i din funktionsklass:

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

Registrera en singleton CosmosClient i din startup så att alla funktioner delar en anslutning. Azure Cosmos DB-dokumentationen rekommenderar att du använder en singleton-klient under hela applikationens livslängd.

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

Injicera CosmosClient sedan i din funktionsklass:

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-förfrågningar

Skapa ett delat HttpClient som statiskt fält så att samma instans återanvänds i alla anrop:

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

Skapa en statisk funktion CosmosClient som initieras en gång och delas mellan alla anrop:

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-förfrågningar

Använd den inbyggda http.agent klassen för bättre anslutningshantering. Det rekommenderade sättet att konfigurera anslutningsgränser i Functions är att sätta ett maximalt antal globalt:

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

Du kan också skapa en anpassad HTTP-agent för specifika förfrågningar:

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

Azure Cosmos DB clients

Skapa CosmosClient utanför funktionshanteraren så att alla anrop delar en enda anslutning. Azure Cosmos DB-dokumentationen rekommenderar att du använder en singleton-klient under hela applikationens livslängd.

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-förfrågningar

I PowerShell kan du inte enkelt skapa statiska singletons inom ett funktionsskript. Använd istället profile.ps1 filen för att initiera delat tillstånd som kvarstår över anrop inom en arbetsinstans:

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

I din funktion, använd Invoke-RestMethod som hanterar anslutningspoolning automatiskt:

# 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

För Azure Cosmos DB, initialisera en delad klient i profile.ps1 genom att använda Azure SDKs:

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

Använd sedan den delade klienten i din funktion:

# run.ps1
param($Timer)

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

HTTP-förfrågningar

Skapa en delad session på modulnivå så att alla funktionsanrop återanvänder samma anslutningspool:

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

Skapa modulnivån CosmosClient så att den kvarstår över alla anrop:

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-förfrågningar

Skapa en delad klient vid modulens omfattning. I v4-programmeringsmodellen kvarstår modulnivåtillståndet över anrop:

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

Skapa CosmosClient utanför hanteraren så att alla anrop delar en enda anslutning:

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