Verbindingen beheren in Azure FunctionsManage connections in Azure Functions

Functies in een functie-app delen resources.Functions in a function app share resources. Onder deze gedeelde resources zijn verbindingen: HTTP-verbindingen, databaseverbindingen en verbindingen met services zoals Azure Storage.Among those shared resources are connections: HTTP connections, database connections, and connections to services such as Azure Storage. Wanneer veel functies gelijktijdig worden uitgevoerd, is het mogelijk om geen beschikbare verbindingen meer te hebben.When many functions are running concurrently, it's possible to run out of available connections. In dit artikel wordt uitgelegd hoe u uw functies codeert om te voorkomen dat u meer verbindingen gebruikt dan nodig is.This article explains how to code your functions to avoid using more connections than they need.

VerbindingslimietConnection limit

Het aantal beschikbare verbindingen is deels beperkt omdat een functie-app wordt uitgevoerd in een sandbox-omgeving.The number of available connections is limited partly because a function app runs in a sandbox environment. Een van de beperkingen die de sandbox aan uw code oplegt, is een limiet voor het aantal uitgaande verbindingen, dat momenteel 600 actieve (in totaal 1200) verbindingen per exemplaar is.One of the restrictions that the sandbox imposes on your code is a limit on the number of outbound connections, which is currently 600 active (1,200 total) connections per instance. Wanneer u deze limiet bereikt, schrijft de functions-runtime het volgende bericht naar de logboeken: Host thresholds exceeded: Connections .When you reach this limit, the functions runtime writes the following message to the logs: Host thresholds exceeded: Connections. Zie Functions-servicelimieten voor meer informatie.For more information, see the Functions service limits.

Deze limiet geldt per exemplaar.This limit is per instance. Wanneer de schaalcontroller instanties van functie-apps toevoegt om meer aanvragen te verwerken, heeft elk exemplaar een onafhankelijke verbindingslimiet.When the scale controller adds function app instances to handle more requests, each instance has an independent connection limit. Dit betekent dat er geen globale verbindingslimiet is en dat u veel meer dan 600 actieve verbindingen kunt hebben voor alle actieve exemplaren.That means there's no global connection limit, and you can have much more than 600 active connections across all active instances.

Zorg er bij het oplossen van problemen voor dat u de Application Insights voor uw functie-app hebt ingeschakeld.When troubleshooting, make sure that you have enabled Application Insights for your function app. Application Insights kunt u metrische gegevens weergeven voor uw functie-apps, zoals uitvoeringen.Application Insights lets you view metrics for your function apps like executions. Zie Telemetrie weergeven inApplication Insights.For more information, see View telemetry in Application Insights.

Statische clientsStatic clients

Om te voorkomen dat u meer verbindingen vasthoudt dan nodig is, hergebruikt u client-exemplaren in plaats van nieuwe exemplaren te maken met elke functie-aanroep.To avoid holding more connections than necessary, reuse client instances rather than creating new ones with each function invocation. We raden u aan clientverbindingen opnieuw te gebruiken voor elke taal waarin u uw functie zou kunnen schrijven.We recommend reusing client connections for any language that you might write your function in. .NET-clients zoals de HttpClient-, DocumentClient-en Azure Storage-clients kunnen bijvoorbeeld verbindingen beheren als u één statische client gebruikt.For example, .NET clients like the HttpClient, DocumentClient, and Azure Storage clients can manage connections if you use a single, static client.

Hier volgen enkele richtlijnen wanneer u een servicespecifieke client gebruikt in een Azure Functions toepassing:Here are some guidelines to follow when you're using a service-specific client in an Azure Functions application:

  • Maak geen nieuwe client bij elke functie-aanroep.Do not create a new client with every function invocation.
  • Maak wel één statische client die elke functie-aanroep kan gebruiken.Do create a single, static client that every function invocation can use.
  • Overweeg om één statische client in een gedeelde helperklasse te maken als verschillende functies dezelfde service gebruiken.Consider creating a single, static client in a shared helper class if different functions use the same service.

