Tartós funkciók kötései az Azure Functionsben

A Durable Functions bővítmény trigger- és kimeneti kötéseket biztosít, amelyek összekapcsolják a kódot a Durable Functions futtatókörnyezetével a munkafolyamat vezényléséhez. Ezekkel a kötésekkel olyan vezénylőfüggvényeket, tevékenységfüggvényeket, entitásfüggvényeket és ügyfélfüggvényeket határozhat meg, amelyek tartós munkafolyamatokat indítnak el és kezelnek.

Ez a cikk bemutatja, hogyan konfigurálhatja és használhatja az egyes kötéseket (a vezénylési eseményindítót, a tevékenységindítót, az entitás-eseményindítót és a vezénylési ügyfelet) minden támogatott nyelvhez tartozó kódmintákkal.

Ügyeljen arra, hogy a cikk tetején válassza ki a Durable Functions fejlesztési nyelvét.

A Durable Functions az Azure Functions Python programozási modelljének mindkét verzióját támogatja. Mivel a Python v2 az ajánlott verzió, a cikkben szereplő példák kizárólag ezt a verziót használják.

Prerequisites

  • Durable Functions SDK, amely a Python Csomagindex (PyPI) csomag azure-functions-durable, verzió 1.2.2 vagy egy újabb verzió
  • A bővítménycsomag 4.x-es (vagy újabb) verziója, amely a host.json projektfájlban van beállítva

Visszajelzést és javaslatokat a Durable Functions SDK for Python-adattárban adhat meg.

Orkesztációs eseményindító

A vezénylési eseményindítóval tartós vezénylőfunkciókat fejleszthet. Ez az eseményindító akkor fut, ha egy új orchestration instance van ütemezve, és amikor egy meglévő orchestration instance eseményt kap. Az orchestrátor függvényeket kiváltó események közé tartozik például a tartós időzítők lejárata, a tevékenységfüggvények válaszai és a külső kliensek által kezdeményezett események.

Amikor függvényeket fejleszt a .NET-ben, az OrchestrationTriggerAttribute .NET attribútummal konfigurálja a vezénylési eseményindítót.

A Java esetében az @DurableOrchestrationTrigger annotációt használja az orkesztrációs trigger konfigurálásához.

Ha a Node.js programozási modell 4. verzióját használja a függvények fejlesztéséhez, importálja az app objektumot a @azure/functions npm modulból. Ezután közvetlenül a függvénykódban hívja meg a app.orchestration Durable Functions API metódusát. Ez a módszer regisztrálja az orchestrator függvényt a Durable Functions keretrendszerben.

Vezénylőfüggvények írásakor a vezénylési eseményindítót a következő JSON-objektummal definiálja a bindingsfunction.json fájl tömbjében:

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

Az orchestration érték annak a vezénylésnek a neve, amelyet az ügyfeleknek használniuk kell a vezénylő függvény új példányainak indításakor. Ez a tulajdonság opcionális. Ha nem adja meg, a függvény neve lesz használva.

Ha a Python v2 programozási modellt használja, a orchestration_trigger dekoratőrrel közvetlenül a Python függvény kódjában definiálhat vezénylési eseményindítót.

A v2 modellben a Durable Functions eseményindítókat és kötéseket a DFApp egy példányából érheti el. Ez az FunctionApp alosztály a Durable Functions számára jellemző dekorátorok exportálására használható.

Ez az eseményindító kötés belsőleg lekérdezi a konfigurált tartós tárolót az új vezénylési eseményekhez. Példák az eseményekre:

  • Orchestration indítási események
  • Tartós időzítő lejárati eseményei
  • Tevékenységfüggvény válaszeseményei
  • Más függvények által kiváltott külső események

Orkesztrációs eseményindító viselkedése

Íme néhány megjegyzés az orchestrációs indítóról:

  • Egyszálas: Egyetlen diszpécserszálat használ az összes vezénylőfüggvény végrehajtásához egyetlen gazdagéppéldányon. Ezért fontos biztosítani, hogy a vezénylő függvénykódja hatékony legyen, és ne végezzen I/O-műveleteket. Azt is fontos biztosítani, hogy ez a szál ne végezhessen aszinkron munkát, kivéve, ha a Durable Functionsre jellemző feladattípusokra vár.
  • Méregüzenetek kezelése: A vezénylési triggerekben nem támogatottak a méregüzenetek.
  • Üzenetek láthatósága: A vezénylési trigger üzenetei kivételre kerülnek a sorból, és konfigurálható ideig láthatatlanná válnak. Az üzenetek láthatósága automatikusan megújul, amíg a függvényalkalmazás fut és kifogástalan állapotban van.
  • Visszatérési értékek: A visszaadott értékek JSON-ra szerializálva lesznek, és megmaradnak az Azure Table Storage vezénylési előzménytáblájában. Ezeket a visszatérési értékeket a vezénylési ügyfélkötéssel kérdezheti le, amelyet később ismertetünk.

Warning

Az Orchestrator függvények soha nem használhatnak bemeneti vagy kimeneti kötéseket a vezénylési trigger kötésétől eltérően. Más kötések használata problémákat okozhat a Durable Task bővítményben, mert előfordulhat, hogy ezek a kötések nem tartják be az egyszálas és az I/O-szabályokat. Ha más kapcsolatokat szeretne használni, adja hozzá őket egy tevékenységfüggvényhez, amelyet a vezénylő függvényből hív meg. A vezénylő függvények kódolási korlátozásairól további információt az Orchestrator függvénykód-megkötései című témakörben talál.

Warning

Az orchestrator függvényeket soha nem szabad asyncdeklarálni.

Orchestrációs trigger használata

Az orchestrációs trigger kötés támogatja a bemeneteket és a kimeneteket is. Íme néhány megjegyzés a bemeneti és kimeneti kezelésről:

  • Bemenetek: Olyan vezénylési triggereket hívhat meg, amelyek bemenetekkel rendelkeznek. A bemenetek a környezeti bemeneti objektumon keresztül érhetők el. Minden bemenetnek JSON-szerializálhatónak kell lennie.
  • Kimenetek: A vezénylési triggerek támogatják a kimeneti és a bemeneti értékeket is. A függvény visszatérési értéke a kimeneti érték hozzárendelésére szolgál. A visszatérési értéknek JSON-szerializálhatónak kell lennie.

Vezénylési trigger minta

Az alábbi kód egy egyszerű „Helló világ!” alkalmazás vezénylő függvényre mutat be példát. Ez a példa vezénylő nem ütemez feladatokat.

Az eseményindító meghatározásához használt attribútum attól függ, hogy a C#-függvényeket futtatja-e:

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

Note

Az előző kód a Durable Functions 2.x verzióra vonatkozik. Az 1.x Durable Functions esetén a DurableOrchestrationContext-t kell használni IDurableOrchestrationContext helyett. A verziók közötti különbségekről további információt a Durable Functions verziók áttekintésében talál.

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

A durable-functions kódtár meghívja a szinkron context.done metódust, amikor a generátorfüggvény kilép.

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

A legtöbb vezénylő függvény tevékenységfüggvényeket hív meg. Az alábbi kód egy „Helló világ!” alkalmazás példát tartalmaz, amely bemutatja, hogyan hívhat meg egy tevékenységfüggvényt:

