Sdílet prostřednictvím

Vazby pro trvalé funkce (Azure Functions)

Rozšíření Durable Functions zavádí tři spouštěcí vazby, které řídí provádění funkcí orchestrátoru, entity a aktivit. Zavádí také výstupní vazbu, která funguje jako klient modulu runtime Durable Functions.

Tento článek popisuje použití těchto čtyř vazeb a obsahuje ukázky kódu. Poskytuje také informace o vlastnostech konfigurace Durable Functions v host.json, soubor metadat obsahující nastavení, která ovlivňují všechny funkce v aplikaci funkcí.

Nezapomeňte vybrat vývojový jazyk Durable Functions v horní části článku.

Durable Functions podporuje obě verze programovacího modelu Pythonu pro Azure Functions . Vzhledem k tomu, že Python v2 je doporučená verze, příklady v tomto článku výhradně obsahují tuto verzi.

Požadavky

V úložišti Durable Functions SDK pro Python můžete poskytnout zpětnou vazbu a návrhy.

Spouštěč orchestrace

Ke spouštění trvalých funkcí orchestrátoru můžete použít spouštěč orchestrací. Tato aktivační událost se spustí, když je naplánována nová instance orchestrace a když existující instance orchestrace obdrží událost. Mezi příklady událostí, které můžou aktivovat funkce orchestrátoru, patří trvalé vypršení platnosti časovače, odpovědi na funkce aktivity a události vyvolané externími klienty.

Při vývoji funkcí v .NET použijete atribut OrchestrationTriggerAttribute .NET ke konfiguraci triggeru orchestrace.

Pro Javu použijete poznámku @DurableOrchestrationTrigger ke konfiguraci triggeru orchestrace.

Při použití verze 4 programovacího modelu Node.js k vývoji funkcí importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.orchestration rozhraní Durable Functions API přímo v kódu funkce. Tato metoda zaregistruje funkci orchestrátoru v rámci Durable Functions.

Při psaní funkcí orchestrátoru definujete trigger orchestrace pomocí následujícího objektu JSON v bindings poli souborufunction.json :

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

Hodnota orchestration je název orchestrace, kterou klienti musí použít, když chtějí spustit nové instance funkce orchestrátoru. Tato vlastnost je nepovinná. Pokud ji nezadáte, použije se název funkce.

Při použití programovacího modelu Pythonu v2 můžete definovat trigger orchestrace pomocí orchestration_trigger dekorátoru přímo v kódu funkce Pythonu.

V modelu v2 přistupujete k triggerům a vazbám Durable Functions z instance DFApp. Tuto podtřídu můžete použít k exportu dekorátorů, které jsou specifické pro FunctionApp Durable Functions.

Tato vazba triggeru interně dotazuje nakonfigurované trvalé úložiště pro nové události orchestrace. Mezi příklady událostí patří události zahájení orchestrace, události vypršení platnosti trvalých časovačů, události odezvy funkce aktivity a externí události vyvolané jinými funkcemi.

Chování spouštěče

Zde je několik poznámek k spouštěči této orchestrace:

  • Jednovláknové: Jedno vlákno dispečeru se používá pro všechna spuštění funkce orchestrátoru v jedné instanci hostitele. Z tohoto důvodu je důležité zajistit, aby byl kód funkce orchestrátoru efektivní a neprovádí žádné vstupně-výstupní operace. Je také důležité zajistit, aby toto vlákno neprovádí žádnou asynchronní práci s výjimkou čekání na typy úloh, které jsou specifické pro Durable Functions.
  • Zpracování jedových zpráv: V aktivačních událostech orchestrace není podpora pro jedové zprávy.
  • Viditelnost zpráv: Spouštěcí zprávy orchestrace jsou vyřazeny z fronty a zůstávají neviditelné po stanovenou dobu. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Návratové hodnoty se serializují do formátu JSON a uchovávají se v tabulce historie orchestrace ve službě Azure Table Storage. Tyto návratové hodnoty mohou být dotazovány prostřednictvím klientské vazby orchestrace, jak je popsáno později.

Výstraha

Funkce orchestratoru by nikdy neměly používat žádné vstupní nebo výstupní vazby kromě vazby aktivační události orchestrace. Použití jiných vazeb může způsobit problémy s rozšířením Durable Task, protože tyto vazby nemusí dodržovat pravidla jednovláknového zpracování a I/O operací. Pokud chcete použít jiné vazby, přidejte je do funkce aktivity, kterou voláte z funkce orchestrátoru. Další informace o kódování omezení pro funkce orchestrátoru naleznete v tématu Omezení kódu funkce orchestratoru.

Výstraha

Funkce orchestrátoru by nikdy neměly být deklarovány async.

Aktivace využití

Vazba orchestračního triggeru podporuje vstupy i výstupy. Tady je několik poznámek ke zpracování vstupu a výstupu:

  • Vstupy: Můžete vyvolat spouštěče orchestrace, které mají vstupy. Vstupy jsou přístupné prostřednictvím kontextového vstupního objektu. Všechny vstupy musí být serializovatelné ve formátu JSON.
  • Výstupy: Triggery orchestrace podporují výstupní i vstupní hodnoty. Návratová hodnota funkce slouží k přiřazení výstupní hodnoty. Návratová hodnota musí být serializovatelná ve formátu JSON.

Ukázka spouštěče

Následující kód poskytuje příklad základní funkce orchestratoru Hello World . Tento příklad orchestrátor neplánuje žádné úlohy.

Atribut, který použijete k definování triggeru, závisí na tom, jestli spouštíte funkce jazyka C# ve stejném procesu jako hostitelský proces služby Functions nebo v izolovaném pracovním procesu.

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

Poznámka:

Předchozí kód je pro Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí Durable Functions.

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

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

Poznámka:

Knihovna durable-functions volá synchronní context.done metodu, když dojde k ukončení funkce generátoru.

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

Většina funkcí orchestrátoru volá funkce aktivit. Následující kód poskytuje příklad Hello World , který ukazuje, jak volat funkci aktivity:

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

Poznámka:

Předchozí kód je pro Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí Durable Functions.

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

Spouštěč aktivity

K vývoji funkcí nazývaných funkce aktivit, které jsou volány funkcemi orchestrátoru, můžete použít trigger aktivity.

Ke konfiguraci triggeru aktivity použijete atribut ActivityTriggerAttribute .NET.

K nakonfigurování spouštěče aktivity použijete @DurableActivityTrigger poznámku.

Pokud chcete zaregistrovat funkci aktivity, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.activity rozhraní Durable Functions API přímo v kódu funkce.

K definování triggeru aktivity použijete následující objekt JSON v bindings poli function.json:

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

Hodnota activity je název aktivity. Tato hodnota je název, který funkce orchestrátoru používají k vyvolání této funkce aktivity. Tato vlastnost je nepovinná. Pokud ji nezadáte, použije se název funkce.

Trigger aktivity můžete definovat pomocí dekorátoru activity_trigger přímo v kódu funkce Pythonu.

Aktivační vazba interně sleduje nakonfigurované trvalé úložiště pro nové události týkající se spouštění aktivit.

Chování spouštěče

Tady je několik poznámek k triggeru aktivity:

  • Threading: Na rozdíl od triggeru orchestrace nemají triggery aktivit žádná omezení pro operace podprocesů nebo vstupně-výstupních operací. Mohou být považovány za běžné funkce.
  • Zpracování jedových zpráv: U aktivačních událostí aktivity není podporována žádná podpora otrávných zpráv.
  • Viditelnost zpráv: Zprávy spouštěče aktivity jsou vyřazeny z fronty a stávají se neviditelnými po konfigurovatelnou dobu trvání. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Návratové hodnoty se serializují do formátu JSON a uchovávají se v nakonfigurovaném trvalém úložišti.

Aktivace využití

