Řetězení funkcí v Durable Functions – ukázka sekvence Hello

Článek
07/27/2024

Řetězení funkcí odkazuje na vzor spuštění posloupnosti funkcí v určitém pořadí. Výstup jedné funkce je často potřeba použít na vstup jiné funkce. Tento článek popisuje posloupnost řetězení, kterou vytvoříte při dokončení rychlého startu Durable Functions (C#, JavaScript, TypeScript , Python, PowerShell nebo Java). Další informace o Durable Functions naleznete v tématu Durable Functions přehled.

Požadavky

Poznámka:

Verze 4 programovacího modelu Node.js pro Azure Functions je obecně dostupná. Nový model v4 je navržený tak, aby měl flexibilnější a intuitivnější prostředí pro vývojáře v JavaScriptu a TypeScriptu. Další informace o rozdílech mezi v3 a v4 najdete v průvodci migrací.

V následujících fragmentech kódu JavaScript (PM4) označuje programovací model V4, nové prostředí.

Funkce

Tento článek vysvětluje následující funkce v ukázkové aplikaci:

E1_HelloSequence: Funkce orchestrátoru, která volá E1_SayHello vícekrát v posloupnosti. Ukládá výstupy z E1_SayHello volání a zaznamenává výsledky.
E1_SayHello: Funkce aktivity, která předpendí řetězec s textem "Hello".
HttpStart: Funkce odolného klienta aktivovaná protokolem HTTP, která spouští instanci orchestrátoru.

funkce orchestrátoru E1_HelloSequence

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

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

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

Všechny funkce orchestrace jazyka C# musí mít parametr typu DurableOrchestrationContext, který existuje v Microsoft.Azure.WebJobs.Extensions.DurableTask sestavení. Tento kontextový objekt umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho CallActivityAsync metody.

Kód volá E1_SayHello třikrát v sekvenci s různými hodnotami parametrů. Návratová hodnota každého volání se přidá do outputs seznamu, který se vrátí na konci funkce.

function.json

Pokud pro vývoj používáte Visual Studio Code nebo Azure Portal, tady je obsah souboru function.json pro funkci orchestrátoru. Většina orchestrátoru function.json soubory vypadá téměř přesně takto.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Důležité je typ vazby orchestrationTrigger . Všechny funkce orchestrátoru musí používat tento typ triggeru.

Upozorňující

Pokud chcete dodržovat pravidlo "žádné vstupně-výstupní operace" funkcí orchestrátoru, nepoužívejte při použití orchestrationTrigger vazby aktivační události žádné vstupní ani výstupní vazby. Pokud jsou potřeba jiné vstupní nebo výstupní vazby, měly by se použít v kontextu activityTrigger funkcí, které volá orchestrátor. Další informace najdete v článku omezení kódu funkce orchestrátoru.

index.js

Tady je funkce orchestrátoru:

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

module.exports = df.orchestrator(function* (context) {
    context.log("Starting chain sample");
    const output = [];
    output.push(yield context.df.callActivity("E1_SayHello", "Tokyo"));
    output.push(yield context.df.callActivity("E1_SayHello", "Seattle"));
    output.push(yield context.df.callActivity("E1_SayHello", "London"));

    return output;
});

Všechny funkce orchestrace Jazyka JavaScript musí obsahovat durable-functions modul. Je to knihovna, která umožňuje psát Durable Functions v JavaScriptu. Mezi funkcí orchestrátoru a dalšími javascriptovými funkcemi existují tři významné rozdíly:

Funkce orchestrátoru je generátorová funkce.
Funkce se zabalí do volání durable-functions metody modulu orchestrator (zde df).
Funkce musí být synchronní. Vzhledem k tomu, že metoda "orchestrator" zpracovává konečné volání "context.done", měla by funkce jednoduše "return".

Objekt context obsahuje objekt s trvalým kontextem df orchestrace, který umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho callActivity metody. Kód volá E1_SayHello třikrát v sekvenci s různými hodnotami parametrů, pomocí které yield označuje, že provádění by mělo čekat na volání asynchronní funkce aktivity, která se mají vrátit. Návratová hodnota každého volání se přidá do outputs pole, které se vrátí na konci funkce.

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

const helloActivityName = "sayHello";

df.app.orchestration("helloSequence", function* (context) {
    context.log("Starting chain sample");

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

    return output;
});

Všechny funkce orchestrace Jazyka JavaScript musí obsahovat durable-functions modul. Tento modul umožňuje psát Durable Functions v JavaScriptu. Pokud chcete použít programovací model uzlu V4, musíte nainstalovat verzi durable-functionsPreview v3.x .

Mezi funkcí orchestrátoru a dalšími javascriptovými funkcemi existují dva významné rozdíly:

Funkce orchestrátoru je generátorová funkce.
Funkce musí být synchronní. Funkce by měla jednoduše "return".

Objekt context obsahuje objekt s trvalým kontextem df orchestrace, který umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho callActivity metody. Kód volá sayHello třikrát v sekvenci s různými hodnotami parametrů, pomocí které yield označuje, že provádění by mělo čekat na volání asynchronní funkce aktivity, která se mají vrátit. Návratová hodnota každého volání se přidá do outputs pole, které se vrátí na konci funkce.

Poznámka:

Python Durable Functions je k dispozici pouze pro modul runtime Functions 3.0.

function.json

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

Důležité je typ vazby orchestrationTrigger . Všechny funkce orchestrátoru musí používat tento typ triggeru.

Upozorňující

init.py

Tady je funkce orchestrátoru:

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


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

main = df.Orchestrator.create(orchestrator_function)

Všechny funkce orchestrace Pythonu durable-functions musí obsahovat balíček. Je to knihovna, která umožňuje psát Durable Functions v Pythonu. Mezi funkcí orchestrátoru a dalšími funkcemi Pythonu existují dva významné rozdíly:

Funkce orchestrátoru je generátorová funkce.
Soubor by měl zaregistrovat funkci orchestrátoru jako orchestrátor tím, že na konci souboru hlásímain = df.Orchestrator.create(<orchestrator function name>). To pomáhá odlišit ho od ostatních pomocných funkcí deklarovaných v souboru.

Objekt context umožňuje volat jiné funkce aktivity a předávat vstupní parametry pomocí jeho call_activity metody. Kód volá E1_SayHello třikrát v sekvenci s různými hodnotami parametrů, pomocí které yield označuje, že provádění by mělo čekat na volání asynchronní funkce aktivity, která se mají vrátit. Vrácená hodnota každého volání se vrátí na konci funkce.

funkce aktivity E1_SayHello

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

Aktivity používají ActivityTrigger atribut. Pomocí poskytnutého IDurableActivityContext kódu můžete provádět akce související s aktivitami, jako je například přístup ke vstupní hodnotě pomocí GetInput<T>.

Implementace E1_SayHello je poměrně triviální operace formátování řetězců.

Místo vazby na funkci IDurableActivityContextaktivity můžete vytvořit vazbu přímo na typ, který se předá do funkce aktivity. Příklad:

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

E1_SayHello/function.json

Soubor function.json pro funkci E1_SayHello aktivity je podobný souboru s tím rozdílem E1_HelloSequence , že používá activityTrigger typ vazby místo orchestrationTrigger typu vazby.

{
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Poznámka:

Všechny funkce aktivit volané funkcí orchestrace musí používat activityTrigger vazbu.

Implementace E1_SayHello je poměrně triviální operace formátování řetězců.

E1_SayHello/index.js

module.exports = function (context) {
    context.done(null, `Hello ${context.bindings.name}!`);
};

Na rozdíl od funkce orchestrace nepotřebuje funkce aktivity žádné speciální nastavení. Vstup předaný funkcí orchestrátoru je umístěn v objektu context.bindings pod názvem activityTrigger vazby - v tomto případě context.bindings.name. Název vazby lze nastavit jako parametr exportované funkce a přistupovat k němu přímo, což je to, co vzorový kód dělá.

Implementace sayHello je poměrně triviální operace formátování řetězců.

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

const helloActivityName = "sayHello";

df.app.activity(helloActivityName, {
    handler: function (input) {
        return `Hello ${input}`;
    },
});

Na rozdíl od funkce orchestrace nepotřebuje funkce aktivity žádné speciální nastavení. Vstup předaný funkcí orchestrátoru je prvním argumentem funkce. Druhým argumentem je kontext vyvolání, který se v tomto příkladu nepoužívá.

E1_SayHello/function.json

Soubor function.json pro funkci E1_SayHello aktivity je podobný souboru s tím rozdílem E1_HelloSequence , že používá activityTrigger typ vazby místo orchestrationTrigger typu vazby.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ]
}

