Hantera orkestreringsinstanser

Använd de inbyggda instanshanterings-API:erna för att starta, fråga, avsluta, pausa, återuppta och rensa orkestreringsinstanser i dina varaktiga arbetsflöden. I Durable Functions exponerar klientbindningen orchestration dessa API:er. I SDK:erna för varaktiga uppgifter är samma åtgärder tillgängliga via DurableTaskClient klassen. Den här artikeln visar hur du utför varje instanshanteringsåtgärd med kodexempel för båda plattformarna.

Tips/Råd

Azure Durable Task Scheduler är den rekommenderade serverdelen för både Durable Functions och Durable Task SDK:er, vilket ger en fullständigt hanterad, serverlös upplevelse för att köra hållbara arbetsflöden i stor skala.

Starta instanser

Metoden start-new (eller schedule-new) på orkestreringsklienten startar en ny orkestreringsinstans. Internt skriver denna metod ett meddelande till den konfigurerade backend (såsom Durable Task Scheduler) och returnerar sedan. Det här meddelandet utlöser asynkront början på en orkestrering med det angivna namnet.

Här är parametrarna för att starta en ny orkestreringsinstans:

Viktigt!

Stödet för den pågående processmodellen kommer att upphöra den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Parameter	Description
Namn	Namnet på orkestratörfunktionen för schemaläggning.
Input	All JSON-serialiserbar data som ska skickas som indata till orkestratorfunktionen.
InstanceId	(Valfritt) Den unika identifieringen av instansen. Om du inte anger den här parametern använder metoden ett slumpmässigt ID.

Tips/Råd

Använd en slumpmässig identifierare för instans-ID:t när det är möjligt. Slumpmässiga instans-ID:er hjälper till att säkerställa en lika belastningsfördelning när du skalar orkestreringsfunktioner över flera virtuella datorer. Det är rätt tid att använda icke-slumpmässiga instans-ID när ID:t kommer från en extern källa eller när du implementerar singleton orchestrator-mönstret.

Parameter	Description
Namn	Namnet på den orkestrering som ska schemaläggas.
Input	All JSON-serialiserbar data som ska skickas som indata till orkestreringen.
InstanceId	(Valfritt) Den unika identifieringen av instansen. Om du inte anger den här parametern använder metoden ett slumpmässigt ID.

Tips/Råd

Använd en slumpmässig identifierare för instans-ID:t när det är möjligt. Slumpmässiga instans-ID:er hjälper till att säkerställa en lika belastningsfördelning när du skalar orkestreringar över flera virtuella datorer. Det är rätt tid att använda icke-slumpmässiga instans-ID när ID:t kommer från en extern källa eller när du implementerar singleton orchestrator-mönstret.

Följande exempelfunktion startar en ny orkestreringsinstans:

C#

Isolerad arbetsmodell

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

Processmodell

[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

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande 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
}

Anmärkning

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för 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

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande 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
}

Anmärkning

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för 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

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande 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
}

Anmärkning

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för 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);
}

Om du vill vänta tills orkestratorn startar innan du återvänder från funktionen använder du waitForInstanceStart() metoden .

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

Viktigt!

PowerShell Durable Task SDK är för närvarande inte tillgängligt.

Följande kod visar hur du startar en ny orkestreringsinstans med hjälp av Durable Task SDK:er:

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Frågeinstanser

När du har startat nya orkestreringsinstanser behöver du troligen göra förfrågningar om deras körstatus för att få reda på om de körs, är slutförda eller har misslyckats.

Metoden get-status på orkestreringsklienten returnerar statusen för en orkestreringsinstans.

Det tar en instanceId (obligatorisk), showHistory (valfritt), showHistoryOutput (valfritt) och showInput (valfritt) som parametrar.

• showHistory: Om det är inställt på true, innehåller svaret körningshistoriken.
• showHistoryOutput: Om det är inställt på true, innehåller körningshistoriken aktivitetsutdata.
• showInput: Om det är inställt falsepå innehåller svaret inte indata för funktionen. Standardvärdet är true.

Metoden returnerar ett objekt med följande egenskaper:

