Orkestrasi tahan lama

Orkestrasi tahan lama menggunakan fungsi orkestrator untuk mengoordinasikan eksekusi fungsi lain dalam alur kerja yang andal dan berjalan lama yang ditentukan sepenuhnya dalam kode. Fungsi orkestrator memiliki karakteristik berikut:

• Mereka mendefinisikan alur kerja dengan menggunakan kode prosedural. Tidak diperlukan skema atau desainer deklaratif.
• Mereka memanggil fungsi lain secara sinkron dan asinkron. Anda dapat menyimpan output dari fungsi yang dipanggil ke variabel lokal.
• Mereka secara otomatis memeriksa kemajuan eksekusi saat fungsi memanggil await operator OR yield , sehingga proses tidak kehilangan status lokal saat didaur ulang atau VM di-reboot.
• Mereka mendukung proses jangka panjang. Total masa pakai instans orkestrasi dapat berupa detik, hari, atau bulan, atau Anda dapat mengonfigurasi instans agar tidak pernah berakhir.

Artikel ini memberikan gambaran umum tentang orkestrasi tahan lama, termasuk identitas orkestrasi, sumber peristiwa, riwayat eksekusi, dan pola alur kerja umum seperti sub-orkestrasi, timer tahan lama, dan penanganan kesalahan.

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.

Untuk informasi tentang jenis fungsi yang tersedia di aplikasi Durable Functions, lihat model pemrograman Tugas Durable.

Petunjuk / Saran

Jika Anda menggunakan C# dengan model pekerja terisolasi .NET, Anda dapat menulis orkestrasi dengan menggunakan pendekatan berbasis fungsi (metode statis dengan [Function] atribut) atau pendekatan berbasis kelas (kelas yang mewarisi dari TaskOrchestrator<TInput, TOutput>). Pendekatan berbasis kelas memerlukan paket generator sumber Microsoft.DurableTask.Generators dan menyajikan pemanggilan yang sangat terketik. Untuk informasi selengkapnya, lihat Generator sumber dan sintaks berbasis kelas. Contoh kode C# dalam artikel ini menunjukkan kedua pendekatan.

Durable Task SDK menyediakan kemampuan orkestrator yang sama dengan Durable Functions untuk membangun alur kerja yang andal dan berjalan lama dengan pemrosesan paralel dan koordinasi berbasis peristiwa. Tidak seperti Durable Functions, orkestrasi Durable Task SDK berjalan sebagai aplikasi mandiri yang didukung oleh Durable Task Scheduler.

Orkestrasi Identitas

Setiap instans orkestrasi memiliki pengidentifikasi instans, juga dikenal sebagai ID instans. Secara default, setiap ID instans adalah pengidentifikasi unik global (GUID) yang dibuat secara otomatis. Namun, Anda dapat menggunakan nilai string apa pun yang dihasilkan pengguna sebagai ID instance. Setiap ID instans orkestrasi harus unik dalam hub tugas.

Aturan berikut berlaku untuk ID instans:

• Mereka harus memiliki jumlah antara 1 dan 100 karakter.
• Mereka tidak boleh memulai dengan @.
• Mereka tidak boleh berisi /, , \#, atau ? karakter.
• Mereka tidak boleh berisi karakter kontrol.

Nota

Gunakan ID instans yang dibuat secara otomatis jika memungkinkan. Gunakan ID instans yang dibuat oleh pengguna untuk skenario yang memiliki pemetaan satu banding satu antara instans orkestrasi dan entitas eksternal yang spesifik untuk aplikasi, seperti pesanan pembelian atau dokumen.

Nota

Penegakan aturan pembatasan karakter yang sebenarnya dapat bervariasi tergantung pada penyedia penyimpanan yang digunakan aplikasi. Untuk membantu memastikan perilaku dan kompatibilitas yang benar, ikuti aturan ID instans sebelumnya.

