Vue d’ensemble de Durable Functions dans le worker isolé .NET

Article
11/22/2023

Cet article est une vue d’ensemble de Durable Functions dans le worker isolé .NET. Le worker isolé permet à votre application Durable Functions de s’exécuter sur une version .NET différente de celle de l’hôte Azure Functions.

Pourquoi utiliser Durable Functions dans le worker isolé .NET ?

L’utilisation de ce modèle vous permet d’obtenir tous les avantages intéressants fournis avec le processus Worker isolé Azure Functions .NET. Pour plus d’informations, consultez Avantages du modèle worker isolé. En outre, ce nouveau KIT de développement logiciel (SDK) inclut de nouvelles fonctionnalités.

Améliorations des fonctionnalités par rapport à Durable Functions dans le processus

L’entrée d’orchestration peut être injectée directement : MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Prise en charge des appels fortement typés et des activités et orchestrations basées sur les classes (REMARQUE : dans la préversion. Pour en savoir plus, voir ici.)
Plus tous les avantages du worker isolé Azure Functions .NET.

Générateur source et activités et orchestrations basées sur les classes

Condition requise : ajouter <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> à votre projet.

En ajoutant le package de générateur source, vous avez accès à deux nouvelles fonctionnalités :

Activités et orchestrations basées sur les classes, une autre façon d’écrire des Durable Functions. Au lieu de « basé sur la fonction », vous écrivez des classes fortement typées qui héritent des types du kit de développement logiciel (SDK) de Durable.
Méthodes d’extension fortement typées pour appeler des sous-orchestrations et des activités. Ces méthodes d’extension peuvent également être utilisées à partir d’activités et d’orchestrations « basées sur des fonctions ».

Exemple basé sur des fonctions

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

Exemple basé sur des classes

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

Entités durables

Les entités durables sont prises en charge dans le Worker .NET isolé. Consultez le Guide du développeur.

Guide de migration

Ce guide part du principe que vous commencez avec un projet Durable Functions .NET 2.x.

Mettez à jour votre projet

La première étape consiste à mettre à jour votre projet vers Azure Functions .NET isolé. Ensuite, mettez à jour vos références de package NuGet Durable Functions.

Ancienne :

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

Nouveau :

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

Mettre à jour votre code

Durable Functions pour le worker isolé .NET est un package entièrement nouveau avec divers types et espaces de noms. Il y a par conséquent des changements requis dans votre code, mais de nombreuses API s’alignent sans aucune modification nécessaire.

Schéma Host.json

Le schéma pour le worker isolé .NET Durable Functions et Durable Functions 2.x est resté le même. Aucune modification ne doit être nécessaire.

Modifications de l’API publique

Ce tableau n’est pas une liste exhaustive des modifications.

2.x	Isolé
`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 injectez une entrée en tant que paramètre : `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Pas d'équivalent
`DurableActivityContext.GetInput<T>()`	Injectez une entrée en tant que paramètre `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, inclut le paramètre `TaskOptions` avec les détails des tentatives.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, inclut le paramètre `TaskOptions` avec les détails des tentatives.
`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`	Supprimé, ajoutez `FunctionContext` en tant que paramètre d’entrée
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Supprimé
`IDurableEntityContext.BatchPosition`	Supprimé
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Supprimé. La valeur renvoyée par la méthode est utilisée à la place.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Les paramètres de constructeur ont été supprimés.
`IDurableOrchestrationClient.GetStatusAsync`	`DurableTaskClient.GetInstanceAsync`

Changements de comportement

Le comportement par défaut de sérialisation est passé de Newtonsoft.Json à System.Text.Json. Vous pourrez trouver plus d’informations ici.

Partager via