Si estás aquí es porque necesitas ayuda para dar tus primeros pasos con Git. Con este tutorial pretendo juntar todas las búsquedas frecuentes que realizo en Google para mi día a día y así poder ayudarte con tus ambiciones.
En qué consiste Git
Git es un sistema de versionado de código fuente, aunque en la actualidad sus usos se han multiplicado, por lo que resulta interesante hablar de ellos:
- Control de versiones.
- Copias de seguridad.
- Trabajo en equipo.
- Sistema de publicación de código libre.
Git utiliza índices para identificar los cambios realizados y dotarte de las herramientas para revertirlos o documentarlos. Además está integrado con la mayoría de los IDEs como es Visual Studio, Visual Studio Code y NetBeans (programa que yo utilizo para desarrollo web).
Como habrás podido ver, Git es un monstruo informático utilizado en la mayoría de los proyectos, por lo que si tú eres uno de los que no lo utiliza, te ánimo a que sigas leyendo.
Repositorios locales y remotos
En primer lugar te quiero explicar lo que es un repositorio. El repositorio es el nombre que tiene un proyecto dentro de Git.
Para entender la filosofía de Git debemos distinguir entre el trabajo que se realiza en local (a nivel de carpeta) y el trabajo publicado en remoto.
¿Es necesario contar con un repositorio remoto? La respuesta es que no, pero perderías mucho potencial que ofrece Git.
En local puedes tener tantas copias de un repositorio remoto como quieras, y cada una puede encontrarse en un estado distinto, pero el repositorio remoto es común para todos.
Los repositorios remotos, como su nombre indica, se encuentran en servidores que se encargan de su almacenamiento. El más popular es GitHub (con el que trabajaremos en esta guía), aunque existen otros muchos o incluso puedes crearte un servidor Git.
Primeros pasos con Git, instalación
Para comenzar a trabajar con Git es necesario instalarlo en nuestro equipo. Para ello puedes descargártelo en este enlace y seguir las instrucciones de instalación.
Hay muchos pasos en la instalación, pero como ya te he dicho anteriormente es por que es un sistema muy potente. En este caso puedes instalarlo por defecto, pero te recomiendo que cuando aprendas a utilizarlo con soltura lo vuelvas a reinstalar configurando detenidamente todas las secciones (que tienen miga).
Git Hub, qué es y creación de cuenta
GitHub es una plataforma extendida entre la mayoría de programadores de código libre, y avalada por el desarrollo de Microsoft. Si todavía no tienes una cuenta este es el momento de crear una. La mayoría de las empresas de desarrollo no buscan un currículum lleno de fantasías, si no que lo que quieren es una cuenta de GitHub con mucha información sobre ti.
Para crear una cuenta de GitHub, tienes que pulsar sobre este enlace e introducir tus datos.
Una vez creada la cuenta, te quiero dar unos consejos sobre su configuración:
Proteger la cuenta
Antes de introducir código, es importante que actives el doble factor de autenticación. Para ello tienes que seguir estos:
- Pulsa sobre tu imagen de perfil, situada arriba a la derecha.
- Entra en ajustes (settings).
- Entra en contraseñas y autenticación (password and authentication)
- Habilita la autenticación de doble factor con el método que más te guste.
Configurar un email extra
Aunque no es necesario, es recomendable que si cuentas con otra dirección de email la introduzcas, ya que sabemos lo que nos sucede a veces con las contraseñas.
Para ello:
- Desde los ajustes, tienes que entrar en emails.
- En la parte superior puedes añadir tu otro email (te pedirá verificación).
- En el apartado de email de recuperación (backup email address), elige la opción de permitir todos los emails (allow all verified emails).
Con esto ya tendrás configurada tu cuenta de forma segura. Hay multitud de configuraciones y personalizaciones, por lo que puedes entretenerte un rato cambiándolo.
Configuración de tokens
Anteriormente la autenticación que se utilizaba era a través de usuario y contraseña, pero un tiempo a esta parte se ha ido sustituyendo por la autenticación mediante token, mucho más segura y personalizable. Los token son unas claves personales que identifican tu usuario en distintas situaciones con distintos permisos.
Una buena práctica es crearte uno con todos los permisos (el token de desarrollo) y otro con permisos de sólo lectura (token de producción). También puedes crear un token si quieres que alguien colabore contigo en un único repositorio.
La creación de tokens da para escribir otra entrada, pero nosotros nos vamos a centrar en lo más básico:
- Entra en los ajustes de tu perfil de GitHub (profile/Settings)
- En la barra lateral izquiera, entra dobre Developer Settings (ajustes de desarrollador)
- Aparecerá una nueva barra de menú, en la que tienes que acceder en Personal access tokens/Tokens (classic)
- Crea un token con los permisos que necesites.
Asegurate de almacenar tu token, ya que no podrás volverlo a ver. En caso de pérdida tendrás que regenerarlo, lo que supondrá la pérdida de conexión de todos los repositorios enlazados anteriormente.
Para poder utilizarlo tendrás que enlazar tu origen de la siguiente manera:
https://{{usuario_github}}:{{token}}@{{urlrepositorio.git}}
Es muy importante que lo empieces a utilizar, ya que la antigua autenticación dejará de estar disponible.
Si te fijas, lo único que tienes que hacer es añadir entre el https:// y el nombre del repositorio una cadena que identifica el usuario y el token (mediante autenticación básica).
Clonar un repositorio
Una de las claves de Git es la clonación de repositorios publicados en algún servidor. En la mayoría de los casos, cuando buscas algún ejemplo de código el desarrollador te enlaza a un proyecto de GitHub, el cual nos podemos descargar a la antigua usanza o podemos clonarle como proyecto Git.
La clonazión se realiza mediante el comando:
git clone {{url_repositorio}}
Si lo que pretendes es clonar el proyecto para trabajar con el deberás clonarlo de la siguiente forma:
git clone https://{{usuario_github}}:{{token}}@{{urlrepositorio.git}}
Si lo clonas de esta forma, ya estarás autenticado para poder realizar cambios
Creación de un repositorio
En esta guía vas a crear un repositorio en GitHub y después lo enlazarás con tu código fuente. Para ello, tienes que acceder a tu cuenta de GitHub y seguir estos pasos:
- En el menú lateral de la izquierda debes pulsar sobre New
- Rellena la información del repositorio (nombre, visibilidad, etc…)
- No hace falta que crees un gitignore ni un readme ya que lo haremos más adelante.
Cuando lo creas, GitHub te muestra unos pasos iniciales que puedes seguir para enlazarlo, aunque en este caso lo vas a hacer de otra forma.
Lo primero que debes hacer es navegar con el terminal hasta la carpeta en la que se encuentra el código fuente (carpeta principal) y escribir lo siguiente:
git init
Con este comando habrás inicializado un repositorio local de Git.
Ahora, lo que debes hacer es enlazarlo. Para ello tienes que escribir:
git remote add origin https://{{usuario_github}}:{{token}}@{{urlrepositorio.git}}
Con esto consigues que tu repositorio local esté conectado al repositorio remoto de GitHub (todavía vacío)
Lo último que debes hacer es realizar una subida inicial con el código fuente en el estado actual. Para ello escribe:
git add .
git commit -m “Commit inicial, o el mensaje que quieras poner”
git push origin {{master}}
Con esto habrás conseguido realizar tu primera subida de cambios en remoto. En la mayoría de los tutoriales el último comando se sustituye por git push, aunque a mi me gusta especificar siempre la rama a la que quiero subir los cambios.
Enlazar repositorio o desenlazar
En el punto anterior te enseñé a enlazar un repositorio remoto a tu código, pero he considerado importante explicar el proceso del enlazado y cambio de repositorio.
Para enlazar un proyecto Git a un repositorio remoto ha que hacerlo mediante el comando:
git remote add origin https://{{usuario_github}}:{{token}}@{{urlrepositorio.git}}
Para que el resultado sea correcto es necesario que el repositorio remoto esté vacío o esté en un estado anterior al mismo que tenemos, ya que Git detectará que no hay correspondencia y no podrá enlazarlo.
Si lo que quieres es quitar el enlace al repositorio remoto tendrás que escribir:
git remote remove origin
Gitignore
Un archivo básico para el correcto funcionamiento de Git es el llamado gitignore. Este archivo se encarga de combinar a Git que archivos individuales o o carpetas deben ignorarse tras sufrir cambios.
En muchas ocasiones es fundamental, ya que hay muchos IDEs que crear archivos temporales (como Visual Studio), o por la estructura del proyecto el código fuente está muy diferenciado del código compilado (como sucede con Node JS y sus node_modules). El problema es que cada vez que hablas y cierres, el proyecto sufrirá cambios, por lo que Git no de dejará seguir trabajando hasta que no vuelvas a guardar los cambios.
Primero tenemos que crear el archivo. Teclea en la consola:
touch .gitignore
Con esto creamos el archivo vacío
Una vez creado podrás buscar la plantilla que necesites y añadirlo a su contenido. En este enlace tienes las plantillas básicas de gitignore, aunque ese archivo le podrás modificar a tu gusto.
Lo siguiente que tienes que hacer es eliminar del índice de Git los archivos añadidos anteriormente:
git rm -r —cached . git add .
Con esto, habrás eliminado todos los archivos del índice de Git, y añadido únicamente los que permitas mediante el gitignore.
Publicación de cambios
Algo fundamental del trabajo con Git es la publicación de cambios. Tendrás que acostumbrarte a hacerlo a menudo (por lo menos una vez al día), ya que es la forma que tendrás de revertir cambios o de salvar tu trabajo en caso de tragedia.
Yo te recomiendo que lo hagas cada vez que resuelvas un problema, o antes de que te embarques a realizar un cambio crítico que puede fallar. Otra de las recomendaciones que te hago, es que seas muy claro con el mensaje que pones, e incluso que los numeres ya que así podrás recorrerlos de una forma muy visual.
En primer lugar, para ver el historial de cambios puedes escribir:
git log
Para salir del historial tienes que escribir «q» de quit.
Te mostrará todo el historial de cambios, ordenados de más recientes a más antiguos.
El proceso de guardar los cambios es:
git add . git commit -m “1.2 - Cambios realizados”
Este es un ejemplo, tu puedes poner lo que quieras entre comillas
Si los quieres salvar en el repositorio remoto:
git push origin {{nombre-rama}}
Con estos comandos, lo primero que has hecho es añadir todos los archivos nuevos (en caso de existir). Lo segundo es añadir un mensaje que haga referencia a los cambios.
Por último, has subido los cambios al repositorio remoto (opcional). En caso de que no subas algún cambio al repositorio remoto, cuando lo hagas se subirá la lista de cambios realizados anteriormente.
Revertir cambios
Llegamos al momento del botón rojo, el Control Z. Hay ocasiones en las que se han publicado unos cambios que creías correctos, pero no habías calculado todos los supuestos y ha fallado. Es el momento de volver atrás, sin peder todos los cambios realizados a posteriori.
Para ello, lo primero que tienes que hacer es identificar el estado al que quieres volver. Teclea:
git log
Navega hasta el estado correcto, y copia el identificador del cambio.
Ahora escribe:
git checkout {id} <strong>.</strong>
IMPORTANTE: no te olvides del punto final.
También lo puedes hacer con el comando, aunque se perderán los últimos cambios:
git reset --hard HEAD~{{3}}
El 3 son los número de commit que deseas revertir
Creación de las ramas
Llegados a este punto, creo conveniente entrar en el maravilloso mundo de las ramas. Una rama es una bifurcación de tu proyecto para poder tener distintas versiones a la vez.
Si te parece confuso piensa en un río. Tiene un nacimiento, pero en un momento dado se puede canalizar parte para realizar otras tareas (presas, regadío, etc..), más adelante vuelve a juntarse con el curso principal.
Cuando creamos un repositorio, por defecto estamos trabajando en la rama principal llamada master. El nombre se puede configurar en las opciones de Git, aunque por intentar seguir los estándares, te recomiendo que siempre tengas como rama principal la master, ya que te ahorrará muchos quebraderos de cabeza y ramas duplicadas (la rama main es muy típica).
La utilización de las ramas es libre, aunque te voy a listar los casos más comunes:
- Sólo la principal (master): Se trabaja siempre en el mismo hilo. Los estados son secuenciales (no recomendable).
- Entornos y versiones (master, beta, versión): Se divide el proyecto en versiones, y se testea previamente antes de su publicación en master.
- Multi-desarrollo (master, desarrollador1, desarrollador2, etc…): Se utiliza para permitir el trabajo en equipo. Cada desarrollador cuenta con una rama y de vez en cuando ponen en común los cambios.
- Incidencias (master e incidencia): Se crea una rama nueva por cada incidencia. Cuando se soluciona y se prueba, se fusiona con la rama principal y se elimina la incidencia (en algunos casos).
Independientemente de cual sea tu caso de uso, la creación de ramas es igual:
git checkout -b {{nombre-rama}}
Con este comando, se creará una rama nueva con el estado de la rama actual.
Es cierto que se pueden crear con el comando git branch, pero he querido simplificar al máximo esta guía (y aun así es bastante extensa).
Para cambiar de rama tienes que escribir:
git checkout {{nombre-rama}}
Escribiendo este comando es cuando comienzas a ver la magia de Git, ya que se cambiarán todos los archivos de tu proyecto y se mostrarán en el estado de esa rama. No te asustes que escribiendo estos comandos no se borra nada.
Fusión de cambios
Cuando trabajas con ramas, es necesario fusionarlas de ciento en viento. El proceso es bastante sencillo pero en ocasiones surgen los problemas de fusión porque git no es capaz de resolver el cambio con el que deseas quedarse. Por lo general sucede cuando se modifica la misma parte del código por dos ramas distintas.
Para fusionar una rama, lo primero que tienes que hacer el moverte a la rama que recibirá la fusión (y no al revés). Para ello:
git checkout {{rama-principal}}
Ahora, tienes que traerte los cambios de la rama nueva:
git merge {{rama-nueva}}
Por último, te recomiendo que publiques los cambios en remoto, para ello:
git push origin {{rama-principal}}
Comandos de Git
En esta sección voy a resumirte los comandos que hemos visto en esta guía para que la tengas de referencia:
| Comando de Git | Cometido del comando |
|---|---|
| git init | Inicializa el repositorio de Git |
| git add | Añade los archivos al índice de Git |
| git rm | Elimina los archivos del índice de Git |
| git commit | Se crea un punto de restauración |
| git checkout | Sirve para cambiar de rama y volver a un estado anterior |
| git remote [add | remove] | Añade o elimina el enlace al repositorio remoto |
| git merge | Fusiona los cambios de otra rama a la rama actual |
| git push | Sube los cambios locales al repositorio remoto |
| git pull | Descarga los cambios del repositorio remoto al local |
| git log | Muestra los cambios y los estados del repositorio |
| git status | Muestra el estado actual del repositorio. |
Conclusiones
Como habrás podido ver, Git es un gigante y es prácticamente imposible aglutinar todo en un sólo artículo.
Además, aunque yo lo use todos los días en mi trabajo, no me considero experto en Git, por lo que este artículo está escrito para ayudarte con lo que sé hasta ahora.
Hay mil formas de hacer lo mismo, yo utilizo estas y hasta la fecha me funcionan muy bien, aunque puede que tu conozcas otra mejor. Si es así no dudes en escribirme un comentario.
¡Espero que te resulte de utilidad, y muchas gracias por visitarme!
Deja un comentario