git remote

Qué hace git remote

Un remoto es una referencia con nombre a otra copia de tu repositorio — generalmente una alojada en un servidor como GitHub, GitLab o Bitbucket. El comando git remote crea, lista, renombra y elimina estas conexiones. No transfiere ningún commit por sí mismo; en cambio, almacena nombres cortos y memorables que apuntan a URLs de repositorios para que los comandos que sí mueven datos — git fetch, git pull y git push — puedan referirse a ellos.

Piensa en un remoto como un marcador. En lugar de escribir git push https://github.com/acme/app.git main cada vez, guardas la URL una vez con el nombre origin y ejecutas git push origin main. La correspondencia entre nombres y URLs vive en el archivo .git/config de tu repositorio, por lo que cada clon mantiene su propia lista de remotos.

El diagrama a continuación muestra dos conexiones remotas desde un repositorio local: una hacia un repositorio central y otra hacia el repositorio de otro desarrollador. Como los nombres se comparten por convención, puedes decirle a un compañero que "haga pull desde upstream" y sabrá exactamente qué comando ejecutar.

El remoto origin

Ejecutar git clone crea automáticamente un remoto llamado origin que apunta de vuelta al repositorio desde el que clonaste. Por convención, origin es "tu" copia canónica en el servidor — la que usas para hacer push y pull día a día. El nombre no tiene nada de especial; es simplemente el valor predeterminado que elige Git, y puedes renombrarlo o eliminarlo como cualquier otro remoto.

Un segundo remoto común es upstream. Cuando haces un fork de un proyecto, origin apunta a tu fork y upstream apunta al repositorio original, de modo que puedes incorporar los nuevos cambios del proyecto mientras envías tu propio trabajo a tu fork.

URLs de repositorio

Una URL de remoto le indica a Git dónde se encuentra el repositorio y qué protocolo de transporte usar. Los dos que verás con más frecuencia son HTTPS y SSH.

HTTPS es el más sencillo de configurar y funciona a través de cortafuegos y proxies. Los repositorios públicos se pueden clonar por HTTPS sin credenciales; para repositorios privados o para hacer push, Git solicita un nombre de usuario y un token de acceso personal, generalmente guardados en caché por un asistente de credenciales.

https://host/path/to/repo.git

SSH se autentica con un par de claves en lugar de una contraseña, lo que resulta conveniente para push repetidos una vez que tu clave está registrada en el servidor. Se presenta en dos formas equivalentes — la URL completa ssh:// y la sintaxis más corta similar a SCP:

ssh://user@host/path/to/repo.git

user@host:path/to/repo.git

No necesitas memorizar el formato de una URL; lo copias desde el botón "Clone" del proveedor de alojamiento. El comando git remote almacena entonces la forma que hayas utilizado.

Subcomandos de git remote

git remote expone varios subcomandos. Cada uno edita la sección de remotos del archivo .git/config; podrías hacer los mismos cambios manualmente en un editor de texto, pero los subcomandos son más seguros y actualizan la configuración relacionada por ti.

git remote add

Registra un nuevo remoto llamado <name> que apunta a <url>.

git remote add <name> <url>

Dos opciones útiles:

• -f ejecuta git fetch <name> inmediatamente después de crear el remoto, de modo que sus ramas se descargan de inmediato.
• --tags hace fetch del remoto e importa también todas sus etiquetas.

git remote rename

Renombra un remoto de <old> a <new>, actualizando las ramas de seguimiento remoto y cualquier configuración relacionada.

git remote rename <old> <new>

git remote remove

Elimina la conexión llamada <name> junto con sus ramas de seguimiento remoto y su configuración. git remote rm es un alias más antiguo para el mismo comando.

git remote remove <name>

git remote set-url

Cambia la URL a la que apunta un remoto existente — por ejemplo, cuando cambias un repositorio de HTTPS a SSH.

git remote set-url <name> <new-url>

git remote get-url

Imprime la(s) URL(s) de un remoto. Agrega --push para ver específicamente la URL de push, o --all para listar todas las URLs configuradas.

git remote get-url <name>

git remote show

Imprime información detallada sobre un remoto: sus URLs de fetch y push, sus ramas y cómo las rastrean tus ramas locales.

git remote show <name>

git remote prune

Elimina las ramas de seguimiento remoto locales de <name> cuyos equivalentes han sido eliminados en el servidor. Usa --dry-run para listar lo que se eliminaría sin borrar nada realmente.

git remote prune <name>

Listar tus remotos

Ejecutar git remote sin argumentos imprime el nombre de cada remoto configurado, uno por línea:

git remote
origin
upstream
other_repo

Agrega la opción -v (verbose) para ver también las URLs de fetch y push de cada remoto:

git remote -v
origin      [email protected]:origin_user/reponame.git (fetch)
origin      [email protected]:origin_user/reponame.git (push)
upstream    https://example.com/upstream_user/reponame.git (fetch)
upstream    https://example.com/upstream_user/reponame.git (push)
other_repo  https://example.com/other_repo/reponame.git (fetch)
other_repo  https://example.com/other_repo/reponame.git (push)

Un remoto puede tener una URL de fetch diferente a la de push — útil, por ejemplo, cuando haces pull desde un espejo rápido pero haces push al servidor canónico.

Agregar un remoto

Para comenzar a colaborar con otro repositorio, regístralo con git remote add. El nombre que elijas se convierte en un atajo que puedes usar en fetch, pull y push:

git remote add upstream https://example.com/upstream_user/reponame.git

Conectarse a los repositorios de otros desarrolladores permite la colaboración fuera del repositorio central. Por ejemplo, si un colega mantiene un repositorio de acceso público en dev.example.com/tom.git, agrégalo así y luego descarga su trabajo:

git remote add tom https://dev.example.com/tom.git
git fetch tom

Inspeccionar un remoto

El subcomando show contacta al remoto e informa sobre sus ramas y la configuración de seguimiento — útil cuando quieres confirmar qué rama se actualizará con un push o pull:

git remote show upstream
* remote upstream
  Fetch URL: https://example.com/upstream_user/reponame.git
  Push  URL: https://example.com/upstream_user/reponame.git
  HEAD branch: main
  Remote branches:
    main      tracked
    docs      tracked
    new-input tracked
  Local ref configured for 'git push':
    main pushes to main (fast-forwardable)

Fetch, pull y push

Configurar un remoto es solo el paso de preparación. Una vez que existe, pasas su nombre a los comandos que realmente mueven los commits:

• git fetch <remote> descarga los nuevos commits del remoto hacia tus ramas de seguimiento remoto sin modificar tus archivos de trabajo.
• git pull <remote> <branch> hace fetch y luego fusiona (o hace rebase) los cambios en tu rama actual.
• git push <remote> <branch> sube tus commits locales al remoto.

git push <remote-name> <branch-name>

Por ejemplo, para publicar la rama main en origin:

git push origin main

Si quieres profundizar en dónde se almacenan estos nombres y URLs, consulta el capítulo de git config, que documenta el archivo .git/config que edita git remote.

Práctica