Objetivo de aprendizaje

Al finalizar esta lectura, el estudiante será capaz de comprender la función de Git como sistema de control de versiones, reconocer su importancia en el trabajo colaborativo y utilizar los comandos básicos de GitHub mediante una práctica guiada.

Introducción: ¿Por qué aprender Git y GitHub?

En el mundo actual del desarrollo, el control de versiones es una herramienta esencial. Git permite registrar cada cambio que hacemos en un proyecto, facilitando el trabajo en equipo y evitando la pérdida de información.
Por su parte, GitHub es la plataforma en línea que potencia esta colaboración, ofreciendo un espacio para compartir, mejorar y mantener proyectos de manera segura.

Si alguna vez te has preguntado cómo los equipos de software pueden trabajar en el mismo código sin confundirse, la respuesta está en Git y GitHub.

¿Qué es Git y por qué es importante?

Git es un sistema que guarda el historial completo de los archivos de un proyecto.
Su importancia radica en que permite:

• Rastrear los cambios realizados en el código.
• Volver a versiones anteriores si algo sale mal.
• Colaborar con varios desarrolladores al mismo tiempo.

Con Git, cada persona puede trabajar en su propia rama sin afectar el código principal, lo que mejora la organización y la productividad.

¿Qué es GitHub?

GitHub es una plataforma que utiliza Git para almacenar repositorios en la nube.
Permite gestionar proyectos, compartir código, revisar cambios y coordinar equipos de desarrollo.
Además, sirve como portafolio profesional y herramienta educativa para aprender prácticas de colaboración.

Entre sus principales funciones destacan:

• Repositorio remoto: copia del proyecto disponible en línea.
• Pull Requests: solicitudes para fusionar cambios entre ramas.
• Forks: copias independientes de proyectos públicos.
• Issues: registro de errores o sugerencias.

Cheatsheet de GitHub (comandos esenciales)

Dominar GitHub es más sencillo cuando se conocen sus comandos básicos.
Aquí tienes una cheatsheet con los más usados:

Consejo: antes de subir tus cambios, asegúrate de ejecutar git status para verificar el estado de tu proyecto.

Actividades de aprendizaje

Para consolidar tu conocimiento, te invitamos a realizar las siguientes actividades interactivas:

1. Actividad práctica: realiza paso a paso la práctica “Domina GitHub y no mueras en el intento”.
2. Actividades de reforzamiento: completa la sopa de letras y el crucigrama sobre los conceptos clave de Git y GitHub.

Estas actividades te ayudarán a reforzar los conceptos, aplicar los comandos básicos y familiarizarte con las herramientas de colaboración más utilizadas en el mundo del desarrollo.

Aprender Git y GitHub no solo mejora tus habilidades técnicas, sino que también fortalece tu capacidad de trabajo en equipo.
Ambas herramientas te permiten colaborar, registrar avances y mantener proyectos organizados.
Empieza por dominar los comandos básicos y ponlos en práctica con las actividades propuestas: ¡la experiencia te hará experto!

La entrada Uso de Git y cheatsheet de GitHub se publicó primero en Frexus.

Subiendo ficheros

1. Selecciona el repositorio en el que quieres subir los ficheros. También se debe de validar que se tenga elegida el branch (rama) correcta.
2. Hay una opción que dice: “agregar ficheros” o. “add file”, pulse sobre esa opción y le brindará un par de opciones, crear un archivo o subir un directorio.
3. Elija la opción subir un directorio, claro que previamente ya debe de tenerlo en su computador.
4. Arrastre su directorio o archivos, escriba que es lo que contiene sus ficheros y pulse sobre el botón que dice “commit change”

Hay que tener en cuenta que la forma en que se tenga las carpetas es la misma manera en la que se creará en el github. A continuación se deja una serie de imágenes que muestran gráficamente los pasos anteriores.

La entrada Git: GitHub y los fichero se publicó primero en Frexus.

El Laboratorio consiste en:

• Montar un servidor que permita recibir los archivos.
• Un cliente desde donde se enviarán los ficheros.
• Hacer uso de los comandos de git para comprenderlos.

Creando Servidor Git

Para esta etapa se debe de contar con un equipo con alguna distribución de GNU/Linux preferentemente. Si no cuenta con ello, se recomienda enteramente instale una en el pc que menos usa.

1. Se debe de contar ya con la instalación de git, si no lo tiene instalado puede ejecutar en la terminal el siguiente comando: $ sudo apt-get install git
2. Se crea un usuario para git, usando el comando: $ sudo adduser git
3. Ahora hay que cambiar de usuario, con el comando: $ su git
4. Se debe de dirigir a la carpeta del usuario git, haciendo uso del comando: $ cd /home/git
5. Se tiene que crear una carpeta donde se alojaran los proyectos con el comando $ mkdir <nombre_carpeta>.git
6. Debe de moverse dentro del directorio creado, con el comando $ cd <nombre_carpeta>.git
7. Una vez dentro del folder, se debe de ejecutar el siguiente comando $ git init --bare

Una vez realizado los pasos anteriores se ha creado un servidor git auto alojado en la red del hogar o del trabajo. Ahora solo queda hacer uso de alguno de los pasos que se listan aquí donde se exponen una serie de “travesuras” o errores que suelen cometerse cuando se inicia en git.

La entrada Montar un server Git se publicó primero en Frexus.

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.

La entrada Git y sus travesuras en el día a día se publicó primero en Frexus.

“Hagas lo que hagas en tu local git lo refleja en el remoto cuando lo hayas enviado, pero no de manera automática” – o al menos hasta hoy aún no encuentro esa forma. –

Lo cierto es que para hacerlo hay que indicar al git que directorio y carpeta se van a eliminar o cambiar en el remoto y posteriormente indicar las carpetas y ficheros que se van a agregar con los cambios los comandos que nos ayudan en esta tarea son los siguientes:

git rm --cached  <ruta/nombre del archivo>

Con el comando git rm --cached se quita del cache del git el fichero que se eliminará del remoto.

ya una vez realizado toda las eliminaciones solo queda hacer el commit y el push

git commit -m "mensaje"
git commit origin <branch>

para agregar los cambios realizados se puede ir fichero por fichero o se puede hacer uso del comando:

git add --all

El comando git add -all agregará todo hasta los directorios ocultos, es posible que se quiera.

git -add .

El comando git add . agregara los ficheros modificados

La entrada Git y los ficheros remotos se publicó primero en Frexus.

Recuerdo hace unos años acceder a un server remoto era super fácil en la terminal copiabas el comando para clonar el repo y listo. – hasta ahí me había quedado – :/

Ahora hay que generar una clave de acceso para la aplicación con la que quieras entrar e incluso indicar a que aplicación va acceder con esa clave y esa clave es un hash para acceder. Me paso con bitbucket. Tarde un par de días en comprender que es lo que faltaba todo estaba bien menos que a la hora de realizar el clon desde la terminal marcaba error y error de permisos, key invalida. (vea imagen 1)

Muchas opciones de como solventar ese error, borrar las key de los accesos ssh, instalar una aplicación propietaria y demás maromas. Hasta que mirando en el apartado de configuraciones de bitbucket hay una sección que dice “app paswords” así que generas una de esas copias el comando de git clone por https y cuando te pide la clave colocas la que generate y pum se hace el clone del repo en tu equipo. (Vea imagen 2)

Una tontería quizá pero de todos los lugares que consulte para solventar ese detalle ninguno funciono mejor que este y después crear una rama, empujar los cambios hacer commit se sintió como hacerlo en local con la diferencia de que todo se enviaba hacia el bitbucket.

En la imagen 2, se llega a esa sección pulsando en el perfil y haciendo clic en la opción “Personal sentting” se pulsa sobre app passwords luego sobre la opción crear y se debe de seleccionar las opciones que se consideren necesarias.

Clonas el repo a tu equipo, luego haces las modificaciones, agregas los ficheros, haces el commit y después envías las modificaciones.

git checkout -b <nombre de la rama>
git push origin --set-up <nombre de la rama>
git add . 
git commit -m "cuerpo del mensaje"
git push

La entrada Git y los remotos se publicó primero en Frexus.

Para ello una solución es enviar a un repositorio ya sea que se encuentre en alguna nube, o en algún disco duro externo donde se tenga los últimos respaldos, los conflictos que llegan a existir es que si el internet no es el adecuado o no se dio los permisos correctos no se podrá o bien descargar y / o actualizar el documento. Y bueno en el otro caso (el del disco duro) pues se tiene el detalle de la corrupción de los datos.

Existe un mecanismo que se llama “Control de Versiones” en sus inicios se usaba uno llamado SVN completamente multiplataforma, con muchas bondades en su tiempo, se podía actualizar en tiempo real los documento y visualizar los cambios existentes entre cada documento, si valía la pena sustituir el nuevo documento por el que se tenía ya.

Con la evolución se crea un concepto llamado “git” el cual puede armarlo en un espacio local con un par de comando o si tienes un poco mas de infraestructura se puede montar un server que permita controlar las versiones e incluso crear nuevas versiones apartir de una ya existente, a esa acción se le llama “fork o rama“

Para la instalación de git en un equipo de computo hay que ir a la siguiente url: https://gitforwindows.org/ si eres usuario de windows, si eres usuario de macosx puedes seguir este enlace: https://git-scm.com/download/mac. Si eres usuario de alguna distribución linux usa este otro enlace: https://git-scm.com/book/es/v2

En el último enlace se puede notar que viene con una serie de documentación en español donde se trata todo lo relacionado con git. Este software de control de versiones, puedes montarlo en tu propio equipo o en un servidor donde te permita hacer los cambios o respaldos de los documentos que utilices, nació para llevar el control de versiones de los programas todo su código fuente, pero hay personas que han usado git para llevar el control de sus tesis, y demás proyectos documentales.

Git y su instalación

Algunas distribuciones linux traen git o alguna versión instalada en el sistema. Para saber si tienes git instalado ejecuta el siguiente comando en la terminal: “git –version” si se encuentra instalado mandará un resultado como lo que se ve en la imagen 1.

Si no aparece nada después de pulsar enter, o marca un error que diga “que no se encuentra el comando git“, entonces se deberá instalar. Para instalar Git en distribuciones linux que son derivadas de Redhat, se puede usar el siguiente comando: “dnf install git” sin las comillas y siendo super usuario. Si usan alguna distro basada en debian pueden usar el siguiente comando: “apt install git” y el comando empezara hacer lo demás. Si están en una macOsx o windows, solo deben de seguir el asistente.

A continuación se deja un curso básico de git. De los amigos de codigofacilito:

La entrada Repositorios, gestión y git se publicó primero en Frexus.