GitFlow : le modèle de gestion de branches

2025-03-07

GitFlow

Qu'est-ce que GitFlow ?

GitFlow est un modèle de gestion de branches pour Git, introduit par Vincent Driessen en 2010. Ce workflow définit un ensemble strict de règles pour la création et la fusion des branches, permettant de gérer efficacement le cycle de développement des logiciels, particulièrement pour les projets ayant des cycles de publication planifiés.

GitFlow s'articule autour de deux branches principales (master et develop) et de trois types de branches auxiliaires (feature, release et hotfix), chacune ayant un rôle spécifique dans le processus de développement.

Différents types de branches dans GitFlow

Branches principales

  1. Master (main) : Représente le code en production. Chaque commit dans cette branche correspond à une nouvelle version en production.

  2. Develop : Branche d'intégration continue où convergent toutes les fonctionnalités développées. Elle contient la dernière version de développement.

Branches auxiliaires

  1. Feature : Créée à partir de develop pour développer une nouvelle fonctionnalité. Une fois terminée, elle est fusionnée dans develop.

  2. Release : Créée à partir de develop pour préparer une nouvelle version. Permet de finaliser la version (corrections mineures, documentation) avant le déploiement.

  3. Hotfix : Créée à partir de master pour corriger rapidement un bug critique en production. Une fois résolue, elle est fusionnée dans master et develop.

Flux de travail avec GitFlow

Développement d'une fonctionnalité

1. Création d'une branche feature à partir de develop
   git checkout -b feature/nouvelle-fonctionnalite develop

2. Développement de la fonctionnalité
   [travail, commits, etc.]

3. Fusion dans develop
   git checkout develop
   git merge --no-ff feature/nouvelle-fonctionnalite

4. Suppression de la branche feature
   git branch -d feature/nouvelle-fonctionnalite

Préparation d'une release

1. Création d'une branche release à partir de develop
   git checkout -b release/1.0.0 develop

2. Corrections mineures et préparation
   [corrections, documentation, etc.]

3. Fusion dans master et tagging
   git checkout master
   git merge --no-ff release/1.0.0
   git tag -a 1.0.0 -m "Version 1.0.0"

4. Fusion dans develop
   git checkout develop
   git merge --no-ff release/1.0.0

5. Suppression de la branche release
   git branch -d release/1.0.0

Correction d'un bug critique en production

1. Création d'une branche hotfix à partir de master
   git checkout -b hotfix/1.0.1 master

2. Correction du bug
   [correction, tests, etc.]

3. Fusion dans master et tagging
   git checkout master
   git merge --no-ff hotfix/1.0.1
   git tag -a 1.0.1 -m "Version 1.0.1"

4. Fusion dans develop
   git checkout develop
   git merge --no-ff hotfix/1.0.1

5. Suppression de la branche hotfix
   git branch -d hotfix/1.0.1

Représentation visuelle de GitFlow

      (hotfix/1.0.1) → o → o → o → → → → → → → → → → → →
                       ↓                                 ↓
master o → → → → → → → o → → → → → → → → → → → → → → → → o
          ↑             ↑                                 ↑
          ↑             ↑ (release/1.0.0)                 ↑
          ↑             o → o → o → →                     ↑
          ↑             ↑           ↓                     ↑
          ↑             ↑           ↓                     ↑
develop o → o → o → o → o → → → → → o → o → o → o → o → → o
              ↑     ↑                   ↑
              ↑     ↑                   ↑
     (feature/A)    ↑            (feature/C)
              o → o o                   o → o → o
                    ↑
                    ↑
             (feature/B)
                    o → o

Implémentation avec l'extension git-flow

L'extension git-flow facilite l'utilisation de ce modèle en automatisant les opérations courantes.

Installation

# Sur macOS avec Homebrew
brew install git-flow-avh

# Sur Linux (Debian/Ubuntu)
apt-get install git-flow

Initialisation

# Dans un dépôt Git existant
git flow init

Commandes principales

# Démarrer une fonctionnalité
git flow feature start nom-fonctionnalite

# Finaliser une fonctionnalité
git flow feature finish nom-fonctionnalite

# Démarrer une release
git flow release start 1.0.0

# Finaliser une release
git flow release finish 1.0.0

# Démarrer un hotfix
git flow hotfix start 1.0.1

# Finaliser un hotfix
git flow hotfix finish 1.0.1

Avantages de GitFlow

  1. Structure claire : Organisation rigoureuse qui facilite la compréhension du flux de développement.
  2. Isolation des fonctionnalités : Chaque fonctionnalité est développée dans sa propre branche, minimisant les interférences.
  3. Support des releases parallèles : Possibilité de maintenir plusieurs versions en production.
  4. Travail en équipe facilité : La séparation des préoccupations permet à plusieurs équipes de travailler sans conflit.
  5. Historique de commits propre : L'utilisation de --no-ff préserve l'historique des branches.

Inconvénients de GitFlow

  1. Complexité : Le modèle peut être trop complexe pour des petits projets ou des équipes réduites.
  2. Overhead administratif : La gestion des branches et des fusions ajoute une charge de travail.
  3. Moins adapté au déploiement continu : Le modèle est conçu pour des cycles de release planifiés, pas pour du déploiement plusieurs fois par jour.
  4. Risque de divergence : Les branches à longue durée de vie peuvent diverger significativement, rendant les fusions difficiles.
  5. Courbe d'apprentissage : Nécessite une compréhension approfondie pour les nouveaux membres de l'équipe.

Comparaison avec d'autres modèles

GitFlow vs GitHub Flow

GitHub Flow est plus simple :

  • Une seule branche principale (main)
  • Des branches de fonctionnalités créées à partir de main
  • Pull requests pour fusionner les changements
  • Déploiement après chaque fusion dans main

Idéal pour : déploiement continu, équipes plus petites, applications web.

GitFlow vs Trunk-Based Development

Trunk-Based Development :

  • Une seule branche principale (trunk ou main)
  • Intégration continue et fréquente (plusieurs fois par jour)
  • Utilisation de feature flags pour désactiver le code incomplet
  • Branches très courtes (quelques heures maximum)

Idéal pour : équipes pratiquant l'intégration continue/déploiement continu (CI/CD).

Cas d'utilisation appropriés pour GitFlow

GitFlow est particulièrement adapté pour :

  1. Logiciels avec versions numérotées : Applications de bureau, bibliothèques, frameworks.
  2. Équipes importantes : Projets impliquant plusieurs équipes travaillant sur différentes fonctionnalités.
  3. Cycles de release planifiés : Produits avec des dates de sortie prédéfinies.
  4. Maintenance de versions multiples : Logiciels nécessitant le support de plusieurs versions en parallèle.

À l'inverse, GitFlow n'est généralement pas recommandé pour :

  1. Applications web avec déploiement continu
  2. Petites équipes ou projets simples
  3. Startups en phase d'itération rapide

Bonnes pratiques avec GitFlow

  1. Commits atomiques : Chaque commit doit représenter un changement logique unique.
  2. Messages de commit descriptifs : Utiliser des messages clairs expliquant le pourquoi du changement.
  3. Revues de code : Mettre en place des pull requests avant les fusions.
  4. Tests automatisés : Exécuter les tests avant chaque fusion importante.
  5. Documentation : Maintenir une documentation sur le workflow pour l'équipe.
  6. Branches de courte durée : Éviter les branches de fonctionnalités trop longues.

Outils pour faciliter l'utilisation de GitFlow

  1. git-flow-avh : Extension de ligne de commande
  2. SourceTree : Interface graphique avec support intégré de GitFlow
  3. GitKraken : Interface graphique avec visualisation du workflow
  4. VS Code avec GitLens : Extension pour visualiser l'historique et les branches
  5. IntelliJ/WebStorm : Support intégré de GitFlow

Conclusion

GitFlow est un modèle de gestion de branches structuré et rigoureux qui convient particulièrement aux projets complexes avec des cycles de release planifiés. Sa force réside dans sa capacité à organiser le développement en équipe et à gérer efficacement plusieurs versions d'un logiciel.

Cependant, sa complexité peut être excessive pour certains projets, et des alternatives plus légères comme GitHub Flow ou Trunk-Based Development peuvent être plus appropriées dans certains contextes, notamment pour le développement web avec déploiement continu.

Le choix du modèle de branches doit toujours être adapté aux besoins spécifiques du projet et de l'équipe. L'essentiel est de suivre un processus cohérent qui facilite la collaboration et garantit la qualité du code.

Ressources

avatar
Darkaine @ Mémos
Je découvre, j'apprends, je prends des notes et je les partage.