Implémenter des fonctionnalités de niveau de service dans votre service d’intervenant

Article
10/15/2024

Comme décrit dans les couches de service, le service d’acteur lui-même est un service fiable. Vous pouvez écrire votre propre service dérivé de ActorService. Vous pouvez également implémenter des fonctionnalités de niveau de service de la même façon que lorsque vous héritez d’un service avec état, par exemple :

Sauvegarde et restauration du service.
Fonctionnalité partagée par tous les acteurs. Par exemple, un disjoncteur.
Appels de procédure à distance sur le service d’acteur proprement dit et sur chaque acteur.

Utiliser le service d’intervenant

Les instances d’acteur ont accès au service d’acteur dans lequel elles s’exécutent. Via le service d’acteur, les instances d’acteur peuvent obtenir par programmation le contexte de service. Le contexte de service comprend l’ID de partition, le nom du service, le nom de l’application et d’autres informations spécifiques de la plateforme Azure Service Fabric.

Task MyActorMethod()
{
    Guid partitionId = this.ActorService.Context.PartitionId;
    string serviceTypeName = this.ActorService.Context.ServiceTypeName;
    Uri serviceInstanceName = this.ActorService.Context.ServiceName;
    string applicationInstanceName = this.ActorService.Context.CodePackageActivationContext.ApplicationName;
}

CompletableFuture<?> MyActorMethod()
{
    UUID partitionId = this.getActorService().getServiceContext().getPartitionId();
    String serviceTypeName = this.getActorService().getServiceContext().getServiceTypeName();
    URI serviceInstanceName = this.getActorService().getServiceContext().getServiceName();
    String applicationInstanceName = this.getActorService().getServiceContext().getCodePackageActivationContext().getApplicationName();
}

Comme tous les services Reliable Services, le service d’acteur doit être inscrit avec un type de service dans le runtime de Service Fabric. Pour que le service d’intervenant exécute vos instances d’intervenant, votre type d’intervenant doit également être inscrit auprès du service d’intervenant. La méthode d’inscription ActorRuntime effectue ce travail pour les acteurs. Dans le cas le plus simple, vous pouvez inscrire votre type d’intervenant, et le service d’intervenant utilise les paramètres par défaut.

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>().GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

Vous pouvez également utiliser une expression lambda fournie par la méthode d’inscription pour construire vous-même le service d’acteur. Vous pouvez ensuite configurer le service d’intervenant et construire explicitement vos instances d’intervenant. Vous pouvez injecter des dépendances à votre intervenant via son constructeur.

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>(
            (context, actorType) => new ActorService(context, actorType, () => new MyActor()))
            .GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

static class Program
{
    private static void Main()
    {
      ActorRuntime.registerActorAsync(
              MyActor.class,
              (context, actorTypeInfo) -> new FabricActorService(context, actorTypeInfo),
              timeout);

        Thread.sleep(Long.MAX_VALUE);
    }
}

Méthodes du service d’acteur

Le service d’intervenant implémente IActorService (C#) ActorService (Java), qui implémentent à leur tour IService (C#) ou Service (Java). Il s’agit de l’interface qu’utilise la communication à distance de Reliable Services, qui autorise des appels de procédure distante sur des méthodes de service. Elle contient des méthodes de niveau de service qui peuvent être appelées à distance via la communication à distance des services. Vous pouvez l’utiliser pour énumérer et supprimer des intervenants.

Service d’acteur personnalisé

En utilisant la fonction lambda de l’inscription d’acteur, vous pouvez enregistrer votre propre service d’acteur personnalisé qui dérive de ActorService (c#) et FabricActorService (Java). Vous pouvez implémenter vos propres fonctionnalités de niveau de service en écrivant une classe de service qui hérite de ActorService (C#) ou FabricActorService (Java). Un service d’intervenant personnalisé hérite de toutes les fonctionnalités de runtime d’intervenant de ActorService (C#) ou FabricActorService (Java). Vous pouvez l’utiliser pour implémenter vos propres méthodes de service.

class MyActorService : ActorService
{
    public MyActorService(StatefulServiceContext context, ActorTypeInformation typeInfo, Func<ActorBase> newActor)
        : base(context, typeInfo, newActor)
    { }
}

class MyActorService extends FabricActorService
{
    public MyActorService(StatefulServiceContext context, ActorTypeInformation typeInfo, BiFunction<FabricActorService, ActorId, ActorBase> newActor)
    {
         super(context, typeInfo, newActor);
    }
}

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>(
            (context, actorType) => new MyActorService(context, actorType, () => new MyActor()))
            .GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

public class Program
{
    public static void main(String[] args)
    {
        ActorRuntime.registerActorAsync(
                MyActor.class,
                (context, actorTypeInfo) -> new FabricActorService(context, actorTypeInfo),
                timeout);
        Thread.sleep(Long.MAX_VALUE);
    }
}

Implémenter une sauvegarde et un restauration d’intervenant

Un service d’acteur personnalisé peut exposer une méthode pour sauvegarder des données d’acteur en tirant parti de l’écouteur de communication à distance déjà présent dans ActorService. Pour obtenir un exemple, consultez Sauvegarder et restaurer des acteurs.

Intervenant qui utilise une pile V2 de communication à distance (compatible avec l’interface)

La pile de communication à distance V2 (compatible avec l’interface, appelée V2_1) a toutes les fonctionnalités de la pile de communication à distance V2. Son interface est compatible avec la pile de communication à distance V1, mais elle ne présente pas de compatibilité descendante avec les piles V1 et V2. Pour procéder à une mise à niveau de la pile V1 vers la pile V2_1 sans que cela ait d’incidence sur la disponibilité du service, suivez les étapes décrites dans la section suivante.

Les modifications suivantes sont requises pour utiliser la pile de communication à distance V2_1 :

Ajoutez l’attribut d’assembly suivant sur les interfaces d’intervenant.

[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]

Créez et mettez à niveau des projets de service d’intervenant et de client d’intervenant pour commencer à utiliser la pile V2.

Mise à niveau du service d’intervenant vers la pile de communication à distance V2 (compatible avec l’interface) sans incidence sur la disponibilité du service

Cette modification est une mise à niveau en deux étapes. Suivez les étapes dans l’ordre indiqué.

Ajoutez l’attribut d’assembly suivant sur les interfaces d’intervenant. Cet attribut démarre deux écouteurs pour le service d’intervenant, V1 (existant) et V2_1. Mettez à niveau le service d’intervenant avec cette modification.
```
[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V1|RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]
```
Mettez à niveau les clients d’intervenant après avoir terminé la mise à niveau précédente. Cette étape permet de s’assurer que le proxy d’intervenant utilise la pile de communication à distance V2_1.

Cette étape est facultative. Modifiez l’attribut précédent pour supprimer l’écouteur V1.

[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]

Intervenant qui utilise la pile de communication à distance V2

Avec le package NuGet version 2.8, les utilisateurs peuvent désormais utiliser la pile de communication à distance V2, qui est plus performante et offre des fonctionnalités telles que la sérialisation personnalisée. Le pile de communication à distance V2 ne présente pas de compatibilité descendante avec la pile de communication à distance existante (désormais appelée pile de communication à distance V1).

Les modifications suivantes sont requises pour utiliser la pile de communication à distance V2.