Poznámka:

Všechny funkce aktivit volané funkcí orchestrace musí používat activityTrigger vazbu.

Implementace E1_SayHello je poměrně triviální operace formátování řetězců.

E1_SayHello/init.py

def main(name: str) -> str:
    return f"Hello {name}!"

Na rozdíl od funkce orchestrátoru funkce aktivity nepotřebuje žádné speciální nastavení. Vstup předaný funkcí orchestrátoru je přímo přístupný jako parametr funkce.

Funkce klienta HttpStart

Instanci funkce orchestrátoru můžete spustit pomocí klientské funkce. Použijete funkci aktivovanou protokolem HttpStart HTTP ke spuštění instancí E1_HelloSequence.

public static class HttpStart
{
    [FunctionName("HttpStart")]
    public static async Task<HttpResponseMessage> Run(
        [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
        [DurableClient] IDurableClient starter,
        string functionName,
        ILogger log)
    {
        // Function input comes from the request content.
        object eventData = await req.Content.ReadAsAsync<object>();
        string instanceId = await starter.StartNewAsync(functionName, eventData);

        log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

        return starter.CreateCheckStatusResponse(req, instanceId);
    }
}

Aby funkce fungovala s orchestrátory, musí obsahovat DurableClient vstupní vazbu. Ke spuštění orchestrace použijete klienta. Může vám také pomoct vrátit odpověď HTTP obsahující adresy URL pro kontrolu stavu nové orchestrace.

HttpStart/function.json

{
    "bindings": [
      {
        "authLevel": "anonymous",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "route": "orchestrators/{functionName}",
        "methods": ["post"]
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "starter",
        "type": "orchestrationClient",
        "direction": "in"
      }
    ],
    "disabled": false
  }

Aby funkce fungovala s orchestrátory, musí obsahovat durableClient vstupní vazbu.

HttpStart/index.js

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

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = await client.startNew(req.params.functionName, undefined, req.body);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};

