Regroupement de plusieurs référentiels Git faisant partie du même projet global

Disons que j'ai un projet qui comporte plusieurs composants: un composant serveur, un composant d'application Web, un composant iOS, un composant Android, etc. Ces composants sont tous des bases de code distinctes, mais sont également couplés de manière lâche (par exemple, une modification du serveur le code peut également nécessiter une modification de tous les autres composants)

Quelle est la manière la plus efficace dans Git d'organiser ce projet? Si vous mettez tout cela dans un seul référentiel, vous aurez toujours les dernières versions mais les choses deviennent assez compliquées lorsque vous commencez à changer un composant et pas les autres.

D'un autre côté, si vous créez chaque composant en tant que référentiel séparé, comment seriez-vous en mesure de «lier» ces référentiels afin de savoir que la version 2.0 de l'application nécessite la version 1.5 du composant serveur, etc.?

Existe-t-il une fonctionnalité dans git en dehors de la mise à jour des fichiers Lisez-moi (ou une meilleure solution que je ne vois pas) pour gérer plus efficacement plusieurs dépôts liés?

Les sous-projets sont le lieu où les systèmes de contrôle de version distribués (DVCS) commencent, sinon se démêlent, deviennent certainement un peu bancaux.

Les sous - modules Git et les sous - référentiels Mercurial visent tous deux à soutenir le sous-projet. Les deux ont amélioré version par version (au point que l'ancien "cette fonctionnalité existe, mais vous ne devriez probablement pas l'utiliser" de Mercurial n'est plus à l'avant-plan.)

Pourtant, les référentiels multi-projets restent plus un cas d'utilisation spécialisé plutôt qu'une fonctionnalité que tout le monde utilise. La documentation contient de nombreuses mises en garde et des instructions «comment utiliser ces instructions» qui indiquent clairement que la gestion des «projets de projets» est une préoccupation à deux niveaux, la méta-gestion étant légèrement mais véritablement différente de la gestion de projet directe à un niveau. En conséquence, il y a beaucoup moins d'expérience là-bas. Et il ne manque pas de "ne pas utiliser de sous-modules git!" et "éviter les sous-dépôts mercuriels!" commentaires et articles de blog.

Ma propre expérience avec les sous-dépôts était mitigée. Cela a fonctionné ... mais c'était aussi ennuyeux. J'adore l'idée de sous-projets, mais dans la pratique, les alternatives - que ce soit de grands projets tout-en-un ou des projets frères et sœurs compagnons - sont plus faciles à résoudre (bien que moins élégantes). J'attends avec impatience le jour où les sous-dépôts sont courants et pas une douleur, mais je ne l'ai pas encore vécu.

Cela ne veut pas dire que la gestion des sous-modules / sous-dépôts ne fonctionnera pas pour vous, mais c'est quelque chose qui doit être fait avec soin, et certainement une certaine expérimentation et planification préalables.

Étant donné que vous êtes concentré sur Git, vous devriez également explorer les sous-arbres Git, que certains trouvent être une meilleure alternative aux sous-modules git .

Si vous utilisez C #, vous pouvez utiliser NuGet.

Faites de chaque composant une bibliothèque et conservez-les dans leur propre référentiel. Faites des versions des composants de base que vous versionnez en fonction du versionnage sémantique.

Enfin, demandez à votre buildserver de regrouper les bibliothèques dans des packages NuGet et de consommer ces packages NuGet dans les projets pour les composants frontaux (iOS, Android).

La même approche de base (dépendances de version et de package) peut également être utilisée dans d'autres langues, mais peut ne pas être aussi pratique.

Je ne vous recommanderais pas d'utiliser les sous-modules Git. Bien qu'il puisse être utilisé pour ce type de problèmes en théorie, je pense que c'est un problème plus important que cela ne vaut.

À mon avis, cela dépendrait de leur couplage réel. Il est vraiment agréable de pouvoir exécuter un automatisé git bisectlors du suivi d'une régression, mais cela sera difficile à faire si chaque commit dépend d'une version différente de vos autres dépendances à exécuter.

Deux options possibles seraient un référentiel avec des sous-modules ou plusieurs référentiels avec de bonnes pratiques de gestion des versions en place.

comment pourriez-vous «lier» ces référentiels pour savoir que la version 2.0 de l'application nécessite la version 1.5 du composant serveur, etc.?

C'est généralement le domaine de certains cadres de gestion des dépendances (par exemple Gradle, Maven), pas Git lui-même.