Penautan fungsi

Penautan fungsi adalah pola di mana Anda menjalankan urutan fungsi secara berurutan. Adalah umum untuk meneruskan output dari satu fungsi ke input berikutnya. Artikel ini menjelaskan urutan penautan yang Anda buat saat menyelesaikan panduan awal Durable Functions (C#, JavaScript, TypeScript, Python, PowerShell, atau Java). Pelajari selengkapnya di ringkasan Durable Functions.

Prasyarat

Menyelesaikan artikel pengantar cepat
Mengkloning atau mengunduh proyek sampel dari GitHub (menggunakan model dalam proses)

Penautan fungsi adalah pola di mana Anda menjalankan urutan aktivitas secara berurutan. Adalah umum untuk meneruskan output dari satu aktivitas ke input berikutnya. Artikel ini menjelaskan rangkaian penautan untuk Durable Task SDKs untuk .NET, JavaScript, Python, dan Java.

Functions

Artikel ini menjelaskan fungsi-fungsi ini di aplikasi sampel:

E1_HelloSequence: Fungsi orkestrator yang memanggil E1_SayHello beberapa kali secara berurutan. Ini menyimpan setiap output dan merekam hasilnya.
E1_SayHello: Fungsi aktivitas yang menambahkan "Halo" ke awal string.
HttpStart: Fungsi klien tahan lama yang dipicu HTTP yang memulai instans orkestrator.

Artikel ini menjelaskan komponen-komponen ini di aplikasi sampel:

GreetingOrchestration, , greetingOrchestratorfunction_chaining_orchestrator, atau ActivityChaining: Orkestrator yang memanggil beberapa aktivitas secara berurutan. Ini menyimpan setiap output dan merekam hasilnya.
Fungsi aktivitas: Aktivitas yang memproses input dan mengembalikan hasil. Setiap aktivitas melakukan transformasi sederhana pada input.
Klien: Aplikasi klien yang memulai instans orkestrator dan menunggu hasilnya.

Pengorkestra

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

Semua fungsi orkestrasi C# harus memiliki parameter jenis DurableOrchestrationContext, yang ada di rakitan Microsoft.Azure.WebJobs.Extensions.DurableTask. Objek konteks ini memungkinkan Anda memanggil fungsi aktivitas lain dan meneruskan parameter input menggunakan CallActivityAsync metodenya.

Kode memanggil E1_SayHello tiga kali secara berurutan dengan nilai parameter yang berbeda. Nilai yang dikembalikan dari setiap panggilan ditambahkan ke daftar outputs, yang akan dikembalikan di akhir fungsi.

Model pemrograman V3

function.json

Jika Anda mengembangkan di Visual Studio Code atau portal Azure, berikut file orkestrator function.json.

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

Pengaturan kunci adalah orchestrationTrigger jenis pengikatan. Semua fungsi orkestrator harus menggunakan jenis pemicu ini.

Peringatan

Untuk mengikuti aturan "tidak ada I/O" dalam fungsi orkestrator, jangan gunakan binding input atau output dengan binding pemicu orchestrationTrigger. Jika Anda memerlukan input atau output binding lainnya, gunakan dalam fungsi activityTrigger yang dipanggil oleh orkestrator. Untuk informasi selengkapnya, lihat batasan kode fungsi orkestrator.

index.js

Berikut adalah fungsi orkestrator:

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

Semua fungsi orkestrasi JavaScript harus menyertakan durable-functions modul. Ini adalah pustaka yang memungkinkan Anda menulis Durable Functions di JavaScript. Tiga perbedaan utama antara fungsi orkestrator dan fungsi JavaScript lainnya:

Fungsi orkestrator adalah fungsi generator.
Fungsi ini dibungkus sebagai panggilan ke dalam metode durable-functions dari modul orchestrator (di sini df).
Fungsi ini sinkron. Karena metode orchestrator memanggil context.done, fungsi mengembalikan.

Objek context berisi objek konteks df orkestrasi tahan lama yang memungkinkan Anda memanggil fungsi aktivitas lain dan meneruskan parameter input menggunakan callActivity metodenya. Kode memanggil E1_SayHello tiga kali secara berurutan dengan nilai parameter yang berbeda, menggunakan yield untuk menunjukkan eksekusi harus menunggu pada panggilan fungsi aktivitas asinkron untuk dikembalikan. Nilai yang dikembalikan dari setiap panggilan ditambahkan ke array outputs, yang dikembalikan di akhir fungsi.

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

Semua fungsi orkestrasi JavaScript harus menyertakan durable-functions modul. Modul ini memungkinkan Anda menulis Durable Functions di JavaScript. Untuk menggunakan model pemrograman simpul V4, Anda perlu menginstal v3.x versi durable-functions.

Dua perbedaan utama antara fungsi orkestrator dan fungsi JavaScript lainnya:

Fungsi orkestrator adalah fungsi generator.
Fungsi ini sinkron. Fungsi mengembalikan hasil.

Objek context berisi objek konteks df orkestrasi tahan lama yang memungkinkan Anda memanggil fungsi aktivitas lain dan meneruskan parameter input menggunakan callActivity metodenya. Kode memanggil sayHello tiga kali secara berurutan dengan nilai parameter yang berbeda, menggunakan yield untuk menunjukkan eksekusi harus menunggu pada panggilan fungsi aktivitas asinkron untuk dikembalikan. Nilai yang dikembalikan dari setiap panggilan ditambahkan ke array outputs, yang dikembalikan di akhir fungsi.

Catatan

Python Durable Functions hanya tersedia untuk runtime Functions 3.0.

function.json

Jika Anda menggunakan Visual Studio Code atau portal Azure untuk pengembangan, berikut adalah konten file function.json untuk fungsi orkestrator. Sebagian besar orkestrator function.json file terlihat hampir persis seperti ini.

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

Yang terpenting adalah jenis pengikatan orchestrationTrigger. Semua fungsi orkestrator harus menggunakan jenis pemicu ini.

Peringatan

Untuk mematuhi aturan "no I/O" fungsi pengatur, jangan gunakan pengikatan input atau output saat menggunakan pengikatan pemicu orchestrationTrigger. Jika pengikatan input atau output lain diperlukan, pengikatan tersebut seharusnya digunakan dalam konteks fungsi activityTrigger, yang disebut oleh orkestrator. Untuk informasi selengkapnya, lihat artikel Batasan kode fungsi orkestrator.

init.py

Berikut adalah fungsi orkestrator:

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)

