Správa instancí orchestrace

Pomocí integrovaných rozhraní API pro správu instancí můžete v trvalých pracovních postupech spouštět, dotazovat, ukončovat, pozastavit, obnovit a vyprázdnit instance orchestrace. V Durable Functions klientská vazba orchestration zveřejňuje tato rozhraní API. Ve sadách SDK Durable Task jsou stejné operace dostupné prostřednictvím třídy DurableTaskClient. Tento článek ukazuje, jak provádět jednotlivé operace správy instancí s příklady kódu pro obě platformy.

Návod

Azure Durable Task Scheduler je doporučený back-end pro sady SDK Durable Functions i sady Durable Task SDK, který poskytuje plně spravované prostředí bez serveru pro spouštění trvalých pracovních postupů ve velkém měřítku.

Spuštění instancí

Metoda start-new (nebo schedule-new) v klientovi orchestrace spustí novou instanci orchestrace. Interně tato metoda zapíše zprávu do nakonfigurovaného backendu (například do Durable Task Scheduler) a poté se vrátí. Tato zpráva asynchronně aktivuje začátek orchestrace se zadaným názvem.

Tady jsou parametry pro spuštění nové instance orchestrace:

Důležité

Support pro model v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovních procesů pro plnou podporu.

Parameter	Description
Name	Název orchestrátoru slouží k rozvrhu.
Vstup	Jakákoli JSON-serializovatelná data, která by měla být předána jako vstup do orchestratorové funkce.
InstanceId	(Volitelné) Unikátní ID instance. Pokud tento parametr nezadáte, použije metoda náhodné ID.

Návod

Kdykoli je to možné, použijte pro ID instance náhodný identifikátor. ID náhodných instancí pomáhají zajistit rovnoměrnou distribuci zatížení při škálování funkcí orchestrátoru napříč několika virtuálními počítači. Správný čas pro používání nenáhodných ID instancí nastává, když ID pochází z externího zdroje nebo při implementaci vzoru singleton orchestrátoru.

Parameter	Description
Name	Název orchestrace podle plánu.
Vstup	Jakákoli JSON-serializovatelná data, která by měla být předána jako vstup do orchestrace.
InstanceId	(Volitelné) Unikátní ID instance. Pokud tento parametr nezadáte, použije metoda náhodné ID.

Návod

Kdykoli je to možné, použijte pro ID instance náhodný identifikátor. ID náhodných instancí pomáhají zajistit rovnoměrnou distribuci zatížení při škálování orchestrací napříč několika virtuálními počítači. Správný čas pro používání nenáhodných ID instancí nastává, když ID pochází z externího zdroje nebo při implementaci vzoru singleton orchestrátoru.

Následující ukázková funkce spustí novou instanci orchestrace:

C#

Izolovaný model pracovního procesu

[Function("HelloWorldQueueTrigger")]
public static async Task Run(
    [QueueTrigger("start-queue")] string input,
    [DurableClient] DurableTaskClient client,
    FunctionContext functionContext)
{
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("HelloWorld", input);
    functionContext.GetLogger("HelloWorldQueueTrigger")
        .LogInformation("Started orchestration with ID = '{InstanceId}'.", instanceId);
}

Model v probíhajícím procesu

[FunctionName("HelloWorldQueueTrigger")]
public static async Task Run(
    [QueueTrigger("start-queue")] string input,
    [DurableClient] IDurableOrchestrationClient starter,
    ILogger log)
{
    string instanceId = await starter.StartNewAsync("HelloWorld", input);
    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
}

JavaScript

Pokud není uvedeno jinak, příklady na této stránce používají trigger HTTP s následujícím function.json.

function.json

{
  "bindings": [
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Tento příklad cílí na Durable Functions verze 2.x. Ve verzi 1.x použijte orchestrationClient místo durableClient.

index.js

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

module.exports = async function(context, input) {
    const client = df.getClient(context);

    const instanceId = await client.startNew("HelloWorld", undefined, input);
    context.log(`Started orchestration with ID = ${instanceId}.`);
};

Python

Pokud není uvedeno jinak, příklady na této stránce používají trigger HTTP s následujícím function.json.

function.json

{
  "scriptFile": "__init__.py",
  "bindings": [    
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Tento příklad cílí na Durable Functions verze 2.x. Ve verzi 1.x použijte orchestrationClient místo durableClient.

__init__.py

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

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    instance_id = await client.start_new('HelloWorld', None, None)
    logging.log(f"Started orchestration with ID = ${instance_id}.")

PowerShell

Pokud není uvedeno jinak, příklady na této stránce používají trigger HTTP s následujícím function.json.

function.json

{
  "bindings": [    
    {
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "Response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Tento příklad cílí na Durable Functions verze 2.x. Ve verzi 1.x použijte orchestrationClient místo durableClient.

run.ps1

param($Request, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName 'HelloWorld'
Write-Host "Started orchestration with ID = '$InstanceId'"

Java

@FunctionName("HelloWorldQueueTrigger")
public void helloWorldQueueTrigger(
        @QueueTrigger(name = "input", queueName = "start-queue", connection = "Storage") String input,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();        
    String instanceID = client.scheduleNewOrchestrationInstance("HelloWorld");
    context.getLogger().info("Scheduled orchestration with ID = " + instanceID);
}

Pokud chcete před návratem z funkce počkat, než se orchestrátor spustí, použijte metodu waitForInstanceStart() .

// wait up to 30 seconds for the scheduled orchestration to enter the "Running" state
client.waitForInstanceStart(instanceID, Duration.ofSeconds(30));

Důležité

V současné době není sada POWERShell Durable Task SDK dostupná.

Následující kód ukazuje, jak spustit novou orchestrační instanci pomocí sady SDK Durable Task.

C#

using Microsoft.DurableTask.Client;

// Schedule a new orchestration instance
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("HelloWorld", input);
Console.WriteLine($"Started orchestration with ID = '{instanceId}'.");

// Optionally, wait for the orchestration to start
OrchestrationMetadata metadata = await client.WaitForInstanceStartAsync(instanceId, timeout: TimeSpan.FromSeconds(30));

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Schedule a new orchestration instance
instance_id = client.schedule_new_orchestration(hello_world, input=input_data)
print(f"Started orchestration with ID = '{instance_id}'.")

# Optionally, wait for the orchestration to start
state = client.wait_for_orchestration_start(instance_id, timeout=30)

Java

import com.microsoft.durabletask.DurableTaskClient;

// Schedule a new orchestration instance
String instanceId = client.scheduleNewOrchestrationInstance("HelloWorld", input);
System.out.println("Started orchestration with ID = '" + instanceId + "'.");

// Optionally, wait for the orchestration to start
OrchestrationMetadata metadata = client.waitForInstanceStart(instanceId, Duration.ofSeconds(30), false);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Schedule a new orchestration instance
const instanceId = await client.scheduleNewOrchestration("HelloWorld", input);
console.log(`Started orchestration with ID = '${instanceId}'.`);

// Optionally, wait for the orchestration to start
const state = await client.waitForOrchestrationStart(instanceId, false, 30);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Instance dotazů

Po spuštění nových instancí orchestrace budete pravděpodobně potřebovat zjistit jejich stav za běhu, abyste se dozvěděli, jestli jsou spuštěné, dokončené nebo neúspěšné.

Metoda get-status v klientovi orchestrace vrátí stav instance orchestrace.

Jako parametry přebírá instanceId (povinné), showHistory (volitelné), showHistoryOutput (volitelné) a showInput (volitelné).

• showHistory: Pokud je nastavená hodnota true, odpověď obsahuje historii spuštění.
• showHistoryOutput: Pokud je nastavená hodnota true, historie provádění obsahuje výstupy aktivit.
• showInput: Pokud je nastavená hodnota false, odpověď neobsahuje vstup funkce. Výchozí hodnota je true.

Metoda vrátí objekt s následujícími vlastnostmi:

Property	Description
Name	Název funkce orchestrátoru.
InstanceId	Instance ID orchestrace (mělo by být stejné jako vstup).instanceId
Čas vytvoření	Čas, kdy funkce orchestrátoru začíná běžet.
LastUpdatedTime	Čas, kdy orchestrace končí, jsou kontrolními body.
Vstup	Vstup funkce jako hodnota JSON. Toto pole není vyplněno, pokud showInput je false.
CustomStatus	Stav vlastní orchestrace ve formátu JSON.
Output	Výstup funkce jako JSON hodnota (pokud funkce dokončí). Pokud funkce orchestrátoru selže, tato vlastnost obsahuje podrobnosti o selhání. Pokud je funkce orchestrátoru pozastavená nebo ukončena, tato vlastnost obsahuje důvod pozastavení nebo ukončení (pokud existuje).
RuntimeStatus: Čeká	Instance je naplánovaná, ale ještě nezačala běžet.
RuntimeStatus: Běží	Instance běží.
RuntimeStatus: Dokončeno	Instance probíhala normálně.
Stav délky: PokračováníNové	Instance se znovu spustila s novou historií. Tento stav je přechodný.
RuntimeStatus: Neúspěšný	Instance selhala s chybou.
RuntimeStatus: Ukončeno	Událost náhle ustala.
RuntimeStatus: Pozastaveno	Instance je pozastavena a může být později obnovena.
historie	Historie provedení orchestrace. Toto pole je vyplněno pouze v případě, že showHistory je nastaveno na truehodnotu .

Parameter	Description
showHistory	Pokud je nastaveno na true, odpověď obsahuje historii vykonání.
showHistoryOutput	Pokud je nastaveno na true, historie provádění obsahuje výstupy aktivit.
showInput	Pokud je nastaveno na false, odezva neobsahuje vstup orchestrace. Výchozí hodnota je true.

Metoda vrátí objekt s následujícími vlastnostmi:

Property	Description
Name	Název orchestrace.
InstanceId	Instance ID orchestrace (mělo by být stejné jako vstup).instanceId
Čas vytvoření	Čas, kdy orchestrace začíná běžet.
LastUpdatedTime	Čas, kdy orchestrace končí, jsou kontrolními body.
Vstup	Vstup orchestrace jako hodnota JSON. Toto pole není vyplněno, pokud showInput je false.
CustomStatus	Stav vlastní orchestrace ve formátu JSON.
Output	Výstup orchestrace jako JSON hodnota (pokud orchestrace dokončí). Pokud orchestrace selže, tato vlastnost obsahuje podrobnosti o selhání. Pokud je orchestrace pozastavena nebo ukončena, tato vlastnost obsahuje důvod pozastavení nebo ukončení (pokud existuje).
RuntimeStatus: Čeká	Instance je naplánovaná, ale ještě nezačala běžet.
RuntimeStatus: Běží	Instance běží.
RuntimeStatus: Dokončeno	Instance probíhala normálně.
Stav délky: PokračováníNové	Instance se znovu spustila s novou historií. Tento stav je přechodný.
RuntimeStatus: Neúspěšný	Instance selhala s chybou.
RuntimeStatus: Ukončeno	Událost náhle ustala.
RuntimeStatus: Pozastaveno	Instance je pozastavena a může být obnovena později.
historie	Historie provedení orchestrace. Toto pole je vyplněno pouze v případě, že showHistory je nastaveno na truehodnotu .

Poznámka:

Orchestrátor není označený jako Completed až do dokončení všech plánovaných úkolů a dokud orchestrátor nedokončí svou práci. Jinými slovy, není dostačující, aby orchestrátor dosáhl svého return prohlášení, aby byl označen jako Completed. To je zvlášť důležité pro případy, kdy WhenAny se používají; tyto orchestrátory často return před provedením všech naplánovaných úloh.

Tato metoda vrátí null (.NET a Java), undefined (JavaScript) nebo None (Python), pokud instance neexistuje.

C#

Izolovaný model pracovního procesu

[Function("GetStatus")]
public static async Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("check-status-queue")] string instanceId)
{
    OrchestrationMetadata? metadata = await client.GetInstanceAsync(
        instanceId,
        getInputsAndOutputs: true);
    // Do something based on the current status.
}

Model v probíhajícím procesu

[FunctionName("GetStatus")]
public static async Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("check-status-queue")] string instanceId)
{
    DurableOrchestrationStatus status = await client.GetStatusAsync(instanceId);
    // do something based on the current status.
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const status = await client.getStatus(instanceId);
    // do something based on the current status.
    // example: if status.runtimeStatus === df.OrchestrationRuntimeStatus.Running: ...
}

Informace o konfiguraci souboru function.json naleznete v tématu Start instancí.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    status = await client.get_status(instance_id)
    # do something based on the current status
    # example: if (existing_instance.runtime_status is df.OrchestrationRuntimeStatus.Running) { ...

PowerShell

param($Request, $TriggerMetadata)

# Get instanceid from body
$InstanceId = $Request.Body.InstanceId

$Status = Get-DurableStatus -InstanceId $InstanceId -ShowHistory -ShowHistoryOutput -ShowInput
Write-Host "Status: $($Status | ConvertTo-Json)"

# Do something based on status
# example: if ($Status.runtimeStatus -eq 'Running') { ... }

Java

@FunctionName("GetStatus")
public void getStatus(
        @QueueTrigger(name = "instanceID", queueName = "check-status-queue", connection = "Storage") String instanceID,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();        
    OrchestrationMetadata metadata = client.getInstanceMetadata(instanceID, false);
    if (metadata != null) {
        OrchestrationRuntimeStatus status = metadata.getRuntimeStatus();
        switch (status) {
            // do something based on the current status
        }
    }
}

C#

using Microsoft.DurableTask.Client;

// Get the status of an orchestration instance
OrchestrationMetadata? metadata = await client.GetInstanceAsync(instanceId, getInputsAndOutputs: true);
if (metadata != null)
{
    OrchestrationRuntimeStatus status = metadata.RuntimeStatus;
    // do something based on the current status
}

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Get the status of an orchestration instance
state = client.get_orchestration_state(instance_id, fetch_payloads=True)
if state is not None:
    status = state.runtime_status
    # do something based on the current status

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.OrchestrationMetadata;

// Get the status of an orchestration instance
OrchestrationMetadata metadata = client.getInstanceMetadata(instanceId, true);
if (metadata != null) {
    OrchestrationRuntimeStatus status = metadata.getRuntimeStatus();
    // do something based on the current status
}

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Get the status of an orchestration instance
const state = await client.getOrchestrationState(instanceId, true);
if (state) {
    const status = state.runtimeStatus;
    // do something based on the current status
}

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Vyhledej všechny instance orchestrace

Pomocí rozhraní API v sadě SDK jazyka můžete dotazovat stav všech instancí orchestrace v centru úloh. Toto rozhraní API "list-instance" nebo "get-status" vrátí seznam objektů, které představují instance orchestrace odpovídající parametrům dotazu.

C#

Izolovaný model pracovního procesu

[Function("GetAllStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData request,
    [DurableClient] DurableTaskClient client,
    FunctionContext functionContext)
{
    ILogger logger = functionContext.GetLogger("GetAllStatus");
    AsyncPageable<OrchestrationMetadata> instances = client.GetAllInstancesAsync(
        new OrchestrationQuery());

    await foreach (OrchestrationMetadata instance in instances)
    {
        logger.LogInformation("{Instance}", instance);
    }
}

Model v probíhajícím procesu

[FunctionName("GetAllStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient client,
    ILogger log)
{
    var noFilter = new OrchestrationStatusQueryCondition();
    OrchestrationStatusQueryResult result = await client.ListInstancesAsync(
        noFilter,
        CancellationToken.None);
    foreach (DurableOrchestrationStatus instance in result.DurableOrchestrationState)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    }

    // Note: ListInstancesAsync only returns the first page of results.
    // To request additional pages provide the result.ContinuationToken
    // to the OrchestrationStatusQueryCondition's ContinuationToken property.
}

JavaScript

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

module.exports = async function(context, req) {
    const client = df.getClient(context);

    const instances = await client.getStatusAll();
    instances.forEach((instance) => {
        context.log(JSON.stringify(instance));
    });
};

Informace o konfiguraci function.json najdete v tématu Start instance.

Python

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


async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    instances = await client.get_status_all()

    for instance in instances:
        logging.log(json.dumps(instance))

Informace o konfiguraci function.json najdete v tématu Start instance.

PowerShell

Poznámka:

PowerShell tuto funkci v současné době nepodporuje, ale můžete ji dosáhnout pomocí Durable Functions rozhraní HTTP API.

Java

@FunctionName("GetAllStatus")
public String getAllStatus(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    DurableTaskClient client = durableContext.getClient();
    OrchestrationStatusQuery noFilter = new OrchestrationStatusQuery();
    OrchestrationStatusQueryResult result = client.queryInstances(noFilter);
    return "Found " + result.getOrchestrationState().size() + " orchestrations.";
}

C#

using Microsoft.DurableTask.Client;

// Query all orchestration instances
AsyncPageable<OrchestrationMetadata> instances = client.GetAllInstancesAsync(new OrchestrationQuery());

await foreach (OrchestrationMetadata instance in instances)
{
    Console.WriteLine(instance.InstanceId);
}

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Query all orchestration instances
instances = client.list_orchestrations()

for instance in instances:
    print(instance.instance_id)

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.OrchestrationStatusQuery;
import com.microsoft.durabletask.OrchestrationStatusQueryResult;

// Query all orchestration instances
OrchestrationStatusQuery query = new OrchestrationStatusQuery();
OrchestrationStatusQueryResult result = client.queryInstances(query);

for (OrchestrationMetadata instance : result.getOrchestrationState()) {
    System.out.println(instance.getInstanceId());
}

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Query all orchestration instances
const instances = client.getAllInstances();

for await (const instance of instances) {
    console.log(instance.instanceId);
}

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Instance orchestrace dotazů s filtry

Co když nepotřebujete všechny informace, které poskytuje standardní dotaz instance? Co když například hledáte čas vytvoření orchestrace nebo stav běhu orchestrace? Zužte dotaz použitím filtrů.

C#

Izolovaný model pracovního procesu

[Function("QueryStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData request,
    [DurableClient] DurableTaskClient client,
    FunctionContext functionContext)
{
    ILogger logger = functionContext.GetLogger("QueryStatus");
    var query = new OrchestrationQuery
    {
        Statuses = new[]
        {
            OrchestrationRuntimeStatus.Pending,
            OrchestrationRuntimeStatus.Running,
        },
        CreatedFrom = DateTime.UtcNow.Subtract(TimeSpan.FromDays(7)),
        CreatedTo = DateTime.UtcNow.Subtract(TimeSpan.FromDays(1)),
        PageSize = 100,
    };

    await foreach (OrchestrationMetadata instance in client.GetAllInstancesAsync(query))
    {
        logger.LogInformation("{Instance}", instance);
    }
}

Model v probíhajícím procesu

[FunctionName("QueryStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient client,
    ILogger log)
{
    // Get the first 100 running or pending instances that were created between 7 and 1 days ago
    var queryFilter = new OrchestrationStatusQueryCondition
    {
        RuntimeStatus = new[]
        {
            OrchestrationRuntimeStatus.Pending,
            OrchestrationRuntimeStatus.Running,
        },
        CreatedTimeFrom = DateTime.UtcNow.Subtract(TimeSpan.FromDays(7)),
        CreatedTimeTo = DateTime.UtcNow.Subtract(TimeSpan.FromDays(1)),
        PageSize = 100,
    };

    OrchestrationStatusQueryResult result = await client.ListInstancesAsync(
        queryFilter,
        CancellationToken.None);
    foreach (DurableOrchestrationStatus instance in result.DurableOrchestrationState)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    }
}

JavaScript

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

module.exports = async function(context, req) {
    const client = df.getClient(context);

    const runtimeStatus = [
        df.OrchestrationRuntimeStatus.Completed,
        df.OrchestrationRuntimeStatus.Running,
    ];
    const instances = await client.getStatusBy(
        new Date(2021, 3, 10, 10, 1, 0),
        new Date(2021, 3, 10, 10, 23, 59),
        runtimeStatus
    );
    instances.forEach((instance) => {
        context.log(JSON.stringify(instance));
    });
};

Viz instance Start pro konfiguraci function.json.

Python

import logging
from datetime import datetime
import json
import azure.functions as func
import azure.durable_functions as df
from azure.durable_functions.models.OrchestrationRuntimeStatus import OrchestrationRuntimeStatus

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    runtime_status = [OrchestrationRuntimeStatus.Completed, OrchestrationRuntimeStatus.Running]

    instances = await client.get_status_by(
        datetime(2021, 3, 10, 10, 1, 0),
        datetime(2021, 3, 10, 10, 23, 59),
        runtime_status
    )

    for instance in instances:
        logging.log(json.dumps(instance))

PowerShell

Poznámka:

Tato funkce se v současné době nepodporuje v PowerShellu, ale můžete ji dosáhnout pomocí Durable Functions rozhraní HTTP API.

Java

@FunctionName("GetRunningInstances")
public String getRunningInstances(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    DurableTaskClient client = durableContext.getClient();
    OrchestrationStatusQuery filter = new OrchestrationStatusQuery()
        .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.PENDING, OrchestrationRuntimeStatus.RUNNING))
        .setCreatedTimeFrom(Instant.now().minus(Duration.ofDays(7)))
        .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(1)));
    OrchestrationStatusQueryResult result = client.queryInstances(filter);
    return "Found " + result.getOrchestrationState().size() + " orchestrations.";
}

C#

using Microsoft.DurableTask.Client;

// Get running or pending instances created in the last 7 days
var query = new OrchestrationQuery
{
    Statuses = new[] { OrchestrationRuntimeStatus.Running, OrchestrationRuntimeStatus.Pending },
    CreatedFrom = DateTime.UtcNow.AddDays(-7),
    CreatedTo = DateTime.UtcNow.AddDays(-1),
    PageSize = 100
};

AsyncPageable<OrchestrationMetadata> instances = client.GetAllInstancesAsync(query);

await foreach (OrchestrationMetadata instance in instances)
{
    Console.WriteLine($"{instance.InstanceId}: {instance.RuntimeStatus}");
}

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient
from datetime import datetime, timedelta

# Get running or pending instances created in the last 7 days
instances = client.list_orchestrations(
    created_time_from=datetime.utcnow() - timedelta(days=7),
    created_time_to=datetime.utcnow() - timedelta(days=1),
    runtime_status=['RUNNING', 'PENDING']
)

for instance in instances:
    print(f"{instance.instance_id}: {instance.runtime_status}")

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.OrchestrationStatusQuery;
import com.microsoft.durabletask.OrchestrationRuntimeStatus;
import java.time.Duration;
import java.time.Instant;
import java.util.List;

// Get running or pending instances created in the last 7 days
OrchestrationStatusQuery filter = new OrchestrationStatusQuery()
    .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.PENDING, OrchestrationRuntimeStatus.RUNNING))
    .setCreatedTimeFrom(Instant.now().minus(Duration.ofDays(7)))
    .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(1)));

