Aller au contenu
Encyclopédie informatique Édition 2026

La gestion de versions et Git

Partie 2 sur 2

Niveau de lecture :

4Git

4.1Une naissance en dix jours

De 2002 à 2005, le noyau Linux était géré avec un outil distribué propriétaire, BitKeeper, dont l’éditeur accordait une licence gratuite aux développeurs du noyau. En avril 2005, à la suite d’un différend, cette licence est retirée. Linus Torvalds, le créateur de Linux, décide d’écrire son propre outil, avec trois exigences : être distribué, être très rapide sur un projet de la taille du noyau, et garantir l’intégrité de l’historique contre toute corruption, accidentelle ou malveillante. En une dizaine de jours, Git gère son propre code ; quelques semaines plus tard, il gère celui du noyau. Torvalds en confie la maintenance dès l’été 2005 au Japonais Junio Hamano, qui l’assure toujours. Git, logiciel libre, est aujourd’hui utilisé par l’immense majorité des développeurs dans le monde.

4.2Les trois zones

Sur l’ordinateur du développeur, Git distingue trois zones (figure 2) :

  • le répertoire de travail : les fichiers tels qu’on les voit et les modifie ;
  • l’index, ou zone de préparation : on y place, avec git add, les modifications que l’on veut inclure dans le prochain enregistrement. Cette étape intermédiaire permet de n’enregistrer qu’une partie de ses modifications, pour faire des commits cohérents ;
  • le dépôt local, rangé dans un dossier caché .git : il contient tout l’historique du projet. La commande git commit y enregistre le contenu de l’index.

Le dépôt local s’échange ensuite avec un ou plusieurs dépôts distants : git push envoie ses commits, git pull récupère ceux des autres et les intègre, git fetch les récupère sans les intégrer. Pour commencer à travailler sur un projet existant, on en fait une copie complète avec git clone, l’équivalent du checkout de CVS, mais qui rapatrie tout l’historique.

SUR VOTRE ORDINATEUR répertoire de travail vos fichiers index zone de préparation dépôt local tout l’historique (dossier .git) dépôt distant serveur partagé (origin) git add git commit git push git pull git switch / restore git clone copie un dépôt distant, avec tout son historique, sur votre ordinateur.
Figure 2. Les zones de Git et les commandes qui font passer les modifications de l’une à l’autre.

4.3Une séance de travail

Voici une séance typique en ligne de commande (voir le shell) ; les mêmes opérations existent dans les environnements de développement et les interfaces graphiques :

git clone https://forge.example.org/equipe/projet.git
cd projet
git switch -c correction-calcul      # créer une branche et s'y placer
# ... modifier les fichiers ...
git status                           # voir ce qui a changé
git diff                             # voir les modifications en détail
git add calcul.py
git commit -m "Corrige l'arrondi des montants négatifs"
git push -u origin correction-calcul # publier la branche

Le message de commit est important : il explique pourquoi la modification a été faite, pour ceux qui reliront l’historique dans des mois ou des années. L’usage est d’écrire une première ligne courte, à l’impératif, suivie si nécessaire d’une explication plus détaillée. La commande git log affiche l’historique, et git blame indique, pour chaque ligne d’un fichier, le dernier commit qui l’a modifiée.

Un bon commit est cohérent : il regroupe une seule modification, la correction d’un bogue ou l’ajout d’une fonction, ni plus ni moins. Les commits fourre-tout, « diverses corrections », qui mêlent dix changements sans rapport, sont difficiles à relire, à annuler ou à comprendre plus tard. Certaines équipes adoptent une convention pour les messages, en les faisant commencer par le type de la modification, fix pour une correction, feat pour une nouvelle fonction (en anglais feature), docs pour la documentation ; un outil peut alors produire automatiquement la liste des changements de chaque version.

4.4Branches et fusions

Dans Git, créer une branche est instantané et ne coûte presque rien : une branche n’est qu’une étiquette qui pointe vers un commit, et chaque commit pointe vers celui qui le précède (figure 3). On crée donc une branche pour chaque fonction, chaque correctif ou chaque expérience, on y travaille sans perturber la branche principale, appelée le plus souvent main, puis on la fusionne (en anglais merge) une fois le travail terminé et vérifié. Une autre opération, le rebasage (en anglais rebase), réapplique les commits d’une branche au-dessus d’une autre, pour obtenir un historique linéaire.

