Dela via

Bindningar för Durable Functions i Azure Functions

Tillägget Durable Functions introducerar tre utlösarbindningar som styr körningen av orkestrerings-, entitets- och aktivitetsfunktioner. Den introducerar också en utdatabindning som fungerar som en klient för Durable Functions-körningen.

Se till att välja ditt Durable Functions-utvecklingsspråk överst i artikeln.

Viktigt!

Den här artikeln stöder programmeringsmodellerna Python v1 och Python v2 för Durable Functions.

Python v2-programmeringsmodell

Durable Functions stöds i den nya python v2-programmeringsmodellen. Om du vill använda v2-modellen måste du installera Durable Functions SDK, som är PyPI-paketet azure-functions-durable, versionen 1.2.2 eller en senare version. Du måste också kontrollera host.json att appen refererar till tilläggspaket version 4.x för att använda v2-modellen med Durable Functions.

Du kan ge feedback och förslag i Durable Functions SDK för Python-lagringsplatsen.

Orkestreringsutlösare

Med orkestreringsutlösaren kan du skapa varaktiga orkestreringsfunktioner. Den här utlösaren körs när en ny orkestreringsinstans schemaläggs och när en befintlig orkestreringsinstans tar emot en händelse. Exempel på händelser som kan utlösa orkestreringsfunktioner är varaktiga timerförfallodatum, aktivitetsfunktionssvar och händelser som genereras av externa klienter.

När du skapar funktioner i .NET konfigureras orkestreringsutlösaren med attributet OrchestrationTriggerAttribute .NET.

För Java används anteckningen @DurableOrchestrationTrigger för att konfigurera orkestreringsutlösaren.

När du skriver orkestreringsfunktioner definieras orkestreringsutlösaren av följande JSON-objekt i matrisen bindings för function.json-filen :

{
    "name": "<Name of input parameter in function signature>",
    "orchestration": "<Optional - name of the orchestration>",
    "type": "orchestrationTrigger",
    "direction": "in"
}
  • orchestration är namnet på orkestreringen som klienter måste använda när de vill starta nya instanser av den här orchestrator-funktionen. Den här egenskapen är valfri. Om det inte anges används namnet på funktionen.

Azure Functions stöder två programmeringsmodeller för Python. Hur du definierar en orkestreringsutlösare beror på din valda programmeringsmodell.

Med programmeringsmodellen Python v2 kan du definiera en orkestreringsutlösare med hjälp av dekoratören orchestration_trigger direkt i python-funktionskoden.

I v2-modellen sker åtkomst till Durable Functions-utlösare och bindningar från en instans av DFApp, som är en underklass av FunctionApp och dessutom exporterar specifika Durable Functions-dekoratörer.

Internt avsöker den här utlösarbindningen det konfigurerade varaktiga arkivet för nya orkestreringshändelser, till exempel orkestreringsstarthändelser, varaktiga timer-förfallohändelser, aktivitetsfunktionssvarshändelser och externa händelser som genereras av andra funktioner.

Utlösarbeteende

Här följer några kommentarer om orkestreringsutlösaren:

  • Enkeltrådning – En enda dispatcher-tråd används för all orchestrator-funktionskörning på en enda värdinstans. Därför är det viktigt att se till att orchestrator-funktionskoden är effektiv och inte utför någon I/O. Det är också viktigt att se till att den här tråden inte utför något asynkront arbete förutom när du väntar på Durable Functions-specifika aktivitetstyper.
  • Hantering av giftmeddelanden – Det finns inget stöd för giftmeddelanden i orkestreringsutlösare.
  • Meddelandesynlighet – Orkestreringsutlösare tas bort och hålls osynliga under en konfigurerbar varaktighet. Synligheten för dessa meddelanden förnyas automatiskt så länge funktionsappen körs och är felfri.
  • Returvärden – Returvärden serialiseras till JSON och sparas i orkestreringshistoriktabellen i Azure Table Storage. Dessa returvärden kan efterfrågas av orkestreringsklientbindningen, som beskrivs senare.

Varning

Orchestrator-funktioner bör aldrig använda några andra indata- eller utdatabindningar än orkestreringsutlösarbindningen. Detta har potential att orsaka problem med tillägget Durable Task eftersom dessa bindningar kanske inte följer reglerna för enkeltrådad bearbetning och I/O. Om du vill använda andra bindningar lägger du till dem i en aktivitetsfunktion som anropas från orkestreringsfunktionen. Mer information om kodningsbegränsningar för orkestreringsfunktioner finns i dokumentationen om begränsningar för Orchestrator-funktionskod .

Varning

Orchestrator-funktioner bör aldrig deklareras async.

Användning av utlösare

Orkestreringsutlösarbindningen stöder både indata och utdata. Här följer några saker att veta om hantering av indata och utdata:

  • inputs – Orkestreringsutlösare kan anropas med indata som nås via kontextindataobjektet. Alla indata måste vara JSON-serialiserbara.
  • outputs – Orkestreringsutlösare stöder både utdata och indatavärden. Returvärdet för funktionen används för att tilldela utdatavärdet och måste vara JSON-serializable.

Utlösarexempel

Följande exempelkod visar hur den enklaste orkestreringsfunktionen "Hello World" kan se ut. I det här exemplet schemalägger inte orkestreraren några uppgifter.

Det specifika attribut som används för att definiera utlösaren beror på om du kör C# -funktionerna i processen eller i en isolerad arbetsprocess.

[FunctionName("HelloWorld")]
public static string Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Anmärkning

Föregående kod är för Durable Functions 2.x. För Durable Functions 1.x måste du använda DurableOrchestrationContext i stället för IDurableOrchestrationContext. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const name = context.df.getInput();
    return `Hello ${name}!`;
});

Anmärkning

Biblioteket durable-functions tar hand om att anropa synkron context.done metod när generatorfunktionen avslutas.

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.orchestration_trigger(context_name="context")
def my_orchestrator(context):
    result = yield context.call_activity("Hello", "Tokyo")
    return result

param($Context)

$InputData = $Context.Input
$InputData

@FunctionName("HelloWorldOrchestration")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    return String.format("Hello %s!", ctx.getInput(String.class));
}

De flesta orkestreringsfunktioner anropar aktivitetsfunktioner, så här är ett "Hello World"-exempel som visar hur du anropar en aktivitetsfunktion:

[FunctionName("HelloWorld")]
public static async Task<string> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    string result = await context.CallActivityAsync<string>("SayHello", name);
    return result;
}

Anmärkning

Föregående kod är för Durable Functions 2.x. För Durable Functions 1.x måste du använda DurableOrchestrationContext i stället för IDurableOrchestrationContext. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const name = context.df.getInput();
    const result = yield context.df.callActivity("SayHello", name);
    return result;
});

@FunctionName("HelloWorld")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String input = ctx.getInput(String.class);
    String result = ctx.callActivity("SayHello", input, String.class).await();
    return result;
}

Aktivitetsutlösare

Med aktivitetsutlösaren kan du skapa funktioner som anropas av orkestreringsfunktioner, så kallade aktivitetsfunktioner.

Aktivitetsutlösaren konfigureras med attributet ActivityTriggerAttribute .NET.

Aktivitetsutlösaren konfigureras med anteckningen @DurableActivityTrigger .

Aktivitetsutlösaren definieras av följande JSON-objekt i matrisen bindings förfunction.json:

{
    "name": "<Name of input parameter in function signature>",
    "activity": "<Optional - name of the activity>",
    "type": "activityTrigger",
    "direction": "in"
}
  • activity är namnet på aktiviteten. Det här värdet är det namn som orchestrator-funktioner använder för att anropa den här aktivitetsfunktionen. Den här egenskapen är valfri. Om det inte anges används namnet på funktionen.

Hur du definierar en aktivitetsutlösare beror på din valda programmeringsmodell.

Använda dekoratören activity_trigger direkt i python-funktionskoden.

Internt kontrollerar den här utlösarbindningen det konfigurerade varaktiga lagret för nya aktivitetsutförandehändelser.

Utlösarbeteende

Här följer några kommentarer om aktivitetsutlösaren:

  • Trådning – Till skillnad från orkestreringsutlösaren har aktivitetsutlösare inga begränsningar kring trådning eller I/O. De kan behandlas som vanliga funktioner.
  • Hantering av giftmeddelanden – Det finns inget stöd för giftmeddelanden i aktivitetsutlösare.
  • Meddelandesynlighet – Meddelanden från aktivitetsutlösare tas ur kö och görs osynliga under en konfigurerbar tidsperiod. Synligheten för dessa meddelanden förnyas automatiskt så länge funktionsappen körs och är felfri.
  • Returvärden – Returvärden serialiseras till JSON och sparas i det konfigurerade varaktiga arkivet.

Användning av utlösare

Aktivitetsutlösarbindningen stöder både indata och utdata, precis som orkestreringsutlösaren. Här följer några saker att veta om hantering av indata och utdata:

  • inputs – Aktivitetsutlösare kan anropas med indata från en orchestrator-funktion. Alla indata måste vara JSON-serialiserbara.
  • outputs – Aktivitetsfunktioner stöder både utdata- och indatavärden. Returvärdet för funktionen används för att tilldela utdatavärdet och måste vara JSON-serializable.
  • metadata – .NET-aktivitetsfunktioner kan binda till en string instanceId parameter för att hämta instans-ID:t för den anropande orkestreringen.

Utlösarexempel

Följande exempelkod visar hur en enkel SayHello aktivitetsfunktion kan se ut.

[FunctionName("SayHello")]
public static string SayHello([ActivityTrigger] IDurableActivityContext helloContext)
{
    string name = helloContext.GetInput<string>();
    return $"Hello {name}!";
}

Standardparametertypen för .NET-bindningen ActivityTriggerAttribute är IDurableActivityContext (eller DurableActivityContext för Durable Functions v1). .NET-aktivitetsutlösare stöder dock även bindning direkt till JSON-serialiserande typer (inklusive primitiva typer), så att samma funktion kan förenklas på följande sätt:

[FunctionName("SayHello")]
public static string SayHello([ActivityTrigger] string name)
{
    return $"Hello {name}!";
}

module.exports = async function(context) {
    return `Hello ${context.bindings.name}!`;
};

JavaScript-bindningar kan också skickas in som extra parametrar, så samma funktion kan förenklas på följande sätt:

module.exports = async function(context, name) {
    return `Hello ${name}!`;
};

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.activity_trigger(input_name="myInput")
def my_activity(myInput: str):
    return "Hello " + myInput

param($name)

"Hello $name!"

@FunctionName("SayHello")
public String sayHello(@DurableActivityTrigger(name = "name") String name) {
    return String.format("Hello %s!", name);
}

Använda indata- och utdatabindningar

Du kan använda vanliga indata- och utdatabindningar utöver aktivitetsutlösarbindningen.

Du kan till exempel ta indata till din aktivitetsbindning och skicka ett meddelande till en händelsehubb med hjälp av Event Hubs-utdatabindningen:

{
  "bindings": [
    {
      "name": "message",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "eventHub",
      "name": "outputEventHubMessage",
      "connection": "EventhubConnectionSetting",
      "eventHubName": "eh_messages",
      "direction": "out"
  }
  ]
}

module.exports = async function (context) {
    context.bindings.outputEventHubMessage = context.bindings.message;
};

Orkestreringsklient

Med orchestration-klientbindningen kan du skriva funktioner som interagerar med orkestreringsfunktioner. Dessa funktioner kallas ofta för klientfunktioner. Du kan till exempel hantera orkestreringsinstanser på följande sätt:

  • Sätt igång dem.
  • Fråga efter deras status.
  • Avsluta dem.
  • Skicka händelser till dem medan de är igång.
  • Rensa instanshistorik.

Du kan binda till orkestreringsklienten med attributet DurableClientAttribute (OrchestrationClientAttribute i Durable Functions v1.x).

Du kan binda till orkestreringsklienten med hjälp av anteckningen @DurableClientInput .

Den hållbara klientutlösaren definieras av följande JSON-objekt i bindings-matrisen function.json:

{
    "name": "<Name of input parameter in function signature>",
    "taskHub": "<Optional - name of the task hub>",
    "connectionName": "<Optional - name of the connection string app setting>",
    "type": "orchestrationClient",
    "direction": "in"
}
  • taskHub – Används i scenarier där flera funktionsappar delar samma lagringskonto men måste isoleras från varandra. Om det inte anges används standardvärdet från host.json . Det här värdet måste matcha det värde som används av målorkestreringsfunktionerna.
  • connectionName – Namnet på en appinställning som innehåller en anslutningssträng för lagringskontot. Lagringskontot som representeras av den här anslutningssträngen måste vara samma som används av målorkestreringsfunktionerna. Om det inte anges används standardanslutningssträngen för lagringskontot för funktionsappen.

Anmärkning

I de flesta fall rekommenderar vi att du utelämnar dessa egenskaper och förlitar dig på standardbeteendet.

Hur du definierar en varaktig klientutlösare beror på din valda programmeringsmodell.

Använda dekoratören durable_client_input direkt i python-funktionskoden.

Kundanvändning

Du binder vanligtvis till IDurableClient (DurableOrchestrationClient i Durable Functions v1.x), vilket ger dig fullständig åtkomst till alla orkestreringsklient-API:er som stöds av Durable Functions.

Du binder vanligtvis till DurableClientContext klassen.

Du måste använda det språkspecifika SDK:et för att få åtkomst till ett klientobjekt.

Här är ett exempel på en kö-aktiverad funktion som startar en "HelloWorld"-orkestrering.

[FunctionName("QueueStart")]
public static Task Run(
    [QueueTrigger("durable-function-trigger")] string input,
    [DurableClient] IDurableOrchestrationClient starter)
{
    // Orchestration input comes from the queue message content.
    return starter.StartNewAsync<string>("HelloWorld", input);
}

Anmärkning

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

function.json

{
  "bindings": [
    {
      "name": "input",
      "type": "queueTrigger",
      "queueName": "durable-function-trigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

index.js

const df = require("durable-functions");

module.exports = async function (context) {
    const client = df.getClient(context);
    return instanceId = await client.startNew("HelloWorld", undefined, context.bindings.input);
};

run.ps1

param([string] $input, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName $FunctionName -Input $input

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.route(route="orchestrators/{functionName}")
@myApp.durable_client_input(client_name="client")
async def durable_trigger(req: func.HttpRequest, client):
    function_name = req.route_params.get('functionName')
    instance_id = await client.start_new(function_name)
    response = client.create_check_status_response(req, instance_id)
    return response

function.json

{
  "bindings": [
    {
      "name": "input",
      "type": "queueTrigger",
      "queueName": "durable-function-trigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

run.ps1

param([string]$InputData, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName 'HelloWorld' -Input $InputData

@FunctionName("QueueStart")
public void queueStart(
        @QueueTrigger(name = "input", queueName = "durable-function-trigger", connection = "Storage") String input,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    // Orchestration input comes from the queue message content.
    durableContext.getClient().scheduleNewOrchestrationInstance("HelloWorld", input);
}

Mer information om startinstanser finns i Instanshantering.

Entitetsutlösare

Med entitetsutlösare kan du skapa entitetsfunktioner. Den här utlösaren stöder bearbetning av händelser för en specifik entitetsinstans.

Anmärkning

Entitetsutlösare är tillgängliga från och med Durable Functions 2.x.

Inom systemet söker den här utlösarbindningen kontinuerligt i det konfigurerade varaktighetslagret efter nya entitetsoperationer som behöver köras.

Entitetsutlösaren konfigureras med attributet EntityTriggerAttribute .NET.

Entitetsutlösaren definieras av följande JSON-objekt i matrisen bindings förfunction.json:

{
    "name": "<Name of input parameter in function signature>",
    "entityName": "<Optional - name of the entity>",
    "type": "entityTrigger",
    "direction": "in"
}

Som standard är namnet på en entitet namnet på funktionen.

Anmärkning

Entitetsutlösare stöds ännu inte för Java.

Hur du definierar en entitetsutlösare beror på din valda programmeringsmodell.

Använda dekoratören entity_trigger direkt i python-funktionskoden.

Utlösarbeteende

Här följer några kommentarer om entitetsutlösaren:

  • Enkeltrådad: En enda dispatcher-tråd används för att bearbeta åtgärder för en viss entitet. Om flera meddelanden skickas till en enda entitet samtidigt bearbetas åtgärderna en i taget.
  • Hantering av giftmeddelanden – Det finns inget stöd för giftmeddelanden i entitetsutlösare.
  • Meddelandesynlighet – Entitetsutlösarmeddelanden tas ur kö och hålls osynliga under en konfigurerbar varaktighet. Synligheten för dessa meddelanden förnyas automatiskt så länge funktionsappen körs och är felfri.
  • Returvärden – Entitetsfunktioner stöder inte returvärden. Det finns specifika API:er som kan användas för att spara tillstånd eller skicka tillbaka värden till orkestreringar.

Tillståndsändringar som görs i en entitet under körningen sparas automatiskt när körningen har slutförts.

Mer information och exempel på hur du definierar och interagerar med entitetsutlösare finns i dokumentationen om varaktiga entiteter .

Entitetsklient

Med entitetsklientbindningen kan du utlösa entitetsfunktioner asynkront. Dessa funktioner kallas ibland för klientfunktioner.

Du kan binda till entitetsklienten med hjälp av attributet DurableClientAttribute .NET i .NET-klassbiblioteksfunktioner.

Anmärkning

[DurableClientAttribute] Kan också användas för att binda till orkestreringsklienten.

Entitetsklienten definieras av följande JSON-objekt i matrisen bindings förfunction.json:

{
    "name": "<Name of input parameter in function signature>",
    "taskHub": "<Optional - name of the task hub>",
    "connectionName": "<Optional - name of the connection string app setting>",
    "type": "durableClient",
    "direction": "in"
}
  • taskHub – Används i scenarier där flera funktionsappar delar samma lagringskonto men måste isoleras från varandra. Om det inte anges används standardvärdet från host.json . Det här värdet måste matcha värdet som används av målentitetsfunktionerna.
  • connectionName – Namnet på en appinställning som innehåller en anslutningssträng för lagringskontot. Lagringskontot som representeras av den här anslutningssträngen måste vara samma som används av målentitetsfunktionerna. Om det inte anges används standardanslutningssträngen för lagringskontot för funktionsappen.

Anmärkning

I de flesta fall rekommenderar vi att du utelämnar de valfria egenskaperna och förlitar dig på standardbeteendet.

Hur du definierar en entitetsklient beror på din valda programmeringsmodell.

Använda dekoratören durable_client_input direkt i python-funktionskoden.

Anmärkning

Entitetsklienter stöds ännu inte för Java.

Mer information och exempel på hur du interagerar med entiteter som en klient finns i dokumentationen om varaktiga entiteter .

host.json inställningar

Konfigurationsinställningar för Durable Functions.

Anmärkning

Alla större versioner av Durable Functions stöds i alla versioner av Azure Functions-körningen. Schemat för den host.json konfigurationen skiljer sig dock något beroende på vilken version av Azure Functions-körningen och durable functions-tilläggsversionen du använder. Följande exempel är till för användning med Azure Functions 2.0 och 3.0. Om du använder Azure Functions 1.0 i båda exemplen är de tillgängliga inställningarna desamma, men avsnittet "durableTask" i host.json ska gå i roten för host.json konfiguration i stället för som ett fält under "tillägg".

{
 "extensions": {
  "durableTask": {
    "hubName": "MyTaskHub",
    "storageProvider": {
      "connectionStringName": "AzureWebJobsStorage",
      "controlQueueBatchSize": 32,
      "controlQueueBufferThreshold": 256,
      "controlQueueVisibilityTimeout": "00:05:00",
      "maxQueuePollingInterval": "00:00:30",
      "partitionCount": 4,
      "trackingStoreConnectionStringName": "TrackingStorage",
      "trackingStoreNamePrefix": "DurableTask",
      "useLegacyPartitionManagement": false,
      "useTablePartitionManagement": true,
      "workItemQueueVisibilityTimeout": "00:05:00",
    },
    "tracing": {
      "traceInputsAndOutputs": false,
      "traceReplayEvents": false,
    },
    "notifications": {
      "eventGrid": {
        "topicEndpoint": "https://topic_name.westus2-1.eventgrid.azure.net/api/events",
        "keySettingName": "EventGridKey",
        "publishRetryCount": 3,
        "publishRetryInterval": "00:00:30",
        "publishEventTypes": [
          "Started",
          "Completed",
          "Failed",
          "Terminated"
        ]
      }
    },
    "maxConcurrentActivityFunctions": 10,
    "maxConcurrentOrchestratorFunctions": 10,
    "maxConcurrentEntityFunctions": 10,
    "extendedSessionsEnabled": false,
    "extendedSessionIdleTimeoutInSeconds": 30,
    "useAppLease": true,
    "useGracefulShutdown": false,
    "maxEntityOperationBatchSize": 50,
    "maxOrchestrationActions": 100000,
    "storeInputsInOrchestrationHistory": false
  }
 }
}

Namn på aktivitetshubben måste börja med en bokstav och bestå av endast bokstäver och siffror. Om det inte anges är standardnamnet för aktivitetshubben för en funktionsapp TestHubName. Mer information finns i Uppgiftshubbar.

Fastighet Standardinställning Beskrivning
hubNamn TestHubName (DurableFunctionsHub om du använder Durable Functions 1.x) Alternativa namn på aktivitetshubben kan användas för att isolera flera Durable Functions-program från varandra, även om de använder samma lagringsserverdel.
controlQueueBatchSize 32 Antalet meddelanden som ska hämtas från kontrollkön åt gången.
kontrollera köbuffertgräns Förbrukningsplan för Python: 32
Förbrukningsplan för andra språk: 128
Dedikerad/Premium-plan: 256		 Antalet kontrollkömeddelanden som kan buffras i minnet åt gången, vid vilken punkt avvisaren väntar innan eventuella ytterligare meddelanden tas ur kö. I vissa situationer kan en minskning av det här värdet avsevärt minska minnesförbrukningen.
antal partitioner 4 Antalet partitioner för kontrollkön. Kan vara ett positivt heltal mellan 1 och 16. Om du ändrar det här värdet måste du konfigurera en ny aktivitetshubb.
Kontroll av köens synlighetstidsgräns 5 minuter Tidsgränsen för synlighet för meddelanden i kontrollkön efter att de har tagits bort.
synlighetstimeout för arbetsobjektkö 5 minuter Synlighetens tidsgräns för kömeddelanden för uttagna arbetsobjekt.
maximalt antal samtidiga aktivitetsfunktioner Förbrukningsplan: 10
Dedikerad/Premium-plan: 10 X antalet processorer på den aktuella datorn		 Det maximala antalet aktivitetsfunktioner som kan bearbetas samtidigt på en enda värdinstans.
maximalt antal samtidiga orkestratörsfunktioner Förbrukningsplan: 5
Dedikerad/Premium-plan: 10 X antalet processorer på den aktuella datorn		 Det maximala antalet orkestreringsfunktioner som kan bearbetas samtidigt på en enda värdinstans.
Maximala samtidiga enhetsfunktioner Förbrukningsplan: 5
Dedikerad/Premium-plan: 10 X antalet processorer på den aktuella datorn		 Det maximala antalet entitetsfunktioner som kan bearbetas samtidigt på en enda värdinstans. Den här inställningen gäller endast när du använder den varaktiga schemaläggaren. I annat fall begränsas det maximala antalet samtidiga entitetskörningar till maxConcurrentOrchestratorFunctions.
max.köavfrågningsintervall 30 sekunder Maximalt styrnings- och arbetsobjektsavsökningsintervall i formatet hh:mm:ss. Högre värden kan resultera i högre svarstider för meddelandebearbetning. Lägre värden kan leda till högre lagringskostnader på grund av ökade lagringstransaktioner.
connectionName (2.7.0 och senare)
anslutningssträngNamn (2.x)
azureStorageConnectionStringName (1.x)		 AzureWebJobsStorage Namnet på en appinställning eller inställningssamling som anger hur du ansluter till de underliggande Azure Storage-resurserna. När en enskild appinställning anges ska det vara en Azure Storage-anslutningssträng.
trackingStoreConnectionName (2.7.0 och senare)
trackingStoreConnectionStringName		 Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabellerna Historik och Instanser. När en enskild appinställning anges ska det vara en Azure Storage-anslutningssträng. Om det inte anges connectionStringName används anslutningen (Durable 2.x) eller azureStorageConnectionStringName (Durable 1.x).
trackingStoreNamePrefix Prefixet som ska användas för tabellerna Historik och Instanser när trackingStoreConnectionStringName har angetts. Om det inte anges är DurableTaskstandardprefixvärdet . Om trackingStoreConnectionStringName inte anges använder hubName tabellerna Historik och Instanser värdet som prefix, och alla inställningar för trackingStoreNamePrefix ignoreras.
spåraInsatserOchResultat falskt Ett värde som anger om indata och utdata för funktionsanrop ska spåras. Standardbeteendet vid spårning av funktionskörningshändelser är att inkludera antalet byte i serialiserade indata och utdata för funktionsanrop. Det här beteendet ger minimal information om hur indata och utdata ser ut utan att svälla upp loggarna eller oavsiktligt exponera känslig information. Om den här egenskapen sätts till "true" används standardloggningen för att logga hela innehållet i funktionsindata och utdata.
traceReplayEvents falskt Ett värde som anger om orkestreringsreprishändelser ska skrivas till Application Insights.
eventGridTopicEndpoint URL:en för en anpassad Azure Event Grid-ämnesslutpunkt. När den här egenskapen har angetts publiceras orkestreringens livscykelaviseringar till den här slutpunkten. Den här egenskapen stöder lösning av appinställningar.
eventGridNyckelInställningsNamn Namnet på appinställningen som innehåller nyckeln som används för autentisering med Azure Event Grids anpassade ämne på EventGridTopicEndpoint.
eventGridPubliceraOmbrytningsantal 0 Antalet gånger du försöker igen om publiceringen till Event Grid-ämnet misslyckas.
EventGridPubliceringsÅterkopplingsintervall 5 minuter Event Grid publicerar återförsöksintervallet i formatet hh:mm:ss .
eventGridPubliceraHändelsetyper En lista över händelsetyper som ska publiceras till Event Grid. Om det inte anges publiceras alla händelsetyper. Tillåtna värden är Started, Completed, Failed, Terminated.
användAppLease sann När värdet är inställt på truekräver appar att ett bloblån på appnivå hämtas innan aktivitetshubbens meddelanden bearbetas. Mer information finns i dokumentationen om haveriberedskap och geo-distribution . Tillgänglig från och med v2.3.0.
användLegacyPartitionshantering falskt När det är inställt på false använder en partitionshanteringsalgoritm som minskar risken för duplicerad funktionskörning när du skalar ut. Tillgänglig från och med v2.3.0. Det rekommenderas inte att ange det här värdet till true.
AnvändTabellPartitionsHantering true i v3.x-tilläggsversioner
false i v2.x-tilläggsversioner		 När värdet är inställt på trueanvänder en algoritm för partitionshantering som är utformad för att minska kostnaderna för Azure Storage V2-konton. Tillgänglig från och med WebJobs.Extensions.DurableTask v2.10.0. Om du använder den här inställningen med hanterad identitet krävs WebJobs.Extensions.DurableTask v3.x eller senare, eller Worker.Extensions.DurableTask-versioner tidigare än v1.2.x eller senare.
använd smidig avstängning falskt (Förhandsversion) Aktivera graciös nedstängning för att minska risken för att värdavstängningar misslyckas med funktioner som körs under processen.
maxEntityOperationBatchSize(2.6.1) Förbrukningsplan: 50
Dedikerad/Premium-plan: 5000		 Det maximala antalet entitetsåtgärder som bearbetas som en batch. Om värdet är 1 inaktiveras batchbearbetningen och varje åtgärdsmeddelande bearbetas av ett separat funktionsanrop.
lagraIngångarIOrkestreringsHistorik falskt När true är inställt till, uppmanar det Durable Task Framework att spara aktivitetsindata i historiktabellen. Detta gör det möjligt att visa aktivitetsfunktionens indata när du kör frågor mot orkestreringshistoriken.
maximal gRPC-meddelandestorlek i byte 4194304 Ett heltalsvärde som anger den maximala storleken i byte för meddelanden som gRPC-klienten för DurableTaskClient kan ta emot. Detta gäller durable functions .NET Isolated och Java.
grpcHttpClientTimeout 100 sekunder Anger tidsgränsen för HTTP-klienten som används av gRPC-klienten i Durable Functions, som för närvarande stöds för .NET-isolerade appar (.NET 6 och senare versioner) och för Java.

Många av de här inställningarna är till för att optimera prestanda. Mer information finns i Prestanda och skala.

Nästa steg

Inbyggd HTTP API-referens för instanshantering