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.

Den här artikeln beskriver användningen av dessa fyra bindningar och innehåller kodexempel. Den innehåller också information om durable functions-konfigurationsegenskaperna i host.json, metadatafilen som innehåller inställningar som påverkar alla funktioner i en funktionsapp.

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

Båda versionerna av Python-programmeringsmodellen för Azure Functions stöds av Durable Functions. Eftersom Python v2 är den rekommenderade versionen innehåller exemplen i den här artikeln exklusivt den här versionen.

Förutsättningar

  • Durable Functions SDK, som är Python Package Index-paketet azure-functions-durable(PyPI), version 1.2.2 eller senare version
  • Tilläggspaketversion 4.x (eller en senare version), som anges i host.json-projektfilen

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

Orkestreringsutlösare

Du kan använda orkestreringsutlösaren för att utveckla hållbara 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 utvecklar funktioner i .NET använder du attributet OrchestrationTriggerAttribute .NET för att konfigurera orkestreringsutlösaren.

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

När du använder version 4 av Node.js programmeringsmodell för att utveckla funktioner importerar app du objektet från modulen @azure/functions npm . Sedan anropar du metoden för app.orchestration Durable Functions-API:et direkt i funktionskoden. Den här metoden registrerar orkestreringsfunktionen med Durable Functions-ramverket.

När du skriver orkestreringsfunktioner definierar du orkestreringsutlösaren med hjälp 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-orchestration>",
    "type": "orchestrationTrigger",
    "direction": "in"
}

Värdet orchestration är namnet på orkestreringen som klienter måste använda när de vill starta nya instanser av orchestrator-funktionen. Den här egenskapen är valfri. Om du inte anger det används namnet på funktionen.

När du använder python v2-programmeringsmodellen kan du definiera en orkestreringsutlösare med hjälp av dekoratören orchestration_trigger direkt i python-funktionskoden.

I v2-modellen får du åtkomst till Durable Functions-utlösare och bindningar från en instans av DFApp. Du kan använda den här underklassen FunctionApp för att exportera dekoratörer som är specifika för Durable Functions.

Internt avsöker den här utlösarbindningen det konfigurerade varaktiga arkivet för nya orkestreringshändelser. Exempel på händelser är 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ågra I/O-åtgärder. 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å aktivitetstyper som är specifika för Durable Functions.
  • 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. Användning av andra bindningar kan orsaka problem med tillägget Durable Task, eftersom dessa bindningar kanske inte följer reglerna för enkel trå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 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 kommentarer om hantering av indata och utdata:

  • Indata: Du kan anropa orkestreringsutlösare som har indata. Indata nås via kontextindataobjektet. Alla indata måste vara JSON-serialiserbara.
  • Utdata: Orkestreringsutlösare stöder både utdata- och indatavärden. Returvärdet för funktionen används för att tilldela utdatavärdet. Returvärdet måste vara JSON-serialiserbart.

Utlösarexempel

Följande kod innehåller ett exempel på en grundläggande Hello World-orkestreringsfunktion. I det här exemplet schemalägger inte orkestreraren några uppgifter.

Attributet som du använder för att definiera utlösaren beror på om du kör C#-funktionerna i samma process som Functions-värdprocessen eller i en isolerad arbetsprocess.

[FunctionName("HelloWorld")]
public static string RunOrchestrator([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 Översikt över Durable Functions-versioner.

const { app } = require('@azure/functions');
const df = require('durable-functions');

df.app.orchestration('helloOrchestrator', function* (context) {
    const name = context.df.getInput();
    return `Hello ${name}`;
});

Anmärkning

Biblioteket durable-functions anropar den synkrona context.done metoden 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. Följande kod innehåller ett Hello World-exempel som visar hur du anropar en aktivitetsfunktion:

[FunctionName("HelloWorld")]
public static async Task<string> RunOrchestrator(
    [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 Översikt över Durable Functions-versioner.

const { app } = require('@azure/functions');
const df = require('durable-functions');

const activityName = 'hello';

df.app.orchestration('helloOrchestrator', function* (context) {
    const name = context.df.getInput();
    const result = yield context.df.callActivity(activityName, 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

Du kan använda aktivitetsutlösaren för att utveckla funktioner som kallas aktivitetsfunktioner som anropas av orkestreringsfunktioner.

Du använder attributet ActivityTriggerAttribute .NET för att konfigurera aktivitetsutlösaren.

Du använder anteckningen @DurableActivityTrigger för att konfigurera aktivitetsutlösaren.

Importera objektet app från modulen @azure/functions npm för att registrera din aktivitetsfunktion. Sedan anropar du metoden för app.activity Durable Functions-API:et direkt i funktionskoden.

Om du vill definiera aktivitetsutlösaren använder du följande JSON-objekt i matrisen bindings förfunction.json:

{
    "name": "<name-of-input-parameter-in-function-signature>",
    "activity": "<optional-name-of-activity>",
    "type": "activityTrigger",
    "direction": "in"
}

Värdet 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 du inte anger det används namnet på funktionen.

Du kan definiera en aktivitetsutlösare med hjälp av 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 för trådning eller I/O-åtgärder. De kan behandlas som vanliga funktioner.
  • Hantering av giftmeddelanden: Det finns inget stöd för giftmeddelanden i aktivitetsutlösare.
  • Meddelandesynlighet: Aktivitetsutlösarmedelanden tas ur kö och förvaras 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.

Användning av utlösare

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

  • Indata: Aktivitetsutlösare kan anropas med indata från en orchestrator-funktion. Alla indata måste vara JSON-serialiserbara.
  • Utdata: 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 kod innehåller ett exempel på en grundläggande Hello World-aktivitetsfunktion .

[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 1.x). .NET-aktivitetsutlösare stöder dock även bindning direkt till JSON-serialiserande typer (inklusive primitiva typer), så du kan också använda följande förenklade version av funktionen:

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

const { app } = require('@azure/functions');
const df = require('durable-functions');
const activityName = 'hello';
df.app.activity(activityName, {
    handler: (input) => {
        return `Hello, ${input}`;
    },
});

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

Förutom aktivitetsutlösarbindningen kan du också använda vanliga indata- och utdatabindningar.

En aktivitetsfunktion kan till exempel ta emot indata från en orchestrator-funktion. Aktivitetsfunktionen kan sedan skicka indata som ett meddelande till Azure Event Hubs.

const { app } = require('@azure/functions');
const df = require('durable-functions');

df.app.orchestration('helloOrchestrator', function* (context) {
    const input = context.df.getInput();
    yield context.df.callActivity('sendToEventHub', input);
    return `Message sent: ${input}`;
});

const { EventHubProducerClient } = require("@azure/event-hubs");
const connectionString = process.env.EVENT_HUB_CONNECTION_STRING;
const eventHubName = process.env.EVENT_HUB_NAME;

df.app.activity("sendToEventHub", {
    handler: async (message, context) => {
        const producer = new EventHubProducerClient(connectionString, eventHubName);
        try {
            const batch = await producer.createBatch();
            batch.tryAdd({ body: message });
            await producer.sendBatch(batch);
            context.log(`Message sent to Event Hubs: ${message}`);
        } catch (err) {
            context.log.error("Failed to send message to Event Hubs:", err);
            throw err;
        } finally {
            await producer.close();
        }
    },
});

app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const orchestratorName = message.orchestratorName || 'helloOrchestrator';
        const input = message.input || null;
        const instanceId = await client.startNew(orchestratorName, { input });
        context.log(`Started orchestration with ID = '${instanceId}'`);
    },
});

Orkestreringsklient

Du kan använda orkestreringsklientbindningen för att 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 instanshistoriken.

Du kan binda till en orkestreringsklient med attributet DurableClientAttribute (OrchestrationClientAttribute i Durable Functions 1.x).

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

Om du vill registrera din klientfunktion importerar du app-objektet från @azure/functions npm-modulen. Sedan anropar du en Durable Functions API-metod som är specifik för din utlösartyp. För en HTTP-utlösare anropar man till exempel metoden app.http. För en köutlösare anropar du app.storageQueue-metoden.

Om du vill definiera den varaktiga klientutlösaren använder du följande JSON-objekt i matrisen bindings förfunction.json:

{
    "name": "<name-of-input-parameter-in-function-signature>",
    "taskHub": "<optional-name-of-task-hub>",
    "connectionName": "<optional-name-of-connection-string-app-setting>",
    "type": "orchestrationClient",
    "direction": "in"
}
  • Egenskapen taskHub används när flera funktionsappar delar samma lagringskonto men måste isoleras från varandra. Om du inte anger den här egenskapen används standardvärdet från host.json . Det här värdet måste matcha värdet som målorkestreringsfunktionerna använder.
  • Värdet connectionName är 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 målorkestreringsfunktionerna använder. Om du inte anger den här egenskapen 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.

Du kan definiera en varaktig klientutlösare med hjälp av dekoratören durable_client_input direkt i python-funktionskoden.

Kundanvändning

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

Du binder vanligtvis till DurableClientContext klassen.

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

Följande kod innehåller ett exempel på en kö-baserad funktion som startar en Hello World-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

Föregående C#-kod ä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 Översikt över Durable Functions-versioner.

const { app } = require('@azure/functions');
const df = require('durable-functions');

app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const orchestratorName = message.orchestratorName || 'helloOrchestrator';
        const input = message.input || null;
        const instanceId = await client.startNew(orchestratorName, { input });
        context.log(`Started orchestration with ID = '${instanceId}' from queue message.`);
    },
});

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

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

@myApp.queue_trigger(
    arg_name="msg",
    queue_name="start-orchestration",
    connection="AzureWebJobsStorage"
)
@myApp.durable_client_input(client_name="client")
async def client_function(msg: func.QueueMessage, client: df.DurableOrchestrationClient):
    input_data = msg.get_body().decode("utf-8")
    await client.start_new("my_orchestrator", None, input_data)
    return None

function.json

{
  "bindings": [
    {
      "name": "InputData",
      "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);
}

Detaljerad information om hur du startar instanser finns i Hantera instanser i Durable Functions i Azure.

Entitetsutlösare

Du kan använda entitetsutlösaren för att utveckla en entitetsfunktion. 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.

Du använder attributet EntityTriggerAttribute .NET för att konfigurera entitetsutlösaren.

För att registrera entitetsutlösaren importerar du objektet app från modulen @azure/functions npm. Sedan anropar du metoden för app.entity Durable Functions-API:et direkt i funktionskoden.

const df = require('durable-functions');
df.app.entity('counter', (context) => {
    const currentValue = context.df.getState(() => 0);
    switch (context.df.operationName) {
        case 'add':
            context.df.setState(currentValue + context.df.getInput());
            break;
        case 'reset':
            context.df.setState(0);
            break;
        case 'get':
            context.df.return(currentValue);
            break;
    }
});

Anmärkning

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

Anmärkning

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

Du kan definiera en entitetsutlösare med hjälp av dekoratören entity_trigger direkt i python-funktionskoden.

Utlösarbeteende

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

  • Enkeltrådning: 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 du kan använda 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 lagras automatiskt efter att körningen är avslutad.

Mer information och exempel på hur du definierar och interagerar med entitetsutlösare finns i Entitetsfunktioner.

Entitetsklient

Du kan använda entitetsklientbindningen för att asynkront utlösa entitetsfunktioner. Dessa funktioner kallas ibland för klientfunktioner.

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

Anmärkning

Du kan också använda [DurableClientAttribute] för att binda till orkestreringsklienten.

I stället för att registrera en entitetsklient använder signalEntity eller callEntity anropar du en entitetsutlösarmetod från en registrerad funktion.

  • Från en köutlöst funktion kan du använda client.signalEntity:

    const { app } = require('@azure/functions');
const df = require('durable-functions');
app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const entityId = new df.EntityId('counter', 'myCounter');
        await client.signalEntity(entityId, 'add', 5);
    },
});

  • Från en orchestrator-funktion kan du använda context.df.callEntity:

    const { app } = require('@azure/functions');
const df = require('durable-functions');
df.app.orchestration('entityCaller', function* (context) {
    const entityId = new df.EntityId('counter', 'myCounter');
    yield context.df.callEntity(entityId, 'add', 5);
    yield context.df.callEntity(entityId, 'add', 5);
    const result = yield context.df.callEntity(entityId, 'get');
    return result;
});

Du kan definiera en entitetsklient med hjälp av dekoratören durable_client_input direkt i python-funktionskoden.

Anmärkning

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

Anmärkning

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

Mer information och exempel på hur du interagerar med entiteter som en klient finns i Åtkomstentiteter.

Durable Functions-inställningar i host.json

Det här avsnittet innehåller information om konfigurationsegenskaperna för Durable Functions i host.json. Information om allmänna inställningar i host.jsonfinns i host.json referens för Azure Functions 1.x eller host.json referens för Azure Functions 2.x och senare.

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 host.json konfigurationen skiljer sig dock något beroende på vilken version av Azure Functions-körningen och vilken version av Durable Functions-tillägget du använder.

Följande kod innehåller två exempel på durableTask inställningar i host.json: en för Durable Functions 2.x och ett för Durable Functions 1.x. Du kan använda båda exemplen med Azure Functions 2.0 och 3.0. Med Azure Functions 1.0 är de tillgängliga inställningarna desamma, men durableTask avsnittet host.json finns i roten av host.json-konfigurationen i stället för att vara ett fält under .

