Tartós vezénylések

Cikk
04/13/2024

A Durable Functions az Azure Functions bővítménye. Vezénylő függvénnyel vezényelheti más Durable-függvények végrehajtását egy függvényalkalmazáson belül. Az Orchestrator-függvények a következő jellemzőkkel rendelkeznek:

Az Orchestrator függvények eljárási kóddal definiálják a függvény-munkafolyamatokat. Nincs szükség deklaratív sémákra vagy tervezőkre.
Az Orchestrator függvények szinkron módon és aszinkron módon is meghívhatnak más tartós függvényeket. Az úgynevezett függvények kimenete megbízhatóan menthető helyi változókba.
Az Orchestrator funkciói tartósak és megbízhatóak. A végrehajtási folyamat automatikusan ellenőrzi, ha a függvény "várja" vagy "hozamokat" ad. A helyi állapot soha nem vész el, amikor a folyamat újraindul vagy a virtuális gép újraindul.
Az Orchestrator függvények hosszú ideig futhatnak. A vezénylési példány teljes élettartama lehet másodperc, nap, hónap vagy soha nem végződő.

Ez a cikk áttekintést nyújt a vezénylő függvényekről, és arról, hogyan segíthetnek a különböző alkalmazásfejlesztési kihívások megoldásában. Ha még nem ismeri a Durable Functions-alkalmazásokban elérhető függvénytípusokat, először olvassa el a Durable Függvénytípusok című cikket.

Vezénylési identitás

A vezénylés minden példánya rendelkezik példányazonosítóval (más néven példányazonosítóval). Alapértelmezés szerint minden példányazonosító egy automatikusan létrehozott GUID. A példányazonosítók azonban bármilyen felhasználó által létrehozott sztringértékek is lehetnek. Minden vezénylési példányazonosítónak egyedinek kell lennie egy feladatközponton belül.

A példányazonosítókra vonatkozó néhány szabály a következő:

A példányazonosítóknak 1 és 100 karakter közöttinek kell lenniük.
A példányazonosítók nem kezdődnek a példánnyal @.
A példányazonosítók nem tartalmazhatnak /, \vagy #? karaktereket.
A példányazonosítók nem tartalmazhatnak vezérlő karaktereket.

Feljegyzés

Általában ajánlott automatikus példányazonosítókat használni, amikor csak lehetséges. A felhasználó által létrehozott példányazonosítók olyan helyzetekre szolgálnak, amikor a vezénylési példány és néhány külső alkalmazásspecifikus entitás, például egy vásárlási megrendelés vagy egy dokumentum között egy-az-egyhez megfeleltetés van.

Emellett a karakterkorlátozási szabályok tényleges érvényesítése az alkalmazás által használt tárolószolgáltatótól függően változhat. A helyes viselkedés és kompatibilitás biztosítása érdekében erősen ajánlott a korábban felsorolt példányazonosító-szabályokat követni.

A vezénylés példányazonosítója a legtöbb példánykezelési művelethez szükséges paraméter. A diagnosztika szempontjából is fontosak, például az alkalmazás Elemzések vezényléskövetési adatainak hibaelhárítási vagy elemzési célból történő kereséséhez. Ezért ajánlott a létrehozott példányazonosítókat külső helyre (például adatbázisba vagy alkalmazásnaplókba) menteni, ahol később könnyen hivatkozhatnak rájuk.

Megbízhatóság

Az Orchestrator-függvények az esemény-forrástervezési minta használatával megbízhatóan fenntartják a végrehajtási állapotukat. A vezénylés aktuális állapotának közvetlen tárolása helyett a Durable Task Framework egy csak hozzáfűző tárolót használ a függvényvezénylés által végrehajtott műveletek teljes sorozatának rögzítéséhez. A csak hozzáfűző tárolók számos előnnyel járnak a teljes futtatókörnyezeti állapot "memóriaképéhez" képest. Az előnyök közé tartozik a nagyobb teljesítmény, a méretezhetőség és a válaszkészség. Emellett végleges konzisztenciát is kaphat a tranzakciós adatokhoz, valamint a teljes auditnaplókhoz és előzményekhez. Az auditnaplók megbízható kompenzáló műveleteket támogatnak.

