사용자 지정 오케스트레이션 상태 설정 및 쿼리

사용자 지정 오케스트레이션 상태를 사용하면 외부 클라이언트가 언제든지 쿼리할 수 있도록 임의의 JSON 메타데이터를 실행 중인 오케스트레이션 인스턴스에 연결할 수 있습니다. 다음을 수행해야 하는 경우 사용자 지정 상태를 사용합니다.

진행 중 상황 보고 - 오케스트레이션이 완료되기를 기다리지 않고 UI에서 오케스트레이션의 현재 단계를 표시하도록 합니다.
오케스트레이션이 계속 실행되는 동안 호출자에게 동적 데이터를 반환합니다( 화면 권장 사항, 할인 정보 또는 다음 단계 지침).
외부 시스템과의 조정 – 다른 서비스나 인간 운영자가 폴링하고 작업할 수 있는 상태를 공유합니다.

경고

사용자 지정 상태 페이로드는 16KB의 UTF-16 JSON 텍스트로 제한됩니다. 더 큰 페이로드가 필요한 경우 외부 스토리지를 사용하고 대신 사용자 지정 상태에 참조(예: Blob URL)를 저장합니다.

Azure Functions 이 상태는 오케스트레이션 클라이언트 개체의 HTTP GetStatus API 또는 해당 SDK API 통해 사용할 수 있습니다.

지속성 작업 SDK에서 이 상태는 DurableTaskClient 오케스트레이션 상태 쿼리 API를 통해 사용할 수 있습니다(예: .NET GetInstanceAsync 또는 Java getInstanceMetadata).

중요합니다

현재 PowerShell 지속성 작업 SDK는 사용할 수 없습니다.

사용자 지정 오케스트레이션 상태에 대한 샘플 사용 사례

다음 표에서는 일반적인 패턴을 요약합니다. 사용 사례를 선택하여 해당 예제로 이동합니다.

사용 사례	설명
오케스트레이션 진행률 시각화	클라이언트가 진행률 표시기를 표시할 수 있도록 각 작업 후에 문자열 또는 개체를 업데이트합니다.
클라이언트에 동적 메타데이터 반환	사용자 지정 서버 쪽 엔드포인트 없이 클라이언트가 렌더링하는 구조적 데이터(예: 권장 사항)를 설정합니다.
클라이언트에 실행 가능한 데이터 제공	오케스트레이션이 외부 이벤트를 기다리는 동안, 클라이언트가 수행할 예약 URL, 할인 정보 또는 다음 단계 지침을 표시합니다.
사용자 지정 상태 쿼리	HTTP API 또는 SDK 호출을 사용하여 클라이언트에서 사용자 지정 상태 값을 읽습니다.

오케스트레이션 진행률 시각화

이 패턴에서 오케스트레이터는 각 활동이 완료된 후(또는 해당 언어로) 호출 SetCustomStatus 하여 마지막으로 완료된 도시의 이름으로 상태를 업데이트합니다. 클라이언트는 상태 엔드포인트를 폴링하고, 현재 값을 읽고, UI에서 진행률 표시기를 업데이트합니다.

다음 샘플에서는 Durable Functions HTTP 상태 엔드포인트를 사용하여 진행률 공유를 보여 줍니다.

메모

이러한 예제는 Durable Functions 2.x용으로 작성되었으며 Durable Functions 1.x와 호환되지 않습니다. 버전 간의 차이점에 대한 자세한 내용은 Durable Functions 버전 문서를 참조하세요.

[FunctionName("E1_HelloSequence")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Tokyo"));
    context.SetCustomStatus("Tokyo");
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Seattle"));
    context.SetCustomStatus("Seattle");
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "London"));
    context.SetCustomStatus("London");

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
}

[FunctionName("E1_SayHello")]
public static string SayHello([ActivityTrigger] string name)
{
    return $"Hello {name}!";
}

E1_HelloSequence 오케스트레이터 함수:

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

