Que sont les Git hooks et comment les utilise-t-on ?

Question

Accepted Answer

**Git hooks** sont des scripts que Git exécute **automatiquement** à certains points du workflow Git (avant/après des commits, des pushes, des fusions, etc.). Ils permettent l'automatisation — l'application de normes, l'exécution de vérifications et le déclenchement d'actions — et sont largement utilisés pour la qualité du code et l'intégration CI.

## Qu'est-ce que les hooks

```text
Hooks are executable scripts in .git/hooks/ (or managed by tools) that Git runs on EVENTS:
  CLIENT-SIDE (local):
    pre-commit   → before a commit is created (lint, format, run quick tests)
    commit-msg   → validate/format the commit message
    pre-push     → before pushing (run tests, prevent pushing broken code)
    post-merge/checkout → after merge/checkout (e.g. reinstall dependencies)
  SERVER-SIDE (on the remote):
    pre-receive / update → enforce policies on push (reject bad pushes)
    post-receive → trigger deployment/CI/notifications after a push
```

## Utilisations courantes

```text
✓ pre-commit → LINT and FORMAT code; run quick tests; block secrets/debug code
  → catch issues BEFORE they're committed (fast feedback, consistent quality)
✓ commit-msg → enforce message format (e.g. Conventional Commits)
✓ pre-push → run the test suite → don't push failing code
✓ server-side → enforce policies; trigger CI/CD and deployments
```

## Gestion des hooks en équipe

```text
⚠️ .git/hooks/ is LOCAL and NOT committed → hooks aren't shared automatically.
To share hooks across a team, use tools:
  → HUSKY (JS ecosystem), pre-commit (Python framework), lefthook, etc.
  → these version hooks in the repo and install them for everyone
→ Combined with CI: hooks give FAST LOCAL feedback; CI is the enforced safety net
  (hooks can be bypassed with --no-verify, so CI must also enforce).
```

## Pourquoi c'est important

Comprendre les Git hooks est une connaissance précieuse au niveau senior pour **automatiser les vérifications de qualité et les actions de workflow**, ce qui est utile pour maintenir la qualité du code et intégrer avec CI/CD.

Les hooks permettent **l'automatisation à des événements Git clés** — l'exécution automatique de scripts avant/après des commits, des pushes, des fusions, etc. — ce qui est largement utilisé pour appliquer des normes et détecter les problèmes rapidement.

L'utilisation la plus courante et la plus précieuse est le **pre-commit hook** pour exécuter **le linting, le formatage, les tests rapides et la détection de secrets avant que le code ne soit committé** — fournissant un retour rapide et assurant une qualité cohérente automatiquement (pour que les problèmes soient détectés au moment du commit plutôt que plus tard en CI ou en revue), une pratique extrêmement populaire.

D'autres utilisations (les hooks commit-msg appliquant les conventions de message comme Conventional Commits, les hooks pre-push exécutant des tests pour éviter de pusher du code cassé, et les hooks côté serveur appliquant les politiques ou déclenchant CI/CD et les déploiements) étendent l'automatisation sur tout le workflow.

Comprendre l'aspect pratique de **gestion en équipe** est important : `.git/hooks/` est local et **n'est pas committé**, donc les hooks ne sont pas partagés automatiquement — les partager dans une équipe nécessite des outils comme **Husky, pre-commit ou lefthook** qui versionnent les hooks dans le dépôt et les installent pour tout le monde.

De manière cruciale, comprendre que les hooks **peuvent être contournés** (`--no-verify`) signifie qu'ils fournissent un retour rapide *local* mais **CI doit aussi appliquer** les vérifications comme le vrai filet de sécurité — une intuition clé sur la défense en profondeur (les hooks locaux pour la rapidité, CI pour l'application).

Puisque l'automatisation des vérifications de qualité et des actions de workflow améliore la qualité et la cohérence du code, et puisque les Git hooks (particulièrement pre-commit pour les vérifications locales, gérés via des outils et complétés par CI) sont un mécanisme largement utilisé pour cela, comprendre les Git hooks — ce qu'ils sont, les utilisations courantes, la gestion d'équipe avec des outils et leur relation à CI — est une connaissance précieuse au niveau senior pour construire des workflows de développement automatisés et orientés sur la qualité, reflétant les pratiques utilisées pour maintenir la qualité dans les équipes professionnelles.