Orkestrasyon örneklerini yönetme

Dayanıklı iş akışlarınızdaki düzenleme örneklerini başlatmak, sorgulamak, sonlandırmak, askıya almak, sürdürmek ve temizlemek için yerleşik örnek yönetimi API'lerini kullanın. Durable Functions'da orchestration istemci bağlaması bu API'leri kullanıma sunar. Dayanıklı Görev SDK'larında aynı işlemler sınıfı aracılığıyla DurableTaskClient kullanılabilir. Bu makalede, her iki platform için kod örnekleriyle her örnek yönetimi işleminin nasıl gerçekleştirebileceğiniz gösterilmektedir.

Tip

Azure Dayanıklı Görev Zamanlayıcı hem Durable Functions hem de Dayanıklı Görev SDK'ları için önerilen arka uç olup dayanıklı iş akışlarını büyük ölçekte çalıştırmak için tam olarak yönetilen, sunucusuz bir deneyim sağlar.

Başlangıç örnekleri

Düzenleme istemcisinde start-new (veya schedule-new) yöntemi yeni bir düzenleme örneği başlatır. Dahili olarak, bu yöntem yapılandırılan arka uçtan (Dayanıklı Görev Zamanlayıcı veya Azure Storage gibi) bir ileti yazar ve sonra döndürür. Bu ileti, belirtilen adla bir düzenlemenin başlatılmasını zaman uyumsuz olarak tetikler.

Yeni bir düzenleme örneği başlatmaya yönelik parametreler şunlardır:

Ad: Planlanacak düzenleyici işlevin adı.
Giriş: Orchestrator işlevine giriş olarak geçirilmesi gereken JSON serileştirilebilir veriler.
InstanceId: (İsteğe bağlı) Örneğin benzersiz kimliği. Bu parametreyi belirtmezseniz, yöntem rastgele bir kimlik kullanır.

Tip

Mümkün olduğunda örnek kimliği için rastgele bir tanımlayıcı kullanın. Rastgele örnek kimlikleri, düzenleyici işlevlerini birden çok VM arasında ölçeklendirirken eşit yük dağılımı sağlamaya yardımcı olur. Rastgele olmayan örnek kimliklerini kullanmak için uygun zaman, kimliğin bir dış kaynaktan geldiği veya tekil düzenleyici desenini uyguladığınız zamandır.

Ad: Programlanması gereken orkestrasyonun adı.
Giriş: Düzenlemeye giriş olarak geçirilmesi gereken JSON serileştirilebilir veriler.
InstanceId: (İsteğe bağlı) Örneğin benzersiz kimliği. Bu parametreyi belirtmezseniz, yöntem rastgele bir kimlik kullanır.

Tip

Mümkün olduğunda örnek kimliği için rastgele bir tanımlayıcı kullanın. Rastgele örnek kimlikleri, düzenlemeleri birden çok VM arasında ölçeklendirirken eşit yük dağılımı sağlamaya yardımcı olur. Rastgele olmayan örnek kimliklerini kullanmak için uygun zaman, kimliğin bir dış kaynaktan geldiği veya tekil düzenleyici desenini uyguladığınız zamandır.

Aşağıdaki örnek işlev yeni bir düzenleme örneği başlatır:

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

Uyarı

Önceki C# kodu, yeni sürümlerde kullanımdan kaldırılan IDurableOrchestrationClient in-process modeli kullanmaktadır ki bu, Durable Functions eklentisinin daha yeni sürümlerinde eski olarak işaretlenmiştir. Yeni .NET projeleri için ile DurableTaskClient kullanmayı göz önünde bulundurun. Daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

Aksi belirtilmediği sürece, bu sayfadaki örneklerde HTTP tetikleyicisi aşağıdaki function.jsonile birlikte kullanılır.

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
}

Uyarı

Bu örnek Dayanıklı İşlevler sürüm 2.x'i hedefler. Sürüm 1.x'te orchestrationClient yerine durableClient kullanın.

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

Aksi belirtilmediği sürece, bu sayfadaki örneklerde HTTP tetikleyicisi aşağıdaki function.jsonile birlikte kullanılır.

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
}

Uyarı

Bu örnek Dayanıklı İşlevler sürüm 2.x'i hedefler. Sürüm 1.x'te orchestrationClient yerine durableClient kullanın.

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

Aksi belirtilmediği sürece, bu sayfadaki örneklerde HTTP tetikleyicisi aşağıdaki function.jsonile birlikte kullanılır.

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
}

Uyarı

Bu örnek Dayanıklı İşlevler sürüm 2.x'i hedefler. Sürüm 1.x'te orchestrationClient yerine durableClient kullanın.

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

Orkestratörün işlevinizden dönmeden önce başlamasını beklemek için waitForInstanceStart() yöntemini kullanın.

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

Önemli

Şu anda PowerShell Dayanıklı Görev SDK'sı kullanılamıyor.

Aşağıdaki kod, Dayanıklı Görev SDK'larını kullanarak yeni bir düzenleme örneğinin nasıl başlatıldığını gösterir:

using Microsoft.DurableTask.Client;

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

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

Sorgu örnekleri

Yeni düzenleme örneklerini başlattıktan sonra büyük olasılıkla çalışma zamanı durumlarını sorgulayarak bunların çalışıp çalışmadığını, tamamlanıp tamamlanmadığını veya başarısız olduğunu öğrenmeniz gerekir.

Düzenleme istemcisinde get-status yöntemi bir düzenleme örneğinin durumunu döndürür.

Parametre olarak bir instanceId (gerekli), showHistory (isteğe bağlı), showHistoryOutput (isteğe bağlı) ve showInput (isteğe bağlı) alır.

showHistory: olarak trueayarlanırsa, yanıt yürütme geçmişini içerir.
showHistoryOutput: olarak trueayarlanırsa, yürütme geçmişi etkinlik çıkışlarını içerir.
showInput: olarak falseayarlanırsa, yanıt işlevin girişini içermez. Varsayılan değer true değeridir.

yöntemi aşağıdaki özelliklere sahip bir nesne döndürür:

İsim: Orchestrator fonksiyonunun adı.
InstanceId: Koordine işleminin örnek ID'si (girişle instanceId aynı olmalıdır).
CreatedTime: Orchestrator işlevinin çalışmaya başladığı saat.
LastUpdatedTime: Düzenlemenin son denetim noktalarının bulunduğu saat.
Giriş: İşlevin JSON değeri olarak girişi. Eğer showInputfalse ise, bu alan doldurulmaz.
CustomStatus: JSON biçiminde özel düzenleme durumu.
Çıkış: İşlevin JSON değeri olarak çıkışı (işlev tamamlanırsa). Orchestrator işlevi başarısız olursa, bu özellik hata ayrıntılarını içerir. Orchestrator işlevi askıya alınırsa veya sonlandırılırsa, bu özellik askıya alma veya sonlandırma nedenini (varsa) içerir.
RuntimeStatus: Aşağıdaki değerlerden biri:
- Beklemede: Örnek zamanlanmış ancak henüz çalışmaya başlamamış.
- Çalışıyor: Örnek çalışıyor.
- Tamamlandı: Örnek normal şekilde tamamlandı.
- ContinuedAsNew: Örnek yeni bir geçmişle yeniden başlatıldı. Bu durum geçici bir durumdur.
- Başarısız: Örnek bir hatayla başarısız oldu.
- Sonlandırıldı: Örnek aniden durdu.
- Askıya alındı: Örnek durduruldu ve daha sonra devam edilebilir.
Geçmiş: Orkestrasyonun yürütme geçmişi. Bu alan yalnızca showHistorytrue olarak ayarlandıysa doldurulur.

showHistory: olarak trueayarlanırsa, yanıt yürütme geçmişini içerir.
showHistoryOutput: olarak trueayarlanırsa, yürütme geçmişi etkinlik çıkışlarını içerir.
showInput: false olarak ayarlandığında, yanıt orchestrasyonun girişini içermez. Varsayılan değer true değeridir.

yöntemi aşağıdaki özelliklere sahip bir nesne döndürür:

Ad: Orkestrasyonun adı.
InstanceId: Koordine işleminin örnek ID'si (girişle instanceId aynı olmalıdır).
CreatedTime: Orkestrasyonun çalışmaya başladığı zaman.
LastUpdatedTime: Düzenlemenin son denetim noktalarının bulunduğu saat.
Giriş: Orkestrasyonun girdisi bir JSON değeri olarak. Eğer showInputfalse ise, bu alan doldurulmaz.
CustomStatus: JSON biçiminde özel düzenleme durumu.
Çıkış: Düzenlemenin JSON değeri olarak çıkışı (düzenleme tamamlanırsa). Düzenleme başarısız olursa, bu özellik hata ayrıntılarını içerir. Orkestrasyon askıya alınmışsa veya sonlandırılmışsa, bu özellik askıya alma veya sonlandırma nedenini (mevcutsa) içerir.
RuntimeStatus: Aşağıdaki değerlerden biri:
- Beklemede: Örnek zamanlanmış ancak henüz çalışmaya başlamamış.
- Çalışıyor: Örnek çalışıyor.
- Tamamlandı: Örnek normal şekilde tamamlandı.
- ContinuedAsNew: Örnek yeni bir geçmişle yeniden başlatıldı. Bu durum geçici bir durumdur.
- Başarısız: Örnek bir hatayla başarısız oldu.
- Sonlandırıldı: Örnek aniden durdu.
- Askıya alındı: Örnek durduruldu ve daha sonra devam edilebilir.
Geçmiş: Orkestrasyonun yürütme geçmişi. Bu alan yalnızca showHistorytrue olarak ayarlandıysa doldurulur.

Uyarı

Zamanlanmış tüm görevleri bitene Completed düzenleyici dönene kadar düzenleyici olarak işaretlenmez. Başka bir deyişle, bir düzenleyicinin return olarak işaretlenmesi için Completed ifadesine ulaşması yeterli değildir. Bu, özellikle WhenAny'ün kullanıldığı durumlar için geçerlidir; bu düzenleyiciler genellikle zamanlanan tüm görevler yürütülmeden önce return çalışır.

Bu yöntem null (.NET ve Java), undefined (JavaScript) veya örnek yoksa None (Python) döndürür.

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma.

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

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

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

param($Request, $TriggerMetadata)

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

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

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

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

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

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

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

const client = createAzureManagedClient(connectionString);

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

Tüm düzenleme örneklerini sorgulama

Görev hub'ınızdaki tüm düzenleme örneklerinin durumlarını sorgulamak için dil SDK'nızdaki API'leri kullanabilirsiniz. Bu "list-instances" veya "get-status" API'si, sorgu parametreleriyle eşleşen düzenleme örneklerini temsil eden nesnelerin listesini döndürür.

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma.

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 yapılandırması için bkz. Örnekleri başlatma.

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

using Microsoft.DurableTask.Client;

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

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

for instance in instances:
    print(instance.instance_id)

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

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

Filtrelerle sorgu düzenleme örnekleri

Standart örnek sorgusunun sağladığı tüm bilgilere ihtiyacınız yoksa ne olur? Örneğin, yalnızca düzenleme oluşturma zamanını veya düzenleme çalışma zamanı durumunu arıyorsanız ne olur? Filtre uygulayarak sorgunuzu daraltma.

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

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma .

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

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

    runtime_status = [OrchestrationRuntimeStatus.Completed, OrchestrationRuntimeStatus.Running]

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

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

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

using Microsoft.DurableTask.Client;

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

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

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

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

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

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

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

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

OrchestrationStatusQueryResult result = client.queryInstances(filter);

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

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

const client = createAzureManagedClient(connectionString);

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

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

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

Orkestrasyon örneklerini sonlandırma

Çalışması çok uzun süren bir düzenleme örneğiniz varsa veya herhangi bir nedenle tamamlanmadan önce durdurmanız gerekiyorsa, sonlandırabilirsiniz.

Sonlandırma API'si için iki parametre, günlüklere ve örnek durumuna yazan bir örnek kimliği ve neden dizesidir.

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma .

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

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

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

param($Request, $TriggerMetadata)

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

Stop-DurableOrchestration -InstanceId $InstanceId -Reason $Reason

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

const client = createAzureManagedClient(connectionString);

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

Sonlandırılan bir örnek sonunda Terminated durumuna geçer. Ancak bu geçiş hemen gerçekleşmez. Bunun yerine, sonlandırma işlemi görev hub'ında bu örnek için diğer işlemlerle birlikte kuyruğa alınır. Sonlandırılan bir örneğin gerçekten "sonlandırılmış" durumuna ne zaman ulaştığını öğrenmek için örnek sorgu API'lerini Terminated kullanabilirsiniz.

Uyarı

Örnek sonlandırma halen yayılmaz. Etkinlik işlevleri ve alt orkestrasyonlar, bunları çağıran düzenleme örneğini sonlandırmanıza bakılmaksızın tamamlanana kadar çalışır.

Oryestrasyon örneklerini askıya almak ve devam ettirmek

Düzenlemeyi askıya almak, çalışan bir düzenlemeyi durdurmanıza olanak tanır. Orkestrasyonu sonlandırmanın aksine, askıya alınmış bir orkestratörü daha sonra sürdürebilirsiniz.

Askıya alma API'si için iki parametre, örnek ID'si ve neden dizesidir; bunlar günlüklere ve örnek durumuna yazılır.

[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

Uyarı

Bu özellik yalnızca tek başına Dayanıklı İşlevler PowerShell SDK'sında kullanılabilir. Geçiş kılavuzuyla birlikte tek başına SDK ile eski yerleşik SDK arasındaki farka bakın.

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

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

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

using Microsoft.DurableTask.Client;

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

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

Askıya alınan bir örnek sonunda Suspended durumuna geçer. Ancak bu geçiş hemen gerçekleşmez. Bunun yerine, askıya alma işlemi, bu örneğe ait diğer işlemlerle birlikte görev hub'ında kuyruğa alınır. Bir çalışan örneğin gerçekten Suspended durumuna ne zaman ulaştığını öğrenmek için örnek API sorgularını kullanın.

Askıya alınan bir orkestratör devam ettirildiğinde, durumu Running olarak geri döner.

Olayları örneklere gönderme

Bazı senaryolarda düzenleyici işlevlerinin beklemesi ve dış olayları dinlemesi gerekir. Bu yaklaşımın yararlı olduğu örnekler arasında izleme ve insan etkileşimi senaryoları yer alır.

Bazı senaryolarda, düzenlemelerin beklemesi ve dış olayları dinlemesi gerekir. Bu yaklaşımın yararlı olduğu örnekler arasında izleme ve insan etkileşimi senaryoları yer alır.

Orchestration istemcisinin raise event API'sini kullanarak çalışan örneklere olay bildirimleri gönderebilirsiniz. Orkestrasyonlar, dış olay bekleme düzenleyici API'sini kullanarak bu olayları dinleyebilir ve yanıtlayabilir.

Raise olayının parametreleri şunlardır:

Örnek Kimliği: Örneğin benzersiz kimliği.
Olay adı: Gönderilecek olayın adı.
Olay verileri: Örneğe gönderilecek JSON ile serileştirilebilen yük.

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma .

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

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

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

param($Request, $TriggerMetadata)

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

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

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

import com.microsoft.durabletask.DurableTaskClient;

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

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

const client = createAzureManagedClient(connectionString);

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

Uyarı

Belirtilen örnek kimliğine sahip bir orkestrasyon örneği yoksa, etkinlik mesajı atılır. Bir örnek varsa ancak henüz olayı beklemiyorsa, olay alınmaya ve işlenmeye hazır olana kadar örnek durumunda depolanır.

Düzenlemenin tamamlanmasını bekleyin

Uzun süre çalışan orkestrasyonlarda beklemek ve bir orkestrasyonun sonuçlarını almak isteyebilirsiniz. Bu gibi durumlarda, düzenlemede bir zaman aşımı süresi tanımlamak da yararlıdır. Zaman aşımı aşılırsa, sonuçlar yerine orkestrasyonun durumu döndürülür.

Orkestrasyon örneğinden gerçek çıktıyı senkron bir şekilde almak için "tamamlanmasını bekleyin veya durum kontrolü yanıtı oluşturun" API'sini kullanın. Varsayılan olarak, bu yöntem on saniyelik bir zaman aşımına ve bir saniyelik yoklama aralığına sahiptir.

Bu API'nin nasıl kullanılacağını gösteren örnek bir HTTP tetikleyici işlevi aşağıda verilmiştir:

// 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 yapılandırması için bkz. Örnekleri başlatma .

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 şu anda bu senaryo için tek bir yöntemi yoktur, ancak bunu birkaç ek kod satırıyla uygulayabilirsiniz.

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

Dayanıklı Görev SDK'ları, düzenlemenin zaman uyumlu bir şekilde bitmesini beklemek için bir yöntem sağlar.

using Microsoft.DurableTask.Client;

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

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

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

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

İşlevi aşağıdaki satırla çağırın. Zaman aşımı için iki saniye ve yeniden deneme aralığı için 0,5 saniye kullanın:

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

Uyarı

Yukarıdaki cURL komutu, projenizde adlı E1_HelloSequence bir orchestrator işlevine sahip olduğunuzu varsayar. HTTP tetikleyici işlevinin nasıl yazıldığından, bunu projenizdeki herhangi bir düzenleyici işlevinin adıyla değiştirebilirsiniz.

Düzenleme örneğinden yanıt almak için gereken süreye bağlı olarak iki durum vardır:

Düzenleme örnekleri tanımlanan zaman aşımı süresi içinde (bu örnekte iki saniye) tamamlanır ve yanıt, zaman uyumlu olarak teslim edilen gerçek düzenleme örneği çıkışıdır:

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

Düzenleme örnekleri tanımlanan zaman aşımı içinde tamamlanamıyor ve yanıt , HTTP API URL'si bulma bölümünde açıklanan varsayılan değerdir:

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

Uyarı

Web kancası URL'lerinin biçimi, çalıştırdığınız Azure Functions konağın sürümüne bağlı olarak farklılık gösterebilir. Yukarıdaki örnek, Azure İşlevleri 3.0 konağı içindir.

Orkestrasyon örnekleri için HTTP yönetim web kancası URL'lerini elde etme

Olayları izlemek veya bir orkestrasyona olayları yükseltmek için bir dış sistem kullanın. Dış sistemler, HTTP API URL bulma bölümünde açıklanan varsayılan yanıtın parçası olan web kancası URL'leri aracılığıyla Durable Functions ile iletişim kurar. Web kancası URL'leri, alternatif olarak orkestrasyon istemci bağlaması kullanılarak programatik olarak erişilebilir. Özellikle, create HTTP yönetim yükü API'si, bu webhook URL'lerini içeren serileştirilebilir bir nesne alır.

HTTP yönetimi yük oluşturma API'sinin bir parametresi vardır:

Örnek Kimliği: Örneğin benzersiz kimliği.

Yöntemler, aşağıdaki dize özelliklerine sahip bir nesne döndürür:

Kimlik: Orkestrasyonun örnek kimliği (girişle InstanceId aynı olmalıdır).
StatusQueryGetUri: Düzenleme örneğinin durum URL'si.
SendEventPostUri: Düzenleme örneğinin "etkinlik oluşturma" URL'si.
TerminatePostUri: Orkestrasyon örneğinin "terminate" URL'si.
PurgeHistoryDeleteUri: Orkestrasyon örneğinin "temizleme geçmişi" URL'si.
SuspendPostUri: Düzenleme örneğinin "askıya alma" URL'si.
ResumePostUri: Orkestrasyon örneğinin "devam et" URL'si.

İşlevler, aşağıdaki örneklerde gösterildiği gibi ilgili düzenlemelerde olayları izlemek veya tetiklamak için bu nesnelerin örneklerini dış sistemlere gönderir.

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

Uyarı

Önceki C# kodu, IDurableOrchestrationClient ve IDurableActivityContext ile işlem içi modeli kullanır ve bunlar, Dayanıklı İşlevler uzantısının daha yeni sürümlerinde eski olarak işaretlenmiştir. Yeni .NET projeleri için ile DurableTaskClient kullanmayı göz önünde bulundurun. Daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

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 yapılandırması için bkz. Örnekleri başlatma .

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

Orkestrasyon örneklerini geri alma

Beklenmeyen bir nedenle düzenleme hatanız varsa, bu amaçla oluşturulmuş bir API kullanarak örneği daha önce iyi durumda bir duruma geri sarabilirsiniz .

Uyarı

Bu API'nin düzgün hata işleme ve yeniden deneme ilkelerinin yerini alması amaçlanmamıştır. Bunun yerine, yalnızca düzenleme örneklerinin beklenmeyen nedenlerle başarısız olduğu durumlarda kullanılması amaçlanmıştır. Failed dışındaki durumlarda orkestrasyonlar (örneğin, Running, Pending, Terminated veya Completed) "geri alınamaz". Hata işleme ve yeniden deneme ilkeleri hakkında daha fazla bilgi için Hata işleme makalesine bakın.

Düzenlemeyi RewindAsync durumuna geri getirmek için rewind (.NET) veya (JavaScript) yöntemini kullanın. Bu yöntem ayrıca düzenleme hatasına neden olan etkinlik veya alt yönetim yürütme hatalarını da yeniden çalıştırır.

Örneğin, bir dizi insan onayı içeren bir iş akışınız olduğunu varsayalım. Varsayalım ki bir dizi aktivite fonksiyonu bir kişiye bildirimde bulunarak onayının gerektiğini bildiriyor ve gerçek zamanlı yanıtın beklenmesini sağlıyor. Tüm onay etkinlikleri yanıt aldıktan veya zaman aşımına uğradıktan sonra, geçersiz bir veritabanı bağlantı dizesi gibi bir uygulamanın yanlış yapılandırılması yüzünden başka bir etkinliğin başarısız olduğunu varsayalım. Sonuç, iş akışının derinliklerinde bir orkestrasyon hatasıdır. RewindAsync (.NET) veya rewind (JavaScript) API'siyle uygulama yöneticisi yapılandırma hatasını düzeltebilir ve başarısız düzenlemeyi hatadan hemen önce duruma geri döndürebilir. İnsan etkileşimi adımlarının hiçbirinin yeniden onaylanması gerekmez ve düzenleme artık başarıyla tamamlanabilir.

Uyarı

Geri sarma özelliği, dayanıklı zamanlayıcılar kullanan düzenleme örneklerini geri sarmayı desteklemez.

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

Uyarı

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 yapılandırması için bkz. Örnekleri başlatma .

using Microsoft.DurableTask.Client;

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

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

const client = createAzureManagedClient(connectionString);

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

Orkestrasyon örneklerini yeniden başlatma

Düzenlemeyi yeniden başlatmak, daha önce çalışan bir örneğin geçmişini kullanarak yeni bir örnek oluşturur. Bu özellik, aynı giriş ve örnek kimliği ile bir orkestrasyonu yeniden çalıştırmak istediğinizde kullanışlıdır ve orijinalini temel alarak yeni bir çalıştırma oluşturur.

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

Uyarı

using Microsoft.DurableTask.Client;

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

Orkestrasyon örneği geçmişini temizleme

Orkestrasyonla ilişkili tüm verileri kaldırmak için örnek geçmişini temizleyin. Örneğin, tamamlanmış bir örnekle ilişkili tüm depolama kaynaklarını silin. Düzenleme istemcisi tarafından tanımlanan temizleme örneği API'sini kullanın.

Aşağıdaki örnekte tek bir orkestrasyon örneğinin nasıl temizleneceği açıklanmaktadır.

[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 yapılandırması için bkz. Örnekleri başlatma .

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

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

    return await client.purge_instance_history(instance_id)

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

using Microsoft.DurableTask.Client;

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

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

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

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

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

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

const client = createAzureManagedClient(connectionString);

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

Aşağıdaki örnekte, belirtilen zaman aralığından sonra tamamlanan tüm düzenleme örneklerinin geçmişini temizleyen zamanlayıcı ile tetiklenen bir işlev gösterilmektedir. Bu durumda, 30 veya daha fazla gün önce tamamlanan tüm örneklerin verilerini kaldırır. Bu örnek işlev günde bir kez, saat 23:00 UTC'de çalışacak şekilde zamanlanmıştır:

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

Uyarı

yöntemi, purgeInstanceHistoryBy birden çok örneğin örnek geçmişini koşullu olarak temizlemek için kullanılabilir.

function.json

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

Uyarı

Bu örnek Dayanıklı İşlevler sürüm 2.x'i hedefler. Sürüm 1.x'te orchestrationClient yerine durableClient kullanın.

index.js

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

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

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

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

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

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

using Microsoft.DurableTask.Client;

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

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

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

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

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

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

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

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

const client = createAzureManagedClient(connectionString);

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

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

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

Uyarı

Temizleme geçmişi işleminin başarılı olması için hedef örneğin çalışma zamanı durumu Tamamlandı, Sonlandırıldı veya Başarısız olmalıdır.

Sonraki Adımlar

Sürüm oluşturma işlemini işleme

Örnek yönetimi için yerleşik HTTP API başvurusu

Dayanıklı Görev SDK'larını kullanmaya başlama

Dayanıklı Görev Zamanlayıcı hakkında bilgi edinin

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-04-22

Orkestrasyon örneklerini yönetme

Başlangıç örnekleri

Sorgu örnekleri

Tüm düzenleme örneklerini sorgulama

Filtrelerle sorgu düzenleme örnekleri

Orkestrasyon örneklerini sonlandırma

Oryestrasyon örneklerini askıya almak ve devam ettirmek

Olayları örneklere gönderme

Düzenlemenin tamamlanmasını bekleyin

Orkestrasyon örnekleri için HTTP yönetim web kancası URL'lerini elde etme

Orkestrasyon örneklerini geri alma

Orkestrasyon örneklerini yeniden başlatma

Orkestrasyon örneği geçmişini temizleme

Sonraki Adımlar

Geri Bildirim

Ek kaynaklar