Meilleures pratiques pour le battement de coeur dans les systèmes distribués
Nous avions dans notre système dans le passé un fournisseur de données externe (appelez-la source) envoiant des battements de cœur réguliers à une application Java (appeler le client informatique). Si le battement de coeur a échoué, le système s'est enfermé (pour éviter de servir des données stables dans une application critique). Ceci était simple que les données et le rythme cardiaque utilisaient le même canal, ce qui la rend très fiable.
Depuis lors, nous avons déménagé dans un système distribué avec Java client décomposé dans plusieurs microservices et données qui circulent en partie à travers kafka files d'attente entre les services.
La chose importante - le système le plus en amont (appelez la destination informatique) devrait encore faire de manière fiable un battement de coeur.
Si nous continuons à envoyer le rythme cardiaque via un canal séparé, tout échec de l'une des microservices ou kafka _ La file d'attente perturbera le flux de données à la destination, d'autre part, le battement de cœur continuera à couler sans interruption - - échouer tout le but d'avoir un battement de coeur
Une solution que je pense est de pousser des battements cardiaques à travers tous les services et kafka _ des files d'attente afin qu'elles prennent le même chemin que les données elles-mêmes. Quoi qu'il en soit, quels sont les meilleurs modèles/critères de conception pour réimplémenter le battement de coeur dans un tel système distribué?
Votre solution est évidente. Lorsque chaque service reçoit un battement de cœur de l'une de ses sources, notez la source et l'heure, et lorsque ce service enverrait un battement de coeur (à ses puits), il vérifie que toutes les sources sont vives.
Si vous avez des sources facultatives, les "ma sources vivantes" deviennent plus difficiles, mais vous avez probablement traité cela dans la manière dont il gère les données, le battement de coeur doit juste correspondre à cette approche.
Si ServiceA peut envoyer des données à l'une des 3 instances de ServiceB, il doit envoyer des battements de coeur à toutes les 3 instances.
Si ServiceC reçoit des données de l'une des 3 instances de ServiceD, il a vu un rythme cardiaque récent de son D source si TouteServiceD envoyé un
Un "battheat" est la résolution du mauvais problème.
Le consommateur des micro-services doit se protéger contre la servant des données obsolètes lorsque l'un des micro-services diminue.
En fait, un battement de coeur, même dans votre configuration actuelle, ne résolvez pas vraiment le problème.
Si la base de données tombe en panne, un "battement de coeur" qui ne se connecte pas à la base de données signalera que l'application est toujours en place. J'ai rencontré cela il y a plusieurs années. Pire encore, vous ne pouvez pas supposer que chaque micro service se connecte à la même base de données.
Chaque appel à un micro-service nécessite une manipulation des erreurs pour tout problème catastrophique pouvant survenir à partir du point de faire appel à l'appel (source) à toutes les ressources utilisées par le micro-service. Vous ne pouvez évidemment pas dire si la base de données d'un micro-service est en baisse lorsque vous devez l'appeler, mais une sorte de réponse d'erreur HTTP reviendra (4xx ou 5xx). Et lorsque les réponses ne reviennent pas, les applications consommant des micro-services ont besoin de délai impartis dans les appels.
Ce dernier élément du puzzle est une bonne surveillance du serveur de l'ensemble de l'écosystème de la technologie et un moyen bien défini et efficace d'informer les personnes responsables du maintien des consommateurs de micro-services de tout problème.
Bienvenue dans l'architecture de service orientée/micro-service. Les choses fonctionnent bien quand ils travaillent, mais lorsque le chaos règne, il se déverse.