Řetězení funkcí

Řetězení funkcí je vzor, ve kterém spouštíte posloupnost funkcí v uvedeném pořadí. Je běžné předat výstup jedné funkce do vstupu další. Tento článek popisuje posloupnost řetězení, kterou vytvoříte po dokončení rychlého startu Durable Functions (C#, JavaScript, TypeScript, Python, PowerShell nebo Java). Další informace najdete v přehledu Durable Functions.

Požadavky

Dokončení článku rychlého startu
Klonování nebo stažení ukázkového projektu z GitHubu (používá model v procesu)

Řetězení funkcí je vzor, ve kterém spouštíte řadu činností ve stanoveném pořadí. Výstup jedné aktivity se běžně předává vstupu další aktivity. Tento článek popisuje řetězení pro sady SDK pro Durable Task u .NET, JavaScript, Python a Java.

Functions

Tento článek popisuje tyto funkce v ukázkové aplikaci:

E1_HelloSequence: Funkce orchestrátoru , která volá E1_SayHello vícekrát v sekvenci. Ukládá každý výstup a zaznamenává výsledky.
E1_SayHello: Funkce aktivity, která přidává "Hello" na začátek řetězce.
HttpStart: Odolná klientská funkce aktivovaná protokolem HTTP, která spouští instanci orchestrátoru.

Tento článek popisuje tyto komponenty v ukázkové aplikaci:

GreetingOrchestration, greetingOrchestrator, function_chaining_orchestratornebo ActivityChaining: Orchestrátor, který volá více aktivit v posloupnosti. Ukládá každý výstup a zaznamenává výsledky.
Funkce aktivit: Aktivity, které zpracovávají vstup a vracejí výsledky. Každá aktivita provádí jednoduchou transformaci vstupu.
Klient: Klientská aplikace, která spouští instanci orchestrátoru a čeká na výsledek.

Orchestrator

[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"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello_DirectInput", "London"));

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

Všechny funkce orchestrace jazyka C# musí mít parametr typu DurableOrchestrationContext, který existuje v sestavení Microsoft.Azure.WebJobs.Extensions.DurableTask. Tento kontextový objekt umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho CallActivityAsync metody.

Kód volá E1_SayHello třikrát v sekvenci s různými hodnotami parametrů. Návratová hodnota každého volání se přidá do outputs seznamu, který se vrátí na konci funkce.

Programovací model V3

function.json

Pokud vyvíjíte na Visual Studio Code nebo na portálu Azure, tady je soubor orchestrátoru function.json.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Klíčovým nastavením je typ vazby orchestrationTrigger. Všechny funkce orchestrátoru musí používat tento typ triggeru.

Varování

Pokud chcete pro funkce orchestrátoru postupovat podle pravidla bez vstupně-výstupních operací, nepoužívejte u vazby triggeru orchestrationTrigger vstupní ani výstupní vazby. Pokud potřebujete jiné vstupní nebo výstupní vazby, použijte je ve activityTrigger funkcích, které orchestrátor volá. Další informace najdete v tématu Omezení kódu funkce orchestrátoru.

index.js

Tady je funkce orchestrátoru:

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

module.exports = df.orchestrator(function* (context) {
    context.log("Starting chain sample");
    const output = [];
    output.push(yield context.df.callActivity("E1_SayHello", "Tokyo"));
    output.push(yield context.df.callActivity("E1_SayHello", "Seattle"));
    output.push(yield context.df.callActivity("E1_SayHello", "London"));

    return output;
});

Všechny funkce orchestrace Jazyka JavaScript musí obsahovat durable-functions modul. Je to knihovna, která umožňuje psát Durable Functions v JavaScriptu. Tři klíčové rozdíly mezi funkcí orchestrátoru a dalšími javascriptovými funkcemi:

Funkce orchestrátoru je generátorová funkce.
Funkce je obsažena ve volání metody modulu durable-functionsorchestrator (zde df).
Funkce je synchronní. Vzhledem k tomu, že metoda orchestrator volá context.done, funkce se vrátí.

Objekt context obsahuje objekt s trvalým kontextem df orchestrace, který umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho callActivity metody. Kód volá E1_SayHello třikrát za sebou s různými hodnotami parametrů, přičemž pomocí yield určuje, že provádění má čekat na dokončení asynchronních volání funkce. Návratová hodnota každého volání se přidá do outputs pole, které se vrátí na konci funkce.

