Información general sobre Durable Functions en el trabajo aislado de .NET

Artículo
11/17/2023

Este artículo es una introducción a Durable Functions en el trabajo aislado de .NET. El trabajo aislado permite que la aplicación de Durable Functions se ejecute en una versión de .NET diferente a la del host de Azure Functions.

¿Por qué usar Durable Functions en el trabajo aislado de .NET?

El uso de este modelo le permite obtener todas las grandes ventajas que se incluyen con el proceso de trabajo aislado de Azure Functions .NET. Para obtener más información, consulte Ventajas del modelo de trabajo aislado. Además, este nuevo SDK incluye algunas características nuevas.

Mejoras de características en Durable Functions en proceso

La entrada de orquestación se puede insertar directamente: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Compatibilidad con llamadas fuertemente tipadas y actividades y orquestaciones basadas en clases (NOTA: en versión preliminar. Para obtener más información, consulte aquí).
Además de todas las ventajas del trabajo aislado de Azure Functions .NET.

Generador de origen y actividades y orquestaciones basadas en clases

Requisito: agregar <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> al proyecto.

Al agregar el paquete del generador de origen, obtendrá acceso a dos características nuevas:

Actividades y orquestaciones basadas en clases, una manera alternativa de escribir Durable Functions. En lugar de "basado en funciones", se escriben clases fuertemente tipadas, que heredan tipos del SDK de Durable.
Métodos de extensión fuertemente tipados para invocar suborquestaciones y actividades. Estos métodos de extensión también se pueden usar desde actividades y orquestaciones "basadas en funciones".

Ejemplo basado en funciones

public static class MyFunctions
{
    [Function(nameof(MyActivity))] 
    public static async Task<string> MyActivity([ActivityTrigger] string input)
    {
        // implementation
    }

    [Function(nameof(MyOrchestration))] 
    public static async Task<string> MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, string input)
    {
        // implementation
        return await context.CallActivityAsync(nameof(MyActivity), input);
    }
}

Ejemplo basado en clases

[DurableTask(nameof(MyActivity))]
public class MyActivity : TaskActivity<string, string>
{
    private readonly ILogger logger;

    public MyActivity(ILogger<MyActivity> logger) // activities have access to DI.
    {
        this.logger = logger;
    }

    public async override Task<string> RunAsync(TaskActivityContext context, string input)
    {
        // implementation
    }
}

[DurableTask(nameof(MyOrchestration))]
public class MyOrchestration : TaskOrchestrator<string, string>
{
    public async override Task<string> RunAsync(TaskOrchestrationContext context, string input)
    {
        ILogger logger = context.CreateReplaySafeLogger<MyOrchestration>(); // orchestrations do NOT have access to DI.

        // An extension method was generated for directly invoking "MyActivity".
        return await context.CallMyActivityAsync(input);
    }
}

Entidades duraderas

Las entidades duraderas se admiten en el trabajo aislado de .NET. Consulte la guía del desarrollador.

Guía de migración

Esta guía presupone que va a empezar con un proyecto de Durable Functions .NET 2.x.

Actualizar el proyecto

El primer paso es actualizar el proyecto para Azure Functions .NET aislado. A continuación, actualice las referencias del paquete NuGet Durable Functions.

Antigua:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="2.9.0" />
</ItemGroup>

Nuevo:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.1.0" />
</ItemGroup>

Actualización del código

Durable Functions para el trabajo aislado de .NET es un paquete completamente nuevo con diferentes tipos y espacios de nombres. Como resultado, se requieren cambios en el código, pero muchas de las API se alinean sin necesidad de cambios.

Esquema de host.json

El esquema para el trabajo aislado de Durable Functions .NET y Durable Functions 2.x se ha mantenido igual, no es necesario realizar ningún cambio.

Cambios en la API pública

Esta tabla no es una lista exhaustiva de cambios.

2.x	Aislado
`IDurableOrchestrationClient`	`DurableTaskClient`
`IDurableOrchestrationClient.StartNewAsync`	`DurableTaskClient.ScheduleNewOrchestrationInstanceAsync`
`IDurableEntityClient.SignalEntityAsync`	`DurableTaskClient.Entities.SignalEntityAsync`
`IDurableEntityClient.ReadEntityStateAsync`	`DurableTaskClient.Entities.GetEntityAsync`
`IDurableEntityClient.ListEntitiesAsync`	`DurableTaskClient.Entities.GetAllEntitiesAsync`
`IDurableEntityClient.CleanEntityStorageAsync`	`DurableTaskClient.Entities.CleanEntityStorageAsync`
`IDurableOrchestrationContext`	`TaskOrchestrationContext`
`IDurableOrchestrationContext.GetInput<T>()`	`TaskOrchestrationContext.GetInput<T>()` o inserte la entrada como parámetro: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	No equivalente
`DurableActivityContext.GetInput<T>()`	Insertar la entrada como parámetro `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, incluya el parámetro `TaskOptions` con detalles de repetición.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, incluya el parámetro `TaskOptions` con detalles de repetición.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` o `TaskOrchestrationContext.CreateReplaySafeLogger(string)`
`IDurableOrchestrationContext.CallEntityAsync`	`TaskOrchestrationContext.Entities.CallEntityAsync`
`IDurableOrchestrationContext.SignalEntity`	`TaskOrchestrationContext.Entities.SignalEntityAsync`
`IDurableOrchestrationContext.LockAsync`	`TaskOrchestrationContext.Entities.LockEntitiesAsync`
`IDurableOrchestrationContext.IsLocked`	`TaskOrchestrationContext.Entities.InCriticalSection`
`IDurableEntityContext`	`TaskEntityContext`.
`IDurableEntityContext.EntityName`	`TaskEntityContext.Id.Name`
`IDurableEntityContext.EntityKey`	`TaskEntityContext.Id.Key`
`IDurableEntityContext.OperationName`	`TaskEntityOperation.Name`
`IDurableEntityContext.FunctionBindingContext`	Se ha eliminado, se agrega `FunctionContext` como parámetro de entrada
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Quitado
`IDurableEntityContext.BatchPosition`	Quitado
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Quitado. Alternativamente, se usa el valor devuelto del método.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Se han quitado los parámetros del constructor.
`IDurableOrchestrationClient.GetStatusAsync`	`DurableTaskClient.GetInstanceAsync`

Cambios de comportamiento

El comportamiento predeterminado de serialización ha cambiado de Newtonsoft.Json a System.Text.Json. Para más información, consulte esta página.

Compartir vía