Conceptos básicos de Git

  • Git se basa en snapshots (instantáneas) del código en un estado determinado, que viene dado por el autor y la fecha.
  • Un Commit es un conjunto de cambios guardados en el repositorio de Git y tiene un identificador SHA1 único.
  • Las ramas (branches) se pueden pensar como una línea de tiempo a partir de los commit. Hay siempre como mínimo una rama principal o predefinida llamada Master.
  • Head es el puntero al último commit en la rama activa.
  • Remote se refiere a sitios que hospedan repositorios remotos como GitHub.

Workflow de Git

git workflow

Imagen obtenida de blog.podrezo.com

Si trabajamos en local (comenzamos en la imagen por la izquierda), inicializamos el directorio de trabajo (working directory). Podemos trabajar (editar ficheros) en el directorio de trabajo.

Con el comando Git add enviamos los cambios a staging, que es un estado intermedio en el que se van almacenando los archivos a enviar en el commit. Finalmente con commit lo enviamos al repositorio local.

Si queremos colaborar con otros, con push subimos los archivos a un repo remoto y mediante pull podríamos traer los cambios realizados por otros en remoto hacia nuestro directorio de trabajo.

Si comenzamos trabajando en remoto, lo primero que hacemos es un clon de la información en el directorio local.

Ayuda de Git

Con git help en el terminal obtenemos ayuda.

Vamos a mirar la ayuda de configuración con

#git help config

Ayuda de Git

Configuración de Git

Como mínimo debemos configurar el nombre y el email en la aplicación con los siguientes comandos:

git config --global user.name "Tu nombre aquí"

git config --global user.email "tu_email_aquí@example.com"

Configuración de Git

Para comprobar podemos usar:

git config -–global –list

Lo que hace el sistema es crear un archivo de texto llamado .gitconfig, por lo que podemos mostrarlo también con cat:

cat ~/.gitconfig

Comenzar a trabajar con Git

Trabajar en un nuevo proyecto con Git

Nos situamos en la carpeta en la que queremos trabajar. Nos aseguramos con pwd, para saber dónde estamos.

Ahora con git init y el nombre del proyecto, creamos un nuevo proyecto:

git init prueba01

03 ver la carpeta oculta de git

Esto crea una carpeta con el mismo nombre y en su interior, podemos observar con ls -a que se crea una subcarpeta oculta .git para el control y gestión de la herramienta.

Trabajar en un proyecto existente con Git

Usamos Initializr para descargar un proyecto demo, lo ponemos en una carpeta, nos situamos en ella y ejecutamos simplemente git init.

04 ver la carpeta oculta de git 02

Primer commit

Ahora vamos a crear algún archivo en el primero de los proyectos. Yo he creado un archivo README.md con el contenido: #Demo de Git.

Ahora, en la carpeta del proyecto ejecutamos

git status

05 git status

Podemos ver los detalles. Estamos ubicados en la rama máster y que tenemos un archivo que no ha sido agregado aún.

Lo primero que vamos a hacer es agregarlo al staging, también llamado Git Index, mediante el comando git add:

git add README.md

06 git add

Ahora vemos que el archivo ya está esperando a ser enviado al repo mediante commit.

Al ejecutar commit no especificamos qué archivos se enviarán. Se envían todos los que estén en staging. Vamos a agregar la opción -m para agregar un mensaje al commit, por ejemplo “commit inicial”:

git commit -m “commit inicial”

07 git commit

Veremos un mensaje similar a este:

Si hacemos un status ahora veremos que el área de staging está vacía y no hay ningún commit pendiente.

Trabajando con Git en local

Ahora vamos a agregar más contenido al archivo README y hacemos un status.

Veremos que ahora el sistema nos indica que hay cambios no enviados al staging:

08 git status con archivos modificados

Con el mismo procedimiento de antes, agregamos (add) y hacemos un nuevo commit:

09 git commit con archivos modificados

También podemos hacer el add y el commit en un solo paso con:

git commit -a

Tal como nos recomienda el propio Git en la captura de arriba. Si queremos también agregar el mensaje quedaría

git commit -am “msj”

Podemos hacer algunos cambios más y agregar otro archivo, por ejemplo, un index.html al proyecto.

10 git status

En este caso vamos a agregar los archivos modificados o nuevos al staging de forma recursiva con

git add .

11 git add punto

Un nuevo commit:

12 nuevo commit

Vamos a volver a hacer algún cambio y lo agregamos al staging. Si nos fijamos en la captura de la anterior operación add, el sistema nos indica que podemos sacar un archivo del stage con git reset HEAD y el nombre del archivo. Lo probamos con README:

git reset HEAD README.md

13 git reset

Un nuevo status nos indicará que hay uno en el staging y otro por agregar:

14 git status tras reset

Como podemos ver, también podemos descartar los cambios en el directorio de trabajo con checkout:

git checkout -- README.md

Esto devuelve nuestro archivo readme al estado anterior.

Recuerda que puedes consultar la ayuda para ver más opciones y comandos. Aquí puedes algunos ejemplos adicionales.

Histórico de operaciones en Git. El log

Con git log podemos ver el histórico de operaciones que hemos hecho:

git log

15 git log

Podemos ver que los commit se han hecho en orden cronológico inverso con los distintos usuarios y que cada uno tiene asociado su clave y su fecha.

Con git help log podemos ver las opciones que existen. Un ejemplo de una vista compacta y colorida sería:

git log --oneline --graph --decorate --color

16 git log con comandos de estilo y compacto

Eliminar archivos del repositorio de Git

Imaginemos que uno de los archivos que ya están en el repositorio de git tras un commit no lo queremos allí. Podemos usar el comando rm de remove y el nombre del archivo:

git rm index.html

17 git status tras eliminación mediante git

Podemos observar que el status nos indica que el cambio ejecutado para el archivo a eliminar está en el staging. Para eliminarlo debemos hacer un nuevo commit:

18 git commit tras eliminación mediante git

Ahora veremos que el archivo index ya no está en el directorio de trabajo.

Ahora vamos a agregar un nuevo archivo, lo agregamos al staging y hacemos un commit. Vamos a eliminarlo manualmente desde el sistema de archivos del SO, no desde Git.

19 git add y commit tras eliminación mediante git

Ahora elimino el archivo humans.txt y hacemos un status:

20 git status tras eliminación manual

Como la misma pantalla indica, podemos usar add o rm para que definitivamente los cambios se agregan al staging.

21 git add y commit tras eliminación manual

En este caso se ha usado un add y tras un commit se ha ejecutado el borrado en el repo.

Mover archivos en Git

Vamos a crear una nueva carpeta “style” para alojar un nuevo archivo de estilos css que ahora se encuentra en la carpeta raíz del proyecto y ya en el repositorio.

Probamos primero a mover manualmente el archivo:

22 mover archivos en git

En este caso vamos a ejecutar git commit -a para agregar al staging y hacer el commit con una sola operación:

23 commit tras mover archivos en git

Ojo! Si volvemos a hacer un status veremos que la carpeta styles no se ha actualizado correctamente. Tendremos que hacerlo recursivo con git add . y luego el commit.

Ignorar archivos en Git

Ahora disponemos de un archivo que no queremos que se agregue nunca al repo, por ejemplo un archivo de log.

24 status de archivo a ignorar en git

En Linux Debian, con el comando nano podemos editar un archivo en un editor de textos en el terminal.

Vamos a editar el archivo .gitignore, en el que especificamos los archivos a ignorar en líneas independientes.

nano .gitignore

Y en el archivo, que aparecerá vacío, agregamos en la primera línea *.log. Guardamos y salimos.

25 edición de archivo gitignore en Nano

Ahora hacemos un status y veremos el archivo .gitignore para agregar a staging:

26 status add y commit tras el ignore

También hemos hecho un nuevo commit.

Trabajando con Git en Remoto

Configuración de una clave para la conexión por SSH y autenticación en GitHub

Lo primero es crear la autenticación SSH. Nos dirigimos a la carpeta raíz de usuario, creamos una carpeta llamada .ssh. Nos movemos a ella y mediante el comando shh-keygen creamos una clave asociada a la cuenta de correo. Vamos a emplear una clave tipo RSA, de modo que el comando quedaría:

ssh-keygen -t rsa -C “correo@dominio.com”

