La gestion de version est une pratique phare du DevOps, indispensable pour la livraison continue, la collaboration sur le code et la qualité du logiciel. Découvrez tout ce que vous devez savoir !
Comment les développeurs de logiciels peuvent-ils collaborer sur un même projet simultanément, sans pour autant créer de bugs et de conflits dans le code source ?
Afin d’éviter ces problèmes, ils utilisent une pratique aussi ancienne que l’informatique : la gestion de version.
Qu’est-ce que la gestion de version ?
La gestion de version ou « version control » est le processus de suivi des modifications apportées au code source d’un projet.
Il peut s’agir d’un ajout de fonctionnalités, d’une correction de bugs ou même d’une refonte complète du code. Dans tous les cas, la gestion de version permet de garder une trace de chaque changement, de qui l’a effectuée et à quelle date.
Chaque modification est enregistrée sous forme de « commit », accompagné d’un message décrivant les changements apportés.
Par la suite, les différents commits doivent être organisés en une chronologie cohérente. Celle-ci permet de comprendre et de retracer l’évolution du code source.
A quoi ça sert de faire de la gestion de version ?
Tout d’abord, la gestion de version aide les développeurs à mieux contrôler les modifications apportées au code source en fournissant un historique détaillé de chaque modification.
Ceci permet de revenir en arrière pour corriger les bugs ou les erreurs introduits dans le code. Une version antérieure stable peut être restaurée très facilement.
En plus d’offrir un suivi, cet historique permet l’auditabilité et peut s’avérer d’un précieux secours en cas de problème de conformité ou de responsabilité juridique.
Cette pratique favorise aussi la collaboration sur un même projet. Elle permet de résoudre les conflits de code source, et facilite la communication entre les membres d’une équipe.
Un développeur peut travailler une branche séparée sans interférer sur celles des autres. Par la suite, ils peuvent fusionner leurs codes.
Comment fonctionne la gestion de version ?
Pour utiliser la gestion de version dans un projet, les développeurs doivent suivre plusieurs étapes clés. D’abord, le projet doit être initié dès le départ avec un système de gestion de version.
Les équipes doivent créer des branches pour chaque modification à apporter, qu’il s’agisse d’une nouvelle fonctionnalité ou d’une correction de bugs.
Les changements effectués doivent être enregistrés sous forme de commits, avec des messages clairs de description.
Afin de maintenir une chronologie cohérente du code source, les différentes branches doivent être fusionnées régulièrement. De plus, les développeurs doivent régulièrement synchroniser leur copie locale du code source avec le serveur central.
A l’aide des « pull requests », les développeurs peuvent proposer des changements à la branche principale. Les autres membres de l’équipe peuvent examiner ces modifications et les approuver ou les refuser.
Cette évaluation du code ou « code review » du code source d’un autre développeur permet de s’assurer qu’il soit de haute qualité et respecte les bonnes pratiques.
Pour profiter pleinement des avantages de la gestion de version, les équipes doivent s’assurer que leurs messages de commit soient clairs et concis.
Il est également important d’éviter de commettre du code qui ne se compile pas, ou qui n’a pas été testé. Par ailleurs, les branches doivent être nommées de manière cohérente et les développeurs doivent s’assurer qu’ils travaillent sur la branche appropriée.
L’histoire de la gestion de version
Aux débuts de l’informatique, les programmes étaient écrits sur des cartes perforées et stockées dans des tiroirs. La gestion de version se faisait donc manuellement, avec des registres tenus par les développeurs pour suivre les modifications du code source.
Au fil du temps, les techniques de développement ont évolué avec l’apparition des cassettes, des disques, puis des ordinateurs personnels et des réseaux de serveur. Les outils de gestion de version ont également évolué pour s’adapter aux nouveaux besoins.
En 1972, le logiciel SCCS (Source Code Control System) a été créé pour gérer les versions du code source sur les systèmes Unix. Il s’agit du premier outil à permettre un contrôle de version automatique. Il était basé sur un système de fichiers spécialisé et exigeait leur verrouillage pendant l’édition.
Dix ans plus tard, en 1982, le système RCS (Revision Control System) a vu le jour. Il était plus souple puisqu’il permettait l’édition de fichiers en simultané. Un système de diff a aussi été introduit pour le suivi des modifications entre les versions.
Par la suite, en 1990, CVS (Concurrent Version System) a été créé pour remplacer RCS. Ce nouveau système a introduit la notion de branches de développement permettant de travailler sur différentes versions du code source, et la possibilité de les fusionner.
Le système Subversion (SVN) fut lancé en l’an 2000 pour succéder à CVS. Il a amélioré la gestion des branches et des tags, afin d’offrir plus d’efficacité et de flexibilité. Des options comme la copie et la gestion de fichiers binaires ont aussi été ajoutées.
Au fil des années, de nombreux autres outils de gestion de version ont été créés tels que Git, Mercurial, Perforce et Bitbucket…
Les outils de gestion de version
On distingue deux types de gestion de version : centralisée et distribuée. Dans un système centralisé, toutes les modifications sont enregistrées sur un serveur central : le référentiel.
Les développeurs travaillent sur des copies locales du code source et soumettent leurs modifications au référentiel. En guise d’exemples, on peut citer CVS, SVN et Perforce.
D’ailleurs, SVN est l’un des plus anciens systèmes de gestion de versions centralisés. Il est encore très utilisé aujourd’hui, et doit notamment son succès à sa simplicité d’utilisation et à sa facilité d’apprentissage.
Cette catégorie de systèmes permet une gestion centralisée du code source, une interface utilisateur plus simple et des fonctionnalités de contrôle d’accès plus avancées.
Au contraire, sur un système distribué, chaque développeur dispose de sa propre copie du code source contenant l'historique complet des modifications.
Il peut travailler sans être connecté à internet, et les modifications sont ensuite synchronisées avec le serveur central et avec les autres développeurs. La fusion des branches permet une mise en commun.
Ces outils offrent une flexibilité accrue, une gestion simplifiée et une meilleure résilience en cas de défaillance.
L’un des plus populaires est Git : un système distribué utilisé par de nombreuses entreprises et projets open source, notamment Linux. Il est réputé pour sa rapidité et sa flexibilité.
Un autre système distribué est Mercurial, à la fois simple et rapide. Il est utilisé par de nombreux projets open source dont Mozilla Firefox.
Les workflows de gestion de version
Les développeurs peuvent exploiter différents workflows pour la gestion de version. Par exemple, Gitflow est une approche populaire.
Elle utilise deux branches principales : la branche master, contenant la version stable du code, et la branche develop, regroupant les changements en cours de développement.
Les fonctionnalités sont développées sur des branches dédiées qui sont ensuite fusionnées avec la branche develop lorsqu’elles sont terminées.
Un autre exemple est le Trunk-Based Development. Il utilise une seule branche principale, appelée la branche trunk.
Toutes les fonctionnalités et corrections de bugs sont développées directement dessus. Les développeurs utilisent des techniques comme les features toggles pour cacher les fonctionnalités en cours de développement aux utilisateurs.
De son côté, le Feature Branching consiste à développer de nouvelles fonctionnalités sur des branches séparées pour ensuite les fusionner avec la branche principale quand elles sont terminées.
Gestion de version et DevOps
La gestion de version fait partie intégrante de la culture DevOps. Elle est indispensable pour l’intégration, la livraison et la mise en production continue : des pratiques au cœur de cette méthodologie.
L’intégration continue consiste à intégrer le code dans une base de code commune à chaque fois qu’un développeur a terminé une tâche, et la livraison continue vise à livrer régulièrement des mises à jour de logiciels à une application ou un système.
Cette approche requiert donc une gestion de version efficace pour travailler simultanément sur la même base de code et fusionner les branches, examiner les commits des autres membres de l’équipe et pour garder une trace de chaque modification apportée au code.
Conclusion : la gestion de version, moteur du CI/CD
Indispensable pour la collaboration sur un code source et le suivi des modifications, la gestion de version est essentielle au CI/CD et constitue donc l’une des pratiques incontournables du DevOps.
Afin d’apprendre à maîtriser les systèmes comme Git et GitHub, mais aussi tous les meilleurs outils et techniques DevOps, vous pouvez choisir DevUniversity.
Notre formation à distance vous permet d’acquérir toutes les compétences nécessaires pour exercer le métier d’ingénieur DevOps. Découvrez dès maintenant le programme DevUniversity !
Vous savez tout sur la gestion de version. Pour plus d’informations sur le même sujet, découvrez notre dossier complet sur le CI/CD.
