Comment commencer à utiliser Git pour différentes bases de code de différents serveurs?

Contexte: J'ai récemment hérité d'un ensemble de projets dans mon entreprise et j'essaie de régler certains problèmes fondamentaux avec la façon dont ils ont été traités. À savoir, les développeurs précédents (qui ne font plus partie de la société) n'utilisaient aucune forme de contrôle de source, faisaient peu de documentation et n'avaient pas vraiment de bons processus de développement en place.

Alors maintenant, j'ai trois serveurs pour des projets (développement, mise en scène, production) qui consistent principalement en des sites Web et des applications et des outils conçus pour les applications tierces et les API que nous utilisons, jusqu'aux magasins de scripts SQL et autres. Ma première pensée a été d'intégrer tout cela dans Git avant que des modifications et des correctifs ne soient apportés, mais j'ai du mal à trouver la meilleure façon de le faire.

De nombreux développements antérieurs ont été effectués directement sur les serveurs de production, ce qui a créé un fossé entre la base de code de chaque serveur. On ne sait pas immédiatement où se situent toutes les différences - je vois des corrections de bogues du côté de la production qui ne sont pas reportées sur le développement / la mise en scène, ainsi que de nouvelles fonctionnalités sur le développement qui n'ont pas été déplacées vers la mise en scène / la production .

Question: Quelle serait la meilleure façon pour moi de les organiser et de les déplacer dans Git? Comment est-ce que je structurerais mes repos / branches pour tenir compte des différences dans le code?

J'ai envisagé de poursuivre le développement à partir de clones du code du serveur de production et de conserver les bases de code de développement / de transfert comme référence historique. Serait-ce potentiellement un point de départ, étant donné que je ne sais rien du code dev / staging de toute façon? Je pouvais simplement créer des dépôts des serveurs de production pour chaque site Web, outil, jeu de scripts, etc., créer des branches pour le code de développement / de transfert existant, et tout nouveau développement se dériverait à partir de la base de code du serveur de production. Est-ce que ça a du sens?

Poussez les trucs de production dans la masterbranche d'un nouveau repo. Créez une developbranche à partir de cela, puis fusionnez-y le serveur de transfert. Vous pouvez vous retrouver avec des conflits qui doivent être résolus. Une fois que ceux -ci sont résolus, créer un autre à feature_branchpartir developet fusionner le serveur de développement en elle. Résolvez tous les conflits qui surviennent.

Cela vous laisse 3 branches, qui représentent vos environnements de production, de mise en scène et de développement. Production -> master, mise en scène -> develop, développement -> feature_branch. Tout développement est donc effectué sur feature_brancheset n'est fusionné dans la developbranche que lorsque la fonctionnalité est terminée, testée et stable. Puisqu'il est stable, il peut être utilisé comme mise en scène. Coupez une releasebranche à partir du developmoment où vous êtes prêt à publier, attachez toutes les extrémités libres, fusionnez-les master, puis vous avez votre nouvelle version de production.

L'une de vos premières commandes après avoir configuré cette configuration devrait être de fusionner le feature_branchback in develop*, puis de le faire à developnouveau master. Gardez à l'esprit que le feature_branchpeut contenir du code et des fonctionnalités non testés, alors soyez prudent lorsque vous le fusionnez developet ensuite master. Une fois cela fait, toutes les branches doivent contenir le même code, et tout développement qui a été fait sur le serveur de production est maintenant redirigé vers le "serveur" de développement.

Dans ce modèle, chaque projet serait dans son propre référentiel, et ce référentiel aurait une branche masteret develop, plus feature_branchespour tout travail effectué.

EDIT, pour répondre aux commentaires: Oui, c'est Gitflow.

Cette stratégie (ou Gitflow en général) maintient le système existant à 3 niveaux (production, mise en scène, développement) avec un chemin de fusion clair depuis le développement jusqu'à la production. L'importation des bases de code de cette manière permet également de synchroniser les branches tout en maintenant le statu quo en production - au moins, jusqu'à ce que les fusions puissent être testées. Cela atteint quelques objectifs: obtient le code dans le contrôle de code source, synchronise et fusionne les différentes bases de code (donc il n'y a plus de corrections de bogues en production mais pas en développement), et fournit un processus agréable à utiliser à l'avenir (un processus bien défini et utilisé par de nombreuses personnes / équipes / entreprises). Si l'OP trouve que Gitflow n'est pas bien adapté à ses projets / équipes / entreprise tel qu'il l'utilise / l'entreprise grandit, alors c'est '

* Vous souhaiterez peut-être couper une autre branche de fonctionnalité et supprimer toutes les nouvelles fonctionnalités évidentes, et fusionner cette branche dans develop(puis dans master). Cela vous évite d'avoir à tester de nouvelles fonctionnalités en plus de tous les autres tests que vous effectuerez.

Je vais recommander le stagingcode comme meilleure référence pour votre importation initiale. En effet, il y a des changements productionqui ne sont pas dans staging, en raison des correctifs, mais beaucoup moins, s'il y en a, stagingqui ne le sont pas production. De même, il y a des changements developmentqui ne sont pas inclus staging, en raison des nouvelles fonctionnalités, mais probablement beaucoup moins, voire aucun, stagingqui ne le sont pas development.

Notez que vous ne pas voulez stagingêtre votre base après votre importation initiale. Il s'agit simplement d'une situation temporaire en raison de modifications qui n'avaient pas été suivies auparavant. Les opérations de succursale se déroulent beaucoup plus facilement si vous ajoutez des modifications plutôt que de les supprimer. Après votre importation initiale, passez au modèle de branchement qui convient le mieux à vos besoins à l'avenir.

Donc, vérifiez votre stagingcode dans une stagingbranche, puis faites un git checkout -b master stagingpour créer votre masterbranche et archivez votre code de production là-dedans. Ensuite, faites un git checkout -b development stagingpour créer votre developmentbranche et vérifiez votre code de développement là-dedans.

Maintenant , vérifier votre developmentbranche et de fusion master en elle. Cela vous permettra de résoudre l'énorme quantité probable de conflits de fusion tout en conservant masterun enregistrement de ce qui est réellement en production. developmentcontient maintenant tous les changements de chaque environnement. Vous pouvez désormais basculer vers le modèle de branchement qui vous convient le mieux.

C'est une bonne idée d'avoir l'histoire. Je créerais le référentiel (ou un pour chaque produit) à partir de l'environnement le plus stable. Créez des branches ou des différences pour les autres.

À un haut niveau:

1. Créer un nouveau référentiel
2. À partir d'une copie de travail basée sur la production: ajoutez tout, validez et envoyez
3. Extraire le maître vers un nouveau répertoire
4. Pour chaque environnement supplémentaire XYZ
   1. Créer une branche Archive-XYZ
   2. Remplacez tout par la XYZsource (sauf .git)
   3. ajouter tout, valider et pousser

Alternativement, si vous êtes sceptique quant à la valeur de ceci, git diff > XYZ.diffau lieu de réellement commettre et pousser, et archiver les différences.

Dans les deux cas, vous devez vous retrouver dans un état où vous pouvez facilement comparer le code que vous avez exécuté dans chaque environnement, que vous pouvez utiliser pour définir un point de départ unique pour chaque projet. Et, si quelque chose se casse, vous pourrez théoriquement comparer vos modifications avec l'un des trois environnements.