Git Hooks et Automatisation

Découvrez comment utiliser les Git Hooks pour automatiser vos processus de développement.

Git Hooks de Base

Configuration

# Activer les hooks
git config core.hooksPath .git/hooks

# Créer un hook pre-commit
touch .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

Hooks Courants

# pre-commit
#!/bin/sh
# Exécuté avant chaque commit
echo "Vérification du code..."

# post-commit
#!/bin/sh
# Exécuté après chaque commit
echo "Notification envoyée..."

# pre-push
#!/bin/sh
# Exécuté avant chaque push
echo "Tests en cours..."

# post-merge
#!/bin/sh
# Exécuté après chaque merge
echo "Mise à jour des dépendances..."

Exemples Pratiques

Vérification du Code

# pre-commit
#!/bin/sh

# Vérifier le formatage
echo "Vérification du formatage..."
npm run lint

# Exécuter les tests
echo "Exécution des tests..."
npm test

# Vérifier les types
echo "Vérification des types..."
npm run type-check

Validation des Messages

# commit-msg
#!/bin/sh

# Vérifier le format du message
commit_msg=$(cat "$1")
if ! echo "$commit_msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?: .+"; then
    echo "Format de message invalide"
    echo "Utilisez: type(scope): description"
    exit 1
fi

Déploiement Automatique

# post-push
#!/bin/sh

# Déployer en staging
if [ "$(git rev-parse --abbrev-ref HEAD)" = "develop" ]; then
    echo "Déploiement en staging..."
    npm run deploy:staging
fi

# Déployer en production
if [ "$(git rev-parse --abbrev-ref HEAD)" = "main" ]; then
    echo "Déploiement en production..."
    npm run deploy:prod
fi

Husky pour Node.js

Installation

# Installer Husky
npm install husky --save-dev

# Initialiser Husky
npx husky install

# Ajouter un hook
npx husky add .husky/pre-commit "npm test"

Configuration

// package.json
{
  "scripts": {
    "prepare": "husky install"
  },
  "husky": {
    "hooks": {
      "pre-commit": "npm test",
      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
    }
  }
}

Git Hooks avec Python

Exemple de Hook

#!/usr/bin/env python3
# pre-commit

import sys
import subprocess

def run_tests():
    try:
        subprocess.run(['pytest'], check=True)
    except subprocess.CalledProcessError:
        print("Les tests ont échoué")
        sys.exit(1)

def check_formatting():
    try:
        subprocess.run(['black', '--check', '.'], check=True)
    except subprocess.CalledProcessError:
        print("Le formatage est incorrect")
        sys.exit(1)

if __name__ == '__main__':
    run_tests()
    check_formatting()

Intégration Continue

GitHub Actions

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Install dependencies
      run: npm install
    - name: Run tests
      run: npm test
    - name: Check formatting
      run: npm run lint

GitLab CI

# .gitlab-ci.yml
stages:
  - test
  - deploy

test:
  stage: test
  script:
    - npm install
    - npm test
    - npm run lint

deploy:
  stage: deploy
  script:
    - npm run deploy
  only:
    - main

Bonnes Pratiques

1. Sécurité

   • Vérifier les dépendances
   • Scanner le code
   • Valider les secrets
   • Protéger les branches

2. Performance

   • Hooks légers
   • Tests rapides
   • Cache des résultats
   • Parallélisation

3. Maintenance

   • Documentation claire
   • Tests des hooks
   • Gestion des erreurs
   • Logs détaillés

Conclusion

Points clés à retenir :

• Automatisation des processus
• Validation du code
• Déploiement automatique
• Intégration continue

Recommandations :

• Choisir les bons hooks
• Automatiser les tests
• Sécuriser les processus
• Suivre les bonnes pratiques
• Se former sur Git