ID instans orkestrasi merupakan parameter yang dibutuhkan untuk sebagian besar operasi manajemen instans. ID Instance juga penting untuk diagnostik sistem. Misalnya, Anda menggunakannya saat menelusuri data pelacakan orkestrasi di Application Insights untuk tujuan pemecahan masalah atau analitik. Untuk alasan ini, simpan ID instans yang dihasilkan ke lokasi eksternal yang memudahkan untuk mereferensikannya nanti, seperti database atau log aplikasi.

ID instans orkestrasi merupakan parameter yang dibutuhkan untuk sebagian besar operasi manajemen instans. ID instans juga penting untuk diagnostik, jadi simpan ID instans yang dihasilkan ke lokasi eksternal yang memudahkan untuk mereferensikannya nanti, seperti database atau log aplikasi.

Reliability

Fungsi orkestrator menggunakan pola desain event sourcing untuk mempertahankan status eksekusinya dengan andal. Alih-alih secara langsung menyimpan status orkestrasi saat ini, Kerangka Kerja Tugas Tahan Lama menggunakan penyimpanan khusus tambahan untuk merekam serangkaian tindakan lengkap yang diambil orkestrasi fungsi. Penyimpanan khusus tambahan memiliki banyak manfaat dibandingkan dengan mencadangkan status runtime penuh. Manfaatnya termasuk peningkatan performa, skalabilitas, dan responsivitas. Anda juga mendapatkan konsistensi akhir untuk data transaksi, jejak audit penuh, dan riwayat. Jejak audit mendukung tindakan kompensasi yang andal.

Kerangka Kerja Tugas Tahan Lama menggunakan pencatatan peristiwa secara transparan. Di balik layar, fungsi orkestrator menggunakan operator di C# dan operator /> .await() pada suatu tugas mengembalikan kontrol ke dispatcher melalui instance kustom Throwable. Dispatcher kemudian mencatat tindakan baru yang dijadwalkan oleh fungsi orkestrator ke dalam penyimpanan. Contoh tindakan termasuk memanggil satu atau beberapa fungsi anak atau menjadwalkan timer yang tahan lama. Aksi commit transparan memperbarui riwayat eksekusi instans orkestrasi dengan menambahkan semua peristiwa baru ke penyimpanan, seperti log yang hanya dapat ditambahkan. Demikian pula, aksi komit membuat pesan di penyimpanan untuk menjadwalkan pekerjaan sesungguhnya. Pada titik ini, fungsi orkestrator dapat dibebaskan dari memori.

Anda dapat menggunakan salah satu penyedia penyimpanan yang tersedia sebagai runtime state store.

Ketika fungsi orkestrasi mendapatkan lebih banyak pekerjaan yang harus dilakukan (misalnya, pesan respons diterima atau timer tahan lama kedaluwarsa), orkestrator bangun dan menjalankan kembali seluruh fungsi dari awal untuk membangun kembali status lokal. Selama pemutaran ulang, jika kode mencoba memanggil fungsi (atau melakukan pekerjaan asinkron lainnya), Kerangka Kerja Tugas Tahan Lama berkonsultasi dengan riwayat eksekusi orkestrasi saat ini. Jika menemukan bahwa aktivitas sudah dijalankan dan menghasilkan hasil, aktivitas akan memutar ulang hasil fungsi tersebut, dan kode orkestrator terus berjalan. Pemutaran ulang berlanjut hingga kode fungsi selesai atau sampai menjadwalkan pekerjaan asinkron baru.

Nota

Agar pola pemutaran ulang berfungsi dengan benar dan andal, kode fungsi orkestrator harus deterministik. Kode orkestrator nondeterministik dapat mengakibatkan kesalahan runtime atau perilaku tak terduga lainnya. Untuk informasi selengkapnya tentang pembatasan kode untuk fungsi orkestrator, lihat Batasan kode fungsi orkestrator.

Nota

Jika fungsi orkestrator memancarkan pesan log, perilaku pemutaran ulang dapat menyebabkan pesan log duplikat dipancarkan. Untuk mempelajari mengapa perilaku ini terjadi dan cara mengatasinya, lihat bagian Logging yang aman untuk pemutaran ulang.

Riwayat orkestrasi

Perilaku event-sourcing dari Durable Task Framework digabungkan erat dengan kode fungsi orkestrator yang Anda tulis. Misalkan Anda memiliki fungsi orkestrator penautan aktivitas, seperti contoh berikut.

C#

Model pekerja terisolasi

[Function("HelloCities")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var outputs = new List<string>();

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

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

Model berbasis kelas (pekerja terisolasi)

Pendekatan berbasis kelas menggunakan generator sumber dan memerlukan paket NuGet Microsoft.DurableTask.Generators .

using Microsoft.DurableTask;

[DurableTask]
public class HelloCities : TaskOrchestrator<object?, List<string>>
{
    public override async Task<List<string>> RunAsync(
        TaskOrchestrationContext context, object? input)
    {
        var outputs = new List<string>();

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

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

Model dalam proses

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

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

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

JavaScript

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

df.app.orchestration("helloSequence", function* (context) {
    const output = [];
    output.push(yield context.df.callActivity("sayHello", "Tokyo"));
    output.push(yield context.df.callActivity("sayHello", "Seattle"));
    output.push(yield context.df.callActivity("sayHello", "London"));

    // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
    return output;
});

Python

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

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

PowerShell

param($Context)

$output = @()

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

$output

Java

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

C#

using Microsoft.DurableTask;

[DurableTask]
public class HelloCities : TaskOrchestrator<object?, List<string>>
{
    public override async Task<List<string>> RunAsync(TaskOrchestrationContext context, object? input)
    {
        var outputs = new List<string>();

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

        return outputs;
    }
}

JavaScript

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

const helloCities: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const result1 = yield ctx.callActivity(sayHello, "Tokyo");
    const result2 = yield ctx.callActivity(sayHello, "Seattle");
    const result3 = yield ctx.callActivity(sayHello, "London");
    return [result1, result2, result3];
};

Python

from durabletask import task

def hello_cities(ctx: task.OrchestrationContext, _):
    result1 = yield ctx.call_activity("say_hello", input="Tokyo")
    result2 = yield ctx.call_activity("say_hello", input="Seattle")
    result3 = yield ctx.call_activity("say_hello", input="London")
    return [result1, result2, result3]

PowerShell

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

Java

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

public class HelloCities implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String result = "";
        result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
        result += ctx.callActivity("SayHello", "Seattle", String.class).await() + ", ";
        result += ctx.callActivity("SayHello", "London", String.class).await();
        ctx.complete(result);
    }
}

Setiap kali Anda menjadwalkan fungsi aktivitas, Durable Task Framework menyimpan status eksekusi fungsi di berbagai titik pemeriksaan. Di setiap titik pemeriksaan, kerangka kerja menyimpan status ke backend penyimpanan yang tahan lama. Status ini adalah riwayat orkestrasi.

Tabel riwayat

Di setiap checkpoint, Kerangka Tugas Tahan Lama melakukan tindakan berikut:

• Menyimpan riwayat eksekusi ke penyimpanan tahan lama.
• Mengantrekan pesan untuk fungsi yang ingin dipanggil orkestrator.
• Mengantrekan pesan untuk orkestrator itu sendiri, seperti pesan timer yang tahan lama dan dapat dipertahankan.

Ketika checkpoint selesai, framework akan menghapus fungsi orchestrator dari memori sampai ada pekerjaan lebih lanjut yang harus dilakukan.

Nota

Azure Storage tidak memberikan jaminan transaksional tentang konsistensi data antara penyimpanan tabel dan antrean saat menyimpan data. Untuk menangani kegagalan, penyedia Durable Functions Azure Storage menggunakan pola konsistensi akhir, seperti Command and Query Responsibility Segregation (CQRS). Penyedia penyimpanan alternatif menawarkan jaminan konsistensi yang lebih kuat:

