Pengikatan untuk Durable Functions di Azure Functions

Ekstensi Durable Functions menyediakan pengikatan pemicu dan output yang menghubungkan kode Anda ke runtime Durable Functions untuk orkestrasi alur kerja. Gunakan pengikatan ini untuk menentukan fungsi orkestrator, fungsi aktivitas, fungsi entitas, dan fungsi klien yang memulai dan mengelola alur kerja yang tahan lama.

Artikel ini menjelaskan cara mengonfigurasi dan menggunakan setiap pengikatan (pemicu orkestrasi, pemicu aktivitas, pemicu entitas, dan klien orkestrasi) dengan sampel kode untuk setiap bahasa yang didukung.

Pastikan untuk memilih bahasa pengembangan Durable Functions Anda di bagian atas artikel.

Durable Functions mendukung kedua versi model pemrograman Python untuk Azure Functions. Karena Python v2 adalah versi yang direkomendasikan, contoh dalam artikel ini secara eksklusif menampilkan versi ini.

Prerequisites

  • Durable Functions SDK, yang merupakan paket Python Package Index (PyPI) azure-functions-durable, versi 1.2.2 atau versi yang lebih baru
  • Bundel ekstensi versi 4.x (atau versi yang lebih baru), yang diatur dalam file proyek host.json

Anda dapat memberikan umpan balik dan saran di Durable Functions SDK untuk repositori Python.

Pemicu Pengelolaan Orkestrasi

Anda dapat menggunakan pemicu orkestrasi untuk mengembangkan fungsi orkestrator yang tahan lama. Pemicu ini dijalankan ketika instans orkestrasi baru dijadwalkan dan ketika instans orkestrasi yang ada menerima peristiwa. Contoh peristiwa yang dapat memicu fungsi orkestrator termasuk kedaluwarsa timer yang tahan lama, respons fungsi aktivitas, dan peristiwa yang dipicu oleh klien eksternal.

Saat mengembangkan fungsi di .NET, Anda menggunakan atribut OrchestrationTriggerAttribute .NET untuk mengonfigurasi pemicu orkestrasi.

Untuk Java, Anda menggunakan anotasi @DurableOrchestrationTrigger untuk mengonfigurasi pemicu orkestrasi.

Saat Anda menggunakan model pemrograman Node.js versi 4 untuk mengembangkan fungsi, Anda mengimpor app objek dari @azure/functions npm modul. Kemudian Anda memanggil metode app.orchestration API Durable Functions langsung dalam kode fungsi Anda. Metode ini mendaftarkan fungsi orkestrator Anda dengan kerangka kerja Durable Functions.

Saat Anda menulis fungsi orkestrator, Anda menentukan pemicu orkestrasi dengan menggunakan objek JSON berikut dalam bindings array file function.json :

{
    "name": "<name-of-input-parameter-in-function-signature>",
    "orchestration": "<optional-name-of-orchestration>",
    "type": "orchestrationTrigger",
    "direction": "in"
}

Nilai orchestration adalah nama orkestrasi yang harus digunakan klien ketika mereka ingin memulai fungsi orkestrator instansi baru. Properti ini bersifat opsional. Jika Anda tidak menentukannya, nama fungsi akan digunakan.

Saat Anda menggunakan model pemrograman Python v2, Anda dapat menentukan pemicu orkestrasi dengan menggunakan dekorator orchestration_trigger langsung dalam kode fungsi Python Anda.

Dalam model v2, Anda mengakses pemicu dan pengikatan Durable Functions dari instance DFApp. Anda dapat menggunakan subkelas FunctionApp ini untuk mengekspor dekorator khusus untuk Durable Functions.

Secara internal, pemicu ini melakukan polling pada penyimpanan yang tahan lama yang telah dikonfigurasi untuk mencari peristiwa orkestrasi baru. Contoh peristiwa meliputi:

  • Peristiwa dimulainya orkestrasi
  • Peristiwa berakhirnya timer persisten
  • Peristiwa respons fungsi aktivitas
  • Peristiwa eksternal yang dimunculkan oleh fungsi lain

Perilaku pemicu orkestrasi

Berikut adalah beberapa catatan tentang pemicu proses orkestrasi:

  • Utas tunggal: Utas dispatcher tunggal digunakan untuk semua eksekusi fungsi orkestrator pada satu instans host. Untuk alasan ini, penting untuk memastikan bahwa kode fungsi orkestrator efisien dan tidak melakukan operasi I/O apa pun. Penting juga untuk memastikan bahwa utas (thread) ini tidak melakukan pekerjaan asinkron, kecuali saat menunggu tugas yang khusus untuk tipe Durable Functions.
  • Penanganan pesan racun: Tidak ada dukungan untuk pesan racun dalam pemicu orkestrasi.
  • Visibilitas pesan: Pesan pemicu orkestrasi dikeluarkan dari antrean dan dibiarkan tidak terlihat selama durasi yang dapat dikonfigurasi. Visibilitas pesan ini diperbarui secara otomatis selama aplikasi fungsi berjalan dan sehat.
  • Nilai pengembalian: Nilai yang dikembalikan diserialisasikan ke JSON dan disimpan ke tabel riwayat orkestrasi di Penyimpanan Tabel Azure. Anda dapat mengkueri nilai pengembalian ini dengan pengikatan klien orkestrasi, yang dijelaskan nanti.

Warning

Fungsi orkestrator tidak boleh menggunakan pengikatan input atau output selain pengikatan pemicu orkestrasi. Penggunaan binding lain dapat menyebabkan masalah dengan ekstensi Durable Task, karena binding tersebut mungkin tidak mematuhi aturan single-threading dan I/O. Jika Anda ingin menggunakan pengikatan lain, tambahkan ke fungsi aktivitas yang dipanggil dari fungsi orkestrator Anda. Untuk informasi selengkapnya tentang batasan pengodean untuk fungsi orkestrator, lihat Batasan kode fungsi orkestrator.

Warning

Fungsi orkestrator sebaiknya tidak pernah dideklarasikan async.

Penggunaan pemicu orkestrasi

Pengikatan pemicu orkestrasi mendukung masukan dan keluaran. Berikut adalah beberapa catatan tentang penanganan input dan output:

  • Input: Anda dapat memanggil pemicu orkestrasi yang memiliki input. Input diakses melalui objek input konteks. Semua input harus dapat diserialisasikan JSON.
  • Output: Pemicu orkestrasi mendukung nilai-nilai output dan input. Nilai pengembalian fungsi digunakan untuk menetapkan nilai output. Nilai yang dikembalikan harus dapat diserialisasikan JSON.

Contoh pemicu orkestrasi

Kode berikut memberikan contoh fungsi orkestrator Halo Dunia dasar. Contoh orkestrator ini tidak menjadwalkan tugas apa pun.

Atribut yang Anda gunakan untuk menentukan pemicu tergantung pada apakah Anda menjalankan fungsi C#Anda:

[FunctionName("HelloWorld")]
public static string RunOrchestrator([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Note

Kode sebelumnya adalah untuk Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antar versi, lihat Gambaran umum versi Durable Functions.

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

df.app.orchestration('helloOrchestrator', function* (context) {
    const name = context.df.getInput();
    return `Hello ${name}`;
});

Note

durable-functions Pustaka memanggil metode sinkron context.done ketika fungsi generator berhenti.

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

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

@myApp.orchestration_trigger(context_name="context")
def my_orchestrator(context):
    result = yield context.call_activity("Hello", "Tokyo")
    return result

param($Context)

$InputData = $Context.Input
$InputData

@FunctionName("HelloWorldOrchestration")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    return String.format("Hello %s!", ctx.getInput(String.class));
}

Sebagian besar fungsi orkestrator memanggil fungsi aktivitas. Kode berikut menyediakan contoh Halo Dunia yang menunjukkan cara memanggil fungsi aktivitas:

[FunctionName("HelloWorld")]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    string result = await context.CallActivityAsync<string>("SayHello", name);
    return result;
}

Note

Kode sebelumnya adalah untuk Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antar versi, lihat Gambaran umum versi Durable Functions.

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

const activityName = 'hello';

df.app.orchestration('helloOrchestrator', function* (context) {
    const name = context.df.getInput();
    const result = yield context.df.callActivity(activityName, name);
    return result;
});

@FunctionName("HelloWorld")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String input = ctx.getInput(String.class);
    String result = ctx.callActivity("SayHello", input, String.class).await();
    return result;
}

Pemicu aktivitas