Semua fungsi orkestrasi Python harus menyertakan paket durable-functions. Ini adalah pustaka yang memungkinkan Anda menulis Durable Functions di Python. Dua perbedaan utama antara fungsi orkestrator dan fungsi Python lainnya:

Fungsi orkestrator adalah fungsi generator.
File mendaftarkan fungsi orkestrator dengan menyatakan main = df.Orchestrator.create(<orchestrator function name>) di akhir file. Ini membantu membedakannya dari fungsi pembantu lain yang dideklarasikan dalam file.

Objek context ini memungkinkan Anda memanggil fungsi aktivitas lain dan meneruskan parameter input menggunakan call_activity metodenya. Kode memanggil E1_SayHello tiga kali secara berurutan dengan nilai parameter yang berbeda, menggunakan yield untuk menunjukkan eksekusi harus menunggu pada panggilan fungsi aktivitas asinkron untuk dikembalikan. Nilai yang dikembalikan dari setiap panggilan dikembalikan di akhir fungsi.

Kode ini menunjukkan orkestrator yang memanggil tiga aktivitas secara berurutan dan meneruskan setiap output ke aktivitas berikutnya:

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

Semua orkestrator .NET mewarisi dari TaskOrchestrator<TInput, TOutput>. Fungsi TaskOrchestrationContext memungkinkan Anda untuk memanggil aktivitas menggunakan CallActivityAsync. Kode memanggil tiga aktivitas secara berurutan, di mana setiap aktivitas menerima output aktivitas sebelumnya.

Kode berikut menunjukkan orkestrator yang memanggil tiga aktivitas secara berurutan:

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

Semua orkestrator JavaScript adalah fungsi generator (async function*) yang digunakan yield untuk memanggil aktivitas. Metode konteks callActivity orkestrasi menjadwalkan eksekusi aktivitas. Kode memanggil tiga aktivitas secara berurutan, meneruskan output setiap aktivitas ke aktivitas berikutnya.

Kode berikut menunjukkan orkestrator yang memanggil tiga aktivitas secara berurutan:

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

Semua orkestrator Python adalah fungsi generator yang menggunakan yield untuk memanggil aktivitas. Metode konteks call_activity orkestrasi menjadwalkan eksekusi aktivitas. Kode memanggil tiga aktivitas secara berurutan, meneruskan output setiap aktivitas ke aktivitas berikutnya.

Kode berikut menunjukkan orkestrator yang memanggil tiga aktivitas secara berurutan:

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

Dalam Java, orkestrator didefinisikan menggunakan TaskOrchestrationFactory. Metode konteks menjadwalkan callActivity eksekusi aktivitas, dan await() menunggu hasilnya. Kode memanggil tiga aktivitas secara berurutan, meneruskan output setiap aktivitas ke aktivitas berikutnya.

Activity

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

Aktivitas menggunakan ActivityTrigger atribut. Gunakan IDurableActivityContext untuk tindakan aktivitas, seperti membaca input dengan GetInput<T>.

E1_SayHello mengformat string sapaan.

Alih-alih mengikat ke IDurableActivityContext, ikat langsung ke tipe yang diteruskan ke fungsi aktivitas tersebut. Contohnya:

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

Model pemrograman V3

E1_SayHello/function.json

function.js file untuk fungsi aktivitas E1_SayHello mirip dengan yang E1_HelloSequence kecuali bahwa ia menggunakan jenis pengikatan activityTrigger selain jenis pengikatan orchestrationTrigger.

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

Catatan

Gunakan pengikatan activityTrigger untuk semua fungsi aktivitas yang dipanggil fungsi orkestrasi.

Implementasinya E1_SayHello adalah operasi pemformatan string yang relatif sepele.

E1_SayHello/index.js

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

Tidak seperti fungsi orkestrasi, fungsi aktivitas tidak memerlukan penyiapan khusus. Orkestrator meneruskan input pada objek context.bindings di bawah nama pengikatan activityTrigger—dalam hal ini, context.bindings.name. Atur nama pengikatan sebagai parameter fungsi yang diekspor untuk mengaksesnya secara langsung, seperti yang dilakukan sampel.

Model pemrograman V4

sayHello mengformat string sapaan.

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

const helloActivityName = "sayHello";

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

Tidak seperti fungsi orkestrasi, fungsi aktivitas tidak memerlukan penyiapan khusus. Orkestrator meneruskan input sebagai argumen pertama ke fungsi. Argumen kedua adalah konteks pemanggilan, yang tidak digunakan contoh ini.

E1_SayHello/function.json

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

Catatan

Semua fungsi aktivitas yang dipanggil oleh fungsi orkestrasi harus menggunakan activityTrigger ikatan.

Implementasinya E1_SayHello adalah operasi pemformatan string yang relatif sepele.

E1_SayHello/init.py

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

Tidak seperti fungsi orkestrator, fungsi aktivitas tidak memerlukan penyiapan khusus. Input yang diteruskan oleh fungsi orkestrator dapat diakses langsung sebagai parameter ke fungsi.

Aktivitas dalam Durable Task SDK diwarisi dari 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!");
    }
}

Gunakan injeksi dependensi untuk mendapatkan layanan seperti ILogger. Tambahkan atribut [DurableTask] untuk mendaftarkan aktivitas ke pekerja.

