Anbindungen für Durable Functions (Azure Functions)

Beide Versionen des Python-Programmiermodells für Azure Functions werden von Durable Functions unterstützt. Da Python v2 die empfohlene Version ist, enthalten Beispiele in diesem Artikel ausschließlich diese Version.

Voraussetzungen

• Durable Functions SDK, das das Python Package Index (PyPI)-Paket azure-functions-durable, Version 1.2.2 oder höher ist
• Erweiterungspaket Version 4.x (oder eine höhere Version), die in der host.json Projektdatei festgelegt wird

Sie können Feedback und Vorschläge im Durable Functions SDK für Python Repository bereitstellen.

Wenn Sie Funktionen in .NET entwickeln, verwenden Sie das Attribut OrchestrationTriggerAttribute .NET zum Konfigurieren des Orchestrierungstriggers.

Für Java verwenden Sie die @DurableOrchestrationTrigger Anmerkung, um den Orchestrierungstrigger zu konfigurieren.

Wenn Sie Version 4 des Node.js Programmiermodells zum Entwickeln von Funktionen verwenden, importieren Sie das app Objekt aus dem @azure/functions npm Modul. Anschließend rufen Sie die app.orchestration-Methode der Durable Functions-API direkt in Ihrem Funktionscode auf. Diese Methode registriert Ihre Orchestratorfunktion mit dem Durable Functions Framework.

Wenn Sie Orchestratorfunktionen schreiben, definieren Sie den Orchestrierungstrigger mithilfe des folgenden JSON-Objekts im bindings Array der function.json-Datei :

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

Der orchestration Wert ist der Name der Orchestrierung, die Clients verwenden müssen, wenn sie neue Instanzen der Orchestratorfunktion starten möchten. Diese Eigenschaft ist optional. Wenn Sie sie nicht angeben, wird der Name der Funktion verwendet.

Wenn Sie das Python v2-Programmiermodell verwenden, können Sie einen Orchestrierungstrigger mithilfe des orchestration_trigger Dekorators direkt in Ihrem Python Funktionscode definieren.

Im v2-Modell greifen Sie auf die Durable Functions Trigger und Bindungen aus einer Instanz von DFApp zu. Sie können diese Unterklasse von FunctionApp verwenden, um Dekorateure zu exportieren, die für Durable Functions spezifisch sind.

Das Attribut, das Sie zum Definieren des Triggers verwenden, hängt davon ab, ob Sie Ihre C#-Funktionen im selben Prozess wie der Hostprozess "Functions" oder in einem isolierten Arbeitsprozess ausführen.

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

[Function("HelloWorld")]
public static string RunOrchestrator([OrchestrationTrigger] TaskOrchestrationContext context, string name)
{
    return $"Hello {name}!";
}

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

df.app.orchestration('helloOrchestrator', function* (context) {
    const name = context.df.getInput();
    return `Hello ${name}`;
});

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

Die meisten Orchestratorfunktionen rufen Aktivitätsfunktionen auf. Der folgende Code enthält ein Hello World Beispiel zum Aufrufen einer Aktivitätsfunktion:

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

Sie verwenden das Attribut ActivityTriggerAttribute .NET zum Konfigurieren des Aktivitätstriggers.

Sie verwenden die @DurableActivityTrigger Anmerkung, um den Aktivitätstrigger zu konfigurieren.

Um Ihre Aktivitätsfunktion zu registrieren, importieren Sie das app Objekt aus dem @azure/functions npm Modul. Anschließend rufen Sie die app.activity-Methode der Durable Functions-API direkt in Ihrem Funktionscode auf.

Um den Aktivitätsauslöser zu definieren, verwenden Sie das folgende JSON-Objekt im bindings Array von function.json:

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

Der activity Wert ist der Name der Aktivität. Dieser Wert ist der Name, den Orchestratorfunktionen zum Aufrufen dieser Aktivitätsfunktion verwenden. Diese Eigenschaft ist optional. Wenn Sie sie nicht angeben, wird der Name der Funktion verwendet.

Sie können einen Aktivitätsauslöser definieren, indem Sie den activity_trigger-Dekoror direkt in Ihrem Python Funktionscode verwenden.

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

Beispielsweise kann eine Aktivitätsfunktion Eingaben von einer Orchestratorfunktion empfangen. Die Aktivitätsfunktion kann diese Eingabe dann als Nachricht an Azure Event Hubs senden.

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

Sie können eine Bindung an einen Orchestrierungsclient mithilfe des Attributs DurableClientAttribute (OrchestrationClientAttribute in Durable Functions 1.x) herstellen.

Sie können eine Bindung an einen Orchestrierungsclient mithilfe der @DurableClientInput Anmerkung herstellen.

Um Ihre Clientfunktion zu registrieren, importieren Sie das app Objekt aus dem @azure/functions npm Modul. Anschließend rufen Sie eine Durable Functions API-Methode auf, die spezifisch für Ihren Triggertyp ist. Für einen HTTP-Trigger rufen Sie beispielsweise die app.http Methode auf. Für einen Warteschlangentrigger rufen Sie die app.storageQueue Methode auf.

Um den dauerhaften Clienttrigger zu definieren, verwenden Sie das folgende JSON-Objekt im bindings Array von 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"
}

• Die taskHub Eigenschaft wird verwendet, wenn mehrere Funktions-Apps dasselbe Speicherkonto gemeinsam nutzen, aber voneinander isoliert werden müssen. Wenn Sie diese Eigenschaft nicht angeben, wird der Standardwert aus host.json verwendet. Dieser Wert muss mit dem Wert übereinstimmen, den die Ziel-Orchestratorfunktionen verwenden.
• Der Wert connectionName ist der Name einer App-Einstellungen, die eine Speicherkonto-Verbindungszeichenfolge enthält. Das Speicherkonto, das durch diese Verbindungszeichenfolge dargestellt wird, muss dasselbe sein, das auch die Ziel-Orchestratorfunktionen verwenden. Wenn Sie diese Eigenschaft nicht angeben, wird die Standardspeicherkonto-Verbindungszeichenfolge für die Funktions-App verwendet.

Sie können einen dauerhaften Clienttrigger definieren, indem Sie den durable_client_input-Dekoror direkt in Ihrem Python Funktionscode verwenden.

In der Regel binden Sie an eine Implementierung von IDurableClient (DurableOrchestrationClient in Durable Functions 1.x), damit Sie vollständigen Zugriff auf alle Orchestrierungsclient-APIs erhalten, die Durable Functions unterstützt.

Sie binden in der Regel an die DurableClientContext Klasse.

Sie müssen das sprachspezifische SDK verwenden, um Zugriff auf ein Clientobjekt zu erhalten.

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

Sie verwenden das Attribut EntityTriggerAttribute .NET zum Konfigurieren des Entitätstriggers.

Um den Entitätstrigger zu registrieren, importieren Sie das app Objekt aus dem @azure/functions npm Modul. Anschließend rufen Sie die app.entity-Methode der Durable Functions-API direkt in Ihrem Funktionscode auf.

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

Sie können einen Entitätstrigger definieren, indem Sie den entity_trigger-Dekoror direkt in Ihrem Python Funktionscode verwenden.

Sie können eine Bindung an den Entitätsclient herstellen, indem Sie das Attribut DurableClientAttribute .NET in .NET Klassenbibliotheksfunktionen verwenden.

Anstatt einen Entitätsclient zu registrieren, verwenden Sie signalEntity oder callEntity, um eine Entitätstriggermethode aus einer beliebigen registrierten Funktion aufzurufen.

• Aus einer von einer Warteschlange ausgelösten Funktion können Sie client.signalEntity verwenden:

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

• Über eine Orchestratorfunktion können Sie context.df.callEntity verwenden:

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

Sie können einen Entitätsclient mithilfe des durable_client_input-Dekorators direkt in Ihrem Python Funktionscode definieren.