OrchestrationStatusQueryResult result = client.queryInstances(filter);

for (OrchestrationMetadata instance : result.getOrchestrationState()) {
    System.out.println(instance.getInstanceId() + ": " + instance.getRuntimeStatus());
}

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";
import { OrchestrationStatus } from "@microsoft/durabletask-js";

const client = createAzureManagedClient(connectionString);

// Get running or pending instances created in the last 7 days
const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);

const instances = client.getAllInstances({
    statuses: [OrchestrationStatus.RUNNING, OrchestrationStatus.PENDING],
    createdFrom: sevenDaysAgo,
    createdTo: oneDayAgo,
});

for await (const instance of instances) {
    console.log(`${instance.instanceId}: ${instance.runtimeStatus}`);
}

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Ukončení instancí orchestrace

Pokud máte instanci orchestrace, která trvá příliš dlouho, nebo ji potřebujete zastavit, než se z nějakého důvodu dokončí, můžete ji ukončit.

Dva parametry rozhraní API pro ukončení jsou ID instance a řetězec důvodu , který zapisuje do protokolů a do stavu instance.

C#

Izolovaný model pracovního procesu

[Function("TerminateInstance")]
public static Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("terminate-queue")] string instanceId)
{
    string reason = "Found a bug";
    return client.TerminateInstanceAsync(instanceId, reason);
}

Model v probíhajícím procesu

[FunctionName("TerminateInstance")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("terminate-queue")] string instanceId)
{
    string reason = "Found a bug";
    return client.TerminateAsync(instanceId, reason);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const reason = "Found a bug";
    return client.terminate(instanceId, reason);
};

Viz instance Start pro konfiguraci function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    reason = "Found a bug"
    return await client.terminate(instance_id, reason)

PowerShell

param($Request, $TriggerMetadata)

# Get instance id from body
$InstanceId = $Request.Body.InstanceId
$Reason = 'Found a bug'

Stop-DurableOrchestration -InstanceId $InstanceId -Reason $Reason

Java

@FunctionName("TerminateInstance")
public void terminateInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    String reason = "Found a bug";
    durableContext.getClient().terminate(instanceID, reason);
}

C#

using Microsoft.DurableTask.Client;

string reason = "Found a bug";
await client.TerminateInstanceAsync(instanceId, reason);

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

reason = "Found a bug"
client.terminate_orchestration(instance_id, reason=reason)

Java

import com.microsoft.durabletask.DurableTaskClient;

String reason = "Found a bug";
client.terminate(instanceId, reason);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

const reason = "Found a bug";
await client.terminateOrchestration(instanceId, reason);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Ukončená instance nakonec přejde do Terminated stavu. Tento přechod se ale nestane okamžitě. Místo toho se operace ukončení zařadí do fronty v uzlu úloh spolu s dalšími operacemi pro danou instanci. Pomocí rozhraní API pro dotazy instance můžete zjistit, kdy ukončená instance skutečně dosáhla Terminated stavu.

Poznámka:

Ukončení instance se v současné době nešíruje. Funkce aktivit a dílčí orchestrace dokončí svůj běh, bez ohledu na to, zda ukončíte instanci orchestrace, která je volala.

Pozastavení a obnovení instancí orchestrace

Pozastavení orchestrace umožňuje zastavit spuštěnou orchestraci. Na rozdíl od ukončení orchestrace můžete později obnovit pozastavený orchestrátor.

Dva parametry pro pozastavené rozhraní API jsou ID instance a řetězec důvodu, který se zapisuje do protokolů a do stavu instance.

C#

Izolovaný model pracovního procesu

[Function("SuspendResumeInstance")]
public static async Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("suspend-resume-queue")] string instanceId)
{
    // To suspend an orchestration
    string suspendReason = "Need to pause workflow";
    await client.SuspendInstanceAsync(instanceId, suspendReason);

    // To resume an orchestration
    string resumeReason = "Continue workflow";
    await client.ResumeInstanceAsync(instanceId, resumeReason);
}

Model v probíhajícím procesu

[FunctionName("SuspendResumeInstance")]
public static async Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("suspend-resume-queue")] string instanceId)
{
    // To suspend an orchestration
    string suspendReason = "Need to pause workflow";
    await client.SuspendAsync(instanceId, suspendReason);

    // To resume an orchestration
    string resumeReason = "Continue workflow";
    await client.ResumeAsync(instanceId, resumeReason);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    // To suspend an orchestration
    const suspendReason = "Need to pause workflow";
    await client.suspend(instanceId, suspendReason);

    // To resume an orchestration
    const resumeReason = "Continue workflow";
    await client.resume(instanceId, resumeReason);
};

Python

import azure.functions as func
import azure.durable_functions as df
from datetime import timedelta

async def main(req: func.HttpRequest, starter: str, instance_id: str):
    client = df.DurableOrchestrationClient(starter)

    # To suspend an orchestration
    suspend_reason = "Need to pause workflow"
    await client.suspend(instance_id, suspend_reason)

    # To resume an orchestration
    resume_reason = "Continue workflow"
    await client.resume(instance_id, resume_reason)

PowerShell

param($Request, $TriggerMetadata)

$InstanceId = $Request.Body.InstanceId

# To suspend an orchestration
$SuspendReason = 'Need to pause workflow'
Suspend-DurableOrchestration -InstanceId $InstanceId -Reason $SuspendReason

# To resume an orchestration
$ResumeReason = 'Continue workflow'
Resume-DurableOrchestration -InstanceId $InstanceId -Reason $ResumeReason

Poznámka:

Tato funkce je k dispozici pouze v samostatném PowerShell SDK pro Durable Functions. Podívejte se na rozdíl mezi samostatnou sadou SDK a starší integrovanou sadou SDK a průvodcem migrací.

Java

@FunctionName("SuspendResumeInstance")
public void suspendResumeInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    DurableTaskClient client = durableContext.getClient();  

    // To suspend an orchestration
    String suspendReason = "Need to pause workflow";
    client.suspendInstance(instanceID, suspendReason);

    // To resume an orchestration
    String resumeReason = "Continue workflow";
    client.resumeInstance(instanceID, resumeReason);
}

C#

using Microsoft.DurableTask.Client;

// To suspend an orchestration
string suspendReason = "Need to pause workflow";
await client.SuspendInstanceAsync(instanceId, suspendReason);

// To resume an orchestration
string resumeReason = "Continue workflow";
await client.ResumeInstanceAsync(instanceId, resumeReason);

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# To suspend an orchestration
suspend_reason = "Need to pause workflow"
client.suspend_orchestration(instance_id, reason=suspend_reason)

# To resume an orchestration
resume_reason = "Continue workflow"
client.resume_orchestration(instance_id, reason=resume_reason)

Java

import com.microsoft.durabletask.DurableTaskClient;

// To suspend an orchestration
String suspendReason = "Need to pause workflow";
client.suspendInstance(instanceId, suspendReason);

// To resume an orchestration
String resumeReason = "Continue workflow";
client.resumeInstance(instanceId, resumeReason);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// To suspend an orchestration
await client.suspendOrchestration(instanceId);

// To resume an orchestration
await client.resumeOrchestration(instanceId);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Pozastavená instance nakonec přejde do Suspended stavu. K tomuto přechodu ale nedojde okamžitě. Místo toho je operace pozastavení zařazena do fronty v modulu úloh spolu s dalšími operacemi pro danou instanci. Pomocí rozhraní API pro dotazy instance zjistěte, kdy spuštěná instance skutečně dosáhla Suspended stavu.

Po obnovení pozastaveného orchestrátoru se jeho stav změní zpět na Running.

Odesílání událostí do instancí

V některých scénářích musí funkce orchestrátoru čekat a naslouchat externím událostem. Mezi příklady, kdy je tento přístup užitečný, patří scénáře monitorování a lidské interakce .

V některých scénářích musí orchestrace čekat a naslouchat externím událostem. Mezi příklady, kdy je tento přístup užitečný, patří scénáře monitorování a lidské interakce .

Oznámení událostí můžete odesílat do spuštěných instancí pomocí rozhraní API pro vyvolání událostí klienta orchestrace. Orchestrace mohou naslouchat těmto událostem a reagovat na ně pomocí API orchestrátoru čekání na externí událost.

Parametry pro vyvolání události jsou:

• ID instance: Jedinečné ID instance.
• Název události: Název události, která se má odeslat.
• Data události: JSON serializovatelná datová část k odeslání do instance.

C#

Izolovaný model pracovního procesu

[Function("RaiseEvent")]
public static Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("event-queue")] string instanceId)
{
    int[] eventData = new int[] { 1, 2, 3 };
    return client.RaiseEventAsync(instanceId, "MyEvent", eventData);
}

Model v probíhajícím procesu

[FunctionName("RaiseEvent")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("event-queue")] string instanceId)
{
    int[] eventData = new int[] { 1, 2, 3 };
    return client.RaiseEventAsync(instanceId, "MyEvent", eventData);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const eventData = [ 1, 2, 3 ];
    return client.raiseEvent(instanceId, "MyEvent", eventData);
};

Viz instance Start pro konfiguraci function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    event_data = [1, 2 ,3]
    return await client.raise_event(instance_id, 'MyEvent', event_data)

PowerShell

param($Request, $TriggerMetadata)

# Get instance id from body
$InstanceId = $Request.Body.InstanceId
$EventName = 'MyEvent'
$EventData = @(1,2,3)

Send-DurableExternalEvent -InstanceId $InstanceId -EventName $EventName -EventData $EventData

Java

@FunctionName("RaiseEvent")
public void raiseEvent(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    String eventName = "MyEvent";
    int[] eventData = { 1, 2, 3 };
    durableContext.getClient().raiseEvent(instanceID, eventName, eventData);
}

C#

using Microsoft.DurableTask.Client;

int[] eventData = new int[] { 1, 2, 3 };
await client.RaiseEventAsync(instanceId, "MyEvent", eventData);

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

event_data = [1, 2, 3]
client.raise_orchestration_event(instance_id, "MyEvent", event_data)

Java

import com.microsoft.durabletask.DurableTaskClient;

int[] eventData = { 1, 2, 3 };
client.raiseEvent(instanceId, "MyEvent", eventData);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

const eventData = [1, 2, 3];
await client.raiseOrchestrationEvent(instanceId, "MyEvent", eventData);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Poznámka:

Pokud neexistuje žádná instance orchestrace se zadaným ID instance, zpráva události se zahodí. Pokud instance existuje, ale ještě nečeká na událost, uloží se událost do stavu instance, dokud nebude připravená k přijetí a zpracování.

Čekání na dokončení orchestrace

V případě dlouhotrvajících orchestrací můžete chtít počkat na výsledky orchestrace. V těchto případech je také užitečné definovat časový limit pro orchestrace. Pokud dojde k překročení časového limitu, vrátí se místo výsledků stav orchestrace.

Použijte API "čekání na dokončení nebo vytvoření odpovědi na stav" pro synchronní získání skutečného výstupu z orchestrace instance. Ve výchozím nastavení má tato metoda časový limit deset sekund a interval dotazování o jedné sekundě.

Tady je příklad funkce triggeru HTTP, která ukazuje, jak používat toto rozhraní API:

C#

Izolovaný model pracovního procesu

[Function("HttpSyncStart")]
public static async Task<HttpResponseData> Run(
    [HttpTrigger(
        AuthorizationLevel.Function,
        "post",
        Route = "orchestrators/{functionName}/wait")] HttpRequestData request,
    [DurableClient] DurableTaskClient client,
    string functionName)
{
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(functionName);

    using var timeoutCancellation = new CancellationTokenSource(TimeSpan.FromSeconds(30));
    return await client.WaitForCompletionOrCreateCheckStatusResponseAsync(
        request,
        instanceId,
        timeoutCancellation.Token);
}

Model v probíhajícím procesu

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;

namespace VSSample
{
    public static class HttpSyncStart
    {
        private const string Timeout = "timeout";
        private const string RetryInterval = "retryInterval";

        [FunctionName("HttpSyncStart")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}/wait")]
            HttpRequestMessage req,
            [DurableClient] IDurableOrchestrationClient starter,
            string functionName,
            ILogger log)
        {
            // Function input comes from the request content.
            object eventData = await req.Content.ReadAsAsync<object>();
            string instanceId = await starter.StartNewAsync(functionName, eventData);

            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

            TimeSpan timeout = GetTimeSpan(req, Timeout) ?? TimeSpan.FromSeconds(30);
            TimeSpan retryInterval = GetTimeSpan(req, RetryInterval) ?? TimeSpan.FromSeconds(1);
            
            return await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(
                req,
                instanceId,
                timeout,
                retryInterval);
        }

        private static TimeSpan? GetTimeSpan(HttpRequestMessage request, string queryParameterName)
        {
            string queryParameterStringValue = request.RequestUri.ParseQueryString()[queryParameterName];
            if (string.IsNullOrEmpty(queryParameterStringValue))
            {
                return null;
            }

            return TimeSpan.FromSeconds(double.Parse(queryParameterStringValue));
        }
    }
}

JavaScript

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

const timeout = "timeout";
const retryInterval = "retryInterval";

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = await client.startNew(req.params.functionName, undefined, req.body);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    const timeoutInMilliseconds = getTimeInSeconds(req, timeout) || 30000;
    const retryIntervalInMilliseconds = getTimeInSeconds(req, retryInterval) || 1000;

    const response = client.waitForCompletionOrCreateCheckStatusResponse(
        context.bindingData.req,
        instanceId,
        timeoutInMilliseconds,
        retryIntervalInMilliseconds
    );
    return response;
};

function getTimeInSeconds(req, queryParameterName) {
    const queryValue = req.query[queryParameterName];
    return queryValue
        ? queryValue * 1000 // expected to be in seconds
        : undefined;
}

Viz instance Start pro konfiguraci function.json.

Python

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

timeout = "timeout"
retry_interval = "retryInterval"

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    instance_id = await client.start_new(req.route_params['functionName'], None, req.get_body())
    logging.log(f"Started orchestration with ID = '${instance_id}'.")

    timeout_in_milliseconds = get_time_in_seconds(req, timeout)
    timeout_in_milliseconds = timeout_in_milliseconds if timeout_in_milliseconds != None else 30000
    retry_interval_in_milliseconds = get_time_in_seconds(req, retry_interval)
    retry_interval_in_milliseconds = retry_interval_in_milliseconds if retry_interval_in_milliseconds != None else 1000

    return await client.wait_for_completion_or_create_check_status_response(
        req,
        instance_id,
        timeout_in_milliseconds,
        retry_interval_in_milliseconds
    )

def get_time_in_seconds(req: func.HttpRequest, query_parameter_name: str):
    query_value = req.params.get(query_parameter_name)
    return query_value if query_value != None else 1000

PowerShell

Poznámka:

PowerShell v současné době nemá integrovaný příkaz pro tento scénář.

Java

Java v současné době nemá pro tento scénář jedinou metodu, ale můžete ji implementovat s několika dalšími řádky kódu.

@FunctionName("HttpStartAndWait")
public HttpResponseMessage httpStartAndWait(
        @HttpTrigger(name = "req", route = "orchestrators/{functionName}/wait", methods = {HttpMethod.POST}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        @BindingName("functionName") String functionName,
        final ExecutionContext context) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance(functionName);
    context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
    try {
        String timeoutString = req.getQueryParameters().get("timeout");
        Integer timeoutInSeconds = Integer.parseInt(timeoutString);
        OrchestrationMetadata orchestration = client.waitForInstanceCompletion(
                instanceId,
                Duration.ofSeconds(timeoutInSeconds),
                true /* getInputsAndOutputs */);
        return req.createResponseBuilder(HttpStatus.OK)
                .body(orchestration.getSerializedOutput())
                .header("Content-Type", "application/json")
                .build();
    } catch (TimeoutException timeoutEx) {
        // timeout expired - return a 202 response
        return durableContext.createCheckStatusResponse(req, instanceId);
    }
}

Sady SDK Durable Task poskytují metodu pro synchronní čekání na dokončení orchestrace.

C#

using Microsoft.DurableTask.Client;

// Wait for orchestration to complete with a timeout
OrchestrationMetadata metadata = await client.WaitForInstanceCompletionAsync(
    instanceId,
    timeout: TimeSpan.FromSeconds(30),
    getInputsAndOutputs: true);

if (metadata.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
    Console.WriteLine($"Output: {metadata.SerializedOutput}");
}

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Wait for orchestration to complete with a timeout
state = client.wait_for_orchestration_completion(
    instance_id,
    timeout=30,
    fetch_payloads=True)

if state.runtime_status == 'COMPLETED':
    print(f"Output: {state.serialized_output}")

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.OrchestrationMetadata;
import java.time.Duration;
import java.util.concurrent.TimeoutException;

// Wait for orchestration to complete with a timeout
try {
    OrchestrationMetadata metadata = client.waitForInstanceCompletion(
            instanceId,
            Duration.ofSeconds(30),
            true /* getInputsAndOutputs */);
    System.out.println("Output: " + metadata.getSerializedOutput());
} catch (TimeoutException e) {
    System.out.println("Orchestration did not complete within timeout");
}

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";
import { OrchestrationStatus } from "@microsoft/durabletask-js";

const client = createAzureManagedClient(connectionString);

// Wait for orchestration to complete with a timeout
const state = await client.waitForOrchestrationCompletion(instanceId, true, 30);

if (state?.runtimeStatus === OrchestrationStatus.COMPLETED) {
    console.log(`Output: ${state.serializedOutput}`);
}

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Volejte funkci pomocí následujícího řádku. Pro časový limit použijte dva sekundy a interval opakování 0,5 sekund:

curl -X POST "http://localhost:7071/orchestrators/E1_HelloSequence/wait?timeout=2&retryInterval=0.5"

Poznámka:

Výše uvedený příkaz cURL předpokládá, že máte v projektu funkci orchestrátoru.E1_HelloSequence Vzhledem k tomu, jak je zapisována funkce triggeru HTTP, můžete ji nahradit názvem libovolné funkce orchestrátoru ve vašem projektu.

V závislosti na době potřebné k získání odpovědi z instance orchestrace existují dva případy:

• Instance orchestrace jsou dokončeny v rámci definovaného časového limitu (v tomto případě dvě sekundy) a odpovědí je skutečný výstup z instance orchestrace, který je synchronně poskytován:

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Thu, 14 Dec 2021 06:14:29 GMT
Transfer-Encoding: chunked

[
    "Hello Tokyo!",
    "Hello Seattle!",
    "Hello London!"
]

• Instance orchestrace se nedají dokončit v rámci definovaného časového limitu a odpověď je výchozí, která je popsaná ve zjišťování adres URL rozhraní HTTP API:

HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8
Date: Thu, 14 Dec 2021 06:13:51 GMT
Location: http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}
Retry-After: 10
Transfer-Encoding: chunked

{
    "id": "d3b72dddefce4e758d92f4d411567177",
    "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/raiseEvent/{eventName}?taskHub={taskHub}&connection={connection}&code={systemKey}",
    "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}",
    "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/terminate?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}",
    "suspendPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/suspend?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}",
    "resumePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/resume?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}"
}

Poznámka:

Formát adres URL webhooku se může lišit v závislosti na tom, jakou verzi Azure Functions hostitele spustíte. Předchozí příklad je určený pro hostitele Azure Functions 3.0.

Načtení adres URL webhooku správy HTTP pro instance orchestrace

K monitorování nebo vyvolání událostí pro orchestraci použijte externí systém. Externí systémy komunikují s Durable Functions prostřednictvím adres URL webhooku, které jsou součástí výchozí odpovědi popsané v zjišťování adres URL rozhraní APIHTTP. Adresy URL webhooků jsou alternativně přístupné prostřednictvím kódu programu pomocí vazby klienta orchestrace. API pro vytvoření datové části správy HTTP specificky obdrží serializovatelný objekt, který obsahuje tyto URL adresy webhooků.

Rozhraní API pro vytvoření datové části správy HTTP má jeden parametr:

• ID instance: Jedinečné ID instance.

Metody vrátí objekt s následujícími vlastnostmi řetězce:

• ID: ID instance orchestrace (musí být stejné jako InstanceId vstup).
• StatusQueryGetUri: Adresa URL stavu instance orchestrace.
• SendEventPostUri: URL adresa orchestrace instance pro "vyvolání události".
• TerminatePostUri: Adresa URL "terminate" instance orchestrace.
• PurgeHistoryDeleteUri: Adresa URL "promazání historie" instance orchestrace.
• SuspendPostUri: Adresa URL instance orchestrace pro "suspend".
• ResumePostUri: URL adresa pro „resume“ instanci orchestrace.

Funkce odesílají instance těchto objektů externím systémům za účelem monitorování nebo vyvolání událostí v odpovídajících orchestracích, jak je znázorněno v následujících příkladech.

C#

Izolovaný model pracovního procesu

[Function("SendInstanceInfo")]
[CosmosDBOutput(
    databaseName: "MonitorDB",
    containerName: "HttpManagementPayloads",
    Connection = "CosmosDBConnectionSetting")]
