Aprende a usar Git con Bitbucket Cloud

Aprende sobre ramas con Bitbucket Cloud

Objetivo

En este tutorial, aprenderás las nociones básicas de crear, revisar y fusionar ramas, además de trabajar con ellas, utilizando Git y Bitbucket Cloud.

Tiempo Público Requisitos previos
35 minutos Ya entiendes el flujo de trabajo básico de Git Tienes Git instalado
Tienes una cuenta de Bitbucket

Este tutorial es para ti si ya entiendes el flujo de trabajo básico de Git, lo que incluye saber hacer lo siguiente:

  • Clonar: copiar el repositorio remoto de Bitbucket Cloud a tu sistema local
  • Añadir o preparar: coger los cambios que has hecho y prepararlos para añadirlos a tu historial de git
  • Confirmar: añadir los archivos nuevos o modificados al historial de git del repositorio
  • Incorporar cambios: obtener los nuevos cambios que han añadido otros al repositorio en tu repositorio local
  • Enviar: enviar los cambios de tu sistema local al repositorio remoto

Si no conoces los puntos básicos de Git, no te preocupes. Solo tienes que echar un vistazo a nuestro tutorial Aprende a usar Git con Bitbucket Cloud y te pondrás al día en un abrir y cerrar de ojos.

Por qué es importante crear ramas

La creación de ramas es una de las mejores maneras de sacar el máximo partido de Git para el control de versiones. La creación de ramas en Git te permite lo siguiente:

  • Tener a varios equipos trabajando a partir de un único repositorio al mismo tiempo.
  • Permitir que los miembros del equipo de cualquier parte del mundo que usen Bitbucket Cloud colaboren.
  • Tener múltiples líneas de desarrollo en marcha al mismo tiempo independientes entre sí sin que se tenga que congelar el código.

Preparación

Como queremos que te sientas como si estuvieras trabajando en un equipo, en un mismo repositorio de Bitbucket, te pediremos que bifurques un repositorio público que hemos proporcionado.

¿En qué consiste bifurcar?

Bifurcar es otra forma de guardar una clonación o una copia. El término "bifurcar" (en programación) deriva de una llamada de sistema Unix que crea una copia de un proceso existente. Así que, a diferencia de una rama, una bifurcación es independiente del repositorio original. Si se elimina el repositorio original, la bifurcación se conserva. Si bifurcas un repositorio, obtienes ese repositorio y todas sus ramas.

  1. Ve a tutorials/tutorials.git.bitbucket.org
  2. Haz clic en + > Bifurcar este repositorio en la parte izquierda de la pantalla.
  3. Modifica el nombre para que sea exclusivo de tu equipo y, a continuación, haz clic en Bifurcar repositorio.
  4. Crea un directorio para el repositorio al que sea fácil acceder. Puedes eligir algo como esto:
     $ mkdir test-repositories $ cd test-repositories/ $ test-repositories
    En el ejemplo anterior, se crea el directorio test-repositories utilizando el comando mkdir (crear directorio) y se cambia a dicho directorio mediante el comando cd (cambiar directorio).
  5. Clona el repositorio bifurcado en el directorio que acabas de crear. Podría tener este aspecto:
     $ git clone https://dstevenstest@bitbucket.org/dstevenstest/mygittutorial.bitbucket.io.git Cloning into 'mygittutorial.bitbucket.io'... remote: Counting objects: 12392, done. remote: Compressing objects: 100% (12030/12030), done. remote: Total 12392 (delta 8044), reused 564 (delta 360) Receiving objects: 100% (12392/12392), 2.72 MiB | 701.00 KiB/s, done. Resolving deltas: 100% (8044/8044), done. $ cd mygittutorial.bitbucket.io/
    Esto clona el repositorio utilizando el comando git clone y crea el directorio que creó la clonación mygittutorial.git.bitbucket.io.

Crea una rama y cambia algo utilizando el flujo de trabajo de creación de ramas