module.exports = df.orchestrator(function*(context){
    const outputs = [];

    outputs.push(yield context.df.callActivity("E1_SayHello", "Tokyo"));
    context.df.setCustomStatus("Tokyo");
    outputs.push(yield context.df.callActivity("E1_SayHello", "Seattle"));
    context.df.setCustomStatus("Seattle");
    outputs.push(yield context.df.callActivity("E1_SayHello", "London"));
    context.df.setCustomStatus("London");

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
});

E1_SayHello 활동 함수:

module.exports = async function(context, name) {
    return `Hello ${name}!`;
};

`E1_HelloSequence` Orchestrator 함수

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


def orchestrator_function(context: df.DurableOrchestrationContext):

    output1 = yield context.call_activity('E1_SayHello', 'Tokyo')
    context.set_custom_status('Tokyo')
    output2 = yield context.call_activity('E1_SayHello', 'Seattle')
    context.set_custom_status('Seattle')
    output3 = yield context.call_activity('E1_SayHello', 'London')
    context.set_custom_status('London')

    return [output1, output2, output3]

main = df.Orchestrator.create(orchestrator_function)

`E1_SayHello` 작업 함수

def main(name: str) -> str:
    return f"Hello {name}!"

`E1_HelloSequence` Orchestrator 함수

param($Context)

$output = @()

$output += Invoke-DurableActivity -FunctionName 'E1_SayHello' -Input 'Tokyo'
Set-DurableCustomStatus -CustomStatus 'Tokyo'

$output += Invoke-DurableActivity -FunctionName 'E1_SayHello' -Input 'Seattle'
Set-DurableCustomStatus -CustomStatus 'Seattle'

$output += Invoke-DurableActivity -FunctionName 'E1_SayHello' -Input 'London'
Set-DurableCustomStatus -CustomStatus 'London'


return $output

`E1_SayHello` 작업 함수

param($name)

"Hello $name"

@FunctionName("HelloCities")
public String helloCitiesOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
    ctx.setCustomStatus("Tokyo");
    result += ctx.callActivity("SayHello", "London", String.class).await() + ", ";
    ctx.setCustomStatus("London");
    result += ctx.callActivity("SayHello", "Seattle", String.class).await();
    ctx.setCustomStatus("Seattle");
    return result;
}

@FunctionName("SayHello")
public String sayHello(@DurableActivityTrigger(name = "name") String name) {
    return String.format("Hello %s!", name);
}

다음 샘플에서는 지속성 작업 SDK 클라이언트 API를 사용하여 진행률 공유를 보여 줍니다.

using System.Threading.Tasks;
using Microsoft.DurableTask;

public class HelloCities : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        string result = "";

        result += await context.CallActivityAsync<string>("SayHello", "Tokyo") + ", ";
        context.SetCustomStatus("Tokyo");

        result += await context.CallActivityAsync<string>("SayHello", "London") + ", ";
        context.SetCustomStatus("London");

        result += await context.CallActivityAsync<string>("SayHello", "Seattle");
        context.SetCustomStatus("Seattle");

        return result;
    }
}

from durabletask import task

def say_hello(ctx: task.ActivityContext, name: str) -> str:
    return f"Hello {name}!"

def hello_cities(ctx: task.OrchestrationContext, _):
    result = ""

    result += (yield ctx.call_activity(say_hello, input="Tokyo")) + ", "
    ctx.set_custom_status("Tokyo")

    result += (yield ctx.call_activity(say_hello, input="London")) + ", "
    ctx.set_custom_status("London")

    result += yield ctx.call_activity(say_hello, input="Seattle")
    ctx.set_custom_status("Seattle")

    return result

import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class HelloCities implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String result = "";

        result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
        ctx.setCustomStatus("Tokyo");

        result += ctx.callActivity("SayHello", "London", String.class).await() + ", ";
        ctx.setCustomStatus("London");

        result += ctx.callActivity("SayHello", "Seattle", String.class).await();
        ctx.setCustomStatus("Seattle");

        ctx.complete(result);
    }
}

import { ActivityContext, OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const sayHello = async (_: ActivityContext, name: string): Promise<string> => {
    return `Hello ${name}!`;
};

const helloCities: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    let result = "";

    result += (yield ctx.callActivity(sayHello, "Tokyo")) + ", ";
    ctx.setCustomStatus("Tokyo");

    result += (yield ctx.callActivity(sayHello, "London")) + ", ";
    ctx.setCustomStatus("London");

    result += yield ctx.callActivity(sayHello, "Seattle");
    ctx.setCustomStatus("Seattle");

    return result;
};

클라이언트는 오케스트레이션 메타데이터를 폴링하고 CustomStatus 필드가 "London"로 설정될 때까지 기다릴 수 있습니다.

using System.Threading.Tasks;
using Microsoft.DurableTask.Client;

string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("HelloCities");

OrchestrationMetadata metadata = await client.WaitForInstanceStartAsync(instanceId, getInputsAndOutputs: true);
while (metadata.SerializedCustomStatus is null || metadata.ReadCustomStatusAs<string>() != "London")
{
    await Task.Delay(200);
    metadata = await client.GetInstanceAsync(instanceId, getInputsAndOutputs: true) ?? metadata;
}

import time
from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Assumes 'client' is a DurableTaskSchedulerClient instance
instance_id = client.schedule_new_orchestration(hello_cities)
state = client.wait_for_orchestration_start(instance_id, fetch_payloads=True)

while state.serialized_custom_status is None or state.serialized_custom_status != '"London"':
    time.sleep(0.2)
    state = client.get_orchestration_state(instance_id, fetch_payloads=True)

String instanceId = client.scheduleNewOrchestrationInstance("HelloCities");
OrchestrationMetadata metadata = client.waitForInstanceStart(instanceId, Duration.ofMinutes(5), true);

while (!"London".equals(metadata.readCustomStatusAs(String.class))) {
    Thread.sleep(200);
    metadata = client.getInstanceMetadata(instanceId, true);
}

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

const client = createAzureManagedClient(connectionString);

const instanceId = await client.scheduleNewOrchestration(helloCities);
let state = await client.waitForOrchestrationStart(instanceId, true, 60);

while (!state?.serializedCustomStatus || JSON.parse(state.serializedCustomStatus) !== "London") {
    await new Promise((resolve) => setTimeout(resolve, 200));
    state = await client.getOrchestrationState(instanceId, true);
}

다음 클라이언트 코드는 오케스트레이션 상태를 폴링하고, CustomStatus가 "London"으로 설정될 때까지 기다린 후 응답을 반환합니다.

[FunctionName("HttpStart")]
public static async Task<HttpResponseMessage> Run(
    [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient starter,
    string functionName,
    ILogger log)
{
    // Function input comes from the request content.
    dynamic eventData = await req.Content.ReadAsAsync<object>();
    string instanceId = await starter.StartNewAsync(functionName, (string)eventData);

    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

    DurableOrchestrationStatus durableOrchestrationStatus = await starter.GetStatusAsync(instanceId);
    while (durableOrchestrationStatus.CustomStatus.ToString() != "London")
    {
        await Task.Delay(200);
        durableOrchestrationStatus = await starter.GetStatusAsync(instanceId);
    }

    HttpResponseMessage httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
    {
        Content = new StringContent(JsonConvert.SerializeObject(durableOrchestrationStatus))
    };

    return httpResponseMessage;
  }
}

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

module.exports = async function(context, req) {
    const client = df.getClient(context);

    // Function input comes from the request content.
    const eventData = req.body;
    const instanceId = await client.startNew(req.params.functionName, undefined, eventData);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    let durableOrchestrationStatus = await client.getStatus(instanceId);
    while (durableOrchestrationStatus.customStatus.toString() !== "London") {
        await new Promise((resolve) => setTimeout(resolve, 200));
        durableOrchestrationStatus = await client.getStatus(instanceId);
    }

    const httpResponseMessage = {
        status: 200,
        body: JSON.stringify(durableOrchestrationStatus),
    };

    return httpResponseMessage;
};

메모