Anda dapat menggunakan pemicu aktivitas untuk mengembangkan fungsi yang dikenal sebagai fungsi aktivitas yang dipanggil oleh fungsi orkestrator.

Anda menggunakan atribut ActivityTriggerAttribute .NET untuk mengonfigurasi pemicu aktivitas.

Anda menggunakan @DurableActivityTrigger anotasi untuk mengonfigurasi pemicu aktivitas.

Untuk mendaftarkan fungsi aktivitas, Anda mengimpor app objek dari @azure/functions npm modul. Kemudian Anda memanggil metode app.activity API Durable Functions langsung dalam kode fungsi Anda.

Untuk menentukan pemicu aktivitas, Anda menggunakan objek JSON berikut dalam bindings array function.json:

{
    "name": "<name-of-input-parameter-in-function-signature>",
    "activity": "<optional-name-of-activity>",
    "type": "activityTrigger",
    "direction": "in"
}

Nilai activity tersebut adalah nama aktivitas. Nilai ini adalah nama yang digunakan fungsi orkestrator untuk memanggil fungsi aktivitas ini. Properti ini bersifat opsional. Jika Anda tidak menentukannya, nama fungsi akan digunakan.

Anda dapat menentukan pemicu aktivitas dengan menggunakan dekorator activity_trigger langsung dalam kode fungsi Python Anda.

Secara internal, pemicu ini melakukan polling terhadap penyimpanan tahan lama yang telah dikonfigurasi untuk mencari peristiwa eksekusi aktivitas baru.

Perilaku pemicu

Berikut adalah beberapa catatan tentang pemicu aktivitas:

  • Threading: Tidak seperti pemicu orkestrasi, pemicu aktivitas tidak memiliki batasan pada operasi utas atau I/O. Mereka dapat diperlakukan seperti fungsi biasa.
  • Penanganan pesan racun: Tidak ada dukungan untuk pesan racun dalam pemicu aktivitas.
  • Visibilitas pesan: Pesan pemicu aktivitas dikeluarkan dari antrean dan disembunyikan selama durasi yang dapat dikonfigurasi. Visibilitas pesan ini diperbarui secara otomatis selama aplikasi fungsi berjalan dan sehat.
  • Nilai pengembalian: Nilai pengembalian diserialisasikan ke JSON dan bertahan ke penyimpanan tahan lama yang dikonfigurasi.

Penggunaan pemicu

Pengaitan dari pemicu aktivitas mendukung baik input maupun output, seperti halnya pemicu orkestrasi. Berikut adalah beberapa catatan tentang penanganan input dan output:

  • Input: Pemicu aktivitas dapat dipanggil dengan input dari fungsi orkestrator. Semua input harus dapat diserialisasikan JSON.
  • Output: Fungsi aktivitas mendukung nilai output dan input. Nilai pengembalian fungsi digunakan untuk menetapkan nilai output dan harus dapat diserialisasikan JSON.
  • Metadata: fungsi aktivitas .NET dapat mengikat ke parameter string instanceId untuk mendapatkan ID instans dari orkestrasi yang memanggil.

Contoh Pemicu

Kode berikut memberikan contoh fungsi aktivitas Halo Dunia dasar.

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

Jenis parameter default untuk pengikatan .NET ActivityTriggerAttribute adalah IDurableActivityContext (atau DurableActivityContext untuk Durable Functions 1.x). Namun, pemicu aktivitas .NET juga mendukung pengikatan langsung ke jenis yang dapat diserialisasikan JSON (termasuk jenis primitif), sehingga Anda juga dapat menggunakan versi fungsi yang disederhanakan berikut:

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

const { app } = require('@azure/functions');
const df = require('durable-functions');
const activityName = 'hello';
df.app.activity(activityName, {
    handler: (input) => {
        return `Hello, ${input}`;
    },
});

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

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

@myApp.activity_trigger(input_name="myInput")
def my_activity(myInput: str):
    return "Hello " + myInput

param($name)

"Hello $name!"

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

Menggunakan pengikatan input dan output aktivitas

Selain pengikatan pemicu aktivitas, Anda juga dapat menggunakan pengikatan input dan output reguler.

Misalnya, fungsi aktivitas dapat menerima input dari fungsi orkestrator. Fungsi aktivitas kemudian dapat mengirim input tersebut sebagai pesan ke Azure Event Hubs.

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