Slouží df.getClient k získání objektu DurableOrchestrationClient . Ke spuštění orchestrace použijete klienta. Může vám také pomoct vrátit odpověď HTTP obsahující adresy URL pro kontrolu stavu nové orchestrace.

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

app.http("httpStart", {
    route: "orchestrators/{orchestratorName}",
    extraInputs: [df.input.durableClient()],
    handler: async (request, context) => {
        const client = df.getClient(context);
        const body = await request.json();
        const instanceId = await client.startNew(request.params.orchestratorName, { input: body });

        context.log(`Started orchestration with ID = '${instanceId}'.`);

        return client.createCheckStatusResponse(request, instanceId);
    },
});

Ke správě a interakci s orchestrátory potřebuje durableClient funkce vstupní vazbu. Tuto vazbu je potřeba zadat v argumentu extraInputs při registraci funkce. Vstup durableClient lze získat voláním df.input.durableClient().

Slouží df.getClient k získání objektu DurableClient . Ke spuštění orchestrace použijete klienta. Může vám také pomoct vrátit odpověď HTTP obsahující adresy URL pro kontrolu stavu nové orchestrace.

HttpStart/function.json

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "route": "orchestrators/{functionName}",
      "methods": [
        "post",
        "get"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

Aby funkce fungovala s orchestrátory, musí obsahovat durableClient vstupní vazbu.

HttpStart/init.py

import logging

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


async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    instance_id = await client.start_new(req.route_params["functionName"], None, None)

    logging.info(f"Started orchestration with ID = '{instance_id}'.")

    return client.create_check_status_response(req, instance_id)

Pomocí konstruktoru DurableOrchestrationClient získejte klienta Durable Functions. Ke spuštění orchestrace použijete klienta. Může vám také pomoct vrátit odpověď HTTP obsahující adresy URL pro kontrolu stavu nové orchestrace.

Spuštění ukázky

Pokud chcete orchestraci spustit E1_HelloSequence , odešlete do HttpStart funkce následující požadavek HTTP POST.

POST http://{host}/orchestrators/E1_HelloSequence

Poznámka:

Předchozí fragment kódu HTTP předpokládá, že v host.json souboru existuje položka, která odebere výchozí api/ předponu ze všech adres URL aktivačních funkcí HTTP. Značky pro tuto konfiguraci najdete v host.json souboru v ukázkách.

Pokud například spouštíte ukázku v aplikaci funkcí s názvem "myfunctionapp", nahraďte {host} textem "myfunctionapp.azurewebsites.net".

Výsledkem je odpověď HTTP 202, jako je tato (zkrácená kvůli stručnosti):

HTTP/1.1 202 Accepted
Content-Length: 719
Content-Type: application/json; charset=utf-8
Location: http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

(...trimmed...)

V tomto okamžiku se orchestrace zařadí do fronty a začne se okamžitě spouštět. Adresu URL v Location hlavičce můžete použít ke kontrole stavu spuštění.

GET http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

Výsledkem je stav orchestrace. Spustí se a dokončí se rychle, takže se zobrazí ve stavu Dokončeno s odpovědí, která vypadá takto (zkrácená kvůli stručnosti):

HTTP/1.1 200 OK
Content-Length: 179
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":null,"output":["Hello Tokyo!","Hello Seattle!","Hello London!"],"createdTime":"2017-06-29T05:24:57Z","lastUpdatedTime":"2017-06-29T05:24:59Z"}

Jak vidíte, runtimeStatus instance je Dokončena a output obsahuje serializovaný výsledek funkce orchestratoru.

Poznámka:

Můžete implementovat podobnou počáteční logiku pro jiné typy triggerů, jako je queueTrigger, eventHubTriggernebo timerTrigger.

Podívejte se na protokoly spuštění funkce. Funkce se spustila E1_HelloSequence a dokončila několikrát kvůli chování přehrávání popsanému v tématu o spolehlivosti orchestrace. Na druhé straně došlo pouze ke třem spuštěním E1_SayHello , protože tyto provádění funkcí se nepřehrají.

Další kroky

Tato ukázka ukázala jednoduchou orchestraci zřetězení funkcí. Další ukázka ukazuje, jak implementovat vzor ventilátoru nebo ventilátoru.

Spuštění ukázky ventilátoru nebo ventilátoru

Sdílet prostřednictvím

Řetězení funkcí v Durable Functions – ukázka sekvence Hello

Požadavky

Funkce

funkce orchestrátoru E1_HelloSequence

function.json

index.js

function.json

init.py

funkce aktivity E1_SayHello

E1_SayHello/function.json

E1_SayHello/index.js

E1_SayHello/function.json

E1_SayHello/init.py

Funkce klienta HttpStart

HttpStart/function.json

HttpStart/index.js

HttpStart/function.json

HttpStart/init.py

Spuštění ukázky

Další kroky

Váš názor

Další materiály