在 Azure 中的 Durable Functions 中管理實例

Durable Functions 中的協調流程是長時間執行的具狀態函式，可使用內建管理 API 啟動、查詢、暫停、繼續和終止。 Durable Functions 協調流程用戶端系結也會公開數個其他實例管理 API，例如將外部事件傳送至實例、清除實例歷程記錄等。本文將詳細說明所有支持的實例管理作業。

啟動執行個體

編排器用戶端綁定上的 start-new（或 schedule-new）方法會啟動新的編排實例。在內部，此方法會透過 Durable Functions 儲存提供者寫入訊息，然後傳回。此訊息會以非同步方式會觸發具有指定名稱的協調流程函式啟動。

啟動新編排流程實例的參數如下：

名稱：要排程的協調器函式名稱。
輸入：任何應作為輸入傳遞至調度函數的 JSON 可序列化數據。
InstanceId:(選擇性）實例的唯一標識碼。如果您未指定此參數，此方法會使用隨機識別碼。

小提示

盡可能使用隨機識別碼作為實例 ID。隨機實例標識碼可協助您在跨多個 VM 調整協調器函式時，確保負載分佈相等。當標識碼必須來自外部來源，或當您實作單一協調器模式時，就是使用非隨機實例識別碼的適當時機。

下列程式代碼是啟動新協調流程實例的範例函式：

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

備註

先前的 C# 程式代碼適用於 Durable Functions 2.x。針對 Durable Functions 1.x，您必須使用 OrchestrationClient 屬性而非 DurableClient 屬性，而且必須使用 DurableOrchestrationClient 參數類型，而不是 IDurableOrchestrationClient。如需版本間差異的詳細資訊，請參閱 Durable Functions 版本一文。

除非另有指定，否則此頁面上的範例會以下列 function.json 使用 HTTP 觸發程序。

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
}

備註

