Visão geral do Durable Functions no trabalho isolado do .NET

Artigo
11/23/2023

Visão geral do Durable Functions no trabalho isolado do trabalho isolado do .NET. O trabalho isolado permite que seu aplicativo Durable Functions seja executado em uma versão do .NET diferente da do host do Azure Functions.

Por que usar Durable Functions no trabalho isolado do .NET?

O uso desse modelo permite obter todos os grandes benefícios que fazem parte do com o processo de trabalho isolado do .NET Azure Functions. Para obter mais informações, consulte Benefícios do modelo de trabalhador isolado. Além disso, esse novo SDK inclui alguns novos recursos.

Aprimoramentos de recursos em relação ao Durable Functions em processo

A entrada de orquestração pode ser injetada diretamente: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Suporte para chamadas fortemente tipadas e atividades baseadas em classe e orquestrações (OBSERVAÇÃO: em versão prévia. Para obter mais informações, consulte aqui.)
Além disso, todos os benefícios do trabalho isolado do .NET Azure Functions.

Gerador de origem e atividades baseadas em classe e orquestrações

Requisito: adicione <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> ao seu projeto.

Ao adicionar o pacote de gerador de origem, você obtém acesso a dois novos recursos:

Atividades baseadas em classe e orquestrações: uma maneira alternativa de escrever as Durable Functions. Em vez de "baseado em função", você escreve classes fortemente tipadas, que herdam tipos do SDK Durável.
Métodos de extensão fortemente tipados para invocar sub orquestrações e atividades. Esses métodos de extensão também podem ser usados de atividades e orquestrações "baseadas em função".

Exemplo baseado em função

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

Exemplo baseado em classe

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

    public MyActivity(ILogger<MyActivity> logger) // activites 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 duráveis

As entidades duráveis têm suporte no trabalho isolado do .NET. Consulte o guia do desenvolvedor.

Guia de migração

Este guia pressupõe que você está começando com um projeto do .NET Durable Functions 2.x.

Atualizar seus arquivos de projeto

A primeira etapa é atualizar seu projeto para Azure Functions .NET isolado. Em seguida, atualize suas referências de pacote NuGet Durable Functions.

Antigo:

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

Novo:

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

Atualizar o código

o Durable Functions para o trabalho isolado do .NET é um pacote totalmente novo com tipos e namespaces diferentes. Há alterações necessárias em seu código como resultado, mas muitas das APIs se alinham sem nenhuma alteração necessária.

Host.json schema

O esquema para trabalho isolado do Durable Functions do .NET e Durable Functions 2.x permaneceu o mesmo, nenhuma alteração deve ser necessária.

Alterações na API pública

Esta tabela não é uma lista completa de todas as alterações.

2. x	Isolado
`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>()` ou injete a entrada como um parâmetro: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Sem equivalente
`DurableActivityContext.GetInput<T>()`	Injete a entrada como um parâmetro `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, inclua o parâmetro`TaskOptions` com detalhes de repetição.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, inclua o parâmetro`TaskOptions` com detalhes de repetição.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` ou `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`	Removido. Adicione `FunctionContext` como um parâmetro de entrada
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Removido
`IDurableEntityContext.BatchPosition`	Removido
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Removidos. Valor de retorno do método usado no lugar.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Parâmetros do construtor removidos.

Alterações de comportamento

O comportamento padrão de serialização foi alterado de Newtonsoft.Json para System.Text.Json. Para mais informações, consulte aqui.

Share via