Udostępnij za pośrednictwem

Powiązania dla trwałych funkcji (Funkcje Azure)

Rozszerzenie Durable Functions wprowadza trzy powiązania wyzwalacza, które kontrolują wykonanie funkcji orkiestratora, jednostki i aktywności. Wprowadza również powiązanie wyjściowe, które działa jako klient dla środowiska uruchomieniowego Durable Functions.

W tym artykule omówiono użycie tych czterech powiązań i przedstawiono przykłady kodu. Zawiera również informacje o właściwościach konfiguracji rozszerzenia Durable Functions w host.json, pliku metadanych, który zawiera ustawienia wpływające na wszystkie funkcje w aplikacji funkcji.

Pamiętaj, aby wybrać język programowania durable functions w górnej części artykułu.

Obie wersje modelu programowania języka Python dla usługi Azure Functions są obsługiwane przez rozszerzenie Durable Functions. Ponieważ język Python w wersji 2 jest zalecaną wersją, przykłady w tym artykule zawierają wyłącznie tę wersję.

Wymagania wstępne

  • Durable Functions SDK, czyli pakiet azure-functions-durablePyPI (Python Package Index), wersja 1.2.2 lub nowsza wersja
  • Pakiet rozszerzenia w wersji 4.x (lub nowszej), który jest ustawiony w pliku projektu host.json

Opinie i sugestie można przekazać w repozytorium Durable Functions SDK dla języka Python.

Wyzwalacz orkiestracji

Możesz użyć wyzwalacza orkiestracji, aby opracować trwałe funkcje orkiestratora. Ten wyzwalacz uruchamia się, gdy zaplanowana jest nowa instancja orkiestracji i gdy istniejąca instancja orkiestracji otrzymuje zdarzenie. Przykłady zdarzeń, które mogą uruchamiać funkcje orkiestratora, obejmują zakończenia trwałych liczników czasu, odpowiedzi funkcji aktywności oraz zdarzenia generowane przez zewnętrznych klientów.

Podczas opracowywania funkcji na platformie .NET należy użyć atrybutu OrchestrationTriggerAttribute .NET, aby skonfigurować wyzwalacz aranżacji.

W przypadku języka Java użyj adnotacji @DurableOrchestrationTrigger, aby skonfigurować wyzwalacz orkiestracji.

W przypadku używania wersji 4 modelu programowania Node.js do tworzenia funkcji należy zaimportować app obiekt z modułu @azure/functions npm . Następnie musisz wywołać metodę app.orchestration interfejsu Durable Functions API bezpośrednio w kodzie funkcji. Ta metoda rejestruje funkcję orkiestratora w frameworku Durable Functions.

Podczas pisania funkcji orkiestratora należy zdefiniować wyzwalacz orkiestracji przy użyciu następującego obiektu JSON w bindings tablicy pliku function.json :

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

Wartość orchestration to nazwa orkiestracji, której klienci muszą używać, gdy chcą uruchomić nowe wystąpienia funkcji orkiestratora. Ta właściwość jest opcjonalna. Jeśli nie określisz jej nazwy, zostanie użyta nazwa funkcji.

W przypadku korzystania z modelu programowania języka Python w wersji 2 można zdefiniować wyzwalacz aranżacji przy użyciu dekoratora orchestration_trigger bezpośrednio w kodzie funkcji języka Python.

W modelu wersji 2 masz dostęp do wyzwalaczy i powiązań Durable Functions za pomocą wystąpienia klasy DFApp. Tej podklasy można użyć do eksportowania FunctionApp dekoratorów specyficznych dla rozszerzenia Durable Functions.

Wewnętrznie to powiązanie z wyzwalaczem regularnie sprawdza skonfigurowane trwałe repozytorium w poszukiwaniu nowych zdarzeń orkiestracji. Przykłady zdarzeń obejmują zdarzenia uruchomienia orkiestracji, zdarzenia wygasania trwałego czasomierza, zdarzenia odpowiedzi funkcji aktywności i zdarzenia zewnętrzne zgłaszane przez inne funkcje.

Zachowanie wyzwalacza

Oto kilka uwag dotyczących wyzwalacza orkiestracji:

  • Jednowątkowa: pojedynczy wątek dyspozytora jest używany do wykonywania wszystkich funkcji orkiestratora w jednym wystąpieniu hosta. Z tego powodu ważne jest, aby upewnić się, że kod funkcji orkiestratora jest wydajny i nie wykonuje żadnych operacji we/wy. Ważne jest również, aby upewnić się, że ten wątek nie wykonuje żadnej asynchronicznej pracy, z wyjątkiem sytuacji, w których oczekuje się typów zadań specyficznych dla Durable Functions.
  • Obsługa komunikatów typu "poison": nie ma wsparcia dla komunikatów typu "poison" w wyzwalaczach orkiestracji.
  • Widoczność komunikatów: komunikaty wyzwalacza orkiestracji są odsłonięty i niewidoczne przez konfigurowalny czas trwania. Widoczność tych wiadomości jest automatycznie odnawiana, o ile aplikacja funkcji działa i jest w dobrej kondycji.
  • Wartości zwracane: wartości zwracane są serializowane do formatu JSON i utrwalane w tabeli historii aranżacji w usłudze Azure Table Storage. Te wartości zwrotne mogą być zapytane przez powiązanie klienta orkiestracji, opisane później.

Ostrzeżenie

Funkcje orkiestratora nigdy nie powinny używać żadnych powiązań wejściowych ani wyjściowych innych niż powiązanie wyzwalające orkiestrację. Użycie innych powiązań może powodować problemy z rozszerzeniem Durable Task, ponieważ te powiązania mogą nie przestrzegać reguł jednowątkowości i wejścia/wyjścia. Jeśli chcesz użyć innych powiązań, dodaj je do funkcji działania wywoływanej z funkcji orkiestratora. Aby uzyskać więcej informacji na temat ograniczeń kodowania funkcji orkiestratora, zobacz Ograniczenia kodu funkcji programu Orchestrator.

Ostrzeżenie

Funkcje orkiestratora nigdy nie powinny być zadeklarowane jako async.

Użycie wyzwalacza

Powiązanie wyzwalacza orkiestracji obsługuje zarówno dane wejściowe, jak i wyjściowe. Oto kilka uwag dotyczących obsługi danych wejściowych i wyjściowych:

  • Dane wejściowe: można wywoływać wyzwalacze orkiestracji, które mają dane wejściowe. Dostęp do danych wejściowych jest uzyskiwany za pośrednictwem obiektu wejściowego kontekstu. Wszystkie dane wejściowe muszą być możliwe do zserializowania w formacie JSON.
  • Dane wyjściowe: wyzwalacze orkiestracji obsługują zarówno wartości wyjściowe, jak i wejściowe. Wartość zwracana funkcji służy do przypisywania wartości wyjściowej. Wartość zwracana musi być serializowalna w formacie JSON.

Przykład wyzwalacza

Poniższy kod zawiera przykład podstawowej funkcji orkiestratora Hello World . Ten przykładowy koordynator nie planuje żadnych zadań.

Atrybut używany do definiowania wyzwalacza zależy od tego, czy uruchamiasz funkcje języka C# w tym samym procesie co proces hosta usługi Functions , czy w izolowanym procesie roboczym.

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

Uwaga