A B C D F G X Y fusion main branche « connexion » : X, Y Chaque rond est un commit ; chaque commit pointe vers le précédent. Une branche n’est qu’une étiquette. On développe la fonction sur une branche, sans gêner main, puis on la fusionne une fois relue et testée.
Figure 3. Une branche de fonctionnalité et sa fusion dans la branche principale.

4.5Les conflits

Comme CVS, Git fusionne automatiquement les modifications qui portent sur des parties différentes d’un fichier. Si deux branches ont modifié les mêmes lignes de façon différente, il signale un conflit et insère dans le fichier les deux versions, entourées de marques, pour que le développeur choisisse (exercice 2) :

<<<<<<< HEAD
TAUX_TVA = 0.20
=======
TAUX_TVA = 0.055
>>>>>>> taux-reduit

Le développeur garde la bonne version, ou combine les deux, retire les marques, puis enregistre le résultat par un commit. Des conflits fréquents sont souvent le signe de branches qui vivent trop longtemps : on limite le risque en fusionnant souvent de petites modifications.

4.6Ce que Git enregistre vraiment

Contrairement à CVS, qui stockait les différences entre versions, Git enregistre à chaque commit un instantané complet de l’arborescence du projet, en ne stockant qu’une fois les fichiers inchangés. Chaque objet, contenu de fichier, dossier, commit, est identifié par son empreinte cryptographique, une valeur calculée à partir de son contenu par une fonction de hachage, historiquement SHA-1 (voir le hachage). L’empreinte d’un commit dépend de son contenu et de celle de son parent, qui dépend de celle de son propre parent, et ainsi de suite : modifier un commit ancien change toutes les empreintes qui suivent. Cette chaîne garantit l’intégrité de l’historique : on ne peut pas le falsifier discrètement. Après la publication en 2017 d’une première collision pratique sur SHA-1, deux documents différents ayant la même empreinte, Git a renforcé ses contrôles et engagé une transition progressive vers la fonction SHA-256.

4.7Quelques outils du quotidien

  • le fichier .gitignore liste les fichiers que Git doit ignorer : fichiers temporaires, résultats de compilation, environnements virtuels (les dossiers où Python installe les bibliothèques propres à un projet), et surtout fichiers contenant des secrets (exercice 5) ;
  • les étiquettes (en anglais tags) marquent une version particulière, par exemple v2.1.0, livrée aux utilisateurs ;
  • git stash met de côté des modifications en cours, le temps de traiter une urgence ;
  • git revert annule un commit en créant un nouveau commit inverse, sans réécrire l’historique partagé ;
  • git bisect retrouve le commit qui a introduit un bogue par recherche dichotomique : on lui indique une version correcte et une version fautive, il propose le commit du milieu, on le teste, et l’on coupe ainsi l’intervalle en deux à chaque étape ; sur mille commits, une dizaine de tests suffisent.

4.8Annuler, corriger, retrouver

Git offre plusieurs façons de revenir en arrière, qu’il faut savoir distinguer :

  • git restore fichier abandonne les modifications d’un fichier qui n’ont pas encore été enregistrées ; elles sont alors perdues définitivement ;
  • git commit --amend corrige le dernier commit, pour un message mal rédigé ou un fichier oublié ;
  • git reset déplace l’étiquette de la branche vers un commit antérieur : les commits suivants disparaissent de la branche ;
  • git revert, déjà cité, ajoute un commit qui défait un commit précédent, sans rien effacer.

Corriger un commit, le rebaser ou revenir en arrière avec git reset revient à réécrire l’historique : Git crée de nouveaux commits, avec de nouvelles empreintes, à la place des anciens. Sur sa propre machine, avant publication, c’est sans danger et même recommandé pour présenter un travail propre. Sur un historique déjà partagé, c’est une autre affaire : les copies des collègues ne correspondent plus, et pour publier la nouvelle version il faut forcer l’envoi, avec git push --force, qui remplace la branche du serveur et peut effacer le travail que d’autres y avaient envoyé entre-temps. La règle est simple : on ne réécrit pas un historique partagé ; on ajoute un commit correctif avec git revert (exercice 7). Si l’on doit vraiment forcer, l’option --force-with-lease refuse l’envoi lorsque la branche distante a changé depuis la dernière synchronisation.

Après une fausse manœuvre, tout n’est pas perdu : Git tient un journal local des positions successives de chaque branche, que l’on consulte avec git reflog, et conserve pendant plusieurs semaines les commits devenus inaccessibles. On peut ainsi retrouver un commit « supprimé » par un reset malheureux et recréer une branche qui pointe vers lui. Ce filet de sécurité ne concerne que les modifications qui ont été enregistrées au moins une fois : d’où le conseil de faire des commits souvent.

Pour s’exercer

Exercice 1 : de CVS à Git

Associez à chaque opération CVS décrite plus haut, checkout, commit, update et release, la ou les commandes Git les plus proches. Quelle différence fondamentale y a-t-il pour le commit ?

Voir la réponse

checkout correspond à git clone (première copie) ; update à git pull ; commit à git commit suivi de git push ; release n’a pas d’équivalent direct, on supprime simplement le dossier. La différence fondamentale : avec CVS, le commit envoyait directement les modifications au serveur ; avec Git, git commit les enregistre dans le dépôt local, et c’est git push qui les partage. On peut donc enregistrer des dizaines de commits hors ligne, puis les publier en une fois.

Exercice 2 : résoudre un conflit

Lors de la fusion de la branche taux-reduit, Git signale le conflit présenté à la section 4.5. Que signifient les marques ? Comment le résoudre ?

Voir la réponse

Entre <<<<<<< HEAD et ======= figure la version de la branche courante, ici le taux de 20 % ; entre ======= et >>>>>>> taux-reduit, celle de la branche fusionnée, le taux de 5,5 %. Git ne peut pas savoir laquelle est juste : un taux unique n’a sans doute pas de sens, et la bonne solution est probablement de garder les deux sous des noms distincts, TAUX_TVA_NORMAL et TAUX_TVA_REDUIT. On édite le fichier en ce sens, on supprime les marques, on vérifie que les tests passent, puis on exécute git add et git commit pour conclure la fusion.

Exercice 3 : lire un graphe

Sur la figure 3, quels commits contient la branche main après la fusion ? Si l’on avait supprimé l’étiquette de la branche connexion juste après la fusion, les commits X et Y auraient-ils été perdus ?

Voir la réponse

Après la fusion, main pointe vers G, dont l’historique comprend G, F, D, C, B, A, et aussi Y et X, puisque le commit de fusion F a deux parents, D et Y. Supprimer l’étiquette connexion ne perd donc rien : X et Y restent accessibles depuis F. Une branche n’est qu’un nom ; ce sont les liens entre commits qui portent l’historique. Supprimer les branches fusionnées est d’ailleurs une bonne habitude.

Exercice 4 : un mot de passe dans l’historique

Un développeur a publié sur un dépôt public un fichier de configuration contenant la clé d’accès à la base de données de production. Il le supprime dans un nouveau commit. Le problème est-il réglé ? Que faire, et dans quel ordre ?

Voir la réponse

Non : le fichier reste dans l’historique, et n’importe qui peut le consulter dans les commits précédents ; des robots parcourent en permanence les dépôts publics à la recherche de tels secrets, et la clé a pu être copiée en quelques minutes. Dans l’ordre : 1) révoquer immédiatement la clé et en créer une nouvelle, c’est la seule mesure qui protège vraiment ; 2) vérifier dans les journaux si la clé a été utilisée par un tiers ; 3) purger le fichier de l’historique avec un outil dédié, en sachant que les copies déjà faites ne seront pas effacées ; 4) ajouter le fichier au .gitignore et ranger désormais les secrets dans un coffre-fort ou des variables d’environnement ; 5) activer la détection automatique des secrets proposée par les forges.

Exercice 5 : écrire un .gitignore

Un projet Python contient un dossier d’environnement virtuel .venv/, des fichiers __pycache__/, un fichier .env de variables d’environnement avec des mots de passe, et des fichiers de journal *.log. Que mettre dans le .gitignore ?

Voir la réponse

Quatre lignes : .venv/, __pycache__/, .env et *.log. Le dossier virtuel et les fichiers compilés se reconstruisent ; les journaux n’ont pas leur place dans l’historique, et peuvent contenir des données personnelles ; le fichier .env contient des secrets. On fournit à la place un fichier d’exemple, .env.example, avec des valeurs fictives, pour indiquer aux autres développeurs quelles variables définir. Attention : le .gitignore n’agit pas sur les fichiers déjà enregistrés dans le dépôt.

Exercice 6 : pourquoi l’historique est infalsifiable

Un attaquant qui a accès au dépôt d’un projet modifie discrètement un commit vieux de six mois pour y glisser une porte dérobée. Pourquoi les autres développeurs peuvent-ils s’en apercevoir ?

Voir la réponse

L’empreinte d’un commit dépend de son contenu et de l’empreinte de son parent. Modifier le commit ancien change son empreinte, donc celle de tous les commits suivants, jusqu’au plus récent. Chaque développeur possède une copie complète de l’historique avec les anciennes empreintes : lors de la synchronisation suivante, Git constate que l’historique a divergé, et refuse de l’intégrer sans fusion explicite ; la manipulation saute aux yeux. C’est pourquoi les attaquants préfèrent ajouter de nouveaux commits d’apparence anodine, et pourquoi la signature des commits et la revue de code restent indispensables.

Exercice 7 : réécrire ou annuler ?

Il y a une semaine, vous avez publié sur la branche main un commit qui introduit un bogue. Depuis, vos collègues ont récupéré la branche et ajouté leurs propres commits. Un collègue vous conseille de supprimer ce commit avec git reset, puis de publier avec git push --force. Qu’en pensez-vous ?

Voir la réponse

C’est une mauvaise idée. git reset réécrit l’historique ; le push --force remplacerait la branche du serveur et effacerait les commits ajoutés depuis par les collègues, ou les obligerait à des manipulations délicates pour réconcilier leurs copies. Il faut utiliser git revert suivi de l’empreinte du commit fautif : Git crée un nouveau commit qui défait exactement ses modifications, que l’on publie normalement. L’historique garde la trace de l’erreur et de sa correction, ce qui est d’ailleurs utile pour comprendre plus tard ce qui s’est passé. Sur une branche protégée, la forge refuserait de toute façon l’envoi forcé.

5Les plateformes de développement

5.1GitHub, GitLab et les autres

Git ne prévoit pas de serveur central, mais il faut bien un lieu commun pour partager le travail. Des forges logicielles hébergent donc les dépôts et y ajoutent des services de collaboration. GitHub, lancé en 2008 et racheté par Microsoft en 2018, héberge la plus grande partie des projets libres du monde et revendique plus de cent millions de développeurs. GitLab, apparu en 2011, peut aussi s’installer sur les serveurs d’une organisation, ce qui en fait un choix fréquent des entreprises et des administrations soucieuses de garder la maîtrise de leur code. Des forges associatives, comme Codeberg, fondée sur le logiciel libre Forgejo, offrent une alternative à but non lucratif. Avant elles, SourceForge, créé en 1999, était le grand hébergeur de projets libres, souvent gérés avec CVS.

5.2Les demandes de fusion et la revue de code

Le principal apport de ces plateformes est la demande de fusion (en anglais pull request chez GitHub, merge request chez GitLab) : un développeur propose d’intégrer une branche ; ses collègues relisent les modifications, les commentent ligne par ligne, demandent des corrections, puis approuvent la fusion. Cette revue de code améliore la qualité, diffuse les connaissances dans l’équipe, et constitue l’une des meilleures défenses contre les failles de sécurité, introduites par erreur ou délibérément. Les plateformes permettent de rendre la revue obligatoire, en protégeant la branche principale contre toute modification directe.

5.3L’intégration continue

Les forges déclenchent aussi automatiquement des traitements à chaque modification : compilation, tests, analyses de qualité et de sécurité, construction d’images de conteneurs, et même déploiement en production. C’est l’intégration continue et le déploiement continu (voir DevOps et les conteneurs). Une demande de fusion n’est alors acceptée que si tous les contrôles sont passés. Ces chaînes automatiques ont accès aux secrets nécessaires au déploiement, ce qui en fait des cibles de choix (voir le coin cyber).

5.4Pas seulement pour le code

Git n’est pas réservé aux développeurs : on l’utilise pour gérer la documentation, des sites Web, des fichiers de configuration de serveurs, des politiques de sécurité, des textes juridiques, et même des livres. Il est en revanche peu adapté aux gros fichiers binaires, comme les vidéos ou les documents bureautiques, dont il ne sait pas comparer ni fusionner le contenu, une limite déjà connue pour CVS ; des extensions permettent de les stocker à part.

5.5Organiser le travail d’une équipe

Git laisse chaque équipe libre d’organiser ses branches. Plusieurs façons de faire, appelées flux de travail (en anglais workflows), se sont imposées :

  • le développement sur le tronc (en anglais trunk-based development) : des branches très courtes, de quelques heures à quelques jours, fusionnées souvent dans la branche principale, qui doit toujours pouvoir être livrée. Les fonctions inachevées y sont présentes mais désactivées par des interrupteurs dans la configuration. C’est l’organisation des équipes qui livrent en continu, plusieurs fois par jour (voir les méthodes agiles) ;
  • les branches de version : pour un logiciel dont plusieurs versions sont maintenues en même temps, chacune a sa branche, où l’on applique les correctifs de sécurité, et chaque version livrée est marquée par une étiquette. Le modèle GitFlow, publié en 2010, organisait ainsi des branches de développement, de préparation de version et de correctif urgent ; jugé lourd pour les applications Web livrées en continu, il a été nuancé par son auteur lui-même en 2020 ;
  • la contribution par copie : dans les projets libres, un contributeur extérieur n’a pas le droit d’écrire dans le dépôt du projet. Il en fait une copie personnelle sur la forge (en anglais fork), y développe sa modification, puis propose aux responsables du projet de l’intégrer par une demande de fusion.

Le noyau Linux, le plus grand projet collaboratif du monde, garde une organisation particulière : les modifications y circulent encore sous forme de correctifs envoyés par courrier électronique sur des listes de discussion, où ils sont relus publiquement ; des responsables de chaque partie du noyau les intègrent dans leurs dépôts, et Linus Torvalds récupère leur travail par git pull. À l’autre extrême, certaines grandes entreprises, comme Google, rangent l’essentiel de leur code dans un dépôt unique géant (en anglais monorepo), géré par des outils maison, tandis que d’autres préfèrent un dépôt par composant.

Pour s’exercer

Exercice 8 : choisir une organisation

Quelle organisation des branches conseilleriez-vous a) à une équipe de six personnes qui développe un site de commerce en ligne, mis en production plusieurs fois par jour ; b) aux responsables d’une bibliothèque de programmation libre dont les versions 2 et 3 sont encore utilisées et doivent recevoir des correctifs de sécurité ?

Voir la réponse

a) Le développement sur le tronc : des branches courtes, relues et testées automatiquement, fusionnées dans main qui est déployée en continu ; les fonctions inachevées sont désactivées par configuration. De longues branches multiplieraient les conflits et retarderaient les livraisons. b) Des branches de version : main pour la version 3 en développement, une branche de maintenance pour la version 2, où l’on reporte les correctifs de sécurité, et une étiquette pour chaque version livrée, par exemple v2.8.4. Les contributions extérieures arrivent par copies et demandes de fusion.

Sécurité de l’information

Le coin cyber

Le dépôt de code est devenu un point névralgique : il contient le savoir-faire d’une organisation, parfois ses secrets, et alimente directement la production. Les attaques sont décrites ici dans leur principe seulement.

C.1Les secrets dans le code

Mots de passe, clés d’API (les clés qui donnent accès à un service en ligne par programme), jetons d’accès au cloud : des millions de secrets sont publiés chaque année par erreur dans des dépôts publics, et des robots les repèrent en quelques minutes. Comme l’historique n’oublie rien, supprimer le fichier dans un nouveau commit ne sert à rien : il faut révoquer le secret (exercice 4). Les forges proposent des outils de détection automatique, qui bloquent même la publication d’un secret reconnu ; des outils équivalents peuvent s’exécuter sur le poste du développeur avant chaque commit. La meilleure prévention reste de ne jamais écrire de secret dans le code, mais de le lire dans un coffre-fort ou une variable d’environnement.

C.2L’intégrité et l’authenticité des commits

Les empreintes de Git garantissent qu’un historique n’a pas été modifié, mais pas qui l’a écrit : le nom et l’adresse de l’auteur d’un commit sont déclaratifs, et n’importe qui peut se faire passer pour un autre. La signature des commits, avec une clé personnelle, prouve leur auteur (voir la signature électronique), et les forges peuvent exiger des commits signés. La protection de la branche principale, la revue obligatoire par au moins une autre personne et l’authentification forte des comptes des développeurs complètent le dispositif. L’affaire de la porte dérobée découverte en 2024 dans l’outil de compression xz, glissée par un contributeur qui avait gagné la confiance du projet pendant deux ans, montre que ces protections ne suffisent pas toujours face à un attaquant patient : la vigilance collective reste essentielle (voir le développement sécurisé).

C.3La chaîne d’intégration, une cible

Les chaînes d’intégration et de déploiement continus ont accès aux secrets de production et peuvent modifier ce qui est livré aux utilisateurs. Un attaquant qui les compromet, par exemple en piégeant l’un des composants partagés qu’elles utilisent, peut voler ces secrets ou glisser du code malveillant dans les logiciels produits. En mars 2025, la compromission d’un module d’automatisation très utilisé sur GitHub a ainsi exposé les secrets de nombreux projets dans leurs journaux d’exécution. Les parades : figer les versions des composants utilisés par leur empreinte, limiter les droits accordés à chaque étape, séparer les secrets de production, et surveiller les journaux.

C.4Idée reçue

« J’ai supprimé le mot de passe dans un nouveau commit, il n’est plus visible. » Faux. Il reste dans l’historique, que toute personne ayant accès au dépôt peut consulter, et il a pu être copié dès sa publication. La seule mesure efficace est de considérer ce secret comme compromis : le révoquer et le remplacer, puis seulement nettoyer l’historique.

C.5Bonnes pratiques

Développeur

  • Ne jamais enregistrer de secret dans un dépôt, même privé ; utiliser un .gitignore adapté et un outil de détection avant chaque commit.
  • Protéger son compte de forge par l’authentification à deux facteurs, et signer ses commits.
  • Relire le contenu exact de ce qu’on enregistre, avec git diff --staged, avant chaque commit.

Organisation

  • Protéger les branches principales : revue obligatoire, contrôles automatiques, pas de modification directe.
  • Activer la détection des secrets et des dépendances vulnérables sur toutes les forges.
  • Durcir les chaînes d’intégration : droits minimaux, composants figés, secrets cloisonnés, journaux surveillés.

Référentiels : OpenSSF (Open Source Security Foundation), Source Code Management Platform Configuration Best Practices et cadre SLSA (Supply-chain Levels for Software Artifacts) · NIST (National Institute of Standards and Technology, l’institut américain de normalisation) SP 800-218, Secure Software Development Framework (2022) · ANSSI (Agence nationale de la sécurité des systèmes d’information), Les essentiels : DevSecOps (2024), sur l’intégration de la sécurité dans les pratiques DevOps.

Références

  1. S. Chacon, B. Straub, Pro Git, 2e éd., Apress, 2014, disponible gratuitement en ligne et en français.
  2. B. Berliner, « CVS II: Parallelizing Software Development », Proceedings of the USENIX Winter Conference, 1990.
  3. B. Collins-Sussman, B. W. Fitzpatrick, C. M. Pilato, Version Control with Subversion, O’Reilly, 2008.
  4. R. Di Cosmo, S. Zacchiroli, « Software Heritage: Why and How to Preserve Software Source Code », iPRES, 2017.
  5. M. Stevens et al., « The First Collision for Full SHA-1 », CRYPTO, 2017.

Voir aussi

Citer cet article

« La gestion de versions et Git », Encyclopédie informatique, révision du 23 octobre 2026.