Vazba spouštěče aktivity podporuje jak vstupy, tak výstupy, stejně jako spouštěč orchestrace. Tady je několik poznámek ke zpracování vstupu a výstupu:

  • Vstupy: Aktivační události aktivity lze spustit s využitím vstupů z funkce orchestrátoru. Všechny vstupy musí být serializovatelné ve formátu JSON.
  • Výstupy: Funkce aktivit podporují výstupní i vstupní hodnoty. Návratová hodnota funkce se používá k přiřazení výstupní hodnoty a musí být serializovatelná ve formátu JSON.
  • Metadata: Funkce aktivit .NET mohou se svázat s parametrem string instanceId, aby získaly ID instance orchestrace, která je volá.

Ukázka spouštěče

Následující kód poskytuje příklad základní funkce aktivity Hello World .

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

Výchozí typ parametru pro vazbu .NET ActivityTriggerAttribute je IDurableActivityContext (nebo DurableActivityContext pro Durable Functions 1.x). Triggery aktivit .NET ale podporují vazbu přímo na typy serializovatelné ve formátu JSON (včetně primitivních typů), takže můžete také použít následující zjednodušenou verzi funkce:

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

Použití vstupních a výstupních vazeb

Kromě vazby spouštěče aktivity můžete také použít běžné vstupní a výstupní vazby.

Například funkce aktivity může přijímat vstupy z funkce orchestrátoru. Funkce aktivity pak může tento vstup odeslat jako zprávu do služby 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}'`);
    },
});

Klient pro orchestraci

Vazbu klienta orchestrace můžete použít k zápisu funkcí, které pracují s funkcemi orchestrátoru. Tyto funkce se často označují jako klientské funkce. Například můžete pracovat s orchestračními instancemi následujícími způsoby:

  • Začněte s nimi.
  • Zadejte dotaz na jejich stav.
  • Zlikvidujte je.
  • Posílejte jim události, když jsou spuštěné.
  • Vymažte historii instancí.

S klientem orchestrace můžete vytvořit vazbu pomocí atributu DurableClientAttribute (OrchestrationClientAttribute v Durable Functions 1.x).

Pomocí poznámky @DurableClientInput můžete vytvořit vazbu s klientem orchestrace.

Pokud chcete zaregistrovat funkci klienta, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu rozhraní API Durable Functions specifickou pro váš typ triggeru. Například pro trigger HTTP voláte metodu app.http . Pro spouštěč fronty zavoláte metodu app.storageQueue.

K definování triggeru trvalého klienta použijete následující objekt JSON v poli bindings pole function.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"
}
  • Tato taskHub vlastnost se používá, když několik funkčních aplikací sdílí stejný účet úložiště, ale musí být navzájem izolovány. Pokud tuto vlastnost nezadáte, použije se výchozí hodnota z host.json . Tato hodnota musí odpovídat hodnotě, kterou používají funkce cílového orchestrátoru.
  • Hodnota connectionName je název nastavení aplikace, které obsahuje připojovací řetězec účtu úložiště. Účet úložiště reprezentovaný tímto připojovacím řetězcem musí být stejný, který používá funkce cílového orchestrátoru. Pokud tuto vlastnost nezadáte, použije se výchozí připojovací řetězec účtu úložiště pro aplikaci funkcí.

Poznámka:

Ve většině případů doporučujeme vynechat tyto vlastnosti a spoléhat se na výchozí chování.

Aktivační událost odolného klienta můžete definovat pomocí dekorátoru durable_client_input přímo v kódu funkce Pythonu.

Použití klienta

Obvykle se svážete s implementací IDurableClient (DurableOrchestrationClient v Durable Functions 1.x), která poskytuje úplný přístup ke všem klientským rozhraním API orchestrace, která Durable Functions podporuje.

Obvykle se připojíte ke třídě DurableClientContext.

Pokud chcete získat přístup k objektu klienta, musíte použít sadu SDK specifickou pro jazyk.

Následující kód ukazuje příklad funkce spuštěné pomocí fronty, která zahajuje proces orchestrace nazvaný Hello World.

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

Poznámka:

Předchozí kód jazyka C# je pro Durable Functions 2.x. Pro Durable Functions 1.x, musíte použít OrchestrationClient atribut místo DurableClient atributu a musíte použít DurableOrchestrationClient typ parametru místo IDurableOrchestrationClient. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí Durable Functions.

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

Podrobné informace o spouštění instancí najdete v tématu Správa instancí v Durable Functions v Azure.

Entita spouštěče

Trigger entity můžete použít k vývoji funkce entity. Tento trigger podporuje zpracování událostí pro konkrétní instanci entity.

Poznámka:

Spouště entit jsou k dispozici od Durable Functions 2.x.

Interně tato spouštěcí vazba pravidelně kontroluje nakonfigurované trvalé úložiště pro nové operace entity, které je třeba vykonat.

Ke konfiguraci triggeru entity použijete atribut EntityTriggerAttribute .NET.

Pokud chcete zaregistrovat trigger entity, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.entity rozhraní Durable Functions API přímo v kódu funkce.

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

Poznámka:

Triggery entit zatím nejsou pro Javu podporované.

Poznámka:

Spouštěče entit se zatím pro PowerShell nepodporují.

Trigger entity můžete definovat pomocí dekorátoru entity_trigger přímo v kódu funkce Pythonu.

Chování spouštěče

Tady je několik poznámek k triggeru entity:

  • Jednovláknové: Jedno vlákno dispečeru se používá ke zpracování operací pro konkrétní entitu. Pokud se do jedné entity současně odesílá více zpráv, operace se zpracovávají postupně.
  • Zpracování jedových zpráv: U triggerů entit není podpora pro jedové zprávy.
  • Viditelnost zpráv: Zprávy triggeru entity jsou vyřazeny z fronty a jsou neviditelné po konfigurovatelnou dobu trvání. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Funkce entit nepodporují návratové hodnoty. Existují specifická rozhraní API, která můžete použít k uložení stavu nebo předání hodnot zpět do orchestrací.

Všechny změny stavu provedené v entitě během provádění se po dokončení provádění automaticky zachovají.

Další informace a příklady definování a interakce s triggery entit naleznete v tématu Funkce entity.

Klientská entita

Pomocí vazby klienta entity můžete asynchronně aktivovat funkce entit. Tyto funkce se někdy označují jako klientské funkce.

S klientem entity můžete vytvořit vazbu pomocí atributu DurableClientAttribute .NET ve funkcích knihovny tříd .NET.

Poznámka:

Můžete také použít [DurableClientAttribute] k propojení s orchestračním klientem.

Místo registrace klienta entity zavoláte pomocí signalEntity nebo callEntity metodu spouštěče entity z jakékoli registrované funkce.

  • Z frontou aktivované funkce můžete použít 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);
    },
});

  • Z funkce orchestrátoru můžete použít 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;
});

Klienta entity můžete definovat pomocí dekorátoru durable_client_input přímo v kódu funkce Pythonu.

Poznámka:

Klienti entit zatím nejsou pro Javu podporovaní.

Poznámka:

Klienti entit zatím nejsou v PowerShellu podporovaní.

Další informace a příklady interakce s entitami jako klienta najdete v tématu Přístupové entity.

Nastavení Durable Functions v host.json

Tato část obsahuje informace o vlastnosti konfigurace Durable Functions v host.json. Informace o obecných nastaveních v host.jsonnajdete v host.json referenčních informacích ke službě Azure Functions 1.x nebo host.json pro Azure Functions 2.x a novější.

Nastavení konfigurace pro Durable Functions

Poznámka:

Všechny hlavní verze Durable Functions jsou podporovány ve všech verzích modulu runtime Azure Functions. Schéma konfigurace host.json se ale mírně liší v závislosti na verzi modulu runtime Azure Functions a verzi rozšíření Durable Functions, kterou používáte.