Programovací model V4

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

const helloActivityName = "sayHello";

df.app.orchestration("helloSequence", function* (context) {
    context.log("Starting chain sample");

    const output = [];
    output.push(yield context.df.callActivity(helloActivityName, "Tokyo"));
    output.push(yield context.df.callActivity(helloActivityName, "Seattle"));
    output.push(yield context.df.callActivity(helloActivityName, "Cairo"));

    return output;
});

Všechny funkce orchestrace Jazyka JavaScript musí obsahovat durable-functions modul. Tento modul umožňuje psát Durable Functions v JavaScriptu. Pokud chcete použít programovací model uzlu V4, musíte nainstalovat v3.x verzi durable-functions.

Dva klíčové rozdíly mezi funkcí orchestrátoru a dalšími javascriptovými funkcemi:

Funkce orchestrátoru je generátorová funkce.
Funkce je synchronní. Funkce se vrátí.

Objekt context obsahuje objekt s trvalým kontextem df orchestrace, který umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho callActivity metody. Kód volá sayHello třikrát za sebou s různými hodnotami parametrů, přičemž pomocí yield určuje, že provádění má čekat na dokončení asynchronních volání funkce. Návratová hodnota každého volání se přidá do outputs pole, které se vrátí na konci funkce.

Poznámka:

Python Durable Functions jsou k dispozici pouze pro modul runtime Functions 3.0.

function.json

Pokud pro vývoj používáte Visual Studio Code nebo portál Azure, tady je obsah souboru function.json pro funkci orchestrátoru. Většina orchestrátoru function.json soubory vypadá téměř přesně takto.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

Důležité je typ vazby orchestrationTrigger . Všechny funkce orchestrátoru musí používat tento typ triggeru.

Varování

Pokud chcete dodržovat pravidlo "žádných vstupně-výstupních operací" orchestračních funkcí, nepoužívejte při použití aktivační vazby orchestrationTrigger žádné vstupní ani výstupní vazby. Pokud jsou potřeba jiné vstupní nebo výstupní vazby, měly by se použít v kontextu activityTrigger funkcí, které volá orchestrátor. Další informace najdete v článku omezení kódu funkce orchestrátoru.

init.py

Tady je funkce orchestrátoru:

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


def orchestrator_function(context: df.DurableOrchestrationContext):
    result1 = yield context.call_activity('E1_SayHello', "Tokyo")
    result2 = yield context.call_activity('E1_SayHello', "Seattle")
    result3 = yield context.call_activity('E1_SayHello', "London")
    return [result1, result2, result3]

main = df.Orchestrator.create(orchestrator_function)

Všechny funkce orchestrace Python musí obsahovat balíček durable-functions. Je to knihovna, která umožňuje psát Durable Functions v Python. Dva klíčové rozdíly mezi funkcí orchestrátoru a dalšími funkcemi Python:

Funkce orchestrátoru je generátorová funkce.
Soubor zaregistruje funkci orchestrátoru tím, že na konci souboru hlásímain = df.Orchestrator.create(<orchestrator function name>). To pomáhá odlišit ho od jiných pomocných funkcí deklarovaných v souboru.

Objekt context umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho call_activity metody. Kód volá E1_SayHello třikrát za sebou s různými hodnotami parametrů, přičemž pomocí yield určuje, že provádění má čekat na dokončení asynchronních volání funkce. Vrácená hodnota každého volání se vrátí na konci funkce.

Tento kód zobrazuje orchestrátor, který volá tři aktivity v posloupnosti a předává každý výstup další aktivitě:

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

[DurableTask]
public class GreetingOrchestration : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, string name)
    {
        // Step 1: Say hello to the person
        string greeting = await context.CallActivityAsync<string>(nameof(SayHelloActivity), name);

        // Step 2: Process the greeting
        string processedGreeting = await context.CallActivityAsync<string>(nameof(ProcessGreetingActivity), greeting);

        // Step 3: Finalize the response
        string finalResponse = await context.CallActivityAsync<string>(nameof(FinalizeResponseActivity), processedGreeting);

        return finalResponse;
    }
}

Všechny orchestrátory .NET dědí z TaskOrchestrator<TInput, TOutput>. TaskOrchestrationContext vám umožňuje volat aktivity pomocí CallActivityAsync. Kód volá tři aktivity v posloupnosti, kde každá aktivita přijímá výstup předchozí aktivity.

Následující kód ukazuje orchestrátor, který volá tři aktivity v posloupnosti:

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

const greetingOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  name: string
): any {
  // Step 1: Say hello to the person
  const greeting: string = yield ctx.callActivity(sayHello, name);

  // Step 2: Process the greeting
  const processedGreeting: string = yield ctx.callActivity(processGreeting, greeting);

  // Step 3: Finalize the response
  const finalResponse: string = yield ctx.callActivity(finalizeResponse, processedGreeting);

  return finalResponse;
};

Všechny orchestrátory JavaScriptu jsou generátorové funkce (async function*), které používají yield k volání aktivit. Metoda kontextu callActivity orchestrace plánuje provádění aktivit. Kód volá tři aktivity v posloupnosti a předává výstup jednotlivých aktivit dalšímu.

Následující kód ukazuje orchestrátor, který volá tři aktivity v posloupnosti:

from durabletask import task

# Orchestrator function
def function_chaining_orchestrator(ctx: task.OrchestrationContext, name: str) -> str:
    """Orchestrator that demonstrates function chaining pattern."""

    # Call first activity
    greeting = yield ctx.call_activity(say_hello, input=name)

    # Call second activity with the result from first activity
    processed_greeting = yield ctx.call_activity(process_greeting, input=greeting)

    # Call third activity with the result from second activity
    final_response = yield ctx.call_activity(finalize_response, input=processed_greeting)

    return final_response

Všechny orchestrátory Python jsou generátorové funkce, které k volání aktivit používají yield. Metoda kontextu call_activity orchestrace plánuje provádění aktivit. Kód volá tři aktivity v posloupnosti a předává výstup jednotlivých aktivit dalšímu.

Následující kód ukazuje orchestrátor, který volá tři aktivity v posloupnosti:

import com.microsoft.durabletask.DurableTaskGrpcWorker;
import com.microsoft.durabletask.DurableTaskSchedulerWorkerExtensions;
import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationFactory;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "ActivityChaining"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                String input = ctx.getInput(String.class);

                // Call activities in sequence, passing output from one to the next
                String x = ctx.callActivity("Reverse", input, String.class).await();
                String y = ctx.callActivity("Capitalize", x, String.class).await();
                String z = ctx.callActivity("ReplaceWhitespace", y, String.class).await();

                ctx.complete(z);
            };
        }
    })
    .build();

V Java se orchestrátory definují pomocí TaskOrchestrationFactory. Metoda kontextu callActivity plánuje provádění aktivity a await() čeká na výsledek. Kód volá tři aktivity v posloupnosti a předává výstup jednotlivých aktivit dalšímu.

Activity

[FunctionName("E1_SayHello")]
public static string SayHello([ActivityTrigger] IDurableActivityContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Aktivity používají ActivityTrigger atribut. Použijte IDurableActivityContext pro akce aktivit, jako je čtení vstupu pomocí GetInput<T>.

E1_SayHello formátuje řetězec pozdravu.

Místo vazby na IDurableActivityContext, navázat přímo na typ, který je předán do funkce aktivity. Příklad:

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

Programovací model V3

E1_SayHello/function.json

Soubor function.json pro funkci aktivity E1_SayHello je podobný té E1_HelloSequence, ale používá typ vazby activityTrigger místo typu vazby orchestrationTrigger.

{
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Použijte vazbu activityTrigger pro všechny funkce aktivit, které orchestrační funkce volá.

Implementace E1_SayHello je poměrně triviální operace formátování řetězců.

E1_SayHello/index.js

module.exports = function (context) {
    context.done(null, `Hello ${context.bindings.name}!`);
};

Na rozdíl od funkce orchestrace funkce aktivity nepotřebuje speciální nastavení. Orchestrátor předá vstup objektu context.bindings pod názvem activityTrigger vazby – v tomto případě context.bindings.name. Nastavte název vazby jako parametr exportované funkce pro přímý přístup, jak to ukazuje příklad.

Programovací model V4

sayHello formátuje řetězec pozdravu.

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

const helloActivityName = "sayHello";

df.app.activity(helloActivityName, {
    handler: function (input) {
        return `Hello ${input}`;
    },
});

Na rozdíl od funkce orchestrace funkce aktivity nepotřebuje speciální nastavení. Orchestrátor předává funkci vstup jako první argument. Druhým argumentem je kontext vyvolání, který tento příklad nepoužívá.

E1_SayHello/function.json

Soubor function.json pro funkci aktivity E1_SayHello je podobný té E1_HelloSequence, ale používá typ vazby activityTrigger místo typu vazby orchestrationTrigger.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ]
}

Poznámka:

Všechny funkce aktivit volané funkcí orchestrace musí používat activityTrigger vazbu.

Implementace E1_SayHello je poměrně triviální operace formátování řetězců.

E1_SayHello/init.py

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

Na rozdíl od funkce orchestrátoru funkce aktivity nepotřebuje žádné speciální nastavení. Vstup předaný funkcí orchestrátoru je přímo přístupný jako parametr funkce.

Aktivity v sadě Durable Task SDK dědí z TaskActivity<TInput, TOutput>:

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

[DurableTask]
public class SayHelloActivity : TaskActivity<string, string>
{
    private readonly ILogger<SayHelloActivity> _logger;

    public SayHelloActivity(ILogger<SayHelloActivity> logger)
    {
        _logger = logger;
    }

    public override Task<string> RunAsync(TaskActivityContext context, string name)
    {
        _logger.LogInformation("Activity SayHello called with name: {Name}", name);
        return Task.FromResult($"Hello {name}!");
    }
}

[DurableTask]
public class ProcessGreetingActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string greeting)
    {
        return Task.FromResult($"{greeting} How are you today?");
    }
}

[DurableTask]
public class FinalizeResponseActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string response)
    {
        return Task.FromResult($"{response} I hope you're doing well!");
    }
}

Použijte injekci závislostí k získání služeb, jako je ILogger. Přidejte atribut [DurableTask] pro registraci aktivity u pracovníka.

Aktivity v sadě Durable Task SDK jsou jednoduché funkce:

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

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

const processGreeting = async (_ctx: ActivityContext, greeting: string): Promise<string> => {
  return `${greeting} How are you today?`;
};

const finalizeResponse = async (_ctx: ActivityContext, response: string): Promise<string> => {
  return `${response} I hope you're doing well!`;
};

Na rozdíl od orchestrátorů můžou aktivity provádět vstupně-výstupní operace, jako jsou volání HTTP, databázové dotazy a přístup k souborům. Vstup se předá přímo jako parametr.

Aktivity v sadě Durable Task SDK jsou jednoduché funkce:

from durabletask import task

def say_hello(ctx: task.ActivityContext, name: str) -> str:
    """First activity that greets the user."""
    return f"Hello {name}!"

def process_greeting(ctx: task.ActivityContext, greeting: str) -> str:
    """Second activity that processes the greeting."""
    return f"{greeting} How are you today?"

def finalize_response(ctx: task.ActivityContext, response: str) -> str:
    """Third activity that finalizes the response."""
    return f"{response} I hope you're doing well!"

Na rozdíl od orchestrátorů můžou aktivity provádět vstupně-výstupní operace, jako jsou volání HTTP, databázové dotazy a přístup k souborům. Vstup se předá přímo jako parametr.

Aktivity v Java se definují pomocí TaskActivityFactory:

import com.microsoft.durabletask.TaskActivity;
import com.microsoft.durabletask.TaskActivityFactory;

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Reverse"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            StringBuilder builder = new StringBuilder(input);
            builder.reverse();
            return builder.toString();
        };
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Capitalize"; }

    @Override
    public TaskActivity create() {
        return ctx -> ctx.getInput(String.class).toUpperCase();
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "ReplaceWhitespace"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            return input.trim().replaceAll("\\s", "-");
        };
    }
})

Zaregistrujte každou aktivitu u tvůrce pracovních procesů pomocí addActivity. Aktivity můžou provádět vstupně-výstupní operace a vracet výsledky orchestrátoru.

Klient

Spusťte instanci funkce orchestrátoru z klientské funkce. HttpStart Ke spuštění instancí E1_HelloSequencepoužijte funkci aktivovanou protokolem HTTP .

public static class HttpStart
{
    [FunctionName("HttpStart")]
    public static async Task<HttpResponseMessage> Run(
        [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
        [DurableClient] IDurableClient 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}'.");

        return starter.CreateCheckStatusResponse(req, instanceId);
    }
}

Pokud chcete pracovat s orchestrátory, přidejte DurableClient vstupní vazbu. Pomocí klienta spusťte orchestraci a vraťte odpověď HTTP, která obsahuje adresy URL ke kontrole stavu nové orchestrace.

