Configura tu identidad global en Git: user.name y user.email

Introducción

Git es una herramienta de control de versiones distribuido que rastrea cambios en el código, documentación, guías e incluso la configuración de proyectos. Cuando trabajas en múltiples proyectos, es probable que quieras una identidad consistente para cada uno. Es ahí donde la configuración global (--global) entra en juego: almacena tu nombre de usuario y dirección de correo electrónico en un solo lugar, sin necesidad de especificarlos en cada git init o git clone.

Si sos un desarrollador que colabora en equipos, un maintainer que escribe commits para proyectos de código abierto, o simplemente un programador que quiere mantener organizado su historial de cambios, comprender cómo establecer y verificar la configuración global es fundamental. En este artículo, te guiaré a través del proceso paso a paso, mostrando ejemplos prácticos de la línea de comandos y cómo interpretar la salida. Al final, sabrás cómo establecer, verificar y solucionar problemas de tu identidad global de Git, asegurando que cada commit refleje la información correcta.

Este artículo está dirigido a principiantes que recién comienzan con Git, desarrolladores intermedios que aún no están familiarizados con las opciones globales, y a cualquier persona que quiera mantener organizado su entorno de desarrollo. No se requiere experiencia previa más allá de un conocimiento básico del uso de la terminal.

Por qué necesitas una configuración global de Git

1. Historia de commits consistente

Cada commit en Git lleva adherido un autor (nombre + email) y un comprador (que puede ser diferente). Si configurás estas propiedades globalmente, todos los commits que hagas en cualquier repositorio usarán automáticamente esa identidad, evitando commits anónimos o duplicados.

2. Colaboración sin fricciones

Cuando envías cambios a un repositorio remoto (por ejemplo, en GitHub, GitLab o Bitbucket), el correo electrónico del autor se vincula a tu perfil. Una dirección de correo electrónico global consistente ayuda a la plataforma a identificarte, habilitar la verificación de dos factores y mostrar contribuciones correctas.

3. Simplificación de la configuración local

Si bien podés sobrescribir la configuración global para un repositorio específico usando la opción --local, hacerlo evita tener que especificar --local user.name "..." en cada nuevo repo. Pensá en la configuración global como un perfil de usuario predeterminado, similar a un perfil de navegador que se aplica automáticamente.

4. Herramientas y servicios que dependen del correo electrónico del autor

Herramientas como GitHub’s “Encontrar colaboradores”, la vista “Actividad reciente” y los servicios externos de CI/CD a menudo filtrarán commits basados en el email del autor. Una identidad global bien configurada hace que esos procesos sean más confiables.

Configuración global básica

Estableciendo el nombre de usuario global

El comando para establecer un nombre de usuario global es:

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

Reemplaza "Tu Nombre" con el nombre que quieres que aparezca en tus commits. Puedes usar tu nombre legal, un apodo o cualquier identificador que prefieras. Para fines de ejemplo, usaremos Alice Developer.

Estableciendo el email global

Del mismo modo, configurás el email global con:

git config --global user.email "alice@example.com"

El email debe ser una dirección que puedas acceder (idealmente una profesional o una dedicada al código abierto). Muchos servicios de desarrollo validan el formato del email del autor, aunque algunos son flexibles.

Verificando la configuración

Una vez que hayas ejecutado ambos comandos, podés confirmar que Git los ha almacenado usando git config --list. Esta lista muestra todas las entradas de configuración (globales, de sistema y locales) en un formato simple de clave/valor:

git config --list | grep -E "user\.(name|email)"

Salida típica:

user.name=Alice Developer
user.email=alice@example.com

El comando grep filtra solo las dos líneas que te interesan, pero también podés ver la lista completa con:

git config --global --list

El cual podría producir:

user.name=Alice Developer
user.email=alice@example.com
credential.helper=manager-core

Por qué usar --global

Cuando especificás --global, Git escribe las claves en $HOME/.gitconfig. Ese archivo es legible para todos los repositorios a menos que se sobrescriba con un archivo .git/config local. Si deseas un nombre/email diferente para un proyecto específico, podés sobrescribirlo de manera local (más sobre eso más adelante).

Flujo de trabajo típico: desde cero hasta el primer commit

A continuación, se presenta un flujo de trabajo paso a paso que podrías seguir en una nueva máquina.

1. Verifica la configuración actual (opcional)

Si ya usaste Git antes, podrías tener una configuración existente. Ejecutá:

git config --list

Notarás entradas como user.name="" o user.email="" si nunca las configuraste.

2. Establece la identidad global

git config --global user.name "Alice Developer"
git config --global user.email "alice@example.com"

3. Confirma los cambios

git config --global --list | grep user

Deberías ver tanto user.name como user.email mostrados.

4. Crea un nuevo repositorio

mkdir my-project && cd my-project
git init
git add .

Cuando hagas un commit por primera vez sin editar nada, Git usará automáticamente tu configuración global:

git commit -m "Inicialización del proyecto"

El comando commit mostrará algo como:

[master (root-commit) 0d8e3f1] Inicialización del proyecto
 1 files changed, 0 insertions(+), 0 deletions(-)
 autor: Alice Developer <alice@example.com>

5. Sobrescribe la configuración localmente (si es necesario)

Supongamos que estás trabajando en un proyecto personal donde prefieres ser acreditado como Alice Smith en lugar de Alice Developer. Podrías establecer la configuración localmente sin afectar tu identidad global:

git config --local user.name "Alice Smith"
git config --local user.email "alice.smith@personal.example.com"

Ahora verifica en este directorio:

git config --list | grep user

Verás tanto las entradas globales como las locales; las entradas locales tienen prioridad.

Ver todo el archivo de configuración

El comando git config --list muestra cada entrada de configuración. Si necesitas una vista más detallada, podés usar git config --global -e (abre un editor). Esta puede ser útil para editar valores directamente.

git config --global -e

Esto invocará tu editor preferido ($EDITOR) y mostrará un archivo similar a:

[core]
	indent = 4
[user]
	name = Alice Developer
	email = alice@example.com
[github]
	user = alicedeveloper

Cualquier cambio hecho allí se reflejará en todos los repositorios.

Inspeccionando la configuración con git config --list

El comando git config --list es muy flexible. Algunas opciones útiles:

• git config --list --show-origin: muestra la fuente (por ejemplo, global, system, local) de cada entrada.
• git config --list --name-only: muestra solo las claves.
• git config --list --value-only: muestra solo los valores.

Ejemplo:

git config --list --show-origin | grep user

Salida esperada (las rutas pueden variar):

user.name=Alice Developer /home/alice/.gitconfig (global)
user.email=alice@example.com /home/alice/.gitconfig (global)

Esta salida ayuda a confirmar que estás viendo las entradas globales y no una entrada local accidental.

Buenas prácticas y errores comunes

1. Usa un correo electrónico que puedas controlar

Elegir una dirección de correo electrónico temporal o descartable puede causar problemas más adelante (por ejemplo, no podrás recuperar la contraseña). Muchos desarrolladores usan una dirección de correo electrónico profesional dedicada solo para el control de versiones.

2. Verifica el formato del correo electrónico

Git no valida estrictamente el formato del email, pero la mayoría de los servicios lo esperan como nombre.apellido@dominio.com. Si usas un proveedor de correo electrónico basado en Git (por ejemplo, GitHub), el email debe ser verificable.

3. Evita sobrescribir accidentalmente la configuración global

Si estás trabajando en múltiples proyectos, ten cuidado al ejecutar git config --global user.name "..." en una terminal compartida (por ejemplo, un servidor SSH). Podrías cambiar la identidad para todos los futuros comandos de Git de ese sistema.

4. Utiliza variables de entorno como alternativa

Algunos equipos usan variables de entorno para la identidad (por ejemplo, GIT_AUTHOR_NAME, GIT_COMMITTER_NAME). Estas tienen prioridad sobre la configuración global si están configuradas. Si alguna vez necesitas cambiar temporalmente el nombre en un script, considerá usar variables de entorno en lugar de modificar la configuración global.

5. Protege tu archivo ~/.gitconfig

El archivo ~/.gitconfig contiene información sensible (nombre, email, incluso credenciales). No lo compartas accidentalmente en control de versiones. Puedes restringir los permisos con chmod 600 ~/.gitconfig.

6. Superposición local frente a global

Si deseas una configuración global diferente para cada usuario en una máquina compartida (por ejemplo, un servidor CI), usa -local en cada repositorio o configura un archivo .git/config separado en el directorio raíz del proyecto.

7. Mantén un registro de cambios

Siempre que cambies la identidad global, anota el motivo (por ejemplo, “cambiado a email profesional”). Puedes mantener un archivo de registro simple en ~/git-identity-notes.txt para ayudarte más adelante.

Errores comunes y cómo solucionarlos

Síntoma	Causa probable	Solución
git commit falla con “Tu correo electrónico actual está configurado...”	El email no es verificable (por ejemplo, example.com) o no estás autenticado.	Usa un email válido que puedas acceder. Si usas GitHub, asegúrate de haber verificado el email en la configuración de GitHub.
git config --list no muestra las entradas globales	Las entradas globales pueden sobrescribirse por una configuración local; verifica con --global --list.	Asegúrate de que estás usando --global correctamente, o ejecuta git config --global --list directamente.
git log muestra un autor genérico <>	Nunca configuraste user.name o user.email.	Ejecuta git config --global user.name "Tu Nombre" y git config --global user.email "tu@correo.com".
Al cambiar de máquina, los commits mantienen el email anterior	La configuración global aún apunta a la identidad anterior.	Actualiza la configuración global con git config --global user.email "nuevo@correo.com" y/o modifica el historial con git filter-repo.

Práctica avanzada: cambiar la identidad globalmente en toda la historia de un repositorio

Si has estado cometiendo con una identidad incorrecta y deseas corregirla, puedes usar herramientas como git filter-repo o git filter-branch. Aquí hay un breve ejemplo usando git filter-repo (instálalo con pip install git-filter-repo):

# Renombra el autor en todos los commits, manteniendo el mismo ID de commit
git filter-repo --force --mailmap REPLACE_MAP

Un archivo mailmap típico puede verse así:

previous.name <previous@example.com> Actual Name <actual@example.com>

Después de ejecutar git filter-repo, deberás forzar push (si ya has publicado el repositorio). Ten cuidado: esto reescribe el historial.

Conclusión

Establecer y verificar la configuración global de Git es un paso fundamental que allana el camino para un control de versiones limpio y colaborativo. Al configurar user.name y user.email globalmente, aseguras que cada commit refleje tu identidad de manera consistente, facilitas la colaboración y evitas problemas comunes como correos electrónicos no verificados o espacios de trabajo sobrescritos accidentalmente.

Recuerda:

1. Elige un nombre claro y un email verificable.
2. Verifica tu configuración con git config --global --list y filtra con grep si es necesario.
3. Utiliza la configuración local cuando necesites una identidad diferente por repositorio.
4. Mantén tus archivos de configuración seguros y documenta cualquier cambio.

Al seguir las mejores prácticas y evitar errores comunes, mantendrás tu configuración de Git ordenada, segura y alineada con tus necesidades de desarrollo. Ahora estás listo para clonar, crear y colaborar en proyectos con confianza, sabiendo que cada commit cuenta tu historia correctamente.

Próximos pasos

• Configura una dirección de correo electrónico profesional si aún no lo has hecho.
• Experimenta con superposiciones locales (--local) para practicar.
• Explora git config --list --show-origin para comprender de dónde proviene cada entrada.
• Aprende a utilizar un archivo .mailmap para mantener un historial de contribuciones limpio.

Si sigues estos pasos, tendrás un perfil de Git sólido y profesional listo para cualquier equipo o proyecto. ¡Feliz programación!