Управление экземплярами в Durable Functions в Azure

2025-06-28

Оркестрации в долговременных функциях — это длительные функции с отслеживанием состояния, которые можно запускать, запрашивать, приостанавливать, возобновлять и завершать с помощью встроенных API управления. Несколько других API управления экземплярами также предоставляются в привязке клиента оркестрации для устойчивых функций, таких как отправка внешних событий в экземпляры, удаление данных журнала экземпляров и т. д. Эта статья содержит подробно описания всех поддерживаемых операций управления экземплярами.

Запуск виртуальных экземпляров

Метод start-new (или schedule-new) в клиентской привязке оркестратора запускает новый экземпляр оркестрации. Внутри этого метода записывается сообщение через поставщика хранилища устойчивых функций , а затем возвращается. Это сообщение асинхронно активирует начало функции оркестрации с указанным именем.

Параметры запуска нового экземпляра оркестрации приведены следующим образом:

Имя: имя функции оркестратора для планирования.
Входные данные: все данные, сериализуемые в формате JSON, которые должны передаваться в качестве входных данных в функцию оркестратора.
InstanceId: (необязательно) Уникальный идентификатор экземпляра. Если этот параметр не указан, метод использует случайный идентификатор.

Подсказка

По возможности используйте случайный идентификатор для идентификатора экземпляра. Идентификаторы случайных экземпляров помогают обеспечить равномерное распределение нагрузки при масштабировании функций оркестратора на нескольких виртуальных машинах. Правильное время использования идентификаторов экземпляров, отличных от случайных, заключается в том, когда идентификатор должен поступать из внешнего источника или при реализации шаблона синглтон-оркестратора.

Следующий код является примером функции, которая запускает новый экземпляр оркестрации:

[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# предназначен для устойчивых функций 2.x. Для Durable Functions 1.x необходимо использовать атрибут OrchestrationClient вместо атрибута DurableClient, а тип параметра DurableOrchestrationClient вместо IDurableOrchestrationClient. Дополнительные сведения о различиях между версиями см. в статье о версиях устойчивых функций .

Если иное не указано, примеры на этой странице используют триггер HTTP со следующими 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
}

Замечание

Этот пример предназначен для 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}.`);
};

Если иное не указано, примеры на этой странице используют триггер HTTP со следующими 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
}

Замечание

Этот пример предназначен для 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}.")

Если иное не указано, примеры на этой странице используют триггер HTTP со следующими 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
}

Замечание

Этот пример предназначен для 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

Вы также можете запустить экземпляр непосредственно с помощью func durable start-new команды в Core Tools, которая принимает следующие параметры:

function-name (обязательно): имя функции для запуска.
input (необязательно): входные данные для функции, встроенные или через JSON-файл. Для файлов добавьте префикс в путь к файлу, @например @path/to/file.json.
id (необязательно): идентификатор инстанции оркестрации. Если этот параметр не указан, команда использует случайный GUID.
connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. По умолчанию используется AzureWebJobsStorage.
task-hub-name (необязательно): имя концентратора задач, используемого для устойчивых функций. Значение по умолчанию — DurableFunctionsHub. Вы также можете задать это в host.json с помощью параметра durableTask:HubName.

Замечание

Команды Core Tools предполагают, что они выполняются из корневого каталога приложения-функции. Если явно указать connection-string-setting и task-hub-name параметры, можно выполнить команды из любого каталога. Хотя эти команды можно выполнить без запуска узла приложения-функции, возможно, вы не сможете наблюдать некоторые последствия, если узел не запущен. Например, команда start-new помещает начальное сообщение в целевой узел задач, но оркестрация на самом деле не выполняется, если не запущен процесс хоста приложения-функции, обрабатывающего сообщение.

Замечание

Команды Core Tools в настоящее время поддерживаются только при использовании поставщика службы хранилища Azure по умолчанию для сохранения состояния среды выполнения.

Следующая команда запускает функцию с именем HelloWorld и передает содержимое файла counter-data.json в него:

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

Экземпляры запросов

После запуска новых экземпляров оркестрации вам, скорее всего, потребуется запросить состояние среды выполнения, чтобы узнать, выполняются ли они, завершены или завершились сбоем.

Метод get-status в привязке клиента оркестрации запрашивает состояние экземпляра оркестрации.

Он принимает instanceId (обязательно), showHistory (необязательно), showHistoryOutput (необязательно) и 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

Кроме того, можно получить состояние экземпляра оркестрации непосредственно с помощью func durable get-runtime-status команды в Core Tools.

Замечание

Команда durable get-runtime-status принимает следующие параметры.

id (обязательно): идентификатор инстанции оркестрации.
show-input (необязательно): если задано значение true, ответ содержит входные данные функции. Значение по умолчанию — false.
show-output (необязательно): если задано значение true, ответ содержит выходные данные функции. Значение по умолчанию — false.
connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. Значение по умолчанию — AzureWebJobsStorage.
task-hub-name (необязательно): имя концентрата задач устойчивых функций, которое будет использовано. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

Следующая команда получает состояние (включая входные и выходные данные) экземпляра с идентификатором экземпляра оркестрации 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 (необязательно): имя концентратора задач устойчивых функций для использования. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

func durable get-history --id 0ab8c55a66644d68a3a8b220b12d209c

Запросить все экземпляры

Вы можете использовать API в пакете SDK для вашего языка программирования, чтобы запрашивать состояния всех экземпляров оркестрации в центре задач. Этот API list-instances или get-status возвращает список объектов, представляющих экземпляры оркестрации, соответствующие параметрам запроса.

[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

Кроме того, можно напрямую запрашивать экземпляры с помощью func durable get-instances команды в Core Tools.

Замечание

Команда durable get-instances принимает следующие параметры.

top (необязательно): эта команда поддерживает разбиение по страницам. Этот параметр соответствует количеству экземпляров, полученных на запрос. Значение по умолчанию равно 10.
continuation-token (необязательно): маркер, указывающий, какая страница или раздел экземпляров требуется извлечь. Каждое get-instances выполнение возвращает токен в следующую группу экземпляров.
connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. Значение по умолчанию — AzureWebJobsStorage.
task-hub-name (необязательно): Имя концентратора задач Durable Functions для использования. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

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

В основных средствах функций Azure можно также использовать durable get-instances команду с фильтрами. Помимо указанных выше параметров top, continuation-token, connection-string-setting и task-hub-name, можно использовать три параметра фильтра (created-after, created-before и runtime-status).

Замечание

Ниже приведены параметры для 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 (необязательно): имя концентратора задач устойчивых функций для использования. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

Если вы не предоставляете фильтры (created-afterилиcreated-beforeruntime-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

Замечание

Эта функция доступна только в автономном пакете SDK PowerShell для устойчивых функций . Ознакомьтесь с разницей между автономным пакетом 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

Вы также можете завершить экземпляр оркестрации напрямую с помощью func durable terminate команды в Core Tools.

Замечание

Команда durable terminate принимает следующие параметры.

id (обязательно): идентификатор экземпляра оркестрации для завершения.
reason (необязательно): причина завершения.
connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. Значение по умолчанию — AzureWebJobsStorage.
task-hub-name (необязательно): имя концентратора задач Устойчивых Функций, который будет использоваться. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

Следующая команда завершает экземпляр оркестрации с идентификатором 0ab8c55a66644d68a3a8b220b12d209c.

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

Отправка событий в экземпляры

В некоторых сценариях функции оркестратора должны ожидать и прослушивать внешние события. Примеры сценариев, в которых это полезно, включают в себя сценарии мониторинга и взаимодействия с человеком .

Вы можете отправлять уведомления о событиях в запущенные экземпляры, используя API генерации событий клиента оркестрации. Оркестрации могут прослушивать и реагировать на эти события с помощью API оркестратора ожидания внешнего события.

Параметры инициации события приведены следующим образом:

Идентификатор экземпляра: уникальный идентификатор экземпляра.
Имя события: имя события для отправки.
Данные событий: полезные данные, сериализуемые в ФОРМАТЕ 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

Вы также можете напрямую поднять событие для экземпляра оркестрации с помощью func durable raise-event команды в Core Tools.

Замечание

Команда durable raise-event принимает следующие параметры.

id (обязательно): идентификатор экземпляра оркестрации.
event-name: имя вызываемого события.
event-data (необязательно): данные, которые нужно отправить в экземпляр оркестрации. Это может быть путь к JSON-файлу или предоставить данные непосредственно в командной строке.
connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. Значение по умолчанию — AzureWebJobsStorage.
task-hub-name (необязательно): имя концентратора задач Durable Functions используемого. Значение по умолчанию — DurableFunctionsHub. Его также можно задать в host.jsonс помощью durableTask:HubName.

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 секунды.

Ниже приведен пример функции HTTP-триггера, демонстрирующей использование этого API:

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

Экземпляры оркестрации не могут завершиться в течение определенного времени ожидания, и ответ по умолчанию описан в обнаружении URL-адресов API HTTP:

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

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

Замечание

Формат URL-адресов веб-перехватчика может отличаться в зависимости от используемой версии узла Функций Azure. Приведенный выше пример предназначен для узла Функций Azure 3.0.

Получение URL веб-хуков для управления HTTP

Вы можете использовать внешнюю систему для отслеживания или инициирования событий в оркестрации. Внешние системы могут взаимодействовать с Durable Functions через URL-адреса веб-перехватчика, которые являются частью ответа по умолчанию, описанного в обнаружении URL-адресов API HTTP. URL-адреса вебхуков также можно получить программно с помощью привязки клиента оркестрации. В частности, API создания полезной нагрузки управления HTTP можно использовать для получения сериализуемого объекта, содержащего эти URL-адреса веб-перехватчика.

В API для создания полезной нагрузки управления HTTP есть один параметр:

Идентификатор экземпляра: уникальный идентификатор экземпляра.

Методы возвращают объект со следующими строковыми свойствами:

Идентификатор: идентификатор экземпляра оркестрации (должен совпадать с входным значением 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# предназначен для устойчивых функций 2.x. Для Durable Functions 1.x необходимо использовать DurableActivityContext вместо IDurableActivityContext, использовать атрибут OrchestrationClient вместо DurableClient, и использовать тип параметра DurableOrchestrationClient вместо IDurableOrchestrationClient. Дополнительные сведения о различиях между версиями см. в статье о версиях устойчивых функций .

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 из привязки клиента оркестрации, чтобы вернуть оркестрацию в состояние Выполнения. Этот метод также повторно запустит ошибки выполнения деятельности или подоркестрации, которые вызвали сбой оркестрации.

Например, предположим, что у вас есть рабочий процесс, включающий ряд утверждений человека. Предположим, что есть ряд функций действий, которые уведомляют кого-то о необходимости утверждения и выжидают ответ в режиме реального времени. После того, как все действия утверждения получили ответы или истекло время ожидания, предположим, что одно из действий не удается завершить из-за неправильной конфигурации приложения, например ошибочной строки подключения к базе данных. Результатом является сбой оркестрации в глубине рабочего процесса. С помощью API (.NET) или JavaScript администратор приложения может исправить ошибку конфигурации и перемотать неудачную оркестрацию обратно в состояние непосредственно перед сбоем. Ни один из шагов взаимодействия с человеком не требуется повторно утвердить, и оркестрация теперь может успешно завершиться.

Замечание

Функция перемотка не поддерживает экземпляры оркестрации, использующие долговременные таймеры.

[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

Вы также можете перемотать экземпляр оркестрации напрямую, используя команду func durable rewind в 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 или более дней назад. В этом примере функция запланирована на выполнение один раз в день в 12:00 по времени UTC.

[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

Историю экземпляра оркестрации можно очистить с помощью func durable purge-history команды в Core Tools. Аналогично второму примеру C# в предыдущем разделе, он очищает историю всех экземпляров оркестрации, созданных в течение указанного интервала времени. Кроме того, можно отфильтровать удаленные экземпляры по состоянию среды выполнения.

Замечание

Команда 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 .

Следующая команда удаляет историю всех неудачных экземпляров, созданных не позднее 14 ноября 2021 г. в 19:35 (UTC).

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

Удаление концентратора задач

func durable delete-task-hub С помощью команды в Core Tools можно удалить все артефакты хранилища, связанные с определенным центром задач, включая таблицы хранилища Azure, очереди и большие двоичные объекты.

Замечание

Команда durable delete-task-hub имеет два параметра:

connection-string-setting (необязательно): имя параметра приложения, содержащего строку подключения к хранилищу для использования. Значение по умолчанию — AzureWebJobsStorage.
task-hub-name (необязательно): имя концентратора задач Durable Functions используемого. По умолчанию используется имя концентратора задач в файле host.json .

Следующая команда удаляет все данные хранилища Azure, связанные с UserTest центром задач.

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

Дальнейшие шаги

Узнайте, как обрабатывать управление версиями

Справочник по встроенному HTTP API для управления экземплярами

Поделиться через

Управление экземплярами в Durable Functions в Azure

Запуск виртуальных экземпляров

Основные инструменты Функций Azure

Экземпляры запросов

Основные инструменты Функций Azure

Запросить все экземпляры

Основные инструменты Функций Azure

Запрос экземпляров с фильтрами

Основные инструменты Функций Azure

Завершение экземпляров

Приостановка и возобновление экземпляров

Основные инструменты Функций Azure

Отправка событий в экземпляры

Основные инструменты Функций Azure

Дождитесь завершения оркестрации

Получение URL веб-хуков для управления HTTP

Перемотка инстансов (предварительный просмотр)

Основные инструменты Функций Azure

Очистить историю экземпляров

Основные инструменты Функций Azure

Удаление концентратора задач

Дальнейшие шаги

Обратная связь

Дополнительные ресурсы