Łączenie łańcuchów funkcji w rozszerzeniu Durable Functions — przykładowa sekwencja Hello

• Ukończ artykuł Szybki start
• Klonowanie lub pobieranie projektu przykładów z usługi GitHub

• Ukończ artykuł Szybki start
• Klonowanie lub pobieranie projektu przykładów z usługi GitHub

• Ukończ artykuł Szybki start
• Klonowanie lub pobieranie projektu przykładów z usługi GitHub

• Ukończ artykuł Szybki start
• Klonowanie lub pobieranie projektu przykładów z usługi GitHub

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

Wszystkie funkcje orkiestracji języka C# muszą mieć parametr typu DurableOrchestrationContext, który istnieje w Microsoft.Azure.WebJobs.Extensions.DurableTask zestawie. Ten obiekt kontekstu umożliwia wywoływanie innych funkcji działania i przekazywanie parametrów wejściowych przy użyciu jego CallActivityAsync metody.

Kod wywołuje E1_SayHello trzy razy w sekwencji z różnymi wartościami parametrów. Wartość zwracana każdego wywołania jest dodawana do outputs listy, która jest zwracana na końcu funkcji.

function.json

Jeśli do programowania używasz programu Visual Studio Code lub witryny Azure Portal, oto zawartość pliku function.json dla funkcji orkiestratora. Większość plików function.json orkiestratora wygląda prawie dokładnie tak.

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

Ważnym elementem orchestrationTrigger jest typ powiązania. Wszystkie funkcje orkiestratora muszą używać tego typu wyzwalacza.

index.js

Oto funkcja orkiestratora:

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

Wszystkie funkcje orkiestracji języka JavaScript muszą zawierać durable-functions moduł. Jest to biblioteka, która umożliwia pisanie rozszerzenia Durable Functions w języku JavaScript. Istnieją trzy znaczące różnice między funkcją orkiestratora a innymi funkcjami języka JavaScript:

1. Funkcja orkiestratora jest funkcją generatora.
2. Funkcja jest owinięta w wywołaniu metody modułu durable-functions orchestrator (tutaj ).df
3. Funkcja musi być synchroniczna. Ponieważ metoda "orchestrator" obsługuje ostateczne wywołanie "context.done", funkcja powinna po prostu "zwrócić".

Obiekt context zawiera df trwały obiekt kontekstu orkiestracji, który umożliwia wywoływanie innych funkcji działania i przekazywanie parametrów wejściowych przy użyciu jego callActivity metody. Kod wywołuje E1_SayHello trzy razy w sekwencji z różnymi wartościami parametrów, używając polecenia yield , aby wskazać, że wykonanie powinno czekać na zwracane wywołania funkcji async. Wartość zwracana każdego wywołania jest dodawana do outputs tablicy, która jest zwracana na końcu funkcji.

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

Wszystkie funkcje orkiestracji języka JavaScript muszą zawierać durable-functions moduł. Ten moduł umożliwia pisanie rozszerzenia Durable Functions w języku JavaScript. Aby użyć modelu programowania węzłów w wersji 4, należy zainstalować wersję zapoznawcza v3.x programu durable-functions.

Istnieją dwie znaczące różnice między funkcją orkiestratora a innymi funkcjami języka JavaScript:

1. Funkcja orkiestratora jest funkcją generatora.
2. Funkcja musi być synchroniczna. Funkcja powinna po prostu zwracać.

Obiekt context zawiera df trwały obiekt kontekstu orkiestracji, który umożliwia wywoływanie innych funkcji działania i przekazywanie parametrów wejściowych przy użyciu jego callActivity metody. Kod wywołuje sayHello trzy razy w sekwencji z różnymi wartościami parametrów, używając polecenia yield , aby wskazać, że wykonanie powinno czekać na zwracane wywołania funkcji async. Wartość zwracana każdego wywołania jest dodawana do outputs tablicy, która jest zwracana na końcu funkcji.

function.json

Jeśli do programowania używasz programu Visual Studio Code lub witryny Azure Portal, oto zawartość pliku function.json dla funkcji orkiestratora. Większość plików function.json orkiestratora wygląda prawie dokładnie tak.

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

Ważnym elementem orchestrationTrigger jest typ powiązania. Wszystkie funkcje orkiestratora muszą używać tego typu wyzwalacza.

__init__.py

Oto funkcja orkiestratora:

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)

Wszystkie funkcje orkiestracji języka Python muszą zawierać durable-functions pakiet. Jest to biblioteka, która umożliwia pisanie rozszerzenia Durable Functions w języku Python. Istnieją dwie znaczące różnice między funkcją orkiestratora a innymi funkcjami języka Python:

1. Funkcja orkiestratora jest funkcją generatora.
2. Plik powinien zarejestrować funkcję orkiestratora jako koordynatora, stwierdzając main = df.Orchestrator.create(<orchestrator function name>) na końcu pliku. Ułatwia to odróżnienie go od innych, pomocnika, funkcji zadeklarowanych w pliku.

Obiekt context umożliwia wywoływanie innych funkcji działania i przekazywanie parametrów wejściowych przy użyciu jego call_activity metody. Kod wywołuje E1_SayHello trzy razy w sekwencji z różnymi wartościami parametrów, używając polecenia yield , aby wskazać, że wykonanie powinno czekać na zwracane wywołania funkcji async. Zwracana wartość każdego wywołania jest zwracana na końcu funkcji.

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

Działania używają atrybutu ActivityTrigger . Użyj podanej IDurableActivityContext opcji, aby wykonać akcje związane z działaniem, takie jak uzyskiwanie dostępu do wartości wejściowej przy użyciu polecenia GetInput<T>.

Implementacja E1_SayHello jest stosunkowo trywialną operacją formatowania ciągów.

Zamiast wiązać z elementem , można powiązać bezpośrednio z typem IDurableActivityContextprzekazywanym do funkcji działania. Na przykład:

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

E1_SayHello/function.json

Plik function.json dla funkcji E1_SayHello działania jest podobny do tego, z E1_HelloSequence tą różnicą, że używa activityTrigger typu powiązania zamiast orchestrationTrigger typu powiązania.

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

Implementacja E1_SayHello jest stosunkowo trywialną operacją formatowania ciągów.

E1_SayHello/index.js

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

W przeciwieństwie do funkcji orkiestracji funkcja działania nie wymaga specjalnej konfiguracji. Dane wejściowe przekazane przez funkcję orkiestratora znajdują się w context.bindings obiekcie pod nazwą activityTrigger powiązania — w tym przypadku context.bindings.name. Nazwę powiązania można ustawić jako parametr wyeksportowanej funkcji i uzyskać do nich bezpośredni dostęp, czyli przykładowy kod.

Implementacja sayHello jest stosunkowo trywialną operacją formatowania ciągów.

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

const helloActivityName = "sayHello";

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

W przeciwieństwie do funkcji orkiestracji funkcja działania nie wymaga specjalnej konfiguracji. Dane wejściowe przekazane przez funkcję orkiestratora są pierwszym argumentem funkcji. Drugim argumentem jest kontekst wywołania, który nie jest używany w tym przykładzie.

E1_SayHello/function.json

Plik function.json dla funkcji E1_SayHello działania jest podobny do tego, z E1_HelloSequence tą różnicą, że używa activityTrigger typu powiązania zamiast orchestrationTrigger typu powiązania.

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

Implementacja E1_SayHello jest stosunkowo trywialną operacją formatowania ciągów.

E1_SayHello/__init__.py

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

W przeciwieństwie do funkcji orkiestratora funkcja działania nie wymaga specjalnej konfiguracji. Dane wejściowe przekazane przez funkcję orkiestratora są bezpośrednio dostępne jako parametr funkcji.

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 wchodzić w interakcje z orkiestratorami, funkcja musi zawierać DurableClient powiązanie wejściowe. Aby rozpocząć aranżację, należy użyć klienta. Może również pomóc zwrócić odpowiedź HTTP zawierającą adresy URL w celu sprawdzenia stanu nowej aranżacji.

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 wchodzić w interakcje z orkiestratorami, funkcja musi zawierać durableClient powiązanie wejściowe.

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

Użyj df.getClient polecenia , aby uzyskać DurableOrchestrationClient obiekt. Aby rozpocząć aranżację, należy użyć klienta. Może również pomóc zwrócić odpowiedź HTTP zawierającą adresy URL w celu sprawdzenia stanu nowej aranżacji.

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

Aby zarządzać orkiestratorami i korzystać z niej, funkcja wymaga powiązania wejściowego durableClient . To powiązanie należy określić w argumencie extraInputs podczas rejestrowania funkcji. Dane durableClient wejściowe można uzyskać przez wywołanie metody df.input.durableClient().

Użyj df.getClient polecenia , aby uzyskać DurableClient obiekt. Aby rozpocząć aranżację, należy użyć klienta. Może również pomóc zwrócić odpowiedź HTTP zawierającą adresy URL w celu sprawdzenia stanu nowej aranżacji.

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 wchodzić w interakcje z orkiestratorami, funkcja musi zawierać durableClient powiązanie wejściowe.

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)

Użyj konstruktora, DurableOrchestrationClient aby uzyskać klienta durable functions. Aby rozpocząć aranżację, należy użyć klienta. Może również pomóc zwrócić odpowiedź HTTP zawierającą adresy URL w celu sprawdzenia stanu nowej aranżacji.