articulo

Git y sus travesuras en el día a día

Bueno esta entrada esta basada en la última travesura que se tuvo con Git. El contexto es que se necesitaba crear una rama nueva del proyecto en que se trabaja, subir los fichero y listo. Nada del otro mundo.

Travesuras cometidas

  • Crear la rama primero en el servidor. Algo que se debe de hacer en local y después subirla. Para eliminarla del server se debe de hacer uso del comando $ git push origin --delete <nombre_rama_borrar>
  • Tener una lista de cambios realizados en diferentes ficheros y no haberles hecho un commit o push.
  • Crear la rama en local y agregar los archivos de golpe (add .), al menos que no existan ficheros que se deban excluir.
  • Equivocar la ruta del server, existe una diferencia entre acceder vía web al git, o acceder por la terminal vía ssh. Visualiza los remotos $ git remote -v y despues elimina tu remoto $ git remote rm <alias_server> En ocaciones es necesario monitorear el server se sugiere hacer uso del comando $ git remote show <alias_server>
  • Error en autenticar, una de las maneras recomendables de acceder por ssh y subir los archivos al server, el cual debe de tener una contraseña diferente a la que se accede vía web. Para el caso de bitbucket, existe la generación de app key que permite generar una key para acceder desde la terminal. Otra forma es generar la key rsa, la diferencia es que en éste hay que crear un fichero de configuración y se suele recomendar que el nombre que se use en el user.name del config sea el mismo.
  • Olvidar configurar las credenciales, el user.name y user.email del config.
  • Olvidar iniciar git en el folder a trabajar, es como decirle a git que en ese folder hay que tomarlo en cuenta.
  • Perder los cambios realizados en un proyecto, (lo recomendable es siempre respaldar). Si por algún motivo se llega a ir a la carpeta de configuración del git y se animan a darle un rm index, respalden, marcará error de que el index es demasiado pequeño. Lo recomendable es que se cree otro directorio fuera del que se este trabajando, se inicie git y se empiece de nuevo.

Por lo que después de resolver cada travesura de git se obtuvo el siguiente algoritmo para trabajar con git:

Pasos para trabajar con git y crear una rama nueva en el server.

  1. Crea un directorio en tu equipo, este contendrá los documentos o archivos a subir al server. $ mkdir proyecto1
  2. Colocarse en el folder creado. $ cd proyecto1
  3. Iniciar git. $ git init
  4. Verificar las variables globales. $ git config --list
    • si el user.name y el user.email no son los correctos o no existe. Hay que modificarlos.
      • $ git config --global user.name "Alexandra"
      • $git config --global user.email "alexadra@dominio.com"
    • Verifique que aparezca los nuevos datos que se han agregado.
    • Si se topa con un texto como «credential.helper» se recomienda quitarlo, no es más que una ventana que salta pidiendo clave para acceder. Se puede quitar con estos comandos $ git config --local --unset credential.helper $ git config --global --unset credential.helper $ git config --system --unset credential.helper
  5. Agregar el servidor remoto. $ git remote add alias user@<servidor>:/directorios/<proyecto>.git en el supuesto que tenga un servidor git en una rpi, el comando quedaría: $git remote pi git@192.168.3.99:/home/git/proyecto.git
  6. Validar que el servidor se agrego correctamente. $ git remote -v, deberá mostrar un listado donde viene el alias que se le dio y asignada.
  7. Crear ficheros, directorios a subir. Si cuenta con un respaldo o esta probando solo cree un archivo.txt (puede usar el comando nano archivo.txt y escribir dentro «hola git«)
  8. Crear una rama, se puede hacer con el uso del comando $ git branch <nombre_rama>.
    • Si llega a marcar algún tipo de error donde no se haya creado la rama utilice el comando: $ git checkout -b <nombre_rama> y omita el paso 10
  9. Validar que la rama se ha creado, se hace con el comando $ git branch
    • Si por algún motivo no llega a mostrar nada el comando $ git branch, se puede ejecutar el comando: $ git show-branch
  10. Moverse a la rama creada, se hace con el comando: $ git checkout <nombre_rama>
  11. Agregar los ficheros que se quieren subir. Se puede usar $ git add . si solo se quiere agregar determinados ficheros $ git add <nombre_archivo>
  12. Visualizar el estatus del git, se realiza con el comando $ git status Mostrará los cambios que se han realizado.
  13. Hacer el commit, se debe de hacer uso del $ git commit -m "mensaje"
  14. Listar los elementos o archivos que se encuentran dentro de una rama, se hace uso del comando $ git ls-tree -r --name-only <comit o branch>
  15. Mandar los cambios (archivos / directorios) al servidor, se hace uso del $git push -u <alias> <rama>
    • Nota: el parámetro -u solo se usa la primera vez que se va a enviar datos al server y se a creado una nueva rama. Así que la próxima vez que se modifique un fichero y se envíe al mismo server en la misma rama, solo hay que quitar ésta opción.
  16. Pedirá la calve de autenticación si se esta usando bitbucket, habría que colocar la key app que se genero en el se sección personal setings (ver acá) y listo

Claro que no siempre es necesario estos 16 pasos, éstos se usarán cuando se crea por primera vez una instancia y se agrega un server, si todo ha salido bien al final se estará usando los siguientes pasos:

Pasos de uso continuo en git y una creación de rama nueva

  1. Crear carpeta de proyecto $ mkdir <nombre_proyecto>
  2. Moverse al folder creado $ cd <nombre_proyecto>
  3. Crear una rama nueva $ git branch <nombre_rama_nueva> o $ git checkout -b <ombre_rama_nueva>
  4. Validar la creación de la rama $ git branch o $ git show-branch
  5. Agregar ficheros $ git add . o $ git add <nombre_archivo>
  6. Hacer el commit $ git commit -m
  7. Enviar los datos al server $ git push -u <alias> <rama>
    • No olvidar que la opción -u es solo para las ramas nuevas.

Y finalmente, se va a estar trabajando y modificando fichero o agregando algo más nuestros pasos finales serían.

Pasos para el día a día, con server agregado y ramas ya creadas

  1. Validar la rama en la que se deben de enviar los archivos. $ git branch o $ git show-branch
    • Si se tiene que cambiar de rama usar $ git checkout <nombre_rama>
  2. Agregar los ficheros $ git add <nombre_archivo>
  3. Validar el estado antes del commit $ git status
  4. Hacer el commit $ git commit -m "mensaje"
  5. Enviar al server $ git push <alias> <rama>

Estos fueron los pasos que se obtuvieron después de resolver cada una de las travesuras cometidas en el git.

Dejar una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *