La gestion de versions et Git
Partie 2 sur 2
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 commandegit commity 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.
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.
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
.gitignoreliste 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 stashmet de côté des modifications en cours, le temps de traiter une urgence ;git revertannule un commit en créant un nouveau commit inverse, sans réécrire l’historique partagé ;git bisectretrouve 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 fichierabandonne les modifications d’un fichier qui n’ont pas encore été enregistrées ; elles sont alors perdues définitivement ;git commit --amendcorrige le dernier commit, pour un message mal rédigé ou un fichier oublié ;git resetdé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.