Gestion de plusieurs succursales en intégration continue

J'ai été confronté au problème de la mise à l'échelle de l'IC dans mon entreprise et en même temps, j'ai essayé de déterminer quelle approche adopter en ce qui concerne l'IC et les branches multiples. Il y a une question similaire à stackoverflow, plusieurs branches de fonctionnalités et intégration continue . J'en ai commencé un nouveau parce que j'aimerais avoir plus de discussion et fournir une analyse dans la question.

Jusqu'à présent, j'ai trouvé qu'il y a 2 approches principales que je peux prendre (ou peut-être quelques autres ???).

• Plusieurs ensembles d'emplois (parler de Jenkins / Hudson ici) par branche
  • Rédiger des outils pour gérer les travaux supplémentaires
    • Créer / modifier / supprimer des jobs en masse
    • Paramètres personnalisés pour chaque travail par branche (URL SCM, duplications des dépôts de gestion des dépôts)
    • Quelques exemples de personnes s'attaquant à ce problème avec les outils shell, les scripts ant et la CLI Jenkins. Voir:
      1. http://jenkins.361315.n4.nabble.com/Multiple-branches-best-practice-td2306578.html
      2. http://jenkins.361315.n4.nabble.com/Is-it-possible-to-handle-multiple-branches-where-some-jobs-should-run-on-each-one-without-duplicatin-td954729. html
      3. http://jenkins.361315.n4.nabble.com/Parallel-development-with-branches-td1013013.html
      4. Configurer ou créer automatiquement une tâche Hudson
  • Causera plus de charge sur votre cluster CI
  • Le cycle de rétroaction pour les développeurs ralentit (si l'infrastructure ne peut pas gérer la nouvelle charge)
• Plusieurs ensembles de travaux par 2 branches (développement et stabilité)
  • Gérez les deux ensembles manuellement (si vous changez la conf d'un job alors assurez-vous de changer dans l'autre branche)
    • PITA mais au moins si peu à gérer
  • Les autres branches supplémentaires ne recevront pas de suite de tests complète avant d'être poussées vers le développement
  • Développeurs insatisfaits. Pourquoi un développeur devrait-il se soucier des problèmes de mise à l'échelle CI? Il a une simple demande, quand je branche je voudrais tester mon code. Facile.

Donc, il semble que si je veux fournir aux développeurs des CI pour leurs propres branches personnalisées, j'ai besoin d'outils spéciaux pour Jenkins (API ou shellscripts ou quelque chose?) Et gérer la mise à l'échelle. Ou je peux leur dire de fusionner plus souvent avec DEV et de vivre sans CI sur des branches personnalisées. Laquelle choisiriez-vous ou y a-t-il d'autres options?

Lorsque vous parlez de mise à l'échelle de CI, vous parlez vraiment de mise à l'échelle de l'utilisation de votre serveur CI pour gérer toutes vos branches de fonctionnalités avec votre ligne principale. Au départ, cela semble être une bonne approche, car les développeurs d'une branche bénéficient de tous les avantages des tests automatisés inclus dans les travaux CI. Cependant, vous rencontrez des problèmes de gestion des travaux du serveur CI (comme vous l'avez découvert) et, plus important encore, vous ne faites pas vraiment CI. Oui, vous utilisez un serveur CI, mais vous n'intégrez pas en permanence le code de tous vos développeurs.

L'exécution d'un véritable CI signifie que tous vos développeurs s'engagent régulièrement sur la ligne principale. Facile à dire, mais le plus dur est de le faire sans casser votre application. Je vous recommande vivement de consulter la livraison continue , en particulier la section Garder votre application libérable dans le Chapitre 13: Gestion des composants et des dépendances . Les principaux points sont:

• Masquez la nouvelle fonctionnalité jusqu'à ce qu'elle soit terminée ( bascule de fonctionnalité AKA ).
• Effectuez toutes les modifications de manière incrémentielle sous la forme d'une série de petits changements, dont chacun est libérable.
• Utilisez la branche par abstraction pour apporter des modifications à grande échelle à la base de code.
• Utilisez des composants pour découpler les parties de votre application qui changent à des rythmes différents.

Ils sont assez explicites, sauf branche par abstraction. Ceci est juste un terme sophistiqué pour:

1. Créez une abstraction sur la partie du système que vous devez modifier.
2. Refactorisez le reste du système pour utiliser la couche d'abstraction.
3. Créez une nouvelle implémentation, qui ne fait pas partie du chemin du code de production tant qu'elle n'est pas terminée.
4. Mettez à jour votre couche d'abstraction pour déléguer à votre nouvelle implémentation.
5. Supprimez l'ancienne implémentation.
6. Supprimez la couche d'abstraction si elle n'est plus appropriée.

Le paragraphe suivant de la section Branches, flux et intégration continue du chapitre 14: Contrôle de version avancé résume les impacts.

L'approche incrémentale nécessite certainement plus de discipline et de soin - et en fait plus de créativité - que de créer une branche et de plonger dans la refonte de l'architecture et le développement de nouvelles fonctionnalités. Mais cela réduit considérablement le risque que vos modifications interrompent l'application et vous fera gagner, à vous et à votre équipe, beaucoup de temps pour fusionner, corriger les ruptures et mettre votre application dans un état déployable.

Il faut un certain changement d'esprit pour abandonner les branches de fonctionnalités et vous obtiendrez toujours une résistance. D'après mon expérience, cette résistance est basée sur le fait que les développeurs ne se sentent pas en sécurité lors de la validation du code sur la ligne principale et c'est une préoccupation raisonnable. Cela découle généralement d'un manque de connaissances, de confiance ou d'expérience avec les techniques énumérées ci-dessus et peut-être du manque de confiance avec vos tests automatisés. Le premier peut être résolu grâce à la formation et au support des développeurs. Ce dernier est un problème beaucoup plus difficile à traiter, mais le branchement ne fournit aucune sécurité supplémentaire, il reporte simplement le problème jusqu'à ce que les développeurs se sentent suffisamment en confiance avec leur code.

Je mettrais en place des emplois distincts pour chaque branche. Je l'ai déjà fait et ce n'est pas difficile à gérer et à configurer si vous avez correctement configuré Hudson / Jenkins. Un moyen rapide de créer plusieurs travaux consiste à copier à partir d'un travail existant qui a des exigences similaires et à les modifier si nécessaire. Je ne sais pas si vous voulez permettre à chaque développeur de configurer ses propres travaux pour ses propres branches, mais ce n'est pas beaucoup de travail pour une seule personne (c'est-à-dire un gestionnaire de build) à gérer. Une fois que les branches personnalisées ont été fusionnées en branches stables, les travaux correspondants peuvent être supprimés lorsqu'ils ne sont plus nécessaires.

Si vous vous inquiétez de la charge sur le serveur CI, vous pouvez configurer des instances distinctes du CI ou même des esclaves séparés pour aider à équilibrer la charge sur plusieurs serveurs. Assurez-vous que le serveur sur lequel vous exécutez Hudson / Jenkins est adéquat. J'ai utilisé Apache Tomcat et je devais simplement m'assurer qu'il disposait de suffisamment de mémoire et de puissance de traitement pour traiter la file d'attente de construction.

Il est important d'être clair sur ce que vous voulez réaliser en utilisant CI, puis de trouver un moyen de l'implémenter sans trop d'efforts manuels ni de duplication. Il n'y a rien de mal à utiliser d'autres outils ou scripts externes exécutés par votre serveur CI qui aident à simplifier votre processus global de gestion de build.

Je choisirais dev + branches stables. Et si vous voulez toujours des branches personnalisées et que vous avez peur de la charge, alors pourquoi ne pas les déplacer vers le cloud et laisser les développeurs les gérer eux-mêmes, par exemple http://cloudbees.com/dev.cb C'est la société où se trouve actuellement Kohsuke . Il existe également un outil Eclipse, donc si vous êtes sur Eclipse, vous l'aurez étroitement intégré directement dans l'environnement de développement.

En fait, ce qui est vraiment problématique, c'est de créer une isolation avec des branches de fonctionnalités. Dans notre entreprise, nous avons un ensemble de projets Maven séparés qui font tous partie d'une plus grande distribution. Ces projets sont gérés par différentes équipes, mais pour chaque distribution, tous les projets doivent être publiés. Un featurebranch peut maintenant se chevaucher d'un projet à un autre et c'est à ce moment que l'isolement de la construction devient douloureux. Nous avons essayé plusieurs solutions:

• créer des référentiels d'instantanés distincts dans nexus pour chaque branche de fonctionnalité
• partager des référentiels locaux sur des esclaves dédiés
• utiliser le plugin repository-server-plugin avec les référentiels en amont
• tout construire dans un seul travail avec un référentiel privé

En fait, la dernière solution est la plus prometteuse. Toutes les autres solutions manquent d'une manière ou d'une autre. Avec le plugin job-dsl, il est facile de configurer une nouvelle branche de fonctionnalités. Copiez et collez simplement le script groovy, adaptez les branches et laissez le job d'amorçage créer les nouveaux jobs. Assurez-vous que le travail d'amorçage supprime les travaux non gérés. Ensuite, vous pouvez facilement évoluer avec des branches de fonctionnalités sur différents projets maven.

Mais comme Tom l'a bien dit ci-dessus, il serait plus agréable de surmonter la nécessité des branches de fonctionnalités et d'apprendre aux développeurs à s'intégrer proprement, mais c'est un processus plus long et le résultat n'est pas clair avec de nombreuses parties du système héritées que vous ne toucherez plus.

mes 2 cents