Tutorial básico de Git

Git es un software de control de versiones. Se puede usar tanto localmente en tu propio equipo, como en la intranet de una empresa, así como globalmente con repositorios en Internet (los más importantes son GitHub, GitLab o Bitbucket).

• Comandos de consola
• Instalar Git
• Configurar Git
• Crear el repositorio
• Modificar y actualizar el repositorio
• Crear y configurar un repositorio remoto en GitHub
• Modificar el repo remoto y traer (pull) los cambios al local
• Modificar el repo local y llevar (push) los cambios al remoto
• Trabajar con ramas y bifurcaciones
• Branches. Crear, acceder, listar y cambiar nombre
• Actualizar rama con modificaciones en remoto
• Pull-Request
• Clonar ramas del remoto
• Anexo

Comandos de consola

Para este tutorial se va a simular la creación del repositorio tutorial-git con comandos de consola en Linux.

Existe software con interfaz gráfica.

Instalar Git

$ sudo apt-get install git

$ git --version
  git version 2.17.1

Configurar Git

Se configurará Git con nuestro nombre de usuario. Para utilizar un repositorio global en Internet, el nombre de usuario de git deberá ser el mismo con el que nos hayamos registrado en ese repositorio (en mi caso frames75).

$ git config --global user.name 'frames75'
$ git config --global user.username 'frames75'
$ git config --global user.email 'frames@frames75.com'

$ git config -l

  user.email=frames@frames75.com
  user.name=frames75
  user.username=frames75

Crear el repositorio

Crearemos una carpeta que contendrá nuestro repositorio.

$ mkdir tutorial-git
$ cd tutorial-git

$ git init
$ git status

  En la rama main
  No hay commits todavía
  no hay nada para confirmar 

Modificar y actualizar el repositorio

Crear un nuevo fichero y guardar (commit) en git.

$ echo 'Hola mundo' > readme.txt

$ git add readme.txt
$ git status

  En la rama main
  No hay commits todavía
  		nuevo archivo:  readme.txt

$ git commit -m 'first commit'
$ git branch -M main
$ git status

  En la rama main
  nada para hacer commit, el árbol de trabajo esta limpio

Si hubiera más de un archivo y se quisiera guardar todos:

$ git add --all

(*) En los repos remotos públicos es importante utilizar el idioma inglés para que cualquier persona del mundo pueda entender de qué trata.

Crear y configurar un repositorio remoto en GitHub

En GitHub crear un repositorio con el mismo nombre tutorial-git (no crear fichero README). Copiar la dirección web de este nuevo repo (https://github.com/frames75/tutorial-git) y pegarla en la siguiente instrucción.

$ git remote add origin https://github.com/frames75/tutorial-git

Posteriormente se puede modificar la URL del repo remoto.

$ git remote set-url <NOMBREDELREMOTO> <URL>

Una vez creado el remoto, debemos llevar (push) los cambios (commits) que hemos hecho en local.

$ git push -u origin main

Modificar el repo remoto y traer (pull) los cambios al local

En el repo de GitHub editaremos online el fichero readme.txt (simulando así la actualización de otro usuario). Para actualizar nuestro repo local necesitamos traernos esa modificación.

$ git pull

La anterior instrucción es equivalente a

$ git pull origin main

Comprobamos que el fichero de nuestro equipo se ha modificado.

Modificar el repo local y llevar (push) los cambios al remoto

En el fichero readme.txt de nuestro equipo añadiremos una nueva línea.

Al hacer esto, comprobamos que se ha creado el fichero de respaldo readme.txt~. Este nuevo fichero no queremos llevarlo al repo remoto, por lo que se lo tendremos que indicar a git. La forma de hacer esto es crear el fichero .gitignore y escribir en él los ficheros y directorios que no queremos compartir.

$ echo readme.txt~ > .gitignore

Seguidamente llevaremos todos los cambios (la modificación con la nueva línea y el fichero .gitignore creado) al repo remoto.

$ git add .
$ git commit -m 'new line'
$ git push

Comprobamos que el fichero remoto se ha modificado.

Trabajar con ramas y bifurcaciones

Para colaborar en repos ajenos se utilizan ramas (branches) y bifurcaciones (forks).

Desde GitHub, vaya a mi repo de pruebas y haga un fork a su cuenta pulsando en el botón superior derecho

Vuelva a su directorio raiz y clone su repo con el fork recién creado.

$ cd ..
$ git clone https://github.com/username/simplest-repo-example
$ cd simplest-repo-example
$ git remote -v 

  origin  https://github.com/username/simplest-repo-example (fetch)
  origin  https://github.com/username/simplest-repo-example (push)

Si el repositorio original recibe cambios, se querrá traerlos a tu proyecto.

$ git remote add upstream https://github.com/frames75/simplest-repo-example
$ git remote -v

  origin  https://github.com/username/simplest-repo-example (fetch)
  origin  https://github.com/username/simplest-repo-example (push)
  upstream  https://github.com/frames75/simplest-repo-example (fetch)
  upstream  https://github.com/frames75/simplest-repo-example (push)

Branches. Crear, acceder, listar y cambiar nombre

Crear una nueva rama local de este repo, y acceder a ella.

$ git branch version-v2
$ git checkout version-v2

Las dos instrucciones anteriores se podrían resumir en la siguiente

$ git checkout -b version-v2

Listar todas las ramas del repo.

$ git branch [--list]

Cambiar el nombre de la rama actual.

$ git branch -m version-v3

Llevar la nueva rama al remoto.

$ git push -u origin version-v3

Actualizar rama con modificaciones en remoto

Comprobar si el repo local está actualizado con los cambios de los colaboradores en el remoto.

$ git fetch --dry-run

  Desempaquetando objetos: 100% (3/3), listo.
  Desde https://github.com/username/simplest-repo-example
   aea947d..76c52b2  version-v3 -> origin/version-v3

El comando anterior nos confima que sí hay cambios en la rama version-v3 del remoto origin. Para ver cuáles son estos cambios antes de actualizar nuestra rama local:

1. Traer la rama remota.
2. Listar todas las ramas, locales y remotas.
3. Acceder a la rama remota.
4. Consultar los cambios.

$ git fetch origin
$ git branch -a

  main
  version-v3
  remotes/origin/HEAD -> origin/main
  remotes/origin/main
  remotes/origin/version-v3
  remotes/upstream/cimon-example
  remotes/upstream/main
  
$ git checkout remotes/origin/version-v3
$ cat fichero_modificado.txt

Combinar los cambios de la rama remota en la rama local.

$ git merge origin version-v3

De esta forma, vemos que git pull origin main equivale a:

$ git fetch origin main
$ git merge origin main

Pull-Request

Un pull-request es una petición que el propietario de un fork de un repositorio hace al propietario del repositorio original para que éste incorpore los cambios (commits) que están en el fork.

Desde el repo del proyecto original bifurcado (en este caso el del usuario cimon-io que he usado), comprobar que hay alguna pull-request pendiente (botón verder Compare & pull request). Crear la pull request y esperar la confirmación del merge por parte del propietario del repo.

Si el propietario considera conveniente la pull request y realiza el merge, ahora tendremos que ser nosotros quienes actualicemos nuestro repo. Es decir, tendremos que hacer un pull desde upstream.

1. Cambiar a la rama principal.
2. Fusionar la rama usada en el pull-request.
3. Eliminar la rama fusionada en local.
4. Eliminar la rama fusionada en remoto.

$ git checkout main
$ git merge version-v3
$ git branch -d version-v3
$ git push origin --delete version-v3

Actualizar desde el repo original recién fusionado.

$ git pull upstream main

Clonar ramas del remoto

Cuando se clona un repositorio remoto, por defecto se trae todas las ramas que tenga.

Es posible que se desee trabajar con una rama específica del repositorio remoto en vez de con la rama principal. Para hacer esto se tienen dos posiblidades:

• Clonar el repositorio, fetch todas las ramas, y checkout la rama específica que nos interesa.
• Clonar el repositorio y fetch solamente la rama que nos interesa.

Opción 1

$ git clone --branch <branchname> <remote-repo-url>

Con esta opción podemos comprobar que nos hemos traído todas las ramas:

$ git remote show origin

Opción 2

$ git clone --branch <branchname> --single-branch <remote-repo-url>

De esta forma sólo rastrearemos la rama indicada en local:

$ git remote show origin

Anexo

Ver el histórico de los cambios en el repo.

$ git log --oneline

Deshacer cambios ó volver a un estado anterior.

$ git revert 62672226

Ver los cambios del repositorio remote antes de traerlos al local.

$ git fetch origin
$ git log main..origin/main
$ git diff main..origin/main
$ git merge origin/main
$ git pull