Maîtriser les hooks Git :

Techniques avancées et
meilleures pratiques

Downloaded on: 21 November 2023

 Ship and manage your
web projects faster
Deploy your projects on Google Cloud Platform's top tier
infrastructure. You'll get 25+ data centers to choose
from, 24/7/365 expert support, and advanced security
with DDoS protection.

Try for free

Git n’a pas besoin d’être complexe, mais certaines de ses facettes le sont et nécessitent une
compréhension plus approfondie – les hooks Git, par exemple. Il s’agit de scripts que Git
exécute automatiquement en fonction de certains évènements.

Bien qu’ils puissent être simples, vous avez beaucoup plus de possibilités de les utiliser de
manière efficace. Cependant, pour cela, vous devez comprendre tous les rouages qui
composent l’ensemble de la roue.

Dans cet article, nous allons nous pencher sur les techniques avancées des hooks Git, y
compris quelques principes fondamentaux, comment les créer et les installer, et plus encore.

Nous expliquerons également les paramètres des hooks et les variables d’environnement,
nous vous donnerons quelques conseils et astuces, nous vous présenterons des méthodes
de dépannage et bien d’autres sujets.
Les fondamentaux des hooks Git : Une introduction
Les hooks sont l’une des principales fonctionnalités de Git: un mécanisme puissant qui vous
permet d’automatiser des tâches, d’appliquer des normes et d’assurer des flux de travail
cohérents tout au long du cycle de vie d’un projet.

Les hooks Git sont des scripts qui s’exécutent automatiquement à des moments précis du
flux de travail Git. Vous pouvez les utiliser pour personnaliser et étendre le comportement de
Git afin de répondre aux besoins de votre projet. Les hooks garantissent le maintien de la
qualité du code, l’exécution des tests et l’orchestration des déploiements.

Git propose plusieurs types de hooks, et chacun d’entre eux se déclenche à différentes
étapes du flux de travail Git :

Pre-commit. Ces hooks s’exécutent avant que vous ne finalisiez un commit, ce qui
vous permet d’appliquer des styles de code, d’exécuter des tests ou de vérifier les
erreurs de syntaxe.
Post-commit. Ces hooks s’exécutent après la création d’un commit. Ils sont utiles pour
les notifications ou la journalisation.
Pre-push. Ce hooks se déclenche avant le transfert du code et vous permet d’effectuer
des tests d’intégration, de vérifier la compatibilité ou d’assurer la qualité.
Post-push. Le hook final s’exécute après que vous ayez terminé un push. En tant que
tel, il est utile pour déployer le code en production ou mettre à jour la documentation.

Vous trouverez les hooks dans le répertoire .git/hooks de votre dépôt Git. Vous pouvez
les utiliser comme modèles pour créer vos propres scripts personnalisés. Les crochets
couvrent une série d’actions et utilisent le préfixe sample- à titre de référence :
 — Un répertoire Git local contenant des fichiers d’exemples de hooks.

Les hooks se déclenchent lors de différentes actions Git. Par exemple, un hook pre-commit
s’exécute lorsque vous livrez des modifications, et un hook pre-push se déclenche avant que
vous ne poussiez vers un serveur distant. Une fois que vous comprenez mieux ces
déclencheurs, vous pouvez déployer des hooks de manière plus stratégique pour renforcer le
contrôle de la qualité et rationaliser votre flux de travail.

Comment créer et installer des hooks Git personnalisés ?

La création et l’installation de hooks Git personnalisés de base peut être un processus
complexe. Cependant, les principes fondamentaux que vous utiliserez ici vous permettront de
développer des hooks avancés plus tard. Passons en revue quelques concepts qui
s’appliquent à tous les hooks que vous créez et installez.
Choisir un type de hook approprié

L’utilisation du bon type de hook pour votre cas d’utilisation spécifique est une première étape
importante. Vous pouvez commencer par comprendre votre propre flux de développement et
vos besoins. Voici une liste de contrôle rapide des considérations à ce sujet :

Tout d’abord, tenez compte des différentes étapes de votre processus, telles que le
codage, les tests et le déploiement. Identifiez également les domaines dans lesquels ce
processus pourrait bénéficier de l’automatisation et des contrôles.
À partir de là, localisez les points de votre flux de travail où des erreurs ou des
incohérences se produisent souvent. Les hooks Git personnalisés peuvent être utiles à
cet égard. Par exemple, si vous oubliez d’exécuter des tests avant un commit, un hook
pre-commit peut résoudre le problème.
Ensuite, réfléchissez au moment où vous souhaitez exécuter le hook dans votre flux de
travail. Par exemple, si vous voulez vous assurer que toutes les livraisons respectent
les normes de codage, un hook pre-commit est approprié. Si vous voulez valider le
code avant de le pousser sur le serveur distant, un hook pre-push sera plus approprié.
Enfin, assurez-vous que le type de hook choisi est compatible avec votre
environnement de développement et les outils que vous utilisez. Pensez au langage de
script que vous utiliserez pour le hook et à son environnement d’exécution.

