Akka.Net聚类简单解释

Question

我尝试使用akka.net做一个简单的集群。

目标是让服务器接收请求并通过集群进行akka.net处理。

为了测试和学习，我创建了一个简单的WCF服务，它接收一个数学方程，并且我希望将这个等式发送到求解。

我有一个项目服务器和另一个客户端。

服务器端的配置是：

<![CDATA[
      akka {
            actor {
              provider = "Akka.Cluster.ClusterActorRefProvider, Akka.Cluster"
              debug {
                receive = on
                autoreceive = on
                lifecycle = on
                event-stream = on
                unhandled = on
              }
              deployment {
                /math {
                  router = consistent-hashing-group #round-robin-pool # routing strategy
                  routees.paths = [ "/user/math" ]
                  virtual-nodes-factor = 8
                  #nr-of-instances = 10 # max number of total routees
                  cluster {
                     enabled = on
                                           max-nr-of-instances-per-node = 2
                                           allow-local-routees = off
                                           use-role = math
                  }
                }
              }
            }
            remote {
                helios.tcp {
                    transport-class = "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote"
                                    applied-adapters = []
                                    transport-protocol = tcp
                    port = 8081
                    hostname = "127.0.0.1"
                }
            }
          cluster {
              seed-nodes = ["akka.tcp://ClusterSystem@127.0.0.1:8081"] # address of seed node
             }

          }
  ]]>

在客户端，配置如下：

 <![CDATA[
      akka {
            actor.provider = "Akka.Cluster.ClusterActorRefProvider, Akka.Cluster"
            remote {
                log-remote-lifecycle-events = DEBUG
                log-received-messages = on

                helios.tcp {
                    transport-class = "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote"
                                    applied-adapters = []
                                    transport-protocol = tcp
                    port = 0
                    hostname = 127.0.0.1
                }
            }
            cluster {
              seed-nodes = ["akka.tcp://ClusterSystem@127.0.0.1:8081"] # address of the seed node
              roles = ["math"] # roles this member is in
             }
            actor.deployment {
              /math {
                router = round-robin-pool # routing strategy
                routees.paths = ["/user/math"]
                nr-of-instances = 10 # max number of total routees
                cluster {
                   enabled = on
                   allow-local-routees = on
                   use-role = math
                   max-nr-of-instances-per-node = 10
                }
              }
            }
          }
  ]]>

似乎正确地建立了群集连接。我看到在服务器端出现的状态和与角色“数学”的关联。

事件与WebCramler上的示例类似，我没有实现生成要传递的消息。我总是收到一封死信。

我试着这样做：

actor = sys.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "math");

或

var actor = sys.ActorSelection("/user/math");

有人知道一个好的教程或可以帮助我吗？谢谢

Answer 1

几点意见：

首先:假设您从服务器向客户端发送工作。那么，您就可以在客户端上有效地远程部署参与者。这意味着只有服务器节点需要actor.deployment配置部分。客户端只需要默认的集群配置(当然还有角色设置)。

第二:试着先简单一点。使用round-robin-pool代替。简单多了。试着让它发挥作用。然后从那里往上爬。这样可以更容易地消除配置/网络/其他问题。

您的用法：actor = sys.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "math");是正确的。

round-robin-pool配置的外观示例：

deployment {
                /math {
                  router = round-robin-pool # routing strategy
                  nr-of-instances = 10 # max number of total routees
                  cluster {
                     enabled = on
                     max-nr-of-instances-per-node = 2
                     allow-local-routees = off
                     use-role = math
                  }
                }
              }

试试这个。如果这有帮助的话请告诉我。

编辑：

好的，在看了你的样品之后。我改变了一些事情

• ActorManager->Process：您在每个请求中创建一个新的路由器参与者。别干那事。只创建一次路由器参与者，并重用IActorRef。
• 删除MathAgentWorker项目中的最小群集大小设置
• 因为你不使用远程角色部署。我把round-robin-pool改成了round-robin-group。

在那之后它起作用了。

还请记住，如果您使用consistent-hashing-group路由器，您需要指定哈希键。有多种方法可以做到这一点，在您的示例中，我认为最简单的方法是将发送到路由器的消息包装在ConsistentHashableEnvelope中。查看文档以获得更多信息。

最后，akka部署部分如下所示：

deployment {
                    /math {
                        router = round-robin-group # routing strategy
                        routees.paths = ["/user/math"]
                        cluster {
                           enabled = on
                           allow-local-routees = off
                           use-role = math
                        }
                     }
                  }

在MathAgentWorker上，我只更改了集群部分，它现在如下所示：

cluster {
                  seed-nodes = ["akka.tcp://ClusterSystem@127.0.0.1:8081"] # address of the seed node
                  roles = ["math"] # roles this member is in
                 }

ActorManager.Process所做的唯一的事情就是：

 return await Program.Instance.RouterInstance.Ask<TResult>(msg, TimeSpan.FromSeconds(10));