Encadenamiento de funciones

• Complete el artículo de inicio rápido.
• Clone o descargue el proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.
• Clone o descargue el proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.
• Clone o descargue el proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.
• Clone o descargue el proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.
• Clone o descargue el proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.

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

Todas las funciones de orquestación de C# deben tener un parámetro de tipo DurableOrchestrationContext, que existe en el ensamblado Microsoft.Azure.WebJobs.Extensions.DurableTask. Este objeto de contexto le permite llamar a otras funciones de actividad y pasar parámetros de entrada con su método .

El código llama a la función tres veces en secuencia con distintos valores de parámetro. El valor devuelto de cada llamada se agrega a la lista , que se devuelve al final de la función.

function.json

Si desarrolla en Visual Studio Code o en el portal de Azure, este es el archivo de orquestador function.json.

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

La configuración clave es el tipo de vinculación. Todas las funciones de orquestador deben usar este tipo de desencadenador.

index.js

La función de orquestador se muestra a continuación:

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

Todas las funciones de orquestación de JavaScript tienen que incluir el módulo . Es una biblioteca que permite escribir Durable Functions en JavaScript. Tres diferencias clave entre una función de orquestador y otras funciones de JavaScript:

1. La función de orquestador es una función generadora.
2. La función se envuelve en una llamada al método del módulo (aquí ).
3. La función es sincrónica. Debido a que el método realiza llamadas, la función devuelve un resultado.

El objeto contiene un objeto de contexto de orquestación duradero que le permite llamar a otras funciones de actividad y pasar parámetros de entrada mediante su método. El código realiza tres llamadas en secuencia con diferentes valores de parámetro, utilizando la función de actividad asincrónica para indicar que la ejecución debe esperar hasta que se devuelvan las llamadas. El valor devuelto de cada llamada se agrega a la matriz , que se devuelve al final de la función.

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

Todas las funciones de orquestación de JavaScript tienen que incluir el módulo . Este módulo le permite escribir Durable Functions en JavaScript. Para usar el modelo de programación de nodos V4, debe instalar la versión de .

Dos diferencias clave entre una función de orquestador y otras funciones de JavaScript:

1. La función de orquestador es una función generadora.
2. La función es sincrónica. La función devuelve.

El objeto contiene un objeto de contexto de orquestación duradero que le permite llamar a otras funciones de actividad y pasar parámetros de entrada mediante su método . El código llama tres veces en secuencia con valores de parámetro diferentes, utilizando `await` para indicar que la ejecución debe esperar a que las llamadas a la función de actividad asincrónica se devuelvan. El valor devuelto de cada llamada se agrega a la matriz , que se devuelve al final de la función.

function.json

Si usa Visual Studio Code o el portal de Azure para el desarrollo, este es el contenido del archivo function.json para la función de orquestador. La mayoría de los archivos function.json de orquestador presentan un aspecto prácticamente idéntico a este.

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

Lo importante es el tipo de enlace . Todas las funciones de orquestador deben usar este tipo de desencadenador.

__init__.py

La función de orquestador se muestra a continuación:

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)

Todas las funciones de orquestación de Python deben incluir el paquete durable-functions. Es una biblioteca que permite escribir Durable Functions en Python. Dos diferencias clave entre una función de orquestador y otras funciones de Python:

1. La función de orquestador es una función generadora.
2. El archivo registra la función de orquestador al especificarla al final del archivo. Esto ayuda a distinguirlo de otras funciones auxiliares declaradas en el archivo.

El objeto le permite llamar a otras funciones de actividad y pasar parámetros de entrada usando su método. El código llama tres veces en secuencia con valores de parámetros diferentes, usando para indicar que la ejecución debe esperar a que las llamadas a las funciones de actividad asincrónica se completen. El valor devuelto de cada llamada se devuelve al final de la función.

El ejemplo de PowerShell aún no está disponible.

Java ejemplo aún no está disponible.

