Git n'est pas qu'un bouton « sauvegarder » : c'est un graphe de l'histoire du projet, et une manière de travailler à plusieurs sans se marcher dessus.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Maître de l'historique
🎬 L'histoire
Deux formateurs de HashBox modifient le même fichier de tarifs, chacun de son côté. Le premier remplace le second sans le savoir ; trois jours plus tard, les anciens prix réapparaissent. Un autre jour, un bug est apparu « quelque part dans les 200 derniers commits » et personne ne sait lequel l'a introduit.
« Git résout les deux problèmes, dit Sam. Chaque version est un point d'un graphe ; on fusionne des branches avec détection des conflits ; et on peut chercher automatiquement le commit coupable. Il faut juste comprendre le modèle. »
Tu apprends le modèle de Git (commits, branches, fusions), les stratégies de collaboration (trunk-based, GitFlow), les conventions de messages, et tu retrouves un bug automatiquement avec git bisect.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer le modèle de Git : commits, graphe orienté acyclique, branches comme pointeurs
- fusionner et résoudre un conflit
- comparer fusion (merge) et réécriture (rebase)
- choisir une stratégie de branches (trunk-based, GitFlow) et protéger la branche principale
- retrouver un commit fautif avec
git bisect
🧩 Défi d'échauffement (5 XP)
Cinq personnes éditent le même rapport en s'envoyant des versions par e-mail : rapport_v3_final_FINAL.docx. Cite trois problèmes. Comment un système qui retient chaque modification avec son auteur, sa date et son explication résoudrait-il chacun d'eux ?
💡 Le concept
Le modèle de Git
Git conserve l'histoire sous forme de commits : des instantanés complets du projet, chacun avec :
- un identifiant (haché SHA du contenu et du parent) ;
- un ou plusieurs parents ;
- un auteur, une date, un message.
Les commits forment un graphe orienté acyclique (DAG). Une branche n'est qu'un pointeur mobile vers un commit ; HEAD indique où l'on se trouve.
gitGraph
commit id: "A"
commit id: "B"
branch fonctionnalite
commit id: "C"
commit id: "D"
checkout main
commit id: "E"
merge fonctionnalite id: "F"
Description du schéma : la branche principale avance de A à B ; une branche « fonctionnalite » part de B et reçoit C et D ; pendant ce temps la branche principale reçoit E ; puis la fusion F réunit les deux histoires.
Les commandes de tous les jours
| Besoin | Commande |
|---|---|
| Voir l'état | git status, git log --oneline --graph |
| Enregistrer | git add fichier puis git commit -m "message" |
| Créer / changer de branche | git switch -c nom / git switch nom |
| Voir les différences | git diff |
| Récupérer / publier | git fetch, git pull, git push |
| Fusionner | git merge nom |
| Annuler sans réécrire l'histoire |
Fusion (merge) et rebase
| Merge | Rebase | |
|---|---|---|
| Idée | crée un commit de fusion à deux parents | rejoue tes commits au-dessus de la branche cible |
| Histoire | fidèle, avec bifurcations | linéaire |
| Risque | graphe plus touffu | réécrit l'histoire : jamais sur une branche déjà partagée |
Règle d'or du rebase : ne réécris jamais l'histoire publique que d'autres ont déjà récupérée.
Les conflits
Un conflit survient quand deux branches modifient les mêmes lignes différemment. Git marque les zones :
<<<<<<< HEAD
prix = 40
=======
prix = 45
>>>>>>> fonctionnalite
On choisit (ou combine), on supprime les marqueurs, on enregistre. Les conflits sont moins douloureux avec de petites branches de courte durée.
Stratégies de collaboration
| Stratégie | Principe | Quand |
|---|---|---|
| Trunk-based | tout le monde intègre souvent (au moins chaque jour) dans la branche principale ; branches très courtes ; fonctionnalités cachées derrière des drapeaux | équipes qui livrent en continu (recommandé par DORA) |
| GitFlow | branches develop, release, hotfix, feature | livraisons planifiées, plusieurs versions maintenues |
| GitHub Flow | une branche principale toujours déployable + branches courtes + demande de fusion | applications web |
Demandes de fusion (pull requests)
Une PR propose de fusionner une branche. C'est le lieu de la revue et de l'automatisation (CI). Bonnes pratiques : petites PR (moins de 400 lignes), description claire, tests verts, revue rapide (quelques heures).
Branche principale protégée
Règles côté dépôt : fusion uniquement via PR, CI verte, au moins une revue, pas de push direct, pas de réécriture d'historique. C'est l'une des portes de qualité de la mission 1 du module.
Messages de commit et versionnement
Les commits conventionnels structurent l'historique : type(portée): résumé avec feat, fix, docs, refactor, test, chore, et ! pour une rupture.
Le versionnement sémantique (MAJEUR.MINEUR.CORRECTIF) en découle :
| Changement | Incrémente |
|---|---|
fix | CORRECTIF |
feat | MINEUR |
rupture de compatibilité (!) | MAJEUR |
git bisect : la recherche dichotomique d'un bug
Tu indiques un commit mauvais et un commit bon ; Git teste le milieu, puis réduit l'intervalle de moitié à chaque étape : 200 commits en environ 8 essais. Avec git bisect run <script>, tout est automatique.
🧠 Astuce : commits petits, atomiques, avec un message qui explique le pourquoi.
git bisectetgit revertdeviennent alors des outils magiques.
🔍 Exemple pas à pas
Problème : utiliser réellement Git dans un dépôt temporaire : historique, branches, conflit résolu, puis git bisect run pour retrouver automatiquement le commit qui a cassé une fonction.
import os, subprocess, tempfile
from pathlib import Path
ENV = dict(os.environ, GIT_AUTHOR_NAME="Kodi", GIT_AUTHOR_EMAIL="[email protected]",
GIT_COMMITTER_NAME="Kodi", GIT_COMMITTER_EMAIL="[email protected]", GIT_CONFIG_GLOBAL="/dev/null", GIT_CONFIG_SYSTEM="/dev/null")
def git(depot, *args, ok=True):
r = subprocess.run(["git", "-c", "init.defaultBranch=main", *args], cwd=depot, env=ENV, capture_output=True, text=True)
if ok and r.returncode != 0:
raise RuntimeError(f"git {' '.join(args)} : {r.stderr.strip()}")
return r
def commit(depot, nom, contenu, message):
Path(depot, nom).write_text(contenu)
git(depot, "add", nom)
git(depot, "commit", "-q", "-m", message)
return git(depot, "rev-parse", "HEAD").stdout.strip()
with tempfile.TemporaryDirectory() as d:
git(d, "init", "-q")
# ---- 1. un historique linéaire avec un bug glissé au 6e commit ----
commits = []
for i (, ):
prix = i <
commits.append(commit(d, , , ))
(, (commits), )
test = Path(d, , ).resolve()
Path(test).write_text()
git(d, , )
git(d, , , commits[-])
git(d, , , commits[])
resultat = git(d, , , , (test))
fautif = (l l resultat.stdout.splitlines() l).split()[]
git(d, , )
(, fautif[:], , git(d, , , , fautif).stdout.strip())
fautif == commits[]
nb_etapes = resultat.stdout.count()
(, nb_etapes, , (commits), )
nb_etapes <=
git(d, , , , )
commit(d, , , )
git(d, , , )
commit(d, , , )
fusion = git(d, , , ok=)
fusion.returncode != fusion.stdout
(, [l l fusion.stdout.splitlines() l][])
contenu = Path(d, ).read_text()
contenu contenu contenu
Path(d, ).write_text()
git(d, , )
git(d, , , , )
parents = git(d, , , , , ).stdout.split()
(, (parents) - , )
(parents) ==
avant = git(d, , , ).stdout.strip()
git(d, , , , , )
apres = git(d, , , ).stdout.strip()
()
(apres) == (avant) +
Lecture :
- Historique : 10 commits simples (
git commitenregistre un instantané complet). git bisect run: en ~3-4 essais (recherche dichotomique, comme dans la mission HEF-010), Git retrouve le 6ᵉ commit, sans intervention humaine, grâce à un script de test dont le code de sortie dit « bon » (0) ou « mauvais » (1).- Conflit : deux branches modifient la même ligne ; Git s'arrête, marque les zones, ne devine pas. On résout, on
add, oncommit: le commit de fusion a deux parents. revert: crée un nouveau commit qui annule l'effet de l'ancien. L'histoire publique reste intacte — c'est la bonne façon d'annuler un changement déjà partagé.
✍️ À toi, avec aide (10 XP)
Écris analyser_commits(messages) qui, à partir d'une liste de messages de commits conventionnels, calcule la prochaine version (à partir de 1.4.2) et un journal des changements regroupé par type :
feat: …→ mineur ;fix: …→ correctif ;feat!: …ouBREAKING CHANGEdans le message → majeur ;- les autres types (
docs,test,chore,refactor) n'incrémentent rien ; - le plus fort incrément l'emporte (majeur > mineur > correctif).
Teste avec trois listes de commits.
💡 Indice 1
Utilise une expression régulière ^(\w+)(\([^)]*\))?(!)?: (.+)$.
💡 Indice 2
Initialise le niveau à None et garde le maximum selon un ordre correctif < mineur < majeur.
💡 Indice 3
Si aucun commit n'incrémente, la version reste inchangée.
✅ Réponse
import re
from collections import defaultdict
MOTIF = re.compile(r"^(\w+)(\([^)]*\))?(!)?: (.+)$")
NIVEAU = {"fix": 1, "feat": 2}
def analyser_commits(messages, version="1.4.2"):
journal, niveau = defaultdict(list), 0
for m in messages:
ligne = m.splitlines()[0]
trouve = MOTIF.match(ligne)
if not trouve:
continue
type_, _, rupture, resume = trouve.groups()
journal[type_].append(resume)
courant = NIVEAU.get(type_, 0)
if rupture or "BREAKING CHANGE" in m:
courant = 3
niveau = max(niveau, courant)
maj, mi, co = map(int, version.split("."))
if niveau == 3: maj, mi, co = maj + 1, 0, 0
elif niveau == 2: mi, co = mi + 1, 0
elif niveau == 1: co += 1
, (journal)
analyser_commits([, ])[] ==
analyser_commits([, ])[] ==
analyser_commits([, ])[] ==
analyser_commits([, ])[] ==
analyser_commits([])[] ==
(analyser_commits([, ]))
🚀 À toi, en solo (20 XP)
Recréer un petit Git. Écris MiniDepot qui conserve un graphe de commits :
commit(message, parents)crée un identifiant par hachage SHA-1 du contenu (message + parents + compteur) et renvoie l'identifiant ;- les branches sont de simples pointeurs
{nom: id}; anciens(id)renvoie l'ensemble de tous les ancêtres ;base_commune(a, b)renvoie l'ancêtre commun le plus récent (base de fusion) ;est_ancetre(a, b): est-ce qu'une fusionbdansaserait un simple « fast-forward » ?- compare ton résultat à
git merge-basesur un vrai dépôt temporaire construit avec le même graphe.
✅ Pistes de correction
import hashlib, os, subprocess, tempfile
from pathlib import Path
class MiniDepot:
def __init__(self):
self.commits, self.branches, self.n = {}, {}, 0
def commit(self, message, parents=()):
self.n += 1
ident = hashlib.sha1(f"{message}|{','.join(parents)}|{self.n}".encode()).hexdigest()[:10]
self.commits[ident] = {"message": message, "parents": tuple(parents)}
return ident
def anciens(self, ident):
vus, pile = set(), [ident]
while pile:
c = pile.pop()
if c in vus:
continue
vus.add(c)
pile.extend(self.commits[c]["parents"])
return vus
def base_commune(self, a, b):
communs = .anciens(a) & .anciens(b)
feuilles = [c c communs (c != o c .anciens(o) o communs)]
feuilles[] (feuilles) == (feuilles)
():
a .anciens(b)
dep = MiniDepot()
A = dep.commit(); B = dep.commit(, (A,))
C = dep.commit(, (B,)); D = dep.commit(, (C,))
E = dep.commit(, (B,))
F = dep.commit(, (D, E))
dep.base_commune(D, E) == B dep.base_commune(D, C) == C
dep.est_ancetre(B, F) dep.est_ancetre(D, E)
dep.base_commune(F, E) == E
ENV = (os.environ, GIT_AUTHOR_NAME=, GIT_AUTHOR_EMAIL=, GIT_COMMITTER_NAME=, GIT_COMMITTER_EMAIL=, GIT_CONFIG_GLOBAL=, GIT_CONFIG_SYSTEM=)
():
subprocess.run([, , , *a], cwd=d, env=ENV, capture_output=, text=, check=).stdout.strip()
tempfile.TemporaryDirectory() d:
git(d, , )
nom :
Path(d, ).write_text(nom); git(d, , ); git(d, , , , nom)
b = git(d, , )
git(d, , , , )
nom :
Path(d, ).write_text(nom); git(d, , ); git(d, , , , nom)
git(d, , , , , b)
Path(d, ).write_text(); git(d, , ); git(d, , , , )
git(d, , , ) == b
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Gros commits fourre-tout | Revue difficile, bisect inutile | Commits atomiques avec message explicatif |
| Réécrire l'histoire déjà partagée | Casse le travail des collègues | Revert pour annuler ; rebase seulement en local |
| Branches qui vivent des semaines | Conflits énormes, intégration douloureuse | Branches courtes, intégration fréquente |
| Pousser directement sur la branche principale | Pas de revue ni de CI | Branche protégée, PR obligatoire |
🐉 Mini-boss (40 XP)
Atelier Git complet, scripté. Écris un script qui, dans un dépôt temporaire, met en scène le travail de trois personnes :
- historique initial de 8 commits conventionnels ;
- deux branches en parallèle qui modifient des fichiers différents (fusion sans conflit) et une troisième qui modifie la même ligne qu'une autre (conflit résolu par script avec une règle claire) ;
- un commit fautif introduit dans une fonction ; retrouve-le avec
git bisect runet un test automatique ; - annule-le avec
git revert(et nonreset) ; - produis la liste des versions (
v1.0.0,v1.1.0, …) avec des tags à partir des types de commits ; - vérifie par code : l'historique de la branche principale ne contient aucun commit réécrit (les SHA publiés avant le revert sont tous encore présents).
✅ Pistes de correction
Un bon travail : un git() utilitaire comme dans l'exemple, des commits générés à partir d'une liste de messages conventionnels, la résolution du conflit par réécriture du fichier puis add et commit, un script bisect basé sur le code de sortie d'un test, git revert --no-edit <sha> (ou -m 1 pour une fusion), git tag -a vX.Y.Z -m … calculé avec analyser_commits, et une vérification git merge-base --is-ancestor <ancien_sha> HEAD pour chaque SHA publié avant le revert.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Une branche Git est :
- A. une copie complète du projet
- B. un fichier de configuration
- C. un pointeur mobile vers un commit
2. Pour annuler un changement déjà partagé, on utilise :
- A. git revert, qui crée un commit d'annulation
- B. git rebase sur la branche publique
- C. supprimer le dépôt
3. Le trunk-based development repose sur :
- A. des branches de longue durée
- B. des intégrations très fréquentes dans la branche principale
- C. un seul développeur
4. 🔁 Révision mission 01 : DevOps cherche surtout à :
- A. remplacer les développeurs par des administrateurs
- B. supprimer les tests
- C. livrer vite et de façon fiable grâce à une responsabilité partagée
5. 🔁 Révision mission 01 : Pour réduire le délai moyen à débit constant, on :
- A. réduit le travail en cours et la taille des lots
- B. augmente la taille des lots
- C. retarde les déploiements
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quelle est la durée de vie typique de tes branches ? Que se passerait-il si elles duraient deux fois moins longtemps ?
- Quel commit de ton historique récent expliquerait mal le pourquoi, six mois plus tard ?
🎒 À retenir
- Git = graphe de commits ; une branche est un pointeur.
- Merge fidèle, rebase linéaire (jamais sur l'histoire publique).
- Conflit = mêmes lignes modifiées ; on résout, on enregistre.
- Trunk-based : petites branches, intégration quotidienne ; branche principale protégée.
git bisect runretrouve un bug par dichotomie ;git revertannule sans réécrire.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Maître de l'historique
← Mission 01 — Culture et flux DevOps · Mission 03 — Build reproductible →
HEF-120 — DevOps et livraison

