Lic informatica: Github

GitHub es una plataforma de alojamiento de código que utiliza Git para control de versiones. Puedes usar GitHub para almacenar, gestionar y colaborar en proyectos de software. A continuación te guío en el uso básico de GitHub.

1. Crear una cuenta en GitHub

Si aún no tienes una cuenta, ve a GitHub.com y regístrate.

2. Instalar Git

Git es el sistema de control de versiones que GitHub usa. Necesitas tenerlo instalado en tu sistema para poder interactuar con GitHub desde la terminal.

Para instalar Git, visita Git SCM y sigue las instrucciones de instalación para tu sistema operativo.

3. Configurar Git

Una vez que tengas Git instalado, debes configurarlo con tu nombre y correo electrónico (este correo debe ser el que usaste para crear tu cuenta en GitHub).

Abre una terminal y ejecuta los siguientes comandos:

git config --global user.name "Tu Nombre"
git config --global user.email "tu-email@example.com"

4. Crear un repositorio en GitHub

Ve a GitHub.com, inicia sesión y haz clic en el botón "New repository" (Nuevo repositorio).
Elige un nombre para tu repositorio.
Decide si quieres que sea público o privado.
Marca la opción "Initialize this repository with a README" si deseas iniciar con un archivo README.
Haz clic en "Create repository".

5. Clonar un repositorio a tu computadora

Para trabajar localmente con tu repositorio de GitHub, puedes clonar el repositorio en tu máquina.

Ve al repositorio en GitHub que quieras clonar.
Haz clic en el botón verde "Code" y copia la URL.
Abre tu terminal y navega hasta el directorio donde quieres clonar el repositorio.

Ejecuta:

git clone https://github.com/usuario/nombre-repositorio.git

Esto creará una copia local del repositorio en tu máquina.

6. Hacer cambios y subirlos a GitHub

Ahora que has clonado el repositorio, puedes hacer cambios y subirlos a GitHub. Aquí están los pasos básicos:

Haz cambios en tu proyecto local (edita, crea o elimina archivos).
Abre la terminal y navega al directorio del repositorio clonado.
Agrega los cambios al área de preparación:
```
git add .
```

Haz un commit de los cambios:

git commit -m "Descripción de los cambios"

Sube los cambios a GitHub:
```
git push origin main
```

7. Crear una rama y trabajar en ella

En lugar de trabajar directamente en la rama principal (main), es una buena práctica crear ramas para nuevas características o cambios.

Crea una nueva rama:
```
git checkout -b nombre-de-la-rama
```
Haz cambios y sigue los pasos de agregar, hacer commit y subir (add, commit, push).
Para subir tu rama al repositorio remoto:
```
git push origin nombre-de-la-rama
```

8. Hacer un Pull Request

Después de trabajar en tu rama, puedes hacer un Pull Request para solicitar la incorporación de tus cambios a la rama principal.

Ve a tu repositorio en GitHub.
Haz clic en la pestaña Pull Requests y luego en New Pull Request.
Selecciona la rama con los cambios y compárala con la rama principal.
Proporciona una descripción detallada y envía el Pull Request.

9. Colaborar en proyectos existentes

Puedes colaborar en otros proyectos de GitHub clonando sus repositorios o haciendo un fork de ellos para trabajar en tu propia copia del proyecto.

Fork: Copia el repositorio de otra persona a tu cuenta.
Pull Request: Solicita que los cambios que hiciste en tu fork sean incluidos en el proyecto original.

10. Ver historial de cambios

Para ver el historial de commits en tu proyecto:

git log

Comados mas usados en github

Los comandos más utilizados en Git y GitHub suelen estar enfocados en la administración básica del flujo de trabajo con ramas, sincronización con el repositorio remoto y la colaboración entre desarrolladores. Aquí te dejo una lista de los comandos más usados:

1. Clonar un repositorio

Clonar un repositorio de GitHub a tu máquina local:
```
git clone https://github.com/usuario/repo.git
```

2. Agregar y confirmar cambios

Ver el estado del repositorio (archivos modificados, no rastreados, etc.):
```
git status
```
Añadir archivos al área de preparación:
- Para un archivo específico:
```
git add archivo.txt
```
- Para todos los archivos modificados:
```
git add .
```
Hacer un commit (guardar los cambios de los archivos en el repositorio):
```
git commit -m "Descripción del cambio"
```

3. Subir cambios al repositorio remoto

Enviar los cambios confirmados al repositorio remoto:
```
git push origin main
```
Donde origin es el nombre del remoto (por defecto), y main es la rama principal.

4. Obtener cambios del repositorio remoto

Actualizar la rama local con los últimos cambios del repositorio remoto:
```
git pull origin main
```

5. Trabajar con ramas

Crear una nueva rama:
```
git checkout -b nueva-rama
```
Cambiar a una rama existente:
```
git checkout nombre-rama
```
Fusionar una rama en la rama actual:
```
git merge nombre-rama
```

6. Gestionar ramas remotas

Listar todas las ramas (locales y remotas):
```
git branch -a
```
Subir una nueva rama al repositorio remoto:
```
git push -u origin nombre-rama
```
Eliminar una rama en el repositorio remoto:
```
git push origin --delete nombre-rama
```

7. Ver el historial de commits

Ver el historial de commits de la rama actual:
```
git log
```

8. Resolución de conflictos de fusión

Cuando hay un conflicto al hacer merge:
- Ver qué archivos tienen conflictos:
```
git status
```
- Editar los archivos en conflicto, resolver los conflictos y luego añadirlos de nuevo:
```
git add archivo.txt
```
- Terminar la fusión:
```
git commit
```

9. Revertir cambios

Descartar cambios no confirmados en un archivo:
```
git checkout -- archivo.txt
```
Eliminar archivos del área de preparación:
```
git reset archivo.txt
```

10. Gestionar el remoto

Agregar un remoto nuevo:

git remote add origin https://github.com/usuario/repo.git

Ver los remotos configurados:
```
git remote -v
```

11. Stashing (almacenar temporalmente cambios)

Guardar cambios sin confirmarlos:
```
git stash
```
Aplicar cambios guardados en el stash:
```
git stash apply
```

12. Etiquetas (Tags)

Crear una etiqueta:
```
git tag v1.0
```
Subir la etiqueta al repositorio remoto:
```
git push origin v1.0
```

13. Revertir cambios: `git reset`, `git revert`, `git checkout`

git reset: Este comando se usa para mover el puntero HEAD a un commit anterior, deshaciendo los cambios que se hicieron después de ese commit. Hay varios tipos de reset:
- --soft: Deshace los commits, pero mantiene los archivos en el área de preparación (staging).
```
git reset --soft HEAD~1
```
  Deshace el último commit pero mantiene los cambios en el área de preparación.
- --mixed (predeterminado): Deshace los commits y elimina los archivos del área de preparación, pero los mantiene modificados en el directorio de trabajo.
```
git reset --mixed HEAD~1
```
- --hard: Deshace los commits y elimina todos los cambios del área de trabajo, devolviendo el repositorio a un estado limpio.
```
git reset --hard HEAD~1
```
git revert: Crea un nuevo commit que deshace los cambios de un commit anterior sin alterar el historial de commits, ideal cuando necesitas mantener un historial limpio:
```
git revert <commit-id>
```
git checkout (para restaurar archivos): Cambia al contenido de un archivo específico desde cualquier commit o rama:
```
git checkout <branch/commit> -- archivo.txt
```

14. Trabajar con `stash`: Guardar y restaurar cambios no confirmados

El stash te permite guardar temporalmente los cambios no confirmados para limpiar el área de trabajo sin hacer un commit. Ideal cuando necesitas cambiar de rama sin perder el trabajo en curso.

Guardar cambios en el stash:
```
git stash
```
Restaurar los cambios guardados:
```
git stash apply
```
Listar todas las entradas guardadas en el stash:
```
git stash list
```
Eliminar el stash después de aplicarlo:
```
git stash pop
```
Eliminar una entrada específica del stash:
```
git stash drop stash@{0}
```

15. Rebase: `git rebase`

El rebase es una técnica avanzada para reescribir el historial de commits, útil para mantener un historial más limpio.

Rebase interactivo: Permite modificar, reordenar, combinar o eliminar commits. Se ejecuta especificando cuántos commits atrás deseas reescribir:
```
git rebase -i HEAD~3
```
Esto abre un editor donde puedes modificar los commits previos.
Rebase de una rama en otra: Mueve la rama actual para que se base en una rama diferente (en lugar de hacer un merge):
```
git rebase nombre-rama
```
Esto "repliega" tus cambios sobre la rama indicada, eliminando los merge commits.

16. Cherry-pick: `git cherry-pick`

Este comando te permite aplicar un commit específico de una rama o historial a otra rama. Es útil cuando quieres llevar un cambio específico a otra rama sin hacer un merge completo.

Aplicar un commit específico:
```
git cherry-pick <commit-id>
```

17. Refactorizar historial: `git filter-branch` o `git filter-repo`

Para realizar cambios masivos en el historial de commits, como cambiar la estructura de los directorios o eliminar archivos confidenciales, puedes usar filter-branch (deprecated) o filter-repo (más moderno).

Modificar el historial de commits (filter-repo):
```
git filter-repo --path old-directory/ --to-subdirectory-filter new-directory/
```
Este comando refactoriza los commits para mover todos los archivos dentro de old-directory/ a new-directory/.

18. Reflog: `git reflog`

Git mantiene un registro de todos los movimientos del HEAD, incluidos los commits eliminados. Con git reflog, puedes recuperar commits que parecían perdidos.

Ver el historial del HEAD:
```
git reflog
```
Recuperar un commit perdido: Si accidentalmente haces un reset --hard, puedes recuperar el commit con:
```
git checkout <reflog-id>
```

19. Submódulos: `git submodule`

Los submódulos permiten incluir un repositorio dentro de otro repositorio, lo que es útil para gestionar dependencias.

Añadir un submódulo:

git submodule add https://github.com/usuario/otro-repo.git

Clonar un repositorio con submódulos: Después de clonar un repositorio que contiene submódulos, debes inicializarlos y actualizarlos:
```
git submodule init
git submodule update
```
Actualizar submódulos: Si hay cambios en el submódulo, puedes actualizarlos:
```
git submodule update --remote
```

20. Squash: Combinar varios commits en uno solo

El squash es una técnica que combina varios commits en uno solo, ayudando a limpiar el historial antes de fusionar cambios.

Combinar varios commits:
```
git rebase -i HEAD~3
```
En la pantalla interactiva, cambia pick por squash en los commits que quieres combinar.

21. Fetch vs. Pull: `git fetch` y `git pull`

git fetch: Trae los cambios del repositorio remoto sin mezclarlos en tu rama actual. Te permite revisar los cambios antes de fusionarlos.
```
git fetch origin
```
git pull: Combina fetch + merge en un solo paso. Trae los cambios remotos y los fusiona automáticamente con tu rama actual:
```
git pull origin main
```

22. Ramas remotas: `git remote prune`

A veces, las ramas remotas eliminadas siguen apareciendo en tu repositorio local. Con el siguiente comando, puedes limpiar esas ramas remotas inactivas:

Limpiar ramas remotas eliminadas:
```
git remote prune origin
```

23. Bundles: `git bundle`

Un bundle es un archivo que contiene todos los objetos y commits de un repositorio, lo que permite compartir un repositorio completo sin necesidad de usar un servidor remoto.

Crear un bundle:
```
git bundle create repo.bundle --all
```

Clonar desde un bundle:

git clone repo.bundle -b main repo-clonado

Comandos avanzados de GitHub

Los comandos avanzados de GitHub son herramientas y funciones que permiten realizar tareas más complejas y específicas en el flujo de trabajo de desarrollo colaborativo, particularmente cuando se utiliza GitHub como plataforma para alojar repositorios de Git y colaborar con otros.

¿Qué son los comandos avanzados de GitHub?

Los comandos avanzados de GitHub son aquellos que te permiten:

Automatizar flujos de trabajo (como pruebas automáticas o despliegue) con GitHub Actions.
Gestionar versiones y lanzamientos de software con GitHub Releases.
Controlar contribuciones a través de pull requests, revisiones de código y protecciones de ramas.
Colaborar más eficientemente utilizando la línea de comandos GitHub CLI (gh), donde puedes gestionar todo desde la terminal.
Interactuar con repositorios remotos para gestionar forks, submódulos y sincronizar proyectos bifurcados.

A continuación te explico algunas áreas clave donde GitHub ofrece comandos avanzados:

1. GitHub CLI (`gh`)

La GitHub CLI (gh) es una herramienta avanzada que permite interactuar con GitHub directamente desde la línea de comandos. Te permite realizar operaciones avanzadas como:

Crear y gestionar pull requests.
Administrar issues.
Verificar el estado de GitHub Actions.
Crear, clonar y bifurcar repositorios.

Ejemplos de comandos de GitHub CLI:

gh pr create         # Crear una nueva pull request
gh issue list        # Listar todos los issues abiertos
gh repo fork         # Bifurcar un repositorio

2. GitHub Actions

GitHub Actions es una herramienta para automatizar tareas dentro de un repositorio. Te permite configurar flujos de trabajo como integración continua (CI) y despliegue continuo (CD).

Algunos de los comandos avanzados incluyen:

Desencadenar workflows manualmente:
```
gh workflow run nombre-del-workflow
```
Ver el estado de los workflows:
```
gh run status
```
Cancelar un workflow que está en ejecución:
```
gh run cancel <ID-run>
```

3. Protección de ramas

GitHub permite proteger ramas importantes (como main o develop), estableciendo reglas que aseguren que todos los cambios pasen por un proceso de revisión o que ciertas pruebas automáticas se ejecuten antes de ser aceptados.

Algunas de estas reglas avanzadas incluyen:

Requerir revisiones antes de fusionar una pull request.
Bloquear push directo a una rama protegida.
Requerir que CI/CD pase exitosamente antes de poder fusionar.

Estas configuraciones no tienen comandos en CLI, pero puedes configurarlas en la interfaz web de GitHub bajo la sección "Branches".

4. GitHub Releases

GitHub Releases permite empaquetar y distribuir versiones de tu software. Puedes marcar un punto en el historial con una versión y compartir archivos binarios asociados a esa versión.

Comandos avanzados incluyen:

Crear una nueva release:

gh release create v1.0.0 --title "Versión 1.0" --notes "Descripción de la versión"

Listar todas las releases:
```
gh release list
```
Eliminar una release:
```
gh release delete v1.0.0
```

5. Sincronización de forks

Cuando trabajas en un proyecto que bifurcaste (fork), puedes usar comandos avanzados de Git y GitHub para mantener tu fork sincronizado con el repositorio original.

Agregar el repositorio original como remoto:

git remote add upstream https://github.com/usuario/repo-original.git

Actualizar tu fork con los cambios del repositorio original:
```
git fetch upstream
git merge upstream/main
```

6. Submódulos en GitHub

Un submódulo es un repositorio de Git incluido dentro de otro repositorio. Esto es útil para proyectos que dependen de otros repositorios.

Agregar un submódulo:

git submodule add https://github.com/usuario/submodulo-repo.git

Actualizar los submódulos:
```
git submodule update --remote
```

7. GitHub Pages

GitHub Pages es una característica que te permite publicar sitios web directamente desde tu repositorio.

Aunque no existen comandos en CLI para gestionarlo, puedes automatizar la publicación usando GitHub Actions para desplegar sitios estáticos.

¿Por qué son importantes estos comandos avanzados?

Los comandos avanzados de GitHub te permiten:

Optimizar tu flujo de trabajo: Automatizando procesos como la ejecución de pruebas y despliegue de software.
Facilitar la colaboración: A través de herramientas para gestionar pull requests, revisiones de código y releases.
Controlar mejor tu código: Usando herramientas avanzadas como submódulos, protección de ramas y releases.
Mejorar la seguridad y calidad del código: Mediante reglas de protección y automatización de pruebas.

Si te gustaría más información sobre algún comando o funcionalidad específica, ¡hazmelo saber!

Etiquetas

Github