Powyższy kod dotyczy rozszerzenia Durable Functions 2.x. W przypadku Durable Functions 1.x należy użyć DurableOrchestrationContext zamiast IDurableOrchestrationContext. Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz Durable Functions versions overview (Omówienie wersji rozszerzenia 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}`;
});

Uwaga

Biblioteka durable-functions wywołuje metodę synchroniczną context.done , gdy funkcja generatora zakończy działanie.

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

Większość funkcji orkiestratora wywołuje funkcje działania. Poniższy kod zawiera przykład hello world , który pokazuje, jak wywołać funkcję działania:

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

Uwaga

Powyższy kod dotyczy rozszerzenia Durable Functions 2.x. W przypadku Durable Functions 1.x należy użyć DurableOrchestrationContext zamiast IDurableOrchestrationContext. Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz Durable Functions versions overview (Omówienie wersji rozszerzenia 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;
}

Wyzwalacz aktywności

Wyzwalacz działania umożliwia opracowywanie funkcji nazywanych funkcjami działania , które są wywoływane przez funkcje orkiestratora.

Aby skonfigurować wyzwalacz działania, należy użyć atrybutu ActivityTriggerAttribute .NET.

Adnotacja @DurableActivityTrigger służy do konfigurowania wyzwalacza działania.

Aby zarejestrować funkcję działania, należy zaimportować app obiekt z modułu @azure/functions npm . Następnie musisz wywołać metodę app.activity interfejsu Durable Functions API bezpośrednio w kodzie funkcji.

Aby zdefiniować wyzwalacz działania, należy użyć następującego obiektu JSON w bindings tablicy function.json:

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

Wartość activity jest nazwą działania. Ta wartość to nazwa, której funkcje orkiestratora używają do wywołania tej funkcji działania. Ta właściwość jest opcjonalna. Jeśli nie określisz jej nazwy, zostanie użyta nazwa funkcji.

Wyzwalacz działania można zdefiniować przy użyciu dekoratora activity_trigger bezpośrednio w kodzie funkcji języka Python.

Wewnętrznie to powiązanie wyzwalające sprawdza skonfigurowany trwały magazyn pod kątem nowych zdarzeń wykonania aktywności.

Zachowanie wyzwalacza

Oto kilka uwag dotyczących wyzwalacza aktywności:

  • Wątkowanie: w przeciwieństwie do wyzwalacza orkiestracji wyzwalacze działania nie mają żadnych ograniczeń dotyczących wątków ani operacji we/wy. Mogą być traktowane jak zwykłe funkcje.
  • Obsługa komunikatów zatrutych: wyzwalacze aktywności nie obsługują zatrutych komunikatów.
  • Widoczność komunikatów: komunikaty wyzwalacza aktywności są usunięte z kolejki i utrzymywane niewidoczne przez konfigurowalny czas trwania. Widoczność tych wiadomości jest automatycznie odnawiana, o ile aplikacja funkcji działa i jest w dobrej kondycji.
  • Zwracane wartości: wartości zwracane są serializowane do formatu JSON i utrwalane w skonfigurowanym magazynie trwałym.

Użycie wyzwalacza

Połączenie wyzwalacza aktywności obsługuje zarówno dane wejściowe, jak i wyjściowe, podobnie jak wyzwalacz orkiestracji. Oto kilka uwag dotyczących obsługi danych wejściowych i wyjściowych:

  • Dane wejściowe: wyzwalacze działania mogą być wywoływane z danymi wejściowymi z funkcji orkiestratora. Wszystkie dane wejściowe muszą być możliwe do zserializowania w formacie JSON.
  • Dane wyjściowe: funkcje działania obsługują zarówno wartości wyjściowe, jak i wejściowe. Wartość zwracana przez funkcję jest używana do przypisania wartości wyjściowej i musi być możliwa do serializacji w formacie JSON.
  • Metadane: funkcje działania platformy .NET mogą wiązać się z parametrem string instanceId w celu uzyskania identyfikatora wystąpienia wywołującej orkiestracji.

Przykład wyzwalacza

Poniższy kod zawiera przykład podstawowej funkcji działania Hello World .

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

Domyślnym typem parametru dla powiązania w platformie .NET ActivityTriggerAttribute jest IDurableActivityContext (lub DurableActivityContext w przypadku Durable Functions 1.x). Jednak wyzwalacze działań platformy .NET obsługują również powiązanie bezpośrednio z typami serializowalnymi w formacie JSON (w tym typami pierwotnymi), dzięki czemu można również użyć następującej uproszczonej wersji funkcji:

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

Używanie powiązań wejściowych i wyjściowych

Oprócz powiązania wyzwalacza działania można również używać zwykłych powiązań wejściowych i wyjściowych.

Na przykład funkcja działania może odbierać dane wejściowe z funkcji orkiestratora. Następnie funkcja działania może wysłać te dane wejściowe jako komunikat do usługi 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 orkiestracji

Powiązania klienta orkiestracji można użyć do pisania funkcji, które współdziałają z funkcjami orkiestratora. Te funkcje są często nazywane funkcjami klienta. Na przykład możesz działać na instancjach orkiestracji w następujący sposób:

  • Uruchom je.
  • Sprawdź ich status.
  • Zlikwiduj ich.
  • Wysyłaj im zdarzenia, gdy są uruchomione.
  • Wyczyść historię wystąpienia.

Można powiązać z klientem orkiestracji przy użyciu atrybutu DurableClientAttribute (OrchestrationClientAttribute w Durable Functions 1.x).

Możesz powiązać z klientem orkiestracji przy użyciu adnotacji @DurableClientInput.

Aby zarejestrować funkcję klienta, należy zaimportować app obiekt z modułu @azure/functions npm . Następnie wywołujesz metodę interfejsu API Durable Functions przeznaczoną dla określonego typu wyzwalacza. Na przykład w przypadku wyzwalacza HTTP wywołasz metodę app.http . W przypadku wyzwalacza kolejki wywołasz metodę app.storageQueue .

Aby zdefiniować trwały wyzwalacz klienta, należy użyć następującego obiektu JSON w bindings tablicy 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"
}
  • Właściwość taskHub jest używana, gdy wiele aplikacji funkcji korzysta z tego samego konta magazynu, ale muszą być od siebie oddzielone. Jeśli nie określisz tej właściwości, zostanie użyta wartość domyślna z host.json . Ta wartość musi być zgodna z wartością używaną przez funkcje orkiestratora docelowego.
  • Wartość connectionName to nazwa ustawienia aplikacji, które zawiera łańcuch połączenia konta magazynowego. Konto magazynu reprezentowane przez ten ciąg połączenia musi być tym samym, którego używają docelowe funkcje orkiestratora. Jeśli nie określisz tej właściwości, będą używane domyślne parametry połączenia konta magazynu dla aplikacji funkcji.

Uwaga

W większości przypadków zalecamy pominięcie tych właściwości i poleganie na domyślnym zachowaniu.

Wyzwalacz klienta trwałego można zdefiniować przy użyciu dekoratora durable_client_input bezpośrednio w kodzie funkcji języka Python.

Użycie przez klienta

Zazwyczaj wiążesz się z implementacją IDurableClient (DurableOrchestrationClient w Durable Functions 1.x), co zapewnia pełny dostęp do wszystkich interfejsów API orchestration client, które obsługuje Durable Functions.

Zazwyczaj wiążesz się z klasą DurableClientContext.

Aby uzyskać dostęp do obiektu klienta, musisz użyć SDK specyficznego dla języka.

Poniższy kod zawiera przykład funkcji wyzwalanej przez kolejkę, która uruchamia orkiestrację 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);
}

Uwaga

Powyższy kod języka C# dotyczy rozszerzenia Durable Functions 2.x. W przypadku rozszerzenia Durable Functions 1.x należy użyć atrybutu OrchestrationClient zamiast atrybutu DurableClient i należy użyć typu parametru DurableOrchestrationClient zamiast IDurableOrchestrationClient. Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz Durable Functions versions overview (Omówienie wersji rozszerzenia 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);
}

Aby uzyskać szczegółowe informacje na temat uruchamiania wystąpień, zobacz Manage instances in Durable Functions in Azure (Zarządzanie wystąpieniami w usłudze Durable Functions na platformie Azure).

Wyzwalacz jednostki

Możesz użyć wyzwalacza jednostki do opracowywania funkcji jednostki. Ten wyzwalacz obsługuje przetwarzanie zdarzeń dla konkretnej instancji encji.

Uwaga

Wyzwalacze jednostki są dostępne od wersji Durable Functions 2.x.

We wnętrzu, to wiązanie wyzwalacza odpytywa skonfigurowany trwały magazyn w poszukiwaniu nowych operacji na jednostkach, które wymagają wykonania.

Aby skonfigurować wyzwalacz jednostki, należy użyć atrybutu EntityTriggerAttribute .NET.

Aby zarejestrować wyzwalacz jednostki, należy zaimportować app obiekt z modułu @azure/functions npm . Następnie musisz wywołać metodę app.entity interfejsu Durable Functions API bezpośrednio w kodzie funkcji.

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

Uwaga

Wyzwalacze encji nie są jeszcze obsługiwane dla Javy.

Uwaga

Wyzwalacze encji nie są jeszcze obsługiwane w PowerShell.

Wyzwalacz jednostki można zdefiniować, używając dekoratora entity_trigger bezpośrednio w kodzie funkcji w Pythonie.

Zachowanie wyzwalacza

Oto kilka uwag dotyczących wyzwalacza jednostki:

  • Jednowątkowa: pojedynczy wątek dyspozytora służy do przetwarzania operacji dla określonej jednostki. Jeśli wiele komunikatów jest wysyłanych jednocześnie do jednej jednostki, operacje są przetwarzane pojedynczo.
  • Obsługa wadliwych komunikatów: nie ma wsparcia dla wadliwych komunikatów w wyzwalaczach jednostki.
  • Widoczność komunikatów: Komunikaty wywołane przez jednostki są usuwane z kolejki i pozostają niewidoczne przez konfigurowalny czas trwania. Widoczność tych wiadomości jest automatycznie odnawiana, o ile aplikacja funkcji działa i jest w dobrej kondycji.
  • Wartości zwracane: funkcje jednostki nie obsługują wartości zwracanych. Istnieją określone interfejsy API, których można użyć do zapisania stanu lub przekazania wartości z powrotem do aranżacji.

Wszelkie zmiany stanu wprowadzone w podmiocie podczas wykonywania są automatycznie utrwalane po jego zakończeniu.

Aby uzyskać więcej informacji i przykładów definiowania wyzwalaczy jednostek i interakcji z nimi, zobacz Funkcje jednostki.

Klient instytucjonalny

Powiązania klienta jednostki można użyć do asynchronicznego wyzwalania funkcji jednostki. Te funkcje są czasami nazywane funkcjami klienckimi.

Możesz powiązać się z klientem encji, używając atrybutu .NET DurableClientAttribute w funkcjach biblioteki klas .NET.

Uwaga

Można również użyć polecenia [DurableClientAttribute], aby powiązać z klientem orkiestracji.

Zamiast rejestrowania klienta encji, użyj signalEntity lub callEntity do wywołania metody wyzwalacza encji z dowolnej zarejestrowanej funkcji.

  • Z funkcji wyzwalanej przez kolejkę można użyć polecenia 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 funkcji orkiestratora można użyć polecenia 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 jednostki można zdefiniować przy użyciu dekoratora durable_client_input bezpośrednio w kodzie funkcji języka Python.

Uwaga

Klienci jednostek nie są jeszcze obsługiwani dla Java.

Uwaga

Klienci jednostek nie są jeszcze obsługiwani w programie PowerShell.

Aby uzyskać więcej informacji i przykłady interakcji z jednostkami jako klientem, zobacz Access entities (Jednostki programu Access).

Ustawienia rozszerzenia Durable Functions w host.json

Ta sekcja zawiera informacje o właściwościach konfiguracji rozszerzenia Durable Functions w host.json. Aby uzyskać informacje o ogólnych ustawieniach w host.json, zobacz dokumentację host.json dla Azure Functions 1.x lub dokumentację host.json dla Azure Functions 2.x i nowszych.

Ustawienia konfiguracyjne dla Durable Functions.

Uwaga

Wszystkie główne wersje funkcji Durable są obsługiwane we wszystkich wersjach środowiska wykonawczego funkcji Azure. Jednak schemat konfiguracji host.json różni się nieco w zależności od wersji środowiska uruchomieniowego usługi Azure Functions i wersji używanego rozszerzenia Durable Functions.

Poniższy kod zawiera dwa przykłady durableTask ustawień w host.json: jeden dla Durable Functions 2.x i jeden dla Durable Functions 1.x. Możesz użyć obu przykładów w usługach Azure Functions 2.0 i 3.0. W usłudze Azure Functions 1.0 dostępne ustawienia są takie same, ale sekcja durableTask w host.json znajduje się w katalogu głównym konfiguracji host.json, zamiast być umieszczona jako pole w extensions.

{
 "extensions": {
  "durableTask": {
    "hubName": "MyTaskHub",
    "defaultVersion": "1.0",
    "versionMatchStrategy": "CurrentOrOlder",
    "versionFailureStrategy": "Reject",
    "storageProvider": {
      "connectionStringName": "AzureWebJobsStorage",
      "controlQueueBatchSize": 32,
      "controlQueueBufferThreshold": 256,
      "controlQueueVisibilityTimeout": "00:05:00",
      "FetchLargeMessagesAutomatically": true,
      "maxQueuePollingInterval": "00:00:30",
      "partitionCount": 4,
      "trackingStoreConnectionStringName": "TrackingStorage",
      "trackingStoreNamePrefix": "DurableTask",
      "useLegacyPartitionManagement": false,
      "useTablePartitionManagement": true,
      "workItemQueueVisibilityTimeout": "00:05:00",
      "QueueClientMessageEncoding": "UTF8"
    },
    "tracing": {
      "traceInputsAndOutputs": false,
      "traceReplayEvents": false,
    },
    "notifications": {
      "eventGrid": {
        "topicEndpoint": "https://topic_name.westus2-1.eventgrid.azure.net/api/events",
        "keySettingName": "EventGridKey",
        "publishRetryCount": 3,
        "publishRetryInterval": "00:00:30",
        "publishEventTypes": [
          "Started",
          "Completed",
          "Failed",
          "Terminated"
        ]
      }
    },
    "maxConcurrentActivityFunctions": 10,
    "maxConcurrentOrchestratorFunctions": 10,
    "maxConcurrentEntityFunctions": 10,
    "extendedSessionsEnabled": false,
    "extendedSessionIdleTimeoutInSeconds": 30,
    "useAppLease": true,
    "useGracefulShutdown": false,
    "maxEntityOperationBatchSize": 50,
    "maxOrchestrationActions": 100000,
    "storeInputsInOrchestrationHistory": false
  }
 }
}
Majątek Wartość domyślna Opis
hubName TestHubName (DurableFunctionsHub w wersji 1.x) Nazwa centrum, które przechowuje bieżący stan aplikacji funkcji. Nazwy centrum zadań muszą zaczynać się od litery i składać się wyłącznie z liter i cyfr. Jeśli nie określisz nazwy, zostanie użyta wartość domyślna. Alternatywne nazwy centrum procesów zadań mogą służyć do izolowania wielu aplikacji Funkcje Trwałe od siebie, nawet jeśli używają tego samego zaplecza magazynowania. Aby uzyskać więcej informacji, zobacz Task hubs.
defaultVersion (wersja domyślna) Domyślna wersja przypisana do nowych instancji orkiestracji. Po określeniu wersji nowe wystąpienia orkiestracji są trwale skojarzone z tą wartością wersji. To ustawienie jest używane przez funkcję wersjonowania orkiestracji, aby umożliwić scenariusze, takie jak wdrożenia bez przestojów i zmiany powodujące niezgodność. Możesz użyć dowolnej wartości ciągu znaków dla wersji.
strategiaDopasowaniaWersji CurrentOrOlder Wartość określająca, w jaki sposób wersje orkiestracji są dopasowywane podczas ładowania funkcji orkiestratora. Prawidłowe wartości to None, Stricti CurrentOrOlder. Aby uzyskać szczegółowe objaśnienia, zobacz Wersjonowanie orkiestracji.
strategiaNiepowodzeniaWersji Odrzuć Wartość określająca, co się stanie, gdy wersja orkiestracji nie jest zgodna z bieżącą defaultVersion wartością. Prawidłowe wartości to Reject i Fail. Aby uzyskać szczegółowe objaśnienia, zobacz Wersjonowanie orkiestracji.
controlQueueBatchSize 32 Liczba wiadomości do pobrania z kolejki kontrolnej jednorazowo.
controlQueueBufferThreshold Plan zużycia dla Pythona: 32
Plan zużycia dla innych języków: 128
Plan dedykowany lub Premium: 256		 Liczba komunikatów kolejki sterowania, które mogą być buforowane w pamięci jednocześnie. Gdy zostanie osiągnięta określona liczba, dyspozytor czeka przed usunięciem z kolejki innych komunikatów. W niektórych sytuacjach zmniejszenie tej wartości może znacznie zmniejszyć zużycie pamięci.
liczba partycji 4 Liczba partycji dla kolejki sterującej. Ta wartość musi być dodatnią liczbą całkowitą z zakresu od 1 do 16. Zmiana tej wartości wymaga skonfigurowania nowego centrum zadań.
kontrolujCzasWidocznościKolejki 00:05:00 Limit czasu widoczności komunikatów usuniętych z kolejki sterowania w formacie hh:mm:ss.
limit czasu widoczności kolejki zadań 00:05:00 Limit czasu widoczności komunikatów w kolejce elementów roboczych w formacie hh:mm:ss.
AutomatycznePobieranieDużychWiadomości prawda Wartość określająca, czy mają być pobierane duże komunikaty w zapytaniach o stan aranżacji. Gdy to ustawienie to true, pobierane są duże komunikaty, które przekraczają limit rozmiaru kolejki. Gdy to ustawienie ma wartość false, pobierany jest adres URL obiektu blob wskazujący na każdy duży komunikat.
maksymalna liczba równoległych funkcji aktywności Plan zużycia: 10
Plan dedykowany lub Premium: 10 razy więcej procesorów na bieżącej maszynie		 Maksymalna liczba funkcji aktywności, które mogą być przetwarzane równocześnie na pojedynczej instancji hosta.
maksymalnaLiczbaRównoległychFunkcjiOrkiestratora Plan zużycia: 5
Plan dedykowany lub Premium: 10 razy więcej procesorów na bieżącej maszynie		 Maksymalna liczba funkcji orkiestratora, które mogą być przetwarzane jednocześnie na pojedynczej instancji hosta.
maksymalnaLiczbaRównoczesnychFunkcjiPodmiotu Plan zużycia: 5
Plan dedykowany lub Premium: 10 razy więcej procesorów na bieżącej maszynie		 Maksymalna liczba funkcji jednostki, które mogą być przetwarzane współbieżnie w jednym wystąpieniu hosta. To ustawienie ma zastosowanie tylko wtedy, gdy używasz trwałego harmonogramu zadań. W przeciwnym razie maksymalna liczba współbieżnych wykonań jednostek jest ograniczona do wartości maxConcurrentOrchestratorFunctions.
maksymalnyInterwałOdpytywaniaKolejki 00:00:30 Maksymalny interwał sondowania kolejki kontrolek i elementów roboczych w formacie hh:mm:ss . Wyższe wartości mogą prowadzić do wyższych opóźnień w przetwarzaniu wiadomości. Niższe wartości mogą prowadzić do wyższych kosztów przechowywania z powodu zwiększonej liczby transakcji magazynowych.
maxOrchestrationActions 100,000 Maksymalna liczba akcji, które może wykonywać funkcja orkiestratora podczas jednego cyklu wykonywania.
connectionName (wersja 2.7.0 lub nowsza)
connectionStringName (wersja 2.x)
azureStorageConnectionStringName (wersja 1.x)		 AzureWebJobsStorage Nazwa ustawienia aplikacji lub zbioru ustawień, które określają, jak połączyć się z bazowymi zasobami Azure Storage. Podając pojedyncze ustawienie aplikacji, powinno to być ciąg połączenia z usługą Azure Storage.
trackingStoreConnectionName (wersja 2.7.0 lub nowsza)
trackingStoreConnectionStringName		 Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z tabelami Historia i Instancje, które przechowują historię wykonywania i metadane dotyczące instancji orkiestracji. Podając pojedyncze ustawienie aplikacji, powinno to być ciąg połączenia z usługą Azure Storage. Jeśli nie określisz ustawienia, użyta zostanie wartość connectionStringName (wersja 2.x) lub wartość azureStorageConnectionStringName (wersja 1.x).
trackingStoreNamePrefix Prefiks do użycia dla tabel History i Instances, gdy podano trackingStoreConnectionStringName. Jeśli nie określisz prefiksu, zostanie użyta wartość domyślna DurableTask . Jeśli trackingStoreConnectionStringName nie zostanie określony, tabele Historia i Instancje używają wartości hubName jako prefiksu, a ustawienia trackingStoreNamePrefix są ignorowane.
śledźWejściaIWyjścia fałszywy Wartość wskazująca, czy śledzić dane wejściowe i wyjściowe wywołań funkcji. Gdy śledzone są zdarzenia wykonywania funkcji, domyślne zachowanie polega na dołączeniu liczby bajtów do serializowanych danych wejściowych i wyjściowych dla wywołań funkcji. To zachowanie zapewnia minimalne informacje o danych wejściowych i wyjściowych, dzięki czemu nie zaśmieca dzienników ani przypadkowo nie ujawnia informacji poufnych. Gdy ta właściwość ma truewartość , cała zawartość danych wejściowych i wyjściowych funkcji jest rejestrowana.
traceReplayEvents fałszywy Wartość wskazująca, czy zapisywać zdarzenia odtwarzania orkiestracji w usłudze Application Insights.
logReplayEvents fałszywy Wartość wskazująca, czy rejestrować ponowne wykonania w dziennikach aplikacji.
punkt końcowy tematu EventGrid URL punktu końcowego niestandardowego tematu Azure Event Grid. Kiedy ustawisz tę właściwość, powiadomienia o zdarzeniach cyklu życia orkiestracji są publikowane w tym punkcie końcowym. Ta właściwość obsługuje ustalanie ustawień aplikacji.
nazwaUstawieniaKluczaEventGrid Nazwa ustawienia aplikacji zawierającego klucz używany do uwierzytelniania za pomocą tematu niestandardowego usługi Event Grid pod adresem EventGridTopicEndpoint URL.
Liczba ponownych prób publikacji EventGrid 0 Liczba ponownych prób w przypadku niepowodzenia publikowania w temacie usługi Event Grid.
przedział czasowy ponownej próby publikacji EventGrid 00:05:00 Interwał ponawiania publikowania w usłudze Event Grid w formacie hh:mm:ss.
Typy Zdarzeń Publikowanych w EventGrid Lista typów zdarzeń do publikacji w Event Grid. Jeśli nie określisz żadnych typów, wszystkie typy zdarzeń zostaną opublikowane. Dozwolone wartości obejmują Started, , CompletedFailedi Terminated.
włączoneRozszerzoneSesje fałszywy Wartość określająca, czy sesje orkiestratora sesji i funkcji jednostki są buforowane.
rozszerzonyLimitCzasuBezczynnościSesjiWSekundach 30 Liczba sekund, przez które bezczynny orkiestrator lub funkcja jednostki pozostaje w pamięci przed jej zwolnieniem. To ustawienie jest używane tylko wtedy, gdy extendedSessionsEnabled ustawienie to true.
użyjAppLease prawda Wartość wskazująca, czy aplikacje muszą uzyskać dzierżawę zasobu blob na poziomie aplikacji przed przetworzeniem komunikatów ośrodka zadań. Aby uzyskać więcej informacji, zobacz Odzyskiwanie po awarii i dystrybucja geograficzna w rozszerzeniu Durable Functions. To ustawienie jest dostępne od wersji 2.3.0.
użyjZarządzaniaPodziałemLegacy fałszywy Wartość określająca typ algorytmu zarządzania partycjami do użycia. W przypadku tego ustawienia falsejest używany algorytm, który zmniejsza możliwość zduplikowania wykonywania funkcji podczas skalowania w górę. To ustawienie jest dostępne od wersji 2.3.0. Ustawienie tej wartości na true jest niewskazane.
użyjZarządzaniaPodziałemTabeli W wersji 3.x: true
W wersji 2.x: false		 Wartość określająca typ algorytmu zarządzania partycjami do użycia. W przypadku tego ustawienia truealgorytm jest używany w celu zmniejszenia kosztów kont usługi Azure Storage w wersji 2. To ustawienie jest dostępne od wersji WebJobs.Extensions.DurableTask v2.10.0. Użycie tego ustawienia z tożsamością zarządzaną wymaga WebJobs.Extensions.DurableTask w wersji 3.x lub nowszej albo Worker.Extensions.DurableTask w wersji 1.2.x lub nowszej.
użyjŁagodnegoZamknięcia fałszywy (Wersja zapoznawcza) Wartość wskazująca, czy należy zamknąć w kontrolowany sposób, aby zmniejszyć prawdopodobieństwo, że zamknięcie hosta spowoduje niepowodzenie funkcji uruchomionych w trakcie działania.
maksymalny rozmiar partii operacji na jednostkach (maxEntityOperationBatchSize) Plan zużycia: 50
Plan dedykowany lub Premium: 5000		 Maksymalna liczba operacji na encjach przetwarzanych jako pakiet. Jeśli ta wartość to 1, przetwarzanie wsadowe jest wyłączone, a każde wywołanie funkcji przetwarza każdy komunikat operacji. To ustawienie jest dostępne od wersji 2.6.1.
przechowujDaneWejścioweWWyciąguOrkiestracji fałszywy Wartość określająca sposób przechowywania danych wejściowych. Gdy to ustawienie to true, struktura Durable Task Framework zapisuje dane wejściowe działań w tabeli historii, a dane wejściowe funkcji działania są wyświetlane w wynikach zapytania historii orkiestracji.
maxGrpcMessageSizeInBytes (maksymalny rozmiar wiadomości Grpc w bajtach) 4,194,304 Wartość całkowita określająca maksymalny rozmiar w bajtach komunikatów, które może odbierać ogólny klient wywołania procedury zdalnej (gRPC). Implementacja DurableTaskClient używa klienta gRPC do zarządzania wystąpieniami orkiestracji. To ustawienie dotyczy izolowanego procesu roboczego platformy .NET rozszerzenia Durable Functions i aplikacji Java.
grpcHttpClientTimeout 00:01:40 Limit czasu w formacie hh:mm:ss dla klienta HTTP używanego przez klienta gRPC w usłudze Durable Functions. Klient jest obecnie obsługiwany w przypadku aplikacji roboczych izolowanych platformy .NET (.NET 6 i nowszych) oraz aplikacji Java.
QueueClientMessageEncoding UTF8 Strategia kodowania komunikatów usługi Azure Queue Storage. Prawidłowe strategie to Format transformacji Unicode –8-bitowy (UTF8) i Base64. To ustawienie ma zastosowanie w przypadku używania biblioteki Microsoft.Azure.WebJobs.Extensions.DurableTask 3.4.0 lub nowszych albo Microsoft.Azure.Functions.Worker.Extensions.DurableTask 1.7.0 lub nowszych.

Wiele z tych ustawień służy optymalizacji wydajności. Aby uzyskać więcej informacji, zobacz Wydajność i skalowanie.

Następne kroki

Wbudowana dokumentacja API HTTP do zarządzania instancjami

  • Last updated on