Vazby pro Durable Functions ve službě Azure Functions

Important

Support pro model v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovních procesů pro plnou podporu.

Rozšíření Durable Functions poskytuje aktivační a výstupní vazby, které připojují váš kód k modulu runtime Durable Functions pro orchestraci pracovních postupů. Pomocí těchto vazeb můžete definovat funkce orchestrátoru, funkce aktivit, funkce entit a klientské funkce, které spouštějí a spravují trvalé pracovní postupy.

Tento článek vysvětluje, jak nakonfigurovat a používat každý trigger (orchestrační trigger, trigger aktivity, trigger entity a orchestrační klient) s ukázkami kódu pro každý podporovaný jazyk.

Nezapomeňte vybrat vývojový jazyk Durable Functions v horní části článku.

Durable Functions podporuje obě verze programovacího modelu Pythonu pro Azure Functions. Vzhledem k tomu, že Python v2 je doporučená verze, příklady v tomto článku výhradně obsahují tuto verzi.

Předpoklady

  • Durable Functions SDK, což je balíček PyPI (Python Package Index) azure-functions-durable, verze 1.2.2 nebo novější verze
  • Sada rozšíření verze 4.x (nebo novější), která je nastavena v projektovém souboru host.json

V úložišti Durable Functions SDK pro Python můžete poskytnout zpětnou vazbu a návrhy.

Spouštěč orchestrace

Ke spouštění trvalých funkcí orchestrátoru můžete použít spouštěč orchestrací. Tato aktivační událost se spustí, když je naplánována nová instance orchestrace a když existující instance orchestrace obdrží událost. Mezi příklady událostí, které můžou aktivovat funkce orchestrátoru, patří trvalé vypršení platnosti časovače, odpovědi na funkce aktivity a události vyvolané externími klienty.

Při vývoji funkcí v .NET použijete atribut OrchestrationTriggerAttribute .NET ke konfiguraci triggeru orchestrace.

Pro Java nakonfigurujete spouštěč orchestrace pomocí anotace @DurableOrchestrationTrigger.

Při použití verze 4 programovacího modelu Node.js k vývoji funkcí importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.orchestration rozhraní Durable Functions API přímo v kódu funkce. Tato metoda zaregistruje funkci orchestrátoru v Durable Functions frameworku.

Při psaní funkcí orchestrátoru definujete trigger orchestrace pomocí následujícího objektu JSON v bindings poli souborufunction.json :

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

Hodnota orchestration je název orchestrace, kterou klienti musí použít, když chtějí spustit nové instance funkce orchestrátoru. Tato vlastnost je volitelná. Pokud ji nezadáte, použije se název funkce.

Při použití programovacího modelu Python v2 můžete definovat aktivační událost orchestrace pomocí dekorátoru orchestration_trigger přímo v kódu funkce Python.

V modelu v2 přistupujete k triggerům a vazbám Durable Functions z instance DFApp. Tuto podtřídu FunctionApp můžete použít k exportu dekorátorů specifických pro Durable Functions.

Tato vazba triggeru interně dotazuje nakonfigurované trvalé úložiště pro nové události orchestrace. Mezi příklady událostí patří:

  • Události zahájení orchestrace
  • Události vypršení platnosti trvalých časovačů
  • Události odezvy funkce aktivity
  • Externí události vyvolané jinými funkcemi

Chování spouštěče orchestrace

Zde je několik poznámek k spouštěči této orchestrace:

  • Jednovláknové: Jedno vlákno dispečeru se používá pro všechna spuštění funkce orchestrátoru v jedné instanci hostitele. Z tohoto důvodu je důležité zajistit, aby byl kód funkce orchestrátoru efektivní a neprovádí žádné vstupně-výstupní operace. Je také důležité zajistit, aby toto vlákno neprovádí žádnou asynchronní práci s výjimkou čekání na typy úloh, které jsou specifické pro Durable Functions.
  • Zpracování jedových zpráv: V aktivačních událostech orchestrace není podpora pro jedové zprávy.
  • Viditelnost zpráv: Spouštěcí zprávy orchestrace jsou vyřazeny z fronty a zůstávají neviditelné po stanovenou dobu. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Návratové hodnoty se serializují do formátu JSON a uchovávají se v tabulce historie orchestrace ve službě Azure Table Storage. Tyto vrácené hodnoty můžete dotazovat pomocí vazby klienta orchestrace, jak je popsáno později.