df.app.orchestration('helloOrchestrator', function* (context) {
    const input = context.df.getInput();
    yield context.df.callActivity('sendToEventHub', input);
    return `Message sent: ${input}`;
});

const { EventHubProducerClient } = require("@azure/event-hubs");
const connectionString = process.env.EVENT_HUB_CONNECTION_STRING;
const eventHubName = process.env.EVENT_HUB_NAME;

df.app.activity("sendToEventHub", {
    handler: async (message, context) => {
        const producer = new EventHubProducerClient(connectionString, eventHubName);
        try {
            const batch = await producer.createBatch();
            batch.tryAdd({ body: message });
            await producer.sendBatch(batch);
            context.log(`Message sent to Event Hubs: ${message}`);
        } catch (err) {
            context.log.error("Failed to send message to Event Hubs:", err);
            throw err;
        } finally {
            await producer.close();
        }
    },
});

app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const orchestratorName = message.orchestratorName || 'helloOrchestrator';
        const input = message.input || null;
        const instanceId = await client.startNew(orchestratorName, { input });
        context.log(`Started orchestration with ID = '${instanceId}'`);
    },
});

Klien orkestrasi

Anda dapat menggunakan pengikatan klien orkestrasi untuk menulis fungsi yang berinteraksi dengan fungsi orkestrator. Fungsi-fungsi ini sering disebut sebagai fungsi klien. Misalnya, Anda dapat bertindak pada instans orkestrasi dengan beberapa cara:

  • Mulai semuanya.
  • Menanyakan status mereka.
  • Hentikan mereka.
  • Kirim acara kepada mereka saat acara tersebut sedang berlangsung.
  • Hapus menyeluruh riwayat instans.

Anda dapat mengikat ke klien orkestrasi dengan menggunakan atribut DurableClientAttribute (OrchestrationClientAttribute dalam Durable Functions 1.x).

Anda dapat mengikat klien orkestrasi dengan menggunakan @DurableClientInput anotasi.

Untuk mendaftarkan fungsi klien, Anda mengimpor app objek dari @azure/functions npm modul. Kemudian Anda memanggil metode API Durable Functions yang khusus untuk jenis pemicu Anda. Misalnya, untuk pemicu HTTP, Anda memanggil metode .app.http Untuk pemicu antrean, Anda memanggil metode app.storageQueue.

Untuk menentukan pemicu klien yang tahan lama, Anda menggunakan objek JSON berikut dalam bindings array function.json:

{
    "name": "<name-of-input-parameter-in-function-signature>",
    "taskHub": "<optional-name-of-task-hub>",
    "connectionName": "<optional-name-of-connection-string-app-setting>",
    "type": "orchestrationClient",
    "direction": "in"
}
  • Properti taskHub digunakan saat beberapa aplikasi fungsi berbagi akun penyimpanan yang sama tetapi perlu diisolasi satu sama lain. Jika Anda tidak menentukan properti ini, nilai default dari host.json digunakan. Nilai ini harus cocok dengan nilai yang digunakan fungsi orkestrator target.
  • Nilai connectionName adalah nama pengaturan aplikasi yang berisi string koneksi akun penyimpanan. Akun penyimpanan yang diwakili oleh string koneksi ini harus sama dengan yang digunakan fungsi orkestrator target. Jika Anda tidak menentukan properti ini, string koneksi akun penyimpanan default untuk aplikasi fungsi digunakan.

Note

Dalam kebanyakan kasus, kami sarankan Anda menghilangkan properti ini dan mengandalkan perilaku default.

Anda dapat menentukan pemicu klien yang tahan lama dengan menggunakan dekorator durable_client_input langsung dalam kode fungsi Python Anda.

Penggunaan klien

Anda biasanya mengikat implementasi IDurableClient (DurableOrchestrationClient di Durable Functions 1.x), yang memberi Anda akses penuh ke semua API klien orkestrasi yang Durable Functions mendukung.

Anda biasanya menghubungkan ke kelas DurableClientContext.

Anda harus menggunakan SDK khusus bahasa untuk mendapatkan akses ke objek klien.

Kode berikut memberikan contoh fungsi yang dipicu oleh antrean untuk memulai orkestrasi Halo Dunia.