Aktivitas di Durable Task SDK adalah fungsi sederhana:

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!`;
};

Tidak seperti orkestrator, aktivitas dapat melakukan operasi I/O seperti panggilan HTTP, kueri database, dan akses file. Input diteruskan langsung sebagai sebuah parameter.

Aktivitas di Durable Task SDK adalah fungsi sederhana:

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

Tidak seperti orkestrator, aktivitas dapat melakukan operasi I/O seperti panggilan HTTP, kueri database, dan akses file. Input diteruskan langsung sebagai sebuah parameter.

Aktivitas di Java didefinisikan menggunakan 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", "-");
        };
    }
})

Daftarkan setiap aktivitas dengan builder pekerja dengan menggunakan addActivity. Aktivitas dapat melakukan operasi I/O dan mengembalikan hasil ke orkestrator.

Klien

Mulai instans fungsi orkestrator dari fungsi klien. Gunakan fungsi HTTP yang dipicu HttpStart untuk memulai instans E1_HelloSequence.

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

Untuk berinteraksi dengan orkestrator, tambahkan pengikatan DurableClient input. Gunakan klien untuk memulai orkestrasi dan mengembalikan respons HTTP yang menyertakan URL untuk memeriksa status orkestrasi baru.

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

Untuk berinteraksi dengan orkestrator, tambahkan pengikatan durableClient input.

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

Gunakan df.getClient untuk mendapatkan DurableOrchestrationClient objek. Gunakan klien untuk memulai orkestrasi dan mengembalikan respons HTTP yang menyertakan URL untuk memeriksa status orkestrasi baru.

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

Untuk mengelola dan berinteraksi dengan orkestrator, tambahkan binding input durableClient. Tentukan pengikatan dalam extraInputs argumen saat Anda mendaftarkan fungsi. Dapatkan input durableClient dengan memanggil df.input.durableClient().

Gunakan df.getClient untuk mendapatkan DurableClient objek. Gunakan klien untuk memulai orkestrasi dan mengembalikan respons HTTP yang menyertakan URL untuk memeriksa status orkestrasi baru.

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

Untuk berinteraksi dengan orkestrator, fungsi harus menyertakan durableClient pengikatan input.

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)

Gunakan konstruktor DurableOrchestrationClient untuk membuat klien Durable Functions. Gunakan klien untuk memulai orkestrasi dan mengembalikan respons HTTP yang menyertakan URL untuk memeriksa status orkestrasi baru.

Mulai orkestrasi dari aplikasi klien. Klien menjadwalkan orkestrasi dan dapat menunggu penyelesaian.

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

Buat DurableTaskClient dengan menggunakan string koneksi ke Durable Task Scheduler. Gunakan ScheduleNewOrchestrationInstanceAsync untuk memulai orkestrasi dan WaitForInstanceCompletionAsync menunggu penyelesaian.

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

Buat DurableTaskAzureManagedClientBuilder dengan menggunakan string koneksi ke Durable Task Scheduler. Gunakan scheduleNewOrchestration untuk memulai orkestrasi dan waitForOrchestrationCompletion menunggu penyelesaian.

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

Menyambungkan DurableTaskSchedulerClient ke Durable Task Scheduler. Gunakan schedule_new_orchestration untuk memulai orkestrasi dan wait_for_orchestration_completion menunggu penyelesaian.

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

Buat DurableTaskClient dengan menggunakan connection string. Gunakan scheduleNewOrchestrationInstance untuk memulai orkestrasi dan waitForInstanceCompletion menunggu penyelesaian.

Jalankan sampel

Untuk menjalankan E1_HelloSequence orkestrasi, kirim permintaan HTTP POST ini ke HttpStart fungsi .

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

Catatan

Cuplikan HTTP sebelumnya mengasumsikan file host.json sampel menghapus awalan default api/ dari semua URL fungsi pemicu HTTP. Temukan konfigurasi ini dalam file host.json sampel.

Misalnya, jika Anda menjalankan sampel di aplikasi fungsi bernama myfunctionapp, ganti {host} dengan myfunctionapp.azurewebsites.net.

Permintaan mengembalikan HTTP 202 (dipangkas untuk ringkasnya):

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

Antrean orkestrasi mulai berjalan segera. Gunakan URL di Location header untuk memeriksa status eksekusi.

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

Tanggapan menunjukkan status orkestrasi. Karena selesai dengan cepat, instans sering dalam keadaan Selesai dan mengembalikan respons seperti ini (dipangkas untuk brevity):

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

Instans runtimeStatusSelesai, dan output berisi hasil serial JSON dari eksekusi fungsi orkestrator.

Catatan

Terapkan logika pemula serupa untuk jenis pemicu lainnya, seperti queueTrigger, eventHubTrigger, atau timerTrigger.

Tinjau log eksekusi fungsi. Fungsi E1_HelloSequence dimulai dan selesai beberapa kali karena perilaku pemutaran ulang yang dijelaskan dalam keandalan orkestrasi. Tetapi E1_SayHello hanya berjalan tiga kali karena eksekusi fungsi aktivitas tidak diputar ulang.

Untuk menjalankan sampel, Anda memerlukan:

Mulai emulator Durable Task Scheduler (untuk pengembangan lokal):

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

Mulai pekerja untuk mendaftarkan orkestrator dan aktivitas.
Jalankan klien untuk menjadwalkan orkestrasi dan menunggu hasilnya.

Output klien menunjukkan hasil orkestrasi berantai:

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

Log pekerja menunjukkan setiap aktivitas berjalan secara berurutan dan meneruskan outputnya ke aktivitas berikutnya.

Langkah berikutnya

Sampel ini menunjukkan orkestrasi rantai fungsi sederhana. Selanjutnya, terapkan pola fan-out/fan-in.

Menjalankan sampel Fan-out/fan-in

Sampel ini menunjukkan orkestrasi rantai fungsi sederhana. Selanjutnya, jelajahi lebih banyak pola.

Mulai menggunakan Durable Task SDK

Untuk contoh JavaScript SDK lengkap, lihat sampel SDK JavaScript Tugas Tahan Lama.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-03-11

Bagikan melalui

Penautan fungsi

Prasyarat

Functions

Pengorkestra

Activity

Klien

Jalankan sampel

Langkah berikutnya

Saran dan Komentar

Sumber Daya Tambahan: