Implementar recursos de nível de serviço em seu serviço de ator

Artigo
06/01/2023

Conforme descrito em camadas de serviço, o próprio serviço de ator é um serviço confiável. Você pode gravar seu próprio serviço que deriva de ActorService. Você também pode implementar recursos de nível de serviço da mesma forma que faria quando você herda um serviço com estado, como:

Backup e restauração do serviço.
Funcionalidade compartilhada para todos os atores, por exemplo, um disjuntor.
Chamadas de procedimento remotas no próprio serviço de ator, bem como em cada ator individual.

Usar o serviço de ator

As instâncias de ator têm acesso ao serviço de ator no qual estão sendo executadas. Por meio do serviço de ator, as instâncias de ator podem obter programaticamente o contexto de serviço. O contexto de serviço tem a ID da partição, o nome do serviço, o nome do aplicativo e outras informações específicas da plataforma do Microsoft 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();
}

Como todos os Reliable Services, o serviço de ator deve ser registrado com um tipo de serviço no runtime do Service Fabric. Para que o serviço de ator seja executado em suas instâncias de ator, o tipo de ator também deve ser registrado no serviço de ator. O método de registro ActorRuntime realiza esse trabalho para os atores. No caso mais simples, é possível registrar o tipo de ator, e o serviço de ator usará as configurações padrão.

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

        Thread.Sleep(Timeout.Infinite);
    }
}

Como alternativa, você pode usar um lambda fornecido pelo método de registro para que você possa construir o serviço de ator por conta própria. Em seguida, você pode configurar o serviço de ator e construir explicitamente as instâncias de ator. É possível injetar dependências no ator por meio de seu construtor.

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étodos do serviço de ator

O Serviço de ator implementa IActorService (C#) ou ActorService (Java), que, por sua vez, implementa IService (C#) ou Service (Java). Essa interface é usada pela comunicação remota dos Reliable Services, que possibilita chamadas de procedimento remoto em métodos de serviço. Ela contém métodos no nível de serviço que podem ser chamados remotamente por meio da comunicação remota do serviço. Você pode usá-los para enumerar e excluir atores.

Serviço de ator personalizado

Usando o lambda de registro do ator, você pode registrar seu próprio serviço de ator personalizado que deriva de ActorService (C#) e FabricActorService (Java). Você pode, então, implementar sua própria funcionalidade de nível de serviço, escrevendo uma classe de serviço que herda ActorService (C#) ou FabricActorService (Java). Um serviço de ator personalizado herda toda a funcionalidade de runtime do ator de ActorService (C#) ou FabricActorService (Java). Ele pode ser usado para implementar seus próprios métodos de serviço.

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

Implementar o backup e a restauração de ator

Um serviço de ator personalizado pode expor um método para fazer backup dos dados do ator aproveitando o ouvinte de comunicação remota já presente em ActorService. Para obter um exemplo, consulte Atores de backup e restauração.

Ator que usa uma pilha de comunicação remota V2 (compatível com a interface)

A pilha de comunicação remota V2 (compatível com a interface, conhecida como V2_1) tem todos os recursos da pilha de comunicação remota V2. Sua interface é compatível com a pilha de comunicação remota V1, mas não é compatível com versões anteriores da V1 e da V2. Para atualizar da V1 para a V2_1 sem afetar a disponibilidade do serviço, siga as etapas na próxima seção.

As seguintes alterações são necessárias para usar a pilha V2_1 de comunicação remota:

Adicione o seguinte atributo de assembly nas interfaces de ator.

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

Compile e atualize os projetos de cliente e de serviço do ator para começar a usar a pilha V2.

Atualize o serviço de ator para a pilha de comunicação remota V2 (compatível com a interface) sem afetar a disponibilidade do serviço

Essa alteração é uma atualização em duas etapas. Siga as etapas deste tutorial.

Adicione o seguinte atributo de assembly nas interfaces de ator. Esse atributo inicia dois ouvintes para o serviço de ator, os ouvintes V1 (existente) e V2_1. Atualize o serviço de ator com essa alteração.
```
[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V1|RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]
```
Atualize os clientes de ator depois de concluir a atualização anterior. Esta etapa garante que o proxy do ator use a pilha de comunicação remota V2_1.

Esta etapa é opcional. Altere o atributo anterior para remover o ouvinte V1.

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

Ator que usa a pilha de comunicação remota V2

Com o pacote NuGet versão 2.8, os usuários agora podem usar a pilha de comunicação remota V2, que é mais eficaz e fornece recursos como serialização personalizada. A V2 de comunicação remota não é compatível com a pilha de comunicação remota existente (agora chamada de pilha de comunicação remota V1).

As seguintes alterações são necessárias para usar a pilha de comunicação remota V2.