JavaScript customStatus 에서 필드는 다음 yield 또는 return 작업이 예약될 때 설정됩니다.

import json
import logging
import azure.functions as func
import azure.durable_functions as df
from time import sleep

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

    logging.info(f"Started orchestration with ID = '{instance_id}'.")

    durable_orchestration_status = await client.get_status(instance_id)
    while durable_orchestration_status.custom_status != 'London':
        sleep(0.2)
        durable_orchestration_status = await client.get_status(instance_id)

    return func.HttpResponse(body='Success', status_code=200, mimetype='application/json')

메모

Python 다음 custom_status 또는 yield 작업이 예약되면 return 필드가 설정됩니다.

@FunctionName("StartHelloCities")
public HttpResponseMessage startHelloCities(
        @HttpTrigger(name = "req") HttpRequestMessage<Void> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) throws InterruptedException {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("HelloCities");
    context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);

    OrchestrationMetadata metadata;
    try {
        metadata = client.waitForInstanceStart(instanceId, Duration.ofMinutes(5), true);
    } catch (TimeoutException ex) {
        return req.createResponseBuilder(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }

    while (!"London".equals(metadata.readCustomStatusAs(String.class))) {
        Thread.sleep(200);
        metadata = client.getInstanceMetadata(instanceId, true);
    }

    return req.createResponseBuilder(HttpStatus.OK).build();
}

클라이언트에 동적 메타데이터 반환

사용자 지정 오케스트레이션 상태를 사용하여 개별 엔드포인트를 빌드하지 않고도 개인 설정된 권장 사항과 같은 구조적 데이터를 클라이언트에 반환할 수 있습니다. 오케스트레이터는 입력에 따라 사용자 지정 상태를 설정하고 클라이언트는 표준 상태 API를 통해 읽습니다. 이렇게 하면 모든 논리가 서버 쪽에 유지되는 동안 클라이언트 쪽 코드가 제네릭으로 유지됩니다.

[FunctionName("CityRecommender")]
public static void Run(
  [OrchestrationTrigger] IDurableOrchestrationContext context)
{
  int userChoice = context.GetInput<int>();

  switch (userChoice)
  {
    case 1:
    context.SetCustomStatus(new
    {
      recommendedCities = new[] {"Tokyo", "Seattle"},
      recommendedSeasons = new[] {"Spring", "Summer"}
     });
      break;
    case 2:
      context.SetCustomStatus(new
      {
                recommendedCities = new[] {"Seattle", "London"},
        recommendedSeasons = new[] {"Summer"}
      });
        break;
      case 3:
      context.SetCustomStatus(new
      {
                recommendedCities = new[] {"Tokyo", "London"},
        recommendedSeasons = new[] {"Spring", "Summer"}
      });
        break;
  }

  // Wait for user selection and refine the recommendation
}

`CityRecommender` 조정자

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

module.exports = df.orchestrator(function*(context) {
    const userChoice = context.df.getInput();

    switch (userChoice) {
        case 1:
            context.df.setCustomStatus({
                recommendedCities: [ "Tokyo", "Seattle" ],
                recommendedSeasons: [ "Spring", "Summer" ],
            });
            break;
        case 2:
            context.df.setCustomStatus({
                recommendedCities: [ "Seattle", "London" ],
                recommendedSeasons: [ "Summer" ],
            });
            break;
        case 3:
            context.df.setCustomStatus({
                recommendedCities: [ "Tokyo", "London" ],
                recommendedSeasons: [ "Spring", "Summer" ],
            });
            break;
    }

    // Wait for user selection and refine the recommendation
});

`CityRecommender` 조정자

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

def orchestrator_function(context: df.DurableOrchestrationContext):
    userChoice = int(context.get_input())

    if userChoice == 1:
        context.set_custom_status({
            'recommendedCities': ['Tokyo', 'Seattle'],
            'recommendedSeasons': ['Spring', 'Summer']
        })
    elif userChoice == 2:
        context.set_custom_status({
            'recommendedCities': ['Seattle', 'London'],
            'recommendedSeasons': ['Summer']
        })
    elif userChoice == 3:
        context.set_custom_status({
            'recommendedCities': ['Tokyo', 'London'],
            'recommendedSeasons': ['Spring', 'Summer']
        })



    # Wait for user selection and refine the recommendation