À ce stade, vous devriez être en mesure de définir des objectifs clairs pour votre hook. Il se
peut même que chaque objectif nécessite un type de hook différent. Cependant, bien qu’il soit
tentant de créer des scripts pour tous les scénarios possibles, il est préférable de se
concentrer d’abord sur les points critiques.

Nommer et placer les hooks Git personnalisés

Nommer et placer correctement les hooks Git personnalisés est crucial pour assurer leur
fonctionnalité et leur maintenabilité. Tout comme les fonctions de votre code, les fichiers, les
noms de classe, etc., vos hooks Git doivent également avoir une convention de nommage
cohérente et descriptive.

Si les hooks doivent supporter plusieurs projets dans le temps, vous pouvez utiliser des
préfixes, par exemple les initiales d’un développeur, un département ou le nom d’une
entreprise. En général, les hooks Git utilisent des lettres minuscules et des traits d’union pour
plus de lisibilité – par exemple, mon-projet-pre-commit.

De plus, bien que vous puissiez stocker les hooks Git dans le répertoire .git/hooks de votre
dépôt, les hooks personnalisés doivent être placés dans un répertoire séparé à l’intérieur du
dossier racine du projet. Cela évitera les écrasements accidentels lors d’une mise à jour de
Git. Cependant, vous devez mettre en place un contrôle de version pour ces hooks avec le
reste du code de votre projet.

Comment créer un hook Git personnalisé basique

La façon typique d’écrire un hook Git de base est de créer un nouveau fichier avec le nom du
hook choisi (comme pre-commit) dans votre répertoire hooks. Nous listerons les noms des
hooks plus tard lorsque nous parlerons des paramètres.

Avant d’ouvrir un fichier pour travailler dessus, vous devez vous assurer qu’il est exécutable
en utilisant l’extrait de ligne de commande suivant :

chmod +x path/to/file/hook-name

N’oubliez pas de remplacer nos textes indicatifs par les bonnes informations. Nous ferons
référence à cet extrait tout au long de cet article, car il devrait s’agir d’une action typique
lorsque vous créez un nouveau hook Git.

Une fois que le fichier est exécutable et ouvert, ajoutez votre logique personnalisée en
utilisant votre langage de script préféré. Il peut s’agir de Bash, Python, Ruby et autres.
L’élaboration de ces scripts dépasse bien sûr le cadre de ce que nous allons aborder ici.
Cependant, vous trouverez plus loin quelques exemples de pseu-docode pour illustrer des
cas d’utilisation et des scénarios spécifiques.

Enfin, avant de valider des modifications, testez votre hook en essayant d’exécuter l’action
correspondante (comme une validation). Il s’agit de l’approche de base pour créer des hooks
Git, mais il existe de nombreux cas d’utilisation avancés. C’est ce que nous verrons plus loin.

Comment créer et installer des hooks personnalisés

avancés
Créer des hooks Git basiques est quelque chose que vous ferez souvent au cours de votre
carrière de développeur. Cependant, de nombreuses situations nécessiteront des hooks plus
avancés et plus complexes. Nous allons maintenant voir quelques cas d’utilisation et des
exemples de hooks pour une variété de scénarios communs.

Créer un hook qui renforce le style du code en utilisant des liners

L’utilisation d’un linter pour renforcer le style du code est une application fantastique pour les
hooks Git. Cela peut aider à maintenir une qualité de code cohérente à travers votre
référentiel et devrait être quelque chose de très utile.

Bien sûr, vous devriez choisir un linter qui convient au langage de programmation de votre
projet. Par exemple, Black est fantastique pour Python. Nous allons utiliser ESLint pour
JavaScript ici pour créer un hook pre-commit.

Tout d’abord, installez le linter en tant que paquet global ou local dans votre projet. Vous
aurez besoin de Node.js et de npm pour cela :

npm install eslint --save-dev

Ensuite, naviguez jusqu’à votre répertoire hooks dans votre dépôt. Créez votre fichier de pre-
commit, puis écrivez un script qui exécute le linter sur vos fichiers mis à disposition. Le hook
devrait empêcher le commit si le linter trouve des problèmes. Voici un exemple approximatif :
 #!/bin/sh