A Durable Functions transzparens módon használja az esemény-beszerzést. A színfalak mögött a await vezénylő függvény (C#) vagy yield (JavaScript/Python) operátora a vezénylési szál irányítását a Durable Task Framework diszpécserének adja vissza. Java esetén nincs speciális nyelvi kulcsszó. Ehelyett egy feladat meghívása .await() visszahozhatja az irányítást a diszpécsernek egy egyéni Throwablerendszeren keresztül. A diszpécser ezután véglegesíti azokat az új műveleteket, amelyeket a vezénylő függvény ütemezett (például egy vagy több gyermekfüggvény meghívása vagy tartós időzítő ütemezése) a tárolóba. A transzparens véglegesítési művelet úgy frissíti a vezénylési példány végrehajtási előzményeit, hogy az összes új eseményt hozzáfűzi a tárolóhoz, hasonlóan egy csak hozzáfűző naplóhoz. Hasonlóképpen, a véglegesítési művelet üzeneteket hoz létre a tárolóban a tényleges munka ütemezéséhez. Ezen a ponton a vezénylő függvény eltávolítható a memóriából. A Durable Functions alapértelmezés szerint az Azure Storage-t használja futtatókörnyezeti állapottárolóként, de más tárolószolgáltatók is támogatottak.

Ha egy vezénylési függvény több feladatot kap (például válaszüzenet érkezik, vagy egy tartós időzítő lejár), a vezénylő felébreszti és újra végrehajtja a teljes függvényt az elejétől kezdve a helyi állapot újraépítéséhez. A visszajátszás során, ha a kód egy függvényt próbál meghívni (vagy bármilyen más aszinkron műveletet végez), a Durable Task Framework az aktuális vezénylés végrehajtási előzményeit tekinti át. Ha úgy találja, hogy a tevékenységfüggvény már végrehajtotta és eredményt adott, visszajátssza a függvény eredményét, és a vezénylő kód továbbra is fut. A visszajátszás a függvénykód befejezéséig vagy az új aszinkron munka ütemezéséig folytatódik.

Feljegyzés

Ahhoz, hogy a visszajátszási minta megfelelően és megbízhatóan működjön, a vezénylő függvény kódjának determinisztikusnak kell lennie. A nem determinisztikus vezénylőkód futásidejű hibákat vagy más váratlan viselkedést eredményezhet. A vezénylőfüggvények kódkorlátozásairól további információt a vezénylő függvény kódkorlátozásainak dokumentációjában talál.

Feljegyzés

Ha egy vezénylő függvény naplóüzeneteket bocsát ki, a visszajátszási viselkedés ismétlődő naplóüzenetek küldését okozhatja. A naplózási témakörből megtudhatja, hogy miért fordul elő ez a viselkedés, és hogyan lehet megkerülni.

Vezénylési előzmények

A Durable Task Framework esemény-beszerzési viselkedése szorosan összefügg az ön által írt vezénylőfüggvény-kóddal. Tegyük fel, hogy rendelkezik egy tevékenységláncoló vezénylő függvénnyel, például a következő vezénylő függvénnyel:

Feljegyzés

Az Azure Functions Node.js programozási modelljének 4- es verziója általánosan elérhető. Az új v4-modell úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A migrálási útmutatóban további információt olvashat a v3 és a v4 közötti különbségekről.

A következő kódrészletekben a JavaScript (PM4) a V4 programozási modellt, az új felületet jelöli.

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

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

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

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

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

module.exports = df.orchestrator(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"));

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

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

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

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello Cairo!"]
    return output;
});

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

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]

main = df.Orchestrator.create(orchestrator_function)

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

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

Amikor egy tevékenységfüggvény ütemezve van, a Durable Task Framework ellenőrzi a függvény végrehajtási állapotát egy tartós tárterület háttérrendszerében (alapértelmezés szerint az Azure Table Storage-ban). Ezt az állapotot nevezzük vezénylési előzményeknek.

Előzménytábla

Általánosságban elmondható, hogy a Durable Task Framework az alábbi feladatokat végzi el minden ellenőrzőponton:

A végrehajtási előzményeket tartós tárolóba menti.
Lekérdezi azokat az üzeneteket, amelyeket a vezénylő meghívni szeretne.
Maga a vezénylő számára is lekérdezi az üzeneteket – például tartós időzítőüzeneteket.

Az ellenőrzőpont befejeződése után a vezénylő függvény szabadon eltávolítható a memóriából, amíg több munka nem történik.

Feljegyzés

Az Azure Storage nem biztosít tranzakciós garanciát az adatok táblatárolóba és üzenetsorokba való mentése között. A hibák kezeléséhez a Durable Functions Azure Storage-szolgáltató végleges konzisztenciamintákat használ. Ezek a minták biztosítják, hogy ne vesszenek el adatok, ha egy ellenőrzőpont közepén összeomlik vagy megszakad a kapcsolat. Az alternatív tárolószolgáltatók, például a Durable Functions MSSQL-tárolószolgáltató erősebb konzisztenciagaranciát biztosíthatnak.

A befejezés után a korábban bemutatott függvény előzményei az Azure Table Storage következő táblázatához hasonlóan néznek ki (illusztrációként rövidítve):

PartitionKey (InstanceId)	EventType	Időbélyegző	Bevitel	Név	Eredmény	Állapot
eaee885b	VégrehajtásStarted	2021-05-05T18:45:28.852Z	null	HelloCities
eaee885b	OrchestratorStarted	2021-05-05T18:45:32.362Z
eaee885b	Feladatütemezett	2021-05-05T18:45:32.670Z		SayHello
eaee885b	OrchestratorCompleted	2021-05-05T18:45:32.670Z
eaee885b	Feladatkiegészítés	2021-05-05T18:45:34.201Z			"""Hello Tokió!"""
eaee885b	OrchestratorStarted	2021-05-05T18:45:34.232Z
eaee885b	Feladatütemezett	2021-05-05T18:45:34.435Z		SayHello
eaee885b	OrchestratorCompleted	2021-05-05T18:45:34.435Z
eaee885b	Feladatkiegészítés	2021-05-05T18:45:34.763Z			"""Hello Seattle!"""
eaee885b	OrchestratorStarted	2021-05-05T18:45:34.857Z
eaee885b	Feladatütemezett	2021-05-05T18:45:34.857Z		SayHello
eaee885b	OrchestratorCompleted	2021-05-05T18:45:34.857Z
eaee885b	Feladatkiegészítés	2021-05-05T18:45:34.919Z			"""Hello London!"""
eaee885b	OrchestratorStarted	2021-05-05T18:45:35.032Z
eaee885b	OrchestratorCompleted	2021-05-05T18:45:35.044Z
eaee885b	Végrehajtás befejezve	2021-05-05T18:45:35.044Z			"[""Hello Tokyo!"",""Hello Seattle!"","Hello London!""]"	Befejeződött

Néhány megjegyzés az oszlopértékekről:

PartitionKey: A vezénylés példányazonosítóját tartalmazza.
EventType: Az esemény típusát jelöli. Az összes előzményesemény-típus részletes leírását itt találja.
Időbélyeg: Az előzményesemény UTC időbélyege.
Név: A meghívott függvény neve.
Bemenet: A függvény JSON-formátumú bemenete.
Eredmény: A függvény kimenete, vagyis a visszatérési értéke.

Figyelmeztetés

Bár hibakeresési eszközként hasznos, ne függjön a táblától. A Durable Functions bővítmény fejlődésével változhat.

Minden alkalommal, amikor egy feladat befejezésére való várakozás után a függvény újraindul, a Durable Task Framework az alapoktól újrafuttatja a vezénylő függvényt. Minden újrafuttatáskor a végrehajtási előzményeket tekinti át annak megállapításához, hogy az aktuális aszinkron tevékenység befejeződött-e. Ha a végrehajtási előzmények azt mutatják, hogy a tevékenység már befejeződött, a keretrendszer visszajátssza a tevékenység kimenetét, és továbblép a következő tevékenységre. Ez a folyamat a teljes végrehajtási előzmények visszajátszásáig folytatódik. Az aktuális végrehajtási előzmények visszajátszása után a helyi változók visszaállítva lesznek a korábbi értékükre.

Jellemzők és minták

A következő szakaszok a vezénylő függvények funkcióit és mintáit ismertetik.

Alvezénylések

Az Orchestrator függvények meghívhatnak tevékenységfüggvényeket, de más vezénylő függvényeket is. Létrehozhat például egy nagyobb vezénylést a vezénylő függvények könyvtárából. Egy vezénylőfüggvény több példányát is futtathatja párhuzamosan.

További információkért és példákért tekintse meg az Al-vezénylések című cikket.

Tartós időzítők

A vezénylések ütemezhetnek tartós időzítőket a késések implementálásához vagy időtúllépési kezelés beállításához az aszinkron műveletekhez. Használjon tartós időzítőket a vezénylő függvényekben a nyelvi natív "alvó" API-k helyett.

További információkért és példákért tekintse meg a Durable időzítőkről szóló cikket.

Külső események

Az Orchestrator-függvények megvárhatják, amíg a külső események frissítik a vezénylési példányt. Ez a Durable Functions funkció gyakran hasznos emberi interakciók vagy más külső visszahívások kezeléséhez.

További információkért és példákért tekintse meg a Külső események című cikket.

