Pola penautan fungsi

Important

Dukungan akan berakhir untuk model dalam proses pada 10 November 2026. Kami sangat menyarankan agar Anda memindahkan aplikasi Anda ke model pekerja terisolasi untuk dukungan penuh.

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

C#

• Menyelesaikan artikel pengantar cepat
• Klon atau unduh proyek sampel dari GitHub
  • Sampel model terisolasi
  • Contoh model dalam proses

JavaScript

Model pemrograman V3

• Menyelesaikan artikel pengantar cepat
• Clone atau unduh proyek sampel dari GitHub

Model pemrograman V4

• Menyelesaikan artikel pengantar cepat
• Clone atau unduh proyek sampel dari GitHub

Python

• Menyelesaikan artikel pengantar cepat
• Clone atau unduh proyek sampel dari GitHub

PowerShell

• Menyelesaikan artikel pengantar cepat
• Clone atau unduh proyek sampel dari GitHub

Java

• Menyelesaikan artikel pengantar cepat

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.

Fungsi dalam contoh chaining

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.

Kode fungsi orkestrator

C#

Model pekerja terisolasi

[Function("E1_HelloSequence")]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext 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", "London"));

    return outputs;
}

Dalam model pekerja terisolasi, fungsi orkestrasi C# menyertakan parameter tipe TaskOrchestrationContext dari Microsoft.DurableTask paket. Gunakan objek konteks ini untuk memanggil fungsi aktivitas dan mengirimkan parameter input menggunakan metodenya CallActivityAsync .

Model dalam proses

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

Dalam model dalam proses, fungsi orkestrasi C# menyertakan parameter bertipe DurableOrchestrationContext, yang ada dalam Microsoft.Azure.WebJobs.Extensions.DurableTask rakitan. Gunakan objek konteks ini untuk memanggil fungsi aktivitas lain dan mengirimkan parameter input menggunakan metodenya CallActivityAsync .

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

JavaScript

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 fungsi orkestratornya:

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:

1. Fungsi orkestrator adalah fungsi generator.
2. Fungsi ini dibungkus sebagai panggilan ke dalam metode durable-functions dari modul orchestrator (di sini df).
3. 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:

1. Fungsi orkestrator adalah fungsi generator.
2. 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.

Python

Nota

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 binding input atau output lain diperlukan, gunakan binding tersebut dalam konteks fungsi activityTrigger yang dipanggil oleh orkestrator. Untuk informasi selengkapnya, lihat artikel Batasan kode fungsi orkestrator.

__init__.py

Berikut fungsi orkestratornya:

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:

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

Objek ini context memungkinkan Anda memanggil fungsi aktivitas lain dan mengirimkan parameter input menggunakan metodenya call_activity . 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.

PowerShell

Orchestrator memanggil Hello aktivitas tiga kali secara berurutan dengan nilai parameter yang berbeda. Nilai balik dari setiap panggilan dikumpulkan dalam $output array.

param($Context)

$output = @()

$output += Invoke-DurableActivity -FunctionName 'Hello' -Input 'Tokyo'
$output += Invoke-DurableActivity -FunctionName 'Hello' -Input 'London'
$output += Invoke-DurableActivity -FunctionName 'Hello' -Input 'Seattle'

$output

Java

@FunctionName("E1_HelloSequence")
public String helloSequence(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await();
    result += ", " + ctx.callActivity("SayHello", "London", String.class).await();
    result += ", " + ctx.callActivity("SayHello", "Seattle", String.class).await();
    return result;
}

Orkestraktor memanggil SayHello tiga kali secara berurutan dengan nilai parameter yang berbeda. Metode callActivity menjadwalkan eksekusi aktivitas, dan await() menunggu hasilnya. Nilai pengembalian dari setiap panggilan ditambahkan ke result string, yang dikembalikan di akhir fungsi.

Sumber contoh: Sampel HelloCities Java.

C#

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.

JavaScript

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.

Python

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.

PowerShell

Sampel ini ditampilkan untuk .NET, JavaScript, Java, dan Python.

Java

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.

Kode fungsi aktivitas

C#

Model pekerja terisolasi

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

Dalam model pekerja terisolasi, aktivitas menggunakan atribut dan ActivityTrigger dapat langsung mengikat ke tipe input yang diberikan orchestrator ke aktivitas.

Model dalam proses

[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 mengaitkan ke IDurableActivityContext, kaitkan langsung ke tipe yang Anda teruskan ke fungsi aktivitas. Contohnya:

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

JavaScript

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
}

Nota

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

Implementasinya E1_SayHello adalah operasi pemformatan string yang relatif sederhana.

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.

Python

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.

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

Nota

Semua fungsi aktivitas yang dipanggil oleh fungsi orkestrasi harus menggunakan binding tersebut activityTrigger .

Implementasinya E1_SayHello adalah operasi pemformatan string yang relatif sederhana.

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 kepadanya dapat diakses langsung sebagai parameter fungsi.

PowerShell

Aktivitas Hello menerima sebuah nama dan mengembalikan string sapaan:

param($name)

"Hello $name!"

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

Java

Aktivitas SayHello menerima sebuah nama dan mengembalikan string sapaan:

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

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

Sumber contoh: Sampel HelloCities Java.

C#

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.

JavaScript

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. Anda mengirimkan input langsung sebagai parameter.

Python

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. Anda mengirimkan input langsung sebagai parameter.

PowerShell

Sampel ini ditampilkan untuk .NET, JavaScript, Java, dan Python.

Java

Definisikan aktivitas dalam Java dengan 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.

Kode klien untuk memulai orkestrasi

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

C#

Model pekerja terisolasi

[Function("HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(
        AuthorizationLevel.Anonymous,
        "get",
        "post",
        Route = "orchestrators/{functionName}")] HttpRequestData request,
    [DurableClient] DurableTaskClient client,
    string functionName)
{
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(functionName);
    return await client.CreateCheckStatusResponseAsync(request, instanceId);
}

Dalam model pekerja terisolasi, gunakan DurableTaskClient untuk menjadwalkan orkestrasi dan mengembalikan respons HTTP dengan URL untuk mengelola instance baru.

Model dalam proses

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

Dalam model yang sedang diproses, tambahkan DurableClient binding input. Gunakan klien untuk memulai orkestrasi dan mengembalikan respons HTTP yang menyertakan URL untuk memeriksa status orkestrasi baru.

JavaScript

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.

Python

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.

PowerShell

using namespace System.Net

param($Request, $TriggerMetadata)

$FunctionName = $Request.Params.FunctionName
$InstanceId = Start-DurableOrchestration -FunctionName $FunctionName
Write-Host "Started orchestration with ID = '$InstanceId'"

$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
Push-OutputBinding -Name Response -Value $Response

Untuk berinteraksi dengan orkestrator, gunakan Start-DurableOrchestration untuk memulai orkestrasi dan New-DurableOrchestrationCheckStatusResponse mengembalikan respons HTTP yang mencakup URL untuk memeriksa status.

Java

@FunctionName("StartHelloSequence")
public HttpResponseMessage startHelloSequence(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Void> request,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("E1_HelloSequence");
Use an HTTP-triggered client function to start the Java chaining orchestration:

```java
@FunctionName("StartOrchestration")
public HttpResponseMessage startOrchestration(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS)
        HttpRequestMessage<Optional<String>> request,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("HelloCities");
    context.getLogger().info("Started orchestration with ID = '" + instanceId + "'.");
    return durableContext.createCheckStatusResponse(request, instanceId);
}

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

Sumber contoh: Sampel HelloCities Java.

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

C#

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.

JavaScript

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.

Python

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.

PowerShell

Sampel ini ditampilkan untuk .NET, JavaScript, Java, dan Python.

Java

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 string koneksi. Gunakan scheduleNewOrchestrationInstance untuk memulai orkestrasi dan waitForInstanceCompletion menunggu penyelesaian.

Jalankan sampel perangkaian fungsi

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

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

Nota

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.

Nota

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:

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

2. Mulai pekerja untuk mendaftarkan orkestrator dan aktivitas.

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