# Stash unstaged changes (optional but recommended)

git stash -q --keep-index

# Run the linter on staged files

npm run lint # Replace with the appropriate linting command
LINT_RESULT=$?

# Unstash the stashed changes (optional but recommended)

git stash pop -q

# Exit with the linter's exit code

exit $LINT_RESULT

Une fois que vous vous êtes assuré que le hook est exécutable, testez-le par le biais d’une
validation. Le hook de pre-commit devrait exécuter le linter. S’il y a des violations de style de
code, vous ne pourrez pas terminer la validation tant que vous n’aurez pas corrigé les
problèmes.

Bien sûr, vous devriez écrire un hook qui fonctionne avec votre propre langage de
programmation et linter, en fonction de votre projet. Par exemple, vous pourriez étendre cet
exemple avec les paramètres de configuration de linter, en l’intégrant à votre processus de
construction, et plus encore.

Implémenter un hook pour exécuter des tests avant un commit

Implémenter un hook pre-commit pour exécuter les tests avant un commit est un excellent
moyen de détecter les problèmes potentiels dès le début. Ainsi, vous pouvez vous assurer
que vous ne livrez que du code fiable.

Pour cet exemple, nous utiliserons le framework de test Jest pour JavaScript. Vous voudrez
installer quelque chose d’adapté à votre projet (comme toujours) :
 npm install jest --save-dev

Comme pour chaque hook, accédez à votre répertoire de hooks, créez un nouveau fichier,
nommez-le et rendez-le exécutable. À partir de là, écrivez un script qui exécute des tests sur
tous les fichiers mis à disposition avant la livraison. Voici un modèle approximatif :

#!/bin/sh

# Stash unstaged changes (optional but recommended)

git stash -q --keep-index

# Run tests on staged files

npm test # Replace with the appropriate test command
TEST_RESULT=$?

# Unstash the stashed changes (optional but recommended)

git stash pop -q

# Exit with the test's exit code

exit $TEST_RESULT

Lorsque vous tentez de valider des modifications, le hook exécute vos tests sur les fichiers
mis à disposition. La livraison sera interrompue en cas d’échec des tests, et vous devrez
résoudre les problèmes avant de procéder à une nouvelle livraison.

Développer un hook pour automatiser le versionnage et le balisage

Un excellent moyen de rationaliser le processus de publication est d’automatiser le

versionnage et le marquage dans Git. Cela garantira une version cohérente dans l’ensemble
de votre base de code.

Pour commencer, choisissez un schéma de versionnement adapté à votre projet. Cela

dépasse le cadre de cet article, mais les schémas les plus courants sont le Semantic
Versioning (SemVer) ou un schéma de versionnement personnalisé.

Ensuite, décidez exactement de ce que fera votre hook. Par exemple, il pourrait lire la version
actuelle, l’incrémenter selon un schéma choisi, et mettre à jour les fichiers nécessaires avec
la nouvelle version. Vous voudrez également écrire un script pour créer des balises basées
sur la version, qui utilise les commandes Git pour créer des balises légères ou annotées.

Une fois que vous avez créé et défini les autorisations pour votre fichier, vous pouvez
commencer à écrire votre hook. Il peut s’agir d’un hook complexe et très spécifique qui peut
même changer d’un projet à l’autre. Cependant, la plupart des hooks de ce type
comprendront les éléments suivants :

Une fonction qui incrémente une partie spécifiée d’une chaîne de version (par exemple,
1.2.3) et renvoie la nouvelle version.
La possibilité de lire la version actuelle à partir d’un fichier de version dédié.
Une fonction permettant de calculer le nouveau numéro de version, y compris la partie
spécifique à incrémenter. Par exemple, 0 pour la version majeure, 1 pour la version
mineure, 2 pour le correctif.

À partir de là, le script doit mettre à jour le fichier de version avec le nouveau numéro, créer
une balise légère avec la nouvelle version, et éventuellement pousser la nouvelle balise vers
un dépôt distant. Une fois que vous avez validé les modifications, le hook s’assurera que
chaque validation est associée à une version et à une balise appropriées.