Este código muestra un orquestador que llama a tres actividades en secuencia y pasa el resultado de cada actividad a la próxima actividad.

using Microsoft.DurableTask;

[DurableTask]
public class GreetingOrchestration : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, string name)
    {
        // Step 1: Say hello to the person
        string greeting = await context.CallActivityAsync<string>(nameof(SayHelloActivity), name);

        // Step 2: Process the greeting
        string processedGreeting = await context.CallActivityAsync<string>(nameof(ProcessGreetingActivity), greeting);

        // Step 3: Finalize the response
        string finalResponse = await context.CallActivityAsync<string>(nameof(FinalizeResponseActivity), processedGreeting);

        return finalResponse;
    }
}

Todos los orquestadores de .NET heredan de TaskOrchestrator<TInput, TOutput>. permite llamar a actividades mediante . El código llama a tres actividades en secuencia, donde cada actividad recibe la salida de la actividad anterior.

El código siguiente muestra un orquestador que llama a tres actividades en secuencia:

import {
  OrchestrationContext,
  TOrchestrator,
} from "@microsoft/durabletask-js";

const greetingOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  name: string
): any {
  // Step 1: Say hello to the person
  const greeting: string = yield ctx.callActivity(sayHello, name);

  // Step 2: Process the greeting
  const processedGreeting: string = yield ctx.callActivity(processGreeting, greeting);

  // Step 3: Finalize the response
  const finalResponse: string = yield ctx.callActivity(finalizeResponse, processedGreeting);

  return finalResponse;
};

Todos los orquestadores de JavaScript son funciones generadoras () que utilizan para llamar a las actividades. El método del contexto de orquestación programa la ejecución de la actividad. El código llama a tres actividades en secuencia, pasando el resultado de cada actividad al siguiente.

El código siguiente muestra un orquestador que llama a tres actividades en secuencia:

from durabletask import task

# Orchestrator function
def function_chaining_orchestrator(ctx: task.OrchestrationContext, name: str) -> str:
    """Orchestrator that demonstrates function chaining pattern."""

    # Call first activity
    greeting = yield ctx.call_activity(say_hello, input=name)

    # Call second activity with the result from first activity
    processed_greeting = yield ctx.call_activity(process_greeting, input=greeting)

    # Call third activity with the result from second activity
    final_response = yield ctx.call_activity(finalize_response, input=processed_greeting)

    return final_response

Todos los orquestadores de Python son funciones de generador que usan yield para llamar a actividades. El método del contexto de orquestación programa la ejecución de la actividad. El código llama a tres actividades en secuencia, pasando el resultado de cada actividad a la siguiente.

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

El código siguiente muestra un orquestador que llama a tres actividades en secuencia:

import com.microsoft.durabletask.*;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "ActivityChaining"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                String input = ctx.getInput(String.class);

                // Call activities in sequence, passing output from one to the next
                String x = ctx.callActivity("Reverse", input, String.class).await();
                String y = ctx.callActivity("Capitalize", x, String.class).await();
                String z = ctx.callActivity("ReplaceWhitespace", y, String.class).await();

                ctx.complete(z);
            };
        }
    })
    .build();

En Java, los orquestadores se definen mediante TaskOrchestrationFactory. El método del contexto programa la ejecución de la actividad y espera el resultado. El código llama a tres actividades en secuencia, pasando la salida de cada actividad a la siguiente.

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

Las actividades usan el atributo. Usa para acciones relacionadas con la actividad, como la lectura de datos de entrada con .

da formato a una cadena de saludo.

En lugar de enlazar a , se enlaza directamente al tipo pasado a la función de actividad. Por ejemplo:

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

E1_SayHello/function.json

El archivo function.json para la función de actividad es similar al de salvo en que usa un tipo de enlace en lugar de un tipo de enlace .

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

La implementación de es una operación de formato de cadena relativamente sencilla.

E1_SayHello/index.js

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

A diferencia de la función de orquestación, una función de actividad no necesita una configuración especial. El orquestador pasa los parámetros de entrada al objeto con el nombre de la vinculación, en este caso, . Establezca el nombre del enlace como parámetro de la función exportada para acceder a ella directamente, como hace el ejemplo.

da formato a una cadena de saludo.

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

const helloActivityName = "sayHello";

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

A diferencia de la función de orquestación, una función de actividad no necesita una configuración especial. El orquestador pasa los datos de entrada como primer argumento a la función. El segundo argumento es el contexto de invocación, que este ejemplo no usa.

E1_SayHello/function.json

El archivo function.json para la función de actividad es similar al de salvo en que usa un tipo de enlace en lugar de un tipo de enlace .

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

La implementación de es una operación de formato de cadena de texto relativamente sencilla.

E1_SayHello/__init__.py

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

A diferencia de una función de orquestación, una función de actividad no necesita una configuración especial. La entrada que se le ha pasado por la función de orquestador es directamente accesible como parámetro de la función.

El ejemplo de PowerShell estará disponible próximamente.

Ejemplo de Java próximamente.

Las actividades del SDK de Durable Task heredan de :

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

[DurableTask]
public class SayHelloActivity : TaskActivity<string, string>
{
    private readonly ILogger<SayHelloActivity> _logger;

    public SayHelloActivity(ILogger<SayHelloActivity> logger)
    {
        _logger = logger;
    }

    public override Task<string> RunAsync(TaskActivityContext context, string name)
    {
        _logger.LogInformation("Activity SayHello called with name: {Name}", name);
        return Task.FromResult($"Hello {name}!");
    }
}

[DurableTask]
public class ProcessGreetingActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string greeting)
    {
        return Task.FromResult($"{greeting} How are you today?");
    }
}

[DurableTask]
public class FinalizeResponseActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string response)
    {
        return Task.FromResult($"{response} I hope you're doing well!");
    }
}

Use la inserción de dependencias para obtener servicios como . Agregue el atributo para registrar la actividad con el trabajador.

Las actividades del SDK de Durable Task son funciones sencillas:

import { ActivityContext } from "@microsoft/durabletask-js";

const sayHello = async (_ctx: ActivityContext, name: string): Promise<string> => {
  return `Hello ${name}!`;
};

const processGreeting = async (_ctx: ActivityContext, greeting: string): Promise<string> => {
  return `${greeting} How are you today?`;
};

const finalizeResponse = async (_ctx: ActivityContext, response: string): Promise<string> => {
  return `${response} I hope you're doing well!`;
};

A diferencia de los orquestadores, las actividades pueden realizar operaciones de E/S como llamadas HTTP, consultas de base de datos y acceso a archivos. La entrada se pasa directamente como parámetro.

Las actividades del SDK de Durable Task son funciones sencillas:

from durabletask import task

def say_hello(ctx: task.ActivityContext, name: str) -> str:
    """First activity that greets the user."""
    return f"Hello {name}!"

def process_greeting(ctx: task.ActivityContext, greeting: str) -> str:
    """Second activity that processes the greeting."""
    return f"{greeting} How are you today?"

def finalize_response(ctx: task.ActivityContext, response: str) -> str:
    """Third activity that finalizes the response."""
    return f"{response} I hope you're doing well!"

A diferencia de los orquestadores, las actividades pueden realizar operaciones de E/S como llamadas HTTP, consultas de base de datos y acceso a archivos. La entrada se pasa directamente como parámetro.

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

Las actividades de Java se definen mediante TaskActivityFactory:

import com.microsoft.durabletask.*;

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Reverse"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            StringBuilder builder = new StringBuilder(input);
            builder.reverse();
            return builder.toString();
        };
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Capitalize"; }

    @Override
    public TaskActivity create() {
        return ctx -> ctx.getInput(String.class).toUpperCase();
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "ReplaceWhitespace"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            return input.trim().replaceAll("\\s", "-");
        };
    }
})

Registre cada actividad con el generador de trabajo mediante . Las actividades pueden realizar operaciones de E/S y devolver resultados al orquestador.

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