Hibakezelés

Az Orchestrator függvények használhatják a programozási nyelv hibakezelési funkcióit. A vezénylési kód támogatja a meglévő mintákat try/catch .

Az Orchestrator-függvények újrapróbálkozési szabályzatokat is hozzáadhatnak az általuk hívott tevékenységhez vagy al-vezénylő függvényekhez. Ha egy tevékenység vagy alvezénylő függvény kivétellel meghiúsul, a megadott újrapróbálkozási szabályzat automatikusan késleltetheti és újrapróbálkozza a végrehajtást egy megadott számú alkalommal.

Feljegyzés

Ha egy vezénylési függvény nem kezelt kivételt tapasztal, a vezénylési példány állapotban Failed fejeződik be. A vezénylési példányokat nem lehet újrapróbálkozásra, ha az sikertelen volt.

További információkért és példákért tekintse meg a hibakezelési cikket.

Kritikus szakaszok (Durable Functions 2.x, jelenleg csak .NET)

A vezénylési példányok egyszálasak, így nem szükséges a vezénylésen belüli versenyfeltételek miatt aggódni. A versenyfeltételek azonban akkor lehetségesek, ha a vezénylések külső rendszerekkel kommunikálnak. A külső rendszerekkel való interakció során a versenyhelyzetek mérséklése érdekében a vezénylő függvények a .NET-ben egy metódussal definiálhatják a kritikus szakaszokat.LockAsync

Az alábbi mintakód egy kritikus szakaszt definiáló vezénylő függvényt mutat be. A metódussal belép a kritikus szakaszba LockAsync . Ehhez a módszerhez egy vagy több hivatkozást kell átadni egy tartós entitásnak, amely tartósan kezeli a zárolási állapotot. A vezénylésnek csak egyetlen példánya tudja egyszerre végrehajtani a kódot a kritikus szakaszban.

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

A LockAsync tartós zár(ok) beszerzése és a IDisposable kritikus szakasz végének visszaadása a megsemmisítéskor. Ez az IDisposable eredmény blokkokkal using együtt használható a kritikus szakasz szintaktikai ábrázolásának lekéréséhez. Amikor egy vezénylő függvény kritikus szakaszba lép, csak egy példány tudja végrehajtani ezt a kódblokkot. A kritikus szakaszba belépni próbáló egyéb példányok mindaddig le lesznek tiltva, amíg az előző példány ki nem lép a kritikus szakaszból.

A kritikus szakasz funkció a tartós entitások módosításainak összehangolásához is hasznos. A kritikus szakaszokról további információt a Durable entitások "Entitáskoordináció" című témakörében talál.

Feljegyzés

Kritikus szakaszok érhetők el a Durable Functions 2.0-ban. Jelenleg csak a .NET in-proc vezénylések implementálják ezt a funkciót. Az entitások és a kritikus szakaszok még nem érhetők el a Durable Functionsben a dotnet-izolált feldolgozó számára.

HTTP-végpontok meghívása (Durable Functions 2.x)

A vezénylő függvények nem végezhetnek I/O-t a vezénylő függvénykódokra vonatkozó korlátozásokban leírtak szerint. Ennek a korlátozásnak a tipikus megkerülő megoldása az, hogy becsomagolja azokat a kódot, amelyeknek I/O-t kell elvégeznie egy tevékenységfüggvényben. A külső rendszerekkel interakcióba lépő vezénylések gyakran használnak tevékenységfüggvényeket HTTP-hívások indításához és az eredménynek a vezényléshez való visszaadásához.

A gyakori minta egyszerűsítése érdekében a vezénylő függvények a metódus használatával közvetlenül meghívhatják a CallHttpAsync HTTP API-kat.

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

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

    if ((int)response.StatusCode == 400)
    {
        // handling of error codes goes here
    }
}

A gyakori minta egyszerűsítése érdekében a vezénylő függvények a metódus használatával közvetlenül meghívhatják a CallHttpAsync HTTP API-kat. A C# (izolált) esetében ez a funkció a Microsoft.Azure.Functions.Worker.Extensions.DurableTask 1.1.0-s verzióban lett bevezetve.

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

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

    if ((int)response.StatusCode == 400)
    {
        // handling of error codes goes here
    }
}

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

module.exports = df.orchestrator(function*(context) {
    const url = context.df.getInput();
    var res = yield context.df.callHttp("GET", url);
    if (res.statusCode >= 400) {
        // handling of error codes goes here
    }
});

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) {
        // handling of error codes goes here
    }
});

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

