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
                }
              }
            }
          }
  ]]>

似乎正确地建立了群集连接。我看到状态[UP]以及与角色的关联＆＃34; math＆＃34;出现在服务器端。

关于WebCramler上的示例的事件，我没有实现发送消息。我总是得到一个动物。

我试着这样：

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

或

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

有人知道一个好的教程还是可以帮助我？感谢

Answer 1

一些评论：

首先：假设您从服务器向客户端发送工作。然后，您实际上是在客户端上远程部署actor。这意味着只有服务器节点需要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：您为每个请求创建一个新的路由器角色。不要这样做。创建路由器actor一次，并重用IActorRef。
摆脱了MathAgentWorker项目
由于您未使用远程actor部署。我将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));

Akka.Net聚类简单解释

1 个答案: