Implementera funktioner på tjänstnivå i aktörstjänsten

Artikel
08/25/2024

Som beskrivs i tjänstskiktning är aktörstjänsten själv en tillförlitlig tjänst. Du kan skriva en egen tjänst som härleds från ActorService. Du kan också implementera funktioner på tjänstnivå på samma sätt som när du ärver en tillståndskänslig tjänst, till exempel:

Tjänstsäkerhetskopiering och återställning.
Delade funktioner för alla aktörer, till exempel en kretsbrytare.
Fjärrproceduren anropar själva aktörstjänsten och på varje enskild aktör.

Använda aktörstjänsten

Aktörsinstanser har åtkomst till aktörstjänsten där de körs. Via aktörstjänsten kan aktörsinstanser programmatiskt hämta tjänstkontexten. Tjänstkontexten har partitions-ID, tjänstnamn, programnamn och annan Azure Service Fabric-plattformsspecifik information.

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

Precis som alla Reliable Services måste aktörstjänsten registreras med en tjänsttyp i Service Fabric-körningen. För att aktörstjänsten ska kunna köra dina aktörsinstanser måste även aktörstypen registreras med aktörstjänsten. ActorRuntime-registreringsmetoden gör det här jobbet för aktörerna. I det enklaste fallet kan du registrera aktörstypen och aktörstjänsten använder sedan standardinställningarna.

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

        Thread.Sleep(Timeout.Infinite);
    }
}

Du kan också använda en lambda som tillhandahålls av registreringsmetoden för att skapa aktörstjänsten själv. Sedan kan du konfigurera aktörstjänsten och uttryckligen konstruera dina aktörsinstanser. Du kan mata in beroenden till aktören via konstruktorn.

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

Aktörstjänstmetoder

Aktörstjänsten implementerar IActorService (C#) eller ActorService (Java), som i sin tur implementerar IService (C#) eller Service (Java). Det här gränssnittet används av Reliable Services-fjärrkommunikation, vilket möjliggör fjärrproceduranrop på tjänstmetoder. Den innehåller metoder på tjänstnivå som kan anropas via fjärrkommunikation via tjänsten. Du kan använda den för att räkna upp och ta bort aktörer.

Anpassad aktörstjänst

Genom att använda lambda för aktörsregistrering kan du registrera din egen anpassade aktörstjänst som härleds från ActorService (C#) och FabricActorService (Java). Sedan kan du implementera dina egna funktioner på tjänstnivå genom att skriva en tjänstklass som ärver ActorService (C#) eller FabricActorService (Java). En anpassad aktörstjänst ärver alla funktioner för aktörskörning från ActorService (C#) eller FabricActorService (Java). Den kan användas för att implementera dina egna tjänstmetoder.

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

Implementera aktörssäkerhetskopiering och återställning

En anpassad aktörstjänst kan exponera en metod för att säkerhetskopiera aktörsdata genom att dra nytta av den fjärrkommunikationslyssnare som redan finns i ActorService. Ett exempel finns i Säkerhetskopiering och återställning av aktörer.

Aktör som använder en V2-stack för fjärrkommunikation (gränssnittskompatibel)

Remoting V2-stacken (gränssnittskompatibel, kallas V2_1) har alla funktioner i V2-fjärrkommunikationsstacken. Dess gränssnitt är kompatibelt med V1-stacken för fjärrkommunikation, men det är inte bakåtkompatibelt med V2 och V1. Om du vill uppgradera från V1 till V2_1 utan att det påverkar tjänstens tillgänglighet följer du stegen i nästa avsnitt.

Följande ändringar krävs för att använda V2_1 stacken för fjärrkommunikation:

Lägg till följande sammansättningsattribut i aktörsgränssnitt.

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

Skapa och uppgradera aktörstjänst- och aktörsklientprojekt för att börja använda V2-stacken.

Aktörstjänstuppgradering till V2-stack (gränssnittskompatibel) utan att påverka tjänstens tillgänglighet

Den här ändringen är en uppgradering i två steg. Följ stegen i den här sekvensen.

Lägg till följande sammansättningsattribut i aktörsgränssnitt. Det här attributet startar två lyssnare för aktörstjänsten, V1 (befintlig) och V2_1 lyssnare. Uppgradera aktörstjänsten med den här ändringen.
```
[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V1|RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]
```
Uppgradera aktörsklienterna när du har slutfört den föregående uppgraderingen. Det här steget ser till att aktörsproxyn använder V2_1 stacken för fjärrkommunikation.

Steget är valfritt. Ändra föregående attribut för att ta bort V1-lyssnaren.

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

Aktör som använder V2-stacken för fjärrkommunikation

Med nuget-paketet version 2.8 kan användarna nu använda V2-stacken för fjärrkommunikation, som presterar bättre och tillhandahåller funktioner som anpassad serialisering. Fjärrkommunikation V2 är inte bakåtkompatibel med den befintliga fjärrkommunikationsstacken (kallas nu för V1-fjärrkommunikationsstacken).

Följande ändringar krävs för att använda V2-stacken för fjärrkommunikation.