Il est probable que vous souhaitiez adapter davantage ce hook aux besoins de votre projet.
Par exemple, vous pourriez gérer des cas tels que la création de balises initiales, la gestion
des conflits de version et la mise à jour des références de version dans les fichiers.
Comprendre les paramètres des hooks et les variables
d’environnement
L’une des raisons pour lesquelles les hooks de Git sont si puissants est la façon dont ils
gèrent les variables dynamiques. Cependant, ce concept peut être complexe à comprendre.
Nous allons donc nous pencher sur les variables d’environnement et les paramètres des
hooks, en commençant par ces derniers.

Comment les paramètres sont transmis aux hooks

Les hooks peuvent recevoir des paramètres spécifiques de Git pour accéder à des
informations contextuelles de votre base de code principale. Git définit les paramètres
automatiquement à l’exécution, et bien que vous n’ayez pas besoin de les définir la plupart du
temps, vous pouvez avoir besoin de les déclarer. Il est essentiel de les comprendre pour
développer des hooks efficaces.

Voici une vue d’ensemble des points clés concernant les paramètres des hooks :

Les hooks Git utilisent des variables positionnelles, où $1 fait référence au premier
paramètre, $2 au deuxième paramètre, et ainsi de suite. Ces paramètres ne sont pas
arbitraires ; ils ont des significations et des objectifs spécifiques. Ainsi, bien qu’ils ne
soient pas « officiels », ils représentent des conventions acceptées pour accéder aux
valeurs des paramètres.
L’ordre des paramètres suit un modèle spécifique. Git transmet ces paramètres à votre
script de hook dans un ordre prédéterminé basé sur le contexte de l’évènement de
hook.
Les noms des variables reflètent l’objectif général des paramètres. Par exemple, $1
contient souvent le chemin d’accès à un fichier tandis que $2 peut être la source d’une
action.

Si vous ajoutez un paramètre que le hook ne peut pas appeler, le script ne pourra
généralement pas l’utiliser. Les paramètres sont spécifiques à un crochet et à un contexte
d’exécution particuliers. Pour éviter tout problème, vous ne devez utiliser que des paramètres
documentés. Cependant, vous pouvez assigner la valeur d’un paramètre positionnel à une
autre variable et l’utiliser ensuite dans votre script :

#!/bin/sh

# Assign $1 to the variable EXAMPLE

EXAMPLE=$1

# Use EXAMPLE variable

echo "The commit message file is: $EXAMPLE"

Dans ce cas, la variable EXAMPLE aura la même valeur que $1, qui est le chemin d’accès au
fichier de messages de validation. Cependant, l’utilisation des noms de variables documentés
rend votre code plus compréhensible.

Notez que dans certains cas, vous utiliserez l’entrée standard (stdin) pour définir les
paramètres, auquel cas vous devriez intégrer ces éléments dans vos hooks.

Trouver les valeurs et les définitions des paramètres des hooks Git

Parce que chaque hook Git a ses propres paramètres, vous aurez probablement besoin
d’une référence pour déterminer ce qu’ils sont pour votre application spécifique. La bonne
nouvelle, c’est qu’il y a plusieurs façons de le faire.

Par exemple, la documentation officielle des hooks Git inclut certains des paramètres les plus
courants. Cependant, la meilleure approche consiste à ouvrir l’un des exemples de hooks Git.
Ceux-ci consistent en un mini-guide sur la façon de scripter le hook et incluront des
définitions de paramètres pour vous :
 — Un exemple de fichier de hook Git en NeoVim.

Ces exemples sont un excellent moyen de se familiariser avec les hooks Git et peuvent
même vous aider à les coder.

Variables d’environnement

Les hooks Git peuvent récupérer les arguments de la ligne de commande, et stdin, comme
nous l’avons vu. Cependant, ils peuvent également récupérer des arguments de
l’environnement lui-même lorsqu’il s’exécute dans un shell bash.
Ces variables d’environnement vous permettent de personnaliser le comportement de vos
hooks Git et de prendre des décisions basées sur différents aspects du flux de travail Git. De
cette manière, vous pouvez créer des hooks Git dynamiques et adaptés au contexte. Par
exemple, vous pouvez les utiliser pour valider les messages de livraison, contrôler l’accès à
des branches spécifiques ou déclencher des actions personnalisées en fonction de l’identité
de l’auteur.

Lister toutes les variables d’environnement n’entre pas dans le cadre de cet article. Nous
vous recommandons de consulter la documentation de Git et les exemples de hooks pour
savoir quelles variables seront utilisées.

Tester les valeurs des variables d’environnement

Git définit généralement différentes variables d’environnement automatiquement en fonction

du hook qu’il appelle. En tant que tel, cela peut vous causer des problèmes si vous n’êtes pas
conscient de ce qui est défini. Par exemple, prenez le résultat suivant pour la variable
GIT_REFLOG_ACTION pour les hooks pre-rebase et post-fusion :

pre-rebase. GIT_REFLOG_ACTION=rebase
post-merge. GIT_REFLOG_ACTION=’pull other master’

Heureusement, il existe un moyen de tester ce que Git fait avec les variables
d’environnement en utilisant un petit extrait de code dans votre hook :

#!/bin/bash

echo Running $BASH_SOURCE

set | egrep GIT
echo PWD is $PWD

Pour résumer le code, la ligne 2 affiche le script en cours d’exécution ; la ligne 3 affiche
toutes les variables d’environnement, puis les filtre pour celles dont le nom contient « GIT » ;
la ligne 4 affiche le répertoire de travail actuel.

Une fois que vous aurez exécuté ce script, vous verrez apparaître les données correspondant
aux variables d’environnement associées à votre hook. À partir de là, vous aurez les
connaissances nécessaires pour vous assurer que vos propres hooks Git peuvent utiliser les
variables d’environnement comme vous le souhaitez.

Trucs et astuces pour gérer et partager vos hooks Git

La gestion des hooks Git au sein d’une équipe ou d’une organisation est cruciale pour
garantir des pratiques de développement cohérentes et automatiser vos flux de travail de
manière efficace. Par exemple, prenez le simple fait d’assigner un répertoire de hooks dédié.
Il y a deux conseils que nous pouvons vous donner ici :

Créez un dépôt central ou un emplacement partagé où vous stockez les hooks

standardisés. Vous pouvez réutiliser ces hooks dans plusieurs projets et cloner ou créer
un lien vers le référentiel pour fournir un accès global.
Organisez vos hooks dans un registre ou une structure de répertoire. Cela permettra à
votre équipe de trouver et d’utiliser facilement les hooks dont elle a besoin.

La documentation est d’autant plus importante que les hooks sont susceptibles d’être utilisés
dans plusieurs projets. Vous devez maintenir une documentation complète qui décrit l’objectif,
l’utilisation et les options de configuration de chaque hook dans le dépôt. Les revues de code
et les stratégies de mise à jour pour ces hooks globaux seront également essentielles.

Nous vous recommandons également de stocker les hooks personnalisés dans le système
de contrôle de version (Version Control System ou VCS) avec la base de code de votre
projet. Cela permet de s’assurer que toute l’équipe a accès à l’ensemble de la bibliothèque de
hooks.

Utiliser les hooks Git côté serveur

Les hooks côté serveur s’exécutent sur le serveur qui héberge le dépôt central de Git. Ainsi,
vous pouvez appliquer des politiques, effectuer des vérifications ou déclencher des actions
côté serveur.
Vous avez deux options de stockage pour vos hooks côté serveur : dans le VCS avec votre
projet ou dans des dépôts séparés.

Stockage des hooks côté serveur à l’aide d’un VCS

L’utilisation de votre VCS pour stocker les hooks côté serveur présente deux avantages. Tout
d’abord, vous pouvez vous assurer que les hooks ont les mêmes versions et la même
maintenance que le reste de votre base de code. Deuxièmement, vous n’aurez besoin de
cloner qu’un seul dépôt pour accéder à la fois au code du projet et aux hooks.

Cependant, en fonction de la nature des hooks spécifiques, le fait de les stocker dans le
même dépôt peut poser des problèmes de sécurité si ces hooks accèdent à des informations
sensibles. De plus, si les hooks sont complexes ou nécessitent des configurations
spécifiques, cela peut augmenter la complexité de votre répertoire principal.

Stocker les hooks côté serveur dans des dépôts séparés

Le fait de conserver les hooks côté serveur dans des dépôts séparés vous permet de les
mettre à jour et de les versionner indépendamment de votre base de code, ce qui peut
réduire les conflits potentiels. Cette modularité peut offrir une plus grande flexibilité.

De plus, vous pouvez stocker ces hooks dans des dépôts à accès restreint. Cela vous aidera
à réduire le risque d’exposition de données sensibles.

En revanche, la maintenance de plusieurs dépôts peut nécessiter des efforts

supplémentaires. De plus, si les hooks reposent sur des versions spécifiques de votre base
de code principale, il peut être difficile de coordonner les changements entre vos dépôts.

Automatiser l’installation des hooks

L’automatisation de l’installation des hooks dans plusieurs dépôts permet de gagner du temps
et d’assurer la cohérence de votre flux de développement. En utilisant des scripts et des
modèles, vous pouvez facilement installer des hooks dans différents dépôts sans intervention
manuelle.
Le processus commence par un dépôt dédié qui contient vos hooks globaux. Vous voudrez
les normaliser : par exemple, évitez de coder en dur des chemins ou des valeurs spécifiques
à un seul dépôt.

À partir de là, vous pouvez commencer à écrire votre script d’installation. Par exemple, le
pseudo-code suivant clonera le dépôt modèle d’un hook et copiera (ou « symlink ») les hooks
dans le répertoire .git/hooks de chaque dépôt :

# Example installation script

# Usage: ./install_hooks.sh /path/to/repository
TEMPLATE_REPO="https://github.com/yourusername/hooks-template.git"
REPO_PATH="$1"
REPO_NAME=$(basename "$REPO_PATH")

# Clone the template repository

git clone --depth 1 "$TEMPLATE_REPO" "$REPO_NAME-hooks"

# Copy or symlink hooks to the repository

cp -r "$REPO_NAME-hooks/hooks" "$REPO_PATH/.git/"
rm -rf "$REPO_NAME-hooks"
echo "Hooks installed in $REPO_NAME”

Une fois que vous avez sauvegardé vos modifications, vous pouvez exécuter le script
d’installation pour chaque dépôt où vous voulez installer les hooks :

./install_hooks.sh /path/to/repository1
./install_hooks.sh /path/to/repository2
# …
Apportez des modifications au dépôt de modèles chaque fois que vous avez besoin de mettre
à jour ou d’ajouter des hooks. La prochaine fois que vous exécuterez le script d’installation
dans un dépôt, les hooks mis à jour seront installés.

Modèles Git

Les modèles Git vous permettent de définir des hooks et des configurations communes pour
de nouveaux dépôts. Ils fournissent une approche systématique pour vous aider à
automatiser les réglages, les configurations et d’autres éléments lorsque vous créez ou
clonez de nouveaux dépôts. Ainsi, vous pouvez vous assurer que chaque dépôt adhère à vos
pratiques habituelles et établies.

Une fois que vous avez créé un dépôt modèle et ajouté vos scripts de hooks, vous pouvez
configurer Git pour qu’il utilise le répertoire comme modèle pour les nouveaux dépôts. Vous
pouvez configurer cela de manière globale ou locale pour chaque utilisateur.

Pour les configurations globales, pointez vers votre répertoire de modèles de crochets :

git config --global init.templateDir /path/to/hooks-template

Pour les configurations locales, vous pouvez spécifier le répertoire exact :

git init --template=/path/to/hooks-template

Lorsque vous créez un nouveau dépôt à l’aide de git init ou que vous clonez un dépôt
existant, Git copie automatiquement le contenu de votre répertoire de modèles de hooks dans
le répertoire .git du nouveau dépôt.
Enfin, bien que les modèles de hooks puissent être génériques, vous pouvez également
autoriser des hooks de personnalisation basés sur des besoins spécifiques. Par exemple, un
script pourrait vérifier la présence d’un fichier de configuration de hook spécifique au dépôt et
l’utiliser s’il est présent.

Pratiques typiques pour vous aider à maintenir des hooks

Git sécurisés
L’utilisation des hooks Git peut être puissante pour l’automatisation des processus et
l’application de pratiques typiques. Cependant, cela peut entraîner des vulnérabilités si vous
ne gérez pas suffisamment bien vos hooks.

Voici une liste rapide de pratiques que vous pourriez mettre en œuvre pour vos propres
hooks :

Assurez-vous d’examiner et de restreindre les autorisations pour les hooks, en

particulier s’il s’agit d’exemples tiers.
Validez et assainissez toujours vos paramètres d’entrée afin de limiter les injections de
code. Utilisez des pratiques sûres, en évitant par exemple d’utiliser directement les
données d’entrée de l’utilisateur dans vos scripts.
Assurez-vous que les hooks ne contiennent pas d’informations confidentielles. C’est là
que les variables d’environnement ou le stockage sécurisé offrent une valeur immense.
Examinez et testez régulièrement les hooks afin d’éviter toute consommation
involontaire de ressources. Cela pourrait même entraîner des attaques par déni de
service distribué (DDoS).

Vous devrez également mettre en œuvre un processus de test et d’examen complet et

approfondi. Cela vous aidera à réduire les vulnérabilités et autres erreurs à l’avenir.

Validation

Nous devrions parler davantage de la mise en œuvre d’une validation et d’une gestion des
erreurs appropriées pour vos hooks. Ceci est crucial pour assurer la fiabilité, la stabilité et la
sécurité.
Par exemple, vous devez toujours valider les entrées ou les paramètres que vos scripts de
hooks reçoivent. Cependant, vous pouvez faire beaucoup plus pour assurer une bonne
validation. Vous pouvez vous assurer que le dépôt est dans l’état attendu pour que le hook
s’exécute bien. Par exemple, dans un hook pre-commit, vérifiez que vous mettez en staging
les fichiers nécessaires avant le commit.

— Une partie d’un fichier hook Git montrant le code exit 0 comme ligne de fin.

La gestion des erreurs sera également précieuse. Les codes de sortie sont tout aussi
cruciaux dans les hooks que dans votre base de code, tout comme les journaux d’erreurs et
les messages d’erreurs informatifs. l’objectif doit être de parvenir à un « échec en douceur »,
comme c’est le cas pour les bases de code plus importantes.

Bien entendu, dans un scénario réel, vos hooks peuvent nécessiter une validation plus
complexe et une logique de gestion des erreurs. Cela signifie que des tests réguliers sont
encore plus importants qu’auparavant.
Actions destructrices accidentelles

Les accidents se produisent, c’est pourquoi il est crucial de configurer vos hooks Git pour
empêcher ces actions destructrices non désirées afin de se prémunir contre la perte ou
l’endommagement de données. Les hooks peuvent essentiellement agir comme des filets de
sécurité en invitant l’utilisateur à effectuer des actions potentiellement dangereuses.

Les hooks pre-receive et de pre-commit fonctionnent bien ici. Voyons rapidement comment
ces deux types de hooks peuvent vous aider :

Les hooks pre-receive permettent d’effectuer des vérifications côté serveur. Cela
se déclenchera avant d’accepter de nouvelles branches ou de nouveaux tags de la part
du client. Votre script doit examiner les références entrantes, vérifier les actions telles
que les poussées de force ou les suppressions de branches, et demander à l’utilisateur
de confirmer. Vous voudrez également analyser les références poussées pour
déterminer si elles impliquent des actions telles que la poussée forcée (--force) ou la
suppression de branches.
Les hooks pre-commit fonctionnent côté client et s’exécutent avant que vous ne
finalisiez une livraison. Bien qu’ils n’empêchent pas directement les actions
destructrices sur le serveur, ils peuvent aider à prévenir les erreurs locales avant la
livraison. Votre script doit analyser les modifications mises en scène et rechercher des
éléments tels que les commandes force push dans les messages de validation. À
partir de là, affichez un message d’avertissement ou d’erreur à l’intention de l’utilisateur.

Cependant, quelles que soient les pratiques que vous mettez en œuvre, elles doivent être
sûres, efficaces et adaptées à vos besoins. Pour cela, vous devez mettre en place une
stratégie d’examen et de test approfondie.

Examiner et tester les hooks Git

Il est essentiel de réviser et de tester les hooks pour s’assurer qu’ils fonctionnent
correctement et qu’ils s’alignent sur votre flux de développement. Des évaluations par les
pairs, une documentation claire, une abondance de commentaires et bien d’autres choses
encore permettent de s’assurer que les hooks sont prêts pour la production.
En ce qui concerne les tests, il est important de les effectuer de manière isolée en utilisant
divers échantillons de données. Vous pouvez également mettre en œuvre des tests de
régression ou d’intégration automatisés.

Enfin, nous vous conseillons de tester les hooks dans différents environnements (tels que vos
serveurs de développement, de staging et de production) pour vous assurer qu’ils ont un
comportement cohérent. Une configuration de journalisation en temps réel vous sera utile à
cet égard, car elle vous permettra de voir ce qui se passe lorsque les données se déplacent
d’un serveur à l’autre.

Comment dépanner vos hooks

Comme pour toute base de code, il se peut que vous ayez à dépanner vos hooks, même
après plusieurs tentatives. En fait, quel que soit votre type de hook Git, vous constaterez que
les mêmes erreurs se répètent. Il s’agit souvent de problèmes simples qui affectent tous les
types de projets, comme les erreurs de syntaxe, les problèmes de permissions, l’utilisation de
chemins relatifs ou codés en dur, et bien plus encore.

Cependant, c’est aussi une bonne idée de vérifier s’il manque des dépendances, car certains
hooks reposent sur des outils, des fichiers ou des bibliothèques externes. Vous devez donc
les rendre disponibles dans l’environnement où vous exécutez le hook.

