Que signifie «construction automatisée»?

J'essaie d'ajouter l'intégration continue à un projet.

Selon Wikipédia , les builds automatisés constituent un élément majeur de CI. Cependant, je suis confus sur ce que cela signifie exactement, car les articles CI et build automation semblent en désaccord.

Points de confusion spécifiques: que signifie «construction automatisée» dans le contexte de:

• un projet utilisant un langage interprété, comme Python ou Perl?
• construire à partir de la source sur la machine d'un utilisateur final?
• une application qui a des dépendances qui ne peuvent pas être simplement précompilées et distribuées, comme une base de données dans un SGBDR local sur la machine de l'utilisateur?

Vous avez raison de noter que, pour certaines technologies, une étape de compilation n'est pas nécessaire. Cependant, je vous recommande de prendre une vue plus large lors de l'interprétation du terme "build automation". Pensez à «construire» comme comprenant les deux principaux composants suivants:

• Processus de transformation des artefacts source (code, schéma de base de données, documentation, etc.) déployé auprès d'un utilisateur final.
• L'application de mesures d'assurance qualité lors de ladite transformation

L'automatisation fait donc simplement référence à l'automatisation de toutes ces opérations, sinon toutes, (c'est-à-dire qu'elles ne nécessitent pas d'intervention manuelle). Cela peut comprendre une variété d'étapes, selon votre technologie:

Étapes de transformation:

• Compilation
• Mise en relation
• Emballage
• Déploiement
• Migration de données
• Sauvegarde
• Notification

Étapes d'assurance qualité:

• Avertissements / erreurs du compilateur
• Tests unitaires
• Tests d'intégration
• Tests système
• Authentification de déploiement

De nos jours, de bons outils CI vous permettront de répondre à toutes ces préoccupations. Initialement, la plupart des magasins souhaitent automatiser la compilation de leur code, car c'est la première - et la plus visible - source de problèmes dans le développement de logiciels conventionnels.

Une génération automatisée est une description d'un processus qui doit couvrir les bases suivantes:

1. Récupérer le dernier code à partir du contrôle de code source
2. Compilez le dernier code dans l'exécutable
3. Exécuter des tests (tests unitaires, tests système, tests d'intégration) sur du code compilé
4. Déployez l'exécutable terminé vers un emplacement connu pour le déploiement.
5. Publiez les résultats de la génération.
   5.1 Compilation réussie, succès du test unitaire

Il s'agit d'un processus interactif qui doit s'exécuter sans aucune intervention manuelle.

À mon avis, une construction automatisée est quelque chose qui

• se produit automatiquement, soit selon un calendrier ou à chaque validation du contrôle de code source
• crée un ensemble d'artefacts qui peuvent être déployés simplement sur n'importe quel serveur

L'objectif est d'avoir un processus de déploiement qui peut être répété - lire: testé - afin qu'au moment où vous déployez en production, vous ayez une certaine certitude que les choses ne vont pas mal se passer. Moins il y aura d'interaction humaine dans les processus de génération et de déploiement, plus votre version sera sûre.

Si vous avez une langue non compilée, vous pouvez toujours créer un site et le compresser pour créer un seul artefact.

Un bon outil CI vous permettra de scripter de nombreuses tâches dans le processus de construction, y compris l'exécution de tests unitaires. Il conservera également les enregistrements de vos builds réussis et infructueux, la couverture des tests, etc. Mais rien de tout cela ne fait partie de ce que je définirais comme une build automatisée. (c.-à-d. un bon processus de construction automatisé a ces choses, mais un mauvais ne manque pas d'être appelé "construction automatisée" car il manque ces choses.)

Je suggère que les tests d'intégration / de régression soient exécutés dans le cadre du processus de déploiement, plutôt que du processus de génération (bien que, si vous disposez d'un environnement pratique, vous pouvez déployer avec chaque génération).

a project using an interpreted language, such as Python or Perl?

Dans le cas des langues interprétées, les choses peuvent être heurtées ou manquées. Certaines langues interpénétrées ont des compilateurs, mais le plus souvent, il n'est probablement pas vraiment nécessaire de les utiliser. Dans ce cas, je balaye généralement le code pour les erreurs de syntaxe et d'analyse à la place de la compilation ou passe directement à l'exécution des tests sur le code.

construire à partir de la source sur la machine d'un utilisateur final?

Pour moi, cela signifie que vous pouvez fournir une seule commande que les utilisateurs finaux peuvent exécuter pour obtenir la dernière version du programme, la compiler, la configurer et la déployer au besoin.

une application qui a des dépendances qui ne peuvent pas être simplement précompilées et distribuées, comme une base de données dans un SGBDR local sur la machine de l'utilisateur?

Ceux-ci relèveraient de la partie test de l'intégration continue car vous pouvez automatiquement détruire et reconstruire les bases de données pour vous assurer que les scripts sont corrects et que le programme les teste correctement.

Ce que vous discutez dans votre question sont en fait 3 concepts différents:

L'intégration continue dans son cœur consiste à apporter de petits changements et à synchroniser fréquemment ces changements avec la «vérité globale». Au lieu de faire une extraction et de la conserver pendant une semaine, un développeur devrait travailler sur des tâches qui peuvent être terminées en une journée afin que son code ne soit jamais trop éloigné de la synchronisation avec le référentiel principal.

Pour y parvenir sans causer de douleur à son équipe (c'est-à-dire archiver une source qui ne construit pas ou ne casse pas les fonctionnalités existantes). Le développeur doit vérifier que son code ne "casse pas la construction". Si cela est fait manuellement, cela ajoute une surcharge supplémentaire au processus de développement (pensez à un projet qui prend beaucoup de temps à construire et / ou qui a de nombreuses interdépendances où une modification d'une ligne de code peut avoir un impact inattendu sur l'application).

Pour atténuer cette situation, nous utilisons d'autres techniques pour supprimer cette surcharge.

Nous utilisons des versions automatisées pour extraire la source et la générer en exécutant éventuellement des tests automatisés qui vérifient que l'application fonctionne comme il se doit (cette étape n'est aussi utile que la suite de tests).

Une étape supplémentaire de livraison continue résout votre problème avec la base de données et d'autres problèmes. L'idée ici est de fournir un certain niveau de versioning pour la base de données et d'autres facteurs de l'environnement afin que nous puissions confirmer le plus rapidement possible que l'application fonctionne dans un environnement aussi proche de la production que possible .

«Construction automatisée» signifie que vous pouvez passer du contrôle de code source à un package livrable avec une seule action (programmable) (généralement un script shell ou un fichier batch).

Dans ce contexte, ce qui constitue exactement une construction dépend beaucoup de ce que vous expédiez exactement, de la façon dont elle est livrée et des étapes requises pour les différentes parties de votre pile de développement, mais dans tous les cas, vous commencez par ce qui est dans le contrôle des sources, et vous vous retrouvez avec un produit livrable (ou un message d'erreur et un chef de projet en colère).

Pour un projet Python simple, une construction automatisée peut consister en seulement deux étapes - vérifier les sources et copier les fichiers pertinents dans les répertoires appropriés. Pour des projets plus complexes, cela peut impliquer des choses comme:

• compilation, liaison
• exécution de tests automatisés
• création de packages d'installation
• installation
• modification des bases de données
• créer des sauvegardes (au cas où vous auriez besoin de revenir en arrière)