Nos pregunta que dónde queremos guardar el fichero con la clave. Podemos seleccionar la opción predefinida.

27 creación de la clave SSH

Con ls -al podemos ver en detalle nos nuevos archivos generados en la operación.

El archivo .pub es la clave pública, que enviaremos a GitHub. Para ello debemos abrir el documento y copiar su contenido.

El editor Nano puede ser un poco complejo de usar para estas operaciones. Aquí tienes otras alternativas para Linux: How to open a particular file from a terminal?. Yo usaré

xdg-open nombre_archivo

Ahora iniciamos sesión en GitHub y nos vamos a Settings à SSH Keys y creamos una nueva, indicando un nombre descriptivo, recuerda que esto se asocia al equipo desde el que trabajamos, y la clave pública que hemos copiado previamente.

28 Agregar la clave SSH en GitHub

Ahora ejecutamos

ssh -T git@github.com

Y deberíamos autenticarnos correctamente:

29 Autenticación en GitHub mediante SSH

Trabajando con un repositorio remoto en GitHub

Primero vamos a crear un nuevo repositorio desde la aplicación web de GitHub con la sesión iniciada.

30 Creación de un nuevo repositorio en GitHub

Una vez creado, en la siguiente pantalla hacemos clic en SSH en la parte superior para ver las instrucciones de envío mediante línea de comandos.

31 Detalles de acceso SSH en GitHub

Ahora nos movemos al proyecto con el que queremos trabajar. Vemos que el status no hay nada pendiente y ejecutamos el primer comando. Usando después…

git remote -v

El comando remote sirve para ver los repositorios remotos asociados. con la opción -v vemos la URL:

32 Git remote para ver el estado de enlazado de la conexión

Las URLs que vemos en la captura anterior son de tipo SSH, indicativo de que podríamos enviar. También podemos agregar repositorios de otros usuarios para recibir con el comando git remote add [nombre] [url].

Ejemplo: $ git remote add pb git://github.com/paulboone/ticgit.git

Para recibir los ficheros de uno de estos repositorios de otro usuario usamos el comando fetch seguido del nombre que hemos puesto en el comando anterior.

Ejemplo: git fetch pb

Ahora vamos a enviar los archivos en local al repo remoto con push y la opción -u para establecer un enlace entre ellos, especificando también el repositorio remoto (origin) y la rama de trabajo (master), quedando:

git push -u origin master

33 Primer push para enviar proyecto a Github

Una vez establecido el enlace no hará falta usar la opción -u, quedando la instrucción para actualizar los cambios en el repositorio remoto de la siguiente manera:

git push origin master

34 Segundo push

Ahora podemos ver el repositorio actualizado en GitHub:

35 Comprobación del repositorio remoto actualizado tras push

Ahora vamos a modificar o agregar algún archivo al repo local y actualizar de nuevo el remoto.

36 nuevos cambios para segundo push

Si vemos el status ahora, este nos indica que hay cambios pendientes de sincronizar con el remoto:

37 nuevo status para segundo push

Aunque ahora estoy trabajando sólo, lo lógico es solicitar los últimos cambios mediante un pull, antes de enviar los nuestros con push, para evitar conflictos con otros miembros del equipo. De modo que ejecutamos:

git pull origin master

git push origin master

38 pull y push para trabajar con otros participantes en GitHub

Ya podemos ver los nuevos cambios en el repositorio remoto.

Al hacer pull, el sistema recupera y trata de unir la rama remota con la local, mientras que con el comando fetch que veíamos antes no. Más info en la documentación oficial.

Recursos

Página oficial

https://git-scm.com/

Descripción en Wikipedia:

https://es.wikipedia.org/wiki/Git

English:

https://en.wikipedia.org/wiki/Git

Manual Desarrolloweb.com

https://desarrolloweb.com/manuales/manual-de-git.html#capitulos185

Para poder disponer de las funcionalidades en la máquina vitual es necesario instalar las Guest Additions de Virtual Box:

How to Install VirtualBox Guest Additions in Ubuntu

Para ejecutar el ejecutable de las guest additions en Debian podemos usar la instrucción

sh VBoxLinuxAdditions.run

Desde un terminal con privilegios.