此範例以 Durable Functions 2.x 版為目標。在 1.x 版中，使用 orchestrationClient 而非 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}.`);
};

除非另有指定，否則此頁面上的範例會以下列 function.json 使用 HTTP 觸發程序。

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
}

備註

此範例以 Durable Functions 2.x 版為目標。在 1.x 版中，使用 orchestrationClient 而非 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}.")

除非另有指定，否則此頁面上的範例會以下列 function.json 使用 HTTP 觸發程序。

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
}

備註

此範例以 Durable Functions 2.x 版為目標。在 1.x 版中，使用 orchestrationClient 而非 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);
}

如果您想要等候協調器啟動後再從函式傳回，也可以使用 waitForInstanceStart() 方法。

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

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 func durable start-new Core Tools 中的命令直接啟動實體，其採用下列參數：

function-name （必要）：要啟動的函式名稱。
input （選擇性）：內嵌或透過 JSON 檔案輸入函式。針對檔案，將 @ 作為前綴新增至檔案路徑，例如 @path/to/file.json。
id （選擇性）：編排作業實例的標識符。如果您未指定此參數，命令會使用隨機 GUID。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。默認值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName 在 host.json 中設定此設定。

備註

Core Tools 命令假設您是從函式應用程式的根目錄執行它們。如果您明確提供 connection-string-setting 和 task-hub-name 參數，您可以從任何目錄執行命令。雖然您可以在未執行函式應用程式主機的情況下執行這些命令，但您可能會發現，除非主機正在執行，否則無法觀察某些效果。例如， start-new 命令會將開始訊息加入目標任務中樞，但編排程序實際上不會執行，除非有可處理該訊息的函式應用程式主機程序才會執行。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

下列命令會啟動名為 HelloWorld 的函式，並將檔案 counter-data.json 的內容傳遞給它：

func durable start-new --function-name HelloWorld --input @counter-data.json --task-hub-name TestTaskHub

查詢執行個體

啟動新的協調流程實例之後，您最可能需要查詢其運行時間狀態，以瞭解其執行中、已完成或失敗。

協調流程用戶端系結上的 get-status 方法會查詢協調流程實例的狀態。

它接受 instanceId （必要）、（選擇性）、 showHistoryshowHistoryOutput （選擇性）和 showInput （選擇性）作為參數。

showHistory：如果設定為 true，回應會包含執行歷程記錄。
showHistoryOutput：如果設定為 true，則執行歷程記錄會包含活動輸出。
showInput：如果設定為 false，回應將不會包含函式的輸入。預設值是 true。

方法會傳回具有下列屬性的物件：

名稱：協調器函式的名稱。
InstanceId：協調流程的實例標識碼（應該與 instanceId 輸入相同）。
CreatedTime：協調器函式開始執行的時間。
LastUpdatedTime：協調流程前次執行檢查點檢查的時間。
輸入：函式的輸入做為 JSON 值。如果 showInput 為 false，則不會填入此欄位。
CustomStatus：JSON 格式的自定義協調流程狀態。
輸出：函式的輸出做為 JSON 值（如果函式已完成）。如果協調器函式失敗，這個屬性會包含失敗詳細數據。如果協調器函式已暫停或終止，這個屬性會包含暫停或終止的原因（如果有的話）。
RuntimeStatus：下列其中一個值：
- 待處理：實例已排程，但尚未開始執行。
- 執行中：實例已開始執行。
- 已完成：實例已正常完成。
- ContinuedAsNew：執行個體本身以新的記錄重新啟動。此狀態是暫時性狀態。
- 失敗：實例失敗，發生錯誤。
- 終止：實例突然停止。
- 已暫停：實例已暫停，且可能在稍後的時間點繼續。
歷程記錄：協調流程的執行記錄。當showHistory設為true時，才會填入此欄位。

備註

在協調器的所有排程工作都完成「且」傳回之前，協調器不會標示為 Completed。換句話說，協調器觸達其 return 陳述式並不足以將其標示為 Completed。這與使用 WhenAny 的情況尤其相關；這些協調器經常在所有排程的工作執行之前 return。

如果實例不存在，這個方法會傳 null 回（.NET 和 Java）、 undefined （JavaScript）或 None （Python）。

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

請參閱啟動實例 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)

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

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 func durable get-runtime-status Core Tools 中的命令，直接取得協調流程實例的狀態。

備註

目前只有在使用預設 Azure 記憶體提供者來保存運行時間狀態時，才支援核心工具命令。

durable get-runtime-status 命令採用下列參數：

id （必要）：編排實例的識別碼。
show-input （選擇性）：如果設定為 true，回應會包含函式的輸入。預設值是 false。
show-output （選擇性）：如果設定為 true，回應會包含函式的輸出。預設值是 false。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName，在 host.json中設定它。

下列命令會擷取具有協調流程實例標識碼為 0ab8c55a66644d68a3a8b220b12d209c 之實例的狀態（包括輸入和輸出）。它假設您從函式應用程式的根目錄執行 func 命令：

func durable get-runtime-status --id 0ab8c55a66644d68a3a8b220b12d209c --show-input true --show-output true

您可以使用 durable get-history 命令來擷取協調流程實例的歷程記錄。它採用下列參數：

id （必要）：調度實例的標識符。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。也可以使用 durableTask:HubName 將其設定在 host.json中。

func durable get-history --id 0ab8c55a66644d68a3a8b220b12d209c

查詢所有實例

您可以使用語言 SDK 中的 API 來查詢工作中樞內所有協調流程實例的狀態。這個 “list-instances” 或 “get-status” API 會傳回代表符合查詢參數之協調流程實例的物件清單。

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

請參閱 function.json 組態的啟動實例。

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

請參閱啟動實例以了解 function.json 組態。

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

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 func durable get-instances Core Tools 中的命令，直接查詢實例。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

durable get-instances 命令採用下列參數：

top （選擇性）：此命令支援分頁。此參數對應於每個要求擷取的實例數目。預設值為 10。
continuation-token （選擇性）：標記，指出要擷取的實例頁面或區段。每個 get-instances 執行都會將令牌傳回至下一組實例。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName，在 host.json中設定它。

func durable get-instances

使用篩選查詢實例

如果您真的不需要標準實例查詢可以提供的所有資訊，該怎麼辦？例如，如果您只想尋找協調流程建立時間，或協調流程運行時間狀態，該怎麼辦？您可以套用篩選來縮小查詢範圍。

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

如需了解 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.";
}

Azure Functions Core Tools (Azure 函式核心工具)

在 Azure Functions Core Tools 中，您也可以使用 durable get-instances 命令搭配篩選。除了上述 top、 continuation-token、 connection-string-setting和 task-hub-name 參數之外，您還可以使用三個篩選參數（created-after、 created-before和 runtime-status）。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

以下是命令的參數 durable get-instances 。

created-after （選擇性）：擷取在此日期/時間（UTC）之後建立的實例。接受 ISO 8601 格式化的日期時間。
created-before （選擇性）：擷取在此日期/時間之前建立的實例（UTC）。接受符合 ISO 8601 標準的日期和時間格式。
runtime-status （選擇性）：擷取具有特定狀態的實例（例如執行中或已完成）。可以提供多個（空格分隔）狀態。
top （選擇性）：每個要求擷取的實例數目。預設值為 10。
continuation-token （選擇性）：標記，指出要擷取的實例頁面或區段。每個 get-instances 執行都會將令牌傳回至下一組實例。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName，在 host.json中設定它。

如果您未提供任何篩選條件（created-after、 created-before或 runtime-status），則命令只會擷取 top 實例，而不論運行時間狀態或建立時間為何。

func durable get-instances --created-after 2021-03-10T13:57:31Z --created-before  2021-03-10T23:59Z --top 15

終止執行個體

如果您有耗時太久才執行的協調流程執行個體，或者只是需要在執行個體完成之前停止執行 (不論原因)，您可以終止執行個體。

終止 API 的兩個參數是 實例識別碼 和原因字串，會寫入記錄和實例狀態。

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

請參閱啟動實例以了解 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);
}

終止的實例最終會轉換成 Terminated 狀態。不過，此轉換不會立即發生。實際上，終止作業會與該執行個體的其他作業一起排入工作中樞佇列。您可以使用實例查詢 API 來知道終止的實例是否已實際到達 Terminated 狀態。

備註

執行個體終止目前不會散佈。無論您是否已終止呼叫活動函式和子協調流程的協調流程執行個體，這些活動函式和子協調流程皆會執行到完成為止。

暫止和繼續執行個體

暫止協調流程可讓您停止執行中的協調流程。不同於終止，您可以選擇在之後的時間點繼續暫止的協調器。

暫停 API 的兩個參數是實例識別碼和原因字串，這些字串會寫入記錄和實例狀態。

[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

備註

此功能僅適用於獨立 Durable Functions PowerShell SDK 。請參閱獨立 SDK 與舊版內建 SDK 之間的差異，以及移轉指南。

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

暫停的實例最終會轉換為 Suspended 狀態。不過，此轉換不會立即發生。實際上，暫止作業會與該執行個體的其他作業一起排入工作中樞佇列。您可以使用實例查詢 API，知道執行中的實例實際上已達到暫止狀態。

當暫停的協調器恢復運行時，其狀態會恢復為 Running。

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 func durable terminate Core Tools 中的命令，直接終止協調流程實例。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

durable terminate 命令採用下列參數：

id （必要）：要終止之編排流程實例的識別碼。
reason （選擇性）：終止的原因。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName，在 host.json中設定它。

下列命令會終止標識碼為 0ab8c55a66644d68a3a8b220b12d209c 的協調流程實例：

func durable terminate --id 0ab8c55a66644d68a3a8b220b12d209c --reason "Found a bug"

將事件傳送至虛擬機實例

在某些情況下，協調器函式必須等候並接聽外部事件。這非常有用的範例案例包括監視和人為互動案例。

您可以使用協調流程用戶端的引發事件 API，將事件通知傳送至執行中的實例。協調流程可以使用 等候外部事件 協調器 API 來接聽和回應這些事件。

raise 事件的參數如下所示：

實例標識碼：實例的唯一標識符。
事件名稱：要傳送的事件名稱。
事件數據：要傳送至實例的 JSON 可串行化承載。

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

請參閱啟動實例以獲取 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);
}

備註

如果沒有具有指定實例標識碼的協調流程實例，則會捨棄事件訊息。如果實例存在，但尚未等候事件，則事件會儲存在實例狀態中，直到它準備好接收並處理為止。

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 Core Tools 中的 func durable raise-event 命令，直接引發事件到協調流程執行個體。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

durable raise-event 命令採用下列參數：

id （必要）：編排實例的識別碼。
event-name：要引發的事件名稱。
event-data （選擇性）：要傳送至協調流程實例的數據。這可以是 JSON 檔案的路徑，也可以直接在命令行上提供數據。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設值為 DurableFunctionsHub。您也可以使用 durableTask：HubName，在 host.json中設定它。

func durable raise-event --id 0ab8c55a66644d68a3a8b220b12d209c --event-name MyEvent --event-data @eventdata.json

func durable raise-event --id 1234567 --event-name MyOtherEvent --event-data 3

等候協調流程完成

在長時間執行的協調流程中，您可能需要等候以取得協調流程的結果。在這些情況下，能夠在協調流程上定義逾時期間也是相當有用的。如果超時，應該傳回編排作業的狀態，而不是結果。

「等候完成或建立檢查狀態回應」API 可用來同步取得協調流程實例的實際輸出。根據預設，此方法的預設逾時為10秒，輪詢間隔為1秒。

以下是示範如何使用此 API 的 HTTP 觸發程式函式範例：

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

請參閱啟動實例以獲取 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 目前在此案例中沒有單一方法。不過，您可以使用幾行額外的程式代碼來實作。

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

呼叫該函數，使用以下這一行。針對逾時使用 2 秒，針對重試間隔使用 0.5 秒：

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

備註

上述 cURL 命令假設您在專案中有名為 E1_HelloSequence 的協調器函式。由於 HTTP 觸發程式函式的撰寫方式，因此您可以將它取代為專案中任何協調器函式的名稱。

取決於從協調流程執行個體取得回應所需的時間，會有兩種情況：

協調流程實例會在定義的逾時內完成（在此案例中為 2 秒），而響應是實際的協調流程實例輸出，會以同步方式傳遞：

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

協調實例無法在定義的逾時內完成，而回應是 HTTP API URL 探索中所述的預設回應：

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

備註

Webhook URL 的格式可能會有所不同，視您執行的 Azure Functions 主機版本而定。上述範例適用於 Azure Functions 3.0 主機。

擷取 HTTP 管理 Webhook URL

您可以使用外部系統來監視或引發事件至協調流程。外部系統可以透過 Webhook URL 與 Durable Functions 通訊，這些 URL 是 HTTP API URL 探索中所述預設回應的一部分。您也可以使用協調流程用戶端繫結，以程式設計的方式存取 Webhook URL。具體而言， 建立 HTTP 管理承載 API 可用來取得包含這些 Webhook URL 的可串行化物件。

建立 HTTP 管理承載 API 有一個參數：

實例標識碼：實例的唯一標識符。

方法會傳回具有下列字串屬性的物件：

標識碼：協調流程的實例標識碼（應與 InstanceId 輸入相同）。
StatusQueryGetUri：協調流程實例的狀態 URL。
SendEventPostUri：協調流程實例的「引發事件」URL。
TerminatePostUri：協調流程執行個體的「終止」URL。
PurgeHistoryDeleteUri：協調流程實例的「清除歷程記錄」URL。
suspendPostUri：協調流程執行個體的「暫止」URL。
resumePostUri：協調流程實例的「繼續」URL。

函式可以將這些物件的實例傳送至外部系統，以監視或引發對應協調流程上的事件，如下列範例所示：

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

備註

先前的 C# 程式代碼適用於 Durable Functions 2.x。針對 Durable Functions 1.x，您必須使用 DurableActivityContext 而非 IDurableActivityContext，必須使用 OrchestrationClient 屬性而非 DurableClient 屬性，而且必須使用 DurableOrchestrationClient 參數類型，而不是 IDurableOrchestrationClient。如需版本間差異的詳細資訊，請參閱 Durable Functions 版本一文。

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

請參閱啟動實例以獲取 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

倒轉實例（預覽）

如果您有因非預期原因而發生協調流程失敗，您可以使用針對該目的建置的 API ，將實例倒轉 為先前狀況良好的狀態。

備註

此 API 不適合取代適當的錯誤處理和重試原則。相反地，它只是要用於協調流程執行個體因非預期原因而失敗的情況。處於 Failed 以外之狀態 (例如 Running、Pending、Terminated、Completed) 的協調流程無法「倒轉」。如需錯誤處理和重試原則的詳細資訊，請參閱錯誤處理一文。

使用協調流程用戶端繫結的 RewindAsync (.NET) 或 rewind(JavaScript) 方法，將協調流程倒轉回到「執行中」狀態。此方法也會重新執行造成協調流程失敗的活動或子協調流程執行失敗。

例如，假設您有一個涉及一系列人工核准的工作流程。假設有一系列活動功能會通知某人其核准是必要的，並等候即時回應。在所有核准活動都收到回應或逾時之後，假設另一個活動因為應用程式設定錯誤而失敗，例如無效的資料庫連接字串。結果是工作流程深層的編排故障。 RewindAsync 使用（.NET）或 rewind （JavaScript） API，應用程式管理員可以修正設定錯誤，並在失敗前立即將失敗的協調流程倒回狀態。不需要重新核准人工互動步驟，協調流程現在可以順利完成。

備註

「倒轉」功能不支援使用耐久計時器來倒轉協調流程執行個體。

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

請參閱啟動實例 function.json 組態。

Azure Functions Core Tools (Azure 函式核心工具)

您也可以使用 Core Tools 中的 func durable rewind 命令，直接倒轉協調流程執行個體。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

durable rewind 命令採用下列參數：

id （必要）：調度實例的標識符。
reason （選擇性）：回溯編排實例的原因。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。預設情況下，會使用 host.json 檔案中的工作中樞名稱。

func durable rewind --id 0ab8c55a66644d68a3a8b220b12d209c --reason "Orchestrator failed and needs to be revived."

清除實例歷程記錄

若要移除與協調流程相關聯的所有數據，您可以清除實例歷程記錄。例如，您可能想要刪除與已完成實例相關聯的任何記憶體資源。若要這樣做，請使用協調流程用戶端所定義的清除實例 API。

第一個範例示範如何清除單一協調流程實例。

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

請參閱啟動實例 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();
    }
}

下一個範例顯示定時器觸發的函式，會清除指定時間間隔之後完成之所有協調流程實例的歷程記錄。在此情況下，它會移除 30 天前完成的所有實例數據。此範例函式排定每天執行一次，UTC 下午 12：00：

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

備註

purgeInstanceHistoryBy方法可用來有條件地清除多個實例的實例歷程記錄。

function.json

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

備註

此範例以 Durable Functions 2.x 版為目標。在 1.x 版中，使用 orchestrationClient 而非 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()));
}

備註

若要讓清除記錄作業成功，目標實例的運行時間狀態必須為 [已完成]、[終止] 或 [失敗]。

Azure Functions Core Tools (Azure 函式核心工具)

您可以使用 Core Tools 中的命令來清除協調流程實例的歷程記錄func durable purge-history。類似於上一節中的第二個 C# 範例，它會清除指定時間間隔期間所建立之所有協調流程實例的歷程記錄。您可以依運行時間狀態進一步篩選已清除的實例。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

此指令 durable purge-history 有數個參數：

created-after （選擇性）：清除在此日期/時間（UTC）之後所建立實例的歷程記錄。接受符合 ISO 8601 標準的日期和時間格式。
created-before （選擇性）：清除在此日期/時間（UTC）之前建立的實例歷程記錄。接受符合 ISO 8601 標準的日期和時間格式。
runtime-status （選擇性）：清除具有特定狀態的實例歷程記錄（例如執行中或已完成）。可以提供多個（空格分隔）狀態。
connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。根據預設，會使用 host.json 檔案中的工作中樞名稱。

下列命令會刪除在 2021 年 11 月 14 日下午 7：35 （UTC）之前建立之所有失敗實例的歷程記錄。

func durable purge-history --created-before 2021-11-14T19:35:00.0000000Z --runtime-status failed

刪除工作中樞

使用 Core Tools 中的func durable delete-task-hub命令，您可以刪除與特定工作中樞相關聯的所有儲存項目，包括 Azure 儲存表、佇列和 Blob。

備註

使用預設的 Azure 記憶體提供者來保存運行時間狀態時，目前僅支援 Core Tools 命令。

此指令 durable delete-task-hub 有兩個參數：

connection-string-setting （選擇性）：包含要使用的記憶體連接字串的應用程式設定名稱。預設值為 AzureWebJobsStorage。
task-hub-name （選擇性）：要使用的 Durable Functions 工作中樞名稱。根據預設，會使用host.json檔案中的工作中樞名稱。

下列命令會刪除與工作中 UserTest 樞相關聯的所有 Azure 記憶體數據。

func durable delete-task-hub --task-hub-name UserTest

後續步驟

瞭解如何處理版本控制

實例管理的內建 HTTP API 參考

意見反應

此頁面對您有幫助嗎？

Last updated on 2025-07-21

共用方式為

在 Azure 中的 Durable Functions 中管理實例

啟動執行個體

Azure Functions Core Tools (Azure 函式核心工具)

查詢執行個體

Azure Functions Core Tools (Azure 函式核心工具)

查詢所有實例

Azure Functions Core Tools (Azure 函式核心工具)

使用篩選查詢實例

Azure Functions Core Tools (Azure 函式核心工具)

終止執行個體

暫止和繼續執行個體

Azure Functions Core Tools (Azure 函式核心工具)

將事件傳送至虛擬機實例

Azure Functions Core Tools (Azure 函式核心工具)

等候協調流程完成

擷取 HTTP 管理 Webhook URL

倒轉實例 （預覽）

Azure Functions Core Tools (Azure 函式核心工具)

清除實例歷程記錄

Azure Functions Core Tools (Azure 函式核心工具)

刪除工作中樞

後續步驟

意見反應

其他資源

倒轉實例（預覽）