Tutorial de GitFlow: ramificación para funcionalidades, lanzamientos y hotfixes

Configurar GitFlow

Antes de aprovechar el modelo de ramificación estructurado de GitFlow, tienes que instalarlo en tu equipo e inicializarlo en tu repositorio. Por suerte, ambos pasos son sencillos.

Para usar GitFlow, ya deberías tener Git instalado en tu máquina. Puedes leer más sobre cómo instalar Git en el Git Install Tutorial.

Instalar GitFlow

GitFlow es una extensión de Git, así que tendrás que instalarla por separado. De forma predeterminada, no viene incluida con Git. El proceso de instalación depende de tu sistema operativo.

Para instrucciones detalladas sobre cómo instalar GitFlow, lee la documentación oficial.

Nota: aunque la extensión de GitFlow facilita la gestión de ramas de funcionalidades, releases y hotfixes con comandos simples, no es estrictamente necesaria. Puedes seguir el flujo de trabajo de GitFlow utilizando comandos estándar de Git—siempre que seas consistente con las convenciones de nombres y las prácticas de fusión. La herramienta simplemente automatiza y refuerza el proceso, algo útil para equipos o proyectos grandes.

macOS

Si usas Homebrew, el gestor de paquetes más popular en macOS, ejecuta:

brew install git-flow-avh

Linux (basado en Debian/Ubuntu)

Si usas un sistema basado en Debian como Ubuntu, utiliza:

sudo apt-get install git-flow

Windows

En Windows, puedes instalar GitFlow a través de Git for Windows y añadir Git Bash a tu terminal.

Para comprobar si GitFlow está instalado, ejecuta:

git flow version

Inicializar GitFlow en un repositorio

Como primer paso, necesitas tener un repositorio Git inicializado antes de usar GitFlow. Puedes leer más en How to Initialize and Set Up a Git Repository.

Una vez instalado GitFlow, puedes inicializarlo en cualquier repositorio Git existente con:

git flow init

GitFlow te pedirá configurar varios ajustes. Aquí tienes un desglose de qué significan y cómo elegir los adecuados:

1. Nombres de ramas: se te pedirán los nombres por defecto.
1. Nombre de la rama de producción (por defecto: master)
2. Nombre de la rama de desarrollo (por defecto: develop)
2. Prefijos para ramas de soporte: GitFlow usa convenciones de nombres para sus distintos tipos de ramas.
1. Ramas de funcionalidades: feature/
2. Ramas de bugfix: bugfix/
3. Ramas de release: release/
4. Ramas de hotfix: hotfix/
5. Ramas de soporte: support/ (raramente usadas en la práctica)
6. Prefijo de etiqueta de versión: v (p. ej., v.1.2.0)

Los valores por defecto funcionan bien para la mayoría de equipos, pero puedes personalizarlos para que coincidan con los estándares de tu organización.

Ejemplo de salida de la inicialización:

git flow init

Which branch should be used for bringing forth production releases?
   - master
Branch name for production releases: [master]
Branch name for "next release" development: [develop]

How to name your supporting branch prefixes?
Feature branches? [feature/]
Bugfix branches? [bugfix/]
Release branches? [release/]
Hotfix branches? [hotfix/]
Support branches? [support/]
Version tag prefix? [] v

Tras inicializar, puedes hacer push de la rama develop a tu repositorio remoto. Puedes leer más sobre cómo hacer push y pull de ramas en el Git Push and Pull Tutorial.

Usar GitFlow para desarrollar

Una vez que GitFlow está inicializado en tu repositorio, puedes empezar a usar su modelo de ramificación para gestionar tu flujo de desarrollo. GitFlow ofrece comandos de alto nivel para trabajar con funcionalidades, releases y hotfixes, lo que facilita mantener el orden y evitar el caos en Git.

En los siguientes subcapítulos, veremos GitFlow en la práctica.

Crear ramas de funcionalidades

Las ramas de funcionalidades se usan para desarrollar nueva funcionalidad sin afectar a la base de código principal.

Puedes crear una rama de funcionalidad ejecutando:

git flow feature start <feature-name>

Este comando crea una nueva rama desde develop llamada feature/<feature-name>. Ya puedes empezar a desarrollar tu funcionalidad y hacer commits como de costumbre.

Finalizar ramas de funcionalidades

Cuando tu funcionalidad esté completa y probada, puedes finalizarla con: 

git flow feature finish <feature-name>

Esto hace lo siguiente:

• Fusiona tu rama de funcionalidad en la rama develop.
• Elimina la rama local feature/<feature-name>.

Si aparecen conflictos de fusión, resuélvelos manualmente y completa la fusión usando el flujo estándar de resolución de conflictos de Git.

Si trabajas en equipos grandes donde primero hay que crear y revisar pull requests, no puedes usar directamente el comando finish de GitFlow; en su lugar, haz lo siguiente:

1. Haz commit de tu trabajo y luego sube la rama:

git push origin feature/<feature-name>

2. Crea un pull request de feature/<feature-name> hacia develop en GitHub, GitLab, etc.
3. Pide revisión, ejecuta tests y consigue aprobaciones.
4. Una vez aprobado, fusiona desde la interfaz de la plataforma y elimina la rama.

Si quieres aprender más sobre GitHub y cómo usarlo, te recomiendo los cursos GitHub Foundations y GitHub Concepts. En otros equipos, quizá sigas el flujo estándar de git flow feature finish, pero deberás pedir una revisión de tu rama antes de fusionarla de vuelta en develop y ejecutar tests sobre tus cambios para asegurar el comportamiento correcto.

Crear ramas de release

Las ramas de release se crean para preparar una nueva versión de producción sin bloquear el desarrollo en curso en la rama develop.

Para iniciar un release, ejecuta:

git flow release start <version-number>

Esto crea una nueva rama llamada release/<version-number>. Esta rama sale de develop.

En esta rama, normalmente finalizas números de versión, corriges bugs menores y actualizas documentación y changelogs.

Finalizar ramas de release

Cuando tu release esté listo para producción, termínalo con:

git flow release finish <version-number>

Este comando:

• Fusiona la rama de release tanto en master como en develop.
• Etiqueta el release en master (p. ej., v1.0.0).
• Elimina la rama local release/<release-number>.

No olvides subir tus cambios y etiquetas:

git push origin master
git push origin develop
git push --tags

# o en corto
git push origin master develop --tags

Crear ramas de hotfix

Los hotfixes se usan para arreglos urgentes en producción cuando se encuentra un bug en la rama master.

Para iniciar un hotfix:

git flow hotfix start <version-number>

Esto crea una rama hotfix/<version-number> a partir de master. Ahora puedes aplicar los cambios y hacer commit del arreglo.

Cuando termines, finalízalo con:

git flow hotfix finish <version-number>

Esto:

• Fusiona el hotfix en master y develop.
• Etiqueta el arreglo en master.
• Elimina la rama local `hotfix/<version-number>`.

Sube tus cambios locales y las etiquetas como siempre:

git push origin master develop --tags

Los hotfixes son especialmente potentes porque te permiten corregir rápidamente problemas en producción sin interferir con el desarrollo en curso en la rama develop.

Imagina que ya hay nuevas funcionalidades fusionadas en develop que aún no quieres lanzar, pero aparece un bug urgente y grave en producción que hay que arreglar. 

Aquí es donde brillan los hotfixes: se ramifican desde master y luego solo se fusionan de vuelta en develop.

Ejemplo de ramificación con GitFlow

Vamos a repasar dos flujos comunes, un ciclo de desarrollo de una funcionalidad y un release con un hotfix, para ver GitFlow en acción y compararlo con los comandos tradicionales de Git.

Al ver ambos enfoques, entenderás mejor cómo la extensión GitFlow simplifica el proceso agrupando varios pasos de Git en comandos simples y estandarizados.

Si necesitas un repaso rápido de los comandos tradicionales de Git, te recomiendo la Complete Git Cheat Sheet. Si quieres una vista rápida de Git, te recomiendo leer GitHub and Git Tutorial for Beginners.

Flujo de trabajo de una funcionalidad

Supón que vas a implementar una nueva funcionalidad que permite a los usuarios autenticarse en tu aplicación. Llamas a esta funcionalidad user-authentication.

Usando GitFlow:

git flow feature start user-authentication

# Trabaja en la funcionalidad
git add .
git commit -m "feat: Implement basic user authentication"

# Cuando termines:
git flow feature finish user-authentication

git push origin develop

Ahora con Git normal:

# Crea y cambia manualmente a una nueva rama
git checkout -b feature/user-authentication develop

# Trabaja en la funcionalidad
git add .
git commit -m "Implement basic user authentication"

# Cuando termines
git checkout develop
git merge feature/user-authentication
git branch -d feature/user-authentication
git push origin develop

Como ves, GitFlow reduce el número de comandos y, por tanto, la complejidad. También es menos propenso a errores, como fusionar por accidente en la rama equivocada.

Para aprender más sobre cómo funciona la fusión en Git, lee Git Merge Tutorial: A Comprehensive Guide with Examples.

Ahora supongamos que estás preparando el release 1.0.0. Pero poco después de lanzarlo, se detecta un bug crítico que hay que arreglar con un hotfix. 

Usando GitFlow:

# Inicia un release
git flow release start 1.0.0

# Ajustes finales, actualiza números de versión
git commit -am "Prepare release v1.0.0"

# Finaliza el release
git flow release finish 1.0.0
git push origin master develop --tags

Ahora has encontrado el bug y necesitas crear un hotfix:

# Inicia un hotfix
git flow hotfix start 1.0.1

# Aplica el arreglo
git commit -am "Fix login issue in production"

# Finaliza el hotfix
git flow hotfix finish 1.0.1
git push origin master develop --tags

Y hacer todo esto de nuevo con comandos de Git tradicionales:

# Release manual
git checkout -b release/1.0.0 develop

# Realiza cambios
git commit -am "Prepare release v1.0.0"

# Fusiona manualmente
git checkout master
git merge release/1.0.0
git tag -a v1.0.0 -m "Release v1.0.0"
git checkout develop
git merge release/1.0.0

# Elimina la rama de release
git branch -d release/1.0.0
git push origin master develop --tags

# Hotfix manual
git checkout -b hotfix/1.0.1 master

# Aplica el arreglo
git commit -am "Fix login issue in production"
git checkout master
git merge hotfix/1.0.1
git tag -a v1.0.1 -m "Hotfix v1.0.1"
git checkout develop
git merge hotfix/1.0.1

# Elimina la rama de hotfix
git branch -d hotfix/1.0.1
git push origin master develop --tags

Buenas prácticas al usar GitFlow

GitFlow es muy potente y te ayuda a gestionar el código de tu equipo. Sin embargo, para sacarle el máximo partido, conviene seguir algunas buenas prácticas.

Estas prácticas ayudan a mantener ramas limpias, reducir conflictos de fusión y mejorar la productividad del equipo, sobre todo en entornos colaborativos.

Nomenclatura consistente de ramas

La coherencia es clave al colaborar. Mantén las convenciones de nombres por defecto de GitFlow salvo que tu equipo tenga una razón de peso para personalizarlas.

Patrones recomendados:

• Ramas de funcionalidades: feature/<feature-name>
• Ramas de release: release/<version-number>
• Ramas de hotfix: hotfix/<version-number>

Usa kebab-case para nombres con varias palabras (p. ej., feature/user-authentication).

Cambios pequeños y frecuentes

Las ramas de larga duración suelen derivar en fusiones dolorosas y pull requests enormes que cuesta revisar. 

Lo sé por experiencia: ya he pasado varias veces por el infierno de los conflictos de fusión, y te conviene evitarlo si puedes.

En su lugar, mantén las ramas de funcionalidades de vida corta y centradas en una sola tarea. Haz commit y push con regularidad para no perder trabajo ni alejarte demasiado de develop.

