Aller au contenu
Encyclopédie informatique Édition 2026

La gestion de versions et Git

« rapport_v2.docx », « rapport_final.docx », « rapport_final_OK.docx » : chacun a connu ces noms de fichiers qui tentent de garder la trace des versions successives d’un document. Pour le code source, où des dizaines de personnes modifient en même temps des milliers de fichiers, il fallait des outils. Les logiciels de gestion de versions enregistrent chaque modification, son auteur et sa raison, permettent de revenir en arrière et de travailler à plusieurs sans s’écraser. Cet article présente leurs principes à travers CVS, un outil historique, puis Git, devenu la référence, son fonctionnement, les plateformes comme GitHub, et les risques de sécurité, des secrets oubliés dans l’historique aux attaques contre la chaîne de développement.

Rubrique
Développement
Niveau
Débutant à avancé
Lecture
19 min (essentiel)
24 min (complet)
Révision
23 octobre 2026
Niveau de lecture :

En bref

  • Un logiciel de gestion de versions enregistre l’historique des modifications d’un projet : qui a changé quoi, quand et pourquoi ; il permet de revenir en arrière et de travailler à plusieurs.
  • Les outils centralisés, comme CVS (Concurrent Versions System) ou Subversion, reposent sur un serveur unique ; les outils distribués, comme Git, donnent à chacun une copie complète du dépôt et de son historique.
  • Avec Git, on prépare ses modifications, on les enregistre dans un commit, puis on les partage avec un dépôt distant, une copie du projet sur un serveur commun ; les branches permettent de développer en parallèle, puis de fusionner.
  • Des plateformes comme GitHub ou GitLab hébergent les dépôts et organisent la collaboration, notamment la revue de code, la relecture des modifications par d’autres développeurs avant de les intégrer.
  • L’historique n’oublie rien : un mot de passe publié dans un commit reste lisible même après sa suppression ; il faut le révoquer immédiatement.

Prérequis conseillés : Les langages de programmation · Le terminal et le shell

1Définition

La gestion de versions (on dit aussi contrôle de version ou versionnage) consiste à enregistrer l’historique des modifications d’un ensemble de fichiers, le plus souvent le code source d’un logiciel, mais aussi de la documentation, des fichiers de configuration ou des descriptions d’infrastructure (voir l’infrastructure en tant que code). Un logiciel de gestion de versions permet :

  • de savoir, pour chaque ligne, qui l’a modifiée, quand et pourquoi ;
  • de revenir à n’importe quelle version antérieure, ou d’annuler une modification malheureuse ;
  • de faire travailler plusieurs personnes en même temps sur les mêmes fichiers, en détectant et en résolvant les conflits ;
  • de mener en parallèle plusieurs lignes de développement, par exemple une nouvelle fonction et un correctif urgent.

Les gros projets de développement, en particulier les projets libres (on dit aussi open source, « à code source ouvert »), auxquels contribuent des milliers de personnes dans le monde, ne pourraient pas exister sans ces outils (voir le logiciel libre). Aujourd’hui, pratiquement tout le code professionnel est géré ainsi, et la maîtrise de Git fait partie des compétences de base de tout développeur, administrateur ou ingénieur en sécurité.

2Pour mémoire : CVS, un outil historique

2.1Principe

CVS (Concurrent Versions System), créé au milieu des années 1980, fut pendant une quinzaine d’années l’outil de référence des projets libres. C’est un système de contrôle de versions client-serveur : un serveur central conserve les fichiers, et chaque utilisateur s’y connecte avec un logiciel client. Il permet à plusieurs personnes de travailler simultanément sur un même ensemble de fichiers. Comme son nom l’indique, il gère les accès concurrents, c’est-à-dire qu’il détecte les conflits lorsque deux personnes travaillent en même temps sur le même fichier.

Son fonctionnement s’appuie sur une base centralisée, le dépôt (en anglais repository), hébergée sur un serveur, qui contient l’historique de toutes les versions successives de chaque fichier. Pour économiser de la place, le dépôt ne stocke que les différences entre les versions successives, avec la date de chaque modification, le nom de son auteur et un commentaire éventuel, ce qui permet un réel suivi des modifications. Chaque personne travaillant sur le projet dispose d’un répertoire de travail (en anglais working copy ou sandbox, « bac à sable »), qui contient une copie des fichiers du dépôt.

2.2Les opérations

  • checkout : à l’aide d’un client CVS, l’utilisateur récupère une copie de travail du projet, pour modifier des fichiers ou simplement consulter leur dernière version ;
  • commit : lorsqu’il a terminé ses modifications, il les transmet au dépôt. Plusieurs développeurs peuvent ainsi travailler simultanément sur leur copie et transmettre leurs modifications ;
  • update : les modifications des autres ne sont pas répercutées automatiquement sur la copie locale ; il faut donc, avant de modifier un fichier, mettre à jour sa copie de travail, pour limiter les risques de conflit. Si un utilisateur tente de transmettre ses modifications alors qu’un autre a déjà modifié le même fichier, CVS détecte un conflit. Si les modifications portent sur des parties différentes du fichier, CVS peut les fusionner automatiquement, en calculant leurs différences, une opération appelée diff ; sinon, il demande à l’utilisateur de fusionner lui-même. Les fusions ne s’appliquent qu’aux fichiers texte : CVS peut stocker des fichiers binaires, mais il n’a pas été conçu pour cela ;
  • release : quand l’utilisateur a terminé son travail et envoyé toutes ses modifications, il peut vider son répertoire de travail.

Le serveur CVS, logiciel libre, fonctionnait sur de nombreux systèmes : les Unix d’IBM (AIX), de HP (HP-UX), de SGI et de Sun (Solaris), Linux et Windows. Conçu pour la ligne de commande, il disposait aussi d’interfaces graphiques, comme CVSWeb, une interface Web pour parcourir le dépôt et les versions des fichiers, ou TortoiseCVS, intégré à l’explorateur de Windows par le menu du clic droit. Son site de référence, cvshome.org, a disparu.

L’apport majeur de CVS tient dans son nom, concurrent. Les outils plus anciens fonctionnaient selon le principe « verrouiller, modifier, déverrouiller » : pour modifier un fichier, il fallait le réserver, et personne d’autre ne pouvait y toucher tant qu’on ne l’avait pas rendu ; un collègue parti en vacances avec un fichier réservé bloquait toute l’équipe. CVS a popularisé le principe « copier, modifier, fusionner » : chacun travaille librement sur sa copie, et l’outil fusionne les modifications, en ne demandant l’arbitrage humain qu’en cas de conflit réel. C’est toujours le principe de Git. Le verrouillage survit pour les fichiers qu’on ne sait pas fusionner, comme les images ou les plans.

2.3Pourquoi CVS a été abandonné

CVS souffrait de défauts importants : ses commits n’étaient pas atomiques, c’est-à-dire qu’une modification portant sur plusieurs fichiers pouvait être enregistrée à moitié en cas de coupure ; il gérait mal le renommage des fichiers et les branches ; et il exigeait une connexion permanente au serveur. Subversion (SVN), lancé en 2000 pour le remplacer, a corrigé l’essentiel de ces défauts en gardant le modèle centralisé ; il reste utilisé dans certaines entreprises. Mais c’est un outil d’un autre type, distribué, qui s’est imposé : Git.

3Centralisé ou distribué ?

Dans un système centralisé, comme CVS ou Subversion, l’historique n’existe que sur le serveur ; chaque développeur n’a qu’une copie de travail, la dernière version des fichiers. Sans accès au serveur, impossible de consulter l’historique ou d’enregistrer une modification. Dans un système distribué, comme Git ou Mercurial, chaque développeur possède une copie complète du dépôt, avec tout son historique (figure 1). On peut tout faire hors ligne, enregistrer, comparer, créer des branches, et l’on n’échange avec les autres que lorsqu’on le souhaite. Un dépôt partagé sert de référence commune, mais par simple convention : techniquement, toutes les copies se valent, et chacune constitue une sauvegarde complète du projet.

CENTRALISÉ (CVS, SUBVERSION) serveur seul historique copie de travail copie de travail copie de travail sans le serveur : pas d’historique, pas de commit DISTRIBUÉ (GIT, MERCURIAL) dépôt partagé par convention dépôt complet historique dépôt complet historique dépôt complet historique chaque copie est une sauvegarde complète ; on travaille hors ligne
Figure 1. Gestion de versions centralisée et distribuée.

La gestion de versions a plus de cinquante ans d’histoire (tableau 1). Chaque génération a corrigé les défauts de la précédente : gérer un projet entier plutôt que des fichiers isolés, permettre le travail simultané, garantir des enregistrements complets, puis se passer de serveur central. Le modèle distribué a d’abord été jugé complexe ; il s’est imposé parce qu’il rend les branches et les fusions faciles, qu’il permet de travailler partout, et qu’il a fait naître les plateformes de collaboration qui organisent aujourd’hui le développement mondial.

Tableau 1. Quelques étapes de l’histoire de la gestion de versions.
AnnéeOutilApport
1972SCCS (Source Code Control System), laboratoires Bellpremier outil : historique de chaque fichier, avec verrouillage
1982RCS (Revision Control System)stockage plus économe des différences, toujours fichier par fichier
1986-1990CVSprojets entiers, client-serveur, travail simultané sans verrou
années 1990ClearCase, Perforce, Visual SourceSafeoutils commerciaux des grandes entreprises ; Perforce reste prisé dans le jeu vidéo
2000Subversion (SVN)successeur de CVS : commits complets ou rien, renommages
2000-2002BitKeepermodèle distribué, logiciel propriétaire, utilisé pour Linux de 2002 à 2005
2005Git, Mercurialoutils libres et distribués, nés à quelques jours d’intervalle
2008GitHubplateforme d’hébergement et de collaboration autour de Git