[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

Az előző kód a Durable Functions 2.x verzióra vonatkozik. Az 1.x Durable Functions esetén a DurableOrchestrationContext-t kell használni IDurableOrchestrationContext helyett. A verziók közötti különbségekről további információt a Durable Functions verziók áttekintésében talál.

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

Tevékenység-eseményindító

A tevékenységindítóval olyan függvényeket fejleszthet, amelyeket a vezénylő függvények meghívnak.

A ActivityTriggerAttribute .NET attribútummal konfigurálhatja a tevékenységindítót.

Az @DurableActivityTrigger annotációt használja a tevékenységindító konfigurálására.

A tevékenységfüggvény regisztrálásához importálni kell az app objektumot a @azure/functions npm modulból. Ezután közvetlenül a függvénykódban hívja meg a app.activity Durable Functions API metódusát.

A tevékenységindító meghatározásához a következő JSON-objektumot kell használnia a bindingsfunction.jsontömbjében:

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

Az activity érték a tevékenység neve. Ez az érték az a név, amelyet a vezénylő függvények használnak a tevékenységfüggvény meghívásához. Ez a tulajdonság opcionális. Ha nem adja meg, a függvény neve lesz használva.

A Python függvény kódjában közvetlenül a activity_trigger dekorátor használatával definiálhat tevékenységindítót.

Ez az eseményindító kötés belsőleg lekérdezi a konfigurált tartós tárolót az új tevékenységvégrehajtási eseményekhez.

Eseményindító működése

Íme néhány megjegyzés a tevékenységindítóról:

  • Szálkezelés: A vezénylési triggertől eltérően a tevékenységindítók nem korlátozzák a szálkezelést vagy az I/O-műveleteket. Ezek kezelhetők, mint a normál függvények.
  • Méregüzenetek kezelése: A tevékenységindítók nem támogatják a mérgező üzeneteket.
  • Üzenet láthatósága: A tevékenységindító üzenetei le vannak kérve, és konfigurálható ideig láthatatlanok maradnak. Az üzenetek láthatósága automatikusan megújul, amíg a függvényalkalmazás fut és kifogástalan állapotban van.
  • Visszatérési értékek: A visszaadott értékek JSON-ra vannak szerializálva, és megmaradnak a konfigurált tartós tárolóban.

Használat kiváltása

A tevékenységindító kötése támogatja a bemeneteket és a kimeneteket is, ugyanúgy, mint a vezénylési eseményindítót. Íme néhány megjegyzés a bemeneti és kimeneti kezelésről:

  • Bemenetek: A tevékenységindítók egy vezénylő függvény bemeneteivel hívhatók meg. Minden bemenetnek JSON-szerializálhatónak kell lennie.
  • Kimenetek: A tevékenységfüggvények támogatják a kimeneti és a bemeneti értékeket is. A függvény visszatérési értéke a kimeneti érték hozzárendelésére szolgál, és JSON-szerializálhatónak kell lennie.
  • Metadata: A .NET tevékenységfüggvények egy string instanceId paraméterhez kapcsolódhatnak a hívó orchestration példányazonosítójának lekéréséhez.

Triggerről minta

Az alábbi kód egy egyszerű „Helló világ!” alkalmazás tevékenységfüggvényre mutat be példát.

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

A .NET ActivityTriggerAttribute kötés alapértelmezett paramétertípusa IDurableActivityContext (vagy DurableActivityContext Durable Functions 1.x esetén). .NET tevékenységindítók azonban támogatják a közvetlenül JSON-szerializálható típusok (beleértve a primitív típusokat) kötését is, így a függvény alábbi egyszerűsített verzióját is használhatja:

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

Tevékenységbemeneti és kimeneti kötések használata

A tevékenységindító kötése mellett használhat normál bemeneti és kimeneti kötéseket is.

Egy tevékenységfüggvény például fogadhat bemenetet egy vezénylő függvénytől. A tevékenységfüggvény ezután elküldheti ezt a bemenetet üzenetként az Azure Event Hubsnak.

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

Orkesztrációs kliens

A vezénylési ügyfélkötéssel olyan függvényeket írhat, amelyek interakcióba lépnek a vezénylő függvényekkel. Ezeket a függvényeket gyakran ügyfélfüggvényeknek nevezzük. Például az alábbi módokon kezelheti az orchestrációs példányokat:

  • Indítsa el őket.
  • Kérdezd le az állapotukat.
  • Állítsa le őket.
  • Eseményeket küldhet nekik futás közben.
  • Törölje a példányelőzményeket.

A DurableClientAttribute attribútum (OrchestrationClientAttribute a Durable Functions 1.x-ben) használatával lehet kötni egy orchestration klienshez.

Kötést végezhet egy vezénylési ügyfélhez a @DurableClientInput annotáció használatával.

Az ügyfélfüggvény regisztrálásához importálja az app objektumot a @azure/functions npm modulból. Ezután meghív egy Durable Functions API-metódust, amely az eseményindító típusára jellemző. EGY HTTP-eseményindító esetében például meghívja a metódust app.http . Sorbanállási indítóra a app.storageQueue metódust kell meghívni.

A tartós ügyfél eseményindítójának meghatározásához a következő JSON-objektumot kell használnia a bindingsfunction.jsontömbjében:

{
    "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"
}
  • A taskHub tulajdonság akkor használatos, ha több függvényalkalmazás is ugyanazt a tárfiókot használja, de el kell különíteni egymástól. Ha nem adja meg ezt a tulajdonságot, a rendszer ahost.json alapértelmezett értékét használja. Ennek az értéknek meg kell egyeznie azzal az értékkel, amelyet a cél vezénylő függvények használnak.
  • A connectionName érték annak az alkalmazásbeállításnak a neve, amely tartalmazza egy tárfiók kapcsolati karakterláncát. A kapcsolati karakterlánc által képviselt tárfióknak meg kell egyeznie azzal, amelyet a cél vezénylő függvények használnak. Ha nem adja meg ezt a tulajdonságot, a függvényalkalmazás alapértelmezett tárfiók-kapcsolati sztringje lesz használva.

Note

A legtöbb esetben azt javasoljuk, hogy hagyja ki ezeket a tulajdonságokat, és az alapértelmezett viselkedésre támaszkodik.

Tartós ügyfél-eseményindítót a durable_client_input dekoratőrrel definiálhat közvetlenül a Python függvény kódjában.

Ügyfél általi használat

Általában egy IDurableClient (DurableOrchestrationClient a Durable Functions 1.x-ben) implementációhoz kötődve teljes hozzáférést biztosít a Durable Functions által támogatott összes orchestrációs kliens API-hoz.

Ön általában az DurableClientContext osztályhoz kötődik.

Az ügyfélobjektumokhoz való hozzáféréshez a nyelvspecifikus SDK-t kell használnia.

A következő kód egy sorkezdeményező függvény példáját adja, amely elindít egy „Helló világ!” alkalmazás orchesztrációt.

[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

Az előzőleg bemutatott C#-kód a Durable Functions 2.x-hez tartozik. Az 1.x Durable Functions esetében a OrchestrationClient attribútum helyett a DurableClient attribútumot kell használnia, és a DurableOrchestrationClient helyett a IDurableOrchestrationClient paramétertípust kell használnia. A verziók közötti különbségekről további információt a Durable Functions verziók áttekintésében talál.

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

A kezdő példányokkal kapcsolatos részletes információkért lásd: Az Azure Durable Functions példányainak kezelése.

Entitás eseményindító

Az entitás-eseményindítóval entitásfüggvényeket fejleszthet. Ez az eseményindító támogatja egy adott entitáspéldány eseményeinek feldolgozását.

Note

Az entitás-eseményindítók a Durable Functions 2.x-től érhetők el.

Ez az eseményindító kötés belsőleg lekérdezi a konfigurált tartós tárolót az új entitásműveletek esetében, amelyeket végre kell hajtani.

Az entitás-eseményindító konfigurálásához a EntityTriggerAttribute .NET attribútumot használja.

Az entitás-eseményindító regisztrálásához importálja az app objektumot a @azure/functions npm modulból. Ezután közvetlenül a függvénykódban hívja meg a app.entity Durable Functions API metódusát.

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

Az entitás-eseményindítót a @DurableEntityTrigger széljegyzet használatával határozhatja meg. Műveletek elküldésére használható EntityRunner.loadAndRun az entitásosztályba.

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

Az entitás-eseményindítók még nem támogatottak a PowerShellben.

Az entitás-eseményindítókat a entity_trigger dekoratőrrel határozhatja meg közvetlenül a Python függvény kódjában.

Eseményindító működése

Íme néhány megjegyzés az entitás-eseményindítóról:

  • Egyszálas: A rendszer egyetlen diszpécserszálat használ egy adott entitás műveleteinek feldolgozásához. Ha egyszerre több üzenetet küld egy entitásnak, a műveletek feldolgozása egyenként történik.
  • Méregüzenetek kezelése: Az entitások eseményindítói nem támogatják a méregüzeneteket.
  • Üzenet láthatósága: Az entitásindító üzenetek kivonásra kerülnek a sorból, és egy konfigurálható időtartamra láthatatlanok maradnak. Az üzenetek láthatósága automatikusan megújul, amíg a függvényalkalmazás fut és kifogástalan állapotban van.
  • Visszaadott értékek: Az entitásfüggvények nem támogatják a visszatérési értékeket. Bizonyos API-k segítségével mentheti az állapotot, vagy visszaadhatja az értékeket a vezényléseknek.

Az entitások végrehajtása során végrehajtott állapotváltozások a végrehajtás befejezése után automatikusan megmaradnak.

Az entitás-eseményindítók definiálásával és használatával kapcsolatos további információkért és példákért tekintse meg az Entitásfüggvényeket.

Entitásügyfél

Az entitásügyfél-kötéssel aszinkron módon aktiválhat entitásfüggvényeket. Ezeket a függvényeket néha ügyfélfüggvényeknek is nevezik.

Az entitásügyfélhez az DurableClientAttribute .NET attribútummal lehet csatlakozni .NET osztálytárfüggvényekben.

Note

A [DurableClientAttribute] való kötéshez is használhatja a kötést.

Entitásügyfél regisztrálása helyett egy regisztrált függvényből hív meg egy entitás-eseményindító metódust a signalEntity vagy callEntity használatával.

  • Egy sor által aktivált függvényből a következőt használhatja 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);
    },
});

  • Vezénylő függvényből a következőt használhatja 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;
});

Az entitásügyfél definiálásához használja a durable_client_input dekoratőrt közvetlenül a Python függvény kódjában.

A @DurableClientInput annotációval kapcsolódhat egy DurableClientContext-hez, amely metódusokat biztosít az entitások jelzésére és az entitások állapotának olvasására.

  • Entitás jelzése HTTP által aktivált függvényből:

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

  • Entitásállapot beolvasása HTTP által aktivált függvényből:

    @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

Az entitás-ügyfelek még nem támogatottak a PowerShellben.

Az entitásokkal ügyfélként való interakcióval kapcsolatos további információkért és példákért lásd: Access-entitások.

Következő lépések

Beépített HTTP API-referencia példánykezeléshez

  • Last updated on