Quel est l'intérêt d'un «Build Server»? [fermé]

Je n'ai pas travaillé pour de très grandes organisations et je n'ai jamais travaillé pour une entreprise qui avait un "Build Server".

Quel est leur but? Pourquoi les développeurs ne construisent-ils pas le projet sur leurs machines locales, ou le sont-ils? Certains projets sont-ils si grands que des machines plus puissantes sont nécessaires pour les construire dans un délai raisonnable?

Le seul endroit où je vois un serveur de construction utile est pour une intégration continue avec le serveur de construction en construisant constamment ce qui est engagé dans le référentiel. Est-ce que je n'ai tout simplement pas travaillé sur des projets assez grands?

Quelqu'un, s'il vous plaît, éclairez-moi: Quel est le but d'un serveur de build?

La raison invoquée est en fait un énorme avantage. Les builds qui vont au QA ne devraient jamais provenir d'un système qui se construit uniquement à partir du référentiel. De cette façon, les packages de construction sont reproductibles et traçables. Les développeurs qui construisent manuellement du code pour tout sauf leurs propres tests sont dangereux. Trop de risques que les choses ne soient pas enregistrées, ne soient pas à jour avec les changements d'autres personnes, etc. etc.

Joel Spolsky à ce sujet.

Les serveurs de construction sont importants pour plusieurs raisons.

• Ils isolent l'environnement Le développeur local de Code Monkey dit "Il se compile sur ma machine" lorsqu'il ne se compile pas sur le vôtre. Cela peut signifier des archivages désynchronisés ou une bibliothèque dépendante manquante. L'enfer Jar n'est pas aussi mauvais que l'enfer .dll; Dans tous les cas, l'utilisation d'un serveur de build est une assurance bon marché que vos builds n'échoueront pas mystérieusement ou n'emballeront pas les mauvaises bibliothèques par erreur.

• Ils concentrent les tâches associées aux builds. Cela inclut la mise à jour de la balise de construction, la création de tout emballage de distribution, l'exécution de tests automatisés, la création et la distribution de rapports de construction. L'automatisation est la clé.

• Ils coordonnent le développement (distribué). Le cas standard est celui où plusieurs développeurs travaillent sur la même base de code. Le système de contrôle de version est au cœur de ce type de développement distribué, mais selon l'outil, les développeurs peuvent ne pas interagir beaucoup avec le code de l'autre. Au lieu de forcer les développeurs à risquer de mauvaises builds ou à s'inquiéter de la fusion du code de manière trop agressive, concevez le processus de build où la build automatisée peut voir le code approprié et traiter les artefacts de build de manière prévisible. De cette façon, lorsqu'un développeur commet quelque chose avec un problème, comme ne pas archiver une nouvelle dépendance de fichier, il peut être averti rapidement. Faire cela dans une zone intermédiaire vous permet de marquer le code qui a été construit afin que les développeurs ne tirent pas de code qui briserait leur version locale. PVCS a très bien fait cela en utilisant l'idée de groupes de promotion. Clearcase pourrait le faire aussi en utilisant des étiquettes, mais nécessiterait plus d'administration de processus que beaucoup de magasins ne se soucient de fournir.

Quel est leur but?
Prenez en charge les machines de développement, fournissez un environnement stable et reproductible pour les builds.

Pourquoi les développeurs ne construisent-ils pas le projet sur leurs machines locales, ou le sont-ils?
Parce qu'avec des logiciels complexes, étonnamment, beaucoup de choses peuvent mal tourner quand on "compile". problèmes que j'ai réellement rencontrés:

• vérifications de dépendances incomplètes de différents types, entraînant la non mise à jour des binaires.
• Les commandes de publication échouent silencieusement, le message d'erreur dans le journal est ignoré.
• Construire en incluant des sources locales pas encore engagées dans le contrôle de code source (heureusement, pas encore de boîtes de message "foutus clients" ..).
• Lorsque vous essayez d'éviter le problème ci-dessus en construisant à partir d'un autre dossier, certains fichiers sont sélectionnés dans le mauvais dossier.
• Le dossier cible dans lequel les binaires sont agrégés contient des fichiers de développeur obsolètes supplémentaires qui ne devraient pas être inclus dans la version

Nous avons une augmentation incroyable de la stabilité puisque toutes les versions publiques commencent par un transfert du contrôle de source vers un dossier vide. Avant, il y avait beaucoup de "problèmes amusants" qui "ont disparu quand Joe m'a donné une nouvelle DLL".

Certains projets sont-ils si grands que des machines plus puissantes sont nécessaires pour les construire dans un délai raisonnable?

Qu'est-ce que «raisonnable»? Si j'exécute une compilation par lots sur ma machine locale, il y a beaucoup de choses que je ne peux pas faire. Plutôt que de payer les développeurs pour les builds à terminer, payez déjà le service informatique pour acheter une véritable machine de build.

Est-ce que je n'ai tout simplement pas travaillé sur des projets assez grands?

La taille est certainement un facteur, mais pas le seul.

Un serveur de build est un concept distinct d'un serveur d'intégration continue. Le serveur CI existe pour créer vos projets lorsque des modifications sont apportées. En revanche, un serveur de génération existe pour générer le projet (généralement une version, par rapport à une révision balisée) sur un environnement propre. Cela garantit qu'aucun piratage, modification, version de configuration / d'artefact non approuvée ou code non validé ne sera intégré au code publié.

Le serveur de construction est utilisé pour construire le code de tout le monde lorsqu'il est archivé. Votre code peut être compilé localement, mais vous n'aurez probablement pas toutes les modifications apportées par tout le monde tout le temps.

Pour ajouter ce qui a déjà été dit:

Un ancien collègue a travaillé dans l'équipe Microsoft Office et m'a dit qu'une compilation complète prenait parfois 9 heures. Ce serait nul de le faire sur VOTRE machine, n'est-ce pas?

Il est nécessaire d'avoir un environnement "propre" exempt d'artefacts des versions précédentes (et de modifications de configuration) afin de garantir que les builds et les tests fonctionnent et ne dépendent pas des artefacts. Un moyen efficace d'isoler consiste à créer un serveur de génération distinct.

Je suis d'accord avec les réponses jusqu'à présent en ce qui concerne la stabilité, la traçabilité et la reproductibilité. (Beaucoup de 'ity's, non?). Ayant UNIQUEMENT travaillé pour de grandes entreprises (Santé, Finance) avec BEAUCOUP de serveurs de build, j'ajouterais que c'est aussi une question de sécurité. Avez-vous déjà vu le film Office Space? Si un développeur mécontent construit une application bancaire sur sa machine locale et que personne d'autre ne la regarde ou ne la teste ... BOOM. Superman III.

Ces machines sont utilisées pour plusieurs raisons, toutes essayant de vous aider à fournir un produit de qualité supérieure.

Une utilisation consiste à simuler une configuration typique de l'utilisateur final. Le produit peut fonctionner sur votre ordinateur, avec tous vos outils de développement et bibliothèques configurés, mais l'utilisateur final n'aura probablement pas la même configuration que vous. D'ailleurs, les autres développeurs n'auront pas non plus exactement la même configuration que vous. Si vous avez un chemin d'accès codé en dur quelque part dans votre code, cela fonctionnera probablement sur votre machine, mais lorsque Dev El O'per essaiera de créer le même code, cela ne fonctionnera pas.

Ils peuvent également être utilisés pour surveiller qui a cassé le produit en dernier, avec quelle mise à jour et où le produit a régressé. Chaque fois qu'un nouveau code est archivé, le serveur de build le construit, et s'il échoue, il est clair que quelque chose ne va pas et que l'utilisateur qui a commis le dernier est en faute.

Pour une qualité cohérente et pour obtenir la construction «hors de votre machine» pour repérer les erreurs d'environnement et pour que tous les fichiers que vous oubliez d'archiver dans le contrôle de code source apparaissent également comme des erreurs de construction.

Je l'utilise également pour créer des installateurs car ceux-ci prennent beaucoup de temps à faire sur le bureau avec la signature de code, etc.

Nous en utilisons un pour savoir que les boîtes de production / test ont les mêmes bibliothèques et versions de ces bibliothèques installées que ce qui est disponible sur le serveur de construction.

C'est une question de gestion et de test pour nous. Avec un serveur de build, nous savons toujours que nous pouvons construire notre ligne principale "trunk" à partir du contrôle de version. Nous pouvons créer une installation principale en un seul clic et la publier sur le Web. Nous pouvons exécuter tous nos tests unitaires à chaque enregistrement du code temporel pour nous assurer qu'il fonctionne. En rassemblant toutes ces tâches dans une seule machine, il est plus facile de bien faire les choses à plusieurs reprises.

Vous avez raison de dire que les développeurs peuvent construire sur leurs propres machines.

Mais voici quelques-unes des choses que notre serveur de build nous achète, et nous ne sommes guère des fabricants de build sophistiqués:

• Problèmes de contrôle de version (certains ont été mentionnés dans les réponses précédentes)
• Efficacité. Les développeurs n'ont pas à s'arrêter pour créer des builds localement. Ils peuvent le lancer sur le serveur et passer à la tâche suivante. Si les builds sont volumineux, c'est encore plus de temps que la machine du développeur n'est pas occupée. Pour ceux qui font une intégration continue et des tests automatisés, c'est encore mieux.
• Centralisation. Notre machine de construction a des scripts qui font la construction, la distribuent aux environnements UAT et même à la mise en production. Les garder au même endroit réduit les tracas liés à leur synchronisation.
• Sécurité. Nous ne faisons pas grand-chose de spécial ici, mais je suis sûr qu'un administrateur système peut faire en sorte que les outils de migration de production ne soient accessibles que sur un serveur de construction par certaines entités autorisées.

Peut-être que je suis le seul ...

Je pense que tout le monde convient qu'il faut

• utiliser un référentiel de fichiers
• faire des compilations à partir du référentiel (et dans un environnement propre)
• utilisez un serveur de test continu (par exemple, le régulateur de vitesse) pour voir si quelque chose est cassé après vos «corrections»

Mais personne ne se soucie des versions construites automatiquement. Quand quelque chose a été cassé dans une construction automatique, mais ce n'est plus maintenant - qui s'en soucie? C'est un travail en cours. Quelqu'un l'a réparé.

Lorsque vous souhaitez créer une version commerciale, vous exécutez une compilation à partir du référentiel. Et je suis à peu près sûr que vous voulez marquer la version dans le référentiel à ce moment - là et non toutes les six heures lorsque le serveur fonctionne.

Donc, peut-être qu'un "serveur de construction" est juste un abus de langage et qu'il s'agit en fait d'un "serveur de test continu". Sinon, cela semble pratiquement inutile.

Un serveur de build vous donne une sorte de deuxième avis sur votre code. Lorsque vous l'enregistrez, le code est vérifié. Si cela fonctionne, le code a une qualité minimale.

De plus, rappelez-vous que les langages de bas niveau prennent beaucoup plus de temps à compiler que les langages de haut niveau. Il est facile de penser: "Eh bien, mon projet .Net se compile en quelques secondes! Quel est le problème?" Il y a quelque temps, j'ai dû jouer avec du code C et j'avais oublié combien de temps il fallait pour compiler.

Un serveur de build est utilisé pour planifier des tâches de compilation (par exemple, des builds nocturnes) de projets généralement volumineux situés dans un référentiel qui peuvent parfois prendre plus de quelques heures.

Un serveur de build vous donne également une base pour l'entiercement, étant capable de capturer toutes les parties nécessaires pour reproduire une build dans le cas où d'autres pourraient avoir le droit d'en prendre possession.