main = df.Orchestrator.create(orchestrator_function)

`CityRecommender` 조정자

param($Context)

$userChoice = $Context.Input -as [int]

if ($userChoice -eq 1) {
    Set-DurableCustomStatus -CustomStatus @{ recommendedCities = @('Tokyo', 'Seattle'); 
                                             recommendedSeasons = @('Spring', 'Summer') 
                                            }  
}

if ($userChoice -eq 2) {
    Set-DurableCustomStatus -CustomStatus @{ recommendedCities = @('Seattle', 'London'); 
                                             recommendedSeasons = @('Summer') 
                                            }  
}

if ($userChoice -eq 3) {
    Set-DurableCustomStatus -CustomStatus @{ recommendedCities = @('Tokyo', 'London'); 
                                             recommendedSeasons = @('Spring', 'Summer') 
                                            }  
}

# Wait for user selection and refine the recommendation

@FunctionName("CityRecommender")
public void cityRecommender(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    int userChoice = ctx.getInput(int.class);
    switch (userChoice) {
        case 1:
            ctx.setCustomStatus(new Recommendation(
                    new String[]{ "Tokyo", "Seattle" },
                    new String[]{ "Spring", "Summer" }));
            break;
        case 2:
            ctx.setCustomStatus(new Recommendation(
                    new String[]{ "Seattle", "London" },
                    new String[]{ "Summer" }));
            break;
        case 3:
            ctx.setCustomStatus(new Recommendation(
                    new String[]{ "Tokyo", "London" },
                    new String[]{ "Spring", "Summer" }));
            break;
    }

    // Wait for user selection with an external event
}

class Recommendation {
    public Recommendation() { }

    public Recommendation(String[] cities, String[] seasons) {
        this.recommendedCities = cities;
        this.recommendedSeasons = seasons;
    }

    public String[] recommendedCities;
    public String[] recommendedSeasons;
}

using System.Threading.Tasks;
using Microsoft.DurableTask;

public class CityRecommender : TaskOrchestrator<int, object?>
{
    public override Task<object?> RunAsync(TaskOrchestrationContext context, int userChoice)
    {
        switch (userChoice)
        {
            case 1:
                context.SetCustomStatus(new
                {
                    recommendedCities = new[] { "Tokyo", "Seattle" },
                    recommendedSeasons = new[] { "Spring", "Summer" },
                });
                break;
            case 2:
                context.SetCustomStatus(new
                {
                    recommendedCities = new[] { "Seattle", "London" },
                    recommendedSeasons = new[] { "Summer" },
                });
                break;
            case 3:
                context.SetCustomStatus(new
                {
                    recommendedCities = new[] { "Tokyo", "London" },
                    recommendedSeasons = new[] { "Spring", "Summer" },
                });
                break;
        }

        // Wait for user selection and refine the recommendation
        return Task.FromResult<object?>(null);
    }
}

from durabletask import task

def city_recommender(ctx: task.OrchestrationContext, user_choice: int):
    if user_choice == 1:
        ctx.set_custom_status({
            "recommendedCities": ["Tokyo", "Seattle"],
            "recommendedSeasons": ["Spring", "Summer"]
        })
    elif user_choice == 2:
        ctx.set_custom_status({
            "recommendedCities": ["Seattle", "London"],
            "recommendedSeasons": ["Summer"]
        })
    elif user_choice == 3:
        ctx.set_custom_status({
            "recommendedCities": ["Tokyo", "London"],
            "recommendedSeasons": ["Spring", "Summer"]
        })

    # Wait for user selection and refine the recommendation