Para interactuar con orquestadores, agregue un enlace de entrada. Use el cliente para iniciar una orquestación y devolver una respuesta HTTP que incluya direcciones URL para comprobar el estado de la nueva orquestación.

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
  }

Para interactuar con orquestadores, agregue una vinculación de entrada.

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

Use para obtener un objeto . Use el cliente para iniciar una orquestación y devolver una respuesta HTTP que incluya direcciones URL para comprobar el estado de la nueva orquestación.

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

Para administrar e interactuar con orquestadores, agregue un enlace de entrada. Especifique el enlace en el argumento al registrar la función. Obtenga la entrada llamando a .

Use para obtener un objeto . Use el cliente para iniciar una orquestación y devolver una respuesta HTTP que incluya direcciones URL para comprobar el estado de la nueva orquestación.

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"
    }
  ]
}

Para interactuar con los orquestadores, la función tiene que incluir un enlace de entrada .

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)

Use el constructor DurableOrchestrationClient para crear un cliente de Durable Functions. Use el cliente para iniciar una orquestación y devolver una respuesta HTTP que incluya direcciones URL para comprobar el estado de la nueva orquestación.

El ejemplo de PowerShell estará disponible próximamente.

Ejemplo de Java próximamente.

using Microsoft.DurableTask.Client;

// Create the client
var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule a new orchestration instance
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(GreetingOrchestration),
    input: "World");

Console.WriteLine($"Started orchestration with ID: {instanceId}");

// Wait for the orchestration to complete
OrchestrationMetadata result = await client.WaitForInstanceCompletionAsync(
    instanceId,
    getInputsAndOutputs: true);

Console.WriteLine($"Orchestration completed with result: {result.ReadOutputAs<string>()}");

Cree el DurableTaskClient mediante una cadena de conexión al Programador de Tareas Duraderas. Utilice para iniciar una orquestación y para esperar a que finalice.

import {
  DurableTaskAzureManagedClientBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const connectionString =
  process.env.DURABLE_TASK_SCHEDULER_CONNECTION_STRING ||
  "Endpoint=http://localhost:8080;Authentication=None;TaskHub=default";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

// Schedule a new orchestration instance
const instanceId = await client.scheduleNewOrchestration(greetingOrchestrator, "World");
console.log(`Started orchestration with ID: ${instanceId}`);

// Wait for the orchestration to complete
const state = await client.waitForOrchestrationCompletion(instanceId, true, 30);
console.log(`Orchestration completed with result: ${state?.serializedOutput}`);

Cree el DurableTaskAzureManagedClientBuilder mediante una cadena de conexión al Programador de Tareas Duraderas. Utilice para iniciar una orquestación y para esperar a que finalice.

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Create the client
client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub_name,
    token_credential=credential
)

# Schedule a new orchestration instance
instance_id = client.schedule_new_orchestration(
    function_chaining_orchestrator,
    input="World"
)

print(f"Started orchestration with ID: {instance_id}")

# Wait for the orchestration to complete
result = client.wait_for_orchestration_completion(instance_id, timeout=60)

if result and result.runtime_status == OrchestrationStatus.COMPLETED:
    print(f"Orchestration completed with result: {result.serialized_output}")

El sistema se conecta al Programador de Tareas Durables. Utilice para iniciar una orquestación y para esperar su finalización.

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerClientExtensions;

// Create the client
DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString)
    .build();

// Schedule a new orchestration instance
String instanceId = client.scheduleNewOrchestrationInstance(
    "ActivityChaining",
    new NewOrchestrationInstanceOptions().setInput("Hello, world!"));

System.out.println("Started orchestration with ID: " + instanceId);

// Wait for the orchestration to complete
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId,
    Duration.ofSeconds(30),
    true);

System.out.println("Orchestration completed with result: " + result.readOutputAs(String.class));

Cree el DurableTaskClient mediante una cadena de conexión. Use para iniciar una orquestación y para esperar a que finalice.