git - remotas - subir rama local a remoto
¿Hacer una pista de Git existente una rama remota? (19)
Sé cómo crear una nueva sucursal que rastree sucursales remotas, pero ¿cómo puedo hacer que una sucursal existente rastree una sucursal remota?
Sé que puedo editar el archivo .git/config
, pero parece que debería haber una forma más fácil.
Utilice la opción ''--track''
Después de un
git pull
:git checkout --track <remote-branch-name>
O:
git fetch && git checkout <branch-name>
1- actualiza tus metadatos locales usando: git fetch --todos
2- muestre sus sucursales locales y remotas usando: git branch -a , vea la siguiente captura de pantalla
3- Cambie a la rama de destino, que desea vincular con el control remoto: usando
git checkout branchName
ejemplo:
4- Enlace su sucursal local a una sucursal remota usando:
rama de git --estable en sentido ascendente a nombreOfRemoteBranch
NB: nameOfRemoteBranch : para copiar desde la salida del paso 2 "git branch -r"
Ejemplo de uso:
Aquí, usando github
y git version 2.1.4
, simplemente haz:
$ git clone [email protected]:user/repo.git
Y los controles remotos vienen por itelsef, incluso si no están vinculados localmente:
$ git remote show origin
* remote origin
Fetch URL: [email protected]:user/repo.git
Push URL: [email protected]:user/repo.git
HEAD branch: master
Remote branches:
develop tracked <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
master tracked
Local branch configured for ''git pull'':
master merges with remote master
Local ref configured for ''git push'':
master pushes to master (up to date)
Pero claro, todavía no hay sucursal local:
$ git branch
* master <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
¿Ver? Ahora, si acaba de pagar develp, hará la magia automáticamente:
$ git checkout develop
Branch develop set up to track remote branch develop from origin.
Switched to a new branch ''develop''
¡Tan fácil!
Resumen. Solo ejecuta estos 2 comandos:
$ git clone [email protected]:user/repo.git
$ git checkout develop
Asegúrate de ejecutar:
git config push.default tracking
para poder empujar sin problemas
Creo que tan pronto como Git 1.5.x podría hacer que una sucursal local $BRANCH
rastreara una sucursal remota origin/$BRANCH
, como esta.
Dado que $BRANCH
y origin/$BRANCH
existen, y no ha verificado actualmente $BRANCH
(cámbielo si tiene), haga lo siguiente:
git branch -f --track $BRANCH origin/$BRANCH
Esto recrea $BRANCH
como una rama de seguimiento. La -f
obliga a la creación a pesar de que ya existen $BRANCH
. --track
es opcional si los valores predeterminados habituales están en su lugar (es decir, el parámetro git-config branch.autosetupmerge
es verdadero).
Tenga en cuenta que si origin/$BRANCH
aún no existe, puede crearlo presionando su $BRANCH
local en el repositorio remoto con:
git push origin $BRANCH
Seguido por el comando anterior para promover la rama local en una rama de seguimiento.
Dada una rama foo
y un remoto upstream
:
A partir de Git 1.8.0:
git branch -u upstream/foo
O, si la rama local foo
no es la rama actual:
git branch -u upstream/foo foo
O, si te gusta escribir comandos más largos, estos son equivalentes a los dos anteriores:
git branch --set-upstream-to=upstream/foo
git branch --set-upstream-to=upstream/foo foo
A partir de Git 1.7.0:
git branch --set-upstream foo upstream/foo
Notas:
Todos los comandos anteriores causarán que foo
local de la sucursal foo
de sucursal remota desde el remoto upstream
. La sintaxis antigua (1.7.x) está en desuso a favor de la nueva sintaxis (1.8+). La nueva sintaxis pretende ser más intuitiva y fácil de recordar.
Ver también: ¿Por qué necesito hacer `--set-upstream` todo el tiempo?
De alguna manera relacionada, estaba tratando de agregar una rama de seguimiento remoto a una rama existente, pero no tenía acceso a ese repositorio remoto en el sistema donde quería agregar esa rama de seguimiento remoto (porque frecuentemente exporto una copia de este Repo a través de sneakernet a otro sistema que tenga acceso para empujar a ese control remoto). Descubrí que no había forma de forzar la adición de una sucursal remota en el local que aún no se había recuperado (por lo que local no sabía que la sucursal existía en el remoto y obtendría el error: the requested upstream branch ''origin/remotebranchname'' does not exist
).
Al final, logré agregar la nueva rama remota previamente desconocida (sin recuperar) agregando un nuevo archivo de cabecera en .git/refs/remotes/origin/remotebranchname
y luego copiando el ref (el globo ocular fue más rápido, por más que cojo); -) desde el sistema con acceso al repositorio de origen a la estación de trabajo (con el repositorio local donde estaba agregando la rama remota).
Una vez hecho esto, podría usar git branch --set-upstream-to=origin/remotebranchname
Editar .git/config
es probablemente la forma más fácil y rápida. Eso es lo que hacen los comandos de Git para manejar sucursales remotas, de todos modos.
Si no quieres eliminar el archivo con la mano (y no es tan difícil de hacer), siempre puedes usar git config
para hacerlo ... pero nuevamente, eso solo va a editar el archivo .git/config
, de todas formas.
Por supuesto, hay formas de rastrear automáticamente una sucursal remota cuando se usa git checkout
(al pasar la --track
, por ejemplo), pero estos comandos funcionan con nuevas sucursales, no con las existentes.
En muy corto
git branch --set-upstream yourLocalBranchName origin/develop
Esto hará que su yourLocalBranchName
la rama remota llamada develop
.
En realidad para que la respuesta aceptada funcione:
git remote add upstream <remote-url>
git fetch upstream
git branch -f --track qa upstream/qa
# OR:
git branch --set-upstream qa upstream/qa
Es posible que encuentre útil la herramienta git_remote_branch
. Ofrece comandos simples para crear, publicar, eliminar, rastrear y renombrar sucursales remotas. Una buena característica es que puedes pedir a un comando grb
que explique qué comandos de git ejecutaría.
grb explain create my_branch github
# git_remote_branch version 0.3.0
# List of operations to do to create a new remote branch and track it locally:
git push github master:refs/heads/my_branch
git fetch github
git branch --track my_branch github/my_branch
git checkout my_branch
Esta no es una respuesta directa a esta pregunta, pero quería dejar una nota aquí para cualquier persona que pueda tener el mismo problema que yo cuando intento configurar una sucursal ascendente.
Tenga cuidado con push.default .
Con versiones anteriores de git, el valor predeterminado era la coincidencia , lo que causaría un comportamiento no deseado si tiene, por ejemplo:
Rama local "master" seguimiento a origen / master
Ramificación remota "ascendente" de seguimiento a ascendente / maestro
Si intentas "git push" cuando estás en la rama "upstream", con push.default el git correspondiente intentaría automáticamente fusionar la rama local "master" en "upstream / master", causando una gran cantidad de caos.
Esto da un comportamiento más sano:
git config - global push.default en sentido ascendente
Esto tambien funcionaria
git branch --set-upstream-to=/< remote>/< branch> < localbranch>
Hago esto como un efecto secundario de empujar con la opción -u
como en
$ git push -u origin branch-name
La opción larga equivalente es --set-upstream
.
El comando git-branch
también comprende --set-upstream
, pero su uso puede ser confuso. La versión 1.8.0 modifica la interfaz.
git branch --set-upstream
está en desuso y puede eliminarse en un futuro relativamente lejano.git branch [-u|--set-upstream-to]
se ha introducido con un orden de argumentos másgit branch [-u|--set-upstream-to]
....
Fue tentador decir
git branch --set-upstream origin/master
, pero eso le dice a Git que organice la rama local "origin / master" para que se integre con la rama actualmente retirada, lo que es muy poco probable a lo que el usuario quiso decir. La opción está en desuso; use la nueva--set-upstream-to
(con una opción corta y dulce-u
) en su lugar.
Supongamos que tiene una sucursal local de foo
y desea que trate a la sucursal con el mismo nombre que la cadena ascendente. Haz que esto suceda con
$ git branch foo
$ git branch --set-upstream-to=origin/foo
o solo
$ git branch --set-upstream-to=origin/foo foo
Para 1.6.x, se puede hacer usando la herramienta git_remote_branch :
grb track foo upstream
Eso hará que Git haga foo
track upstream/foo
.
Para crear una nueva rama, podríamos usar el siguiente comando
git checkout --track -b example origin/example Para que la rama ya creada cree un enlace entre el control remoto y luego desde esa rama, use el comando siguiente
git branch -u origin/remote-branch-name
Puede hacer lo siguiente (suponiendo que se haya retirado en el maestro y desee enviar a un maestro de sucursal remoto):
Configura el ''remoto'' si aún no lo tienes
git remote add origin ssh://...
Ahora configura el master para saber para rastrear:
git config branch.master.remote origin
git config branch.master.merge refs/heads/master
Y empuje
git push origin master
Uso el siguiente comando (suponga que el nombre de su rama local es "nombre de la rama local" y el nombre de la rama remota es "nombre de la rama remota"):
$ git branch --set-upstream-to=origin/branch-name-remote branch-name-local
Si tanto las sucursales locales como las remotas tienen el mismo nombre, haga lo siguiente:
$ git branch --set-upstream-to=origin/branch-name branch-name
o simplemente por:
cambie a la rama si no está ya en ella:
[za]$ git checkout branch_name
correr
[za]$ git branch --set-upstream origin branch_name
Branch origin set up to track local branch brnach_name by rebasing.
y listo para
[za]$ git push origin branch_name
Puede alawys echar un vistazo al archivo de configuración para ver qué está siguiendo qué ejecutando:
[za]$ git config -e
También es bueno saber esto, muestra qué ramas se rastrean y cuáles no. :
[za]$ git remote show origin