Zarządzanie wystąpieniami orkiestracji

Wbudowane interfejsy API zarządzania wystąpieniami umożliwiają uruchamianie, wykonywanie zapytań, kończenie, wstrzymywanie, wznawianie i przeczyszczanie wystąpień aranżacji w trwałych przepływach pracy. W Durable Functions powiązanie klienta orchestration uwidacznia te interfejsy API. W zestawach SDK Durable Task te same operacje są dostępne przez klasę DurableTaskClient. W tym artykule pokazano, jak wykonać każdą operację zarządzania wystąpieniami przy użyciu przykładów kodu dla obu platform.

Wskazówka

Azure Durable Task Scheduler jest zalecanym zapleczem technicznym zarówno dla Durable Functions, jak i Durable Task SDKs, zapewniając w pełni zarządzane, bezserwerowe środowisko do uruchamiania odpornych przepływów pracy w dużej skali.

Uruchamianie wystąpień

Metoda start-new (lub schedule-new) na kliencie orkiestracji uruchamia nowe wystąpienie orkiestracji. Wewnętrznie ta metoda zapisuje wiadomość do skonfigurowanego backendu (takiego jak Durable Task Scheduler), a następnie zwraca wiadomość. Ten komunikat asynchronicznie wyzwala początek aranżacji o określonej nazwie.

Poniżej przedstawiono parametry uruchamiania nowego wystąpienia orkiestracji:

Ważna

Wsparcie dla modelu w toku zakończy się 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu roboczego w celu uzyskania pełnej obsługi.

Parameter	Opis
Nazwa	Nazwa orchestratora służy do harmonogramu.
Dane wejściowe	Wszelkie dane serializowalne w JSON, które powinny być przekazywane jako wejście do funkcji orchestratora.
Identyfikator wystąpienia	(Opcjonalnie) Unikalny identyfikator instancji. Jeśli nie określisz tego parametru, metoda używa losowego identyfikatora.

Wskazówka

Użyj identyfikatora losowego dla identyfikatora wystąpienia, jeśli jest to możliwe. Identyfikatory wystąpień losowych pomagają zapewnić równomierny rozkład obciążenia podczas skalowania funkcji orkiestratora na wielu maszynach wirtualnych. Odpowiedni czas używania niestosowych identyfikatorów wystąpień jest wtedy, gdy identyfikator pochodzi ze źródła zewnętrznego lub podczas implementowania wzorca orkiestratora typu singleton.

Parameter	Opis
Nazwa	Nazwa orkiestracji do harmonogramu.
Dane wejściowe	Wszelkie dane serializowalne w JSON, które powinny być przekazywane jako wejście do orkiestracji.
Identyfikator wystąpienia	(Opcjonalnie) Unikalny identyfikator instancji. Jeśli nie określisz tego parametru, metoda używa losowego identyfikatora.

Wskazówka

Użyj identyfikatora losowego dla identyfikatora wystąpienia, jeśli jest to możliwe. Identyfikatory wystąpień losowych pomagają zapewnić równomierne rozłożenie obciążenia podczas skalowania orkiestracji na wielu maszynach wirtualnych. Odpowiedni czas używania niestosowych identyfikatorów wystąpień jest wtedy, gdy identyfikator pochodzi ze źródła zewnętrznego lub podczas implementowania wzorca orkiestratora typu singleton.

Przykładowa funkcja, którą za chwilę zobaczysz, uruchamia nową instancję orkiestracji.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

Jeśli nie określono inaczej, przykłady na tej stronie używają wyzwalacza HTTP z następującymi 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
}

Uwaga / Notatka

Przykład ten dotyczy Durable Functions w wersji 2.x. W wersji 1.x użyj polecenia orchestrationClient zamiast 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}.`);
};

Jeśli nie określono inaczej, przykłady na tej stronie używają wyzwalacza HTTP z następującymi 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
}

Uwaga / Notatka

Przykład ten dotyczy Durable Functions w wersji 2.x. W wersji 1.x użyj polecenia orchestrationClient zamiast 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}.")

Jeśli nie określono inaczej, przykłady na tej stronie używają wyzwalacza HTTP z następującymi 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
}

Uwaga / Notatka

Przykład ten dotyczy Durable Functions w wersji 2.x. W wersji 1.x użyj polecenia orchestrationClient zamiast durableClient.

run.ps1

param($Request, $TriggerMetadata)

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

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

Aby zaczekać na uruchomienie orchestratorem przed powrotem z funkcji, użyj metody waitForInstanceStart().

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

Ważna

Obecnie zestaw POWERShell Durable Task SDK nie jest dostępny.

Poniższy kod pokazuje, jak uruchomić nowe wystąpienie orkiestracji przy użyciu SDK Durable Task:

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

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)

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

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

Instancje zapytań

Po uruchomieniu nowych wystąpień orkiestracji najprawdopodobniej musisz wykonać zapytanie dotyczące ich stanu czasu wykonywania, aby dowiedzieć się, czy są uruchomione, ukończone lub zakończone niepowodzeniem.

Metoda get-status na kliencie orkiestracji zwraca stan instancji orkiestracji.

Przyjmuje ( instanceId wymagane), showHistory (opcjonalne), showHistoryOutput (opcjonalne) i showInput (opcjonalnie) jako parametry.

showHistory: Jeśli ustawiono wartość true, odpowiedź zawiera historię wykonywania.
showHistoryOutput: Jeśli ustawiono wartość true, historia wykonywania zawiera dane wyjściowe działań.
showInput: Jeśli ustawiono wartość false, odpowiedź nie zawiera danych wejściowych funkcji. Domyślna wartość to true.

Metoda zwraca obiekt o następujących właściwościach:

Property	Opis
Nazwa	Nazwa funkcji orkiestratora.
Identyfikator wystąpienia	ID instancji orkiestracji (powinno być takie samo jak `instanceId` wejście).
Czas utworzenia	Moment, w którym funkcja orchestratora zaczyna działać.
LastUpdatedTime	Czas, w którym orkiestracja się kończy, to punkt kontrolny.
Dane wejściowe	Dane wejściowe funkcji jako wartość JSON. To pole nie jest wypełniane, jeśli `showInput` ma wartość `false`.
CustomStatus	Status niestandardowej orkiestracji w formacie JSON.
Output	Dane wyjściowe funkcji jako wartość JSON (jeśli działanie funkcji zostanie zakończone). Jeśli funkcja orkiestratora zakończy się niepowodzeniem, ta właściwość zawiera szczegóły błędu. Jeśli funkcja orkiestratora jest zawieszona lub zakończona, ta właściwość zawiera przyczynę zawieszenia lub zakończenia (jeśli istnieje).
RuntimeStatus: Oczekuje	Instancja została zaplanowana, ale jeszcze nie została uruchomiona.
RuntimeStatus: Działający	Instancja działa.
RuntimeStatus: Ukończone	Instancja zakończyła się normalnie.
Stan uruchomienia: Kontynuowano jako nowe	Instancja uruchomiła się ponownie z nową historią. Ten stan jest stanem przejściowym.
RuntimeStatus: Nieudane	Instancja zakończyła się błędem.
RuntimeStatus: Zakończony	Instancja nagle się zatrzymała.
RuntimeStatus: Zawieszony	Instancja zostaje zawieszona i można ją wznowić później.
Historia	Historia wykonania orkiestracji. To pole jest wypełniane tylko wtedy, gdy `showHistory` jest ustawione na `true`.

Parameter	Opis
`showHistory`	Jeśli ustawimy na `true`, odpowiedź zawiera historię wykonania.
`showHistoryOutput`	Jeśli ustawiono wartość `true`, historia wykonywania zawiera dane wyjściowe działania.
`showInput`	Jeśli ustawiono na `false`, odpowiedź nie zawiera danych wejściowych orkiestracji. Domyślna wartość to `true`.

Metoda zwraca obiekt o następujących właściwościach:

Property	Opis
Nazwa	Nazwa orkiestracji.
Identyfikator wystąpienia	Identyfikator instancji orkiestracji (powinien być taki sam jak dane wejściowe `instanceId`).
Czas utworzenia	Moment, w którym orkiestracja zaczyna działać.
LastUpdatedTime	Czas, w którym orkiestracja się kończy, to punkt kontrolny.
Dane wejściowe	Dane wejściowe orkiestracji jako wartość JSON. To pole nie jest wypełniane, jeśli `showInput` ma wartość `false`.
CustomStatus	Status niestandardowej orkiestracji w formacie JSON.
Output	Dane wyjściowe orkiestracji jako wartość JSON (jeśli orkiestracja się zakończy). Jeśli aranżacja zakończy się niepowodzeniem, ta właściwość zawiera szczegóły błędu. Jeśli aranżacja jest zawieszona lub zakończona, ta właściwość zawiera przyczynę zawieszenia lub zakończenia (jeśli istnieje).
RuntimeStatus: Oczekuje	Instancja została zaplanowana, ale jeszcze nie została uruchomiona.
RuntimeStatus: Działający	Instancja jest uruchomiona.
RuntimeStatus: Ukończone	Instancja zakończyła się normalnie.
Stan uruchomienia: Kontynuowano jako nowe	Instancja uruchomiła się ponownie z nową historią. Ten stan jest stanem przejściowym.
RuntimeStatus: Nieudane	Instancja zakończyła się błędem.
RuntimeStatus: Zakończony	Instancja nagle się zatrzymała.
RuntimeStatus: Zawieszony	Instancja zostaje zawieszona i może zostać wznowiona w późniejszym czasie.
Historia	Historia wykonania orkiestracji. To pole jest wypełniane tylko wtedy, gdy `showHistory` jest ustawione na `true`.

Uwaga / Notatka

Orkiestrator nie jest oznaczany jako Completed dopóki nie zakończą się wszystkie zaplanowane zadania i nie powróci orkiestrator. Innymi słowy, nie wystarczy, aby orkiestrator dotarł do swojej return instrukcji, aby został oznaczony jako Completed. Jest to szczególnie istotne w przypadkach, w których WhenAny jest używane; te orkiestratory często return przed wykonaniem wszystkich zaplanowanych zadań.

Ta metoda zwraca null (.NET i Java), undefined (JavaScript) lub None (Python), jeśli instancja nie istnieje.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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: ...
}

Aby zapoznać się z konfiguracją function.json, patrz Uruchamianie wystąpień.

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) { ...

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') { ... }

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

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
}

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

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
}

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
}

Wykonywanie zapytań dotyczących wszystkich wystąpień orkiestracji

Możesz używać interfejsów API w SDK w danym języku, aby wykonywać zapytania dotyczące statusów wszystkich instancji orkiestracji w centrum zadań. Interfejs API "list-instances" lub "get-status" zwraca listę obiektów reprezentujących instancje orkiestracji zgodne z parametrami zapytania.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Aby uzyskać konfigurację function.json, zobacz Rozpocznij wystąpienia.

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

Aby uzyskać konfigurację function.json, zobacz Rozpocznij wystąpienia.

@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.";
}

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

for instance in instances:
    print(instance.instance_id)

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

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

Instancje orkiestracji zapytań z filtrami

Co zrobić, jeśli nie potrzebujesz wszystkich informacji, które udostępnia zapytanie wystąpienia standardowego? Na przykład co zrobić, jeśli szukasz czasu utworzenia orkiestracji lub statusu działania orkiestracji? Zawęź zapytanie, stosując filtry.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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

@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.";
}

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

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

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

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

Kończenie instancji orkiestracji

Jeśli masz wystąpienie orkiestracji, które trwa zbyt długo, lub musisz zatrzymać je przed ukończeniem z jakiegokolwiek powodu, możesz go zakończyć.

API do zakończenia ma dwa parametry: identyfikator wystąpienia i ciąg znaków przyczyny, które są zapisywane w dziennikach i w stanie wystąpienia.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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)

param($Request, $TriggerMetadata)

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

Stop-DurableOrchestration -InstanceId $InstanceId -Reason $Reason

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

const client = createAzureManagedClient(connectionString);

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

Zakończone wystąpienie ostatecznie przechodzi do stanu Terminated. Ale to przejście nie dzieje się natychmiast. Zamiast tego operacja zakończenia jest kolejkowana w centrum zadań wraz z innymi operacjami dla tego wystąpienia. Możesz użyć interfejsów API zapytania instancji, aby dowiedzieć się, kiedy zakończona instancja faktycznie osiągnęła Terminated stan.

Uwaga / Notatka

Zakończenie wystąpienia nie jest obecnie propagowane. Funkcje aktywności i pod-orkiestracje działają do zakończenia, niezależnie od tego, czy kończy się wystąpienie orkiestracji, które je wywołało.

Wstrzymywanie i wznawianie procesów orkiestracji

Wstrzymanie orkiestracji umożliwia zatrzymanie działającej orkiestracji. W przeciwieństwie do zakończenia orkiestracji, można wznowić zawieszonego orkiestratora w późniejszym czasie.

Dwa parametry API zawieszenia to identyfikator wystąpienia i ciąg przyczyny, które są zapisywane w dziennikach i w stanie wystąpienia.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

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)

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

Uwaga / Notatka

Ta funkcja jest dostępna tylko w autonomicznym zestawie SDK programu PowerShell Durable Functions. Zapoznaj się z różnicą między autonomicznym zestawem SDK i starszym wbudowanym zestawem SDK wraz z przewodnikiem migracji.

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

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

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)

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

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

Wstrzymane wystąpienie ostatecznie przechodzi do stanu Suspended. Jednak to przejście nie następuje natychmiast. Zamiast tego, operacja wstrzymania jest kolejkowana w hubie zadań wraz z innymi operacjami dla tego wystąpienia. Użyj API zapytań dla wystąpień, aby dowiedzieć się, kiedy działające wystąpienie rzeczywiście osiągnęło Suspended stan.

Po wznowieniu zawieszonego koordynatora jego stan zmieni się z powrotem na Running.

Wyślij zdarzenia do wystąpień

W niektórych scenariuszach funkcje orkiestratora muszą czekać i nasłuchiwać zdarzeń zewnętrznych. Przykłady, w których takie podejście jest przydatne, obejmują scenariusze monitorowania i interakcji człowieka .

W niektórych scenariuszach orkiestracje muszą oczekiwać i nasłuchiwać na zdarzenia zewnętrzne. Przykłady, w których takie podejście jest przydatne, obejmują scenariusze monitorowania i interakcji człowieka .

Powiadomienia o zdarzeniach można wysyłać do uruchomionych wystąpień przy użyciu interfejsu API zgłaszania zdarzeń klienta orkiestracji. Orkiestracje mogą nasłuchiwać tych zdarzeń i reagować na nie przy użyciu interfejsu API oczekiwania na zdarzenie zewnętrzne orkiestratora.

Parametry wywołania zdarzenia to:

Identyfikator wystąpienia: unikatowy identyfikator wystąpienia.
Nazwa zdarzenia: nazwa zdarzenia do wysłania.
Dane zdarzenia: ładunek z możliwością serializacji JSON do wysłania do wystąpienia.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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)

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

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

const client = createAzureManagedClient(connectionString);

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

Uwaga / Notatka

Jeśli nie ma wystąpienia orkiestracji z określonym identyfikatorem wystąpienia, komunikat zdarzenia zostanie odrzucony. Jeśli instancja istnieje, ale nie oczekuje jeszcze na zdarzenie, zdarzenie jest przechowywane w stanie instancji, aż będzie gotowe do odebrania i przetworzenia.

Poczekaj na ukończenie aranżacji

W długotrwałych orkiestracjach możesz chcieć poczekać i uzyskać wyniki orkiestracji. W takich przypadkach warto również zdefiniować limit czasu orkiestracji. Jeśli przekroczono limit czasu, stan aranżacji jest zwracany zamiast wyników.

Użyj interfejsu API "czekaj na ukończenie lub utwórz odpowiedź do sprawdzenia stanu", aby uzyskać rzeczywisty wynik z wystąpienia orkiestracji synchronicznie. Domyślnie ta metoda ma limit czasu wynoszący dziesięć sekund i interwał sondowania wynoszący jedną sekundę.

Oto przykładowa funkcja wyzwalacza HTTP, która pokazuje, jak używać tego interfejsu API:

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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

Java nie ma obecnie jednej metody dla tego scenariusza, ale można zaimplementować ją za pomocą kilku dodatkowych wierszy kodu.

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

SDK Durable Task zapewniają metodę oczekiwania na zakończenie orkiestracji w sposób synchroniczny.

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

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

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

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

Wywołaj funkcję za pomocą następującego wiersza. Użyj dwóch sekund dla limitu czasu i 0,5 sekundy dla interwału ponawiania prób:

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

Uwaga / Notatka

Powyższe polecenie cURL zakłada, że masz funkcję orkiestratora o nazwie E1_HelloSequence w projekcie. Ze względu na sposób zapisywania funkcji wyzwalacza HTTP można zastąpić ją nazwą dowolnej funkcji orkiestratora w projekcie.

W zależności od czasu wymaganego do uzyskania odpowiedzi z wystąpienia orkiestracji istnieją dwa przypadki:

Wystąpienia orkiestracji kończą się w zdefiniowanym limicie czasu (w tym przypadku dwie sekundy), a odpowiedź jest rzeczywistym wyjściem wystąpienia orkiestracji, dostarczanym synchronicznie:

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!"
]

Instancje orkiestracji nie mogą się zakończyć w określonym czasie, a odpowiedź jest domyślną określoną w Odnajdywanie adresów URL interfejsu API HTTP:

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

Uwaga / Notatka

Format adresów URL elementu webhook może się różnić w zależności od wersji uruchomionego hosta Azure Functions. Powyższy przykład dotyczy hosta Azure Functions 3.0.

Pobieranie adresów URL webhooków zarządzania za pomocą HTTP dla wystąpień orkiestracji

Użyj systemu zewnętrznego do monitorowania lub zgłaszania zdarzeń do orkiestracji. Systemy zewnętrzne komunikują się z Durable Functions za pośrednictwem adresów URL webhooków, które są częścią domyślnej odpowiedzi opisanej w Odnajdywaniu adresów URL interfejsu API HTTP. Adresy URL elementów webhook są również dostępne programistycznie przy użyciu powiązania klienta orkiestracji. W szczególności interfejs API tworzenia ładunku zarządzania protokołem HTTP pobiera obiekt z możliwością serializacji zawierający te adresy URL elementów webhook.

Interfejs API tworzenia ładunku zarządzania http ma jeden parametr:

Identyfikator wystąpienia: unikatowy identyfikator wystąpienia.

Metody zwracają obiekt z następującymi właściwościami ciągu:

Identyfikator: identyfikator wystąpienia orkiestracji (powinien być taki sam jak InstanceId wejście).
StatusQueryGetUri: URL stanu wystąpienia orkiestracji.
SendEventPostUri: adres URL "zgłoś zdarzenie" wystąpienia orkiestracji.
TerminatePostUri: adres URL "terminate" wystąpienia orkiestracji.
PurgeHistoryDeleteUri: adres URL "czyszczenia historii" wystąpienia orkiestracji.
SuspendPostUri: adres URL "suspend" wystąpienia orkiestracji.
ResumePostUri: URL "resume" dla wystąpienia orkiestracji.

Funkcje wysyłają wystąpienia tych obiektów do systemów zewnętrznych w celu monitorowania lub zgłaszania zdarzeń w odpowiednich orkiestracjach, jak pokazano w poniższych przykładach.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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

using namespace System.Net

param($Request, $TriggerMetadata)

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

Ponowne przewijanie wystąpień aranżacji

Jeśli wystąpi błąd orkiestracji z nieoczekiwanego powodu, cofnij wystąpienie do poprzedniego, zdrowego stanu przy użyciu interfejsu API utworzonego w tym celu.

Uwaga / Notatka

Ten interfejs API nie jest przeznaczony do zastąpienia odpowiednich zasad obsługi błędów i ponawiania prób. Zamiast tego ma być używany tylko w przypadkach, gdy wystąpienia orkiestracji kończą się niepowodzeniem z nieoczekiwanych powodów. Orkiestracje w stanach innych niż Failed (na przykład Running, Pending, Terminated lub Completed) nie mogą być "cofnięte". Aby uzyskać więcej informacji na temat obsługi błędów i zasad ponawiania prób, zobacz artykuł Obsługa błędów .

Użyj metody RewindAsync (.NET) lub rewind (JavaScript) w powiązaniu klienta orkiestracji, aby przywrócić orkiestrację do stanu Running. Ta metoda ponownie uruchamia również błędy wykonywania działań lub podorchestracji, które spowodowały niepowodzenie aranżacji.

Załóżmy, że masz przepływ pracy obejmujący serię zatwierdzeń przez ludzi. Załóżmy, że szereg funkcji aktywności powiadamia kogoś, że ich zatwierdzenie jest potrzebne i czekają na odpowiedź w czasie rzeczywistym. Po otrzymaniu odpowiedzi lub przekroczeniu limitu czasu na wszystkie działania zatwierdzania, załóżmy, że inne działanie kończy się niepowodzeniem z powodu błędnej konfiguracji aplikacji, na przykład z powodu nieprawidłowego ciągu połączenia bazy danych. Wynikiem jest niepowodzenie aranżacji głęboko w przepływie pracy. Za pomocą interfejsu API RewindAsync (.NET) lub rewind (JavaScript) administrator aplikacji może naprawić błąd konfiguracji i przewinąć nieudaną aranżację z powrotem do stanu bezpośrednio przed awarią. Żaden z kroków interakcji z człowiekiem nie musi zostać ponownie zatwierdzony, a aranżacja może zakończyć się pomyślnie.

Uwaga / Notatka

Funkcja przewijania nie obsługuje instancji orkiestracji korzystających z trwałych czasomierzy.

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

using Microsoft.DurableTask.Client;

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

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

Ponowne uruchamianie wystąpień orkiestracji

Ponowne uruchomienie orkiestracji powoduje utworzenie nowego wystąpienia przy użyciu historii wcześniej uruchomionego wystąpienia. Ta funkcja jest przydatna, gdy chcesz ponownie uruchomić orkiestrację z tymi samymi danymi wejściowymi i wzorcem identyfikatora wystąpienia, tworząc nowy przebieg bazujący na oryginalnej orkiestracji.

Model izolowanego pracownika

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

Model w trakcie przetwarzania

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

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

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

Historia wystąpienia orkiestracji przeczyszczania

Aby usunąć wszystkie dane skojarzone z orkiestracją, usuń historię instancji. Na przykład usuń wszystkie zasoby pamięci masowej skojarzone z ukończonym wystąpieniem. Użyj interfejsu API przeczyszczania wystąpienia zdefiniowanego przez klienta aranżacji.

W poniższym przykładzie pokazano, jak wyczyścić pojedynczą instancję orkiestracji.

Model izolowanego pracownika

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

Model w trakcie przetwarzania

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

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

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

Zobacz Uruchom instancje dla konfiguracji function.json.

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)

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

using Microsoft.DurableTask.Client;

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

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).")

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).");

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).`);

W poniższym przykładzie pokazano funkcję wyzwalaną przez czasomierz, która czyści historię wszystkich wystąpień orkiestracji zakończonych po określonym interwale czasu. W takim przypadku usuwa dane dla wszystkich wystąpień ukończonych 30 lub więcej dni temu. Ta przykładowa funkcja jest zaplanowana raz dziennie, o 12:00 CZASU UTC:

Model izolowanego pracownika

[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 w trakcie przetwarzania

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

Metoda purgeInstanceHistoryBy może służyć do warunkowego przeczyszczania historii wystąpień dla wielu wystąpień.

function.json

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

Uwaga / Notatka

Przykład ten dotyczy Durable Functions w wersji 2.x. W wersji 1.x użyj polecenia orchestrationClient zamiast 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);
};

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)

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

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).");

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).")

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).");

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).`);

Uwaga / Notatka

Aby operacja historii przeczyszczania powiodła się, status uruchomieniowy wystąpienia docelowego musi być Zakończony, Przerwany lub Niepowodzenie zakończone.

Następne kroki

Obsługa wersjonowania

Wbudowana dokumentacja API HTTP do zarządzania instancjami

Rozpocznij pracę z zestawami SDK Durable Task

Dowiedz się więcej o harmonogramie zadań trwałych

Opinia

Czy ta strona była pomocna?

Last updated on 2026-08-15

Zarządzanie wystąpieniami orkiestracji

Uruchamianie wystąpień

Instancje zapytań

Wykonywanie zapytań dotyczących wszystkich wystąpień orkiestracji

Instancje orkiestracji zapytań z filtrami

Kończenie instancji orkiestracji

Wstrzymywanie i wznawianie procesów orkiestracji

Wyślij zdarzenia do wystąpień

Poczekaj na ukończenie aranżacji

Pobieranie adresów URL webhooków zarządzania za pomocą HTTP dla wystąpień orkiestracji

Ponowne przewijanie wystąpień aranżacji

Ponowne uruchamianie wystąpień orkiestracji

Historia wystąpienia orkiestracji przeczyszczania

Następne kroki

Opinia

Dodatkowe zasoby