Flujos de Git

Gitflow para equipos grandes: ramas, releases y hotfixes

Guía práctica para usar Gitflow en equipos de ingeniería grandes: roles de las ramas, comandos paso a paso, proceso de release y hotfix, reglas de CI y errores comunes.

Diagrama de Gitflow: ramas main, develop, feature, release y hotfix a lo largo del tiempo

Gitflow es un modelo de ramas de Git que asigna a cada tipo de trabajo su propia rama y un camino fijo hacia producción. Los desarrolladores crean el trabajo nuevo desde develop, los candidatos a versión se cortan en ramas release/* y solo el código liberado llega a main. Para equipos de decenas de ingenieros que entregan software versionado con un calendario, esa previsibilidad es justamente el valor del modelo.

Esta guía explica cómo funciona Gitflow, los comandos exactos de cada paso y las reglas que lo mantienen sano cuando mucha gente lo usa a la vez. Parte del modelo propuesto por Vincent Driessen y del tutorial de Gitflow de Atlassian, ampliado con las prácticas de escala que aplicamos en proyectos de producción.

Cuándo encaja Gitflow y cuándo no

Gitflow se diseñó para software con versiones explícitas: productos que se instalan, se publican en tiendas de apps, se entregan a clientes por contrato o se soportan en varias versiones a la vez. Funciona bien cuando:

  • Publicas con un ritmo definido (cada dos semanas, cada mes, cada trimestre) y no en cada merge.
  • Una etapa de QA o UAT debe validar un candidato congelado antes de producción.
  • Mantienes versiones antiguas y necesitas parchearlas.
  • Varios equipos contribuyen a un mismo código y necesitan un punto de integración claro.

Es una mala opción si despliegas un servicio web varias veces al día. En ese caso, la rama develop de larga vida y la ceremonia de release añaden demora sin añadir seguridad, y el desarrollo basado en trunk suele ser mejor. Elige el flujo que necesita tu proceso de entrega, no el que está de moda.

Los cinco tipos de rama

Gitflow tiene dos ramas de larga vida y tres tipos de ramas de corta vida.

Diagrama de ramas de GitflowCinco carriles en el tiempo. El carril main guarda los releases etiquetados v1.0.0, v1.0.1 y v1.1.0. Una rama hotfix sale de main tras v1.0.0 y se fusiona en main y en develop. Las ramas feature salen de develop y vuelven a él. Una rama release sale de develop, se estabiliza y se fusiona en main y de vuelta en develop.v1.0.0v1.0.1v1.1.0mainhotfix/*release/*developfeature/*
Fig. 1. Gitflow: main guarda las versiones publicadas, develop integra la siguiente.
Rama Vive Se crea desde Se fusiona en Propósito
main siempre n/a n/a Solo código liberado y listo para producción. Cada commit es una versión etiquetada.
develop siempre main (una vez) n/a Rama de integración de la próxima versión. Siempre compila.
feature/* días develop develop Un cambio: una historia, un bug, una refactorización.
release/* días a semanas develop main y develop Estabilizar una versión: correcciones, número de versión, notas.
hotfix/* horas a días main main y develop Corrección urgente de producción que no puede esperar al próximo release.

Dos reglas sostienen el modelo:

  1. Nadie hace commits directos en main ni en develop. Todo cambio llega por pull request.
  2. main siempre coincide con lo que está en producción. Si puedes etiquetarlo, es un release.

Flujo paso a paso

1. Crear las ramas de larga vida

Parte de main y crea develop una sola vez:

git switch main
git switch -c develop
git push -u origin develop

2. Construir una feature

Crea la rama desde el develop más reciente, nómbrala con el ticket y mantenla pequeña.

git switch develop
git pull --ff-only
git switch -c feature/PAY-142-flujo-reembolsos

# trabaja y haz commits pequeños
git add -p
git commit -m "PAY-142: agregar endpoint de solicitud de reembolso"

git push -u origin feature/PAY-142-flujo-reembolsos

Abre un pull request hacia develop. Cuando esté aprobado y el CI en verde, fusiónalo y borra la rama:

git switch develop
git pull --ff-only
git branch -d feature/PAY-142-flujo-reembolsos

Una rama feature debe vivir días, no semanas. Cuanto más vive, más se aleja de develop y más doloroso es el merge.

3. Cortar un release

Cuando develop contiene el alcance de la próxima versión, crea desde ahí la rama de release. Desde ese momento develop queda libre para recibir trabajo de la versión siguiente.

git switch develop
git pull --ff-only
git switch -c release/1.4.0
git push -u origin release/1.4.0

En la rama de release solo se hace trabajo de release: subir el número de versión, actualizar el changelog y corregir bugs que encuentre QA. Nada de features nuevas. Cada corrección es un commit pequeño o un pull request hacia release/1.4.0.

4. Publicar el release

Cuando el candidato está aprobado, fusiónalo en main, etiquétalo y vuelve a fusionarlo en develop para no perder las correcciones hechas durante la estabilización.

git switch main
git pull --ff-only
git merge --no-ff release/1.4.0
git tag -a v1.4.0 -m "Release 1.4.0"
git push origin main --tags

git switch develop
git pull --ff-only
git merge --no-ff release/1.4.0
git push origin develop

git push origin --delete release/1.4.0
git branch -d release/1.4.0

Usa --no-ff en estos merges para que el historial conserve un commit de fusión que muestre qué commits pertenecieron al release. En un equipo, estos merges normalmente son pull requests y no comandos locales, de modo que la protección de ramas y el CI siguen aplicando.

5. Atender un hotfix de producción

Un bug crítico en producción no puede esperar al próximo release. Crea la rama desde main, corrígelo y fusiónalo en las dos ramas de larga vida.

git switch main
git pull --ff-only
git switch -c hotfix/1.4.1

# corrige el bug, haz commit y abre un pull request hacia main
git commit -am "Corregir error de redondeo en totales de factura"

git switch main
git merge --no-ff hotfix/1.4.1
git tag -a v1.4.1 -m "Hotfix 1.4.1"
git push origin main --tags

git switch develop
git merge --no-ff hotfix/1.4.1
git push origin develop

Si en ese momento hay una rama release/* abierta, fusiona el hotfix en la rama de release en lugar de develop. La rama de release lo llevará a develop cuando se cierre.

Cómo escalar Gitflow en equipos grandes

Los comandos son los mismos para tres personas o para trescientas. Lo que cambia con la escala es la disciplina que se necesita a su alrededor.

Protege las ramas de larga vida

Configura tu plataforma Git para que las reglas las haga cumplir el sistema y no la memoria de las personas:

  • Bloquea los push directos y los force push a main, develop y release/*.
  • Exige al menos una aprobación de revisión, y dos para main y release/*.
  • Exige que pasen los checks de estado (build, pruebas, lint, escaneo de seguridad) antes de fusionar.
  • Exige que la rama esté al día con el destino antes de fusionar, o usa una cola de merge.
  • Usa un archivo CODEOWNERS para que los cambios en áreas sensibles pidan automáticamente a los revisores correctos.
# .github/CODEOWNERS
/payments/        @acme/equipo-pagos
/infra/           @acme/equipo-plataforma
*.sql             @acme/equipo-datos

Estandariza nombres de ramas y commits

Los nombres predecibles hacen que las ramas sean fáciles de buscar y permiten que la automatización actúe sobre ellas. Elige una convención y hazla cumplir con una regla del servidor o una verificación de CI:

feature/<TICKET>-<descripcion-corta>   feature/PAY-142-flujo-reembolsos
release/<mayor.menor.parche>           release/1.4.0
hotfix/<mayor.menor.parche>            hotfix/1.4.1

Referencia el ID del ticket en cada commit o título de pull request. Vincula el código con el trabajo planificado y facilita generar el changelog.

Ejecuta un CI distinto por tipo de rama

No todas las ramas necesitan el mismo pipeline. Una división habitual:

Evento Pipeline
Pull request hacia develop Build, pruebas unitarias y de integración, lint, análisis estático
Merge en develop Todo lo anterior y despliegue al entorno compartido de desarrollo o staging
Push a release/* Suite de regresión completa, despliegue a QA o UAT, verificaciones de rendimiento y seguridad
Merge en main Construir una sola vez el artefacto de release, etiquetarlo y desplegar a producción
# GitHub Actions: reglas de disparo por tipo de rama
on:
  pull_request:
    branches: [develop, main, 'release/**']
  push:
    branches: [develop, main, 'release/**', 'hotfix/**']

Construye el artefacto una sola vez en la rama de release y promueve ese mismo artefacto por los entornos. Reconstruir para producción significa publicar algo que no probaste.

Asigna un responsable de release

En un equipo grande, un release necesita una persona responsable: un release manager o un rol rotativo entre ingenieros senior. Esa persona abre la rama de release, controla lo que entra, coordina la aprobación de QA y realiza o aprueba el merge a main. Sin un responsable con nombre, las ramas de release derivan y se pierden correcciones.

Mantén las features cortas con feature flags

El mayor costo de Gitflow a escala son las ramas feature de larga vida que chocan entre sí. Divide el trabajo grande en tramos que puedan fusionarse en días y oculta el comportamiento sin terminar detrás de un feature flag, de modo que el código incompleto pueda llegar con seguridad a develop e incluso a producción:

if (flags.isEnabled('refund-flow')) {
  registerRefundRoutes(app);
}

Fusiona develop en las ramas feature de larga duración con regularidad (o haz rebase si tu equipo acordó reescribir el historial de ramas privadas), para que los conflictos aparezcan pronto y en piezas pequeñas.

Automatiza el versionado y el changelog

Usa Versionado Semántico: MAYOR.MENOR.PARCHE. Los releases suben el número menor (o mayor) y los hotfixes suben el parche. Genera las notas de versión a partir de los pull requests fusionados o de Conventional Commits, para que nadie las escriba a mano a último momento.

Soporta más de una versión

Si los clientes usan versiones antiguas, mantén una rama support/1.x cortada desde la última etiqueta 1.x en main. Aplica ahí las correcciones con el mismo proceso de hotfix y etiquétalas (v1.9.4). Mantén corta esa lista: cada versión soportada multiplica el esfuerzo de pruebas.

Errores comunes

  • Dejar que develop se rompa. Si develop está en rojo, todos los ingenieros quedan bloqueados. Primero corrige o revierte, después investiga.
  • Agregar features a una rama de release. Convierte la estabilización en una segunda línea de desarrollo. Lo nuevo espera al siguiente release.
  • Olvidar el merge de vuelta. Una corrección que llega a main pero no a develop reaparece como regresión en el siguiente release. Automatiza el merge de vuelta o inclúyelo en la lista de verificación del release.
  • Ramas feature de larga vida. Semanas de divergencia significan merges dolorosos y bugs de integración tardíos. Divide el trabajo y usa flags.
  • Hacer squash en ramas de release y hotfix. Elimina el historial compartido que mantiene limpios los merges posteriores entre main y develop. Puedes hacer squash de las features; conserva los commits de fusión en las ramas de larga vida.
  • Builds distintos por entorno. Promueve un solo artefacto; no reconstruyas en cada etapa.
  • Aplicar Gitflow a un servicio con despliegue continuo. Mira la siguiente sección.

Cómo se compara Gitflow con otros flujos

Gitflow GitHub Flow Desarrollo basado en trunk
Ramas de larga vida main, develop main main (trunk)
Mecanismo de release Ramas de release y etiquetas Despliegue desde main tras cada merge Despliegue desde el trunk, a menudo con flags
Ideal para Productos versionados, releases programados, varias versiones soportadas Apps web con entrega continua Equipos maduros con mucha automatización
Frecuencia de integración Por feature, hacia develop Por pull request Varias veces al día
Complejidad Mayor Baja Poco proceso, mucha disciplina de ingeniería

Ninguno es correcto en todos los casos. Muchas organizaciones usan Gitflow para sus apps móviles y productos on-premise, y desarrollo basado en trunk para sus servicios web internos.

Lista de verificación de Gitflow para tu equipo

  • main y develop están protegidas; los push directos están bloqueados.
  • Los nombres de rama y las referencias a tickets se validan automáticamente.
  • Todo pull request requiere revisión y CI en verde.
  • Las ramas feature viven días y el trabajo sin terminar está detrás de flags.
  • Una persona con nombre es responsable de cada release.
  • Las ramas de release solo aceptan correcciones, nunca features nuevas.
  • Cada release y hotfix se etiqueta y se fusiona de vuelta en develop.
  • Se construye un solo artefacto por release y se promueve por todos los entornos.
  • Las notas de versión se generan del trabajo fusionado, no de memoria.

Preguntas frecuentes

¿Sigue siendo relevante Gitflow?

Sí, para el tipo de producto adecuado. El modelo encaja mal con equipos que despliegan de forma continua, y por eso muchos migraron a desarrollo basado en trunk. Para software versionado con ciclos de release, puertas de QA y versiones soportadas, Gitflow sigue siendo una estructura clara y probada.

¿Cuál es la diferencia entre develop y main?

main contiene solo lo que ya se liberó y es la fuente de verdad de producción. develop contiene trabajo integrado que aún no se liberó. El código pasa de develop a main únicamente mediante una rama de release.

¿Debo usar merge o rebase?

Usa commits de fusión (--no-ff) para cerrar ramas de release y hotfix, de modo que el historial muestre qué se publicó y cuándo. Para ramas feature, tu equipo puede elegir merge, squash o rebase; lo importante es que la decisión sea consistente y esté documentada.

¿Necesito la extensión de línea de comandos git flow?

No. Solo envuelve los mismos comandos de Git que se muestran en esta guía. Muchos equipos la omiten y usan pull requests con protección de ramas, porque así la plataforma exige revisión y CI en cada merge.

Lecturas recomendadas

Sobre el autor

Rootnite Engineering

Equipo de ingeniería de Rootnite

Los ingenieros detrás del software a medida, la automatización y los productos de Rootnite. Documentamos las prácticas que usamos para construir y operar sistemas en producción para que otros equipos puedan reutilizarlas.

  • Git
  • Gitflow
  • Gestión de releases
  • Estrategia de ramas
  • CI/CD

¿Necesitas un equipo que trabaje así?

Diseñamos, construimos y operamos software de producción con las prácticas de estas guías. Cuéntanos sobre tu proyecto.

Contactar a Rootnite