Bindningar för Durable Functions (Azure Functions)

  • Artikel

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 används Durable Functions-utlösare och bindningar från en instans av DFApp, vilket är en underklass av FunctionApp som dessutom exporterar Durable Functions-specifika 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.

Beteende för utlösare

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 kan orsaka problem med tillägget Durable Task eftersom dessa bindningar kanske inte följer reglerna för enkeltrådning 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.

Utlösaranvändning

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 utdatavärden och indata. 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. Observera att den här exempelorkestreraren faktiskt inte schemalägger 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}!";
}

Kommentar

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

Kommentar

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

Kommentar

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 för bindings function.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 avsöker den här utlösarbindningen det konfigurerade varaktiga arkivet för nya aktivitetskörningshändelser.

Beteende för utlösare

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 – Aktivitetsutlö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 det konfigurerade varaktiga arkivet.

Utlösaranvändning

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 utdatavärden och indata. 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 ytterligare 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 agera på orkestreringsinstanser på följande sätt:

  • Starta dem.
  • Fråga efter deras status.
  • Avsluta dem.
  • Skicka händelser till dem medan de körs.
  • 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 varaktiga klientutlösaren definieras av följande JSON-objekt i matrisen bindingsför 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 ett lagringskonto anslutningssträng. Lagringskontot som representeras av den här anslutningssträng måste vara samma som används av målorkestreringsfunktionerna. Om det inte anges används standardlagringskontot anslutningssträng för funktionsappen.

Kommentar

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.

Klientanvä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öutlöst 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);
}

Kommentar

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.

Kommentar

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

Internt avsöker den här utlösarbindningen det konfigurerade varaktiga arkivet för nya entitetsåtgärder som måste köras.

Entitetsutlösaren konfigureras med attributet EntityTriggerAttribute .NET.

Entitetsutlösaren definieras av följande JSON-objekt i matrisen bindingsför function.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.

Kommentar

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.

Beteende för utlösare

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ö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 – 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.

Kommentar

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

Entitetsklienten definieras av följande JSON-objekt i matrisen bindingsför 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": "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 ett lagringskonto anslutningssträng. Lagringskontot som representeras av den här anslutningssträng måste vara samma som används av målentitetsfunktionerna. Om det inte anges används standardlagringskontot anslutningssträng för funktionsappen.

Kommentar

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.

Kommentar

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.

Kommentar

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 bör 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": true,
      "useTablePartitionManagement": false,
      "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,
    "extendedSessionsEnabled": false,
    "extendedSessionIdleTimeoutInSeconds": 30,
    "useAppLease": true,
    "useGracefulShutdown": false,
    "maxEntityOperationBatchSize": 50,
    "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.

Property Standardvärde beskrivning
hubName 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.
controlQueueBufferThreshold Förbrukningsplan för Python: 32
Förbrukningsplan för JavaScript och C#: 128
Dedikerad/Premium-plan: 256		 Antalet kontrollkömeddelanden som kan buffrads i minnet åt gången, då avsändaren väntar innan eventuella ytterligare meddelanden tas bort.
partitionCount 4 Antalet partitioner för kontrollkön. Kan vara ett positivt heltal mellan 1 och 16.
controlQueueVisibilityTimeout 5 minuter Tidsgränsen för synligheten för meddelanden i kön för dequeued-kontroller.
workItemQueueVisibilityTimeout 5 minuter Tidsgränsen för synligheten för kömeddelanden för dequeued arbetsobjekt.
maxConcurrentActivityFunctions 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.
maxConcurrentOrchestratorFunctions 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.
maxQueuePollingInterval 30 sekunder Det maximala avsökningsintervallet för kontroll och arbetsobjekt 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)
connectionStringName (2.x)
azureStorage Anslut ionStringName (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.
trackingStore Anslut ionName (2.7.0 och senare)
trackingStore Anslut ionStringName		 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.
traceInputsAndOutputs 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 anges till true loggas hela innehållet i funktionsindata och utdata genom att standardfunktionen loggas.
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 orkestreringshändelser för livscykelmeddelanden till den här slutpunkten. Den här egenskapen stöder App Inställningar-lösning.
eventGridKeySettingName Namnet på appinställningen som innehåller nyckeln som används för att autentisera med det anpassade Azure Event Grid-ämnet på EventGridTopicEndpoint.
eventGridPublishRetryCount 0 Antalet gånger du försöker igen om publiceringen till Event Grid-ämnet misslyckas.
eventGridPublishRetryInterval 5 minuter Event Grid publicerar återförsöksintervallet i formatet hh:mm:ss .
eventGridPublishEventTypes 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.
useAppLease true 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.
useLegacyPartitionManagement falskt När det är inställt på falseanvänder använder en partitionshanteringsalgoritm som minskar risken för duplicerad funktionskörning vid utskalning. Tillgänglig från och med v2.3.0.
useTablePartitionManagement falskt 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 v2.10.0. Den här funktionen är för närvarande i förhandsversion och är ännu inte kompatibel med förbrukningsplanen.
useGracefulShutdown falskt (Förhandsversion) Aktivera korrekt avstängning för att minska risken för att värdavstängningar misslyckas med funktionskörningar i 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.
storeInputsInOrchestrationHistory falskt När värdet är inställt på trueanger du till 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.

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