DEV Community

Cover image for Introdução aos Atores Virtuais (Grains) em .NET com Proto.Actor
Rafael Andrade
Rafael Andrade

Posted on

Introdução aos Atores Virtuais (Grains) em .NET com Proto.Actor

#braziliandevs #protoactor #actormodel #distributedsystems

No artigo anterior, discuti a configuração de um ator simples. Este artigo foca em Virtual Actor, um conceito que amplia o modelo tradicional de atores com gerenciamento automático de ciclo de vida e comunicação simplificada.

Virtual Actor (Grain)

O modelo de Virtual Actor (ou grain), popularizado pelo framework Orleans da Microsoft, abstrai o gerenciamento manual do ciclo de vida dos atores. Enquanto atores tradicionais exigem criação explícita e referência via PID, os atores virtuais são identificados por uma chave única. O framework os cria, ativa ou reativa automaticamente conforme necessário. Essa abstração simplifica a escalabilidade em sistemas distribuídos, dissociando a identidade do ator de sua localização física ou estado.

Diferenças-chave em relação aos atores clássicos:

  1. Gerenciamento de Ciclo de Vida: O framework (ex: Orleans ou Proto.Actor) cuida da ativação/desativação.
  2. Endereçamento: A comunicação usa identificadores lógicos, não PIDs.
  3. Persistência de Estado: Integra camadas de gerenciamento de estado para tolerância a falhas.

Requisitos

Definindo o Virtual Actor (Grain)

O Proto.Actor usa Protocol Buffers para definir interfaces de atores. Crie um arquivo Greeting.proto:

syntax = "proto3"; option csharp_namespace = "VirtualActor"; import "google/protobuf/empty.proto"; message SayHelloRequest { string name = 1; } service GreetingGrain { rpc SayHello(SayHelloRequest) returns (google.protobuf.Empty); }
Enter fullscreen mode Exit fullscreen mode

Isso gera:

  • Classes de requisição/resposta (ex: SayHelloRequest).
  • Classe base (GreetingGrainBase) para a lógica do ator.

Atualize o .csproj para habilitar a geração de código:

<ItemGroup> <Protobuf Include="Greeting.proto"> <GrcpServices>None</GrcpServices> </Protobuf> </ItemGroup> <ItemGroup> <ProtoGrain Include="Greeting.proto" /> </ItemGroup>
Enter fullscreen mode Exit fullscreen mode

Implementando o Ator

Crie uma classe GreetingActor herdando de GreetingGrainBase:

public class GreetingActor( IContext context, ClusterIdentity clusterIdentity, ILogger<GreetingActor> logger ) : GreetingGrainBase(context) { private int _invocationCount = 0; public override Task SayHello(SayHelloRequest request) { logger.LogInformation( "Hello {Name} (Cluster ID: {ClusterId} | Invocation Count: {Count})", request.Name, clusterIdentity.Identity, _invocationCount++ ); return Task.CompletedTask; } }
Enter fullscreen mode Exit fullscreen mode

Detalhes:

  • Gerenciamento de Estado: _invocationCount rastreia chamadas (thread-safe graças ao modelo de atores).
  • Injeção de Dependências: ILogger é injetado via ActivatorUtilities.

Configurando o Sistema de Atores

Configure o cluster com TestProvider (para desenvolvimento) e PartitionIdentityLookup:

var actorSystemConfig = Proto.ActorSystemConfig.Setup(); var remoteConfig = GrpcNetRemoteConfig.BindToLocalhost(); var clusterConfig = ClusterConfig .Setup( clusterName: "VirtualActor", clusterProvider: new TestProvider(new TestProviderOptions(), new InMemAgent()), identityLookup: new PartitionIdentityLookup() ) .WithClusterKind( kind: GreetingGrainActor.Kind, prop: Props.FromProducer(() => new GreetingGrainActor((context, clusterIdentity) => ActivatorUtilities.CreateInstance<GreetingActor>(provider, context, clusterIdentity))) ); return new ActorSystem(actorSystemConfig) .WithServiceProvider(provider) .WithRemote(remoteConfig) .WithCluster(clusterConfig);
Enter fullscreen mode Exit fullscreen mode

Integrando ao .NET

Registre o serviço de cluster como um IHostedService:

public class ActorSystemClusterHostedService(ActorSystem actorSystem) : IHostedService { public async Task StartAsync(CancellationToken cancellationToken) { await actorSystem.Cluster().StartMemberAsync(); } public async Task StopAsync(CancellationToken cancellationToken) { await actorSystem.Cluster().ShutdownAsync(); } }
Enter fullscreen mode Exit fullscreen mode

Registre em Program.cs:

services.AddHostedService<ActorSystemClusterHostedService>();
Enter fullscreen mode Exit fullscreen mode

Interagindo com Atores Virtuais

Use GetGreetingGrain para referenciar um ator por ID:

var actor = actorSystem.Cluster().GetGreetingGrain(fromName); await actor.SayHello(new SayHelloRequest { Name = toName }, CancellationToken.None);
Enter fullscreen mode Exit fullscreen mode

Exemplo de fluxo:

while (true) { Console.Write("Seu nome (ou 'q' para sair): "); var fromName = Console.ReadLine(); if (fromName == "q") break; Console.Write("Nome do destinatário: "); var toName = Console.ReadLine(); if (toName == "q") break; await actor.SayHello(new SayHelloRequest { Name = toName }); }
Enter fullscreen mode Exit fullscreen mode

Benefícios dos Atores Virtuais

  1. Concorrência Simplificada: Processamento sequencial de mensagens evita condições de corrida.
  2. Escalabilidade Elástica: Adicione/remova nós sem reconfigurar atores.
  3. Resiliência: Reativação automática garante comportamento "sempre ativo".

Conclusão

Atores Virtuais (ou Grains) revolucionam o desenvolvimento de sistemas distribuídos ao abstrair complexidade enquanto mantêm os benefícios do modelo de atores. Com o Proto.Actor, desenvolvedores .NET podem:

  • Focar na Lógica de Negócio: O framework gerencia ativação, escalabilidade e recuperação.
  • Construir Sistemas Resilientes: Reativação automática e persistência de estado garantem tolerância a falhas.
  • Escalar sem Esforço: Transparência de localização e clustering elástico distribuem carga entre nós.

Para produção:

  • Substitua TestProvider por provedores como Kubernetes ou Consul.
  • Adicione armazenamento persistente (ex: Redis, PostgreSQL).
  • Implemente monitoramento e health checks.

Referência

Top comments (0)