Contrôle de source basé sur Git dans l'entreprise: outils et pratiques suggérés?
J'utilise git pour des projets personnels et je trouve ça génial. Il est rapide, flexible, puissant et fonctionne très bien pour le développement à distance.
Mais maintenant, c'est obligatoire au travail et, franchement, nous avons des problèmes.
Au départ, git ne semble pas bien fonctionner pour un développement centralisé dans une grande organisation (plus de 20 développeurs) avec des développeurs de capacités et de niveaux de sophistication git différents - en particulier par rapport à d'autres systèmes de contrôle de source comme Perforce ou Subversion, qui visent ce type d'environnement. (Oui, je sais, Linus n'a jamais voulu cela.)
Mais - pour des raisons politiques - nous sommes coincés avec du crétin, même s'il craint pour ce que nous essayons de faire avec.
Voici certaines des choses que nous voyons:
- Les outils GUI ne sont pas matures
- À l'aide des outils de ligne de commande, il est bien trop facile de bousiller une fusion et d'effacer les modifications de quelqu'un d'autre
- Il n'offre pas d'autorisations de référentiel par utilisateur au-delà des privilèges globaux en lecture seule ou en lecture-écriture
- Si vous avez une autorisation sur N'IMPORTE QUELLE partie d'un référentiel, vous pouvez faire la même chose pour CHAQUE partie du référentiel, donc vous ne pouvez pas faire quelque chose comme créer une branche de suivi en petit groupe sur le serveur central que d'autres personnes ne peuvent pas jouer avec.
- Les flux de travail autres que "tout va bien" ou "dictateur bienveillant" sont difficiles à encourager, encore moins à faire respecter
- Il n'est pas clair s'il vaut mieux utiliser un seul grand référentiel (qui permet à tout le monde de tout gâcher) ou de nombreux référentiels par composant (ce qui crée des maux de tête en essayant de synchroniser les versions).
- Avec plusieurs référentiels, il n'est pas clair non plus comment répliquer toutes les sources d'une autre personne en tirant du référentiel central, ou pour faire quelque chose comme tout récupérer à 16h30 hier après-midi.
Cependant, j'ai entendu dire que les gens utilisent git avec succès dans les grandes organisations de développement.
Si vous êtes dans cette situation - ou si vous avez généralement des outils, des conseils et des astuces pour rendre plus facile et plus productif l'utilisation de git dans une grande organisation où certaines personnes ne sont pas des fans de ligne de commande - j'aimerais entendre ce que vous avez suggérer.
BTW, j'ai déjà posé une version de cette question sur LinkedIn, et je n'ai pas eu de vraies réponses mais beaucoup de "ça alors, j'aimerais aussi le savoir!"
MISE À JOUR: Permettez-moi de clarifier ...
Où je travaille, nous ne pouvons rien utiliser d'autre que git. Ce n'est pas une option. Nous sommes coincés avec ça. Nous ne pouvons pas utiliser Mercurial, svn, bitkeeper, Visual Source Safe, ClearCase, PVCS, SCCS, RCS, Bazaar, Darcs, monotone, Perforce, Fossil, AccuRev, CVS ou même le bon vieux projecteur d'Apple que j'ai utilisé en 1987. Donc, alors que vous êtes les bienvenus pour discuter d'autres options, vous n'obtiendrez pas la prime si vous ne discutez pas de git.
Je recherche également conseils pratiques sur l'utilisation de git dans l'entreprise. J'ai mis toute une liste de problèmes que nous rencontrons en haut de cette question. Encore une fois, les gens sont invités à discuter de la théorie, mais si vous voulez gagner la prime, donnez-moi des solutions.
Contre l'opinion commune, je pense que l'utilisation d'un DVCS est un choix idéal en entreprise car elle permet des workflows très flexibles. Je parlerai d'abord de l'utilisation d'un DVCS par rapport à CVCS, des meilleures pratiques et ensuite de git en particulier.
DVCS vs CVCS dans un contexte d'entreprise:
Je ne parlerai pas des avantages/inconvénients généraux ici, mais plutôt de me concentrer sur votre contexte. C'est la conception commune, que l'utilisation d'un DVCS nécessite une équipe plus disciplinée que l'utilisation d'un système centralisé. En effet, un système centralisé vous offre un moyen facile de appliquer votre flux de travail, l'utilisation d'un système décentralisé nécessite plus de communication et de la discipline pour s'en tenir à l'établi de conventions. Bien que cela puisse sembler induire des frais généraux, je vois un avantage dans l'augmentation de la communication nécessaire pour en faire un bon processus. Votre équipe devra communiquer sur le code, sur les modifications et sur l'état du projet en général.
Une autre dimension dans le contexte de la discipline est d'encourager la ramification et les expériences. Voici une citation de la récente entrée bliki de Martin Fowler sur Version Control Tools , il a trouvé une description très concise de ce phénomène.
DVCS encourage les branchements rapides pour l'expérimentation. Vous pouvez faire des branches dans Subversion, mais le fait qu'elles soient visibles par tous décourage les gens d'ouvrir une branche pour un travail expérimental. De même, un DVCS encourage le contrôle du travail: la validation de modifications incomplètes, qui peuvent même ne pas compiler ou passer des tests, dans votre référentiel local. Encore une fois, vous pouvez le faire sur une branche développeur dans Subversion, mais le fait que ces branches soient dans l'espace partagé rend les gens moins susceptibles de le faire.
DVCS permet des workflows flexibles car ils fournissent un suivi des changements via des identifiants uniques au niveau mondial dans un graphique acyclique dirigé (DAG) au lieu de simples différences textuelles. Cela leur permet de suivre en toute transparence l'origine et l'historique d'un ensemble de modifications, ce qui peut être très important.
Workflows:
Larry Osterman (un développeur Microsoft travaillant sur l'équipe Windows) a excellent article de blog sur le flux de travail qu'ils utilisent au sein de l'équipe Windows. Ils ont notamment:
- Un coffre propre et de haute qualité (repo principal)
- Tout le développement se produit sur les branches de fonctionnalités
- Les équipes de fonctionnalités ont des repos d'équipe
- Ils fusionnent régulièrement les derniers changements de tronc dans leur branche de fonctionnalité ( Forward Integrate )
- Les fonctionnalités complètes doivent passer plusieurs portes de qualité, par exemple examen, couverture de test, Q & A (repos sur leur propre)
- Si une fonctionnalité est terminée et a une qualité acceptable, elle est fusionnée dans le tronc ( Reverse Integrate )
Comme vous pouvez le voir, en ayant chacun de ces référentiels en direct, vous pouvez dissocier différentes équipes qui avancent à des rythmes différents. La possibilité de mettre en œuvre un système de porte flexible de qualité distingue également le DVCS du CVCS. Vous pouvez également résoudre vos problèmes d'autorisation à ce niveau. Seule une poignée de personnes devraient avoir accès au référentiel maître. Pour chaque niveau de la hiérarchie, ayez un dépôt séparé avec les politiques d'accès correspondantes. En effet, cette approche peut être très flexible au niveau de l'équipe. Vous devez laisser à chaque équipe le soin de décider si elle souhaite partager son référentiel d'équipe entre elles ou si elle souhaite une approche plus hiérarchique où seul le chef d'équipe peut s'engager dans le référentiel d'équipe.
(L'image a été volée chez Joel Spolsky hginit.com .)
Une chose reste à dire à ce stade: - même si DVCS offre de grandes capacités de fusion, c'est jamais un remplacement pour l'utilisation de l'intégration continue. Même à ce stade, vous avez une grande flexibilité: CI pour le dépôt de tronc, CI pour les dépôts d'équipe, les repos Q&A, etc.
Git dans un contexte d'entreprise:
Git n'est peut-être pas la solution idéale pour un contexte d'entreprise comme vous l'avez déjà souligné. Répétant certaines de vos préoccupations, je pense que ce sont notamment:
Prise en charge encore un peu immature sur Windows (veuillez me corriger si cela a changé récemment)Maintenant, Windows a client github windows , tortoisegit , SourceTree from atlassian- Manque d'outils GUI matures, pas d'intégration de vdiff/merge citoyen de première classe
- Interface incohérente avec un très faible niveau d'abstractions au-dessus de son fonctionnement interne
- Une courbe d'apprentissage très abrupte pour les utilisateurs de svn
- Git est très puissant et permet facile de modifier l'historique, très dangereux si vous ne savez pas ce que vous faites (et vous le ferez parfois même si vous pensiez le savoir)
- Aucune option de support commercial disponible
Je ne veux pas commencer une guerre des flammes git vs hg ici, vous avez déjà fait la bonne étape en passant à un DVCS. Mercurial aborde certains des points ci-dessus et je pense donc qu'il convient mieux dans un contexte d'entreprise:
- Toutes les plates-formes qui exécutent python sont prises en charge
- Grands outils GUI sur toutes les principales plates-formes (win/linux/OS X), intégration d'outils de fusion/vdiff de première classe
- Interface très cohérente, transition facile pour les utilisateurs svn
- Peut faire la plupart des choses que git peut faire aussi, mais fournit une abstraction plus propre. Les opérations dangereuses sont toujours explicites. Les fonctionnalités avancées sont fournies via des extensions qui doivent être explicitement activées.
- n support commercial est disponible de selenic.
En bref, lorsque j'utilise DVCS dans une entreprise, je pense qu'il est important de choisir un outil qui introduit le moins de friction. Pour que la transition soit réussie, il est particulièrement important de prendre en compte les compétences variables entre les développeurs (en ce qui concerne VCS).
Réduction du frottement:
Ok, puisque vous semblez être vraiment coincé avec la situation, il y a deux options à mon humble avis. Il n'y a aucun outil pour rendre git moins compliqué; git est compliqué. Soit vous affrontez cela, soit vous contournez git: -
- Obtenez un cours d'introduction à git pour toute l'équipe. Cela devrait inclure uniquement les bases et quelques exercices (important!).
- Convertissez le dépôt principal en svn et laissez les "jeunes étoiles" git-svn . Cela donne à la plupart des développeurs une interface facile à utiliser et peut compenser le manque de discipline dans votre équipe, tandis que les jeunes stars peuvent continuer à utiliser git pour leurs propres repos.
Pour être honnête, je pense que vous avez vraiment un problème de personnes plutôt qu'un problème d'outil. Que peut-on faire pour améliorer cette situation?
- Vous devez indiquer clairement que vous pensez que votre processus actuel se terminera par une base de code maintenable.
- Investissez du temps dans l'intégration continue. Comme je l'ai souligné ci-dessus, quel que soit le type de VCS que vous utilisez, il n'y a jamais de remplacement pour CI. Vous avez déclaré qu'il y a des gens qui poussent la merde dans le référentiel maître: demandez-leur de réparer leur merde pendant qu'une alerte rouge se déclenche et leur reproche d'avoir rompu la construction (ou de ne pas répondre à une mesure de qualité ou autre).
Je suis l'ingénieur SCM pour une organisation de développement assez importante, et nous nous sommes convertis à git à partir de svn au cours de la dernière année. Nous l'utilisons de manière centralisée.
Nous utilisons gitosis pour héberger les référentiels. Nous avons divisé nos référentiels monolithiques svn en de nombreux référentiels git plus petits, car l'unité de branchement de git est essentiellement le référentiel. (Il existe des moyens de contourner cela, mais ils sont maladroits.) Si vous voulez des types de contrôles d'accès par branche, gitolite pourrait être une meilleure approche. Il existe également une version à l'intérieur du pare-feu de GitHub si vous voulez dépenser de l'argent. Pour nos besoins, la gitose est très bien car nous avons des autorisations assez ouvertes sur nos référentiels. (Nous avons des groupes de personnes qui ont un accès en écriture à des groupes de référentiels, et tout le monde a un accès en lecture à tous les référentiels.) Nous utilisons gitweb pour une interface Web.
Quant à certaines de vos préoccupations spécifiques:
- fusion: vous pouvez utiliser un outil de fusion visuel de votre choix; il existe des instructions à divers endroits sur la façon de le configurer. Le fait que vous puissiez faire la fusion et vérifier sa validité totalement sur votre repo local est, à mon avis, un atout majeur pour git; vous pouvez vérifier la fusion avant de pousser quoi que ce soit.
- GUI: Nous avons quelques personnes utilisant TortoiseGit mais je ne le recommande pas vraiment; il semble interagir de façon étrange avec la ligne de commande. Je dois convenir qu'il s'agit d'un domaine qui doit être amélioré. (Cela dit, je ne suis pas un fan des interfaces graphiques pour le contrôle de version en général.)
- branches de suivi en petit groupe: si vous utilisez quelque chose qui fournit des listes de contrôle d'accès plus fines comme la gitolite, c'est assez facile à faire, mais vous pouvez également créer une branche partagée en connectant les référentiels locaux de divers développeurs - un référentiel git peut avoir plusieurs télécommandes.
Nous sommes passés à git parce que nous avons beaucoup de développeurs distants et parce que nous avons eu de nombreux problèmes avec Subversion. Nous expérimentons toujours des workflows, mais pour le moment, nous les utilisons essentiellement de la même manière que nous utilisions Subversion. Une autre chose que nous avons appréciée, c'est qu'elle a ouvert d'autres flux de travail possibles, comme l'utilisation de référentiels intermédiaires pour la révision du code et le partage de code entre de petits groupes. Cela a également encouragé beaucoup de gens à commencer à suivre leurs scripts personnels, etc., car il est si facile de créer un référentiel.
Oui, je sais, Linus n'a jamais voulu cela.
En fait, Linus soutient que les systèmes centralisés ne peuvent tout simplement pas fonctionner.
Et, qu'est-ce qui ne va pas avec le workflow dictateur et lieutenants?
Rappelez-vous, git est un système distribué ; n'essayez pas de l'utiliser comme un central.
(mis à jour)
La plupart de vos problèmes disparaîtront si vous n'essayez pas d'utiliser git comme s'il s'agissait de "svn on steroids" (car ce n'est pas le cas).
Au lieu d'utiliser un référentiel nu en tant que serveur central sur lequel tout le monde peut pousser (et potentiellement bousiller), configurez quelques gestionnaires d'intégration qui gèrent les fusions, afin qu'ils soient les seuls à pouvoir pousser vers le référentiel nu.
Habituellement, ces personnes devraient être les chefs d'équipe: chaque leader intègre le travail de sa propre équipe et le pousse vers le référentiel béni.
Encore mieux, quelqu'un d'autre (c'est-à-dire le dictateur) se retire des chefs d'équipe et intègre leurs changements dans le référentiel béni.
Il n'y a rien de mal à ce flux de travail, mais nous sommes une startup surchargée de travail et avons besoin de nos outils pour remplacer le temps humain et l'attention; personne n'a de bande passante pour faire des révisions de code, et encore moins être un dictateur bienveillant.
Si les intégrateurs n'ont pas le temps de revoir le code, c'est bien, mais vous devez toujours avoir des personnes qui intègrent les fusions de tout le monde.
Faire des pulls git ne prend pas beaucoup de temps.
git pull A
git pull B
git pull C
git remplace le temps humain et l'attention; c'est pourquoi il a été écrit en premier lieu.
- Les outils GUI ne sont pas matures
Les outils de l'interface graphique peuvent très bien gérer les choses de base.
Les opérations avancées nécessitent un état d'esprit codeur/ringard (par exemple, je suis à l'aise de travailler à partir de la ligne de commande). Il faut un peu de temps pour comprendre les concepts, mais ce n'est pas si difficile.
- À l'aide des outils de ligne de commande, il est bien trop facile de bousiller une fusion et d'effacer les modifications de quelqu'un d'autre
Ce ne sera pas un problème sauf si vous avez de nombreux développeurs incompétents avec un accès en écriture complet au "référentiel central".
Mais, si vous configurez votre flux de travail de sorte que seules quelques personnes (intégrateurs) écrivent dans le référentiel "béni", cela ne sera pas un problème.
Git ne facilite pas le rejet des fusions.
Lorsqu'il y a des conflits de fusion, git marquera clairement les lignes en conflit afin que vous sachiez quels changements vous appartiennent et lesquels ne le sont pas.
Il est également facile d'effacer le code d'autres personnes avec svn ou tout autre outil (non distribué). En fait, c'est beaucoup plus facile avec ces autres outils parce que vous avez tendance à "vous asseoir sur les changements" pendant une longue période et à un moment donné les fusions peuvent devenir horriblement difficiles.
Et parce que ces outils ne savent pas comment fusionner, vous finissez toujours par devoir fusionner les choses manuellement. Par exemple, dès que quelqu'un effectue un commit sur un fichier que vous éditez localement, il sera marqué comme un conflit qui doit être résolu manuellement; maintenant que est un cauchemar de maintenance.
Avec git, la plupart du temps, il n'y aura pas de conflits de fusion car git peut réellement fusionner. Dans le cas où un conflit se produit, git marquera clairement les lignes pour que vous sachiez exactement quels changements sont les vôtres et quels changements viennent d'autres personnes .
Si quelqu'un efface les changements des autres tout en résolvant un conflit de fusion, ce ne sera pas par erreur: ce sera soit parce que c'était nécessaire pour la résolution du conflit, soit parce qu'ils ne savent pas ce qu'ils font.
Il n'offre pas d'autorisations de référentiel par utilisateur au-delà des privilèges globaux en lecture seule ou en lecture-écriture
Si vous avez une autorisation sur N'IMPORTE QUELLE partie d'un référentiel, vous pouvez faire la même chose pour CHAQUE partie du référentiel, donc vous ne pouvez pas faire quelque chose comme créer une branche de suivi en petit groupe sur le serveur central que d'autres personnes ne peuvent pas jouer avec.
- Les flux de travail autres que "tout va bien" ou "dictateur bienveillant" sont difficiles à encourager, encore moins à faire respecter
Ces problèmes disparaîtront lorsque vous cesserez d'essayer d'utiliser git comme s'il s'agissait d'un système centralisé.
- Il n'est pas clair s'il vaut mieux utiliser un seul grand référentiel (qui permet à tout le monde de tout gâcher) ou de nombreux référentiels par composant (ce qui crée des maux de tête en essayant de synchroniser les versions).
Appel de jugement.
Quel genre de projets avez-vous?
Par exemple: la version xy du projet A dépend-elle exactement de la version wz du projet B telle que à chaque fois que vous vérifiez xy du projet A, vous devez également payer wz du projet B, sinon il ne se construira pas? Si c'est le cas, je mettrais le projet A et le projet B dans le même référentiel, car ils sont évidemment deux parties d'un même projet.
La meilleure pratique ici est de tilisez votre cervea
- Avec plusieurs référentiels, il n'est pas clair non plus comment répliquer toutes les sources d'une autre personne en tirant du référentiel central, ou pour faire quelque chose comme tout récupérer à 16h30 hier après-midi.
Je ne sais pas ce que tu veux dire.
Je recommande vivement http://code.google.com/p/gerrit/ pour le travail en entreprise. Il vous donne un contrôle d'accès et un flux de travail basé sur la révision intégré. Il s'authentifie sur n'importe quel système LDAP. Vous pouvez le connecter à Hudson avec http://wiki.hudson-ci.org/display/HUDSON/Gerrit+Plugin , vous permettant de créer et de tester des modifications pendant qu'elles sont encore en cours d'examen; c'est une configuration vraiment impressionnante.
Si vous décidez d'utiliser gerrit, je recommande d'essayer de garder une histoire assez linéaire, pas une histoire branchée comme certains gars open source comme. Gerrit formule ceci comme "autoriser uniquement les changements rapides". Ensuite, vous pouvez utiliser la ramification et la fusion de la façon dont vous en avez l'habitude, pour les versions et ainsi de suite.
Je réponds à cette question sur la base de mon expérience en tant que développeur manager dans un grand telco, où nous avons adopté Git en 2010
Vous avez ici un ensemble de problèmes assez différent:
- workflows
- outils client
- contrôle d'accès et intégration du serveur
Workflows
Nous avons adopté avec succès un mode de référentiel central: ce que nous avons dans notre projet d'entreprise (un grand portail pour une base de 5 millions d'utilisateurs) est un référentiel central de facto qui produit les versions officielles puis est pris en compte dans le processus de livraison (qui, dans notre , se compose de trois niveaux de tests et de deux déploiements). Chaque développeur gère son propre référentiel, et nous travaillons branche par fonctionnalité.
Outils client
Il y a maintenant plusieurs options disponibles, c'est maintenant une zone très encombrée. De nombreux développeurs utilisent avec succès Idée IntelliJ et Eclipse avec le plugin Git , sans autre chose. De plus, la plupart des développeurs Linux utilisent le client CLI git, sans aucun problème. Certains développeurs Mac utilisent avec succès Tower Git . Veuillez noter que aucun de ces clients ne peut empêcher l'utilisateur de "gâcher" avec le référentiel central: un mécanisme de contrôle côté serveur est nécessaire
Contrôle d'accès et intégration du serveur
Si vous voulez éviter que les développeurs "gâchent" votre référentiel Git, vous devez vraiment choisir une solution qui:
- expose une interface d'administration Web décente pour effectuer toutes les opérations
- vous permet d'imposer les identités des utilisateurs (l'utilisation d'un référentiel Git "nu" est extrêmement facile à valider au nom de quelqu'un d'autre)
- vous offre une sécurité fine (pour que vous puissiez par exemple empêcher FORCE-Push et définir certaines branches en lecture seule pour certains développeurs/groupes)
- s'intégrer à votre système d'authentification d'entreprise (par exemple LDAP, Windows ActiveDirectory)
- vous offre un audit complet (la conformité SOX est parfois très importante pour les grandes entreprises)
Il n'y a pas tellement de solutions côté serveur prêtes à l'emploi qui peuvent aider cela, je vous suggère de vérifier l'une d'entre elles:
- Gitorious : il peut fournir une sécurité de niveau d'accès de base, mais il manque un contrôle des autorisations finement défini, vous devrez donc probablement faire un codage pour gérer des scénarios tels que les autorisations au niveau de la branche. Il manque également l'intégration avec les mécanismes d'authentification d'entreprise existants
- GitHub Enterprise: récemment publié par GitHub, il propose GitHub dans votre entreprise. Il manque de conformité SOX et de sécurité à grain fin
- Gerrit : il peut fournir une sécurité de niveau d'accès fine et une intégration avec les systèmes d'authentification d'entreprise, mais il manque de conformité SOX et SSO. De plus, certaines opérations ne peuvent être effectuées que via SSH via CLI
- GitEnterprise : il fournit des autorisations au niveau des succursales, l'authentification unique, la conformité SOX, une administration Web complète. Il a récemment été également intégré à Gerrit, de sorte qu'il vous fournit également une instance Gerrit complète
J'espère que cela t'aides!
Il semble que votre problème est que vous n'avez pas décidé ou institué un flux de travail. Git est suffisamment flexible pour l'utiliser comme svn ou tout autre VCS, mais il est si puissant que si vous n'établissez pas de règles que tout le monde doit suivre, vous allez vous retrouver avec un gâchis. Je recommanderais le flux de travail dictateur-lieutenant que quelqu'un a mentionné ci-dessus, mais combiné avec le modèle de branchement décrit par Vincent Driessen . Pour plus d'informations, voir ces captures d'écran par David Bock , et celle-ci par Mark Derricutt .
Sur le tools, les utilisateurs de MacOS-X trouvent GitX (http://gitx.frim.nl/) très simple et efficace. L'inconvénient est qu'il ne prend pas en charge les hooks du client Git (ceux sous $ GIT_ROOT/.git/hooks).
Dans l'ensemble, je fais fortement pour choisir un outil qui prend en charge contrôle d'accès à grain fin sur: - les branches (afin de séparer les branches de publication stables avec une sécurité stricte des branches de sujet qui nécessitent plus d'agilité et de flexibilité) - contrôle d'identité (auteur/committer). Ceci est KEY for SOX - restrictions des commandes git - audit-trail. C'est la CLÉ pour SOX
Ceux que j'ai utilisés avec succès avec ces fonctionnalités sont:
- Révision du code Gerrit (http://code.google.com/p/gerrit/)
- GitEnterprise (http://gitenterprise.com)
- CollabNet TeamForge (http://www.collab.net/gotgit), utilise Gerrit 2.1.8 dans les coulisses
P.S. Ne sous-estimez pas la conformité SOX et CMMI: plusieurs fois, votre choix est limité et dicté par les politiques de sécurité de votre entreprise.
J'espère que cela t'aides.
Luca.
Nous sommes récemment passés de svn à git. Parce que git-daemon ne fonctionne pas avec msysgit, nous avons opté pour une approche de référentiel central sur un serveur Linux avec gitosis.
Pour éliminer la possibilité de foirer le maître, nous l'avons simplement supprimé. Au lieu de cela, nous préparons toutes les versions en fusionnant les branches sélectionnées pour tester et étiqueter la fusion. S'il réussit les tests, le commit est étiqueté avec une version et mis en production.
Pour gérer cela, nous avons un rôle tournant de gestionnaire de versions. Le gestionnaire de versions est responsable de l'examen de chaque branche avant qu'elle ne soit prête pour le test. Ensuite, lorsque le propriétaire du produit décide qu'il est temps de regrouper les branches approuvées pour une nouvelle version de test, le gestionnaire de versions effectue la fusion.
Nous avons également un rôle tournant de helpdesk de niveau 2 et au moins pour nous, la charge de travail est telle qu'il est possible d'avoir les deux rôles en même temps.
Comme l'avantage de ne pas avoir de maître, il n'est pas possible d'ajouter du code au projet sans passer par le gestionnaire de versions, nous avons donc découvert directement la quantité de code qui a été ajoutée silencieusement au projet auparavant.
Le processus de révision commence avec le propriétaire de la branche soumettant le diff au tableau de révision et en mettant un post-it vert sur le tableau blanc avec le nom de la branche (nous avons un flux de travail basé sur Kanban) sous "pour révision", ou s'il fait partie d'un utilisateur complet histoire, déplacez la carte histoire entière à "pour révision" et mettez le postit là-dessus. Le gestionnaire de relocalisation est celui qui déplace les cartes et les publie sur "prêt pour le test", puis le propriétaire du produit peut sélectionner celles à inclure dans la prochaine version de test.
Lors de la fusion, le gestionnaire de versions s'assure également que la validation de la fusion contient un message de validation sensible qui peut être utilisé dans le journal des modifications pour le propriétaire du produit.
Lorsqu'une version a été mise en production, la balise est utilisée comme nouvelle base pour les branches et toutes les branches existantes sont fusionnées avec elle. De cette façon, toutes les branches ont un parent commun, ce qui facilite la gestion des fusions.
En ce qui concerne les points 3 et 4 (autorisations par utilisateur, par section, par branche), jetez un œil à gitolite (couvert dans le livre Pro Git: http: // progit. org/book/ch4-8.html ).
Politique ou pas, Git est un aussi bon choix de DCVS que n'importe quel autre. Comme tout outil puissant, il vaut la peine de passer un peu de temps à comprendre comment l'outil est conçu pour fonctionner, et, à cette fin, je recommande fortement le livre Pro Git. Quelques heures passées avec lui permettront d'économiser beaucoup de frustration à long terme.
- Installez une interface Web décente, comme Github FI
- Restez fidèle à un modèle relativement centralisé (au départ) pour que les gens soient à l'aise.
- Exécutez une génération d'intégration continue pour chaque branche partagée.
- Partagez un bon ensemble d'options globales de configuration git.
- Intégrez git dans votre shell, avec la complétion de bash, et une invite avec la branche actuelle.
- Essayez l'intégration Git d'IntelliJ comme outil de fusion.
- Assurez-vous que vous .gitignore comme approprié.
J'ajouterai également un article "avez-vous pensé".
L'un des grands avantages de Bazaar est sa flexibilité. C'est là qu'il bat tous les autres systèmes distribués. Vous pouvez utiliser Bazaar en mode centralisé, en mode distribué ou obtenir ceci: les deux (ce qui signifie que les développeurs peuvent choisir le modèle avec lequel ils sont à l'aise ou celui qui fonctionne le mieux pour leur groupe de travail). Vous pouvez également déconnecter un référentiel centralisé lorsque vous êtes en déplacement et le reconnecter à votre retour.
En plus de cela, une excellente documentation et quelque chose qui rendra votre entreprise heureuse: un support commercial disponible.
Afin d'utiliser git efficacement dans une équipe de développement avec beaucoup de développeurs, un système CI qui construit et teste en continu est nécessaire. Jenkins fournit un tel véhicule et je le recommande vivement. La pièce d'intégration doit être faite quoi qu'il arrive et c'est beaucoup moins cher de le faire plus tôt et plus souvent.
GUI: Pour le moment, TortoiseGit v1.7.6 devrait convenir à la plupart des opérations quotidiennes. Log, Commit, Push, Pull, Fetch, Diff, Merge, Branch, Cherry-pick, Rebase, Tag, Export, Stash, Add submodule, etc ... Support x64 nativement aussi
Plus adapté au développement collaboratif que la gitose ou la gitolite mais open-source est Gitorious . C'est une Ruby sur Rails application qui gère la gestion des référentiels et la fusion. Elle devrait résoudre bon nombre de vos problèmes).
Git permet de créer des branches privées. Cela encourage les développeurs à s'engager souvent afin de décomposer les modifications en petits commits. Lorsque le développeur est prêt à publier ses modifications, il envoie au serveur central. Il peut utiliser des scripts de pré-validation pour vérifier son code si nécessaire.
NXP gère Git et Subversion avec une plate-forme commune (à l'échelle de l'entreprise), intégrant Android développement mobile avec des projets logiciels traditionnels: http://www.youtube.com/watch ? v = QX5wn0igv7Q