• Durable Task Scheduler, opsi yang direkomendasikan untuk dikelola Azure, menyimpan status orkestrasi dalam layanan backend terkelola yang menghindari model koordinasi table-and-queue yang digunakan oleh Azure Storage.
• Penyedia penyimpanan Durable Functions Microsoft SQL Server (MSSQL) memungkinkan konsistensi data yang kuat melalui backup/restore dan failover.

Saat fungsi yang ditampilkan sebelumnya selesai, riwayatnya terlihat seperti data dalam tabel berikut di Table Storage. Entri disingkat untuk ilustrasi.

PartitionKey (InstanceId)	JenisAcara	Penanda Waktu	Input	Nama	Result	Kedudukan
eaee885b	PelaksanaanDimulai	2021-05-05T18:45:28.852Z	nol	Halo Kota
eaee885b	OrkestratorStarted	2021-05-05T18:45:32.362Z
eaee885b	Tugas Terjadwal	2021-05-05T18:45:32.670Z		SayHello
eaee885b	OrkestratorSelesai	2021-05-05T18:45:32.670Z
eaee885b	TugasSelesai	2021-05-05T18:45:34.201Z			"""Halo Tokyo!"""
eaee885b	OrkestratorStarted	2021-05-05T18:45:34.232Z
eaee885b	Tugas Terjadwal	2021-05-05T18:45:34.435Z		SayHello
eaee885b	OrkestratorSelesai	2021-05-05T18:45:34.435Z
eaee885b	TugasSelesai	2021-05-05T18:45:34.763Z			"""Halo Seattle!"""
eaee885b	OrkestratorStarted	2021-05-05T18:45:34.857Z
eaee885b	Tugas Terjadwal	2021-05-05T18:45:34.857Z		SayHello
eaee885b	OrkestratorSelesai	2021-05-05T18:45:34.857Z
eaee885b	TugasSelesai	2021-05-05T18:45:34.919Z			"""Halo London!"""
eaee885b	OrkestratorStarted	2021-05-05T18:45:35.032Z
eaee885b	OrkestratorSelesai	2021-05-05T18:45:35.044Z
eaee885b	Pelaksanaan Selesai	2021-05-05T18:45:35.044Z			"[""Hello Tokyo!"","Hello Seattle!",""Hello London!""]"	Selesai

Kolom tabel berisi nilai berikut:

• PartitionKey: ID instans orkestrasi.
• EventType: Jenis peristiwa. Untuk deskripsi terperinci tentang semua jenis peristiwa riwayat, lihat Peristiwa Riwayat Kerangka Kerja Tugas Tahan Lama.
• Tanda waktu: Tanda waktu Waktu Universal Terkoordinasi dari peristiwa sejarah.
• Input: Input fungsi yang diformat JSON.
• Nama: Nama fungsi yang dipanggil.
• Hasil: Output dari fungsi tersebut, khususnya nilai pengembaliannya.

Peringatan

Tabel ini berguna sebagai alat penelusuran kesalahan, tetapi format dan kontennya mungkin berubah seiring berkembangnya ekstensi Durable Functions.

Setiap kali fungsi dilanjutkan setelah menunggu tugas selesai, Kerangka Kerja Tugas Tahan Lama menjalankan ulang fungsi orkestrator dari awal. Pada setiap eksekusi ulang, ia berkonsultasi dengan riwayat eksekusi untuk menentukan apakah tugas asinkron saat ini selesai. Jika riwayat eksekusi menunjukkan bahwa tugas sudah selesai, kerangka kerja memutar ulang output tugas tersebut dan melanjutkan ke tugas berikutnya. Proses ini berlanjut hingga seluruh riwayat eksekusi diputar ulang. Setelah riwayat eksekusi saat ini diputar ulang, variabel lokal dipulihkan ke nilai sebelumnya.

Fitur dan pola

Bagian berikut menjelaskan fitur dan pola fungsi orkestrator.

Sub-orkestrasi pada fungsi orkestrator