Property	Description
Namn	Namnet på orkestratörfunktionen.
InstanceId	Instans-ID:t för orkestreringen (bör vara detsamma som instanceId inmatningen).
CreatedTime	Den tidpunkt då orkestratorfunktionen börjar köras.
LastUpdatedTime	Tidpunkten då orkestreringen senast skapade en kontrollpunkt.
Input	Funktionens indata som ett JSON-värde. Det här fältet fylls inte i om showInput är false.
CustomStatus	Anpassad orkestreringsstatus i JSON-format.
Output	Utdata från funktionen som ett JSON-värde (om funktionen fullbordas). Om orkestreringsfunktionen misslyckas innehåller den här egenskapen information om felet. Om orkestreringsfunktionen pausas eller avslutas innehåller den här egenskapen orsaken till avstängningen eller avslutningen (om någon).
RuntimeStatus: Väntar	Instansen är schemalagd men har ännu inte börjat köras.
RuntimeStatus: Körs	Instansen körs.
RuntimeStatus: Slutförd	Instansen avslutades normalt.
KörtidStatus: FortsätterSom Nytt	Instansen startade om med en ny historik. Det här tillståndet är ett tillfälligt tillstånd.
RuntimeStatus: Misslyckades	Instansen misslyckades på grund av ett fel.
RuntimeStatus: Avslutad	Händelsen avbröts abrupt.
RuntimeStatus: Pausad	Instansen avbryts och kan återupptas senare.
History	Genomförandehistoriken för orkestreringen. Det här fältet fylls bara i om showHistory är inställt på true.

Parameter	Description
showHistory	Om den sätts till true, innehåller svaret exekveringshistoriken.
showHistoryOutput	Om den sätts till true, innehåller exekveringshistoriken aktivitetsutdata.
showInput	Om värdet är false, innehåller svaret inte indata till orkestreringen. Standardvärdet är true.

Metoden returnerar ett objekt med följande egenskaper:

Property	Description
Namn	Namnet på orkestreringen.
InstanceId	Instans-ID:t för orkestreringen (bör vara detsamma som instanceId inmatningen).
CreatedTime	Tidpunkten då orkestreringen börjar köras.
LastUpdatedTime	Tidpunkten då orkestreringen senast skapade en kontrollpunkt.
Input	Indata för orkestreringen som ett JSON-värde. Det här fältet fylls inte i om showInput är false.
CustomStatus	Anpassad orkestreringsstatus i JSON-format.
Output	Utdata från orkestreringen som ett JSON-värde (om orkestreringen slutförs). Om orkestreringen misslyckas innehåller den här egenskapen information om felet. Om orkestreringen avbryts eller avslutas innehåller den här egenskapen orsaken till avstängningen eller uppsägningen (om någon).
RuntimeStatus: Väntar	Instansen är schemalagd men har ännu inte börjat köras.
RuntimeStatus: Körs	Instansen körs.
RuntimeStatus: Slutförd	Instansen slutfördes normalt.
KörtidStatus: FortsätterSom Nytt	Instansen startade om sig själv med en ny historia. Det här tillståndet är ett tillfälligt tillstånd.
RuntimeStatus: Misslyckades	Instansen misslyckades på grund av ett fel.
RuntimeStatus: Avslutad	Händelsen avbröts abrupt.
RuntimeStatus: Pausad	Instansen avbryts och kan återupptas vid ett senare tillfälle.
History	Genomförandehistoriken för orkestreringen. Det här fältet fylls bara i om showHistory är inställt på true.

Anmärkning

En orkestrerare markeras inte som Completed förrän alla schemalagda uppgifter har slutförts och orkestratorn återvänder. Med andra ord räcker det inte att en orkestrerare når sin return instruktion för att den ska markeras som Completed. Detta är särskilt relevant för fall där WhenAny används; dessa orkestratorer ofta return innan alla schemalagda uppgifter körs.

Den här metoden returnerar null (.NET och Java), undefined (JavaScript) eller None (Python) om instansen inte finns.

C#

Isolerad arbetsmodell

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

Processmodell

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

Mer information omfunction.json konfiguration finns i Starta instanser.

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Hämta alla orkestreringsinstanser

Du kan använda API:er i ditt språk-SDK för att fråga efter status för alla orkestreringsinstanser i aktivitetshubben. Det här "list-instances" eller "get-status"- API:et returnerar en lista över objekt som representerar orkestreringsinstanserna som matchar frågeparametrarna.

C#

Isolerad arbetsmodell

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

Processmodell

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

Mer information om function.json konfiguration finns i Starta instanser.

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

Mer information om function.json konfiguration finns i Starta instanser.

PowerShell

Anmärkning

PowerShell stöder för närvarande inte den här funktionen, men du kan uppnå den med hjälp av Durable Functions 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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Sök orkestreringsinstanser med filter

Vad händer om du inte behöver all information som en standardinstansfråga tillhandahåller? Vad händer om du till exempel bara letar efter orkestreringsgenereringstiden eller orkestreringskörningsstatusen? Begränsa frågan genom att använda filter.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Anmärkning

Den här funktionen stöds inte för närvarande i PowerShell, men du kan uppnå den med hjälp av Durable Functions 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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Avsluta orkestreringsinstanser

Om du har en orkestreringsinstans som tar för lång tid att köra, eller om du behöver stoppa den innan den slutförs av någon anledning, kan du avsluta den.

De två parametrarna för termins-API:et är ett instans-ID och en orsakssträng som skriver till loggar och till instansstatusen.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

En avslutad instans övergår så småningom till tillståndet Terminated . Men den här övergången sker inte omedelbart. I stället placeras avslutningsåtgärden i aktivitetshubben tillsammans med andra åtgärder för denna instans. Du kan använda API:erna för instansfrågor för att veta när en avslutad instans faktiskt har nått Terminated tillståndet.

Anmärkning

Instansnedstängning sprids just nu inte. Aktivitetsfunktioner och underorkestreringar körs tills de är klara, oavsett om du avslutar den orkestreringsinstans som anropade dem.

Pausa och återuppta orkestreringsinstanser

Om du pausar en orkestrering kan du stoppa en orkestrering som körs. Till skillnad från att avsluta en orkestrering kan du återuppta en pausad orkestrerare senare.

De två parametrarna för det pausade API:et är ett instans-ID och en orsakssträng som skrivs till loggar och till instansstatusen.

C#

Isolerad arbetsmodell

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

Processmodell

[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

Anmärkning

Den här funktionen är endast tillgänglig i fristående Durable Functions PowerShell SDK. Se skillnaden mellan det fristående SDK:et och det äldre inbyggda SDK:et tillsammans med migreringsguiden.

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

En pausad instans övergår så småningom till tillståndet Suspended . Den här övergången sker dock inte omedelbart. Pausåtgärden placeras i stället i aktivitetshubben tillsammans med andra åtgärder för den instansen. Använd API:erna för instansfrågor för att veta när en instans som körs faktiskt har nått tillståndet Suspended .

När en pausad orkestrerare återupptas ändras dess status tillbaka till Running.

Skicka händelser till instanser

I vissa scenarier måste orkestreringsfunktioner vänta och lyssna efter externa händelser. Exempel där den här metoden är användbar är scenarier för övervakning och mänsklig interaktion .

I vissa scenarier måste orkestreringar vänta och lyssna efter externa händelser. Exempel där den här metoden är användbar är scenarier för övervakning och mänsklig interaktion .

Du kan skicka händelsemeddelanden till instanser som körs med hjälp av api:et för att skapa händelse i orkestreringsklienten. Orkestreringar kan lyssna på och svara på dessa händelser genom att använda orkestrerar-API:t för att vänta på externa händelser.

Parametrarna för höjningshändelsen är:

• Instans-ID: Instansens unika ID.
• Händelsenamn: Namnet på den händelse som ska skickas.
• Händelsedata: En JSON-serialiserbar nyttolast som ska skickas till instansen.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Anmärkning

Om det inte finns någon orkestreringsinstans med det angivna instans-ID:t ignoreras händelsemeddelandet. Om det finns en instans men den ännu inte väntar på händelsen lagras händelsen i instanstillståndet tills den är redo att tas emot och bearbetas.

Vänta tills orkestrering har slutförts

I långvariga orkestreringar kanske du vill vänta och få resultatet av en orkestrering. I dessa fall är det också användbart att definiera en tidsgräns för orkestreringen. Om tidsgränsen överskrids returneras orkestreringens tillstånd i stället för resultatet.

Använd API :et "vänta på slutförande eller skapa svar på kontrollstatus" för att hämta faktiska utdata från en orkestreringsinstans synkront. Som standard har den här metoden en timeout på tio sekunder och ett avsökningsintervall på en sekund.

Här är ett exempel på en HTTP-utlösarfunktion som visar hur du använder det här API:et:

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Anmärkning

PowerShell har för närvarande inte något inbyggt kommando för det här scenariot.

Java

Java har för närvarande inte en enda metod för det här scenariot, men du kan implementera den med några extra kodrader.

@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:er för varaktiga uppgifter tillhandahåller en metod för att vänta tills en orkestrering slutförs synkront.

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Anropa funktionen med följande rad. Använd två sekunder för tidsgränsen och 0,5 sekunder för återförsöksintervallet:

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

Anmärkning

Ovanstående cURL-kommando förutsätter att du har en orchestrator-funktion med namnet E1_HelloSequence i projektet. På grund av hur HTTP-utlösarfunktionen skrivs kan du ersätta den med namnet på valfri orkestreringsfunktion i projektet.

Beroende på den tid som krävs för att hämta svaret från orkestreringsinstansen finns det två fall:

• Orkestreringsinstanserna avslutas inom den definierade tidsgränsen (i det här fallet två sekunder), och svaret är den faktiska orkestreringsinstansens utdata, som levereras synkront:

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

• Orkestreringsinstanserna kan inte slutföras inom den definierade tidsgränsen, och svaret är standarden som beskrivs i HTTP API URL-upptäckt:

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

Anmärkning

Formatet på webhooks-URL:erna kan variera beroende på vilken version av Azure Functions värd du kör. Föregående exempel är för Azure Functions 3.0-värdmiljö.

Hämta HTTP-hanteringswebbhooks-URL:er för orkestreringsinstanser

Använd ett externt system för att övervaka eller utlösa händelser för en orkestrering. Externa system kommunicerar med Durable Functions via webhook-URL:er som ingår i standardsvaret som beskrivs i HTTP API URL-identifiering. Webhook-URL:erna är alternativt tillgängliga programmatiskt med hjälp av orkestreringsklientbindningen. Mer specifikt hämtar API:et create HTTP management payload ett serialiserbart objekt som innehåller dessa webhook-URL:er.

API för att skapa HTTP-hanteringsnyttolast har en parameter:

• Instans-ID: Instansens unika ID.

Metoderna returnerar ett objekt med följande strängegenskaper:

• ID: Instans-ID för orkestreringen (bör vara samma som InstanceId indata).
• StatusQueryGetUri: Status-URL:en för orkestreringsinstansen.
• SendEventPostUri: URL för att "utlösa händelse" med orkestreringsinstansen.
• TerminatePostUri: "avsluta"-URL:en för orkestreringsinstansen.
• PurgeHistoryDeleteUri: URL:en för "rensningshistorik" för orkestreringsinstansen.
• SuspendPostUri: URL för att suspendera orkestreringsinstansen.
• ResumePostUri: Den "återuppta" URL:en för orkestreringsinstansen.

Funktioner skickar instanser av dessa objekt till externa system för att övervaka eller utlösa händelser på motsvarande orkestreringar, som visas i följande exempel.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Anmärkning

Java stöder för närvarande inte den här funktionen.

Spola tillbaka orkestreringsinstanser

Om du har ett orkestreringsfel av en oväntad anledning spolar du tillbaka instansen till ett tidigare felfritt tillstånd med hjälp av ett API som skapats för det ändamålet.

Anmärkning

Det här API:et är inte avsett att ersätta korrekt felhantering och återförsöksprinciper. Det är i stället avsett att endast användas i fall där orkestreringsinstanser misslyckas av oväntade skäl. Orkestreringar i andra tillstånd än Failed (till exempel Running, Pending, Terminatedeller Completed) kan inte "återskapas". Mer information om felhantering och återförsöksprinciper finns i artikeln Felhantering .

Använd metoden RewindAsync (.NET) eller rewind (JavaScript) för klientbindningen orchestration för att återställa orkestreringen till Running. Den här metoden kör också om körningsfelen för aktiviteten eller delorchestrationen som orsakade orkestreringsfelet.

Anta till exempel att du har ett arbetsflöde som omfattar en rad mänskliga godkännanden. Anta att en serie aktivitetsfunktioner meddelar någon att deras godkännande behövs och väntar ut realtidssvaret. När alla godkännandeaktiviteter har fått svar eller blivit tidsbegränsade, kan vi anta att en annan aktivitet misslyckas på grund av ett konfigurationsfel i applikationen, som till exempel en ogiltig databasanslutningssträng. Resultatet är ett orkestreringsfel djupt in i arbetsflödet. Med API:et RewindAsync (.NET) eller rewind (JavaScript) kan en programadministratör åtgärda konfigurationsfelet och spola tillbaka den misslyckade orkestreringen till tillståndet omedelbart före felet. Inget av stegen för mänsklig interaktion behöver godkännas på nytt och orkestreringen kan nu slutföras.

Anmärkning

Återspolningsfunktionen har inte stöd för att spola tillbaka orkestreringsinstanser som använder varaktiga timers.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av function.json.

Python

Anmärkning

Python stöder för närvarande inte den här funktionen.

PowerShell

Anmärkning

PowerShell stöder för närvarande inte den här funktionen.

Java

Anmärkning

Java stöder för närvarande inte den här funktionen.

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

Det här exemplet visas endast för .NET och JavaScript.

PowerShell

Det här exemplet visas endast för .NET och JavaScript.

Java

Det här exemplet visas endast för .NET och JavaScript.

Starta om orkestreringsinstanser

Om du startar om en orkestrering skapas en ny instans med hjälp av historiken från en tidigare körd instans. Den här funktionen är användbar när du vill köra en orkestrering igen med samma indata- och instans-ID-mönster, vilket skapar en ny körning baserat på originalet.

C#

Isolerad arbetsmodell

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

Processmodell

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

JavaScript

Anmärkning

JavaScript stöder för närvarande inte den här funktionen.

Python

Anmärkning

Python stöder för närvarande inte den här funktionen.

PowerShell

Anmärkning

PowerShell stöder för närvarande inte den här funktionen.

Java

Anmärkning

Den här funktionen stöds för närvarande inte i Java.

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

Det här exemplet visas endast för .NET och JavaScript.

PowerShell

Det här exemplet visas endast för .NET och JavaScript.

Java

Det här exemplet visas endast för .NET och JavaScript.

Rensa orkestreringsinstanshistorik

Om du vill ta bort alla data som är associerade med en orkestrering rensar du instanshistoriken. Ta till exempel bort alla lagringsresurser som är associerade med en slutförd instans. Använd den purge instance API som definierats av orkestreringsklienten.

I följande exempel visas hur du rensar en enda orkestreringsinstans.

C#

Isolerad arbetsmodell

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

Processmodell

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

Se Startinstanser för konfigurationen av 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

Anmärkning

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med hjälp av Durable Functions HTTP API.

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

I följande exempel visas en timerutlöst funktion som rensar bort historiken för alla orkestreringsinstanser som avslutades innan det angivna tidsintervallet. I det här fallet tar den bort data för alla instanser som slutfördes för 30 eller fler dagar sedan. Den här exempelfunktionen är schemalagd att köras en gång per dag kl. 12:00 UTC:

C#

Isolerad arbetsmodell

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

Processmodell

[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

Metoden purgeInstanceHistoryBy kan användas för att villkorligt rensa instanshistorik för flera instanser.

function.json

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

Anmärkning

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för 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

Anmärkning

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med hjälp av Durable Functions HTTP API.

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

Durable Task SDK är inte tillgängligt för PowerShell. Använd Durable Functions i stället.

Anmärkning

För att rensningshistoriken ska lyckas måste körningsstatusen för målinstansen vara Slutförd, Avslutad eller Misslyckad.

Nästa steg

Hantera versionshantering

Inbyggd HTTP API-referens för instanshantering

Kom igång med Durable Task SDK:er

Lär dig mer om Durable Task Scheduler