Arnout,


I have a single type of actor that I create that will be not be 
instantiated but available to instantiate on a server cluster, lets call, 
ClusterX. That cluster can have two seed nodes and grow from 1 to 1000 
member nodes. These actors will have a key-value pair as state and when the 
state gets updated, they publish the changed value to a topic that is 
specific to that actor’s key  and subscribed by, say, 10 other actors with 
their own key value pairs. They update their key value pairs based on an 
algorithm and immediately publish to topics linked to their state keys. 
This chain process only stops when there are no more subscribers left.


The first in chain actor who got his state updated, is from external server.


The way I designed from what I read from your documentation is to use 
ClusterClient on external server, where an actor gets instatiated and gets 
ClusterClient and uses that to ‘tell’ ClusterReceptionist lying on seed 
nodes. I made sure the code of each of my actors on the 1-1000 member 
cluster nodes register themselves with the ClusterReceptionist as soon as 
they get instantiated. So I thought, ClusterClient on external (external to 
ClusterX) server ‘tell’s ClusterReceptionist with a key-value and 
ClusterReceptionist, which knows the registered actor (by the key of the 
state), will send it to him.


For me, the problem was ClusterReceptionist is a bottleneck because 
ClusterClient can only send to particular remote host (a seed node) on the 
clusterX. I am looking for a better way to be able to scale the ‘tell’-ing 
of the key-value pairs to Cluster Receptionist. 


Also, I could not figure out if I create the Actor on seed node, will it be 
rebalanced to another shard on a member node of ClusterX? 


Should not there be a better way for external server’s ClusterClient to 
create node agnostic way, Actors, that will be properly balanced and 
locations identified when further ‘tell’s need to be told?


Or am I thinking the whole thing wrong?


1. I need actors created from external requests without having to know 
where they are being created.

2. The actors also need to be receiving messages from external(external to 
Cluster they are in) programs without having to maintain a registry of the 
actors external to the cluster.


I also need persistence with cluster sharing because of all the rebalancing 
stuff.


Ram

On Monday, July 10, 2017 at 1:41:46 AM UTC-4, Ram K wrote:
>
> I have tried ActorSelection etc but it requires a host IP to be given 
> where the actor will be created.
>
> I have used ClusterClient with ClusterReceptionist on each node to send 
> messages to the destination actors but could not find anything in AKKA 
> documentation about a facility that will take request to create a specific 
> actor and create somewhere on the cluster without the original requestor 
> having to bother where it needs to be created or moved to.
>
> For my purposes I am using ClusterSharding with persistence and two seed 
> nodes and ClusterReceptionist on all nodes.
>
>
> Ram
>

-- 
>>>>>>>>>>      Read the docs: http://akka.io/docs/
>>>>>>>>>>      Check the FAQ: 
>>>>>>>>>> http://doc.akka.io/docs/akka/current/additional/faq.html
>>>>>>>>>>      Search the archives: https://groups.google.com/group/akka-user
--- 
You received this message because you are subscribed to the Google Groups "Akka 
User List" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to akka-user+unsubscr...@googlegroups.com.
To post to this group, send email to akka-user@googlegroups.com.
Visit this group at https://groups.google.com/group/akka-user.
For more options, visit https://groups.google.com/d/optout.

Reply via email to