Následující kód obsahuje dva příklady durableTask nastavení v host.json: jeden pro Durable Functions 2.x a jeden pro Durable Functions 1.x. Oba příklady můžete použít se službou Azure Functions 2.0 a 3.0. S Azure Functions 1.0 jsou dostupná nastavení stejná, ale část durableTask v souboru host.json se nachází v kořenovém adresáři konfigurace host.json místo toho, aby byla polem pod extensions.

{
 "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,
    },
    "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
  }
 }
}
Vlastnictví Výchozí hodnota Popis
název uzlu TestHubName (DurableFunctionsHub v 1.x) Název centra, ve které je uložen aktuální stav aplikace funkcí. Názvy centra úkolů musí začínat písmenem a obsahovat pouze písmena a číslice. Pokud nezadáte název, použije se výchozí hodnota. Názvy alternativních center úloh se dají použít k izolaci více aplikací Durable Functions od sebe, i když používají stejný back-end úložiště. Další informace najdete v tématu Centra úloh.
Verze defaultVersion Výchozí verze, která se má přiřadit k novým instancím orchestrace. Při zadávání verze jsou nové instance orchestrace trvale přidruženy k této hodnotě verze. Toto nastavení používá funkce správy verzí orchestrace k povolení scénářů, jako jsou nasazení bez výpadků i při provádění zásadních změn. Pro verzi můžete použít libovolnou řetězcovou hodnotu.
strategiePorovnáníVerzí Aktuální nebo starší Hodnota, která určuje, jak se verze orchestrace slaďují při načítání funkcí orchestrátoru. Platné hodnoty jsou None, Stricta CurrentOrOlder. Podrobné vysvětlení najdete v tématu Verzování orchestrace.
strategie při selhání verze Odmítat Hodnota, která určuje, co se stane, když verze orchestrace neodpovídá aktuální defaultVersion hodnotě. Platné hodnoty jsou Reject a Fail. Podrobné vysvětlení najdete v tématu Verzování orchestrace.
controlQueueBatchSize 32 Počet zpráv, které se mají v jeden okamžik stáhnout z řídicí fronty
controlQueueBufferThreshold Plán spotřeby pro Python: 32
Plán spotřeby pro další jazyky: 128
Vyhrazený plán nebo Plán Premium: 256		 Počet zpráv řídicí fronty, které lze najednou uchovávat v paměťovém bufferu. Po dosažení zadaného čísla bude dispečer čekat před vyřazením dalších zpráv. V některých situacích může snížení této hodnoty významně snížit spotřebu paměti.
partitionCount 4 Počet oddílů v řídící frontě. Tato hodnota musí být kladné celé číslo od 1 do 16. Změna této hodnoty vyžaduje konfiguraci nového centra úloh.
řízení doby viditelnosti fronty 00:05:00 Časový limit viditelnosti zpráv odstrěněných z řídicí fronty ve formátu hh:mm:ss.
Časový limit viditelnosti fronty úkolů (workItemQueueVisibilityTimeout) 00:05:00 Časový limit viditelnosti zpráv ve frontě vyřazených pracovních položek ve formátu hh:mm:ss.
ZískatVelkéZprávyAutomaticky pravda Hodnota, která určuje, jestli se mají načítat velké zprávy v dotazech na stav orchestrace. Při tomto nastavení se truenačtou velké zprávy, které překračují limit velikosti fronty. Při tomto nastavení se falsenačte adresa URL objektu blob, která odkazuje na každou velkou zprávu.
MaximálníPočetSoučasnýchFunkcíAktivit Plán spotřeby: 10
Vyhrazený plán nebo plán Premium: 10krát počet procesorů na aktuálním počítači		 Maximální počet funkcí aktivity, které mohou být současně zpracovány na jedné hostitelské instanci.
maximálníPočetSoučasnýchOrchestrátorovýchFunkcí Plán spotřeby: 5
Vyhrazený plán nebo plán Premium: 10krát počet procesorů na aktuálním počítači		 Maximální počet funkcí orchestrátoru, které lze současně zpracovat v jedné instanci hostitele.
Maximální počet současných funkcí entit (maxConcurrentEntityFunctions) Plán spotřeby: 5
Vyhrazený plán nebo plán Premium: 10krát počet procesorů na aktuálním počítači		 Maximální počet funkcí entity, které lze současně zpracovat v jedné instanci hostitele. Toto nastavení platí jenom v případě, že používáte trvalý plánovač úloh. V opačném případě je maximální počet souběžných spuštění entit omezen na maxConcurrentOrchestratorFunctions hodnotu.
maxQueuePollingInterval 00:00:30 Maximální řídicí interval a interval dotazování fronty pracovních položek ve formátu hh:mm:ss. Vyšší hodnoty můžou mít za následek vyšší latenci zpracování zpráv. Nižší hodnoty můžou mít za následek vyšší náklady na úložiště kvůli zvýšeným transakcím úložiště.
maxOrchestrationActions 100 000 Maximální počet akcí, které může funkce orchestrátoru provést během jednoho cyklu provádění.
connectionName (v2.7.0 a novější)
connectionStringName (v2.x)
azureStorageConnectionStringName (v1.x)		 AzureWebJobsStorage Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k podkladovým prostředkům Azure Storage. Když zadáte nastavení jediné aplikace, mělo by se jednat o připojovací řetězec Azure Storage.
trackingStoreConnectionName (v2.7.0 a novější)
trackingStoreConnectionStringName		 Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k tabulkám Historie a Instance, které ukládají historii provádění a metadata o instancích orchestrace. Když zadáte nastavení jediné aplikace, mělo by se jednat o připojovací řetězec Azure Storage. Pokud nezadáte nastavení, použije se hodnota připojení connectionStringName (v2.x) nebo hodnota připojení azureStorageConnectionStringName (v1.x).
trackingStoreNamePrefix Předpona, která se má použít pro tabulky Historie a Instance, je-li trackingStoreConnectionStringName zadána. Pokud nezadáte předponu, použije se výchozí hodnota DurableTask . Pokud trackingStoreConnectionStringName není zadáno, tabulky Historie a Instance používají hubName hodnotu jako předponu a trackingStoreNamePrefix nastavení se ignoruje.
trasování vstupů a výstupů Nepravda Hodnota, která určuje, zda se mají sledovat vstupy a výstupy volání funkce. Při trasování událostí spuštění funkce je výchozím chováním zahrnout počet bajtů do serializovaných vstupů a výstupů pro volání funkce. Toto chování poskytuje minimální informace o vstupech a výstupech, aby nedošlo k zahlcení protokolů a neúmyslnému zpřístupnění citlivých informací. Pokud je truetato vlastnost , celý obsah vstupů a výstupů funkce jsou protokolovány.
sledovatPřehranéUdálosti Nepravda Hodnota, která označuje, zda se mají události přehrání orchestrací zapisovat do Application Insights.
logReplayEvents Nepravda Hodnota, která označuje, zda se má protokolovat opakované spuštění v protokolech aplikace.
eventGridTopicEndpoint Adresa URL pro koncový bod vlastního tématu v Azure Event Grid. Při nastavování této vlastnosti se události oznámení o životním cyklu orchestrace publikují do tohoto koncového bodu. Tato vlastnost podporuje rozlišení nastavení aplikace.
NastaveníKlíčeEventGrid Název nastavení aplikace, které obsahuje klíč použitý k ověřování pomocí vlastního tématu Event Gridu EventGridTopicEndpoint na adrese URL.
počítadloOpakováníPublikaceEventGrid 0 Počet opakování, pokud publikování do tématu Event Gridu selže.
eventGridPublishRetryInterval (interval opakování pro publikování událostí v Event Grid) 00:05:00 Interval opakování publikování v Event Grid ve formátu hh:mm:ss.
Typy událostí publikování v Event Grid (eventGridPublishEventTypes) Seznam typů událostí, které se mají publikovat do Event Gridu. Pokud nezadáte žádné typy, publikují se všechny typy událostí. Povolené hodnoty zahrnují Started, Completed, Faileda Terminated.
povolenéRozšířenéSezení Nepravda Hodnota, která určuje, zda jsou relace orchestrátoru a relace funkce entity ukládány do mezipaměti.
časový_limit_prodloužené_nečinnosti_relace_v_sekundách 30 Počet sekund, po které nečinný orchestrátor nebo funkce entity zůstanou v paměti před uvolněním. Toto nastavení se používá pouze, když je extendedSessionsEnabled nastaveno na true.
useAppLease pravda Hodnota indikující, zda aplikace musí před zpracováním zpráv centra úloh získat pronájem blobů na úrovni aplikace. Další informace naleznete v tématu Zotavení po havárii a geografické distribuce v Durable Functions. Toto nastavení je dostupné od verze 2.3.0.
useLegacyPartitionManagement Nepravda Hodnota, která určuje typ algoritmu správy oddílů, který se má použít. Při tomto nastavení false se používá algoritmus, který snižuje možnost duplikování provádění funkcí při škálování. Toto nastavení je dostupné od verze 2.3.0. Nastavení této hodnoty na true nedoporučují.
useTablePartitionManagement Ve verzi 3.x: pravda
V 2.x: nepravda		 Hodnota, která určuje typ algoritmu správy oddílů, který se má použít. Při tomto nastavení truese používá algoritmus, který je navržený ke snížení nákladů na účty Azure Storage v2. Toto nastavení je dostupné od WebJobs.Extensions.DurableTask v2.10.0. Použití tohoto nastavení se spravovanou identitou vyžaduje WebJobs.Extensions.DurableTask verze 3.x nebo novější nebo Worker.Extensions.DurableTask v1.2.x nebo novější.
PoužítUkončeníBezVýpadků Nepravda (Preview) Hodnota, která označuje, jestli se má přívětivě vypnout, aby se snížila pravděpodobnost, že vypnutí hostitele může způsobit selhání provádění funkcí probíhajících v procesu.
maxEntityOperationBatchSize Plán spotřeby: 50
Vyhrazený plán nebo Plán Premium: 5 000		 Maximální počet operací entit, které se zpracovávají jako dávka. Pokud je tato hodnota 1, dávkování je zakázané a samostatné vyvolání funkce zpracuje každou zprávu o operaci. Toto nastavení je dostupné od verze 2.6.1.
uložitVstupyDoHistorieOrchestrace Nepravda Hodnota, která určuje, jak ukládat vstupy. Pokud je toto nastavení nastaveno true, architektura Durable Task Framework ukládá vstupy aktivit v tabulce Historie a vstupy funkcí aktivit se zobrazí ve výsledcích dotazu historie orchestrace.
maxGrpcMessageSizeInBytes 4,194,304 Celočíselná hodnota, která nastavuje maximální velikost zpráv v bajtech, které může přijímat obecný klient vzdáleného volání procedur (gRPC). Implementace DurableTaskClient používá klienta gRPC ke správě instancí orchestrace. Toto nastavení platí pro izolovaný proces aplikací Durable Functions na platformě .NET a pro aplikace v Javě.
grpcHttpClientTimeout 00:01:40 Časový limit ve formátu hh:mm:ss pro klienta HTTP používaný klientem gRPC v Durable Functions. Klient je aktuálně podporovaný pro izolované pracovní aplikace .NET (.NET 6 a novější verze) a pro aplikace v Javě.
QueueClientMessageEncoding UTF8 Strategie kódování pro zprávy azure Queue Storage. Platné strategie jsou formát transformace Unicode –8bitová (UTF8) a Base64. Toto nastavení platí, pokud používáte Microsoft.Azure.WebJobs.Extensions.DurableTask 3.4.0 nebo novější nebo Microsoft.Azure.Functions.Worker.Extensions.DurableTask 1.7.0 nebo novější.

Mnohé z těchto nastavení slouží k optimalizaci výkonu. Další informace najdete v tématu Výkon a škálování.

Další kroky

Zabudovaná referenční dokumentace HTTP API pro správu instancí

  • Last updated on