public static object SendInstanceInfo(
    [ActivityTrigger] TaskActivityContext context,
    [DurableClient] DurableTaskClient client)
{
    HttpManagementPayload payload = client.CreateHttpManagementPayload(context.InstanceId);

    // Send the payload to Azure Cosmos DB.
    return new { Payload = payload, id = context.InstanceId };
}

Model v probíhajícím procesu

[FunctionName("SendInstanceInfo")]
public static void SendInstanceInfo(
    [ActivityTrigger] IDurableActivityContext ctx,
    [DurableClient] IDurableOrchestrationClient client,
    [CosmosDB(
        databaseName: "MonitorDB",
        containerName: "HttpManagementPayloads",
        Connection = "CosmosDBConnectionSetting")]out dynamic document)
{
    HttpManagementPayload payload = client.CreateHttpManagementPayload(ctx.InstanceId);

    // send the payload to Azure Cosmos DB
    document = new { Payload = payload, id = ctx.InstanceId };
}

JavaScript

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

modules.exports = async function(context, ctx) {
    const client = df.getClient(context);

    const payload = client.createHttpManagementPayload(ctx.instanceId);

    // send the payload to Azure Cosmos DB
    context.bindings.document = JSON.stringify({
        id: ctx.instanceId,
        payload,
    });
};

Viz instance Start pro konfiguraci function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.cosmosdb.cdb.Document:
    client = df.DurableOrchestrationClient(starter)

    payload = client.create_check_status_response(req, instance_id).get_body().decode()

    return func.cosmosdb.CosmosDBConverter.encode({
        id: instance_id,
        payload: payload
    })

PowerShell

using namespace System.Net

param($Request, $TriggerMetadata)

$InstanceId = $Request.Body.InstanceId
$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
Push-OutputBinding -Name Response -Value $Response

Java

Poznámka:

Java tuto funkci v současné době nepodporuje.

Převinout instance orchestrace zpět

Pokud dojde k selhání orchestrace z neočekávaného důvodu, resetujte instanci do předchozího funkčního stavu pomocí rozhraní API vytvořeného pro tento účel.

Poznámka:

Toto rozhraní API nemá být náhradou za správné zpracování chyb a zásady opakování. Místo toho se má použít pouze v případech, kdy instance orchestrace selžou z neočekávaných důvodů. Orchestrace v jiných stavech než Failed (například Running, Pending, Terminated nebo Completed) nemohou být "přetočeny". Další informace o zpracování chyb a zásadách opakování najdete v článku Zpracování chyb .

Pomocí metody RewindAsync (.NET) nebo rewind (JavaScript) vazby klienta orchestration přepněte orchestraci zpět do stavu Running. Tato metoda také znovu spustí provádění aktivity nebo suborchestrace, jejichž selhání způsobilo selhání orchestrace.

Řekněme například, že máte pracovní postup zahrnující řadu lidských schválení. Předpokládejme, že řada funkcí aktivit upozorní někoho, že je potřeba jejich schválení, a je potřeba počkat na odezvu v reálném čase. Jakmile všechny aktivity schválení obdrží odpovědi nebo vyprší časový limit, může dojít k selhání jiné aktivity kvůli chybné konfiguraci aplikace, například neplatnému připojovacímu řetězci databáze. Výsledkem je selhání orchestrace hluboko v pracovním postupu. S rozhraním API RewindAsync (.NET) nebo rewind (JavaScript) může správce aplikace opravit chybu konfigurace a vrátit neúspěšnou orchestraci do stavu těsně před selháním. Žádný z kroků pro lidskou interakci není potřeba znovu schválit a orchestrace se teď může úspěšně dokončit.

Poznámka:

Funkce převinutí neumožňuje převinutí instancí orchestrace, které používají trvalé časovače.

C#

Izolovaný model pracovního procesu

[Function("RewindInstance")]
public static Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("rewind-queue")] string instanceId)
{
    string reason = "Orchestrator failed and needs to be revived.";
    return client.RewindInstanceAsync(instanceId, reason);
}

Model v probíhajícím procesu

[FunctionName("RewindInstance")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("rewind-queue")] string instanceId)
{
    string reason = "Orchestrator failed and needs to be revived.";
    return client.RewindAsync(instanceId, reason);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const reason = "Orchestrator failed and needs to be revived.";
    return client.rewind(instanceId, reason);
};

Viz instance Start pro konfiguraci function.json.

Python

Poznámka:

Python tuto funkci v současné době nepodporuje.

PowerShell

Poznámka:

PowerShell tuto funkci v současné době nepodporuje.

Java

Poznámka:

Java tuto funkci v současné době nepodporuje.

C#

using Microsoft.DurableTask.Client;

string reason = "Orchestrator failed and needs to be revived.";
await client.RewindInstanceAsync(instanceId, reason);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

const reason = "Orchestrator failed and needs to be revived.";
await client.rewindInstance(instanceId, reason);

Python

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

PowerShell

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

Java

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

Restartování orchestračních instancí

Restartování orchestrace vytvoří novou instanci pomocí historie dříve spuštěné instance. Tato funkce je užitečná, když chcete znovu spustit orchestraci se stejným vzorem ID vstupu a instance a vytvořit nové spuštění založené na původním příkazu.

C#

Izolovaný model pracovního procesu

[Function("RestartInstance")]
public static Task<string?> Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("restart-queue")] string instanceId)
{
    return client.RestartAsync(instanceId, restartWithNewInstanceId: true);
}

Model v probíhajícím procesu

[FunctionName("RestartInstance")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("restart-queue")] string instanceId)
{
    return client.RestartAsync(instanceId, restartWithNewInstanceId: true);
}

JavaScript

Poznámka:

JavaScript tuto funkci v současné době nepodporuje.

Python

Poznámka:

Python tuto funkci v současné době nepodporuje.

PowerShell

Poznámka:

PowerShell tuto funkci v současné době nepodporuje.

Java

Poznámka:

Tato funkce se v současné době nepodporuje v Javě.

C#

using Microsoft.DurableTask.Client;

// Restart an orchestration with a new instance ID
string newInstanceId = await client.RestartInstanceAsync(instanceId, restartWithNewInstanceId: true);
Console.WriteLine($"Restarted as new instance: {newInstanceId}");

// Restart an orchestration keeping the same instance ID
await client.RestartInstanceAsync(instanceId, restartWithNewInstanceId: false);

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Restart an orchestration with a new instance ID
const newInstanceId = await client.restartOrchestration(instanceId, true);
console.log(`Restarted as new instance: ${newInstanceId}`);

// Restart an orchestration keeping the same instance ID
await client.restartOrchestration(instanceId, false);

Python

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

PowerShell

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

Java

Tato ukázka se zobrazuje pouze pro .NET a JavaScript.

Vymazání historie instancí orchestrace

Pokud chcete odebrat všechna data přidružená k orchestraci, vyprázdněte historii instancí. Odstraňte například všechny prostředky úložiště přidružené k dokončené instanci. Použijte rozhraní API vyprázdnění instance definované klientem orchestrace.

Následující příklad ukazuje, jak vyprázdnit jednu instanci orchestrace.

C#

Izolovaný model pracovního procesu

[Function("PurgeInstanceHistory")]
public static async Task Run(
    [DurableClient] DurableTaskClient client,
    [QueueTrigger("purge-queue")] string instanceId)
{
    await client.PurgeInstanceAsync(instanceId);
}

Model v probíhajícím procesu

[FunctionName("PurgeInstanceHistory")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("purge-queue")] string instanceId)
{
    return client.PurgeInstanceHistoryAsync(instanceId);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);
    return client.purgeInstanceHistory(instanceId);
};

Viz instance Start pro konfiguraci function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    return await client.purge_instance_history(instance_id)

PowerShell

Poznámka:

Tato funkce se v PowerShellu v současné době nepodporuje, ale můžete ji dosáhnout pomocí rozhraní API http Durable Functions.

Java

@FunctionName("PurgeInstance")
public HttpResponseMessage purgeInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}, route = "purge/{instanceID}") HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        @BindingName("instanceID") String instanceID) {
    PurgeResult result = durableContext.getClient().purgeInstance(instanceID);
    if (result.getDeletedInstanceCount() == 0) {
        return req.createResponseBuilder(HttpStatus.NOT_FOUND)
                .body("No completed instance with ID '" + instanceID + "' was found!")
                .build();
    } else {
        return req.createResponseBuilder(HttpStatus.OK)
                .body("Successfully purged data for " + instanceID)
                .build();
    }
}

C#

using Microsoft.DurableTask.Client;

// Purge a single orchestration instance
PurgeResult result = await client.PurgeInstanceAsync(instanceId);
Console.WriteLine($"Purged {result.PurgedInstanceCount} instance(s).");

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Purge a single orchestration instance
result = client.purge_orchestration(instance_id)
print(f"Purged {result.deleted_instance_count} instance(s).")

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.PurgeResult;

// Purge a single orchestration instance
PurgeResult result = client.purgeInstance(instanceId);
System.out.println("Purged " + result.getDeletedInstanceCount() + " instance(s).");

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Purge a single orchestration instance
const result = await client.purgeOrchestration(instanceId);
console.log(`Purged ${result?.deletedInstanceCount ?? 0} instance(s).`);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Následující příklad ukazuje funkci aktivovanou časovačem, která vymaže historii pro všechny instance orchestrace, které se dokončily po zadaném časovém intervalu. V tomto případě odebere data pro všechny instance dokončené před 30 nebo více dny. Tato ukázková funkce je naplánovaná tak, aby běžela jednou denně v 12:00 UTC:

C#

Izolovaný model pracovního procesu

[Function("PurgeInstanceHistory")]
public static async Task Run(
    [DurableClient] DurableTaskClient client,
    [TimerTrigger("0 0 12 * * *")] TimerInfo myTimer)
{
    var filter = new PurgeInstancesFilter(
        CreatedFrom: DateTime.MinValue,
        CreatedTo: DateTime.UtcNow.AddDays(-30),
        Statuses: new[] { OrchestrationRuntimeStatus.Completed });

    await client.PurgeAllInstancesAsync(filter);
}

Model v probíhajícím procesu

[FunctionName("PurgeInstanceHistory")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [TimerTrigger("0 0 12 * * *")] TimerInfo myTimer)
{
    return client.PurgeInstanceHistoryAsync(
        DateTime.MinValue,
        DateTime.UtcNow.AddDays(-30),  
        new List<OrchestrationStatus>
        {
            OrchestrationStatus.Completed
        });
}

JavaScript

Metodu purgeInstanceHistoryBy lze použít k podmíněnému vymazání historie instancí pro více instancí.

function.json

{
  "bindings": [
    {
      "schedule": "0 0 12 * * *",
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Tento příklad cílí na Durable Functions verze 2.x. Ve verzi 1.x použijte orchestrationClient místo durableClient.

index.js

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

module.exports = async function (context, myTimer) {
    const client = df.getClient(context);
    const createdTimeFrom = new Date(0);
    const createdTimeTo = new Date().setDate(today.getDate() - 30);
    const runtimeStatuses = [ df.OrchestrationRuntimeStatus.Completed ];
    return client.purgeInstanceHistoryBy(createdTimeFrom, createdTimeTo, runtimeStatuses);
};

PowerShell

Poznámka:

Tato funkce se v PowerShellu v současné době nepodporuje, ale můžete ji dosáhnout pomocí rozhraní API http Durable Functions.

Python

import azure.functions as func
import azure.durable_functions as df
from azure.durable_functions.models.DurableOrchestrationStatus import OrchestrationRuntimeStatus
from datetime import datetime, timedelta

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    created_time_from = datetime.min
    created_time_to = datetime.today() + timedelta(days = -30)
    runtime_statuses = [OrchestrationRuntimeStatus.Completed]

    return await client.purge_instance_history_by(created_time_from, created_time_to, runtime_statuses)

Java

@FunctionName("PurgeInstances")
public void purgeInstances(
        @TimerTrigger(name = "purgeTimer", schedule = "0 0 12 * * *") String timerInfo,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        ExecutionContext context) throws TimeoutException {
    PurgeInstanceCriteria criteria = new PurgeInstanceCriteria()
            .setCreatedTimeFrom(Instant.now().minus(Duration.ofDays(60)))
            .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(30)))
            .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.COMPLETED));
    PurgeResult result = durableContext.getClient().purgeInstances(criteria);
    context.getLogger().info(String.format("Purged %d instance(s)", result.getDeletedInstanceCount()));
}

C#

using Microsoft.DurableTask.Client;

// Purge completed instances older than 30 days
var filter = new PurgeInstancesFilter(
    CreatedFrom: DateTime.MinValue,
    CreatedTo: DateTime.UtcNow.AddDays(-30),
    Statuses: new[] { OrchestrationRuntimeStatus.Completed });

PurgeResult result = await client.PurgeAllInstancesAsync(filter);
Console.WriteLine($"Purged {result.PurgedInstanceCount} instance(s).");

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient
from datetime import datetime, timedelta

# Purge completed instances older than 30 days
result = client.purge_orchestrations(
    created_time_from=datetime.min,
    created_time_to=datetime.utcnow() - timedelta(days=30),
    runtime_status=['COMPLETED']
)
print(f"Purged {result.deleted_instance_count} instance(s).")

Java

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.PurgeInstanceCriteria;
import com.microsoft.durabletask.PurgeResult;
import com.microsoft.durabletask.OrchestrationRuntimeStatus;
import java.time.Duration;
import java.time.Instant;
import java.util.List;

// Purge completed instances older than 30 days
PurgeInstanceCriteria criteria = new PurgeInstanceCriteria()
    .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(30)))
    .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.COMPLETED));

PurgeResult result = client.purgeInstances(criteria);
System.out.println("Purged " + result.getDeletedInstanceCount() + " instance(s).");

JavaScript

import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";
import { OrchestrationStatus, PurgeInstanceCriteria } from "@microsoft/durabletask-js";

const client = createAzureManagedClient(connectionString);

// Purge completed instances older than 30 days
const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

const criteria = new PurgeInstanceCriteria();
criteria.setCreatedTimeTo(thirtyDaysAgo);
criteria.setRuntimeStatusList([OrchestrationStatus.COMPLETED]);

const result = await client.purgeOrchestration(criteria);
console.log(`Purged ${result?.deletedInstanceCount ?? 0} instance(s).`);

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Poznámka:

Aby operace vyprázdnění historie proběhla úspěšně, stav běhu cílové instance musí být Dokončeno, Ukončeno nebo Neúspěšné.

Další kroky

Správa verzování

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

Začínáme se sadami SDK Durable Task

Další informace o plánovači trvalých úloh