Crear repositorio Git desde Git Bash
Git es una de las herramientas de control de versiones más utilizadas hoy en día. Aunque hace algún tiempo eran más populares los sistemas centralizados como SVN, la realidad es que actualmente Git es el amo y señor en este campo. Si estás trabajando en una aplicación relativamente moderna, no me estaría arriesgando demasiado si dijera que estáis usando Git para el control de versiones. Así que os recomiendo que profundicéis todo lo posible en el manejo de esta herramienta, ya que es un conocimiento transversal que os podréis llevar de un proyecto a otro.
Dicho esto, vamos a ver lo básico de Git. Os quiero comentar los pasos necesarios para crear e inicializar un repositorio Git para vuestro proyecto. Aunque esto se puede realizar de varias formas, en concreto hoy quiero explicarlo utilizando la herramienta Git Bash, ya que se trata del método que con seguridad podremos emplear en cualquier tipo de proyecto.
Crear repositorio Git desde Git Bash
Obviamente, en primer lugar tendremos que disponer del proyecto para el que surge la necesidad de establecer un control de versiones. Ese será el proyecto para el que vamos a crear el repositorio Git. En nuestro caso, vamos a partir de un proyecto del siguiente tipo:
Vamos a crearnos una clase java básica en el paquete com.universo.repositorio. El contenido de dicha clase es irrelevante y solamente nos servirá para ir viendo cómo se agregan las modificaciones al repositorio Git. Por ejemplo, creamos la clase AppGit.java
// **************************************************
package com.universo.repositorio;
public class AppGit {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Creacion de un repositorio Git desde Git Bash");
}
}
//**************************************************
Inicializar repositorio Git desde Git Bash
Una vez que tenemos identificado el proyecto a versionar, ya podemos irnos a la herramienta Git Bash e inicializar el repositorio desde allí.
1º) Nos vamos al explorador de Windows y nos situamos en la carpeta raíz del proyecto. En mi caso se trata de la siguiente ubicación:
C:\Users\jjsanchez\eclipse-workspace-2021\universojava\ControlGitBash
2º) Desde ahí ejecutamos la herramienta Git Bash. Se nos debería abrir una ventana ubicada en la carpeta del proyecto. Esto es, algo así:
3º) A continuación, desde la ubicación en la que nos encontramos, procedemos a crear el repositorio Git con el comando de inicializar:
git init
La ventana nos mostrará algo así:
4º) Si hacemos un git status, podremos ver que ahora tendremos todo el contenido del proyecto pendiente de incorporar al repositorio.
git status
Nos mostrará algo así:
Commits iniciales del repositorio
5º) Llegados a este punto, ya podemos pasar el contenido del proyecto al área Index de Git. Con esto dejaremos el contenido preparado para realizar el commit inicial.
git add .
Como vemos, el contenido ha quedado incorporado al Index.
6º) A continuación, realizamos el commit inicial del proyecto añadiendo todo el contenido que se encuentra pendiente en el Index.
git commit -m "Commit inicial del proyecto"
El resultado sería el siguiente:
7º) Vamos a añadir un segundo commit, para crear algo de historia en nuestro proyecto. Modificamos la clase AppGit.java para que quede de la siguiente forma:
// **************************************************
package com.universo.repositorio;
public class AppGit {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Creacion de un repositorio Git desde Git Bash");
System.out.println("Commit intermedio");
}
}
//**************************************************
8º) A continuación, realizamos el commit de las modificaciones que acabamos de introducir en nuestro proyecto con los comandos requeridos.
git add .
git commit -m "Commit intermedio"
El resultado será el siguiente:
9º) Añadimos un tercer commit para crear historia adicional en nuestro proyecto. La clase AppGit.java debería quedar algo así:
// **************************************************
package com.universo.repositorio;
public class AppGit {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Creacion de un repositorio Git desde Git Bash");
System.out.println("Commit intermedio");
System.out.println("Commit realizado antes de conectar con GitHub");
}
}
//**************************************************
10º) A continuación, consolidamos el commit de las modificaciones que acabamos de realizar en nuestro proyecto con los comandos requeridos.
git add .
git commit -m "Commit realizado antes de conectar con GitHub"
El resultado será el siguiente:
11º) Si consultamos el historial de nuestro repositorio, veremos que ahora en nuestro entorno local tenemos un proyecto con 3 commits asociados.
git log --oneline
Deberíais tener algo como esto:
Crear repositorio remoto en GitHub
12º) A continuación, vamos a crearnos un repositorio remoto en GitHub para poder ir subiendo los cambios que hemos realizado en nuestro entorno local y tener un respaldo en la nube. Para ello, desde GitHub seleccionamos el icono "+" y posteriormente marcamos la opción "NEW REPOSITORY".
🚨 Para aquellos que no conozcáis GitHub (si es que todavía queda alguien), os dejo aquí abajo el enlace para que podáis acceder y crearos una cuenta con ellos.
13º) En la siguiente pantalla tendremos que indicar el nombre del repositorio remoto con el que vamos a conectar nuestro repositorio local de Git. Yo voy a crearme un repositorio con el nombre:
repo-controlgitbash
Quedará indicado así:
14º) En la parte de abajo de la pantalla tenemos un apartado denominado "INITIALIZE THIS REPOSITORY WITH". En un proyecto normal, lo correcto sería crearnos el repositorio generando tanto el archivo README como el archivo .gitignore. Sin embargo, como hoy el objetivo simplemente es dar una idea global básica de cómo se crea un repositorio Git, vamos dejar dichas opciones sin marcar.
15º) Finalmente, una vez hayamos configurado nuestro repositorio remoto en GitHub, pulsamos el botón CREATE REPOSITORY.
Nos aparecerá una pantalla como la siguiente.
👉 Aquí se nos indica el endpoint en el que estará ubicado nuestro repositorio remoto:
https://github.com/alcaudon71/repo-controlgitbash.git
Adicionalmente, en la parte de abajo de la pantalla nos aparece una ayuda con las instrucciones que habría que ejecutar para conectar nuestro repositorio local con el repositorio remoto que nos acabamos de crear. Por ejemplo, en mi caso me aparece lo siguiente:
…or create a new repository on the command line
echo "# repo-controlgitbash" >> README.md git init git add README.md git commit -m "first commit" git branch -M main git remote add origin https://github.com/alcaudon71/repo-controlgitbash.git git push -u origin main
…or push an existing repository from the command line
git remote add origin https://github.com/alcaudon71/repo-controlgitbash.git git branch -M main git push -u origin main
Conectar repositorio Git con repositorio GitHub
16º) Ahora nos toca volver a la herramienta Git Bash para realizar la conexión de nuestro repositorio local con el repositorio creado en GitHub. Procedemos a indicar:
git remote add origin https://github.com/alcaudon71/repo-controlgitbash.git
El resultado será el siguiente:
Ahora ya tenemos enlazados ambos repositorios.
17º) A continuación, procedemos a subir a nuestro repositorio GitHub los cambios existentes en nuestro repositorio Git local. Esto se hace con el siguiente comando:
git push -u origin master
18º) Nos aparecerá la ventana de validación de GitHub. Introducimos nuestro usuario y password de GitHub. Pulsamos LOGIN.
19º) Nos aparecerá una ventana en la que se solicita nuestro usuario de acceso OpenSSH al repositorio de GitHub. Introducimos nuestro usuario y pulsamos OK.
20º) Nos aparecerá una ventana en la que se solicita nuestra password de acceso OpenSSH al repositorio de GitHub. Introducimos nuestra password y pulsamos OK.
21º) Si todos los pasos anteriores han ido correctamente, finalmente el contenido de nuestro repositorio local se habrá subido al repositorio remoto.
Nos debería aparecer algo así:
22º) Si volvemos a GitHub y visualizamos de nuevo el contenido del repositorio que nos hemos creado hace algunos pasos, ahora el aspecto será el siguiente.
Como vemos, ahora nos aparece la rama "master" del repositorio, junto con el contenido que acabamos de subir desde nuestro repositorio local.
23º) Si pulsamos en el botón de "COMMITS", podremos ver el historial de commits de nuestro proyecto, que debería coincidir con los 3 commits que nos hemos creado al principio de este post. Deberíais tener una pantalla tal como esta:
Ahí podemos ver enumerados los 3 commits iniciales que hemos creado en el proyecto:
- Commit inicial del proyecto
- Commit intermedio
- Commit realizado antes de conectar con GitHub
Sincronizar repositorio local con GitHub
24º) Ahora procedemos a añadir un nuevo commit en nuestro proyecto para crear historial posterior a la conexión con GitHub. La clase AppGit.java debería quedar algo así:
// **************************************************
package com.universo.repositorio;
public class AppGit {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Creacion de un repositorio Git desde Git Bash");
System.out.println("Commit intermedio");
System.out.println("Commit realizado antes de conectar con GitHub");
System.out.println("Ya tenemos repositorio en GitHub");
}
}
//**************************************************
25º) A continuación, realizamos el commit de las modificaciones que acabamos de incluir en nuestro proyecto con los comandos requeridos.
git add .
git commit -m "Ya tenemos repositorio en GitHub"
El resultado será el siguiente:
26º) Posteriormente subimos los cambios que acabamos de realizar al repositorio remoto (esto es, al repositorio que hemos abierto en GitHub). Esto lo hacemos con el siguiente comando:
git push
El resultado será el siguiente.
Como vemos, el mensaje de git status nos está indicando que nuestra rama local "master" ya está sincronizada ("up to date") con la rama "origin/master" alojada en GitHub.
27º) Finalmente, volvemos a GitHub y comprobamos si se ha actualizado el contenido del repositorio. Para ello, nos vamos a la consulta de commits del proyecto.
Como se aprecia, en el inventario ya nos aparece el nuevo commit que acabamos de crear con posterioridad a la conexión con el repositorio GitHub. Ahora tenemos los 4 commits siguientes.
- Ya tenemos repositorio en GitHub
- Commit inicial del proyecto
- Commit intermedio
- Commit realizado antes de conectar con GitHub
Aunque parecen muchos pasos, la realidad es que aquí hemos visto el proceso muy detallado y eso lo hace parecer más complicado de lo que es. La realidad es que, una vez que estemos un poco rodados, la creación de un repositorio Git pasará a ser una actividad que realizaremos de manera más o menos automática. Leed el post un par de veces más y veréis como la cosa se capta con mayor claridad. Eso sí, tened en cuenta que aquí hemos visto los pasos a seguir con la herramienta Git Bash, pero existen muchas más alternativas para ejecutar el procedimiento que hemos visto hoy.
Pues nada, eso era todo lo que quería comentaros en relación con la creación de un repositorio Git desde Git Bash. Espero que la guía os resulte de utilidad a los programadores que sois principiantes (y a los no tan principiantes). Si es así, entonces el post habrá cumplido con su función...
Saludos.
Comentarios
Publicar un comentario