Home / Herramientas / Git en tu Mac: instalación, identidad y claves SSH paso a paso
Git en tu Mac: instalación, identidad y claves SSH paso a paso

Git en tu Mac: instalación, identidad y claves SSH paso a paso

17 November 2026 · 23 min de lectura ··

Por qué conviene preparar Git con cuidado en una Mac nueva

Cuando abres una Mac por primera vez y quieres empezar a programar, Git es casi siempre la primera herramienta que necesitas. Sin ella no puedes clonar proyectos, guardar el historial de tu trabajo ni colaborar con otras personas. La buena noticia es que macOS facilita mucho el arranque, pero esa facilidad esconde un detalle: el Git que aparece “de regalo” en el sistema no es necesariamente el que te conviene usar durante años.

En este tutorial recorreremos todo el camino con calma. Instalaremos Git por el método más mantenible, comprobaremos que funciona, definiremos tu identidad, ajustaremos opciones que ahorran fricción diaria, guardaremos credenciales de forma segura y conectaremos tu equipo con GitHub mediante claves SSH y la herramienta de línea de comandos gh. Al final verás una lista de errores frecuentes y cómo resolverlos.

Las versiones de referencia que verificamos para escribir esta guía son las siguientes. Git está en la serie 2.55, macOS en su generación 27 (llamada Golden Gate, que solo funciona en Macs con Apple silicon) y Homebrew en la serie 7. GitHub CLI mantiene la línea 2.x, con versiones menores que cambian con frecuencia. No hace falta que tengas exactamente esos números; los comandos que verás funcionan igual en versiones cercanas, y al final de cada paso te indicamos cómo comprobar lo que tienes instalado.

Si estás empezando desde cero y todavía no tienes claro qué es un repositorio o un commit, te recomendamos leer antes Git y GitHub desde cero: control de versiones para principiantes, donde se explican esos conceptos. Aquí nos centraremos en la parte de preparación del entorno.

Comprobar qué Git trae ya tu sistema

Antes de instalar nada conviene saber si ya hay algo. Abre la aplicación Terminal (la encuentras con Spotlight pulsando Comando y barra espaciadora, y escribiendo su nombre) y ejecuta:

git --version

Si tu Mac no tiene las herramientas de desarrollo de Apple, macOS mostrará una ventana emergente que ofrece instalar las “Command Line Developer Tools”. Si la aceptas, se descarga un paquete que incluye un Git compilado por Apple. Si ya las tienes, verás una salida parecida a esta:

git version 2.50.1 (Apple Git-155)

El texto entre paréntesis es la pista clave. Esa versión la mantiene Apple y se actualiza solo junto con las herramientas de línea de comandos o con una actualización del sistema, de modo que casi siempre va varias versiones por detrás de la oficial. Para aprender y para proyectos pequeños es perfectamente utilizable. Sin embargo, si quieres las funciones más recientes, correcciones de seguridad inmediatas y control sobre cuándo actualizas, lo razonable es instalar tu propia copia con un gestor de paquetes.

Una forma útil de saber qué binario se está ejecutando realmente es preguntar por su ruta:

which git

Con el Git de Apple la ruta será /usr/bin/git. Más adelante, tras instalar la versión de Homebrew, verás que apunta a otro sitio. Guarda esta comprobación, porque será nuestra herramienta principal de diagnóstico.

Instalar Homebrew, el gestor de paquetes de macOS

Homebrew es un gestor de paquetes para macOS. Con un solo comando descarga, compila o instala binarios de miles de programas y los mantiene actualizados. Lo usaremos para Git y también para otras herramientas que querrás tener a mano, como gh.

Homebrew necesita las Command Line Tools de Apple para funcionar, pero su instalador se encarga de pedirlas si faltan. Ejecuta el script oficial de instalación:

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

El instalador te explica qué va a hacer, te pide confirmar con la tecla Intro y solicita la contraseña de tu usuario. Cuando termina, imprime un apartado llamado “Next steps” con dos o tres líneas que debes copiar y ejecutar. Este paso es el que más gente se salta, y es el motivo de que luego el terminal diga “brew: command not found”.

En un Mac con Apple silicon, Homebrew se instala en /opt/homebrew, y hay que añadir esa carpeta al PATH. Las líneas que te sugiere el instalador suelen ser equivalentes a estas:

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

La primera línea guarda la configuración para futuras sesiones y la segunda la activa en la ventana actual. Como macOS usa zsh como intérprete por defecto, el archivo adecuado es ~/.zprofile. Si usas otro intérprete, adapta el nombre del archivo.

Una nota sobre Macs con Intel: macOS 27 solo admite Apple silicon, así que en equipos nuevos no tendrás que preocuparte por la ruta /usr/local. Si mantienes una Mac Intel con una versión anterior del sistema, Homebrew pasa a un soporte reducido en las series recientes y es posible que algunas fórmulas ya no se actualicen con tanta rapidez.

Comprueba que todo quedó bien:

brew --version
brew doctor

El segundo comando revisa la instalación y avisa de problemas. Lo ideal es ver el mensaje “Your system is ready to brew”. Si aparecen advertencias, léelas con atención, porque suelen indicar exactamente qué corregir.

Instalar Git con Homebrew y comprobar que se usa el correcto

Con Homebrew funcionando, instalar Git es una sola línea:

brew install git

El proceso descarga la fórmula y sus dependencias. Al terminar, abre una ventana nueva del terminal para que se recargue el PATH y verifica:

git --version
which git

Deberías ver algo como esto:

git version 2.55.0
/opt/homebrew/bin/git

Si la ruta sigue siendo /usr/bin/git, significa que tu PATH pone antes la carpeta del sistema que la de Homebrew. Revisa que la línea con brew shellenv esté en tu ~/.zprofile y que no haya otra configuración que reordene las rutas. Puedes ver el orden actual con:

echo $PATH | tr ':' '\n'

Lo correcto es que /opt/homebrew/bin aparezca antes que /usr/bin. A partir de ahora, mantener Git al día es tan sencillo como ejecutar de vez en cuando estos dos comandos:

brew update
brew upgrade git

Una ventaja importante de esta forma de instalar es que mantener Git siempre actualizado deja de depender de las actualizaciones del sistema operativo. Si aparece una vulnerabilidad, recibirás la corrección en cuanto la fórmula se publique, no meses después.

Entender los tres niveles de configuración

Instalar Git no basta para empezar a trabajar. Antes de guardar tu primer commit hay que decirle quién eres, y para eso se usa git config. Este comando lee y escribe variables que controlan el comportamiento de Git, y esas variables viven en tres niveles distintos.

  • Nivel de sistema, con la opción --system: afecta a todos los usuarios del equipo. Rara vez lo tocarás en una Mac personal.
  • Nivel global, con la opción --global: afecta a todos los repositorios de tu usuario. Se guarda en ~/.gitconfig. Es el nivel que usarás casi siempre.
  • Nivel local, con la opción --local (o sin opción): afecta solo al repositorio donde estás. Se guarda en .git/config dentro de ese proyecto.

La regla es que el nivel más específico gana. Si tu configuración global dice una cosa y la local dice otra, dentro de ese repositorio se aplica la local. Esto resulta muy práctico cuando trabajas con un correo personal y otro de empresa, como veremos más abajo.

Puedes ver de dónde viene cada valor con la opción --show-origin:

git config --list --show-origin

La salida indica el archivo de cada línea, lo cual ayuda a descubrir por qué un ajuste no tiene el valor que esperabas.

Definir tu identidad: nombre y correo

Cada commit guarda un autor. Si no configuras estos datos, Git intentará adivinarlos a partir del nombre de tu usuario del sistema y del equipo, y el resultado suele ser un correo inválido que luego es molesto de corregir. Hazlo desde el principio:

git config --global user.name "Lucía Fernández"
git config --global user.email "[email protected]"

Usa un nombre real o el que quieras que aparezca públicamente. Para el correo, lo ideal es el mismo que registraste en tu cuenta de GitHub, GitLab o similar, porque así la plataforma asocia tus commits a tu perfil. Si prefieres no publicar tu dirección personal, GitHub ofrece un correo anónimo con formato de “noreply” que puedes encontrar en los ajustes de tu cuenta, en la sección de correos electrónicos.

Para confirmar que se guardó, lee los valores concretos:

git config --global user.name
git config --global user.email

Si cometiste un error al escribir, no hay nada que reparar. Basta con volver a ejecutar el mismo comando con el valor correcto, y se sobrescribe el anterior. También puedes abrir el archivo directamente y editarlo, porque es texto plano:

git config --global --edit

Este comando abre ~/.gitconfig en tu editor. De momento, tras definir la identidad, tendrá un aspecto como este:

[user]
	name = Lucía Fernández
	email = [email protected]

Elegir el editor que Git abrirá por ti

Hay momentos en los que Git abre un editor: al escribir un mensaje de commit largo, al hacer un rebase interactivo o al resolver una combinación. Si no indicas nada, usará el valor de la variable de entorno EDITOR o, en su defecto, vi, que desconcierta a quien nunca lo ha usado, porque no es obvio cómo salir de él.

Elige el que te resulte cómodo. Algunas opciones habituales:

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

Solo debes ejecutar una de ellas. En el caso de Visual Studio Code, la opción --wait es imprescindible: le dice a Git que espere a que cierres la pestaña antes de continuar. Sin ella, Git creería que has terminado de inmediato y cancelaría la operación por tener un mensaje vacío. Para que el comando code exista en tu terminal, instala la orden desde la paleta de comandos del propio editor.

Si usas otro editor gráfico, busca en su documentación el equivalente de “esperar a que se cierre”. Casi todos tienen uno.

Ajustes recomendados que evitan problemas futuros

Con identidad y editor definidos ya puedes trabajar, pero hay varios ajustes que merece la pena fijar desde el primer día. Ninguno es obligatorio, y todos se pueden revertir.

Nombre de la rama inicial

Por defecto, git init creaba una rama llamada master. Hoy la convención dominante es main, y las plataformas de alojamiento la usan al crear repositorios nuevos. Para que tus repositorios locales coincidan:

git config --global init.defaultBranch main

Colores en la salida

Los colores hacen mucho más legible git status y git diff. En las versiones modernas ya vienen activados cuando el terminal los admite, pero declararlo de forma explícita no estorba:

git config --global color.ui auto

El valor auto activa los colores solo cuando la salida va a una pantalla, y los desactiva cuando redirigimos el resultado a un archivo, lo que evita que se llene de secuencias de escape.

Comportamiento de pull y push

Al ejecutar git pull, Git debe combinar tus cambios con los remotos. Si has divergido, hay dos estrategias: crear un commit de combinación o reaplicar tus commits encima de los remotos (rebase). Git te avisa de que debes elegir una. Si prefieres un historial lineal, configura el rebase:

git config --global pull.rebase true

Si en cambio prefieres que solo se acepte un avance simple y que cualquier divergencia se detenga para decidir a mano, usa esta variante:

git config --global pull.ff only

Para push, hay un ajuste que ahorra el error típico de la primera subida de una rama nueva, el de “no tiene una rama upstream”. Con esta variable Git crea la relación automáticamente:

git config --global push.autoSetupRemote true

Archivos que nunca quieres versionar

macOS genera un archivo oculto llamado .DS_Store en casi cada carpeta que abres con el Finder. No aporta nada a un proyecto y ensucia los repositorios. En lugar de añadirlo al .gitignore de cada proyecto, puedes crear una lista global de exclusiones personales:

git config --global core.excludesfile ~/.gitignore_global
printf ".DS_Store\n.AppleDouble\n.LSOverride\n*.swp\n.idea/\n.vscode/\n" > ~/.gitignore_global

Con esto, Git ignora esos archivos en todos tus repositorios sin que tengas que tocar el .gitignore del equipo. Recuerda que esta lista es solo tuya: los patrones que afectan a todo el proyecto, como las carpetas de dependencias, deben seguir en el .gitignore del repositorio para que lo comparta todo el mundo.

Alias para los comandos que repites

Los alias convierten secuencias largas en atajos. Estos son algunos que resultan útiles:

git config --global alias.st "status -sb"
git config --global alias.lg "log --oneline --graph --decorate -15"
git config --global alias.ultimo "log -1 --stat"
git config --global alias.deshacer "reset --soft HEAD~1"

Después, git st muestra un estado compacto y git lg un gráfico breve de las últimas quince confirmaciones. Antes de usar el alias deshacer, asegúrate de entender qué hace: mueve la rama un commit atrás pero conserva tus cambios preparados. Si quieres profundizar en cómo escribir buenos mensajes y en las opciones que admite la confirmación de cambios, consulta Git commit explicado: opciones, mensajes y buenas prácticas.

Revisar y corregir lo que has configurado

Después de varios ajustes, es sano mirar el resultado completo:

git config --global --list

Una salida típica sería:

user.name=Lucía Fernández
user.email=[email protected]
core.editor=code --wait
init.defaultbranch=main
color.ui=auto
pull.rebase=true
push.autosetupremote=true
core.excludesfile=/Users/lucia/.gitignore_global
alias.st=status -sb

Observa que Git escribe los nombres de las variables en minúsculas al listarlos. No es un error, la comparación no distingue mayúsculas. Si necesitas eliminar un ajuste que ya no quieres, existe una orden específica:

git config --global --unset alias.deshacer

Y si lo que quieres es ver el valor efectivo de una variable en el repositorio actual, teniendo en cuenta todos los niveles, pregunta sin indicar ninguno:

git config user.email

Esa consulta es muy útil para confirmar con qué correo vas a firmar el commit que estás a punto de hacer.

Usar identidades distintas según la carpeta

Un caso muy real: tienes proyectos personales y proyectos del trabajo, y no quieres mezclar los correos. Git permite incluir configuración condicional según la ubicación del repositorio. Organiza tus carpetas de forma que cada contexto viva en una raíz distinta:

~/Proyectos
├── personal
│   ├── blog
│   └── scripts
└── empresa
    ├── api-pagos
    └── panel-interno

En tu ~/.gitconfig añade una sección que cargue otro archivo cuando el repositorio esté dentro de empresa:

[user]
	name = Lucía Fernández
	email = [email protected]

[includeIf "gitdir:~/Proyectos/empresa/"]
	path = ~/.gitconfig-empresa

Y crea ese archivo adicional con el correo corporativo:

[user]
	email = [email protected]

Desde ese momento, cualquier repositorio bajo ~/Proyectos/empresa/ usará el correo de trabajo, y el resto seguirá con el personal. Verifícalo entrando en uno de ellos y ejecutando git config user.email. Es una solución más robusta que acordarse de configurar cada clon a mano, porque el olvido es justo lo que acaba produciendo commits con el correo equivocado.

Guardar credenciales con el llavero de macOS

Cuando trabajas con repositorios remotos por HTTPS, Git necesita autenticarte en cada conexión. Escribir la contraseña o el token cada vez sería insoportable, así que se usa un asistente de credenciales. En macOS, el asistente natural es el llavero del sistema, que almacena los datos cifrados y los protege con tu sesión.

git config --global credential.helper osxkeychain

Las instalaciones de Git con Homebrew y las de Apple incluyen este asistente. La primera vez que te autentiques, la clave se guarda, y las siguientes veces Git la recupera sin preguntar.

Un aviso importante sobre las contraseñas: las plataformas de alojamiento ya no aceptan la contraseña de tu cuenta para operaciones de Git por HTTPS. Lo que se pide es un token de acceso personal o una autenticación a través de un navegador. Por eso, la vía más cómoda y segura es la que vemos en las dos secciones siguientes: claves SSH o GitHub CLI, que gestionan todo esto por ti.

Si guardaste una credencial incorrecta y Git insiste en usarla, puedes borrarla pidiendo al asistente que la olvide:

printf "protocol=https\nhost=github.com\n\n" | git credential-osxkeychain erase

También puedes eliminarla desde la aplicación Acceso a Llaveros, buscando la entrada de github.com.

Crear una clave SSH y registrarla en el llavero

SSH es el método preferido por muchos desarrolladores para hablar con un remoto: no tienes que introducir credenciales por conexión, y la clave privada nunca sale de tu equipo. Se basa en un par de claves, una privada que guardas y una pública que entregas a la plataforma.

Genera el par con el algoritmo Ed25519, que es hoy el recomendado por su seguridad y su brevedad:

ssh-keygen -t ed25519 -C "[email protected]"

El programa pregunta dónde guardar el archivo. Acepta la ruta por defecto, que será ~/.ssh/id_ed25519, pulsando Intro. A continuación solicita una contraseña de protección (passphrase). Te aconsejamos no dejarla vacía: si alguien copia el archivo de tu clave, esa contraseña es la última barrera. Gracias al llavero, no tendrás que teclearla en cada uso.

Verifica que se crearon los dos archivos:

~/.ssh
├── id_ed25519
└── id_ed25519.pub

El archivo sin extensión es la clave privada y no debe compartirse jamás. El que termina en .pub es la pública, la que sí se entrega.

Ahora inicia el agente SSH y añade la clave guardando su contraseña en el llavero de macOS:

eval "$(ssh-agent -s)"
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Para que esto sea permanente, crea o edita el archivo ~/.ssh/config y añade lo siguiente:

Host github.com
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519

Con esta configuración, el sistema carga la clave automáticamente y recuerda la contraseña. Si por algún motivo el archivo config no existe, créalo con touch ~/.ssh/config y limita sus permisos con chmod 600 ~/.ssh/config, ya que SSH rechaza archivos de configuración demasiado abiertos.

Registrar la clave pública en GitHub y probar la conexión

Copia el contenido de tu clave pública al portapapeles con el comando propio de macOS:

pbcopy < ~/.ssh/id_ed25519.pub

Después, en la web de GitHub, entra en los ajustes de tu cuenta, busca el apartado de claves SSH y GPG, pulsa el botón de añadir una nueva clave SSH, ponle un título reconocible (por ejemplo, “MacBook personal”) y pega el contenido. Guarda.

Para comprobar que funciona, abre una conexión de prueba:

La primera vez, SSH te preguntará si confías en el servidor y mostrará su huella. Escribe yes para continuar. Si todo va bien, recibirás un mensaje de bienvenida con tu nombre de usuario, y el comando terminará sin abrir ninguna sesión interactiva, que es lo esperado.

Desde este punto, puedes clonar repositorios con la dirección SSH, que tiene este formato:

git clone [email protected]:tu-usuario/mi-proyecto.git

Si ya tienes un repositorio clonado por HTTPS y quieres pasarlo a SSH, cambia la dirección remota:

git remote set-url origin [email protected]:tu-usuario/mi-proyecto.git
git remote -v

El segundo comando enseña las direcciones de lectura y escritura para que compruebes el cambio.

Alternativa cómoda: autenticarse con GitHub CLI

La herramienta oficial de línea de comandos de GitHub, llamada gh, simplifica el proceso. Puede iniciar sesión por ti, generar y subir una clave SSH, y además permite crear repositorios, abrir solicitudes de cambio y revisar incidencias sin salir del terminal. Instálala con Homebrew:

brew install gh
gh --version

Después inicia sesión con el asistente interactivo:

gh auth login

Te hará varias preguntas: la plataforma (GitHub.com), el protocolo preferido para Git (HTTPS o SSH) y la forma de autenticarte. Lo más cómodo es elegir el navegador: te muestra un código de un solo uso, abre la página de GitHub y, cuando lo introduces, la sesión queda activa. Si eliges SSH, el asistente puede detectar tu clave o crear una nueva y subirla a tu cuenta.

Una pieza especialmente útil es que gh puede actuar como asistente de credenciales de Git. Esto sustituye la necesidad de gestionar tokens a mano cuando usas HTTPS:

gh auth setup-git
gh auth status

El segundo comando muestra con qué cuenta estás conectado, qué protocolo usas y qué permisos tiene el token. Resulta útil para depurar problemas de autenticación. Con esta base ya puedes crear un repositorio directamente desde una carpeta local:

mkdir diario-de-bitacora && cd diario-de-bitacora
git init
echo "# Diario de bitácora" > README.md
git add README.md
git commit -m "Primer commit con el README"
gh repo create diario-de-bitacora --private --source=. --push

Esta secuencia crea la carpeta, inicializa Git, guarda un primer commit, crea el repositorio remoto privado y sube el contenido en un solo paso. Si quieres que sea público, cambia la opción --private por --public.

Firmar tus commits con la clave SSH

Cualquiera puede escribir el nombre y el correo que quiera en su configuración, de modo que un commit por sí solo no demuestra quién lo hizo. La firma criptográfica añade esa garantía y GitHub muestra una etiqueta de “Verified” junto a los commits firmados. Desde hace varias versiones, Git permite firmar con la misma clave SSH que ya tienes, sin necesidad de montar GPG.

Configura Git para que use el formato SSH y apunte a tu clave pública:

git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true

Para que GitHub reconozca la firma, debes añadir la misma clave pública en tus ajustes, pero esta vez eligiendo el tipo “Signing Key” en lugar de “Authentication Key”. Es el mismo contenido, registrado con otro propósito. Puedes subirla dos veces, una para cada función.

Con commit.gpgsign true, todos los commits nuevos se firman automáticamente. Para comprobar un commit concreto en tu máquina, necesitas una lista de firmantes permitidos:

printf "[email protected] %s\n" "$(cat ~/.ssh/id_ed25519.pub)" > ~/.ssh/allowed_signers
git config --global gpg.ssh.allowedSignersFile ~/.ssh/allowed_signers
git log --show-signature -1

Esa última instrucción muestra la verificación de la firma del commit más reciente. Si ves un mensaje de “Good signature”, todo está en su sitio.

Hacer una prueba completa de extremo a extremo

Es buena idea validar toda la cadena con un repositorio de práctica. Sigue esta secuencia y comprueba cada resultado:

mkdir -p ~/Proyectos/personal/prueba-git && cd ~/Proyectos/personal/prueba-git
git init
git status

La salida debería indicar que estás en la rama main y que todavía no hay commits. Crea un archivo, prepáralo y confirma:

echo "Hola desde mi Mac" > saludo.txt
git add saludo.txt
git commit -m "Añade un saludo de prueba"
git log --oneline

Verás una línea con el identificador abreviado del commit y tu mensaje. Si has activado la firma, comprueba también con git log --show-signature -1. Para confirmar la autoría, mira el detalle completo:

git log -1 --format="%an <%ae>"

Debe imprimir el nombre y el correo que definiste antes. Si coincide, tu identidad está bien configurada. Si estás pensando en profundizar más allá de lo básico, la guía completa de Git para desarrolladores cubre ramas, combinaciones y flujos de trabajo en equipo que complementan esta preparación.

Errores frecuentes y cómo resolverlos

Aunque el proceso es corto, hay tropiezos que se repiten. Estos son los más habituales con su causa y su solución.

El terminal dice “brew: command not found”

Es casi siempre porque no se ejecutaron las líneas de “Next steps” del instalador. Añade la línea con brew shellenv a tu ~/.zprofile, como vimos, y abre una terminal nueva. Para confirmar que el binario existe, comprueba la carpeta de instalación con ls /opt/homebrew/bin.

Git sigue mostrando la versión de Apple

Si git --version imprime “Apple Git” después de instalar con Homebrew, tu PATH tiene prioridad en el orden equivocado. Revisa con which -a git, que lista todos los ejecutables encontrados en orden de prioridad. El primero de la lista es el que se usa. Mueve la carga de brew shellenv a una posición anterior o, simplemente, comprueba que no hay otra configuración que antepone /usr/bin.

Los commits aparecen con un correo extraño

Si ves un correo con el nombre de tu equipo seguido de “.local”, es que no configuraste user.email. Defínelo ahora. Ten en cuenta que los commits ya hechos conservarán el valor antiguo; para corregir el último puedes usar git commit --amend --reset-author --no-edit, siempre que aún no lo hayas publicado. Reescribir historial ya compartido es delicado y debe coordinarse con el equipo.

Permission denied al conectar por SSH

Significa que el servidor no reconoce ninguna de tus claves. Revisa tres cosas en este orden. Primero, que la clave pública esté realmente registrada en tu cuenta. Segundo, que el agente la tenga cargada, con ssh-add -l. Tercero, que la dirección remota use el formato [email protected]:, y no una dirección HTTPS. Para obtener más información, ejecuta la conexión en modo detallado:

Las líneas de salida muestran qué claves se ofrecen y cuál rechaza el servidor.

Vim se queda abierto y no sé salir

Si Git abrió vi o vim por falta de editor configurado, pulsa la tecla Escape, escribe :wq y pulsa Intro para guardar y salir, o :q! para salir sin guardar. Después configura core.editor con una herramienta que conozcas para que no vuelva a pasar.

El editor se cierra y Git aborta el commit

Es el síntoma de un editor gráfico configurado sin la opción de espera. Añade --wait al comando, como mostramos en la sección del editor. Comprueba el valor con git config core.editor.

Avisos de permisos en la carpeta .ssh

SSH es muy estricto con los permisos. Si ves un aviso de “UNPROTECTED PRIVATE KEY FILE”, restringe el acceso:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

Buenas prácticas de seguridad y mantenimiento

Una vez que todo funciona, conviene adoptar unos hábitos que evitan problemas a largo plazo.

  • Protege la clave privada con contraseña y no la copies a servicios en la nube ni a repositorios. Si sospechas que se ha filtrado, elimínala de tu cuenta de GitHub y genera una nueva.
  • Usa una clave por equipo en lugar de reutilizar la misma en todos tus dispositivos. Así, si pierdes uno, revocas solo esa.
  • Actualiza con regularidad. Ejecutar brew update && brew upgrade una vez por semana mantiene Git, gh y el resto de herramientas con parches al día.
  • Revisa tus claves registradas de vez en cuando en los ajustes de GitHub y elimina las de equipos que ya no usas.
  • Nunca confirmes secretos como contraseñas, tokens o archivos .env. Añade esos patrones al .gitignore del proyecto, y si por error llegaste a subir uno, considera la credencial comprometida y rótala.
  • Haz una copia de tu ~/.gitconfig y de tu configuración de SSH (sin la clave privada sin cifrar) en un lugar seguro. Te permitirá reproducir tu entorno en una máquina nueva en minutos.

Un detalle que ayuda mucho al migrar de equipo: la configuración global es un único archivo de texto. Si lo guardas en un repositorio privado de configuración personal, restaurar tu entorno se reduce a copiar ese archivo y repetir la instalación de Homebrew.

Comparar el método de Homebrew con otras alternativas

Homebrew no es la única forma de instalar Git en una Mac. Conviene conocer las demás para elegir con criterio.

El Git de Apple, que llega con las Command Line Tools, es la opción de menor esfuerzo. Funciona sin instalar nada adicional y se actualiza con el sistema. Su desventaja es el retraso respecto a la versión oficial. Es una buena opción para quien solo necesita lo básico.

El instalador gráfico del proyecto, disponible en su página oficial, ofrece paquetes para macOS. Es sencillo de seguir con un asistente, pero no se actualiza solo, y deberás descargar cada versión nueva manualmente. Además, puede conflictuar con otras copias en el PATH.

MacPorts es otro gestor de paquetes veterano, con un enfoque más aislado que instala en /opt/local. Es una alternativa sólida, aunque la comunidad de Homebrew es más grande y encontrarás más documentación y ayuda.

Compilar desde el código fuente te da el máximo control, pero exige gestionar dependencias y actualizaciones por tu cuenta. Solo tiene sentido si necesitas una compilación con opciones especiales.

Por último, hay interfaces gráficas como GitHub Desktop, Fork o Tower, que pueden instalarse con Homebrew mediante el subcomando brew install --cask. Son un complemento, no un sustituto: seguirán necesitando que Git esté disponible y bien configurado, y tus ajustes globales les afectarán igual.

Para la gran mayoría de las personas que programan, Homebrew ofrece el mejor equilibrio entre facilidad, actualizaciones y ecosistema, y por eso lo hemos elegido como base de este tutorial.

Conclusiones

Preparar Git en una Mac es una tarea de unos pocos minutos, pero hacerla bien te ahorra horas de confusión después. Has visto cómo distinguir el Git de Apple del que instalas con Homebrew, cómo comprobar que se ejecuta el correcto y cómo mantenerlo actualizado con un solo comando.

También has aprendido a definir tu identidad en el nivel global, a separar correos personales y profesionales con configuración condicional, y a fijar ajustes que mejoran el día a día, como la rama inicial main, la subida automática de ramas y la lista global de archivos ignorados. Has conectado tu equipo con GitHub de dos maneras complementarias, mediante claves SSH guardadas en el llavero y mediante gh, y has activado la firma de commits para que tu autoría sea verificable.

Lo más importante es que ahora sabes diagnosticar: which git, git config --list --show-origin, ssh -vT y gh auth status te dicen casi siempre dónde está el problema. Con tu entorno listo, el siguiente paso natural es practicar el flujo de trabajo con ramas, commits y solicitudes de cambio, empezando por un proyecto pequeño propio. Revisa de vez en cuando las versiones de tus herramientas, porque Git, Homebrew, gh y macOS evolucionan con rapidez, y mantenerlas al día es parte de trabajar con seguridad.