Il y a des problèmes spécifiques qui peuvent survenir avec les hooks Git. Par exemple, les
hooks doivent sortir avec un code d’état non nul pour indiquer un échec. De plus, les hooks
ne doivent pas contenir de boucles infinies. Si ces deux conditions ne sont pas remplies, vous
risquez de provoquer des comportements inattendus et de perturber votre flux de travail.

Vous pouvez également constater que les conflits entre deux hooks entraînent des
interactions et des conséquences inattendues. Ce que l’on appelle les « race conditions »
peuvent également entraver vos attentes. C’est le cas lorsque deux hooks ou plus se
déclenchent à la suite d’évènements similaires, mais que l’un se termine avant l’autre – ce qui
aura un impact sur le résultat final que vous attendez.

C’est là que les révisions et les tests deviennent vitaux. Il est également important de tenir à
jour la documentation afin d’éviter les problèmes et de s’assurer que les hooks fonctionnent
comme vous l’attendez.
En parlant de documentation, le matériel de référence de Git est une lecture essentielle. En
fait, avec cet article et peut-être le site indépendant du guide Git Hooks (en utilisant les pages
GitHub), vous ne devriez pas avoir besoin de trop de matériel de lecture.

— Le site du guide Git Hooks.

Cependant, vous pouvez également vous intéresser aux applications qui vous aident à gérer
les Git Hooks. Lefthook est régulièrement mis à jour et bénéficie d’un support important sur
GitHub, tandis que Husky est très utile pour réduire en charpie vos messages de validation.

Les avantages de l’intégration des hooks dans les

pipelines d’intégration continue (CI/CD)
Les pipelines CI/CD fonctionnent bien avec les hooks Git, car ces scripts peuvent vous aider
à automatiser des tâches, à assurer une qualité constante et à fournir des contrôles de
sécurité.

Par exemple, les hooks de pre-commit vous permettent d’exécuter des contrôles de qualité
du code, tels que le linting, l’analyse statique et le formatage. En ce qui concerne les tests,
vous pouvez déclencher des tests unitaires, des suites de tests ou d’autres contrôles
automatisés au stade de pre-commit. D’autre part, les hooks pre-push vous permettent
d’exécuter des tests d’intégration, des analyses de sécurité, etc.

L’utilisation de hooks dans vos pipelines CI/CD présente de nombreux avantages :

Cohérence. Les hooks vous permettent d’appliquer des pratiques cohérentes à tous les
commits et déploiements, ce qui réduira le nombre d’erreurs.
Contrôles automatisés. Vous pouvez automatiser les contrôles de qualité du code, les
tests, les analyses de sécurité et d’autres tâches importantes. Cela réduira les efforts
manuels et vous laissera plus de temps à consacrer à d’autres tâches.
Détection précoce des problèmes. Les hooks vous permettent de détecter les
problèmes à un stade précoce du processus de développement, ce qui les empêche de
se propager dans votre pipeline.
Réduction des risques de déploiement. Grâce aux vérifications et aux tests
automatisés déclenchés par les hooks, le risque de déployer un code défectueux peut
être considérablement réduit.

Comme l’API de Kinsta vous permet de mettre en place des pipelines CI/CD, vous pouvez
également y intégrer des hooks Git. Kinsta vous permet de récupérer l’intégralité de votre
dépôt à partir d’un emplacement distant et autorise les poussées à l’aide d’une extension
tierce telle que WP Pusher.
 — La page d’accueil de WP Pusher.

Bien sûr, cela signifie également que vous avez la possibilité d’utiliser des hooks Git. Ainsi,
votre installation Kinsta peut tirer parti de ces puissants scripts au sein de votre dépôt.

Résumé
Git est un outil essentiel pour tout projet de développement, mais un de ses aspects, en
particulier, pourrait dynamiser votre flux de travail de codage et de déploiement. Les hooks
Git vous permettent de créer des scripts utilisant un certain nombre de langages pour
automatiser divers aspects de votre processus de contrôle de version. Il s’agit d’un concept
simple dont les dessous sont quelque peu complexes.

Notre article vous montre comment utiliser des techniques avancées pour tirer le meilleur
parti des hooks Git. Vous pouvez les utiliser à la fois localement et côté serveur, les rendre
dynamiques en utilisant des paramètres et des variables, travailler avec plusieurs dépôts
distants, et plus encore. En fait, nous pensons qu’à ce stade, les hooks Git pourraient devenir
votre arme secrète pour améliorer la productivité, la qualité du code et le temps d’exécution
des projets.

Vous avez des questions concernant les hooks Git et leur utilisation ? N’hésitez pas à nous
en faire part dans les commentaires ci-dessous !