def orchestrator_function(context: df.DurableOrchestrationContext):
    url = context.get_input()
    res = yield context.call_http('GET', url)
    if res.status_code >= 400:
        # handing of error code goes here

Az alapszintű kérés- és válaszminták támogatása mellett a módszer támogatja a gyakori aszinkron HTTP 202 lekérdezési minták automatikus kezelését, valamint támogatja a külső szolgáltatásokkal való hitelesítést felügyelt identitásokkal.

További információkért és részletes példákért tekintse meg a HTTP-funkciókról szóló cikket.

Feljegyzés

A HTTP-végpontok közvetlenül a vezénylő függvényekből való meghívása a Durable Functions 2.0-s és újabb verziókban érhető el.

Több paraméter átadása

Nem lehet közvetlenül több paramétert átadni egy tevékenységfüggvénynek. A javaslat az objektumok vagy összetett objektumok tömbjének átadása.

A .NET-ben ValueTuple-objektumokat is használhat. Az alábbi minta a C# 7-hez hozzáadott ValueTuple új funkcióit használja:

[FunctionName("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string major = "ComputerScience";
    int universityYear = context.GetInput<int>();

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

[FunctionName("CourseRecommendations")]
public static async Task<object> Mapper([ActivityTrigger] IDurableActivityContext inputs)
{
    // parse input for student's major and year in university
    (string Major, int UniversityYear) studentInfo = inputs.GetInput<(string, int)>();

    // retrieve and return course recommendations by major and university year
    return new
    {
        major = studentInfo.Major,
        universityYear = studentInfo.UniversityYear,
        recommendedCourses = new []
        {
            "Introduction to .NET Programming",
            "Introduction to Linux",
            "Becoming an Entrepreneur"
        }
    };
}

A .NET-ben ValueTuple-objektumokat is használhat. Az alábbi minta a C# 7-hez hozzáadott ValueTuple új funkcióit használja:

[Function("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context, int universityYear)
{
    string major = "ComputerScience";

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

[FunctionName("CourseRecommendations")]
public static async Task<object> Mapper(
    [ActivityTrigger] (string Major, int UniversityYear) studentInfo, FunctionContext executionContext)
{
    // retrieve and return course recommendations by major and university year
    return new
    {
        major = studentInfo.Major,
        universityYear = studentInfo.UniversityYear,
        recommendedCourses = new []
        {
            "Introduction to .NET Programming",
            "Introduction to Linux",
            "Becoming an Entrepreneur"
        }
    };
}

Orchestrator

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

module.exports = df.orchestrator(function*(context) {
    const location = {
        city: "Seattle",
        state: "WA"
    };
    const weather = yield context.df.callActivity("GetWeather", location);

    // ...
});

`GetWeather` Tevékenység

module.exports = async function (context, location) {
    const {city, state} = location; // destructure properties into variables

    // ...
};

const getWeatherActivityName = "getWeather";

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

    // ...
});

df.app.activity(getWeatherActivityName, async function (location) {
    const { city, state } = location; // destructure properties into variables

    // ...
});

Orchestrator

from collections import namedtuple
import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    Location = namedtuple('Location', ['city', 'state'])
    location = Location(city='Seattle', state= 'WA')

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

    # ...

`GetWeather` Tevékenység

from collections import namedtuple

Location = namedtuple('Location', ['city', 'state'])

def main(location: Location) -> str:
    city, state = location
    return f"Hello {city}, {state}!"

Orchestrator

param($Context)

$output = @()

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

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

# ...

`GetWeather` Tevékenység

param($location)

"Hello $($location.City), $($location.State)!"
# ...

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

@FunctionName("GetWeather")
public String getWeather(@DurableActivityTrigger(name = "location") Location location) {
    if (location.city.equals("Seattle") && location.state.equals("WA")) {
        return "Cloudy";
    } else {
        return "Unknown";
    }
}

class Location {
    public String city;
    public String state;
}

Következő lépések

Vezénylési kódkorlátozások

Megosztás a következőn keresztül:

Tartós vezénylések

Vezénylési identitás

Megbízhatóság

Vezénylési előzmények

Előzménytábla

Jellemzők és minták

Alvezénylések

Tartós időzítők

Külső események

Hibakezelés

Kritikus szakaszok (Durable Functions 2.x, jelenleg csak .NET)

HTTP-végpontok meghívása (Durable Functions 2.x)

Több paraméter átadása

Orchestrator

`GetWeather` Tevékenység

Orchestrator

`GetWeather` Tevékenység

Orchestrator

`GetWeather` Tevékenység

Következő lépések

Visszajelzés

További források