Bindingen voor Durable Functions (Azure Functions)

Beide versies van het Python-programmeermodel voor Azure Functions worden ondersteund door Durable Functions. Omdat Python v2 de aanbevolen versie is, bevatten voorbeelden in dit artikel uitsluitend deze versie.

Vereiste voorwaarden

• Durable Functions SDK, het Pakketindexpakket azure-functions-durable(PyPI) van Python, versie 1.2.2 of een latere versie
• Extensiebundel versie 4.x (of een latere versie), die is ingesteld in het host.json projectbestand

U kunt feedback en suggesties geven in de Durable Functions SDK voor Python-opslagplaats.

Wanneer u functies in .NET ontwikkelt, gebruikt u het kenmerk OrchestrationTriggerAttribute . NET om de orchestration-trigger te configureren.

Voor Java gebruikt u de @DurableOrchestrationTrigger annotatie om de orkestratietrigger te configureren.

Wanneer u versie 4 van het Node.js programmeermodel gebruikt om functies te ontwikkelen, importeert u het app object uit de @azure/functions npm module. Vervolgens roept u de methode van de app.orchestration Durable Functions-API rechtstreeks aan in uw functiecode. Met deze methode wordt uw orchestratorfunctie geregistreerd bij het Durable Functions-framework.

Wanneer u orchestratorfuncties schrijft, definieert u de orchestrationtrigger met behulp van het volgende JSON-object in de bindings matrix van het function.json-bestand :

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

De orchestration waarde is de naam van de orchestratie die clients moeten gebruiken wanneer ze nieuwe exemplaren van de orchestrator-functie willen starten. Deze eigenschap is optioneel. Als u deze niet opgeeft, wordt de naam van de functie gebruikt.

Wanneer u het Python v2-programmeermodel gebruikt, kunt u een indelingstrigger definiëren met behulp van de orchestration_trigger decorator rechtstreeks in uw Python-functiecode.

In het v2-model hebt u toegang tot de Durable Functions-triggers en -bindingen van een exemplaar van DFApp. U kunt deze subklasse FunctionApp gebruiken om decorators te exporteren die specifiek zijn voor Durable Functions.

Het kenmerk dat u gebruikt om de trigger te definiëren, is afhankelijk van of u uw C#-functies uitvoert in hetzelfde proces als het Functions-hostproces of in een geïsoleerd werkproces.

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

De meeste orchestratorfuncties roepen activiteitsfuncties aan. De volgende code bevat een Hello World-voorbeeld dat laat zien hoe u een activiteitsfunctie aanroept:

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

U gebruikt het kenmerk ActivityTriggerAttribute .NET om de activiteitstrigger te configureren.

U gebruikt de @DurableActivityTrigger aantekening om de activiteitstrigger te configureren.

Als u de activiteitsfunctie wilt registreren, importeert u het app object uit de @azure/functions npm module. Vervolgens roept u de methode van de app.activity Durable Functions-API rechtstreeks aan in uw functiecode.

Als u de activiteitstrigger wilt definiëren, gebruikt u het volgende JSON-object in de bindings matrix van function.json:

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

De activity waarde is de naam van de activiteit. Deze waarde is de naam die orchestratorfuncties gebruiken om deze activiteitsfunctie aan te roepen. Deze eigenschap is optioneel. Als u deze niet opgeeft, wordt de naam van de functie gebruikt.

U kunt een activiteitstrigger definiëren met behulp van de activity_trigger decorator rechtstreeks in uw Python-functiecode.

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

Een activiteitsfunctie kan bijvoorbeeld invoer ontvangen van een orchestratorfunctie. De activiteitsfunctie kan die invoer vervolgens verzenden als een bericht naar 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}'`);
    },
});

U kunt binden aan een orkestratieclient met behulp van het kenmerk DurableClientAttribute (OrchestrationClientAttribute in Durable Functions 1.x).

U kunt verbinding maken met een orchestratieclient met behulp van de @DurableClientInput annotatie.

Als u de clientfunctie wilt registreren, importeert u het app object uit de @azure/functions npm module. Vervolgens roept u een Durable Functions-API-methode aan die specifiek is voor uw triggertype. Voor een HTTP-trigger roept u bijvoorbeeld de app.http methode aan. Voor een wachtrijtrigger roept u de app.storageQueue methode aan.

Als u de duurzame clienttrigger wilt definiëren, gebruikt u het volgende JSON-object in de bindings matrix van 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"
}

• De taskHub eigenschap wordt gebruikt wanneer meerdere functie-apps hetzelfde opslagaccount delen, maar van elkaar moeten worden geïsoleerd. Als u deze eigenschap niet opgeeft, wordt de standaardwaarde van host.json gebruikt. Deze waarde moet overeenkomen met de waarde die de doelorchestratorfuncties gebruiken.
• De connectionName waarde is de naam van een app-instelling die een verbindingsreeks voor een opslagaccount bevat. Het opslagaccount dat wordt vertegenwoordigd door deze verbindingsreeks moet hetzelfde zijn als dat van de doel-orkestratiefuncties. Als u deze eigenschap niet opgeeft, wordt voor de functie-app de standaard verbindingsreeks voor het opslagaccount gebruikt.

U kunt een duurzame clienttrigger definiëren met behulp van de durable_client_input decorator rechtstreeks in uw Python-functiecode.

Doorgaans verbindt u zich met een implementatie van IDurableClient (DurableOrchestrationClient in Durable Functions 1.x), waarmee u volledige toegang krijgt tot alle orchestration-client-API's die Durable Functions ondersteunt.

Normaal gesproken bindt u aan de DurableClientContext klas.

U moet de taalspecifieke SDK gebruiken om toegang te krijgen tot een clientobject.

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

U gebruikt het kenmerk EntityTriggerAttribute .NET om de entiteitstrigger te configureren.

Als u de entiteitstrigger wilt registreren, importeert u het app object uit de @azure/functions npm module. Vervolgens roept u de methode van de app.entity Durable Functions-API rechtstreeks aan in uw functiecode.

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

U kunt een entiteitstrigger definiëren met behulp van de entity_trigger decorator rechtstreeks in uw Python-functiecode.

U kunt verbinding maken met de entiteitsclient met behulp van het . NET-kenmerk DurableClientAttribute in .NET-klassebibliotheekfuncties.

In plaats van een entiteitsclient te registreren, gebruikt u signalEntity of callEntity om een entiteitstriggermethode aan te roepen vanuit een geregistreerde functie.

• Vanuit een door een wachtrij geactiveerde functie kunt u het volgende gebruiken 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);
      },
  });
  

• Vanuit een orchestratorfunctie kunt u het volgende gebruiken 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;
  });
  

U kunt een entiteitsclient definiëren met behulp van de durable_client_input decorator rechtstreeks in uw Python-functiecode.