Git Hooks y automatización

Descubre cómo utilizar los Git Hooks para automatizar tus procesos de desarrollo.

Git Hooks básicos

Configuración

# 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 habituales

# 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..."

Ejemplos prácticos

Verificación del código

# 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

Validación de los mensajes

# 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

Despliegue automático

# 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 para Node.js

Instalación

# Installer Husky
npm install husky --save-dev

# Initialiser Husky
npx husky install

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

Configuración

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

Git Hooks con Python

Ejemplo 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()

Integración continua

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

Buenas prácticas

1. Seguridad

   • Verificar las dependencias
   • Escanear el código
   • Validar los secretos
   • Proteger las ramas

2. Rendimiento

   • Hooks ligeros
   • Tests rápidos
   • Caché de los resultados
   • Paralelización

3. Mantenimiento

   • Documentación clara
   • Tests de los hooks
   • Gestión de errores
   • Logs detallados

Conclusión

Puntos clave que recordar:

• Automatización de los procesos
• Validación del código
• Despliegue automático
• Integración continua

Recomendaciones:

• Elegir los hooks adecuados
• Automatizar los tests
• Asegurar los procesos
• Seguir las buenas prácticas
• Formarse en Git