Programovací model V3

HttpStart/function.json

{
    "bindings": [
      {
        "authLevel": "anonymous",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "route": "orchestrators/{functionName}",
        "methods": ["post"]
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "starter",
        "type": "orchestrationClient",
        "direction": "in"
      }
    ],
    "disabled": false
  }

Pokud chcete pracovat s orchestrátory, přidejte durableClient vstupní vazbu.

HttpStart/index.js

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

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

    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};

Použijte df.getClient k získání objektu DurableOrchestrationClient. Pomocí klienta spusťte orchestraci a vraťte odpověď HTTP, která obsahuje adresy URL ke kontrole stavu nové orchestrace.

Programovací model V4

const df = require("durable-functions");
const { app } = require("@azure/functions");

app.http("httpStart", {
    route: "orchestrators/{orchestratorName}",
    extraInputs: [df.input.durableClient()],
    handler: async (request, context) => {
        const client = df.getClient(context);
        const body = await request.json();
        const instanceId = await client.startNew(request.params.orchestratorName, { input: body });

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

        return client.createCheckStatusResponse(request, instanceId);
    },
});

Pokud chcete spravovat orchestrátory a pracovat s nimi, přidejte durableClient vstupní vazbu. Při registraci funkce zadejte vazbu v extraInputs argumentu. durableClient Získejte vstup voláním df.input.durableClient().

Použijte df.getClient k získání objektu DurableClient. Pomocí klienta spusťte orchestraci a vraťte odpověď HTTP, která obsahuje adresy URL ke kontrole stavu nové orchestrace.

HttpStart/function.json

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "route": "orchestrators/{functionName}",
      "methods": [
        "post",
        "get"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

Aby funkce fungovala s orchestrátory, musí obsahovat durableClient vstupní vazbu.

HttpStart/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(req.route_params["functionName"], None, None)

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

    return client.create_check_status_response(req, instance_id)

Pomocí konstruktoru DurableOrchestrationClient vytvořte klienta Durable Functions. Pomocí klienta spusťte orchestraci a vraťte odpověď HTTP, která obsahuje adresy URL ke kontrole stavu nové orchestrace.

Spusťte orchestraci z klientské aplikace. Klient naplánuje orchestraci a může počkat na dokončení.

using System;
using Microsoft.DurableTask.Client;

// Create the client
var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule a new orchestration instance
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(GreetingOrchestration),
    input: "World");

Console.WriteLine($"Started orchestration with ID: {instanceId}");

// Wait for the orchestration to complete
OrchestrationMetadata result = await client.WaitForInstanceCompletionAsync(
    instanceId,
    getInputsAndOutputs: true);

Console.WriteLine($"Orchestration completed with result: {result.ReadOutputAs<string>()}");

Vytvořte DurableTaskClient pomocí připojovacího řetězce pro plánovač trvalých úloh. Slouží ScheduleNewOrchestrationInstanceAsync k zahájení orchestrace a WaitForInstanceCompletionAsync čekání na dokončení.

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

const connectionString =
  process.env.DURABLE_TASK_SCHEDULER_CONNECTION_STRING ||
  "Endpoint=http://localhost:8080;Authentication=None;TaskHub=default";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

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

// Wait for the orchestration to complete
const state = await client.waitForOrchestrationCompletion(instanceId, true, 30);
console.log(`Orchestration completed with result: ${state?.serializedOutput}`);

Vytvořte DurableTaskAzureManagedClientBuilder pomocí připojovacího řetězce pro plánovač trvalých úloh. Slouží scheduleNewOrchestration k zahájení orchestrace a waitForOrchestrationCompletion čekání na dokončení.

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Create the client
client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub_name,
    token_credential=credential
)

# Schedule a new orchestration instance
instance_id = client.schedule_new_orchestration(
    function_chaining_orchestrator,
    input="World"
)

print(f"Started orchestration with ID: {instance_id}")

# Wait for the orchestration to complete
result = client.wait_for_orchestration_completion(instance_id, timeout=60)

if result and result.runtime_status == "COMPLETED":
    print(f"Orchestration completed with result: {result.serialized_output}")

Připojí DurableTaskSchedulerClient se k Plánovači trvalých úloh. Slouží schedule_new_orchestration k zahájení orchestrace a wait_for_orchestration_completion čekání na dokončení.

import java.time.Duration;

import com.microsoft.durabletask.DurableTaskClient;
import com.microsoft.durabletask.NewOrchestrationInstanceOptions;
import com.microsoft.durabletask.OrchestrationMetadata;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerClientExtensions;

// Create the client
DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString)
    .build();

// Schedule a new orchestration instance
String instanceId = client.scheduleNewOrchestrationInstance(
    "ActivityChaining",
    new NewOrchestrationInstanceOptions().setInput("Hello, world!"));

System.out.println("Started orchestration with ID: " + instanceId);

// Wait for the orchestration to complete
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId,
    Duration.ofSeconds(30),
    true);

System.out.println("Orchestration completed with result: " + result.readOutputAs(String.class));

Pomocí connection string vytvořte DurableTaskClient. Slouží scheduleNewOrchestrationInstance k zahájení orchestrace a waitForInstanceCompletion čekání na dokončení.

Spusťte ukázku

Chcete-li spustit orchestraci E1_HelloSequence, odešlete tento požadavek HTTP POST do funkce HttpStart.

POST http://{host}/orchestrators/E1_HelloSequence

Poznámka:

Předchozí fragment kódu HTTP předpokládá, že soubor host.json ze vzorku odebere výchozí api/ předponu ze všech URL adres funkce spouštěče HTTP. Tuto konfiguraci najdete v ukázkovém souboruhost.json .

Pokud například spouštíte ukázku v aplikaci s funkcemi s názvem myfunctionapp, nahraďte {host} za myfunctionapp.azurewebsites.net.

Požadavek vrátí http 202 (zkrácený kvůli stručnosti):

HTTP/1.1 202 Accepted
Content-Length: 719
Content-Type: application/json; charset=utf-8
Location: http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

(...trimmed...)

Orchestrace fronty se spustí okamžitě. Pomocí adresy URL v Location záhlaví zkontrolujte stav spuštění.

GET http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

Odpověď zobrazuje stav orchestrace. Vzhledem k tomu, že se instance rychle dokončí, je často ve stavu Dokončeno a vrací odpověď, jako je tato (zkrácená kvůli stručnosti):

HTTP/1.1 200 OK
Content-Length: 179
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":null,"output":["Hello Tokyo!","Hello Seattle!","Hello London!"],"createdTime":"2017-06-29T05:24:57Z","lastUpdatedTime":"2017-06-29T05:24:59Z"}

Instance runtimeStatus je dokončena a output obsahuje serializovaný výsledek funkce orchestratoru.

Poznámka:

Implementujte podobnou počáteční logiku pro jiné typy triggerů, například queueTrigger, eventHubTriggernebo timerTrigger.

Zkontrolujte protokoly spuštění funkce. Funkce E1_HelloSequence se spustí a dokončí několikrát z důvodu chování přehrávání popsaného ve spolehlivosti orchestrace. Ale E1_SayHello se spustí pouze třikrát, protože provádění funkcí aktivity se neprovádí znovu.

Pokud chcete ukázku spustit, potřebujete:

Spusťte emulátor plánovače úloh Durable (pro místní vývoj):

docker run -d -p 8080:8080 -p 8082:8082 --name dts-emulator mcr.microsoft.com/dts/dts-emulator:latest

Spusťte pracovní proces ke zaregistrování orchestrátoru a aktivit.
Spusťte klienta a naplánujte orchestraci, poté počkejte na výsledek.

Výstup klienta zobrazuje zřetězený výsledek orchestrace:

Started orchestration with ID: abc123
Orchestration completed with result: "Hello World! How are you today? I hope you're doing well!"

Protokoly pracovních procesů ukazují, že každá aktivita se spouští v posloupnosti a předává její výstup další aktivitě.

Další kroky

Tato ukázka demonstruje jednoduchou orchestraci propojení funkcí. Dále implementujte model fan-out/fan-in.

Spustit ukázku fan-out/fan-in

Tato ukázka demonstruje jednoduchou orchestraci propojení funkcí. Dále prozkoumejte další vzory.

Začínáme se sadami SDK Durable Task

Kompletní příklady JavaScript SDK najdete v příkladech Durable Task JavaScript SDK.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-11

Sdílet prostřednictvím

Řetězení funkcí

Požadavky

Functions

Orchestrator

Activity

Klient

Spusťte ukázku

Další kroky

Váš názor

Další materiály