import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class CityRecommender implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        int userChoice = ctx.getInput(int.class);

        switch (userChoice) {
            case 1:
                ctx.setCustomStatus(new Recommendation(
                        new String[]{ "Tokyo", "Seattle" },
                        new String[]{ "Spring", "Summer" }));
                break;
            case 2:
                ctx.setCustomStatus(new Recommendation(
                        new String[]{ "Seattle", "London" },
                        new String[]{ "Summer" }));
                break;
            case 3:
                ctx.setCustomStatus(new Recommendation(
                        new String[]{ "Tokyo", "London" },
                        new String[]{ "Spring", "Summer" }));
                break;
        }

        // Wait for user selection and refine the recommendation
    }
}

class Recommendation {
    public Recommendation(String[] cities, String[] seasons) {
        this.recommendedCities = cities;
        this.recommendedSeasons = seasons;
    }

    public String[] recommendedCities;
    public String[] recommendedSeasons;
}

import { OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const cityRecommender: TOrchestrator = async function* (ctx: OrchestrationContext, userChoice: number): any {
    switch (userChoice) {
        case 1:
            ctx.setCustomStatus({
                recommendedCities: ["Tokyo", "Seattle"],
                recommendedSeasons: ["Spring", "Summer"],
            });
            break;
        case 2:
            ctx.setCustomStatus({
                recommendedCities: ["Seattle", "London"],
                recommendedSeasons: ["Summer"],
            });
            break;
        case 3:
            ctx.setCustomStatus({
                recommendedCities: ["Tokyo", "London"],
                recommendedSeasons: ["Spring", "Summer"],
            });
            break;
    }

    // Wait for user selection and refine the recommendation
};

클라이언트에 실행 가능한 데이터 제공

이 패턴에서 오케스트레이터는 사용자 지정 상태를 통해 할인, 예약 URL 및 시간 제한과 같은 시간에 민감한 정보를 표시한 다음, 일시 중지하여 외부 이벤트를 기다립니다. 클라이언트는 사용자 지정 상태를 읽고 제품을 표시하고 사용자가 작업을 할 때 확인 이벤트를 다시 오케스트레이터로 보냅니다.

[FunctionName("ReserveTicket")]
public static async Task<bool> Run(
  [OrchestrationTrigger] IDurableOrchestrationContext context)
{
  string userId = context.GetInput<string>();

  int discount = await context.CallActivityAsync<int>("CalculateDiscount", userId);

  context.SetCustomStatus(new
  {
    discount = discount,
    discountTimeout = 60,
    bookingUrl = "https://www.myawesomebookingweb.com",
  });

  bool isBookingConfirmed = await context.WaitForExternalEvent<bool>("BookingConfirmed");

  context.SetCustomStatus(isBookingConfirmed
    ? new {message = "Thank you for confirming your booking."}
    : new {message = "The booking was not confirmed on time. Please try again."});

  return isBookingConfirmed;
}

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

module.exports = df.orchestrator(function*(context) {
    const userId = context.df.getInput();

    const discount = yield context.df.callActivity("CalculateDiscount", userId);

    context.df.setCustomStatus({
        discount,
        discountTimeout: 60,
        bookingUrl: "https://www.myawesomebookingweb.com",
    });

    const isBookingConfirmed = yield context.df.waitForExternalEvent("BookingConfirmed");

    context.df.setCustomStatus(isBookingConfirmed
        ? { message: "Thank you for confirming your booking." }
        : { message: "The booking was not confirmed on time. Please try again." }
    );

    return isBookingConfirmed;
});

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

def orchestrator_function(context: df.DurableOrchestrationContext):
    userId = int(context.get_input())

    discount = yield context.call_activity('CalculateDiscount', userId)

    status = { 'discount' : discount,
        'discountTimeout' : 60,
        'bookingUrl' : "https://www.myawesomebookingweb.com",
    }
    context.set_custom_status(status)

    is_booking_confirmed = yield context.wait_for_external_event('BookingConfirmed')
    context.set_custom_status({'message': 'Thank you for confirming your booking.'} if is_booking_confirmed 
        else {'message': 'The booking was not confirmed on time. Please try again.'})
    return is_booking_confirmed

main = df.Orchestrator.create(orchestrator_function)

param($Context)

$userId = $Context.Input -as [int]

$discount = Invoke-DurableActivity -FunctionName 'CalculateDiscount' -Input $userId

$status = @{
            discount = $discount;
            discountTimeout = 60;
            bookingUrl = "https://www.myawesomebookingweb.com"
            }

Set-DurableCustomStatus -CustomStatus $status

$isBookingConfirmed = Invoke-DurableActivity -FunctionName 'BookingConfirmed'

if ($isBookingConfirmed) {
    Set-DurableCustomStatus -CustomStatus @{message = 'Thank you for confirming your booking.'}
} else {
    Set-DurableCustomStatus -CustomStatus @{message = 'The booking was not confirmed on time. Please try again.'}
}

return $isBookingConfirmed

@FunctionName("ReserveTicket")
public boolean reserveTicket(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String userID = ctx.getInput(String.class);
    int discount = ctx.callActivity("CalculateDiscount", userID, int.class).await();
    ctx.setCustomStatus(new DiscountInfo(discount, 60, "https://www.myawesomebookingweb.com"));

    boolean isConfirmed = ctx.waitForExternalEvent("BookingConfirmed", boolean.class).await();
    if (isConfirmed) {
        ctx.setCustomStatus("Thank you for confirming your booking.");
    } else {
        ctx.setCustomStatus("There was a problem confirming your booking. Please try again.");
    }

    return isConfirmed;
}

class DiscountInfo {
    public DiscountInfo() { }
    public DiscountInfo(int discount, int discountTimeout, String bookingUrl) {
        this.discount = discount;
        this.discountTimeout = discountTimeout;
        this.bookingUrl = bookingUrl;
    }
    public int discount;
    public int discountTimeout;
    public String bookingUrl;
}

using System.Threading.Tasks;
using Microsoft.DurableTask;

public class ReserveTicket : TaskOrchestrator<string, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, string userId)
    {
        int discount = await context.CallActivityAsync<int>("CalculateDiscount", userId);

        context.SetCustomStatus(new
        {
            discount,
            discountTimeout = 60,
            bookingUrl = "https://www.myawesomebookingweb.com",
        });

        bool isBookingConfirmed = await context.WaitForExternalEvent<bool>("BookingConfirmed");
        context.SetCustomStatus(isBookingConfirmed
            ? new { message = "Thank you for confirming your booking." }
            : new { message = "The booking was not confirmed on time. Please try again." });

        return isBookingConfirmed;
    }
}

from durabletask import task

def calculate_discount(ctx: task.ActivityContext, user_id: str) -> int:
    # Calculate discount based on user
    return 10

def reserve_ticket(ctx: task.OrchestrationContext, user_id: str):
    discount = yield ctx.call_activity(calculate_discount, input=user_id)

    ctx.set_custom_status({
        "discount": discount,
        "discountTimeout": 60,
        "bookingUrl": "https://www.myawesomebookingweb.com"
    })

    is_booking_confirmed = yield ctx.wait_for_external_event("BookingConfirmed")
    if is_booking_confirmed:
        ctx.set_custom_status({"message": "Thank you for confirming your booking."})
    else:
        ctx.set_custom_status({"message": "The booking was not confirmed on time. Please try again."})

    return is_booking_confirmed

import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class ReserveTicket implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String userId = ctx.getInput(String.class);
        int discount = ctx.callActivity("CalculateDiscount", userId, int.class).await();

        ctx.setCustomStatus(new DiscountInfo(discount, 60, "https://www.myawesomebookingweb.com"));

        boolean isConfirmed = ctx.waitForExternalEvent("BookingConfirmed", boolean.class).await();
        if (isConfirmed) {
            ctx.setCustomStatus("Thank you for confirming your booking.");
        } else {
            ctx.setCustomStatus("The booking was not confirmed on time. Please try again.");
        }

        ctx.complete(isConfirmed);
    }
}

class DiscountInfo {
    public DiscountInfo(int discount, int discountTimeout, String bookingUrl) {
        this.discount = discount;
        this.discountTimeout = discountTimeout;
        this.bookingUrl = bookingUrl;
    }

    public int discount;
    public int discountTimeout;
    public String bookingUrl;
}

import { ActivityContext, OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const calculateDiscount = async (_: ActivityContext, userId: string): Promise<number> => {
    // Calculate discount based on user
    return 10;
};

const reserveTicket: TOrchestrator = async function* (ctx: OrchestrationContext, userId: string): any {
    const discount: number = yield ctx.callActivity(calculateDiscount, userId);

    ctx.setCustomStatus({
        discount,
        discountTimeout: 60,
        bookingUrl: "https://www.myawesomebookingweb.com",
    });

    const isBookingConfirmed: boolean = yield ctx.waitForExternalEvent("BookingConfirmed");
    ctx.setCustomStatus(isBookingConfirmed
        ? { message: "Thank you for confirming your booking." }
        : { message: "The booking was not confirmed on time. Please try again." }
    );

    return isBookingConfirmed;
};

사용자 지정 오케스트레이션 상태 쿼리

이전 예제에서는 오케스트레이터 코드에서 사용자 지정 상태를 설정하는 방법을 보여 줍니다. 이 섹션에서는 외부 클라이언트가 해당 값을 읽는 방법에 중점을 둡니다.

오케스트레이터가 SetCustomStatus 호출한 후 외부 클라이언트는 기본 제공 Durable Functions HTTP API를 통해 값을 쿼리할 수 있습니다. 다음은 그 예입니다.

GET /runtime/webhooks/durabletask/instances/instance123

응답에는 런타임 메타데이터와 함께 필드가 포함됩니다 customStatus .

{
  "runtimeStatus": "Running",
  "input": null,
  "customStatus": { "nextActions": ["A", "B", "C"], "foo": 2 },
  "output": null,
  "createdTime": "2019-10-06T18:30:24Z",
  "lastUpdatedTime": "2019-10-06T19:40:30Z"
}

오케스트레이션 클라이언트 SDK를 사용하여 프로그래밍 방식으로 사용자 지정 상태를 쿼리할 수도 있습니다. 전체 참조는 쿼리 인스턴스를 참조하세요.

지속성 작업 SDK는 기본 제공 HTTP 상태 엔드포인트를 제공하지 않습니다. 대신 오케스트레이션 인스턴스 메타데이터 API를 사용하여 DurableTaskClient에서 프로그래밍 방식으로 사용자 지정 상태를 쿼리합니다.

using Microsoft.DurableTask.Client;

OrchestrationMetadata? metadata = await client.GetInstanceAsync(instanceId, getInputsAndOutputs: true);
string? customStatusJson = metadata?.SerializedCustomStatus;

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Assumes 'client' is a DurableTaskSchedulerClient instance
state = client.get_orchestration_state(instance_id, fetch_payloads=True)
custom_status_json = state.serialized_custom_status

OrchestrationMetadata metadata = client.getInstanceMetadata(instanceId, true);
CustomStatusPayload payload = metadata.readCustomStatusAs(CustomStatusPayload.class);

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

const client = createAzureManagedClient(connectionString);

// Get the custom status of an orchestration instance
const state = await client.getOrchestrationState(instanceId, true);
const customStatusJson = state?.serializedCustomStatus;

경고

사용자 지정 상태 페이로드는 16KB의 UTF-16 JSON 텍스트로 제한됩니다.

다음 단계

지속성 타이머에 대해 알아보기

Durable Task SDK 사용 시작

피드백

이 페이지가 도움이 되었나요?

Last updated on 2026-04-28

사용자 지정 오케스트레이션 상태 설정 및 쿼리

사용자 지정 오케스트레이션 상태에 대한 샘플 사용 사례

오케스트레이션 진행률 시각화

클라이언트에 동적 메타데이터 반환

클라이언트에 실행 가능한 데이터 제공

사용자 지정 오케스트레이션 상태 쿼리

다음 단계

피드백

추가 리소스