Scala + Akka: Comment développer un cluster haute disponibilité multi-machine

Question

Nous développons un système de serveur Scala + pour Akka un jeu qui servira clients dans Android, iPhone et Second Life. Il y a des parties de ce serveur qui doivent être hautement disponibles, en cours d'exécution sur plusieurs machines. Si l'un de ces filières de serveurs (de, par exemple, défaillance matérielle), le système a besoin pour continuer à fonctionner. Je pense que je veux les clients d'avoir une liste des machines ils vont essayer de se connecter avec, similaire à la façon dont fonctionne Cassandra.

Les exemples à plusieurs nœuds, je l'ai vu jusqu'à présent avec Akka me semblent être centrées autour de l'idée d'évolutivité, plutôt que la haute disponibilité (au moins en ce qui concerne le matériel). Les exemples multinœuds semblent avoir toujours un point de défaillance unique. Par exemple il y a des équilibreurs de charge, mais si je dois redémarrer l'une des machines qui ont équilibreurs de charge, mon système souffriront un temps d'arrêt.

Y a-t-il des exemples qui montrent ce type de tolérance aux pannes de matériel pour Akka? Ou, avez-vous des idées sur de bonnes manières pour y arriver?

Jusqu'à présent, la meilleure réponse que je suis en mesure de trouver est d'étudier les documents Erlang du Bureau du Procureur, méditer sur eux, et essayer de comprendre comment mettre mon système en même temps en utilisant les blocs de construction disponibles à Akka.

Mais s'il y a des ressources, des exemples ou des idées sur la façon d'Etat part entre plusieurs machines de manière que si l'un d'eux descend les choses continuer à courir, je serais sûr de les apprécier, parce que je suis inquiet que je pourrais être réinventer la roue. Peut-être est un conteneur de STM multi-noeuds qui maintient automatiquement l'état partagé en synchronisation sur plusieurs nœuds? Ou peut-être cela est si facile à faire que la documentation ne prend pas la peine montrant des exemples de la façon de le faire, ou peut-être que je ne l'ai pas été assez approfondie dans mes recherches et encore l'expérimentation. Toutes les pensées ou les idées seront appréciées.

Answer 1

HA et la gestion de la charge est un aspect très important de l'évolutivité et est disponible en tant que partie de l'offre commerciale de AkkaSource.

Answer 2

Si vous listez plusieurs hôtes potentiels dans vos clients déjà, ceux-ci peuvent effectivement devenir équilibreurs de charge.

Vous pouvez offrir un service de suggestion hôte et recommande au client quelle machine ils doivent se connecter à (fonction de la charge en cours, ou autre), le client peut épingler que jusqu'à ce que la connexion échoue.

Si le service de suggestion hôte n'est pas là, le client peut choisir simplement un hôte aléatoire liste interne de celle-ci, les essayer jusqu'à ce qu'il se connecte.

Idéalement le premier démarrage, le client se connecte au service de suggestion d'accueil et non seulement se dirigé vers un hôte approprié, mais une liste d'autres hôtes potentiels. Cette liste peut être régulièrement mis à jour chaque fois que le client se connecte.

Si le service de suggestion d'accueil est en baisse sur les clients la première tentative (peu probable, mais ...), vous pouvez pré-déployer une liste d'hôtes dans le client installer afin qu'il puisse commencer immédiatement sélectionner au hasard les hôtes dès le début si il a aussi.

Assurez-vous que votre liste d'hôtes est des noms d'hôte réels, et non adresses IP, qui vous donnent plus de flexibilité à long terme (c.-à-vous « avez toujours » host1.example.com, host2.example.com ... etc . même si vous déplacez les adresses IP d'infrastructure et de changement).

Answer 3

Vous pouvez jeter un oeil comment RedDwarf et de la fourche DimDwarf sont construits. Ils sont à la fois les serveurs d'applications de jeu crash-qu'horizontalement évolutifs et DimDwarf est en partie écrit en Scala (nouvelle fonctionnalité de messagerie). Leur approche et l'architecture doivent correspondre à vos besoins très bien :)

Answer 4

2 cents ..

« comment l'état de partage entre plusieurs machines de manière que si l'un d'eux descend des choses à continuer à courir »

Ne pas partager l'état entre les machines, au lieu état de la partition entre toutes les machines. Je ne connais pas votre domaine donc je ne sais pas si cela va fonctionner. Mais essentiellement si vous affectez certains agrégats (en termes DDD) à certains nœuds, vous pouvez garder ces agrégats en mémoire (acteur, agent, etc.) quand ils sont utilisés. Pour ce faire, vous aurez besoin d'utiliser quelque chose comme Zookeeper pour coordonner les noeuds poignée qui agrégats. En cas d'échec, vous pouvez apporter le haut global sur un autre nœud.

De plus, si vous utilisez un modèle d'approvisionnement d'événements pour construire vos agrégats, il devient presque banal d'avoir des copies en temps réel (esclaves) de votre ensemble sur d'autres noeuds par ces nœuds d'écoute pour les événements et maintenir leurs propres copies.

En utilisant Akka, nous obtenons entre les nœuds de communication à distance presque gratuitement. Cela signifie que ce qui poignées jamais nœud une demande qui pourrait avoir besoin d'interagir avec un agrégat / entité sur un autre noeuds peuvent le faire avec RemoteActors.

Ce que je viens de décrire est très générale, mais donne une approche de tolérance aux pannes et distribué avec Akka ZooKeeper. Il peut ou ne peut pas aider. Je l'espère.

Tous les meilleurs, Andy