Git: tutorial básico del sistema de control de versiones
No solo las empresas desarrollan proyectos de software de forma colaborativa: también en el sector del código abierto, varios cientos o incluso miles de voluntarios y colaboradores pueden participar en la creación, el mantenimiento, la optimización o la edición de un programa, dependiendo del tamaño del proyecto. Sería prácticamente imposible llevar a cabo estas tareas sin un buen sistema para registrar y controlar los numerosos cambios realizados por todos los desarrolladores.
Una de las soluciones más populares en este sentido es Git, un programa de licencia libre que puedes aprender a manejar rápidamente y utilizar de forma totalmente gratuita. En nuestro tutorial, te enseñamos todos los conceptos básicos para que seas capaz de dar tus primeros pasos con este sistema de control de versiones.
- Domina el mercado con nuestra oferta 3x1 en dominios
- Tu dominio protegido con SSL Wildcard gratis
- 1 cuenta de correo electrónico por contrato
¿Qué es Git?
Git es un sistema de control de versiones desarrollado en 2005 por Linus Thorvalds, el creador de Linux, y publicado bajo la licencia de software libre GPLv2 de GNU. La particularidad de esta herramienta es que, aunque guarda un repositorio central para cada proyecto, todos los participantes descargan una copia local del mismo en su propio dispositivo. Cada una de estas copias constituye una copia completa de todo el contenido del repositorio, por lo que no es necesario estar conectado a la red para trabajar. Además, estos archivos sirven como copia de seguridad en caso de que el repositorio principal falle o resulte dañado. Los cambios en los archivos pueden intercambiarse con todos los demás participantes del proyecto en cualquier momento y, si corresponde, añadirse al repositorio.
Una de las alternativas más conocidas a Git es Subversion, una herramienta también de código abierto y más conocida como SVN, que se basa en un sistema de gestión central, contrariamente a Git. En nuestro artículo Git vs. SVN: una comparativa del control de versiones, te contamos qué tienen en común estos programas y en qué se diferencian.
Cómo instalar Git en el dispositivo
Si quieres empezar a utilizar Git como programa de control de versiones, en primer lugar, debes familiarizarte con el propio software y su interfaz de usuario. Git está disponible para Windows, Unix/Linux y macOS, con diferentes versiones que presentan pequeñas diferencias de uso. Después de llevar a cabo la instalación estándar correspondiente, puedes controlar el programa con el símbolo del sistema o una interfaz gráfica de usuario en cualquiera de los sistemas operativos.
Para poder utilizar los comandos explicados en este tutorial de Git, los usuarios de Windows deben ejecutarlo a través de Git Bash, un shell de estilo Unix que emula la línea de comandos de Git y está incluido en el paquete de instalación. Si lo prefieres, también es posible controlar el software con el símbolo del sistema o la terminal de Windows, aunque debes tener en cuenta que la estructura de los parámetros de los comandos difiere (por ejemplo, se emplean signos de ídem en lugar de comillas).
Para mostrar este video, se requieren cookies de terceros. Puede acceder y cambiar sus ajustes de cookies aquí. En la página oficial del proyecto Git, encontrarás los archivos de instalación binarios, las instrucciones para instalar el administrador de paquetes (sistemas Unix) y las ediciones portátiles listas para usar para cada sistema operativo. Solo tienes que descargar el paquete de instalación deseado o elegir el paquete apropiado mediante el administrador y, a continuación, seguir las instrucciones del asistente. Obviamente, con las ediciones portátiles no es necesario llevar a cabo la instalación.
En la página de descargas de git-scm.com, la comunidad de Git ofrece diferentes interfaces gráficas para el sistema de control de versiones. Además, entre otras cosas, proporciona aplicaciones Git para Android e iOS que permiten utilizar esta herramienta de código abierto en dispositivos móviles.
Git: tutorial para empezar a utilizarlo paso a paso
Una vez instalado Git, ya puedes utilizar el sistema para controlar las versiones de tus proyectos. Como con cualquier otro programa, el primer paso es comprender las funciones y comandos básicos para sacarle el máximo partido a la herramienta. En nuestro completo tutorial de Git, te explicamos los comandos más importantes para configurar y utilizar Git mediante la interfaz de línea de comandos y que puedas crear y administrar fácilmente tu propio repositorio.
Pese a conocerse desde 2015 que una configuración errónea de Git o, para ser más exactos, del servidor web en activo, pone a los repositorios del sistema de gestión de versiones a disposición pública en la red, son muchas las webs que a día de hoy aún exponen a sus ficheros. Esto ocurre siempre que un directorio Git se guarda en el directorio web raíz del servidor, algo a evitar en todos los casos. Hay dos opciones: o no se guardan nunca aquí o se configura al servidor web de tal manera que no pueda accederse al directorio .git desde fuera. En esta entrada del blog Internetwache.org, encuentras una guía detallada para proteger el directorio .git.
Crear o clonar un repositorio Git
El repositorio Git es el directorio central de un proyecto y, por lo tanto, también el principal punto de contacto para todos los participantes, a través del cual se lleva a cabo el control de todas las versiones. Por ello, el primer paso consiste en crear este repositorio principal o clonarlo (en forma de copia de trabajo) en caso de que vayas a incorporarte a un proyecto que ya se esté gestionando con Git.
Tanto si quieres configurar el control de versiones para un nuevo proyecto como si acabas de instalar Git para aprender a trabajar con la herramienta, debes crear un nuevo repositorio. Para ello, ejecuta el comando cd (change directory) para acceder al directorio de tu dispositivo donde desees ubicarlo:
cd ruta al directorio- Rápido, seguro, flexible y escalable
- Certificado SSL/DDoS incluido
- Dominio y asesor personal incluidos
Una vez allí, introduce el siguiente comando para crear un repositorio .git:
git init
Si ya existe un repositorio Git para el proyecto, solo tienes que introducir el comando git clone seguido de la dirección web o de red de ese repositorio para crear una copia de trabajo en el ordenador:
git clone https://one-test.website/git-repositoryComprobar el estado del repositorio y añadir nuevos archivos al control de versiones
Uno de los conceptos básicos para utilizar Git es organizar adecuadamente el propio directorio de trabajo, lo que permite no solo proponer cambios e innovaciones personales a un proyecto, que luego son aceptados mediante el comando git commit (enviar), sino también obtener información sobre las actividades de otros usuarios. Puedes comprobar si tu copia de trabajo está actualizada ejecutando este comando:
git statusPor lo general, en el caso de los repositorios creados recientemente, o cuando el repositorio principal y la copia de trabajo coinciden por completo, recibirás un aviso de que no se ha modificado el proyecto (No commits yet). Además, Git te informa de que no has compartido tus cambios para el próximo commit (nothing to commit).
Para añadir un nuevo archivo al control de versiones o para registrar algún cambio para el siguiente commit, introduce el comando git add y el nombre de este archivo, que debe encontrarse en tu directorio de trabajo. En nuestro tutorial, añadiremos un documento de texto llamado “Test” como ejemplo:
git add Test.txtDespués, cuando vuelvas a comprobar el estado del repositorio, verás que el documento está a la espera de someterse a la siguiente fase de confirmación de cambios del proyecto, en que estos se aceptarán o no (Changes to be commited):
Confirmar los cambios mediante commit y añadirlos al HEAD
Cualquier cambio que hayas propuesto incorporar al proyecto, como hemos explicado en el punto anterior, debe confirmarse con commit para que se incluya en el HEAD. El HEAD es una especie de índice que apunta al último commit efectuado en el entorno de trabajo Git actual (también llamado “rama”). El comando para hacerlo es el siguiente:
git commitAntes de ejecutar el comando git commit, no te olvides de comprobar si has marcado todos los cambios que deseas incluir en el repositorio remoto (con git add). De lo contrario, estos serán ignorados, incluso si se encuentran en la copia de trabajo guardada en el directorio.
Después de ejecutar el comando, Git inicia automáticamente el editor que configuraste como predeterminado durante la instalación o que el propio sistema abre por defecto. En el documento, puedes añadir un comentario personal sobre el commit planificado, en el que las líneas anotadas se separan por punto y coma y, por lo tanto, no se muestran más adelante. En cuanto cierres el editor, Git creará el commit:
Como se muestra en la captura de pantalla, después de ejecutar git commit, obtienes un mensaje que resume el commit: entre corchetes figuran, por un lado, el nombre de la rama del proyecto a la que se transfirieron los cambios (en este caso, master, ya que nuestro repositorio de trabajo también es el repositorio principal) y, por otra parte, la suma de comprobación SHA-1 del commit (en este caso, c0fdc90). Les siguen el comentario que anotó el propio usuario (aquí, “Test”) y algunos datos concretos sobre los cambios.
Revisar o deshacer commits ejecutados
Una vez aceptados los cambios mediante el comando commit, puedes editar el contenido o eliminarlo por completo en cualquier momento más adelante. Por ejemplo, un caso típico sería precipitarse al ejecutar commit y olvidarse de algún archivo o configuración importante. En este caso, puedes registrar archivos nuevos o modificados a posteriori mediante el comando git add y volver a transferirlos. Para ello, añade --amend al comando estándar:
git commit --amendSi quieres deshacer el último commit generado, puedes hacerlo con el siguiente comando de Git:
git reset --soft HEAD~1Este comando cancela el commit registrado por última vez en el HEAD. Los archivos que contiene se restablecen como “cambios planificados para el próximo commit” en el estado del proyecto. Si lo que quieres es eliminar por completo los datos introducidos, ejecuta el siguiente comando en lugar del anterior:
git reset --hard HEAD~1Mostrar el historial de commits
Aprender a gestionar proyectos con Git es especialmente útil debido a las características básicas de control de versiones que ofrece el sistema. Por ejemplo, una gran ventaja de este programa de código abierto es que siempre puedes visualizar los últimos cambios que se han realizado en el repositorio. Para ello, puedes utilizar el siguiente comando de Git:
git logDe manera predeterminada, el comando git log enumera los commits generados en orden cronológico inverso: la suma de comprobación SHA-1, el autor (nombre y dirección de correo electrónico) y la fecha de cada commit. Además, se muestra un comentario individual que sirve a todos los usuarios como indicador para poder buscar rápidamente las versiones. En un apartado anterior de este tutorial de Git, generamos un solo commit con el mensaje “Test”. Al ejecutar el comando, se nos muestra el archivo solicitado:
El comando git log también puede modificarse utilizando varios parámetros. En la siguiente tabla, te mostramos algunas de las posibilidades:
| Parámetros para git log | Descripción |
|---|---|
| -p | Muestra también los cambios incluidos en un commit |
| -2 | Enumera solo los dos últimos commits ejecutados |
| --stat | Añade una pequeña estadística a cada registro que muestra qué archivos se han modificado y cuántas líneas se han insertado o eliminado |
| --pretty | Cambia el formato de salida con diferentes posibilidades; por ejemplo, --pretty=online enumera todos los commits en una sola línea |
| --abbrev-commit | Muestra solo los primeros caracteres de una suma de comprobación SHA-1 |
| --relative-date | Muestra la fecha de un cambio en formato relativo (por ejemplo, “hace dos semanas”) |
Incluir commits en el repositorio principal
Hasta ahora, hemos mostrado cómo guardar los cambios como commit en el HEAD del directorio local. Para que estos también se incluyan en el repositorio principal, debes ejecutar el siguiente comando:
git push origin masterDe este modo, Git transfiere automáticamente todos los commits ejecutados, que hasta ahora solo habían estado en la copia de trabajo, al directorio principal, que también recibe el nombre de master. Si sustituyes este nombre por el de otra rama (la del proyecto), los archivos se enviarán directamente allí.
Crear, eliminar y enumerar etiquetas en Git
Al igual que muchos otros sistemas de control de versiones, Git tiene una función de etiquetado que resalta los elementos seleccionados en el historial del repositorio. Por lo general, estas etiquetas se utilizan para identificar versiones del software, como 1.0, 2.0 o posteriores, y permitir que estas sean fáciles de acceder en todo momento, incluso en el caso de los proyectos grandes. Git admite dos tipos de etiquetas:
- Etiquetas anotadas (annotated): se guardan como objetos independientes en la base de datos e incluyen su propia suma de comprobación, etiqueta, fecha, nombre y dirección de correo electrónico del creador de la etiqueta, así como la firma opcional GNU Privacy Guard (GPG).
- Etiquetas no anotadas (lightweight): al igual que las ramas, solo sirven de referencia para identificar un commit. Este tipo resulta útil si solo necesitas una etiqueta temporal o si no quieres guardar datos avanzados.
Para crear etiquetas anotadas en Git, ejecuta el comando git tag -a en el commit que desees. Si también añades el parámetro -m, podrás anotar entre comillas el mensaje que debe incluir la etiqueta directamente en el símbolo del sistema. En este tutorial de Git, hemos generado el commit “Test”, que ahora vincularemos a una etiqueta que incluye el mensaje “example tag”:
git tag -a Test -m “example tag”Si omites el parámetro -m al generar la etiqueta, Git abrirá automáticamente el editor para que puedas introducir el mensaje de la etiqueta.
Para las etiquetas no anotadas, procedemos de manera similar: en este caso, solo ejecutamos el comando básico git tag en el commit deseado y no utilizamos ningún otro parámetro. En el ejemplo utilizado en este tutorial de Git, el comando sería el siguiente:
git tag TestEn cuanto haya etiquetas en el repositorio, podemos mostrarlas con el mencionado git tag y los parámetros opcionales -l o --list:
git tag
git tag -l
git tag --list
Para eliminar una etiqueta del directorio de trabajo local, ejecuta el comando git tag -d. Nuestra referencia a “Test” se elimina de la siguiente manera:
git tag -d TestTen en cuenta que también debes transferir las etiquetas al repositorio principal de forma manual como commit. Para ello, introduce el nombre de la etiqueta y el comando git push origin. También puedes añadir el parámetro --tags en vez del nombre de la etiqueta, mediante el cual todas las etiquetas generadas se incluyen en el repositorio:
git push origin --tagsCrear, administrar y eliminar ramas
Las ramas ya mencionadas en este tutorial de Git no son, en principio, más que versiones de trabajo individuales del repositorio principal, que también se clasifica como una rama llamada master. Mediante esta estructura, Git proporciona una base perfecta para desarrollar características y funciones de forma independiente y combinarlas en etapas posteriores, lo que también recibe el nombre de fusionar (en inglés, merge).
Crear una nueva rama es fácil: solo debes ejecutar el comando git branch y añadir el nombre que quieras poner a la rama. Por ejemplo, puedes generar una rama de ejemplo llamada test_branch de la siguiente manera:
git branch test_branchDespués, puedes cambiar a esta rama en cualquier momento mediante el comando git checkout:
git checkout test_branch
Para combinar dos o más ramas, utiliza el comando git merge. Antes, ejecuta checkout para cambiar al directorio que debe incluir la otra rama y, después, ejecuta allí este comando, incluyendo el nombre de la rama que se fusionará. Nuestra versión de trabajo test_branch se puede fusionar con el repositorio principal de la siguiente manera:
git checkout master
git merge test_branchSi has fusionado varias ramas de trabajo y, por lo tanto, ya no te hace falta una rama en particular, puedes eliminarla fácilmente. Para ello, introduce el comando git branch -d y la rama que ya no necesites. Eliminaremos test_branch, nuestro ejemplo en este tutorial de Git, mediante el siguiente comando:
git branch -d test_branchEl único requisito para eliminar una rama es encontrarse en otra distinta en ese momento. Por lo tanto, has de cambiar al repositorio principal antes de ejecutar el comando, como puedes ver en la siguiente captura de pantalla:
En nuestra Digital Guide también encontrarás información sobre "Git branch rename: cómo renombrar una rama local y remota de Git".
Con el saldo inicial de cada tarifa puedes usar el servidor cloud de IONOS durante 1 mes de forma gratuita (o hasta que se agote el saldo) y disfrutar de la combinación perfecta de rendimiento y seguridad.