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

Artigo
08/25/2024

Conforme descrito em camadas de serviço, o próprio serviço do ator é um serviço confiável. Você pode escrever 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 quando herda um serviço com monitoração de estado, como:

Serviço de backup e restauração.
Funcionalidade compartilhada para todos os atores, por exemplo, um disjuntor.
O procedimento remoto chama o próprio serviço do ator e cada ator individualmente.

Use o serviço de ator

As instâncias de ator têm acesso ao serviço de ator no qual estão sendo executadas. Através do serviço de ator, as instâncias do 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 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 Serviços Confiáveis, o serviço de ator deve ser registrado com um tipo de serviço no tempo de execução do Service Fabric. Para que o serviço de ator execute suas instâncias de ator, seu tipo de ator também deve ser registrado no serviço de ator. O método de registo ActorRuntime realiza este trabalho para atores. No caso mais simples, você pode registrar seu tipo de ator, e o serviço de ator usa 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 construir o serviço de ator por conta própria. Em seguida, você pode configurar o serviço ator e construir explicitamente suas instâncias de ator. Você pode injetar dependências em seu ator através 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 de serviço do ator

O serviço ator implementa IActorService (C#) ou ActorService (Java), que por sua vez implementa IService (C#) ou Service (Java). Essa interface é usada pela comunicação remota de Serviços Confiáveis, que permite chamadas de procedimento remoto em métodos de serviço. Ele contém métodos de nível de serviço que podem ser chamados remotamente por meio de comunicação remota de serviço. Você pode usá-lo para enumerar e excluir atores.

Serviço de ator personalizado

Usando o lambda de registro de ator, você pode registrar seu próprio serviço de ator personalizado que deriva de ActorService (C#) e FabricActorService (Java). Em seguida, você pode implementar sua própria funcionalidade de nível de serviço escrevendo uma classe de ActorService serviço que herda (C#) ou FabricActorService (Java). Um serviço de ator personalizado herda toda a funcionalidade de tempo de execução 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 backup e restauração do ator

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

Ator que usa uma pilha V2 remota (compatível com interface)

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

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

Adicione o seguinte atributo assembly nas interfaces do ator.

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

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

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

Esta alteração é uma atualização em duas etapas. Siga os passos nesta sequência.

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

Este passo é 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 V2 de comunicação remota

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

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