[FunctionName("QueueStart")]
public static Task Run(
    [QueueTrigger("durable-function-trigger")] string input,
    [DurableClient] IDurableOrchestrationClient starter)
{
    // Orchestration input comes from the queue message content.
    return starter.StartNewAsync<string>("HelloWorld", input);
}

Note

Kode C# sebelumnya adalah untuk Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan atribut OrchestrationClient alih-alih atribut DurableClient, dan Anda harus menggunakan jenis parameter DurableOrchestrationClient alih-alih IDurableOrchestrationClient. Untuk informasi selengkapnya tentang perbedaan antar versi, lihat Gambaran umum versi Durable Functions.

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

app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const orchestratorName = message.orchestratorName || 'helloOrchestrator';
        const input = message.input || null;
        const instanceId = await client.startNew(orchestratorName, { input });
        context.log(`Started orchestration with ID = '${instanceId}' from queue message.`);
    },
});

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

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

@myApp.queue_trigger(
    arg_name="msg",
    queue_name="start-orchestration",
    connection="AzureWebJobsStorage"
)
@myApp.durable_client_input(client_name="client")
async def client_function(msg: func.QueueMessage, client: df.DurableOrchestrationClient):
    input_data = msg.get_body().decode("utf-8")
    await client.start_new("my_orchestrator", None, input_data)
    return None

function.json

