Instalación en distintos sistemas operativos: Windows, macOS, Linux

Para comenzar a utilizar Git, es necesario instalarlo correctamente en tu sistema operativo. A continuación, se detallan los pasos para instalar Git en Windows, macOS y Linux.

Instalación en Windows

En Windows, puedes instalar Git utilizando el paquete Git for Windows, que incluye herramientas como Git Bash y Git GUI.

1. Visita la página oficial de Git en git-scm.com y descarga el instalador para Windows.

2. Ejecuta el instalador y sigue las indicaciones del asistente de instalación.

3. Durante la instalación, presta atención a las siguientes opciones:

• Editor por defecto: selecciona tu editor de texto preferido para usar con Git.

• Ajustes del PATH: es recomendable escoger "Git from the command line and also from 3rd-party software" para tener acceso a Git desde la línea de comandos y otras aplicaciones.

• Configuración de HTTPS: selecciona la opción recomendada para manejar conexiones HTTPS de forma segura.

4. Una vez finalizada la instalación, abre Git Bash o el Símbolo del sistema y verifica la instalación ejecutando:

git --version

Si el comando retorna la versión de Git instalada, la instalación ha sido exitosa.

Instalación en macOS

En macOS, tienes varias opciones para instalar Git, siendo las más comunes mediante Xcode Command Line Tools o usando el gestor de paquetes Homebrew.

Opción 1: Xcode Command Line Tools

1. Abre el Terminal.

2. Ejecuta el siguiente comando para instalar las herramientas de línea de comandos de Xcode:

xcode-select --install

3. Aparecerá un cuadro de diálogo solicitando la instalación. Haz clic en Instalar y sigue las instrucciones.
4. Una vez finalizada la instalación, verifica ejecutando:

git --version

Opción 2: Homebrew

Si prefieres utilizar Homebrew, asegúrate de tenerlo instalado. Si no, puedes instalarlo ejecutando:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Luego, instala Git con:

brew install git

Verifica la instalación ejecutando:

git --version

Instalación en Linux

En Linux, la instalación de Git se realiza a través del gestor de paquetes de tu distribución.

Distribuciones basadas en Debian/Ubuntu

1. Actualiza los índices de paquetes:

sudo apt update

2. Instala Git:

sudo apt install git

Fedora

Instala Git utilizando dnf:

sudo dnf install git

CentOS/RHEL

Instala Git con yum:

sudo yum install git

Arch Linux

Utiliza pacman para instalar Git:

sudo pacman -S git

Una vez instalada, confirma la versión ejecutando:

git --version

Verificación final

Después de realizar la instalación en cualquier sistema operativo, es recomendable configurar tu nombre de usuario y correo electrónico globalmente:

git config --global user.name "Tu Nombre"

git config --global user.email "tu.correo@example.com"

Estos ajustes son esenciales para que tus commits sean correctamente etiquetados.

Configuración global vs. local con git config: Ajustes de usuario, correo y alias

La herramienta git config permite personalizar múltiples aspectos del comportamiento de Git. Es importante entender la diferencia entre la configuración global y la local, ya que esto afecta cómo se aplican los ajustes en distintos contextos.

Git almacena su configuración en tres niveles:

1. Sistema (--system): Afecta a todos los usuarios y repositorios en un sistema dado.

2. Global (--global): Afecta a todos los repositorios del usuario actual.

3. Local (por defecto, sin bandera): Afecta únicamente al repositorio actual.

Configuración global

La configuración global es aquella que se aplica a todos los repositorios de Git del usuario. Se almacena en el archivo ~/.gitconfig en sistemas Unix y en %USERPROFILE%\.gitconfig en Windows.

Para establecer una configuración global, se utiliza la opción --global. Por ejemplo, para configurar el nombre de usuario y el correo electrónico que aparecerán en los commits:

git config --global user.name "Nombre Apellido"
git config --global user.email "correo@ejemplo.com"

Estas configuraciones se aplicarán en todos los repositorios donde no se haya establecido una configuración local específica.

Configuración local

La configuración local se aplica únicamente al repositorio en el que se ejecuta el comando. Esta configuración se almacena en el archivo .git/config dentro del repositorio. Para establecer una configuración local, simplemente se omite la opción --global:

git config user.name "Nombre Local"
git config user.email "local@ejemplo.com"

Esto es útil cuando trabajas en proyectos en los que necesitas usar un nombre o correo electrónico diferente, como cuando colaboras en repositorios con distintas identidades o cuentas de correo.

Prioridad de la configuración

Cuando Git necesita un valor de configuración, sigue el siguiente orden de precedencia:

1. Local: Configuración específica del repositorio.

2. Global: Configuración del usuario.

3. Sistema: Configuración a nivel del sistema operativo.

Esto significa que la configuración local sobrescribe a la global, y esta a su vez a la del sistema.

Ajustes comunes con git config

Además del nombre y el correo electrónico, es habitual personalizar otros aspectos para mejorar la eficiencia al usar Git.

Configurar el editor por defecto

Git suele requerir un editor de texto para ingresar mensajes de commit o para editar configuraciones. Puedes establecer tu editor preferido:

git config --global core.editor "code --wait"

En este ejemplo, se configura Visual Studio Code como editor por defecto. El parámetro --wait asegura que Git espere a que cierres el editor antes de continuar.

Crear alias para comandos frecuentes

Los alias permiten abreviar comandos largos o complejos, aumentando la productividad. Por ejemplo:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.cm "commit -m"

Ahora, en lugar de escribir git status, puedes simplemente escribir git st. Los alias pueden incluir parámetros y combinaciones de comandos.

Colorear la salida en la terminal

Para mejorar la legibilidad, es recomendable habilitar el color en la salida de Git:

git config --global color.ui auto

Esto permitirá que Git use colores para diferenciar elementos en comandos como git status o git diff.

Visualizar la configuración

Puedes ver todas las configuraciones actuales ejecutando:

git config --list --show-origin

El parámetro --show-origin muestra el archivo de origen de cada configuración, permitiendo identificar si el ajuste es local o global.

Editar directamente los archivos de configuración

Si prefieres editar las configuraciones en un archivo de texto, puedes abrir los archivos de configuración:

• Configuración global:

git config --global --edit

• Configuración local:

git config --edit

Esto abrirá el archivo correspondiente en el editor por defecto, donde podrás modificar o añadir nuevas configuraciones.

Caso de uso: Múltiples identidades de usuario

Supongamos que trabajas en proyectos personales y profesionales desde el mismo equipo, y necesitas usar diferentes correos electrónicos en tus commits. Puedes establecer una configuración global para tu correo personal:

git config --global user.name "Nombre Personal"
git config --global user.email "personal@correo.com"

Y luego, en el directorio del proyecto profesional, estableces una configuración local:

git config user.name "Nombre Profesional"
git config user.email "profesional@empresa.com"

De esta manera, Git utilizará la configuración local en el repositorio profesional y la global en los demás.

Variables de entorno relacionadas

Git también puede leer ciertas variables de entorno que influyen en su comportamiento. Por ejemplo, GIT_EDITOR para especificar el editor o GIT_SSH para definir el cliente SSH a utilizar.

Para establecer una variable de entorno temporalmente, puedes usar:

export GIT_EDITOR=nano

Ten en cuenta que las variables de entorno tienen prioridad sobre las configuraciones de Git.

Resumen de comandos útiles

• Establecer configuración global:

git config --global <clave> <valor>

• Establecer configuración local:

git config <clave> <valor>

• Crear alias para comandos:

git config --global alias.<alias> "<comando>"

• Ver todas las configuraciones:

git config --list --show-origin

• Editar configuración global o local:

git config --global --edit
git config --edit

Con una correcta configuración de Git, puedes optimizar tu flujo de trabajo y asegurarte de que tus contribuciones estén adecuadamente identificadas.

Creación y uso de llaves SSH y creación de token: Autenticación segura

La autenticación segura es fundamental al interactuar con repositorios remotos. Git permite autenticarse utilizando llaves SSH o tokens de acceso personal, lo que incrementa la seguridad y simplifica el proceso de conexión.

Creación y uso de llaves SSH

Las llaves SSH son un par de claves criptográficas que establecen una conexión segura entre tu máquina y el servidor remoto, evitando la necesidad de introducir contraseñas constantemente. A continuación, se detallan los pasos para generar y utilizar llaves SSH.

Generación de una llave SSH

Para generar una llave SSH, ejecuta el siguiente comando en la terminal:

ssh-keygen -t ed25519 -C "tu.correo@example.com"

Este comando crea una nueva llave utilizando el algoritmo Ed25519, recomendado por su seguridad y eficiencia. El parámetro -C añade un comentario identificativo, generalmente tu correo electrónico.

Al ejecutar el comando:

1. Se te solicitará una ubicación para guardar la llave. Presiona Enter para aceptar la ruta por defecto (~/.ssh/id_ed25519).

2. Se te pedirá introducir una frase de contraseña. Puedes establecer una para añadir una capa extra de seguridad o dejarla en blanco para evitar tener que introducirla cada vez.

Añadir la llave SSH al agente SSH

Para facilitar la gestión de las llaves, puedes utilizar el agente SSH, que almacena las llaves en memoria y agiliza la autenticación. Inicia el agente SSH con:

eval "$(ssh-agent -s)"

Luego, añade tu llave privada al agente:

ssh-add ~/.ssh/id_ed25519

Registrar la llave pública en el servidor remoto

Para que el servidor remoto reconozca tu llave SSH, debes añadir la llave pública a tu cuenta en el servicio que utilices (por ejemplo, GitHub, GitLab o Bitbucket).

Primero, copia el contenido de tu llave pública:

cat ~/.ssh/id_ed25519.pub

Esto mostrará una cadena de texto que comienza con ssh-ed25519. Copia todo el contenido mostrado.

Luego, en el servicio correspondiente:

• GitHub:

1. Accede a tu cuenta y navega a Settings (Configuración).

2. En el menú lateral, selecciona SSH and GPG keys.

3. Haz clic en New SSH key.

4. Asigna un título para identificar la llave y pega el contenido copiado en el campo Key.

5. Haz clic en Add SSH key.

Probar la conexión SSH

Para verificar que todo funciona correctamente, prueba la conexión con:

ssh -T git@github.com

Si la configuración es correcta, recibirás un mensaje de bienvenida. Es posible que se te pregunte si deseas continuar; escribe yes para confirmar.

Configurar Git para usar SSH

Para asegurar que Git utilice SSH al interactuar con repositorios remotos, comprueba la URL remota:

git remote -v

Si la URL comienza con https://, cámbiala por la versión SSH:

git remote set-url origin git@github.com:usuario/repositorio.git

Reemplaza usuario y repositorio por tus datos. De este modo, Git usará SSH para las operaciones con el remoto.

Creación y uso de tokens de acceso personal

En situaciones donde no es posible utilizar SSH, puedes emplear tokens de acceso personal como alternativa segura.

Generar un token en GitHub

Para crear un token en GitHub:

1. Accede a Settings en tu cuenta.

2. Selecciona Developer settings y luego Personal access tokens.

3. Haz clic en Generate new token.

4. Asigna un nombre al token y elige los alcances (scopes) necesarios, como repo para acceso completo.

5. Haz clic en Generate token.

El token se mostrará una única vez; guárdalo en un lugar seguro.

Usar el token para autenticación HTTPS

Al realizar operaciones que requieran autenticación, utiliza el token en lugar de la contraseña. Por ejemplo, al hacer git push:

Username: tu_usuario
Password: <pega aquí el token>

Para evitar ingresar el token cada vez, configura un asistente de credenciales:

git config --global credential.helper store

Esto almacenará tus credenciales de forma segura después del primer uso.

Gestión segura de llaves y tokens

Es crucial manejar con cuidado tus llaves SSH y tokens, ya que otorgan acceso a tus repositorios. Algunas prácticas recomendadas son:

• No compartir tus llaves privadas ni tokens.
• Evitar incluir llaves o tokens en el código fuente o en repositorios.
• Revocar y regenerar tokens periódicamente o si crees que han sido comprometidos.
• Utilizar frases de contraseña en tus llaves SSH para mayor seguridad.

Uso de múltiples llaves SSH

Si necesitas gestionar varias llaves SSH para diferentes cuentas o servicios, puedes configurar el archivo ~/.ssh/config:

Host github-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_personal

Host github-trabajo
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_trabajo

Al clonar repositorios, especifica el host configurado:

git clone git@github-personal:usuario/repositorio.git

Así, Git utilizará la llave apropiada para cada conexión.