Comment puis-je déployer des acteurs pour séparer des processus/machines et utiliser le routeur ConsistentHashingGroup?

Question

Comment puis-je déployer des acteurs pour séparer des processus/machines et utiliser le routeur ConsistentHashingGroup?

Ma stratégie consiste à exploiter le routeur ConsistentHashingGroup en construisant dynamiquement un fichier de configuration avec les adresses de nœuds sur mon système. Ces nœuds ne sont pas tous sur le même processus mais peuvent également fonctionner sur des processus séparés.

L'exemple de fichier de configuration ci-dessous repose sur des adresses statiques. Cependant, je crois que j'ai besoin de générer dynamiquement un fichier de configuration car les chemins d'acteurs sur d'autres noeuds/machines ne sont pas connus au moment de la compilation.

 let config = ConfigurationFactory.ParseString(@" 
     routees.paths = [ 
      ""akka://ClusterSystem/user/Worker1"" #testing full path 
      ""akka://ClusterSystem/user/Worker2"" 
      ""akka://ClusterSystem/user/Worker3"" 
      user/Worker4 
     ]") 

Des suggestions?

Answer 1

J'ai d'abord dû référencer les noms des acteurs distants que je voulais utiliser dans mon configuration:

var config = ConfigurationFactory.ParseString(@" 
akka { 
    log-config-on-start = on 
    stdout-loglevel = DEBUG 
    loglevel = DEBUG 
    actor { 
     provider = ""Akka.Remote.RemoteActorRefProvider, Akka.Remote"" 

     debug { 
      receive = on 
      autoreceive = on 
      lifecycle = on 
      event-stream = on 
      unhandled = on 
     } 

     deployment { 
      /localactor { 
       router = consistent-hashing-pool 
       nr-of-instances = 5 
       virtual-nodes-factor = 10 
      } 
      /remoteactor1 { 
       router = consistent-hashing-pool 
       nr-of-instances = 5 
       remote = ""akka.tcp://system2@localhost:8080"" 
      } 
      /remoteactor2 { 
       router = consistent-hashing-pool 
       nr-of-instances = 5 
       remote = ""akka.tcp://system2@localhost:8080"" 
      } 
      /remoteactor3 { 
       router = consistent-hashing-pool 
       nr-of-instances = 5 
       remote = ""akka.tcp://system2@localhost:8080"" 
      } 
     } 
    } 
    remote { 
     dot-netty.tcp { 
      port = 8090 
      hostname = localhost 
     } 
    } 
} 
"); 

Je puis déployé à distance les acteurs:

//create a remote deployed actor 
    var remote1 = system.ActorOf(Props.Create(() => new SomeActor(null, 123)).WithRouter(FromConfig.Instance), "remoteactor1"); 
    var remote2 = system.ActorOf(Props.Create(() => new SomeActor(null, 456)).WithRouter(FromConfig.Instance), "remoteactor2"); 
    var remote3 = system.ActorOf(Props.Create(() => new SomeActor(null, 789)).WithRouter(FromConfig.Instance), "remoteactor3"); 

je devais ensuite ajouter les acteurs qui ont été déployés récemment à une instance ConsistentHashingGroup:

var hashGroup = system.ActorOf(Props.Empty.WithRouter(new ConsistentHashingGroup(config))); 

    Task.Delay(500).Wait(); 

    var routee1 = Routee.FromActorRef(remote1); 
    hashGroup.Tell(new AddRoutee(routee1)); 

    var routee2 = Routee.FromActorRef(remote2); 
    hashGroup.Tell(new AddRoutee(routee2)); 

    var routee3 = Routee.FromActorRef(remote3); 
    hashGroup.Tell(new AddRoutee(routee3)); 

j'étais alors en mesure t o utiliser l'instance de routeur pour envoyer des messages:

for (var i = 0; i < 5; i++) 
    { 
     for (var j = 0; j < 7; j++) 
     { 
      var message = new SomeMessage(j, $"remote message: {j}"); 
      hashGroup.Tell(message, someSender); 
     } 
    } 

Answer 2

Vous savez. Dans un scénario du monde réel. Les acteurs n'apparaissent pas comme par magie. Vous les déployez dans le cadre d'un routeur de pool par exemple, ou d'un autre mécanisme. Ou vous les démarrez explicitement.

Si vous exécutez votre groupe de hash à partir d'un noeud spécifique. Et vous savez où cela commence au moment du design. Vous pourriez également avoir des acteurs utilisant pub/sub pour publier leur propre adresse sur un sujet bien connu. Quel autre acteur s'inscrit et inscrit dans votre hashgroup. De cette manière, vous définissez un type de protocole/de conversation à l'intérieur de votre cluster que les acteurs peuvent utiliser pour faire partie d'un groupe de hachage spécifique.

Est-ce que cela a du sens?