Git Avanzado: Flujos de Trabajo Profesionales

¡Domina las técnicas avanzadas de Git! En este tutorial avanzado te guiaré paso a paso para que aprendas flujos de trabajo profesionales, rebasing, hooks y automatización que te harán más eficiente en proyectos complejos.

Objetivo: Aprender técnicas avanzadas de Git incluyendo flujos de trabajo profesionales, rebasing interactivo, hooks de automatización, submodulos y integración con CI/CD.

Paso 1: Flujos de Trabajo Profesionales

Git Flow - Para Proyectos Estructurados

# Instalación (depende del SO)
# Para macOS: brew install git-flow
# Para Linux: apt-get install git-flow

# Inicializar git-flow en tu proyecto
git flow init
# Accepta los valores por defecto o personaliza las ramas

# Comandos esenciales de git-flow:
git flow feature start nueva-funcionalidad
git flow feature publish nueva-funcionalidad
git flow feature finish nueva-funcionalidad

git flow release start 1.2.0
git flow release publish 1.2.0
git flow release finish 1.2.0

git flow hotfix start error-critico
git flow hotfix finish error-critico

GitHub Flow - Para Desarrollo Ágil

# Flujo simplificado para integración continua
# 1. Siempre tener main estable
git checkout main
git pull origin main

# 2. Crear rama descriptiva
git checkout -b add-oauth-authentication

# 3. Commits regulares con mensajes claros
git add .
git commit -m "Implementar autenticación OAuth básica"

# 4. Subir rama regularmente
git push -u origin add-oauth-authentication

# 5. Crear Pull Request temprano

# 6. Revisión y merge a través de PR

Paso 2: Rebasing Avanzado

Rebase Interactivo

# Reorganizar últimos 5 commits
git rebase -i HEAD~5

# Comandos disponibles durante rebase interactivo:
# pick - usar commit
# reword - usar commit pero editar mensaje
# edit - usar commit pero pausar para amendments
# squash - combinar commit con el anterior
# fixup - como squash pero descartar mensaje
# drop - eliminar commit

# Después de editar, guardar y cerrar el editor

Rebase con Main

# Mantener tu rama actualizada con main
git checkout mi-rama
git fetch origin
git rebase origin/main

# Resolver conflictos si los hay durante el rebase
# Luego continuar:
git rebase --continue

# O abortar si hay problemas:
git rebase --abort

Paso 3: Bisect - Encontrar Commits Problemáticos

# Iniciar bisect para encontrar un bug
git bisect start
git bisect bad                 # Marcar commit actual como malo
git bisect good v1.0.0         # Marcar un commit conocido como bueno

# Git te llevará a un commit intermedio
# Probar el código y marcar como good o bad:
git bisect good
# o
git bisect bad

# Continuar hasta encontrar el commit culpable
git bisect reset               # Finalizar la búsqueda

Paso 4: Hooks de Git - Automatización

Hooks Locales

# Los hooks están en .git/hooks/
# Ejemplo: pre-commit hook para ejecutar tests
#!/bin/sh
npm test
if [ $? -ne 0 ]; then
    echo "Tests fallaron. Commit abortado."
    exit 1
fi

# Hooks útiles:
# pre-commit - antes del commit
# prepare-commit-msg - preparar mensaje de commit
# pre-push - antes de push
# post-merge - después de merge

Husky - Hooks Modernos

// package.json configuration
{
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged",
      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
      "pre-push": "npm test"
    }
  }
}

Paso 5: Submódulos y Subtrees

Submódulos

# Añadir submódulo
git submodule add https://github.com/usuario/lib-externa.git

# Clonar repositorio con submódulos
git clone --recurse-submodules https://github.com/usuario/repo-con-submodulos.git

# Actualizar submódulos
git submodule update --init --recursive

Subtrees

# Añadir subtree
git subtree add --prefix=libs/externa https://github.com/usuario/lib-externa.git main --squash

# Traer updates del subtree
git subtree pull --prefix=libs/externa https://github.com/usuario/lib-externa.git main --squash

# Push cambios al subtree
git subtree push --prefix=libs/externa https://github.com/usuario/lib-externa.git main

Paso 6: Reflog - Tu Red de Seguridad

# Ver historial de acciones en Git
git reflog

# Recuperar commits perdidos
git reflog
# Encontrar el hash del commit perdido
git checkout [hash]
git checkout -b rama-recuperada

# Recuperar rama eliminada
git reflog
git checkout -b rama-eliminada [hash-de-ultimo-commit]

Paso 7: Trabajo con Múltiples Remotos

# Añadir múltiples remotos
git remote add upstream https://github.com/original/repo.git
git remote add fork https://github.com/mi-usuario/repo.git

# Sincronizar con upstream
git fetch upstream
git checkout main
git merge upstream/main

# Push a diferentes remotos
git push fork main
git push fork nueva-rama

# Ver diferencias entre remotos
git remote -v
git fetch --all
git diff main fork/main

Paso 8: Patches y Trabajo Offline

# Crear patch de cambios
git format-patch HEAD~3 --stdout > mis-cambios.patch

# Aplicar patch
git apply mis-cambios.patch
# o
git am mis-cambios.patch

# Trabajar offline
git add .
git commit -m "Trabajo offline"
# Más tarde, cuando tengas conexión:
git pull --rebase origin main
git push origin mi-rama

Paso 9: Custom Commands y Aliases Avanzados

# Añadir a ~/.gitconfig
[alias]
    # Alias visuales
    graph = log --all --graph --decorate --oneline
    prettylog = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)'

    # Alias funcionales
    undo = reset --soft HEAD~1
    amend = commit --amend --no-edit
    staged = diff --cached
    unstage = reset HEAD --

    # Alias de mantenimiento
    cleanup = "!git branch --merged | grep -v '\\*\\|main\\|master\\|develop' | xargs -n 1 git branch -d"
    recent = for-each-ref --sort=-committerdate refs/heads/ --format='%(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'"

Paso 10: Worktree - Múltiples Directorios de Trabajo

# Crear nuevo worktree para feature
git worktree add ../mi-proyecto-feature nueva-rama

# Trabajar en el nuevo directorio
cd ../mi-proyecto-feature

# Cuando termines, eliminar worktree
git worktree remove ../mi-proyecto-feature

Paso 11: Debugging con Git

# Buscar cuándo se introdujo una línea específica
git blame archivo.txt

# Buscar cambios en una línea específica
git log -L 10,15:archivo.txt

# Buscar commits que afectaron a un archivo
git log --follow archivo.txt

# Buscar commits por contenido
git log -S"función-eliminada"
git log -G"regex-búsqueda"

Paso 12: Seguridad y Best Practices

GPG signing

# Configurar signing de commits
git config --global commit.gpgsign true
git config --global user.signingkey [KEY-ID]

# Firmar tag
git tag -s v1.0.0 -m "Versión 1.0.0"

# Verificar commits firmados
git log --show-signature

.gitignore Avanzado

# Ignorar todo excepto...
/*
!/src/
!/package.json

# Ignorar archivos excepto algunos tipos
*.log
!important.log

# Ignorar carpetas pero mantener estructura
logs/**/*
!logs/.keep

# Ignorar según entorno
.env.*
!.env.example

Paso 13: Integración con CI/CD

# Script de CI ejemplo
#!/bin/bash
# .github/workflows/ci.yml equivalente en script

git fetch --prune --unshallow
git diff --name-only origin/main...HEAD > changed_files.txt

# Ejecutar tests solo si hay cambios relevantes
if grep -q "src/" changed_files.txt; then
    npm test
fi

if grep -q "docs/" changed_files.txt; then
    npm run build-docs
fi

Paso 14: Resolución de Conflictos Avanzada

# Usar herramientas visuales para conflictos
git mergetool

# Configurar tu herramienta preferida
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Abortar merge complejo
git merge --abort

# Guardar cambios temporales durante merge
git stash
git merge otra-rama
git stash pop
# Resolver conflictos

Paso 15: Monorepo Techniques

# Sparse checkout para repos grandes
git clone --filter=blob:none --no-checkout https://github.com/grand-repo.git
cd grand-repo
git sparse-checkout init --cone
git sparse-checkout set app/api

# Trabajar con partial clones
git clone --depth 1 https://github.com/grand-repo.git
git fetch --unshallow  # Cuando necesites historial completo

Paso 16: Recursos y Próximos Pasos

Para profundizar:

• Git internals: Entender .git directory
• Custom Git commands: Crear tus propios comandos
• Git with LFS: Para archivos grandes
• Git automation: Scripts para flujos complejos

Herramientas relacionadas:

• GitLens: Extensión de VSCode
• Tig: Cliente terminal para Git
• Lazygit: UI terminal para Git
• GitKraken: Cliente gráfico

Libros recomendados:

• "Pro Git" - Scott Chacon
• "Git Pocket Guide" - Richard E. Silverman
• "Version Control with Git" - Jon Loeliger

Conclusión

¡Felicidades! Ahora dominas técnicas avanzadas de Git que te permitirán trabajar eficientemente en proyectos complejos y equipos grandes. Practica estos conceptos en tus proyectos y explora más herramientas avanzadas.

Para más tutoriales sobre desarrollo profesional y herramientas, visita nuestra sección de tutoriales.

¡Con estos conocimientos avanzados ya puedes gestionar proyectos complejos con Git!

💡 Tip Importante

📝 Mejores Prácticas para Git Avanzado

Para trabajar profesionalmente con Git en entornos complejos, considera estos consejos avanzados:

• Elige el flujo correcto: Git Flow para proyectos estructurados, GitHub Flow para desarrollo ágil.

• Usa rebase con cuidado: Rebase mantiene el historial limpio, pero nunca en ramas compartidas.

• Automatiza con hooks: Implementa validaciones automáticas para mantener la calidad del código.

• Trabaja con submodulos estratégicamente: Úsalos solo cuando sea necesario para evitar complejidad.

• Mantén reflog como respaldo: Siempre puedes recuperar commits "perdidos" con reflog.

• Firma tus commits: Añade autenticidad y confianza a tus contribuciones.

• Integra con CI/CD: Automatiza pruebas y despliegues para flujos eficientes.

• Documenta tus procesos: Crea guías para tu equipo sobre convenciones y flujos.

📚 Documentación: Revisa la documentación completa de Git aquí y Git Flow aquí

¡Estos consejos te ayudarán a usar Git de manera profesional en proyectos de gran escala!