Voorbeelden van clientcodeClient code examples

In deze sectie worden de best practices gedemonstreerd voor het maken en gebruiken van clients op basis van uw functiecode.This section demonstrates best practices for creating and using clients from your function code.

HttpClient-voorbeeld (C#)HttpClient example (C#)

Hier is een voorbeeld van C#-functiecode die een statisch HttpClient-exemplaar maakt:Here's an example of C# function code that creates a static HttpClient instance:

// Create a single, static HttpClient
private static HttpClient httpClient = new HttpClient();

public static async Task Run(string input)
{
    var response = await httpClient.GetAsync("https://example.com");
    // Rest of function
}

Een veelvoorkomende vraag over HttpClient in .NET is: "Moet ik mijn client verwijderen?"A common question about HttpClient in .NET is "Should I dispose of my client?" Over het algemeen kunt u objecten verwijderen die worden geïmplementeerd IDisposable wanneer u klaar bent met het gebruik ervan.In general, you dispose of objects that implement IDisposable when you're done using them. Maar u hoeft een statische client niet te verwijderen omdat u er niet klaar mee bent wanneer de functie wordt beëindigd.But you don't dispose of a static client because you aren't done using it when the function ends. U wilt dat de statische client live blijft voor de duur van uw toepassing.You want the static client to live for the duration of your application.

Voorbeelden van HTTP-agent (JavaScript)HTTP agent examples (JavaScript)

Omdat het betere opties voor verbindingsbeheer biedt, moet u de systeemeigen klasse gebruiken in plaats van http.agent niet-systeemeigen methoden, zoals de node-fetch module.Because it provides better connection management options, you should use the native http.agent class instead of non-native methods, such as the node-fetch module. Verbindingsparameters worden geconfigureerd via opties voor de http.agent klasse .Connection parameters are configured through options on the http.agent class. Zie nieuwe Agent( opties [ ] )voor gedetailleerde opties die beschikbaar zijn voor de HTTP-agent.For detailed options available with the HTTP agent, see new Agent([options]).

De globale http.globalAgent klasse die wordt gebruikt door heeft al deze waarden ingesteld op de respectieve http.request() standaardwaarden.The global http.globalAgent class used by http.request() has all of these values set to their respective defaults. De aanbevolen manier om verbindingslimieten in Functions te configureren, is door een maximumaantal globaal in te stellen.The recommended way to configure connection limits in Functions is to set a maximum number globally. In het volgende voorbeeld wordt het maximum aantal sockets voor de functie-app bepaalt:The following example sets the maximum number of sockets for the function app:

http.globalAgent.maxSockets = 200;

In het volgende voorbeeld wordt alleen voor die aanvraag een nieuwe HTTP-aanvraag gemaakt met een aangepaste HTTP-agent:The following example creates a new HTTP request with a custom HTTP agent only for that request:

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

DocumentClient-codevoorbeeld (C#)DocumentClient code example (C#)

DocumentClient maakt verbinding met een Azure Cosmos DB exemplaar.DocumentClient connects to an Azure Cosmos DB instance. In Azure Cosmos DB wordt aanbevolen dat u een singleton Azure Cosmos DB client gebruikt voor de levensduur van uw toepassing.The Azure Cosmos DB documentation recommends that you use a singleton Azure Cosmos DB client for the lifetime of your application. In het volgende voorbeeld ziet u één patroon om dat in een functie te doen:The following example shows one pattern for doing that in a function:

#r "Microsoft.Azure.Documents.Client"
using Microsoft.Azure.Documents.Client;

private static Lazy<DocumentClient> lazyClient = new Lazy<DocumentClient>(InitializeDocumentClient);
private static DocumentClient documentClient => lazyClient.Value;

private static DocumentClient InitializeDocumentClient()
{
    // Perform any initialization here
    var uri = new Uri("example");
    var authKey = "authKey";
    
    return new DocumentClient(uri, authKey);
}

public static async Task Run(string input)
{
    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("database", "collection");
    object document = new { Data = "example" };
    await documentClient.UpsertDocumentAsync(collectionUri, document);
    
    // Rest of function
}

Als u met functions v3.x werkt, hebt u een verwijzing nodig naar Microsoft.Azure.DocumentDB.Core.If you are working with functions v3.x, you need a reference to Microsoft.Azure.DocumentDB.Core. Voeg een verwijzing toe aan de code:Add a reference in the code:

#r "Microsoft.Azure.DocumentDB.Core"

Maak ook een bestand met de naam function.proj voor uw trigger en voeg de onderstaande inhoud toe:Also, create a file named "function.proj" for your trigger and add the below content :


<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netcoreapp3.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.DocumentDB.Core" Version="2.12.0" />
    </ItemGroup>
</Project>

CosmosClient-codevoorbeeld (JavaScript)CosmosClient code example (JavaScript)

CosmosClient maakt verbinding met een Azure Cosmos DB exemplaar.CosmosClient connects to an Azure Cosmos DB instance. In Azure Cosmos DB wordt aanbevolen dat u een singleton Azure Cosmos DB client gebruikt voor de levensduur van uw toepassing.The Azure Cosmos DB documentation recommends that you use a singleton Azure Cosmos DB client for the lifetime of your application. In het volgende voorbeeld ziet u één patroon om dat in een functie te doen:The following example shows one pattern for doing that in a function:

const cosmos = require('@azure/cosmos');
const endpoint = process.env.COSMOS_API_URL;
const key = process.env.COSMOS_API_KEY;
const { CosmosClient } = cosmos;

const client = new CosmosClient({ endpoint, key });
// All function invocations also reference the same database and container.
const container = client.database("MyDatabaseName").container("MyContainerName");

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

SqlClient-verbindingenSqlClient connections

Uw functiecode kan de .NET Framework-gegevensprovider voor SQL Server(SqlClient)gebruiken om verbindingen te maken met een relationele SQL-database.Your function code can use the .NET Framework Data Provider for SQL Server (SqlClient) to make connections to a SQL relational database. Dit is ook de onderliggende provider voor gegevenskaders die afhankelijk zijn van ADO.NET, zoals Entity Framework.This is also the underlying provider for data frameworks that rely on ADO.NET, such as Entity Framework. In tegenstelling tot HttpClient- en DocumentClient-verbindingen ADO.NET standaard groeperen van verbindingen geïmplementeerd.Unlike HttpClient and DocumentClient connections, ADO.NET implements connection pooling by default. Maar omdat u nog steeds geen verbindingen meer hebt, moet u de verbindingen met de database optimaliseren.But because you can still run out of connections, you should optimize connections to the database. Zie SQL Server Connection Pooling (ADO.NET) voor meer informatie.For more information, see SQL Server Connection Pooling (ADO.NET).

Tip

Sommige gegevens frameworks, zoals Entity Framework, halen meestal verbindingsreeksen op uit de sectie ConnectionStrings van een configuratiebestand.Some data frameworks, such as Entity Framework, typically get connection strings from the ConnectionStrings section of a configuration file. In dit geval moet u expliciet SQL database-verbindingsreeksen toevoegen aan de verzameling Verbindingsreeksen van uw functie-app-instellingen en in de local.settings.jsin het bestand in uw lokale project. In this case, you must explicitly add SQL database connection strings to the Connection strings collection of your function app settings and in the local.settings.json file in your local project. Als u een exemplaar van SqlConnection maakt in uw functiecode, moet u de waarde connection string opslaan in Toepassingsinstellingen met uw andere verbindingen.If you're creating an instance of SqlConnection in your function code, you should store the connection string value in Application settings with your other connections.

Volgende stappenNext steps

Zie Onjuiste antipatroon voor instantiëring voor meer informatie over waarom statische clients worden aanbevolen.For more information about why we recommend static clients, see Improper instantiation antipattern.

Zie De Azure Functions en betrouwbaarheid van uw Azure Functions voor meer Azure Functions.For more Azure Functions performance tips, see Optimize the performance and reliability of Azure Functions.