Cambios pequeños e incrementales son más fáciles de probar, revisar e integrar.

Sincronízate con develop con regularidad

Cuando trabajes en una rama de funcionalidad, no te quedes atrás. Asegúrate de traer con frecuencia los últimos cambios de la rama develop para minimizar conflictos de fusión más adelante:

git checkout feature/<your-feature>
git fetch origin
git rebase origin/develop

Mantenerte sincronizado hace que la integración sea más fluida y que tus cambios sigan siendo compatibles con lo que están construyendo otras personas.

Revisa y prueba antes de fusionar

Aunque GitFlow permite fusionar directamente con comandos como git flow feature finish, lo mejor es usar pull requests (PR) o merge requests (MR) para todas las fusiones hacia develop y master.

Ventajas:

• Permite flujos de revisión y aprobación de código
• Dispara comprobaciones automáticas de CI/CD
• Aporta una trazabilidad clara de los cambios

Esto es especialmente crítico en entornos de producción donde importa el control de calidad.

Solución de problemas en GitFlow

Incluso con un flujo estructurado como GitFlow, pueden surgir problemas, sobre todo al trabajar en equipo o con ramas de larga duración. 

En esta sección cubrimos los retos más comunes y cómo resolverlos con eficacia.

Conflictos de fusión

Los conflictos de fusión son habituales cuando varias personas trabajan en la misma base de código y son molestos.Suelen darse cuando dos ramas han modificado las mismas líneas de código.

Pasos para resolver un conflicto de fusión:

1. Detén el proceso de git flow finish.
2. Fusiona manualmente la rama en su destino:

git checkout develop
git merge feature/<your-feature>

3. Git te pedirá resolver los conflictos. Abre los archivos en conflicto y busca los marcadores como estos:

<<<<<<< HEAD
Code from develop
=======
Code from feature branch
>>>>>>> feature/my-feature

4. Edita y limpia el código manualmente.
5. Una vez resuelto, marca los archivos como resueltos:

git add <resolved-file>

6. Luego completa la fusión con:

git commit -m “resolve merge conflict …”

Limpiar ramas obsoletas

A veces, tu repositorio acumula ramas feature, release o hotfix desactualizadas. Para evitar confusiones, mantén tu repositorio lo más limpio posible.

Puedes solucionarlo siguiendo estos pasos:

1. Lista todas las ramas locales:

git branch

2. Elimina una rama local:

git branch -d <branch-name>

3. Si la rama no se ha fusionado todavía y estás seguro de que se puede eliminar:

git branch -D <branch-name>

4. Elimina una rama remota:

git push origin --delete <branch-name>

Es fundamental revisar con regularidad tus ramas y limpiar las obsoletas para mantener el repositorio en buen estado.

Conclusión

GitFlow es un marco sólido para aportar colaboración, claridad y control a tu flujo de desarrollo. Ya sea en un proyecto en solitario con más gente implicada o en un equipo grande, GitFlow te ayuda a mantener el orden separando con claridad el desarrollo de funcionalidades, los lanzamientos y los hotfixes.

Cuando empecé a usar GitFlow, fue un antes y un después. Se acabó el caos de fusiones. Se acabaron las dudas sobre qué rama usar. Cada tarea tenía su sitio y cada release seguía un proceso repetible y fiable. Con el tiempo, he introducido GitFlow en todos los equipos con los que he trabajado. Y siempre ha traído más estructura, colaboración más fluida y menos errores.

En este tutorial has aprendido:

• Qué es GitFlow y por qué es útil
• Cómo instalar e inicializar GitFlow
• Cómo trabajar con funcionalidades, releases y hotfixes
• Buenas prácticas para evitar problemas comunes
• Cómo adaptar GitFlow a flujos modernos usando pull requests

Si estás listo para llevar tu flujo de trabajo con Git al siguiente nivel, prueba GitFlow en tu próximo proyecto. Y si ya dominas lo básico, empieza a plantearte integrarlo con la pipeline de CI/CD de tu equipo, el proceso de revisión o incluso con GitHub Actions.