Warning

Funkce orchestratoru by nikdy neměly používat žádné vstupní nebo výstupní vazby kromě vazby aktivační události orchestrace. Použití jiných vazeb může způsobit problémy s rozšířením Durable Task, protože tyto vazby nemusí dodržovat pravidla jednovláknového zpracování a I/O operací. Pokud chcete použít jiné vazby, přidejte je do funkce aktivity, kterou voláte z funkce orchestrátoru. Další informace o kódování omezení pro funkce orchestrátoru naleznete v tématu Omezení kódu funkce orchestratoru.

Warning

Funkce orchestrátoru by nikdy neměly být deklarovány async.

Využití orchestračního spouštěče

Vazba orchestračního triggeru podporuje vstupy i výstupy. Tady je několik poznámek ke zpracování vstupu a výstupu:

  • Vstupy: Můžete vyvolat spouštěče orchestrace, které mají vstupy. Vstupy jsou přístupné prostřednictvím kontextového vstupního objektu. Všechny vstupy musí být serializovatelné ve formátu JSON.
  • Výstupy: Triggery orchestrace podporují výstupní i vstupní hodnoty. Návratová hodnota funkce slouží k přiřazení výstupní hodnoty. Návratová hodnota musí být serializovatelná ve formátu JSON.

Ukázka orchestrace spouštěče

Následující kód poskytuje příklad základní funkce Hello World orchestrátoru. Tento příklad orchestrátor neplánuje žádné úlohy.

Atribut, který použijete k definování triggeru, závisí na tom, jestli spouštíte funkce jazyka C#:

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

Note

Předchozí kód je pro Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí 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

Knihovna durable-functions volá synchronní context.done metodu, když dojde k ukončení funkce generátoru.

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

Většina funkcí orchestrátoru volá funkce aktivit. Následující kód poskytuje příklad Hello World, který ukazuje, jak volat funkci aktivity:

[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

Předchozí kód je pro Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí 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;
}

Spouštěč aktivity

K vývoji funkcí nazývaných funkce aktivit, které jsou volány funkcemi orchestrátoru, můžete použít trigger aktivity.

Ke konfiguraci triggeru aktivity použijete atribut ActivityTriggerAttribute .NET.

K nakonfigurování spouštěče aktivity použijete @DurableActivityTrigger poznámku.

Pokud chcete zaregistrovat funkci aktivity, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.activity rozhraní Durable Functions API přímo v kódu funkce.

K definování triggeru aktivity použijete následující objekt JSON v bindings poli function.json:

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

Hodnota activity je název aktivity. Tato hodnota je název, který funkce orchestrátoru používají k vyvolání této funkce aktivity. Tato vlastnost je volitelná. Pokud ji nezadáte, použije se název funkce.

Trigger aktivity můžete definovat pomocí dekorátoru activity_trigger přímo v kódu funkce Pythonu.

Aktivační vazba interně sleduje nakonfigurované trvalé úložiště pro nové události týkající se spouštění aktivit.

Chování spouštěče

Tady je několik poznámek k triggeru aktivity:

  • Threading: Na rozdíl od triggeru orchestrace nemají triggery aktivit žádná omezení pro operace podprocesů nebo vstupně-výstupních operací. Mohou být považovány za běžné funkce.
  • Zpracování jedových zpráv: U aktivačních událostí aktivity není podporována žádná podpora otrávných zpráv.
  • Viditelnost zpráv: Zprávy spouštěče aktivity jsou vyřazeny z fronty a stávají se neviditelnými po konfigurovatelnou dobu trvání. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Návratové hodnoty se serializují do formátu JSON a uchovávají se v nakonfigurovaném trvalém úložišti.

Aktivace využití

Vazba spouštěče aktivity podporuje jak vstupy, tak výstupy, stejně jako spouštěč orchestrace. Tady je několik poznámek ke zpracování vstupu a výstupu:

  • Vstupy: Aktivační události aktivity lze spustit s využitím vstupů z funkce orchestrátoru. Všechny vstupy musí být serializovatelné ve formátu JSON.
  • Výstupy: Funkce aktivit podporují výstupní i vstupní hodnoty. Návratová hodnota funkce se používá k přiřazení výstupní hodnoty a musí být serializovatelná ve formátu JSON.
  • Metadata: Funkce aktivit .NET mohou se svázat s parametrem string instanceId, aby získaly ID instance orchestrace, která je volá.

Ukázka spouštěče

Následující kód poskytuje příklad základní funkce aktivity Hello World.

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

Výchozí typ parametru pro vazbu .NET ActivityTriggerAttribute je IDurableActivityContext (nebo DurableActivityContext pro Durable Functions 1.x). Triggery aktivit .NET ale podporují vazbu přímo na typy serializovatelné ve formátu JSON (včetně primitivních typů), takže můžete také použít následující zjednodušenou verzi funkce:

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

Použití vstupního a výstupního vázání aktivity

Kromě vazby spouštěče aktivity můžete také použít běžné vstupní a výstupní vazby.

Například funkce aktivity může přijímat vstupy z funkce orchestrátoru. Funkce aktivity pak může tento vstup odeslat jako zprávu do služby 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}'`);
    },
});

Klient pro orchestraci

Vazbu klienta orchestrace můžete použít k zápisu funkcí, které pracují s funkcemi orchestrátoru. Tyto funkce se často označují jako klientské funkce. Například můžete pracovat s orchestračními instancemi následujícími způsoby:

  • Začněte s nimi.
  • Zadejte dotaz na jejich stav.
  • Zlikvidujte je.
  • Posílejte jim události, když jsou spuštěné.
  • Vymažte historii instancí.

S klientem orchestrace můžete vytvořit vazbu pomocí atributu DurableClientAttribute (OrchestrationClientAttribute v Durable Functions 1.x).

Pomocí poznámky @DurableClientInput můžete vytvořit vazbu s klientem orchestrace.

Pokud chcete zaregistrovat funkci klienta, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu rozhraní API Durable Functions, která je specifická pro váš typ triggeru. Například pro trigger HTTP voláte metodu app.http . Pro spouštěč fronty zavoláte metodu app.storageQueue.

K definování triggeru trvalého klienta použijete následující objekt JSON v poli bindings pole 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"
}
  • Tato taskHub vlastnost se používá, když několik funkčních aplikací sdílí stejný účet úložiště, ale musí být navzájem izolovány. Pokud tuto vlastnost nezadáte, použije se výchozí hodnota z host.json . Tato hodnota musí odpovídat hodnotě, kterou používají funkce cílového orchestrátoru.
  • Hodnota connectionName je název nastavení aplikace, které obsahuje připojovací řetězec účtu úložiště. Účet úložiště reprezentovaný tímto řetězcem připojení musí být stejný jako ten, který používají cílové funkce orchestrátoru. Pokud tuto vlastnost nezadáte, použije se výchozí připojovací řetězec účtu úložiště pro aplikaci funkcí.

Note

Ve většině případů doporučujeme vynechat tyto vlastnosti a spoléhat se na výchozí chování.

Můžete definovat spouštěč odolného klienta pomocí dekorátoru durable_client_input přímo v kódu vaší funkce v Pythonu.

Použití klienta

Obvykle se svážete s implementací IDurableClient (DurableOrchestrationClient v Durable Functions 1.x), která poskytuje úplný přístup ke všem klientským rozhraním API orchestrace, která Durable Functions podporuje.

Obvykle se připojíte ke třídě DurableClientContext.