{
  "bindings": [
    {
      "name": "InputData",
      "type": "queueTrigger",
      "queueName": "durable-function-trigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

run.ps1

param([string]$InputData, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName 'HelloWorld' -Input $InputData

@FunctionName("QueueStart")
public void queueStart(
        @QueueTrigger(name = "input", queueName = "durable-function-trigger", connection = "Storage") String input,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    // Orchestration input comes from the queue message content.
    durableContext.getClient().scheduleNewOrchestrationInstance("HelloWorld", input);
}

Untuk informasi terperinci tentang memulai instans, lihat Mengelola instans di Durable Functions di Azure.

Pemicu entitas

Anda dapat menggunakan pemicu entitas untuk mengembangkan fungsi entitas. Pemicu ini mendukung pengolahan kejadian untuk instans entitas tertentu.

Note

Pemicu entitas tersedia mulai dari Durable Functions 2.x.

Secara internal, pemicu ini melakukan polling pada penyimpanan persisten yang dikonfigurasi untuk operasi entitas baru yang perlu dijalankan.

Anda menggunakan atribut EntityTriggerAttribute .NET untuk mengonfigurasi pemicu entitas.

Anda mengimpor objek app dari modul @azure/functions npm untuk mendaftarkan pemicu entitas. Kemudian Anda memanggil metode app.entity API Durable Functions langsung dalam kode fungsi Anda.

const df = require('durable-functions');
df.app.entity('counter', (context) => {
    const currentValue = context.df.getState(() => 0);
    switch (context.df.operationName) {
        case 'add':
            context.df.setState(currentValue + context.df.getInput());
            break;
        case 'reset':
            context.df.setState(0);
            break;
        case 'get':
            context.df.return(currentValue);
            break;
    }
});

Anda dapat menentukan pemicu entitas dengan menggunakan @DurableEntityTrigger anotasi. Gunakan EntityRunner.loadAndRun untuk mengirimkan operasi ke kelas entitas Anda.

import com.microsoft.durabletask.AbstractTaskEntity;
import com.microsoft.durabletask.TaskEntityOperation;
import com.microsoft.durabletask.azurefunctions.DurableEntityTrigger;
import com.microsoft.durabletask.EntityRunner;

public class CounterEntity extends AbstractTaskEntity<Integer> {

    public void add(int value) {
        this.state += value;
    }

    public int get() {
        return this.state;
    }

    public void reset() {
        this.state = 0;
    }

    @Override
    protected Integer initializeState(TaskEntityOperation operation) {
        return 0;
    }

    @Override
    protected Class<Integer> getStateType() {
        return Integer.class;
    }
}

// Entity function
@FunctionName("Counter")
public String counterEntity(
    @DurableEntityTrigger(name = "req") String req) {
    return EntityRunner.loadAndRun(req, CounterEntity::new);
}

Note

Pemicu entitas belum didukung untuk PowerShell.

Anda dapat menentukan pemicu entitas dengan menggunakan dekorator entity_trigger langsung dalam kode fungsi Python Anda.

Perilaku pemicu

Berikut beberapa catatan tentang pemicu entitas:

  • Utas tunggal: Satu utas dispatcher digunakan untuk memproses operasi untuk entitas tertentu. Jika beberapa pesan dikirim ke satu entitas secara bersamaan, operasi diproses satu per satu.
  • Penanganan pesan racun: Tidak ada dukungan untuk pesan racun dalam pemicu entitas.
  • Visibilitas pesan: Pesan pemicu entitas dikeluarkan dari antrean dan menjadi tidak terlihat untuk jangka waktu yang dapat dikonfigurasi. Visibilitas pesan ini diperbarui secara otomatis selama aplikasi fungsi berjalan dan sehat.
  • Nilai Pengembalian: Fungsi entitas tidak mendukung nilai pengembalian. Ada API tertentu yang dapat Anda gunakan untuk menyimpan nilai status atau meneruskan kembali ke orkestrasi.

Setiap perubahan status yang dilakukan pada entitas selama eksekusinya secara otomatis dipertahankan setelah eksekusi selesai.

Untuk informasi selengkapnya dan contoh menentukan dan berinteraksi dengan pemicu entitas, lihat Fungsi entitas.

Klien Perusahaan

Anda dapat menggunakan pengikatan klien entitas untuk memicu fungsi entitas secara asinkron. Fungsi-fungsi ini terkadang disebut sebagai fungsi klien.

Anda dapat mengikat klien entitas dengan menggunakan atribut DurableClientAttribute .NET dalam fungsi pustaka kelas .NET.

Note

Anda juga dapat menggunakan [DurableClientAttribute] untuk menghubungkan ke klien orkestrasi.

Alih-alih mendaftarkan klien entitas, Anda menggunakan signalEntity atau callEntity untuk memanggil metode pemicu entitas dari fungsi terdaftar apa pun.

  • Dari fungsi yang dipicu oleh antrean, Anda dapat menggunakan client.signalEntity:

    const { app } = require('@azure/functions');
const df = require('durable-functions');
app.storageQueue('helloQueueStart', {
    queueName: 'start-orchestration',
    extraInputs: [df.input.durableClient()],
    handler: async (message, context) => {
        const client = df.getClient(context);
        const entityId = new df.EntityId('counter', 'myCounter');
        await client.signalEntity(entityId, 'add', 5);
    },
});

  • Dari fungsi orkestrator, Anda dapat menggunakan context.df.callEntity:

    const { app } = require('@azure/functions');
const df = require('durable-functions');
df.app.orchestration('entityCaller', function* (context) {
    const entityId = new df.EntityId('counter', 'myCounter');
    yield context.df.callEntity(entityId, 'add', 5);
    yield context.df.callEntity(entityId, 'add', 5);
    const result = yield context.df.callEntity(entityId, 'get');
    return result;
});

Anda dapat menentukan klien entitas dengan menggunakan dekorator durable_client_input langsung dalam kode fungsi Python Anda.

Anda dapat menggunakan @DurableClientInput anotasi untuk mengikat ke DurableClientContext, yang menyediakan metode untuk memberi sinyal entitas dan membaca status entitas.

  • Memberi sinyal entitas dari fungsi yang dipicu HTTP:

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

    EntityInstanceId entityId = new EntityInstanceId("Counter", "myCounter");
    durableContext.signalEntity(entityId, "add", 5);

    return request.createResponseBuilder(HttpStatus.ACCEPTED)
        .body("Signal sent")
        .build();
}

  • Membaca status entitas dari fungsi yang dipicu HTTP:

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

    EntityInstanceId entityId = new EntityInstanceId("Counter", "myCounter");
    EntityMetadata metadata = durableContext.getEntityMetadata(entityId, true);

    if (metadata == null) {
        return request.createResponseBuilder(HttpStatus.NOT_FOUND).build();
    }

    Integer state = metadata.readStateAs(Integer.class);
    return request.createResponseBuilder(HttpStatus.OK)
        .body(state)
        .build();
}

Note

Klien entitas belum didukung untuk PowerShell.

Untuk informasi selengkapnya dan contoh berinteraksi dengan entitas sebagai klien, lihat Entitas akses.

Langkah berikutnya

Referensi API HTTP bawaan untuk manajemen instans

  • Last updated on