Vas a añadir una cita a tu página web en esta rama.

  1. Crea una rama utilizando el comando git branch.
     $ git branch test-1
  2. Consulta la rama que acabas de crear utilizando el comando git checkout.
     $ git checkout test-1 Switched to branch 'test-1'
  3. Enumera las ramas que tienes localmente utilizando el comando git branch.
     $ git branch master * test-1
  4. Actualiza el archivo editme.html añadiendo una cita. Puedes usar algo como lo siguiente:
     
    This is a quote, and I like it.
    A quote: The Art of Quoting
  5. Añade ese cambio.
     git add editme.html
    Nota: Tu cambio no se ha confirmado en el historial de Git todavía. Está en estado de "espera". Lo aprendimos en Guardado de cambios.
  6. Confirma el cambio con un mensaje de confirmación descriptivo.
     git commit editme.html -m'added a new quote' [test-1 063b772] added a new quote 1 file changed, 3 insertions(+), 3 deletions(-)
    Nota: Ahora los cambios forman parte del historial de Git como una única "confirmación". Lo aprendimos en Guardado de cambios.
  7. Envía ese cambio a Bitbucket utilizando el comando git push.
     git push fatal: The current branch test-1 has no upstream branch. To push the current branch and set the remote as upstream, use git push --set-upstream origin test-1
    Verás un error, porque la primera vez que envías una nueva rama que has creado localmente tienes que designar esa rama.
  8. Envía la rama y cambia utilizando el comando git push branch.
     $ git push origin test-1 Counting objects: 3, done. Delta compression using up to 8 threads. Compressing objects: 100% (3/3), done. Writing objects: 100% (3/3), 363 bytes | 0 bytes/s, done. Total 3 (delta 2), reused 0 (delta 0) remote: remote: Create pull request for test-1: remote: https://bitbucket.org/dstevenstest/dans.git.bitbucket.org/pull-requests/new?source=test-1&t=1 remote: To https://bitbucket.org/dstevenstest/dans.git.bitbucket.org.git * [new branch] test-1 -> test-1
    Esto le indica al sistema que el repositorio de origen es el destino de esta nueva rama.
  9. Abre tu repositorio del tutorial y haz clic en Ramas. Ahora deberías ver tanto la rama master como la test-1. Debería ser algo así:
Aprende las ramas de Bitbucket

Crea, recupera y consulta una rama remota

Cuando trabajes en equipo, probablemente tendrás que recuperar ramas que creen otros miembros del equipo y envíen a Bitbucket, o incorporar cambios en ellas. En este ejemplo, entenderás los puntos básicos de crear ramas que creen otras personas y trabajar con ellas.

  1. Ve a tu repositorio del tutorial en Bitbucket y haz clic en Ramas. Deberías ver algo como esto: Branches
  2. Haz clic en Crear rama, ponle a la rama test-2 y haz clic en Crear.
  3. Copia el comando git fetch en el cuadro de diálogo para consultar tu rama. Probablemente será algo así:
     $ git fetch && git checkout test-2 From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org * [new branch] test-2 -> origin/test-2 Branch test-2 set up to track remote branch test-2 from origin. Switched to a new branch 'test-2'
  4. Utiliza el comando git branch en tu terminal. Deberías ver una lista de ramas similar a la siguiente:
     $ git branch master test-1 * test-2
    La rama con el asterisco * es la rama activa. Esto es fundamental recordarlo cuando trabajas en cualquier flujo de trabajo de creación de ramas.
  5. Utiliza el comando git status y verás algo como esto:
     $ git status On branch test-2 Your branch is up-to-date with 'origin/test-2'. nothing to commit, working tree clean
    Puedes ver en qué rama estás y que la rama está actualizada en esos momentos con respecto a la rama remota (origen).
  6. Utiliza el comando git checkout para volver a cambiar el centro de atención a la otra rama. El comando será algo parecido a esto:
     $ git checkout test-1 Switched to branch 'test-1' Your branch is ahead of 'origin/test-1' by 3 commits. (use "git push" to publish your local commits)
    Una de las cosas más importantes que hay que recordar al trabajar con ramas es que quieres estar seguro de que la rama en la que estás haciendo cambios es la correcta.

Envía el cambio y crea una solicitud de incorporación de cambios

