DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesCollaborer efficacement avec Git et GitHub04 - Rebaser et nettoyer l'historique avec git rebase

Détails

  • 25 minutes
  • Intermédiaire

Objectifs

  • Comprendre la différence entre rebase et merge
  • Utiliser le rebase interactif pour nettoyer l'historique
  • Résoudre des conflits lors d'un rebase
Module Collaborer efficacement avec Git et GitHub

Exercice 04 : Rebaser et nettoyer l'historique avec git rebase

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

  • ✅ Expliquer la différence entre git rebase et git merge
  • ✅ Rebaser une branche feature sur main pour un historique linéaire
  • ✅ Utiliser le rebase interactif (squash, reword, fixup)
  • ✅ Résoudre des conflits pendant un rebase et savoir l'annuler

Durée estimée : 25 minutes | Difficulté : ⭐⭐⭐☆☆


📖 Contexte

git rebase réécrit l'historique en déplaçant des commits d'une base à une autre. Là où git merge crée un "merge commit" qui conserve les deux historiques, git rebase produit un historique linéaire - comme si vous aviez développé votre feature directement sur le dernier état de main.

Le rebase interactif (git rebase -i) est encore plus puissant : il permet de nettoyer, fusionner, renommer ou supprimer des commits avant de les intégrer.

Règle d'or : Ne jamais rebaser une branche partagée ou déjà poussée sur laquelle d'autres travaillent.


📋 Énoncé

Vous avez un repository git-intermediaire-tp avec plusieurs commits sur une branche feature. Vous allez la rebaser sur main, nettoyer son historique, et gérer un conflit.


🧭 Déroulement

Tâche 1 : Rebase simple d'une branche feature sur main

Créez une branche feature/rebase-demo à partir d'un commit ancien de main. Ajoutez 2 commits dessus. Pendant ce temps, ajoutez 1 commit sur main. Rebasez la branche sur main.

Indice : git rebase main depuis la branche feature rejoue vos commits au-dessus du dernier commit de main. Contrairement à merge, il n'y a pas de "merge commit" : l'historique reste linéaire.

Vérification : git log --oneline --graph affiche une ligne droite sans branchement.


Tâche 2 : Comparer rebase et merge visuellement

Sur une nouvelle branche feature/merge-demo, faites les mêmes changements. Utilisez git merge main cette fois. Comparez les deux historiques avec git log --oneline --graph.

Indice : git log --all --oneline --graph affiche toutes les branches. Le merge crée un commit de merge avec deux parents. Le rebase crée de nouveaux commits avec de nouveaux SHA.

Vérification : L'historique de feature/merge-demo montre un "Merge commit", celui de feature/rebase-demo est linéaire.


Tâche 3 : Rebase interactif - squash et reword

Sur feature/rebase-demo, vous avez 3 petits commits ("fix typo", "wip", "ajout feature"). Utilisez git rebase -i HEAD~3 pour les fusionner en un seul commit propre avec un bon message.

Indice : Dans l'éditeur interactif, changez pick en squash (ou s) pour les commits à fusionner dans le précédent. reword (ou r) permet de renommer un commit. fixup fusionne sans garder le message.

Vérification : git log --oneline -5 affiche un seul commit à la place des 3 commits de travail.


Tâche 4 : Résoudre un conflit pendant un rebase

Créez une situation de conflit : modifiez la même ligne dans main et dans feature/rebase-demo. Lancez git rebase main, résolvez le conflit, puis continuez le rebase.

Indice : Lors d'un conflit, Git s'arrête. Éditez le fichier pour résoudre (supprimer les marqueurs <<<<, ====, >>>>), puis git add <fichier> et git rebase --continue. Ne faites PAS git commit.

Vérification : git log --oneline affiche vos commits rebasés après le commit de main.


Tâche 5 : Annuler un rebase avec --abort

Relancez un rebase conflictuel. Cette fois, au lieu de résoudre, annulez le rebase entièrement pour revenir à l'état d'avant.

Indice : git rebase --abort annule le rebase en cours et restaure la branche dans son état original - c'est votre "sortie de secours" en cas de problème.

Vérification : Après --abort, git log --oneline montre exactement le même historique qu'avant le rebase.


🗂️ Mini-Projet

bash
# Rebase simple
git checkout -b feature/rebase-demo HEAD~2
git commit --allow-empty -m "feat: commit A"
git commit --allow-empty -m "feat: commit B"
git rebase main

# Rebase interactif (sur les 3 derniers commits)
git rebase -i HEAD~3
# Dans l'éditeur :
# pick  abc1234  feat: commit A
# squash def5678  wip: fix typo
# squash ghi9012  wip: ajout feature

# Résoudre un conflit de rebase
git rebase main
# CONFLIT -> éditer le fichier -> git add -> git rebase --continue

# Annuler
git rebase --abort

Checkpoints :

  • git log --graph montre un historique linéaire après rebase
  • 3 commits sont fusionnés en 1 avec le rebase interactif
  • Un conflit de rebase est résolu avec --continue
  • git rebase --abort restaure l'état initial

Retour au module

Sur cette page

  • 🎯 Objectifs
  • 📖 Contexte
  • 📋 Énoncé
  • 🧭 Déroulement
  • Tâche 1 : Rebase simple d'une branche feature sur main
  • Tâche 2 : Comparer rebase et merge visuellement
  • Tâche 3 : Rebase interactif - squash et reword
  • Tâche 4 : Résoudre un conflit pendant un rebase
  • Tâche 5 : Annuler un rebase avec --abort
  • 🗂️ Mini-Projet