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

Artikel
06/01/2023

Enligt beskrivningen 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 Plattformsspecifik information för 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();
}

Precis som med 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 aktörstypen också vara registrerad hos aktörstjänsten. ActorRuntime-registreringsmetoden gör det här jobbet för aktörerna. I det enklaste fallet kan du registrera din aktörstyp 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 tillåter 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

Med hjälp av 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 aktörskörningsfunktioner 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 säkerhetskopiering och återställning av aktör

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

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

V2-stacken för fjärrkommunikation (gränssnittskompatibel, så kallad V2_1) har alla funktioner i V2-fjärrkommunikationsstacken. Gränssnittet ä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.

Uppgradering av aktörstjänsten till V2-stacken (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 tidigare uppgraderingen. Det här steget ser till att aktörsproxyn använder V2_1 stacken för fjärrkommunikation.

Det här ä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 fungerar bättre och tillhandahåller funktioner som anpassad serialisering. Fjärrkommunikation V2 är inte bakåtkompatibel med den befintliga fjärrkommunikationsstacken (kallas nu V1-fjärrkommunikationsstacken).

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