Ahora es el momento de que se revise tu primer cambio y fusionar la rama.

  1. Haz clic en +> Crear una solicitud de incorporación de cambios. Puedes ver tu rama test-1 como la rama origen y la maestra en la rama de destino.

    Como hemos creado este repositorio bifurcando uno existente, el destino se define en la rama maestra del repositorio que hemos bifurcado.

    Para corregirlo, tendrás que cambiar la rama de destino del repositorio (la rama con la que fusionarás los cambios) de tutorials/tutorials.git.bitbucket.org a tu repositorio.

    Pull Request

    Además, tienes que añadir revisores en tu equipo para la solicitud de incorporación de cambios. Más información sobre las solicitudes de incorporación de cambios

  2. Haz clic en Crear solicitud de incorporación de cambios.
  3. Haz un comentario en la solicitud de incorporación de cambios seleccionando una línea en la diff (el área que muestra el cambio que has hecho en el archivo editme.html).
  4. Haz clic en Aprobar en la parte superior izquierda de la página. Por supuesto, en una solicitud de incorporación de cambios real tendrías revisores que hacen comentarios.
  5. Haz clic en Fusionar.
  6. (Opcional) Actualiza el mensaje de confirmación con más detalles.
  7. Selecciona la estrategia de fusión Confirmación de fusión de las dos opciones:
    • Confirmación de fusión: mantiene todas las confirmaciones de tu rama de origen y las incorpora a la rama de destino. Esta opción es la misma que escribir git merge --no-ff en la línea de comandos.
    • Combinar: combina tus confirmaciones cuando fusionas la rama de origen con la rama de destino. Esta opción es la misma que escribir git merge --squash en la línea de comandos.
    Más información sobre estos dos tipos de estrategias de fusión.
  8. Haz clic en Confirmaciones y verás cómo la rama que acabas de fusionar encaja en el esquema general de cambios.

Elimina una rama e incorpora los cambios de la rama maestra en la rama de trabajo local

Ahora has pasado por el flujo de trabajo de creación de ramas básico y tu cambio está en la rama maestra. La última cosa que aprenderemos es cómo eliminar la rama que acabas de fusionar, incorporar cambios a la rama maestra actualizada y fusionar la rama maestra actualizada en tu rama test-2.

¿Por qué eliminar la rama?

Recuerda que la creación de ramas en Git difiere de SVN o sistemas de control de versiones similares al utilizar las ramas tanto como ramas de larga ejecución (por ejemplo, una rama maestra y una de desarrollo) como ramas de desarrollo a corto plazo (los ejemplos que utilizamos en este tutorial). Como este es el caso, no es una mala idea eliminar las ramas locales para que tu entorno local esté más limpio.

¿Por qué incorporar los cambios de la rama maestra y fusionarla con test-2?

Esto es un ejemplo de un caso en el que estás trabajando en un repositorio en el que también está trabajando otro miembro del equipo. Es una buena idea incorporar los cambios en tu rama de trabajo de vez en cuando para evitar los conflictos de fusión en las solicitudes de incorporación de cambios.

  1. Abre tu terminal y ejecuta el comando git status. El resultado debería ser algo parecido a esto:
     $ git status On branch test-1 nothing to commit, working tree clean
    Puedes ver que estás en la rama que acabas de utilizar para hacer el cambio y que no tienes ningún cambio. Estamos listos para deshacernos de esa rama ahora que hemos acabado ese trabajo.
  2. Cambia a la rama maestra ejecutando el comando git checkout master. El resultado debería ser algo así:
     git checkout master Switched to branch 'master' Your branch is up-to-date with 'origin/master'.
    ¿Te has fijado en que el mensaje dice que estás actualizado? Se trata solo de tu rama local. Lo sabemos, porque acabamos de fusionar un cambio en la rama maestra y no hemos incorporado ese cambio del repositorio remoto a nuestro sistema local. Es lo que haremos a continuación.
  3. Ejecuta el comando git pull. El resultado debería ser algo así:
     $ git pull remote: Counting objects: 1, done. remote: Total 1 (delta 0), reused 0 (delta 0) Unpacking objects: 100% (1/1), done. From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org 2d4c0ab..dd424cb master -> origin/master Updating 2d4c0ab..dd424cb Fast-forward editme.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
    Lo que ha sucedido es que, cuando incorporas los cambios del repositorio remoto, git ejecuta una fusión de avance rápido para integrar los cambios que has hecho. Asimismo, enumera cuántos archivos y líneas han cambiado en ese archivo.
  4. Ejecuta el comando git branch -d {nombre_de_la_rama} para eliminar la rama test-1. El resultado será algo así:
     $ git branch -d test-1 Deleted branch test-1 (was 063b772)
    Puedes ver que se eliminó la rama y cuál fue el último hash de la confirmación para esa rama. Esta es la forma segura de eliminar una rama, porque git no permitirá eliminar la rama si tiene cambios sin confirmar. Sin embargo, tienes que tener en cuenta que esto no evitará que se eliminen cambios que se han confirmado en el historial de git, pero que no se han fusionado en otra rama.
  5. Cambia a la rama test-2 utilizando el comando git checkout.
     $ git checkout test-2 Switched to branch 'test-2' Your branch is up-to-date with 'origin/test-2'.
  6. Fusiona la rama maestra con la rama de trabajo utilizando el comando git merge master test-2. El resultado será algo como esto:
     $ git merge master test-2 Updating 2d4c0ab..dd424cb Fast-forward editme.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
    Es importante recordar lo siguiente:
    • La rama activa importa. Si quieres fusionar la rama maestra con la test-2, esta última tiene que estar extraída (activa). Pasa lo mismo si quieres fusionar la rama test-2 con la maestra; esta última tiene que estar activa.
    • Para ver qué rama está activa en cualquier momento, utiliza git branch y la rama activa tendrá un asterisco o utiliza git status para que te diga en qué rama estás y si hay cambios locales pendientes.

Esperamos que hayas aprendido un poco sobre la creación de ramas y los comandos implicados. Vamos a revisar lo que hemos explicado:

Revisa el flujo de trabajo de ramas

El flujo de trabajo de creación de ramas de función en Git es una forma eficaz de trabajar con tu equipo en Bitbucket. En este flujo de trabajo, todo el desarrollo de funciones se desarrolla en ramas separadas de la rama maestra principal. Como resultado, varios desarrolladores pueden trabajar en sus propias funciones sin tocar el código principal.

Empieza con la rama maestra

Este flujo de trabajo te ayuda a colaborar en tu código con al menos otra persona. Siempre y cuando Bitbucket y tus repositorios locales estén actualizados, estás listo para empezar.

Crea una nueva rama

Utiliza una rama diferente para cada función o incidencia en la que trabajes. Tras crear una rama, extráela localmente para que cualquier cambio que hagas esté en dicha rama.

Actualiza, añade, confirma e incorpora cambios

Trabaja en la función y confirma como lo harías siempre que utilizas Git. Cuando estés listo, envía tus confirmaciones, lo que actualiza la rama de función en Bitbucket.

Haz que se revise tu código

Para recibir comentarios de tu código, crea una solicitud de incorporación de cambios en Bitbucket. A partir de ese momento, puedes añadir revisores y asegurarte de que todo esté bien antes de fusionar.

Resuelve los comentarios

Ahora tus compañeros de equipo comentan y aprueban. Resuelve sus comentarios localmente, confirma y envía los cambios a Bitbucket. Tus actualizaciones aparecen en la solicitud de incorporación de cambios.

Fusiona tu rama

Antes de fusionar, puede que tengas que resolver conflictos de fusión si otros han hecho cambios en el repositorio. Cuando tu solicitud de incorporación de cambios esté aprobada y sin conflictos, puedes añadir tu código a la rama maestra. Fusiona desde la solicitud de incorporación de cambios en Bitbucket.

Este tutorial está limitado en su habilidad de mostrar cómo las ramas consiguen que los equipos sean más eficaces. Hay varios enfoques a la creación de ramas y explicamos algunos de estos enfoques en: Comparación de flujos de trabajo.