Fungsi orchestrator dapat memanggil fungsi aktivitas, tetapi mereka juga dapat memanggil fungsi orchestrator lainnya. Misalnya, Anda dapat membangun orkestrasi yang lebih besar dari pustaka fungsi orkestrator. Atau, Anda dapat menjalankan beberapa instans fungsi orkestrator secara paralel.

Untuk informasi selengkapnya dan contoh, lihat Sub-orkestrasi dalam Durable Functions (Azure Functions).

Timer tahan lama

Orkestrasi dapat menjadwalkan timer tahan lama untuk menerapkan penundaan atau untuk menyiapkan penanganan batas waktu pada tindakan asinkron. Gunakan timer tahan lama dalam fungsi orkestrator alih-alih API bahasa asli sleep .

Untuk informasi selengkapnya dan contoh, lihat Timers di Durable Functions (Azure Functions).

Peristiwa eksternal

Fungsi orkestrator dapat menunggu peristiwa eksternal untuk memperbarui instans orkestrasi. Fitur Durable Functions ini sering berguna untuk menangani interaksi manusia atau panggilan balik eksternal lainnya.

Untuk informasi selengkapnya dan misalnya, lihat Menangani peristiwa eksternal di Durable Functions (Azure Functions).

Penanganan kesalahan

Fungsi orkestrator dapat menggunakan fitur penanganan kesalahan bahasa pemrograman. Kode orkestrasi mendukung pola yang sudah ada seperti try/catch.

Fungsi orkestrator juga dapat menambahkan kebijakan pengulangan ke fungsi aktivitas atau sub-orkestrator yang mereka panggil. Jika fungsi aktivitas atau sub-orkestrator gagal dengan pengecualian, kebijakan coba lagi yang ditentukan dapat secara otomatis menunda dan mencoba kembali eksekusi hingga jumlah waktu yang ditentukan.

Nota

Jika ada pengecualian yang tidak tertangani dalam fungsi orkestrator, instans orkestrasi selesai dalam keadaan Failed . Anda tidak bisa mencoba lagi instance orkestrasi setelah instance tersebut gagal.

Untuk informasi selengkapnya dan untuk contoh, lihat Penanganan Kesalahan dalam Durable Functions (Azure Functions).

Bagian kritis (Durable Functions 2.x)

Instans orkestrasi berutas tunggal, sehingga kondisi balapan tidak menjadi perhatian dalam orkestrasi. Namun, kondisi kompetitif dimungkinkan ketika orkestrasi tersebut berinteraksi dengan sistem eksternal. Untuk mengurangi kondisi konkurensi saat berinteraksi dengan sistem eksternal, fungsi orkestrator dapat menetapkan bagian kritis dengan menggunakan mekanisme penguncian. .NET dan JavaScript mendukung bagian kritis.

Kode sampel berikut menunjukkan fungsi orkestrator yang menentukan bagian penting. Memasuki bagian kritis memerlukan pengiriman satu atau lebih referensi ke entitas tahan lama, yang mengelola status kunci secara permanen. Hanya satu instans orkestrasi ini yang dapat menjalankan kode di bagian penting pada satu waktu.

C#

Gunakan metode LockAsync untuk memasukkan bagian kritis.

[FunctionName("Synchronize")]
public static async Task Synchronize(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var lockId = new EntityId("LockEntity", "MyLockIdentifier");
    using (await context.LockAsync(lockId))
    {
        // Critical section. Only one orchestration can enter at a time.
    }
}

Dalam orkestrasi pekerja terisolasi .NET, gunakan TaskOrchestrationContext.Entities.LockEntitiesAsync (lihat pemetaan API terisolasi .NET).

Metode LockAsync memperoleh kunci tahan lama dan mengembalikan IDisposable yang mengakhiri bagian kritis saat dilepas. Hasil ini IDisposable dapat digunakan bersama dengan using blok untuk mendapatkan representasi sintaks dari bagian kritis. Saat fungsi orkestrator memasuki bagian penting, hanya satu instans yang dapat menjalankan blok kode tersebut. Instans lain yang mencoba memasuki bagian penting diblokir hingga instans sebelumnya keluar dari bagian penting.

JavaScript

Gunakan metode context.df.lock untuk memasukkan bagian kritis.

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

df.app.orchestration("synchronize", function* (context) {
    const lockId = new df.EntityId("LockEntity", "MyLockIdentifier");
    const lock = yield context.df.lock(lockId);
    try {
        // Critical section. Only one orchestration can enter at a time.
    } finally {
        lock.release();
    }
});

Metode context.df.lock ini memperoleh kunci persisten dan mengembalikan DurableLock. Panggil release untuk mengakhiri bagian kritis, atau biarkan runtime melepaskan kunci secara otomatis saat orkestrasi berakhir. Saat fungsi orkestrator memasuki bagian penting, hanya satu instans yang dapat menjalankan blok kode tersebut. Instans lain yang mencoba memasuki bagian penting diblokir hingga instans sebelumnya keluar dari bagian penting.

Nota

context.df.lock API memerlukan paket npm 3.4.0 versi durable-functions atau yang lebih baru dan ekstensi 3.13.0 versi Microsoft.Azure.WebJobs.Extensions.DurableTask atau yang lebih baru.

Python

Nota

Python saat ini tidak mendukung bagian kritis.

PowerShell

Nota

Bagian kritis saat ini tidak didukung di PowerShell.

Java

Nota

Java saat ini tidak mendukung bagian kritis.

Fitur bagian penting juga berguna untuk mengoordinasikan perubahan pada entitas yang tahan lama. Untuk informasi selengkapnya tentang bagian penting, lihat Koordinasi entitas.

Nota

Bagian kritis tersedia di Durable Functions 2.x untuk orkestrasi .NET dan JavaScript. Untuk .NET, API berbeda menurut model: model in-process menggunakan IDurableOrchestrationContext.LockAsync, sedangkan model isolated menggunakan TaskOrchestrationContext.Entities.LockEntitiesAsync.

Panggilan ke titik akhir HTTP (Durable Functions 2.x)

Fungsi Orchestrator tidak dapat melakukan operasi I/O, seperti yang dijelaskan dalam constraint kode fungsi Orchestrator. Untuk mengatasi keterbatasan ini, bungkus kode apa pun yang perlu melakukan operasi I/O dalam fungsi aktivitas. Orkestrasi yang berinteraksi dengan sistem eksternal sering menggunakan fungsi aktivitas untuk melakukan panggilan HTTP dan mengembalikan hasilnya ke orkestrasi.

Untuk menyederhanakan pola umum ini, fungsi orkestrator dapat menggunakan CallHttpAsync metode untuk memanggil API HTTP secara langsung.

C#

Model pekerja terisolasi

[Function("CheckSiteAvailable")]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Make an HTTP GET request to the specified endpoint.
    DurableHttpResponse response = await context.CallHttpAsync(
        method: HttpMethod.Get,
        uri: url,
        content: null,
        retryOptions: null);

    if ((int)response.StatusCode == 400)
    {
        // Handle error codes.
    }
}

Model dalam proses

[FunctionName("CheckSiteAvailable")]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Make an HTTP GET request to the specified endpoint.
    DurableHttpResponse response = 
        await context.CallHttpAsync(HttpMethod.Get, url);

    if ((int)response.StatusCode == 400)
    {
        // Handle error codes.
    }
}

JavaScript

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

df.app.orchestration("checkSiteAvailable", function* (context) {
    const url = context.df.getInput();
    var res = yield context.df.callHttp({ method: "GET", url });
    if (res.statusCode >= 400) {
        // Handle error codes.
    }
});

Python

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    url = context.get_input()
    res = yield context.call_http('GET', url)
    if res['statusCode'] >= 400:
        # Handle error codes.

PowerShell

PowerShell saat ini tidak mendukung fitur ini.

Java

Java saat ini tidak mendukung fitur ini.