{
 "extensions": {
  "durableTask": {
    "hubName": "MyTaskHub",
    "defaultVersion": "1.0",
    "versionMatchStrategy": "CurrentOrOlder",
    "versionFailureStrategy": "Reject",
    "storageProvider": {
      "connectionStringName": "AzureWebJobsStorage",
      "controlQueueBatchSize": 32,
      "controlQueueBufferThreshold": 256,
      "controlQueueVisibilityTimeout": "00:05:00",
      "FetchLargeMessagesAutomatically": true,
      "maxQueuePollingInterval": "00:00:30",
      "partitionCount": 4,
      "trackingStoreConnectionStringName": "TrackingStorage",
      "trackingStoreNamePrefix": "DurableTask",
      "useLegacyPartitionManagement": false,
      "useTablePartitionManagement": true,
      "workItemQueueVisibilityTimeout": "00:05:00",
      "QueueClientMessageEncoding": "UTF8"
    },
    "tracing": {
      "traceInputsAndOutputs": false,
      "traceReplayEvents": false,
    },
    "httpSettings":{
      "defaultAsyncRequestSleepTimeMilliseconds": 30000,
      "useForwardedHost": 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
  }
 }
}
Fastighet Standardvärde Beskrivning
hubNamn TestHubName (DurableFunctionsHub i v1.x) Namnet på hubben som lagrar det aktuella tillståndet för en funktionsapp. Namn på aktivitetshubben måste börja med en bokstav och bestå av endast bokstäver och siffror. Om du inte anger något namn används standardvärdet. 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. Mer information finns i Uppgiftshubbar.
defaultVersion (standardversion) Förinställd version för att tilldela till nya orkestreringsinstanser. När du anger en version associeras nya orkestreringsinstanser permanent med det här versionsvärdet. Den här inställningen används av funktionen för orkestreringsversionering för att aktivera scenarier som distributioner utan driftstopp med genombrottsförändringar. Du kan använda valfritt strängvärde för versionen.
versionMatchStrategy AktuellEllerÄldre Ett värde som anger hur orkestreringsversioner matchas när orkestreringsfunktioner läses in. Giltiga värden är None, Strictoch CurrentOrOlder. Detaljerade förklaringar finns i Orkestreringsversionering.
strategi för versionsfel Avvisa Ett värde som anger vad som händer när en orkestreringsversion inte matchar det aktuella defaultVersion värdet. Giltiga värden är Reject och Fail. Detaljerade förklaringar finns i Orkestreringsversionering.
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 eller Premium-plan: 256		 Antalet kontrollkömeddelanden som kan bufferas i minnet åt gången. När det angivna numret har nåtts väntar distributören innan andra meddelanden köas av. 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. Det här värdet måste 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 00:05:00 Tidsgränsen för synligheten för dequeued-kontrollkömeddelanden i hh:mm:ss-format .
synlighetstimeout för arbetsobjektkö 00:05:00 Synlighetstidsgränsen för kömeddelanden för borttagna arbetsobjekt i hh:mm:ss format.
HämtaStoraMeddelandenAutomatiskt sann Ett värde som anger om stora meddelanden ska hämtas i orkestreringsstatusfrågor. När den här inställningen är truehämtas stora meddelanden som överskrider gränsen för köstorlek. När den här inställningen är falsehämtas en blob-URL som pekar på varje stort meddelande.
maximalt antal samtidiga aktivitetsfunktioner Förbrukningsplan: 10
Dedikerad eller Premium-plan: 10 gånger så många 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 eller Premium-plan: 10 gånger så många 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 eller Premium-plan: 10 gånger så många 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 värdet.
max.köavfrågningsintervall 00:00:30 Det maximala avsökningsintervallet för kontroll och arbetsobjekt i hh:mm:ss-format . 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.
maxOrchestrationActions 100,000 Det maximala antalet åtgärder som en orkestreringsfunktion kan utföra under en enda körningscykel.
connectionName (v2.7.0 och senare)
connectionStringName (v2.x)
azureStorageConnectionStringName (v1.x)		 AzureWebJobsStorage Namnet på en appinställning eller inställningssamling som anger hur du ansluter till de underliggande Azure Storage-resurserna. När du anger en enda appinställning bör det vara en Azure Storage-anslutningssträng.
trackingStoreConnectionName (v2.7.0 och senare)
trackingStoreConnectionStringName		 Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabellerna Historik och Instanser, som lagrar körningshistoriken och metadata om orkestreringsinstanser. När du anger en enda appinställning bör det vara en Azure Storage-anslutningssträng. Om du inte anger någon inställning, används connectionStringName-värdet (v2.x) eller azureStorageConnectionStringName-värdet (v1.x).
trackingStoreNamePrefix Prefixet som ska användas för tabellerna Historik och Instanser när trackingStoreConnectionStringName har angetts. Om du inte anger något prefix används standardvärdet DurableTask för . Om trackingStoreConnectionStringName inte anges använder tabellerna Historik och Instanser värdet hubName som prefix och inställningen trackingStoreNamePrefix ignoreras.
spåraInsatserOchResultat falskt Ett värde som anger om indata och utdata för funktionsanrop ska spåras. När funktioners körningshändelser spåras är standardinställningen att inkludera antalet byte i serialiserade indata och utdata för funktionsanrop. Det här beteendet ger minimal information om indata och utdata så att loggarna inte blir uppsvällda eller oavsiktligt exponerar känslig information. När den här egenskapen är trueloggas hela innehållet i funktionsindata och utdata.
traceReplayEvents falskt Ett värde som anger om orkestreringsreprishändelser ska skrivas till Application Insights.
loggaUppspelningshändelser falskt Ett värde som anger huruvida repriserade körningar ska loggas i programloggarna.
eventGridTopicEndpoint URL:en för en anpassad Azure Event Grid-ämnesslutpunkt. När du anger den här egenskapen publiceras orkestreringens livscykelmeddelanden 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 att autentisera med det anpassade Event Grid-ämnet på EventGridTopicEndpoint URL:en.
eventGridPubliceraOmbrytningsantal 0 Antalet gånger du försöker igen om publiceringen till Event Grid-ämnet misslyckas.
EventGridPubliceringsÅterkopplingsintervall 00:05:00 Event Grids publicerings- och återförsöksintervall i formatet hh:mm:ss.
eventGridPubliceraHändelsetyper En lista över händelsetyper som ska publiceras till Event Grid. Om du inte anger några typer publiceras alla händelsetyper. Tillåtna värden är Started, Completed, Failedoch Terminated.
extendedSessionsEnabled falskt Ett värde som anger om sessionsorkestrerings- och entitetsfunktionssessioner cachelagras.
utökadSessionVilotidsgränsISekunder 30 Antalet sekunder som en inaktiv orkestrerings- eller entitetsfunktion finns kvar i minnet innan den tas bort. Den här inställningen används endast när inställningen extendedSessionsEnabled är true.
användAppLease sann Ett värde som anger om appar måste skaffa ett blob-leasing på appnivå innan meddelanden i aktivitetshubben bearbetas. För mer information, se haveriberedskap och geodistribution i Durable Functions. Den här inställningen är tillgänglig från och med v2.3.0.
användLegacyPartitionshantering falskt Ett värde som anger vilken typ av partitionshanteringsalgoritm som ska användas. När den här inställningen är falseanvänds en algoritm som minskar risken för duplicerad funktionskörning vid utskalning. Den här inställningen är tillgänglig från och med v2.3.0. Det rekommenderas inte att sätta det här värdet till true.
AnvändTabellPartitionsHantering I v3.x: true
I v2.x: false		 Ett värde som anger vilken typ av partitionshanteringsalgoritm som ska användas. När den här inställningen är trueanvänds en algoritm som är utformad för att minska kostnaderna för Azure Storage v2-konton. Den här inställningen är tillgänglig från och med WebJobs.Extensions.DurableTask v2.10.0. Om du använder den här inställningen med en hanterad identitet krävs WebJobs.Extensions.DurableTask v3.x eller senare, eller Worker.Extensions.DurableTask v1.2.x eller senare.
använd smidig avstängning falskt (Förhandsversion) Ett värde som anger om du ska stänga av korrekt för att minska risken för att värdavstängningar orsakar att funktionskörningar i processen misslyckas.
maxEntityOperationBatchSize Förbrukningsplan: 50
Dedikerad eller Premium-plan: 5 000		 Det maximala antalet entitetsåtgärder som bearbetas som en batch. Om det här värdet är 1 inaktiveras batchbearbetningen och ett separat funktionsanrop bearbetar varje åtgärdsmeddelande. Den här inställningen är tillgänglig från och med v2.6.1.
lagraIngångarIOrkestreringsHistorik falskt Ett värde som anger hur indata ska lagras. När den här inställningen är truesparar Durable Task Framework aktivitetsindata i tabellen Historik och aktivitetsfunktionens indata visas i orkestreringshistorikens frågeresultat.
maximal gRPC-meddelandestorlek i byte 4,194,304 Ett heltalsvärde som anger den maximala storleken i byte för meddelanden som den allmänna gRPC-klienten (Remote Procedure Call) kan ta emot. Implementeringen av DurableTaskClient använder gRPC-klienten för att hantera orkestreringsinstanser. Den här inställningen gäller för Durable Functions .NET-isolerade arbets- och Java-appar.
grpcHttpClientTimeout 00:01:40 Tidsgränsen i hh:mm:ss-format för HTTP-klienten som används av gRPC-klienten i Durable Functions. Klienten stöds för närvarande för .NET-isolerade arbetsappar (.NET 6 och senare versioner) och för Java-appar.
QueueClientMessageEncoding UTF8 Kodningsstrategin för Azure Queue Storage-meddelanden. Giltiga strategier är Unicode Transformation Format–8-bitars (UTF8) och Base64. Den här inställningen gäller när du använder Microsoft.Azure.WebJobs.Extensions.DurableTask 3.4.0 eller senare, eller Microsoft.Azure.Functions.Worker.Extensions.DurableTask 1.7.0 eller senare.
standardAsynkronBegäranSovtidMillisekunder 30000 Standardintervallet för avsökning i millisekunder för asynkrona HTTP-API:er. När en klient avsöker statusen för en långvarig orkestrering med hjälp av HTTP-statusfrågans slutpunkt avgör det här värdet hur länge klienten ska vänta innan avsökningen görs igen.
useForwardedHost falskt När värdet är inställt på sant använder tillägget HTTP-rubrikerna X-Forwarded-Host och X-Forwarded-Proto för att konstruera URL:er i HTTP-svar.

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

  • Last updated on