Devrions-nous partager une base de données entre deux «microservices»?
Nous mettons en œuvre un service qui expose les données relatives à une partie particulière d'une entreprise. Il apportera des données de différentes sources, de faire des ETL et de le stockera à Redis. Il exposera ces données via des points de terminaison de repos (et éventuellement graphql).
Pour l'évolutivité, Redis sera reproduit de Londres aux États-Unis. Le service qui réside aux États-Unis n'aura pas besoin de faire de l'ETL car il n'utilisera que les données existantes dans Redis.
Parce que ce service a deux "modes" (lire et écrire à Londres, et juste lire aux États-Unis), nous discutons de savoir si nous devrions la diviser en deux services; celui qui écrit les données et celui qui lit les données.
Option 1:
Avoir deux services, potentiellement dans différents repos, où l'ETL et l'écriture des données et qui lit simplement ces données.
Les problèmes que nous pouvons voir avec cela sont que nous aurons deux beaucoup de tout (repos, projets de TeamCity, pieuvre déployant, etc.). Nous pourrions également nous retrouver avec des problèmes de versions car ils ont le potentiel d'évoluer à différentes vitesses.
Option deux:
Un service qui peut être démarré comme "lecture-écriture" ou "readonly"; À Londres, nous allons commencer dans le mode "lecture-écriture" et aux États-Unis, nous la démarrerons en mode "Readonly".
Cela résout la question de plusieurs repos, plusieurs projets d'équipe, etc.
Les problèmes que nous pouvons voir avec cette approche sont la complexité supplémentaire de la démarrer en particulier "mode". De plus, nous allons déployer un code (les composants ETL) essentiellement "éteints" en mode Radique.
Nous avons lu divers articles en ligne. Certains disent que les bases de données ne devraient jamais être partagées entre les "microservices" et certains en disant que c'est absolument bien.
Jusqu'à présent, j'ai utilisé des apostrophes autour du mot microservices. J'ai fait cela parce que jusqu'à présent dans cette question, j'ai utilisé le mot pour décrire "fonctionnalité technique", plutôt que plus bien défini :
L'approche de microservice de la division est différente et se scinder dans des services organisés autour de la capacité d'entreprise
J'aime cette description d'un microservice et je pense que cela donne du poids à mon option préférée, qui est l'option deux.
Mais je ne suis pas d'expert d'architecture, alors j'avais pensé que je me demanderais de voir ce que sont les opinions des autres peuples.
Quelle option choisiriez-vous ou feriez-vous quelque chose de totalement différent?
La raison pour laquelle il est généralement préférable de séparer les écrivies et les lisons est dû au fait que les problèmes qui résultent d'eux sont différents et, selon que votre application soit lue ou écrite, vous pouvez réduire les services de manière indépendante. Gestion des latences lors des écrivies (généralement plus élevées) et le nombre de raccordements à vos bases de données est beaucoup plus facile, une manipulation de services spécialisée écrit pour éviter les conflits est super utile.
[.
[.____] Bien sûr, en séparant, vous devez garder en tête de la version à l'esprit, mais il y a tellement de cadres sérialisés qui gèrent vraiment très bien la version (comme Protobuf, l'épargne).
[.____] Séparer les reposer - de tous les problèmes que nous développons à traiter, la dernière chose devrait être plusieurs équipes travaillant sur le même repo menant à de nombreux conflits.
Il n'est vraiment pas facile de donner une réponse spécifique à cette question sans connaître les exigences détaillées.
Il y a une recommandation: "Gardez ensemble ce qui change ensemble". Je dirais que si vous avez des exigences que vous n'avez pas écrites, départ petit!. Tout mettre dans un référentiel. Avoir un travail de construction. Déployer ensemble. Jusqu'à ce que vous ayez une bonne raison de la diviser.
Si les clients des États-Unis viendront à vous pour des demandes de fonctionnalités et des modifications complètement indépendantes des Londres, il pourrait alors que cela aurait peut-être un sens de scinder le projet (code, construction, déploiement), mais vous pouvez le faire plus tard, lorsque la première La demande de fonctionnalité est entrée.
Il n'y a rien de mal avec une réutilisation et une division de 100% de code via Configuration. Ne vous concentrez pas trop sur les coûts d'installation intérieurs du déploiement d'une "configuration" - vous devrez probablement configurer votre projet de toute façon (par ex. Sur l'environnement de test et l'environnement de production). La question de savoir s'il faut appliquer une ETL ou non est une autre option de configuration.
La question de savoir si vous souhaitez utiliser la configuration ou plutôt que la mise en œuvre pour vous séparer dépend vraiment de la manière dont vous vous attendez à ce que votre service évolue au fil du temps.
Certaines choses à réfléchir lorsque vous l'architecte/conception de votre service serait: - Les différents clients dépendent-ils toujours des mêmes données? - Les clients souhaitent-ils toujours que les données mises à jour simultanément (zones horodes)? - Y aura-t-il de nouveaux clients à l'avenir qui veulent avoir des données différentes et des moments différents? - Les différents clients auront-il différentes exigences non fonctionnelles (par exemple la performance)? Si vous utilisez REDIS et que vous répliquez des données entre Londres et nous, vous avez probablement besoin d'un accès très rapide à ces données? - Y aura-t-il des différents ou les mêmes développeurs pour les deux clients? - Les services seront-ils toujours libérés ensemble? Avez-vous besoin d'un temps d'arrêt des versions? À quelle fréquence avez-vous besoin de libérer?
Du point de vue architectural/design, vous devez découpler la collecte des données, la transformation des données de l'évaluation et de la transformation des données (lecture). Écrire et lire une partie de transformation, donc pour les clients de Londres que vous faites:
- Recueillir -> Transform -> Store et Lire -> Transform -> Servir
Pour les clients américains que vous faites:
- Recueillir -> Transform -> Store et Lire -> [Non Transform] -> Servir
En tout cas, il est logique que votre conception logicielle ait du sens pour découpler ces étapes autant que possible. Si votre conception de logiciel est bonne, vous n'avez aucun problème à scinder votre code plus tard. Que vous utilisiez ensuite une "configuration" ou "implémentation" pour que deux services différents est plus ou moins une décision mineure.
La manière dont vous configurez votre codeBase et votre construction a des raisons différentes. Sauf si vous n'avez pas de raison spécifique ou n'anticipez pas un problème de fractionnement plus tard, ne le faites pas.
Théoriquement, si deux microservices lisent une et même base de données, pourquoi avez-vous besoin de microservices, mais pas à un monolithe? Naturellement, il s'agit de la question, que s'ils lisent une seule et même base de données, mais chaque service a son propre ensemble de tables. Ensuite, il semble plus acceptable d'avoir des microservices séparés.
À la question donnée - vous avez mentionné que Redis sera répliqué, vous disposez donc de deux bases de données distinctes. Ensuite, il est parfaitement logique d'avoir deux services distincts, la seule chose qu'ils partagent en commun sont le modèle de données. Aux États-Unis, vous ne déployez que le lecteur, au Royaume-Uni, vous aurez un déploiement de lecteurs et d'écrivains. Néanmoins, il y a le problème que le lecteur britannique aura les données à jour légèrement plus rapidement que le lecteur américain.
Je pense que vous pourriez avoir un malentendu courant sur ce qui constitue un microservice. Les opérations de lecture et d'écriture ne sont pas des services et un microservice n'est pas de 1 à 1 avec des opérations. Vous pouvez avoir un microservice avec des opérations de lecture et d'écriture. Cela ne fait pas de monolithe. Cet article donne une vue d'ensemble des concepts de ce qui est et n'est pas une architecture de microservice:
Un bon moyen de regarder un microservice individuel est une collection de fonctions associées ou de points d'extrémité composant un contexte délimité dans votre domaine d'activité.
L'accent est mis sur le mien. La question que vous devez demander est de savoir si les services de lecture et d'écriture sont intrinsèquement couplés. Ce n'est pas aussi évident que cela pourrait sembler, mais ils sont souvent parce que l'opération de lecture dépend de la manière dont les données sont écrites. Vous pourrez peut-être éviter cela en construisant etl entre le côté lecture et l'écriture, mais la valeur de le faire est discutable et crée plus de complexité.
Votre besoin de ne pas lire que dans une région semble davantage comme une préoccupation d'autorisation qu'un architectural.