Selain mendukung pola permintaan dan respons dasar, metode ini mendukung penanganan otomatis pola polling HTTP 202 asinkron yang umum. Ini juga mendukung autentikasi dengan layanan eksternal dengan menggunakan identitas terkelola.

Untuk informasi selengkapnya dan untuk contoh terperinci, lihat fitur HTTP.

Nota

Memanggil titik akhir HTTP secara langsung dari fungsi orkestrator tersedia di Durable Functions 2.0 dan versi-versi selanjutnya.

Mengoper beberapa parameter ke fungsi aktivitas

Anda tidak dapat langsung mengirimkan beberapa parameter ke fungsi aktivitas. Berikan array yang berisi objek atau objek komposit sebagai gantinya.

C#

Model pekerja terisolasi

Di .NET, gunakan jenis komposit yang dapat diserialisasikan, seperti rekaman, untuk meneruskan beberapa parameter.

public record CourseInfo(string Major, int UniversityYear);

[Function("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    int universityYear = context.GetInput<int>();
    CourseInfo courseInfo = new("ComputerScience", universityYear);
    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations", courseInfo);
    return courseRecommendations;
}

Model dalam proses

Di .NET, gunakan jenis komposit yang dapat diserialisasi untuk meneruskan beberapa parameter. Sampel berikut menggunakan kelas sederhana:

public class CourseInfo
{
    public string Major { get; set; }
    public int UniversityYear { get; set; }
}

[FunctionName("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var input = new CourseInfo
    {
        Major = "ComputerScience",
        UniversityYear = context.GetInput<int>()
    };

    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations",
        input);
    return courseRecommendations;
}

JavaScript

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

df.app.orchestration("getWeatherOrchestrator", function* (context) {
    const location = {
        city: "Seattle",
        state: "WA",
    };
    const weather = yield context.df.callActivity("getWeather", location);

    // ...
});

df.app.activity("getWeather", {
    handler: async (input) => {
        const { city, state } = input; // Destructure properties into variables.
        // ...
    }
});

Python

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    location = {'city': 'Seattle', 'state': 'WA'}

    weather = yield context.call_activity("GetWeather", location)
    # ...

@app.activity_trigger(input_name="location")
def GetWeather(location):
    city = location['city']
    state = location['state']
    return f"Hello {city}, {state}!"

PowerShell

param($Context)

$location = @{
    City = 'Seattle'
    State  = 'WA'
}

Invoke-DurableActivity -FunctionName 'GetWeather' -Input $location

# ...

Java

@FunctionName("GetWeatherOrchestrator")
public String getWeatherOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    var location = new Location();
    location.city = "Seattle";
    location.state = "WA";
    String weather = ctx.callActivity("GetWeather", location, String.class).await();
    return weather;
}

C#

Di .NET, gunakan tipe record atau tuple untuk meneruskan beberapa parameter sebagai satu objek gabungan.

using Microsoft.DurableTask;

public record LocationInfo(string City, string State);

[DurableTask]
public class GetWeatherOrchestration : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        var location = new LocationInfo("Seattle", "WA");
        string weather = await context.CallActivityAsync<string>("GetWeather", location);
        return weather;
    }
}

JavaScript

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

const getWeatherOrchestrator: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const location = { city: "Seattle", state: "WA" };
    const weather = yield ctx.callActivity(getWeather, location);
    // ...
};

Python

from durabletask import task

def get_weather_orchestrator(ctx: task.OrchestrationContext, _):
    location = {"city": "Seattle", "state": "WA"}
    weather = yield ctx.call_activity("get_weather", input=location)
    # ...

PowerShell

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

Java

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

public class GetWeatherOrchestration implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Location location = new Location();
        location.city = "Seattle";
        location.state = "WA";
        String weather = ctx.callActivity("GetWeather", location, String.class).await();
        ctx.complete(weather);
    }
}

Langkah berikutnya

Batasan kode fungsi orkestrator

Mulai menggunakan Durable Task SDK