Je veux créer un système qui n'aura pas un seul point de défaillance. J'avais l'impression que les routeurs sont l'outil pour le faire, mais je ne suis pas sûr que cela fonctionne comme je m'y attendais. C'est le point d'entrée de mon programme:Akka point de défaillance unique
object Main extends App{
val system = ActorSystem("mySys", ConfigFactory.load("application"))
val router = system.actorOf(
ClusterRouterPool(RoundRobinPool(0), ClusterRouterPoolSettings(
totalInstances = 2, maxInstancesPerNode = 1,
allowLocalRoutees = false, useRole = Some("testActor"))).props(Props[TestActor]),
name = "testActors")
}
Et ceci est le code pour l'exécution de la ActorSystem à distance (de sorte que le routeur peut déployer le code TestActor aux nœuds distants):
object TestActor extends App{
val system = ActorSystem("mySys", ConfigFactory.load("application").getConfig("testactor1"))
case object PrintRouterPath
}
I Je cours cela deux fois, une fois avec testactor1 et une fois avec testactor2.
Code TestActor:
class TestActor extends Actor with ActorLogging{
implicit val ExecutionContext = context.dispatcher
context.system.scheduler.schedule(10000 milliseconds, 30000 milliseconds,self, PrintRouterPath)
override def receive: Receive = {
case PrintRouterPath =>
log.info(s"router is on path ${context.parent}")
}
}
Et application.conf
akka{
actor {
provider = "akka.cluster.ClusterActorRefProvider"
}
remote {
log-remote-lifecycle-events = off
netty.tcp {
hostname = "127.0.0.1"
port = 2552
}
}
cluster {
seed-nodes = [
"akka.tcp://[email protected]:2552"
"akka.tcp://[email protected]:2553"
"akka.tcp://[email protected]:2554"]
auto-down-unreachable-after = 20s
}
}
testactor1{
akka{
actor {
provider = "akka.cluster.ClusterActorRefProvider"
}
remote {
log-remote-lifecycle-events = off
netty.tcp {
hostname = "127.0.0.1"
port = 2554
}
}
cluster {
roles.1 = "testActor"
seed-nodes = [
"akka.tcp://[email protected]:2552"
"akka.tcp://[email protected]:2553"
"akka.tcp://[email protected]:2554"]
auto-down-unreachable-after = 20s
}
}
}
testactor2{
akka{
actor {
provider = "akka.cluster.ClusterActorRefProvider"
}
remote {
log-remote-lifecycle-events = off
netty.tcp {
hostname = "127.0.0.1"
port = 2553
}
}
cluster {
roles.1 = "testActor"
seed-nodes = [
"akka.tcp://[email protected]:2552"
"akka.tcp://[email protected]:2553"
"akka.tcp://[email protected]:2554"]
auto-down-unreachable-after = 20s
}
}
}
Maintenant, le problème est que lorsque le processus qui a commencé le routeur est tué, les acteurs qui exécutent le code de TestActor, ne recevant aucun message (les messages que le planificateur envoie), je m'attendrais à ce que le routeur soit déployé sur un autre noeud de départ dans le cluster et les acteurs seront récupérés. Est-ce possible? ou existe-t-il un autre moyen de mettre en œuvre ce flux et de ne pas avoir un seul point de défaillance?
1) permet de dire que j'ai deux noeuds en cours d'exécution testActor vous suggérez pour démarrer le routeur sur chacun d'entre eux (groupe d'avoir exactement les mêmes deux cas sur chaque routeur). maintenant comment vais-je utiliser le routeur? Je veux dire quel sera le but de l'utiliser? Si je veux envoyer un message de diffusion aux routes, je vais soit envoyer un message à l'un des noeuds contenant le routeur (et ce noeud peut être indisponible) ou les envoyer à tous et ensuite recevoir plusieurs messages. Est-ce que je manque quelque chose? 2) Si j'utilise 'ClusterSingletonManager', cela ne veut-il pas dire que je ne peux pas démarrer deux acteurs avec' TestActor'? –