Micro-services et réplication de données

Je construis une nouvelle application et lisais sur l'architecture des micro-services. L'architecture elle-même a beaucoup de sens du point de vue du développement, du déploiement et de la gestion du cycle de vie. Cependant, un problème est apparu concernant la façon de gérer les données de base.

Par exemple, j'ai 2 applications - disons l'application Sales et une application Ticketing. Supposons que ces deux applications sont conçues comme des micro-services propres. Cependant, ces deux applications, lorsqu'elles sont déployées (en supposant qu'elles sont déployées séparément, par exemple, Sales utilise MongoDB et Ticketing utilise MariaDB), devraient avoir accès aux mêmes instances de données de base, par exemple Comptes, Produits. Cela signifierait qu'il y aurait une application propriétaire pour une entité de données de base donnée (par exemple pour les comptes, il pourrait s'agir de l'application des ventes) et une partie intéressée (par exemple, l'application de billetterie aurait besoin d'avoir des informations sur les comptes).

Cela peut être réalisé de plusieurs manières: - Réplication des données du maître à la partie intéressée - Lecture synchrone de la partie intéressée au maître (la dépendance de synchronisation n'est pas recommandée par le paradigme de l'architecture des micro-services) - Propre référentiel centralisé

Même dans les comptes, il peut y avoir une partie principale commune aux ventes et à la billetterie (par exemple, nom du compte, adresse, etc.). Cependant, certains aspects du compte peuvent être UNIQUEMENT pertinents pour les ventes et d'autres uniquement pour la billetterie.

Avez-vous des réflexions / meilleures pratiques / opinions concernant l'une des options mentionnées ci-dessus?

Je faisais partie d'une équipe qui a réussi à construire une architecture de microservices à l'aide d'un bus de service.

Au départ, nous pensions que des microservices et une architecture pilotée par les événements nous permettraient de corriger la base de données sous-jacente de boule de boue sous-jacente.

Ce que nous avons appris, c'est que les microservices et une architecture pilotée par les événements nous obligeaient à nous débarrasser de la base de données sous-jacente de boule de boue.

Je crois que les données partagées sont incroyablement difficiles à bien faire avec les microservices - pour moi, c'est extrêmement difficile. Je recommande de ne pas autoriser les services à voir les données des autres. Si vous ne pouvez pas l'interroger, vous ne pouvez pas introduire accidentellement une dépendance.

Si vous faites partager des données, certainement un seul service ne peut jamais fait un seul dossier; c'est le seul service qui écrit dans l'enregistrement, et tout autre utilisateur des mêmes données devrait avoir un accès en lecture seule.

Malheureusement, même cette petite quantité gérée de partage introduit un couplage important entre vos services. Et si un service ne veut pas que les données soient sous cette forme? Peut-être qu'il veut une agrégation. Obtenez-vous votre service "propriétaire / écriture" pour écrire des données agrégées au profit d'un autre service? Je vous déconseille.

Et si le propriétaire souhaite conserver les données sous une forme différente? Ensuite, chaque service de lecture doit être mis à jour. C'est un cauchemar d'entretien.

La meilleure solution que nous avions était une duplication et une dénormalisation importantes de nos données. Les microservices conservent leurs propres copies des données dont ils se soucient.

Les messages étaient souvent publiés avec suffisamment de données d'accompagnement pour les traiter.

Par exemple, vous pourriez imaginer qu'un service d'expédition postale pourrait avoir besoin de garder une trace des modifications apportées à une adresse client, au cas où il aurait besoin de publier quelque chose. Mais si votre message «article prêt pour l'expédition» inclut l'adresse de destination dans les données du message, le service d'expédition n'a plus besoin de suivre les adresses changeantes liées aux clients; juste des adresses ponctuelles liées aux articles lors de leur expédition.

Je ne peux pas suggérer comment concevoir des solutions avec des données synchronisées. Nos solutions de données ont été construites autour de l'idée d'une "cohérence éventuelle".

Ainsi, lorsqu'un client met à jour son adresse, le service d'adresse traite la commande initiale à partir de l'interface utilisateur. Une fois que ses données sont correctes, il publie un événement pour notifier tous les autres services intéressés "Adresse client mise à jour" - avec l'adresse complète jointe en tant que données. Ces services mettront à jour leurs propres magasins de données avec les parties des données qui leur tiennent à cœur.

L'idée est que chaque fois qu'un service doit entreprendre une action importante, il doit disposer d'une copie des informations suffisamment à jour pour agir correctement, soit indépendamment, soit dans le cadre du message auquel il répond.

Le stockage partagé des données irait à l'encontre de l'architecture de microservice. Le fait est que s'il y a des comptes, il devrait y avoir un service pour les gérer et il ne devrait pas y avoir d'autre moyen d'interagir avec ces comptes que de faire un service complet. Vos microservices ne seraient pas indépendants s'ils partageaient un stockage commun et toute modification du mécanisme de stockage, de la validation ou d'autres contraintes devait être implémentée dans les deux services. Dans la pratique, cela ne se produit jamais et empêche rapidement les deux applications de subir des modifications importantes.

Utilisez donc un service comme seul moyen d'accéder à vos données, par exemple les comptes. Il peut arriver que l'implémentation d'une fonctionnalité dans un autre service nécessite une modification du service Comptes, et c'est OK. N'oubliez pas que la logique spécifique à n'importe quel service devrait être dans ce service et que le moins de choses spécifiques possible devraient aller dans le microservice Comptes.

devrait avoir accès aux mêmes instances de données de base, par exemple Comptes, Produits

Pas le même. Chaque micro-service doit faire sa propre cartographie pour les comptes, les produits, etc. Nous supposons que chaque micro-service aura une manière différente de travailler avec les entités.

Dans Domain Driven Design, cela est courant, où chaque contexte délimité (dans la même application!) Peut mapper la même entité d'une manière différente.

Si vous avez besoin de plus d'informations, je recommande le livre Building Microservices: Designing Fine-Grained Systems

Avez-vous envisagé le concept d'enregistrements squelettes basés sur un ensemble maître?

Par exemple, un microservice gère les comptes et l'autre gère les produits. Un tiers peut conserver des enregistrements des deux pour son objectif spécifique au domaine.