Pokud chcete získat přístup k objektu klienta, musíte použít sadu SDK specifickou pro jazyk.

Následující kód ukazuje příklad funkce spuštěné pomocí fronty, která zahajuje proces orchestrace nazvaný Hello World.

[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

Předchozí kód jazyka C# je pro Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít atribut OrchestrationClient místo atributu DurableClient a místo DurableOrchestrationClient použít typ parametru IDurableOrchestrationClient. Další informace o rozdílech mezi verzemi najdete v tématu Přehled verzí 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);
}

Podrobné informace o spouštění instancí najdete v tématu Správa instancí v Durable Functions v Azure.

Entita spouštěče

Trigger entity můžete použít k vývoji funkce entity. Tento trigger podporuje zpracování událostí pro konkrétní instanci entity.

Note

Spouště entit jsou k dispozici od Durable Functions 2.x.

Interně tato spouštěcí vazba pravidelně kontroluje nakonfigurované trvalé úložiště pro nové operace entity, které je třeba vykonat.

Ke konfiguraci triggeru entity použijete atribut EntityTriggerAttribute .NET.

Pokud chcete zaregistrovat trigger entity, importujete app objekt z @azure/functions npm modulu. Pak zavoláte metodu app.entity rozhraní Durable Functions API přímo v kódu funkce.

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

Entitu triggeru můžete definovat pomocí anotace @DurableEntityTrigger. Pomocí EntityRunner.loadAndRun odesílejte operace třídě entity.

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

Spouštěče entit se zatím pro PowerShell nepodporují.

Trigger entity můžete definovat pomocí dekorátoru entity_trigger přímo v kódu funkce Pythonu.

Chování spouštěče

Tady je několik poznámek k triggeru entity:

  • Jednovláknové: Jedno vlákno dispečeru se používá ke zpracování operací pro konkrétní entitu. Pokud se do jedné entity současně odesílá více zpráv, operace se zpracovávají postupně.
  • Zpracování jedových zpráv: U triggerů entit není podpora pro jedové zprávy.
  • Viditelnost zpráv: Zprávy triggeru entity jsou vyřazeny z fronty a jsou neviditelné po konfigurovatelnou dobu trvání. Viditelnost těchto zpráv se automaticky obnovuje, pokud je funkční aplikace spuštěna a v dobrém stavu.
  • Návratové hodnoty: Funkce entit nepodporují návratové hodnoty. Existují specifická rozhraní API, která můžete použít k uložení stavu nebo předání hodnot zpět do orchestrací.

Všechny změny stavu provedené v entitě během provádění se po dokončení provádění automaticky zachovají.

Další informace a příklady definování a interakce s triggery entit naleznete v tématu Funkce entity.

Klientská entita

Pomocí vazby klienta entity můžete asynchronně aktivovat funkce entit. Tyto funkce se někdy označují jako klientské funkce.

S klientem entity můžete vytvořit vazbu pomocí atributu DurableClientAttribute .NET ve funkcích knihovny tříd .NET.

Note

Můžete také použít [DurableClientAttribute] k propojení s orchestračním klientem.

Místo registrace klienta entity zavoláte pomocí signalEntity nebo callEntity metodu spouštěče entity z jakékoli registrované funkce.

  • Z frontou aktivované funkce můžete použít 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);
    },
});

  • Z funkce orchestrátoru můžete použít 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;
});

Klienta entity můžete definovat pomocí dekorátoru durable_client_input přímo v kódu funkce Pythonu.

Anotaci @DurableClientInput můžete použít k navázání na DurableClientContext, který poskytuje metody pro signalizování entit a čtení stavu entit.

  • Signalizovat entitu z funkce aktivované protokolem 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();
}

  • Čtení stavu entity z funkce aktivované protokolem 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

Klienti entit zatím nejsou v PowerShellu podporovaní.

Další informace a příklady interakce s entitami jako klienta najdete v tématu Přístupové entity.

Další kroky

Zabudovaná referenční dokumentace HTTP API pro správu instancí

  • Last updated on